ArServerClient.cpp

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
*/

#include "Aria.h"
#include "ArExport.h"
#include "ArServerClient.h"
#include "ArServerCommands.h"
#include "ArClientCommands.h"
#include "ArServerData.h"
#include "ArServerUserInfo.h"

AREXPORT ArServerClient::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, int rejecting, 
        const char *rejectingString) :
  myProcessPacketCB(this, &ArServerClient::processPacket, NULL, true)
{
  ArNetPacket packet;

  // set our default to no command
  pushCommand(0);

  myAuthKey = authKey;
  myIntroKey = introKey;
  myTcpSocket.transfer(tcpSocket);
  myTcpSocket.setCloseCallback(tcpSocket->getCloseCallback());
  myTcpSocket.setNonBlock();
  myTcpReceiver.setSocket(&myTcpSocket);
  myTcpReceiver.setProcessPacketCB(&myProcessPacketCB);
  myTcpSender.setSocket(&myTcpSocket);
  mySendUdpCB = sendUdpCallback;
  myDataMap = dataMap;
  myTcpOnly = false;
  myUserInfo = userInfo;
  myPasswordKey = passwordKey;
  myServerKey = serverKey;
  myRejecting = rejecting;
  if (rejectingString != NULL)
    myRejectingString = rejectingString;

  packet.empty();
  packet.setCommand(ArServerCommands::INTRODUCTION);
  packet.strToBuf("alpha");
  packet.uByte2ToBuf(udpPort);
  packet.uByte4ToBuf(myAuthKey);
  packet.uByte4ToBuf(myIntroKey);
  packet.strToBuf(myPasswordKey.c_str());
  sendPacketTcp(&packet);

  resetTracking();
  
  internalSwitchState(STATE_SENT_INTRO);
}

AREXPORT ArServerClient::~ArServerClient()
{
  myTcpReceiver.setSocket(NULL);
  myTcpReceiver.setProcessPacketCB(NULL);
  myTcpSocket.close();
  
  // new way to get the request change functor called
  std::list<ArServerClientData *>::iterator it;
  ArServerClientData *data;
  ArServerData *serverData;
  while ((it = myRequested.begin()) != myRequested.end())
  {
    data = (*it);
    serverData = (*it)->getServerData();
    myRequested.pop_front();
    delete data;
    serverData->callRequestChangedFunctor();
  }
  /* old way
  ArUtil::deleteSet(myRequested.begin(), myRequested.end());
  myRequested.clear();
  */
  ArUtil::deleteSetPairs(myTrackingSentMap.begin(), 
                         myTrackingSentMap.end());
  myTrackingSentMap.clear();

  ArUtil::deleteSetPairs(myTrackingReceivedMap.begin(), 
                         myTrackingReceivedMap.end());
  myTrackingReceivedMap.clear();
}

void ArServerClient::internalSwitchState(ServerState state)
{
  myState = state;
  myStateStart.setToNow();
}

AREXPORT bool ArServerClient::tcpCallback(void)
{
  if (myState == STATE_REJECTED)
  {
    myTcpSender.sendData();
    ArUtil::sleep(10);
    return false;
  }

  if (myState == STATE_DISCONNECTED)
    return false;

  if (!myTcpReceiver.readData())
  {
    ArLog::log(ArLog::Verbose, "Trouble receiving tcp data from %s",
               myTcpSocket.getIPString());
    return false;
  }
  if (!myTcpSender.sendData())
  {
    ArLog::log(ArLog::Verbose, "Trouble sending tcp data to %s", myTcpSocket.getIPString());
    return false;
  }
  return true;
}

AREXPORT void ArServerClient::handleRequests(void)
{
  std::list<ArServerClientData *>::iterator it;
  ArServerClientData *data;  
  ArServerData *serverData;
  ArTime lastSent;
  
  // walk through our list
  for (it = myRequested.begin(); it != myRequested.end(); ++it)
  {
    data = (*it);
    lastSent = data->getLastSent();
    // see if this needs to be called
    if (data->getMSec() != -1 && 
        (data->getMSec() == 0 || lastSent.mSecSince() > data->getMSec()))
    {
      serverData = data->getServerData();
      // call it, then set it so we know we did
      pushCommand(serverData->getCommand());
      if (serverData->getFunctor() != NULL)
        serverData->getFunctor()->invoke(this, data->getPacket());
      popCommand();
      data->setLastSentToNow();
    }
  }
}


