ArServerBase.h

Go to the documentation of this file.

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef NLSERVERBASE_H
#define NLSERVERBASE_H

#include "Aria.h"
#include "ArServerClient.h"
#include "ArServerData.h"
#include "ArNetPacket.h"
#include "ArNetPacketReceiverUdp.h"
#include "ArServerUserInfo.h"
class ArServerBase: public ArASyncTask
{
public:
  AREXPORT ArServerBase(bool addAriaExitCB = true, 
                        const char *serverName = "");
  AREXPORT virtual ~ArServerBase();
  
  AREXPORT bool open(unsigned int port, const char *openOnIP = NULL);
  AREXPORT void close(void);
  AREXPORT void loopOnce(void);

  AREXPORT bool addData(const char *name, const char *description,
                        ArFunctor2<ArServerClient *, ArNetPacket *> *functor,
                        const char *argumentDescription,
                        const char *returnDescription,
                        const char *commandGroup = NULL,
                        const char *dataFlags = NULL);

  AREXPORT bool loadUserInfo(const char *fileName, 
                             const char *baseDirectory = "");
  
  AREXPORT void logUserInfo(void);

  AREXPORT void logCommandGroups(void);  

  AREXPORT void logCommandGroupsToFile(const char *fileName);  

  AREXPORT void setGroupDescription(const char *GrpName, const char *GrpDesc);  

  AREXPORT void logGroupDescriptions(void);  

  AREXPORT void logGroupDescriptionsToFile(const char *fileName);  

  AREXPORT void setServerKey(const char *serverKey);

  AREXPORT void rejectSinceUsingCentralServer(
          const char *centralServerIPString);

  AREXPORT virtual void run(void);
  
  AREXPORT virtual void runAsync(void);

  AREXPORT int getNumClients(void);

  AREXPORT unsigned int findCommandFromName(const char *command);

  AREXPORT bool broadcastPacketTcp(ArNetPacket *packet, const char *name);

  AREXPORT bool broadcastPacketTcpWithExclusion(
          ArNetPacket *packet, const char *name, 
          ArServerClient *excludeClient);

  AREXPORT bool broadcastPacketUdp(ArNetPacket *packet, const char *name);

  AREXPORT bool broadcastPacketUdpWithExclusion(
        ArNetPacket *packet, const char *name, ArServerClient *excludeClient);

  AREXPORT void processPacket(ArNetPacket *packet, 
                              struct sockaddr_in *sin);

  AREXPORT bool sendUdp(ArNetPacket *packet, 
                        struct sockaddr_in *sin);
  
  AREXPORT void logTracking(bool terse = true);

  AREXPORT void resetTracking(void);

  // the function for the thread
  AREXPORT virtual void * runThread(void *arg);

  AREXPORT unsigned int getTcpPort(void);
  AREXPORT unsigned int getUdpPort(void);

  AREXPORT void addCycleCallback(ArFunctor* functor);

  AREXPORT void remCycleCallback(ArFunctor* functor);

  AREXPORT void addClientRemovedCallback(ArFunctor1<ArServerClient *> *functor);
  AREXPORT void remClientRemovedCallback(ArFunctor1<ArServerClient *> *functor);
  AREXPORT void makeNewServerClientFromSocket(ArSocket *socket, 
                                              bool doNotReject);
  AREXPORT const ArServerUserInfo *getUserInfo(void) const;
  AREXPORT void setUserInfo(const ArServerUserInfo *userInfo);
  AREXPORT bool addDataAdvanced(
          const char *name, const char *description,
          ArFunctor2<ArServerClient *, ArNetPacket *> *functor,
          const char *argumentDescription, const char *returnDescription,
          const char *commandGroup = NULL, const char *dataFlags = NULL, 
          unsigned int commandNumber = 0,
          ArFunctor2<long, unsigned int> *requestChangedFunctor = NULL, 
          ArFunctor2<ArServerClient *, ArNetPacket *> 
          *requestOnceFunctor = NULL);
  AREXPORT void setAdditionalDataFlags(const char *additionalDataFlags);
  AREXPORT long getFrequency(unsigned int command, 
                             bool internalCall = false);
  AREXPORT bool broadcastPacketTcpByCommand(
          ArNetPacket *packet, unsigned int command);

  AREXPORT bool broadcastPacketTcpByCommandWithExclusion(
          ArNetPacket *packet, unsigned int command,
          ArServerClient *excludeClient);

  AREXPORT bool broadcastPacketUdpByCommand(
          ArNetPacket *packet, unsigned int command);

  AREXPORT bool broadcastPacketUdpByCommandWithExclusion(
          ArNetPacket *packet, unsigned int command,
          ArServerClient *excludeClient);

  AREXPORT bool dataHasFlag(const char *name, const char *dataFlag);
  AREXPORT bool dataHasFlagByCommand(unsigned int command, 
                                     const char *dataFlag);
  
protected:
  std::string myServerName;
  ArMutex myDataMutex;
  ArMutex myClientsMutex;
  ArMutex myCycleCallbacksMutex;
  void acceptTcpSockets(void);
  AREXPORT void finishAcceptingSocket(ArSocket *socket, 
                                      bool skipPassword = false, 
                                      bool doNotReject = false);

  unsigned int myTcpPort;
  unsigned int myUdpPort;
  // our mapping of the ints to the serverData
  std::map<unsigned int, ArServerData *> myDataMap;
  std::map<std::string, std::string> myGroupDescription;                        

  int myRejecting;
  std::string myRejectingString;
  // the number we're on for the current data
  unsigned int myNextDataNumber;
  std::string myAdditionalDataFlags;
  bool myOpened;
  std::list<ArServerClient *> myClients;
  ArNetPacketReceiverUdp myUdpReceiver;
  ArFunctor2C<ArServerBase, ArNetPacket *, struct sockaddr_in *> myProcessPacketCB;
  ArRetFunctor2C<bool, ArServerBase, ArNetPacket *, struct sockaddr_in *> mySendUdpCB;  
  ArSocket myTcpSocket;
  ArSocket myUdpSocket;
  std::list<ArFunctor*> myCycleCallbacks;
  std::list<ArFunctor1<ArServerClient *> *> myClientRemovedCallbacks;

  const ArServerUserInfo *myUserInfo;
  std::string myServerKey;
  ArFunctorC<ArServerBase> myAriaExitCB;
  ArRetFunctor2C<long, ArServerBase, unsigned int, bool> myGetFrequencyCB;
};

#endif

---