ArClientBase.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 NLCLIENTBASE_H
#define NLCLIENTBASE_H

#include "Aria.h"
#include "ArNetPacket.h"
#include "ArNetPacketSenderTcp.h"
#include "ArNetPacketReceiverTcp.h"
#include "ArNetPacketReceiverUdp.h"
#include "ArClientData.h"

class ArClientBase : public ArASyncTask
{
public:
  
  enum ClientState {
    STATE_NO_CONNECTION, 
    STATE_FAILED_CONNECTION, 
    STATE_OPENED_SOCKET, 
    STATE_EXCHANGED_INTROS, 
    STATE_REJECTED, 
    STATE_WAITING_LIST, 
    STATE_CONNECTED, 
    STATE_LOST_CONNECTION 
  };
  
  enum {
    CLIENT_KEY_LENGTH = 16
  };

  AREXPORT ArClientBase();
  AREXPORT virtual ~ArClientBase();
  
  AREXPORT virtual void setRobotName(const char *name);

  AREXPORT virtual const char *getRobotName() const;


  AREXPORT bool blockingConnect(const char *host, int port, bool print = true,
                                const char *user = NULL, 
                                const char *password = NULL);


  AREXPORT bool disconnect(void);


  AREXPORT bool startNonBlockingDisconnect();


  AREXPORT void finishNonBlockingDisconnect();


  AREXPORT bool isConnected(void) { return myState == STATE_CONNECTED;}
  
  AREXPORT bool wasRejected(void) { return myState == STATE_REJECTED; }

  AREXPORT bool addHandler(const char *name, 
                            ArFunctor1 <ArNetPacket *> *functor);

  AREXPORT bool remHandler(const char *name, ArFunctor1<ArNetPacket *> *functor);

  AREXPORT bool request(const char *name, long mSec, 
                                ArNetPacket *packet = NULL);

  AREXPORT bool requestStop(const char *name);
  
  AREXPORT bool requestOnce(const char *name, 
                                              ArNetPacket *packet = NULL,
                            bool quiet = false);

  AREXPORT bool requestOnceUdp(const char *name, 
                            ArNetPacket *packet = NULL);

  AREXPORT bool requestOnceWithString(const char *name, const char *str);
  
  AREXPORT bool dataExists(const char *name);

  AREXPORT const char *getHost(void);

  
  AREXPORT void setServerKey(const char *serverKey, bool print = true);
  
  AREXPORT ArTime getLastPacketReceived(void);

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

  AREXPORT void logDataList(void);

  AREXPORT void addCycleCallback(ArFunctor *functor);
  
  AREXPORT void remCycleCallback(ArFunctor *functor);

  AREXPORT bool sendPacketTcp(ArNetPacket *packet);
  AREXPORT bool sendPacketUdp(ArNetPacket *packet);

  AREXPORT void setConnectTimeoutTime(int sec);

  AREXPORT int getConnectTimeoutTime(void);

  AREXPORT void logTracking(bool terse);
  
  AREXPORT void resetTracking(void);

  AREXPORT void addServerShutdownCB(ArFunctor *functor,
                               ArListPos::Pos position = ArListPos::LAST);

  AREXPORT void remServerShutdownCB(ArFunctor *functor);

  AREXPORT void addDisconnectOnErrorCB(ArFunctor *functor,
                               ArListPos::Pos position = ArListPos::LAST);

  AREXPORT void remDisconnectOnErrorCB(ArFunctor *functor);

  AREXPORT void loopOnce(void);

  AREXPORT void processPacket(ArNetPacket *packet, bool tcp);

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

  AREXPORT void setTcpOnlyFromServer(void);
  AREXPORT void setTcpOnlyToServer(void);

  AREXPORT bool isTcpOnlyFromServer(void);
  AREXPORT bool isTcpOnlyToServer(void);
  AREXPORT void getClientKey(unsigned char key[CLIENT_KEY_LENGTH]);
  
  AREXPORT const char *getName(ArNetPacket *packet, bool internalCall = false);
  AREXPORT const char *getName(unsigned int command, bool internalCall = false);
  // the function for the thread
  AREXPORT virtual void * runThread(void *arg);
  AREXPORT struct in_addr *getTcpAddr(void) { return myTcpSocket.inAddr(); }
  AREXPORT bool internalBlockingConnect(
          const char *host, int port, bool print, const char *user, 
          const char *password, ArSocket *tcpSocket);
  AREXPORT ArSocket *getTcpSocket(void) { return &myTcpSocket; }
  AREXPORT ArSocket *getUdpSocket(void) { return &myUdpSocket; }
  AREXPORT const std::map<unsigned int, ArClientData *> *getDataMap(void)
    { return &myIntDataMap; }
  AREXPORT unsigned int findCommandFromName(const char *name);
  AREXPORT bool requestByCommand(unsigned int command, long mSec, 
                                 ArNetPacket *packet = NULL);
  AREXPORT bool requestStopByCommand(unsigned int command);
  