void ArServerClient::sendListPacket(void)
{
  ArNetPacket packet;
  std::map<unsigned int, ArServerData *>::iterator it;
  unsigned int count;
  unsigned int shortLen;
  unsigned int longLen;
  ArServerData *serverData;

  // First we send a list of numbers, names and descriptions
  packet.setCommand(ArServerCommands::LIST);
  
  // number of entries (we'll overwrite it later with the right number)
  shortLen = packet.getLength();
  packet.uByte2ToBuf(0);
  // loop through the data to build the packet
  for (it = myDataMap->begin(), count = 0; it != myDataMap->end(); it++)
  {
    serverData = (*it).second;
    if (myUserInfo == NULL || 
        serverData->getCommandGroup() == NULL || 
        serverData->getCommandGroup()[0] == '\0' || 
        myGroups.count(serverData->getCommandGroup()) != 0 || 
        myGroups.count("all") != 0)
    {
      count++;
      packet.uByte2ToBuf(serverData->getCommand());
      packet.strToBuf(serverData->getName());
      packet.strToBuf(serverData->getDescription());
    }
  }
  // put the real number of entries in the right spot 
  longLen = packet.getLength();
  packet.setLength(shortLen);
  packet.uByte2ToBuf(count);
  packet.setLength(longLen);

  sendPacketTcp(&packet);

  // then we send a list of the arguments and returns... they aren't
  // combined so that the packet structure doesn't need to change
  packet.empty();
  packet.setCommand(ArServerCommands::LISTARGRET);
  
  // number of entries (we'll overwrite it later with the right number)
  shortLen = packet.getLength();
  packet.uByte2ToBuf(0);
  
  // loop through the data to build the packet
  for (it = myDataMap->begin(), count = 0; it != myDataMap->end(); it++)
  {
    serverData = (*it).second;
    if (myUserInfo == NULL || 
        serverData->getCommandGroup() == NULL || 
        serverData->getCommandGroup()[0] == '\0' || 
        myGroups.count(serverData->getCommandGroup()) != 0 || 
        myGroups.count("all") != 0)
    {
      count++;
      packet.uByte2ToBuf(serverData->getCommand());
      packet.strToBuf(serverData->getArgumentDescription());
      packet.strToBuf(serverData->getReturnDescription());
    }

  }
  // put the real number of entries in the right spot
  longLen = packet.getLength();
  packet.setLength(shortLen);
  packet.uByte2ToBuf(count);
  packet.setLength(longLen);
  sendPacketTcp(&packet);


  // then we send a list of command groups... they aren't
  // combined so that the packet structure doesn't need to change
  packet.empty();
  packet.setCommand(ArServerCommands::LISTGROUPANDFLAGS);
  
  // number of entries (we'll overwrite it later with the right number)
  shortLen = packet.getLength();
  packet.uByte2ToBuf(0);
  
  // loop through the data to build the packet
  for (it = myDataMap->begin(), count = 0; it != myDataMap->end(); it++)
  {
    serverData = (*it).second;
    if (myUserInfo == NULL || 
        serverData->getCommandGroup() == NULL || 
        serverData->getCommandGroup()[0] == '\0' || 
        myGroups.count(serverData->getCommandGroup()) != 0 || 
        myGroups.count("all") != 0)
    {
      count++;
      packet.uByte2ToBuf(serverData->getCommand());
      packet.strToBuf(serverData->getCommandGroup());
      packet.strToBuf(serverData->getDataFlagsString());
    }

  }
  // put the real number of entries in the right spot
  longLen = packet.getLength();
  packet.setLength(shortLen);
  packet.uByte2ToBuf(count);
  packet.setLength(longLen);
  sendPacketTcp(&packet);
}

