ArServerClient.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 NLSERVERCLIENT_H
#define NLSERVERCLIENT_H

#include "ArNetPacket.h"
#include "ArNetPacketReceiverTcp.h"
#include "ArNetPacketSenderTcp.h"

class ArServerData;
class ArServerUserInfo;

#include "ArServerClientData.h"


class ArServerClient
{
public:
  enum ServerState {
    STATE_SENT_INTRO, 
    STATE_REJECTED, 
    STATE_CONNECTED, 
    STATE_DISCONNECTED 
  };


  AREXPORT ArServerClient(ArSocket *tcpSocket, unsigned int udpPort, 
                          long authKey, long introKey, 
                          ArRetFunctor2<bool, ArNetPacket *, 
                          struct sockaddr_in *> *sendUdpCallback,
                          std::map<unsigned int, ArServerData *> *dataMap,
                          const char *passwordKey, const char *serverKey,
                          const ArServerUserInfo *userInfo = NULL,
                          int rejecting = 0, 
                          const char *rejectingString = "");
  AREXPORT virtual ~ArServerClient();
  
  AREXPORT bool tcpCallback(void);
  
  AREXPORT void processPacket(ArNetPacket *packet, bool tcp = true);
  
  AREXPORT bool sendPacketTcp(ArNetPacket *packet);
  AREXPORT bool sendPacketUdp(ArNetPacket *packet);

  AREXPORT bool hasGroupAccess(const char *group);

  AREXPORT void broadcastPacketTcp(ArNetPacket *packet); 

  AREXPORT void broadcastPacketUdp(ArNetPacket *packet);

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

  AREXPORT const char *getIPString(void) const;

  AREXPORT void shutdown(void);

  AREXPORT void setUdpAddress(struct sockaddr_in *sin);

  AREXPORT struct sockaddr_in *getUdpAddress(void);
 
  AREXPORT long getAuthKey(void);

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

  AREXPORT ArSocket *getTcpSocket(void) { return &myTcpSocket; }
  AREXPORT void forceDisconnect(bool quiet);
  AREXPORT long getFrequency(ArTypes::UByte2 command);
protected:
  // Some members so that we don't have to pass the number around
  std::list<unsigned int> myCommandStack;
  AREXPORT bool setupPacket(ArNetPacket *packet);
  // Pushes a new number onto our little stack of numbers
  void pushCommand(unsigned int num);
  // Pops the command off the stack
  void popCommand(void);
  // Gets the command we're on
  unsigned int getCommand();

  // this sends a list packet to our client
  void sendListPacket(void);

  // this could just be dealth with by seeing if myUserInfo is NULL,
  // but that may be confusing
  const ArServerUserInfo *myUserInfo;
  std::set<std::string, ArStrCaseCmpOp> myGroups;  
  ArNetPacketSenderTcp myTcpSender;
  std::map<unsigned int, ArServerData *> *myDataMap;
  std::list<ArServerClientData *> myRequested;
  void internalSwitchState(ServerState state);
  ServerState myState;
  ArTime myStateStart;
  bool myUdpConfirmedFrom;
  bool myUdpConfirmedTo;
  ArSocket myTcpSocket;
  ArNetPacketReceiverTcp myTcpReceiver;
  ArFunctor2C<ArServerClient, ArNetPacket *, bool> myProcessPacketCB;
  ArRetFunctor2<bool, ArNetPacket *, struct sockaddr_in *> *mySendUdpCB;
  struct sockaddr_in mySin;
  long myAuthKey;
  long myIntroKey;
  bool myTcpOnly;
  std::string myPasswordKey;
  std::string myServerKey;

  int myRejecting;
  std::string myRejectingString;


  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, ArTypes::UByte2, bool tcp);
  std::map<ArTypes::UByte2, Tracker *> myTrackingSentMap;
  std::map<ArTypes::UByte2, Tracker *> myTrackingReceivedMap;
  
};

#endif

---