  AREXPORT bool requestOnceByCommand(unsigned int command,
                            ArNetPacket *packet = NULL);
  AREXPORT bool requestOnceByCommandUdp(unsigned int command,
                            ArNetPacket *packet = NULL);
  bool getReceivedDataList(void) { return myReceivedDataList; }
  bool getReceivedArgRetList(void) { return myReceivedArgRetList; }
  bool getReceivedGroupAndFlagsList(void) { return myReceivedGroupAndFlagsList; }
  int getRejected(void) { return myRejected; }
  const char *getRejectedString(void) { return myRejectedString; }
protected:
 
  std::string myRobotName;
  std::string myLogPrefix;
  
  AREXPORT bool setupPacket(ArNetPacket *packet);
  ArTime myLastPacketReceived;
  std::list<ArFunctor *> myServerShutdownCBList;
  std::list<ArFunctor *> myDisconnectOnErrorCBList;
  std::list<ArFunctor *> myCycleCallbacks;
  void clear(void);
  // does the first part of connection
  bool internalConnect(const char *host, int port, bool obsolete);
  void internalStartUdp(void);
  void buildList(ArNetPacket *packet);
  void internalSwitchState(ClientState state);
  bool myReceivedDataList;
  bool myReceivedArgRetList;
  bool myReceivedGroupAndFlagsList;
  ClientState myState;
  ArTime myStateStarted;
  bool myUdpConfirmedFrom;
  bool myUdpConfirmedTo;
  // if we only send tcp
  bool myTcpOnlyTo;
  // if we only receive tcp from the server
  bool myTcpOnlyFrom;

  bool myQuiet;
  std::string myHost;
  std::string myUser;
  std::string myPassword;
  // the time we allow for connections
  int myTimeoutTime;
  // the time we started our connection
  ArTime myStartedConnection;
  
  ArMutex myDataMutex;
  ArMutex myClientMutex;
  ArMutex myMapsMutex;
  ArMutex myStateMutex;
  ArMutex myCallbackMutex;
  ArMutex myCycleCallbackMutex;
  ArMutex myPacketTrackingMutex;
  // our map of names to ints
  std::map<std::string, unsigned int> myNameIntMap;
  // our map of ints to functors
  std::map<unsigned int, ArClientData *> myIntDataMap;
  
  struct sockaddr_in myUdpSin;
  bool myUdpSinValid;
  // the port the server said it was using
  unsigned int myServerReportedUdpPort;
  // the port the server actually is using
  unsigned int myServerSentUdpPort;
  unsigned int myUdpPort;
  long myAuthKey;
  long myIntroKey;
  std::string myServerKey;
  // this is a key we have for identifying ourselves moderately uniquely
  unsigned char myClientKey[16];
  ArNetPacketSenderTcp myTcpSender;
  ArNetPacketReceiverTcp myTcpReceiver;
  ArNetPacketReceiverUdp myUdpReceiver;
  ArSocket myTcpSocket;
  ArSocket myUdpSocket;
  ArFunctor2C<ArClientBase, ArNetPacket *, bool> myProcessPacketCB;
  ArFunctor2C<ArClientBase, ArNetPacket *, struct sockaddr_in *> myProcessPacketUdpCB;

  int myRejected;
  char myRejectedString[32000];

  ArTime myTrackingStarted;
  class Tracker
  {
  public:
    Tracker() { reset(); }
    virtual ~Tracker() {}
    void reset(void) 
      { myPacketsTcp = 0; myBytesTcp = 0; myPacketsUdp = 0; myBytesUdp = 0; }
    long myPacketsTcp;
    long myBytesTcp;
    long myPacketsUdp;
    long myBytesUdp;
  };
  AREXPORT void trackPacketSent(ArNetPacket *packet, bool tcp);
  AREXPORT void trackPacketReceived(ArNetPacket *packet, bool tcp);
  std::map<unsigned int, Tracker *> myTrackingSentMap;
  std::map<unsigned int, Tracker *> myTrackingReceivedMap;

};

#endif // NLCLIENTBASE_H

---