AREXPORT void ArServerClient::processPacket(ArNetPacket *packet, bool tcp)
{
  std::string str;
  struct sockaddr_in sin;
  unsigned int clientUdpPort;
  ArNetPacket retPacket;

  //printf("Command number %d\n", packet->getCommand());
  // if we're in intro mode and received back the intro
  if (myState == STATE_SENT_INTRO && 
      packet->getCommand() == ArClientCommands::INTRODUCTION)
  {
    char user[512];
    unsigned char password[16];
    clientUdpPort = packet->bufToUByte2();
    packet->bufToStr(user, sizeof(user));
    packet->bufToData((char *)password, 16);

    if (myRejecting != 0)
    {
      retPacket.empty();
      retPacket.setCommand(ArServerCommands::REJECTED);
      retPacket.byte2ToBuf(myRejecting);
      retPacket.strToBuf(myRejectingString.c_str());
      sendPacketTcp(&retPacket);
      if (myRejecting == 2)
        ArLog::log(ArLog::Normal, 
   "Rejected connection from %s since we're using a central server at %s",
                   myTcpSocket.getIPString(), myRejectingString.c_str());
      internalSwitchState(STATE_REJECTED);
      return;
    }

    // if user info is NULL we're not checking passwords
    if (myUserInfo != NULL && 
        !myUserInfo->matchUserPassword(user, password, myPasswordKey.c_str(),
                                       myServerKey.c_str()))
    {
      retPacket.empty();
      retPacket.setCommand(ArServerCommands::REJECTED);
      retPacket.byte2ToBuf(1);
      retPacket.strToBuf("");
      sendPacketTcp(&retPacket);
      ArLog::log(ArLog::Normal, "Rejected user '%s' or password from %s",
                 user, myTcpSocket.getIPString());
      internalSwitchState(STATE_REJECTED);
      return;
    }
    if (myUserInfo != NULL)
      myGroups = myUserInfo->getUsersGroups(user);
    else
      myGroups.clear();
    sin.sin_family = AF_INET;
    sin.sin_addr = *myTcpSocket.inAddr();
    sin.sin_port = ArSocket::hostToNetOrder(clientUdpPort);
    if (myUserInfo != NULL)
      ArLog::log(ArLog::Normal, 
                 "Client connected from %s with user %s", 
                 myTcpSocket.getIPString(), user);
    else
      ArLog::log(ArLog::Normal, 
                 "Client connected from %s", myTcpSocket.getIPString());

    setUdpAddress(&sin);
    // send that we've connected
    retPacket.empty();
    retPacket.setCommand(ArServerCommands::CONNECTED);
    sendPacketTcp(&retPacket);
    // note that we're connected
    internalSwitchState(STATE_CONNECTED);

    // send them the list
    sendListPacket();
    // send the udp introduction
    retPacket.empty();
    retPacket.setCommand(ArServerCommands::UDP_INTRODUCTION);
    retPacket.byte4ToBuf(myIntroKey);
    sendPacketUdp(&retPacket);
  }
  // if we aren't in intro mode and got an intro somethings wrong
  else if (packet->getCommand() == ArClientCommands::INTRODUCTION)
  {
    ArLog::log(ArLog::Terse, 
               "ArServerClient: Received introduction when not in intro mode");
    return;
  }
  // if we got this over tcp then they only want tcp
  else if (packet->getCommand() == ArClientCommands::UDP_INTRODUCTION)
  {
    if (!myTcpOnly)
    {
      ArLog::log(ArLog::Normal, "ArServerClient: Got UDP introduction over tcp, assuming client only wants tcp data.");
      myTcpOnly = true;
    }
    return;
  }
  // if we're connected and got a udp confirmation
  else if ((myState == STATE_CONNECTED || 
            myState == STATE_SENT_INTRO) && 
           packet->getCommand() == ArClientCommands::UDP_CONFIRMATION)
  {
    myUdpConfirmedTo = true;
    ArLog::log(ArLog::Verbose, "Server's udp connection to client confirmed.");
    return;
  }
  // if we're not connected (or close) and got a confirmation
  else if (packet->getCommand() == ArClientCommands::UDP_CONFIRMATION)
  {
    ArLog::log(ArLog::Normal, "ArServerClient: Received udp confirmation when not connected.");
    return;
  }
  else if (packet->getCommand() == ArClientCommands::TCP_ONLY)
  {
    ArLog::log(ArLog::Verbose, "ArServerClient: Client only wants tcp data.");
    myTcpOnly = true;
    return;
  }
  else if (packet->getCommand() == ArClientCommands::SHUTDOWN)
  {
    ArLog::log(ArLog::Normal, "Client from %s has disconnected.",
               myTcpSocket.getIPString());
    internalSwitchState(STATE_DISCONNECTED);
    return;
  }
  // if we're connected its a request, then set all that up
  else if (myState == STATE_CONNECTED && 
           packet->getCommand() == ArClientCommands::REQUEST)
  {
    std::list<ArServerClientData *>::iterator it;
    ArServerClientData *data;
    ArServerData *serverData;
    unsigned int command;
    long mSec;
    // see which one they requested
    command = packet->bufToUByte2();
    mSec = packet->bufToByte4();

    // first we see if we already have this one
    for (it = myRequested.begin(); it != myRequested.end(); ++it)
    {
      data = (*it);
      serverData = data->getServerData();
      if (serverData->getCommand() == command)
      {
        trackPacketReceived(packet, command, true);
        data->setMSec(mSec);
        data->setPacket(packet);
        data->getPacket()->setCommand(command);
        serverData->callRequestChangedFunctor();
        ArLog::log(ArLog::Verbose, "ArServerClient: revised request for command %d to %d mSec with new argument", serverData->getCommand(), mSec);
        return;
      }
    }
    // we didn't have it, so make a new one
    std::map<unsigned int, ArServerData *>::iterator sdit;
    if ((sdit = myDataMap->find(command)) == myDataMap->end())
    {
      ArLog::log(ArLog::Terse, 
              "ArServerClient got request for command %d which doesn't exist", 
                 command);
      return;
    }
    serverData = (*sdit).second;
    if (serverData == NULL) 
    {
      ArLog::log(ArLog::Terse, "ArServerClient::processPackets request handler has NULL serverData\n");
    }
    if (myUserInfo != NULL && 
        serverData->getCommandGroup() != NULL &&
        serverData->getCommandGroup()[0] != '\0' &&
        myGroups.count(serverData->getCommandGroup()) == 0 &&
        myGroups.count("all") == 0)
    {
      ArLog::log(ArLog::Normal, 
                 "ArServerClient: %s tried to request command '%s' but it doesn't have access to that command", 
                 myTcpSocket.getIPString(), 
                 serverData->getName());
      return;
    }
    trackPacketReceived(packet, command, true);
    data = new ArServerClientData(serverData, mSec, packet);
    data->getPacket()->setCommand(command);
    ArLog::log(ArLog::Verbose, "ArServerClient: added request for command %s every %d mSec", serverData->getName(), mSec);
    if (mSec == 0)
      ArLog::log(ArLog::Normal, "ArServerClient: client from %s requested command %s every at 0 msec", myTcpSocket.getIPString(), serverData->getName());
    myRequested.push_front(data);
    serverData->callRequestChangedFunctor();
    pushCommand(command);
    if (serverData->getFunctor() != NULL)
      serverData->getFunctor()->invoke(this, data->getPacket());
    popCommand();
    return;
  }
  // if we got a request when we're not connected
  else if (packet->getCommand() == ArClientCommands::REQUEST)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerClient got a request while not connected.\n");
    return;
  }
  // if we're connected its a requestStop, then set all that up
  else if (myState == STATE_CONNECTED && 
           packet->getCommand() == ArClientCommands::REQUESTSTOP)
  {
    std::list<ArServerClientData *>::iterator it;
    ArServerClientData *data;
    ArServerData *serverData;
    unsigned int command;
    // see which one they requested
    command = packet->bufToUByte2();

    // first we see if we have this one
    for (it = myRequested.begin(); it != myRequested.end(); ++it)
    {
      data = (*it);
      serverData = data->getServerData();
      // we have a match, so set the new params then return
      if (data->getServerData()->getCommand() == command)
      {
        trackPacketReceived(packet, command, true);
        myRequested.erase(it);
        ArLog::log(ArLog::Verbose, "ArServerClient: stopped request for command %d", serverData->getCommand());
        delete data;
        serverData->callRequestChangedFunctor();
        return;
      }
    }
    // if we don't have it... that means that it wasn't here
    
    // find out what to call it
    std::map<unsigned int, ArServerData *>::iterator sdit;
    if ((sdit = myDataMap->find(command)) == myDataMap->end())
    {
      ArLog::log(ArLog::Terse, 
              "ArServerClient got a requeststop for command %d which doesn't exist", 
                 command);
      return;
    }
    trackPacketReceived(packet, command, true);
    serverData = (*sdit).second;
    if (serverData == NULL) 
      ArLog::log(ArLog::Terse, "ArServerClient::processPackets requeststop handler has NULL serverData on back command %d", command);
    else
      ArLog::log(ArLog::Normal, "ArServerClient: got a stop request for command %s that isn't requested", serverData->getName());
    return;
  }
  // if we got a requestStop when we're not connected
  else if (packet->getCommand() == ArClientCommands::REQUESTSTOP)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerClient got a requeststop while not connected.\n");
    return;
  }
  // if we're connected and its a command to execute just once
  else if (myState == STATE_CONNECTED)
  {
    unsigned int command;
    std::map<unsigned int, ArServerData *>::iterator it;
    ArServerData *serverData;

    command = packet->getCommand();
    if ((it = myDataMap->find(command)) == myDataMap->end())
    {
      ArLog::log(ArLog::Terse, 
              "ArServerClient got request for command %d which doesn't exist", 
                 command);
      return;
    }
    serverData = (*it).second;
    if (myUserInfo != NULL && 
        serverData->getCommandGroup() != NULL &&
        serverData->getCommandGroup()[0] != '\0' &&
        myGroups.count(serverData->getCommandGroup()) == 0 &&
        myGroups.count("all") == 0)
    {
      ArLog::log(ArLog::Normal, 
                 "ArServerClient: %s tried to request command '%s' once but it doesn't have access to that command", 
                 myTcpSocket.getIPString(), 
                 serverData->getName());
      return;
    }
    trackPacketReceived(packet, command, true);
    ArLog::log(ArLog::Verbose, "ArServerClient got command %s", (*it).second->getName());
    pushCommand(command);
    if (serverData->getFunctor() != NULL)
      serverData->getFunctor()->invoke(this, packet);
    if (serverData->getRequestOnceFunctor() != NULL)
      serverData->getRequestOnceFunctor()->invoke(this, packet);
    popCommand();
    return;
  }
  else
  {
    ArLog::log(ArLog::Terse, 
               "ArServerClient: rogue packet command %u in state %d", 
               packet->getCommand(), myState);
  }
}

AREXPORT void ArServerClient::forceDisconnect(bool quiet)
{
  if (!quiet)
    ArLog::log(ArLog::Normal, "Client from %s has been forcibly disconnected.",
               myTcpSocket.getIPString());
  internalSwitchState(STATE_DISCONNECTED);
}

AREXPORT void ArServerClient::processAuthPacket(ArNetPacket *packet, 
                                       struct sockaddr_in *sin)
{
  ArNetPacket retPacket;
  long authKey;
  // check the auth key again, just in case

  authKey = packet->bufToUByte4();
  if (authKey != myAuthKey)
  {
    ArLog::log(ArLog::Terse, "ArServerClient: authKey given does not match actual authKey, horrible error.");
    return;
  }
  
  if (mySin.sin_port != sin->sin_port)
  {
    ArLog::log(ArLog::Verbose, 
               "Client says it is using port %u but is using port %u\n", 
               ArSocket::netToHostOrder(mySin.sin_port),
               ArSocket::netToHostOrder(sin->sin_port));
  }
  myUdpConfirmedFrom = true;
  mySin.sin_port = sin->sin_port;
  ArLog::log(ArLog::Verbose, "Client connected to server on udp port %u", 
             ArSocket::netToHostOrder(mySin.sin_port));
  // TODO put some state info here to note that its fully udp connected
  retPacket.empty();
  retPacket.setCommand(ArServerCommands::UDP_INTRODUCTION);
  retPacket.byte4ToBuf(myIntroKey);
  sendPacketUdp(&retPacket);
  retPacket.empty();
  retPacket.setCommand(ArServerCommands::UDP_CONFIRMATION);
  sendPacketTcp(&retPacket);
}

AREXPORT void ArServerClient::broadcastPacketTcp(ArNetPacket *packet)
{
  std::list<ArServerClientData *>::iterator it;
  ArServerClientData *data;  
  ArServerData *serverData;
  ArTime lastSent;

  // walk through our list
  for (it = myRequested.begin(); it != myRequested.end(); ++it)
  {
    data = (*it);
    serverData = data->getServerData();
    // see if this is our data, if it is send the packet
    if (serverData->getCommand() == packet->getCommand())
    {
      sendPacketTcp(packet);
      return;
    }
  }
  // we didn't have the data to send
}

AREXPORT void ArServerClient::broadcastPacketUdp(ArNetPacket *packet)
{
  std::list<ArServerClientData *>::iterator it;
  ArServerClientData *data;  
  ArServerData *serverData;
  ArTime lastSent;
  
  // walk through our list
  for (it = myRequested.begin(); it != myRequested.end(); ++it)
  {
    data = (*it);
    serverData = data->getServerData();
    // see if this is our data, if it is send the packet
    if (serverData->getCommand() == packet->getCommand())
    {
      sendPacketUdp(packet);
      return;
    }
  }
  // we didn't have the data to send
}

AREXPORT bool ArServerClient::sendPacketTcp(ArNetPacket *packet)
{
  if (!setupPacket(packet))
    return false;
  else
  {
    trackPacketSent(packet, true);
    myTcpSender.sendPacket(packet);
    return true;
  }
}

AREXPORT bool ArServerClient::sendPacketUdp(ArNetPacket *packet)
{
  if (myTcpOnly)
    return sendPacketTcp(packet);
  
  if (!setupPacket(packet))
    return false;
  else if (mySendUdpCB != NULL)
  {
    trackPacketSent(packet, false);
    return mySendUdpCB->invokeR(packet, &mySin);
  }
  else
    return false;
}

AREXPORT  bool ArServerClient::setupPacket(ArNetPacket *packet)
{
  if (myState == STATE_DISCONNECTED)
    return false;

  if (packet->getCommand() == 0)
  {
   if (getCommand() != 0)
     packet->setCommand(getCommand());
   else
     ArLog::log(ArLog::Terse, "ArServerClient::sendPacket: packet to send has no command and we have no command in the stack");
  }
  packet->finalizePacket();
  return true;
} 


AREXPORT void ArServerClient::setUdpAddress(struct sockaddr_in *sin)
{
  mySin = *sin;
}

AREXPORT struct sockaddr_in *ArServerClient::getUdpAddress(void)
{
  return &mySin;
}

AREXPORT long ArServerClient::getAuthKey(void)
{
  return myAuthKey;
}

unsigned int ArServerClient::getCommand(void)
{
  return myCommandStack.front();
}

void ArServerClient::pushCommand(unsigned int command)
{
  myCommandStack.push_front(command);
}

void ArServerClient::popCommand(void)
{
  if (myCommandStack.size() == 0)
  {
    ArLog::log(ArLog::Terse, 
      "ArServerClient::popCommand: popCommand tried to be called when stack empty.");
  }
  myCommandStack.pop_front();
}

AREXPORT void ArServerClient::shutdown(void)
{
  ArNetPacket packet;
  
  packet.setCommand(ArServerCommands::SHUTDOWN);
  sendPacketTcp(&packet);
  myTcpSender.sendData();
}

AREXPORT const char *ArServerClient::getIPString(void) const
{
  return myTcpSocket.getIPString();
}

void ArServerClient::trackPacketSent(ArNetPacket *packet, bool tcp)
{
  if (myTrackingSentMap.find(packet->getCommand()) == myTrackingSentMap.end())
    myTrackingSentMap[packet->getCommand()] = new Tracker;

  if (tcp)
  {
    myTrackingSentMap[packet->getCommand()]->myPacketsTcp++;
    myTrackingSentMap[packet->getCommand()]->myBytesTcp += packet->getLength();
  }
  else
  {
    myTrackingSentMap[packet->getCommand()]->myPacketsUdp++;
    myTrackingSentMap[packet->getCommand()]->myBytesUdp += packet->getLength();
  }
}

void ArServerClient::trackPacketReceived(ArNetPacket *packet, ArTypes::UByte2 command, bool tcp)
{
  if (myTrackingReceivedMap.find(command) == myTrackingReceivedMap.end())
    myTrackingReceivedMap[command] = new Tracker;

  if (tcp)
  {
    myTrackingReceivedMap[command]->myPacketsTcp++;
    myTrackingReceivedMap[command]->myBytesTcp += packet->getLength();
  }
  else
  {
    myTrackingReceivedMap[command]->myPacketsUdp++;
    myTrackingReceivedMap[command]->myBytesUdp += packet->getLength();
  }
}

AREXPORT void ArServerClient::logTracking(bool terse)
{
  std::map<ArTypes::UByte2, Tracker *>::iterator it;

  ArTypes::UByte2 command;
  Tracker *tracker = NULL;
  long seconds;

  seconds = myTrackingStarted.secSince();
  if (seconds == 0)
    seconds = 1;

  char name[512];

  long packetsReceivedTcp = 0;
  long bytesReceivedTcp = 0;
  long packetsReceivedUdp = 0;
  long bytesReceivedUdp = 0;

  ArLog::log(ArLog::Terse, "");
  ArLog::log(ArLog::Terse, "Received tracking for %s (active %d seconds):", 
             getIPString(), seconds);
  for (it = myTrackingReceivedMap.begin(); it != myTrackingReceivedMap.end(); it++)
  {
    command = (*it).first;
    tracker = (*it).second;

    packetsReceivedTcp += tracker->myPacketsTcp;
    bytesReceivedTcp += tracker->myBytesTcp;
    packetsReceivedUdp += tracker->myPacketsUdp;
    bytesReceivedUdp += tracker->myBytesUdp;

    std::map<unsigned int, ArServerData *>::iterator nameIt;
    if ((nameIt = myDataMap->find(command)) != myDataMap->end())
      snprintf(name, sizeof(name), "%s", (*nameIt).second->getName());
    // if we're command 255 or less and there's no name its probably
    // one of the server commands we don't really need to track
    else if (command <= 255)
      continue;
    // we should know what the name of everything other then the
    // server command is, but print if we don't, just in case
    else
      snprintf(name, sizeof(name), "#%d", command);
    if (terse)
    {
      ArLog::log(ArLog::Terse, 
                 "%35s %7ld pkts %10ld B %7ld B/sec", 
                 name, tracker->myPacketsTcp + tracker->myPacketsUdp, 
                 tracker->myBytesTcp + tracker->myBytesUdp,
                 ((tracker->myBytesTcp + tracker->myBytesUdp)/
                  seconds));
    }
    else
    {
      ArLog::log(ArLog::Terse, 
         "%35s %7ld tcp pkts %10ld tcp B %7ld tcp B/S %7ld udp pkts %10ld udp B %7ld udp B/s ", 
                 name, tracker->myPacketsTcp, tracker->myBytesTcp, 
                 tracker->myBytesTcp/seconds,
                 tracker->myPacketsUdp, tracker->myBytesUdp,
                 tracker->myBytesUdp/seconds);
    }
  }
  
  ArLog::log(ArLog::Terse, "");
  if (terse)
  {
    ArLog::log(ArLog::Terse, "%-35s %7ld pkts %10ld B %7ld B/sec", 
               "Total Received", packetsReceivedTcp + packetsReceivedUdp, 
               bytesReceivedTcp + bytesReceivedUdp,
               (bytesReceivedTcp + bytesReceivedUdp) / seconds);
  }
  else
  {
    ArLog::log(ArLog::Terse, "%-35s %7ld tcp pkts %10ld tcp B %7ld tcp B/S %7ld udp pkts %10ld udp B %7ld udp B/sec",  
               "Total Received", packetsReceivedTcp, bytesReceivedTcp, 
               bytesReceivedTcp/seconds, packetsReceivedUdp, bytesReceivedUdp, 
               bytesReceivedUdp/seconds);
    ArLog::log(ArLog::Terse, "%-35s %7ld tcp rcvs %10ld tcp B %7ld tcp B/S",
               "Low level TCP Received", myTcpSocket.getRecvs(), 
               myTcpSocket.getBytesRecvd(), 
               myTcpSocket.getBytesRecvd()/seconds);
  }

  long packetsSentTcp = 0;
  long bytesSentTcp = 0;
  long packetsSentUdp = 0;
  long bytesSentUdp = 0;

  ArLog::log(ArLog::Terse, "");
  ArLog::log(ArLog::Terse, "Sent tracking for %s (active %d seconds):", 
             getIPString(), seconds);
  for (it = myTrackingSentMap.begin(); it != myTrackingSentMap.end(); it++)
  {
    command = (*it).first;
    tracker = (*it).second;

    packetsSentTcp += tracker->myPacketsTcp;
    bytesSentTcp += tracker->myBytesTcp;
    packetsSentUdp += tracker->myPacketsUdp;
    bytesSentUdp += tracker->myBytesUdp;

    std::map<unsigned int, ArServerData *>::iterator nameIt;
    if ((nameIt = myDataMap->find(command)) != myDataMap->end())
      snprintf(name, sizeof(name), "%s", (*nameIt).second->getName());
    // if we're command 255 or less and there's no name its probably
    // one of the server commands we don't really need to track
    else if (command <= 255)
      continue;
    // we should know what the name of everything other then the
    // server command is, but print if we don't, just in case
    else
      snprintf(name, sizeof(name), "#%d", command);
    if (terse)
    {
      ArLog::log(ArLog::Terse, 
                 "%35s %7ld pkts %10ld B %7ld B/sec", 
                 name, tracker->myPacketsTcp + tracker->myPacketsUdp, 
                 tracker->myBytesTcp + tracker->myBytesUdp,
                 ((tracker->myBytesTcp + tracker->myBytesUdp)/
                  seconds));
    }
    else
    {
      ArLog::log(ArLog::Terse, 
         "%35s %7ld tcp pkts %10ld tcp B %7ld tcp B/S %7ld udp pkts %10ld udp B %7ld udp B/s ", 
                 name, tracker->myPacketsTcp, tracker->myBytesTcp, 
                 tracker->myBytesTcp/seconds,
                 tracker->myPacketsUdp, tracker->myBytesUdp,
                 tracker->myBytesUdp/seconds);
    }
  }

  ArLog::log(ArLog::Terse, "");
  if (terse)
  {
    ArLog::log(ArLog::Terse, "%-35s %7ld pkts %10ld B %7ld B/sec", 
               "Total Sent", packetsSentTcp + packetsSentUdp, 
               bytesSentTcp + bytesSentUdp,
               (bytesSentTcp + bytesSentUdp) / seconds);    
    ArLog::log(ArLog::Terse, "");
    ArLog::log(ArLog::Terse, "%-35s %7ld pkts %10ld B %7ld B/sec", 
               "Total Sent and Received", 
               (packetsSentTcp + packetsSentUdp + 
                packetsReceivedTcp + packetsReceivedUdp),
               (bytesSentTcp + bytesSentUdp + 
                bytesReceivedTcp + bytesReceivedUdp),
               (bytesSentTcp + bytesSentUdp + 
                bytesReceivedTcp + bytesReceivedUdp) / seconds);
  }
  else
  {
    ArLog::log(ArLog::Terse, "%-35s %7ld tcp pkts %10ld tcp B %7ld tcp B/S %7ld udp pkts %10ld udp B %7ld udp B/sec",  
               "Total Sent", packetsSentTcp, bytesSentTcp, 
               bytesSentTcp / seconds,
               packetsSentUdp, bytesSentUdp, bytesSentUdp / seconds);
    ArLog::log(ArLog::Terse, "%-35s %7ld tcp snds %10ld tcp B %7ld tcp B/S",
               "Low level TCP Sent", myTcpSocket.getSends(), 
               myTcpSocket.getBytesSent(), 
               myTcpSocket.getBytesSent() / seconds);

    ArLog::log(ArLog::Terse, "");
    ArLog::log(ArLog::Terse, "%-35s %7ld tcp pkts %10ld tcp B %7ld tcp B/S %7ld udp pkts %10ld udp B %7ld udp B/sec",  
               "Total Sent and Received", packetsSentTcp = packetsReceivedTcp, 
               bytesSentTcp + bytesReceivedTcp, 
               (bytesSentTcp + bytesReceivedTcp) / seconds,
               packetsSentUdp + packetsReceivedUdp, 
               bytesSentUdp + bytesReceivedUdp, 
               (bytesSentUdp + bytesReceivedUdp) / seconds);
  }

  ArLog::log(ArLog::Terse, "");
}


AREXPORT void ArServerClient::resetTracking(void)
{
  std::map<ArTypes::UByte2, Tracker *>::iterator it;

  myTrackingStarted.setToNow();

  for (it = myTrackingSentMap.begin(); it != myTrackingSentMap.end(); it++)
    (*it).second->reset();

  for (it = myTrackingReceivedMap.begin(); 
       it != myTrackingReceivedMap.end(); 
       it++)
    (*it).second->reset();

  myTcpSocket.resetTracking();
}

AREXPORT bool ArServerClient::hasGroupAccess(const char *group)
{
  if (myUserInfo == NULL || group == NULL || group[0] == '\0' || 
      myGroups.count(group) > 0 || myGroups.count("all") > 0)
    return true;
  else
    return false;  
}

AREXPORT long ArServerClient::getFrequency(ArTypes::UByte2 command)
{
  std::list<ArServerClientData *>::iterator it;
  ArServerClientData *data;  
  ArServerData *serverData;
  
  // walk through our list
  for (it = myRequested.begin(); it != myRequested.end(); ++it)
  {
    data = (*it);
    serverData = data->getServerData();
    // see if this is our data, if it is send the packet
    if (serverData->getCommand() == command)
    {
      if (data->getMSec() >= 0)
        return data->getMSec();
      else
        return -1;
    }
  }
  return -2;
}

---