ArClientBase.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 "ArClientBase.h"
#include "ArServerCommands.h"
#include "ArClientCommands.h"
#include "md5.h"

//#define ARDEBUG_CLIENTBASE

#if (defined(_DEBUG) && defined(ARDEBUG_CLIENTBASE))
#define IFDEBUG(code) {code;}
#else
#define IFDEBUG(code)
#endif 

AREXPORT ArClientBase::ArClientBase() :
  myRobotName(""),
  myLogPrefix(""),
  myProcessPacketCB(this, &ArClientBase::processPacket, NULL, true),
  myProcessPacketUdpCB(this, &ArClientBase::processPacketUdp)

{
  setThreadName("ArClientBase");
  myTcpSender.setSocket(&myTcpSocket);
  myTcpReceiver.setSocket(&myTcpSocket);
  myTcpReceiver.setProcessPacketCB(&myProcessPacketCB);
  myUdpReceiver.setSocket(&myUdpSocket);
  myUdpReceiver.setProcessPacketCB(&myProcessPacketUdpCB);
  clear();
}

AREXPORT ArClientBase::~ArClientBase()
{
  clear();
}

AREXPORT void ArClientBase::setRobotName(const char *name)
{
  myRobotName = ((name != NULL) ? name : "");

  myLogPrefix = "";
  if (!myRobotName.empty()) {
    myLogPrefix = myRobotName + ": ";
  }
}

AREXPORT const char *ArClientBase::getRobotName() const
{
  return myRobotName.c_str();
}


void ArClientBase::clear(void)
{
  internalSwitchState(STATE_NO_CONNECTION);

  myServerReportedUdpPort = 0;
  myUdpConfirmedFrom = false;
  myUdpConfirmedTo = false;
  myTcpOnlyTo = false;
  myTcpOnlyFrom = false;
  myTimeoutTime = 3;
  myQuiet = false;
  myLastPacketReceived.setToNow();

  myRejected = 0;
  myRejectedString[0] = '\0';

  myReceivedDataList = false;
  myReceivedArgRetList = false;
  myReceivedGroupAndFlagsList = false;

  resetTracking();

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

AREXPORT void ArClientBase::addCycleCallback(ArFunctor *functor)
{
  myCycleCallbackMutex.lock();
  myCycleCallbacks.push_front(functor);
  myCycleCallbackMutex.unlock();
}

AREXPORT void ArClientBase::remCycleCallback(ArFunctor *functor)
{
  myCycleCallbackMutex.lock();
  myCycleCallbacks.remove(functor);
  myCycleCallbackMutex.unlock();
}


AREXPORT void ArClientBase::setConnectTimeoutTime(int sec)
{
  myDataMutex.lock();
  if (sec < 0)
    myTimeoutTime = 0;
  else
    myTimeoutTime = sec;
  myDataMutex.unlock();
}

AREXPORT int ArClientBase::getConnectTimeoutTime(void)
{
  return myTimeoutTime;
}



AREXPORT bool ArClientBase::blockingConnect(const char *host, int port, 
                                            bool print, const char *user,
                                            const char *password)
{
  return internalBlockingConnect(host, port, print, user, password, NULL);
}

AREXPORT bool ArClientBase::internalBlockingConnect(
        const char *host, int port, bool print, const char *user,
        const char *password, ArSocket *tcpSocket)
{
  bool ret = false;
  ArTime startedUdpWait;
  ArNetPacket packet;
  bool debugPrinting = false;
  myDataMutex.lock();
  myHost = host;
  myQuiet = !print;
  myTcpReceiver.setQuiet(myQuiet);
  if (user != NULL)
    myUser = user;
  else
    myUser = "";
  if (password != NULL)
    myPassword = password;
  else
    myPassword = "";

  if (myState == STATE_LOST_CONNECTION)
  {
    ArLog::log(ArLog::Normal, "Trying a connection on a client that'd lost connection.");
    clear();
  }

  myDataMutex.unlock();
    
  if (myState != STATE_NO_CONNECTION && myState != STATE_FAILED_CONNECTION)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Terse, 
         "ArClientBase: Connection already established or being connected.");
    return false;
  }


  if (debugPrinting)
    ArLog::log(ArLog::Normal, "0");
  myDataMutex.lock();
  myStartedConnection.setToNow();
  myDataMutex.unlock();
  if (tcpSocket != NULL)
  {
    myDataMutex.lock();
    myTcpSocket.transfer(tcpSocket);
    internalStartUdp();
    myDataMutex.unlock();
    internalSwitchState(STATE_OPENED_SOCKET);

  }
  else
  {
    /*
    while (1)
    {
    */
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "1");
    loopOnce();
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "1.1");
    myDataMutex.lock();
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "1.2");
    if (internalConnect(host, port, print))
    {
      myDataMutex.unlock();
      if (debugPrinting)
        ArLog::log(ArLog::Normal, "2");
      //break;
    }
    else
    {
      myTcpSocket.close();
      myUdpSocket.close();
      internalSwitchState(STATE_FAILED_CONNECTION);
      myDataMutex.unlock();
      if (debugPrinting)
        ArLog::log(ArLog::Normal, "3");
      return false;
      /*
      // see if we didn't get udp from
      if (myStartedConnection.mSecSince() > myTimeoutTime * .33 * 1000.0)
      {
        if (debugPrinting)
          ArLog::log(ArLog::Normal, "3");
        internalSwitchState(STATE_FAILED_CONNECTION);

        return false;
      }
      else 
      {
        if (debugPrinting)
          ArLog::log(ArLog::Normal, "4");
          internalSwitchState(STATE_FAILED_CONNECTION);
        ArUtil::sleep(100);
      }
      */
    }
    //}
  }

  if (debugPrinting)
    ArLog::log(ArLog::Normal, "5");
  while (myState != STATE_REJECTED && myState != STATE_CONNECTED && 
         myState != STATE_NO_CONNECTION)
  {
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "6");
    loopOnce();
    if (myTimeoutTime > 0 && 
        myStartedConnection.mSecSince() > myTimeoutTime * 1000.0)
    {
      if (debugPrinting)
        ArLog::log(ArLog::Normal, "7");
      if (!myQuiet)
        ArLog::log(ArLog::Terse, "ArClientBase::blockingConnect: a Connection timed out.");
      internalSwitchState(STATE_FAILED_CONNECTION);
      //myState = STATE_NO_CONNECTION;
      myTcpSocket.close();
      myUdpSocket.close();
      return false;
    }
    ArUtil::sleep(1);
  }
  if (myState == STATE_REJECTED)
  {
    myTcpSocket.close();
    myUdpSocket.close();
    return false;
  }
  if (debugPrinting)
    ArLog::log(ArLog::Normal, "8");
  startedUdpWait.setToNow();
  while ((!myUdpConfirmedFrom && !myTcpOnlyFrom) || 
         (!myUdpConfirmedTo && !myTcpOnlyTo))
  {
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "9");
    loopOnce();
    // see if we didn't get udp from
    if (startedUdpWait.mSecSince() > myTimeoutTime * .66 * 1000.0 &&
        !myUdpConfirmedFrom && !myTcpOnlyFrom)
    {
      packet.empty();
      packet.setCommand(ArClientCommands::TCP_ONLY);
      sendPacketTcp(&packet);
      myDataMutex.lock();
      myTcpOnlyFrom = true;
      myDataMutex.unlock();
      if (!myQuiet)
        ArLog::log(ArLog::Normal, "ArClientBase: Didn't get confirmation of UDP from server, switching to TCP.");
    }
    // see if we haven't confirmed udp to
    if (startedUdpWait.mSecSince() > myTimeoutTime * .66 * 1000.0 &&
        !myUdpConfirmedTo && !myTcpOnlyTo)
    {
      packet.empty();
      myDataMutex.lock();
      myTcpOnlyTo = true;
      myDataMutex.unlock();
      if (!myQuiet)
        ArLog::log(ArLog::Normal, "ArClientBase: Didn't get confirmation of UDP to server, switching to TCP.");
    }
    if (myTimeoutTime > 0 && 
        startedUdpWait.mSecSince() > myTimeoutTime * 1000.0)
    {
      if (!myQuiet)
        ArLog::log(ArLog::Terse, "ArClientBase::blockingConnect: b Connection timed out.");
      ArLog::log(
              ArLog::Normal, "timeout %d startedMSecSince %d startedUdpWaitMSecSince %d udpFrom %d udpTo %d tcpOnlyFrom %d tcpOnlyTo %d", 
              myTimeoutTime, myStartedConnection.mSecSince(), 
              startedUdpWait.mSecSince(), myUdpConfirmedFrom, 
              myUdpConfirmedTo, myTcpOnlyFrom, myTcpOnlyTo);
      //myState = STATE_NO_CONNECTION;
      internalSwitchState(STATE_FAILED_CONNECTION);
    }
    ArUtil::sleep(1);
  }
  if (debugPrinting)
    ArLog::log(ArLog::Normal, "10");
  if (myState == STATE_CONNECTED)
    ret = true;
  if (!ret)
  {
    myTcpSocket.close();
    myUdpSocket.close();
  }
  return ret;  
}

bool ArClientBase::internalConnect(const char *host, int port, bool obsolete)
{
  bool debugPrinting = false;
  if (debugPrinting)
    ArLog::log(ArLog::Normal, "a");
  // if we connect tcp then connect up the udp
  if (myTcpSocket.connect(host, port, ArSocket::TCP))
  {
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "b");
    if (!myTcpSocket.setNonBlock())
    {
      ArLog::log(ArLog::Terse,
                 "ArClientBase::connect: Failed to set TCP socket nonblock");
      return false;
    }
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "c");
    internalStartUdp();
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "d");
    if (!myQuiet)
      ArLog::log(ArLog::Verbose, 
        "Opened client connection to %s on tcp port %d with my udp port of %d",
                 host, port, myUdpPort);
    // we can't tell if udp connected or not (because its udp) so just
    // say we're good
    internalSwitchState(STATE_OPENED_SOCKET);
    if (debugPrinting)
      ArLog::log(ArLog::Normal, "e");
    return true;
  }
  else
  {
    if (!myQuiet)
      ArLog::log(ArLog::Terse,
                 "ArClientBase::connect: Failed to open TCP socket");
    internalSwitchState(STATE_FAILED_CONNECTION);
    return false;
  }
}

void ArClientBase::internalStartUdp(void)
{
  // fire up the udp
  if (!myUdpSocket.create(ArSocket::UDP) ||
      !myUdpSocket.findValidPort(10000) ||
      !myUdpSocket.setNonBlock())
  {
    myUdpSocket.setLinger(0);
    if (!myQuiet)
      ArLog::log(ArLog::Terse, 
                 "ArClientBase::connect: Failed to open udp socket, forcing TCP");
    //internalSwitchState(STATE_FAILED_CONNECTION);
    //return false;              
    myTcpOnlyTo = true;
    myTcpOnlyFrom = true;
  }
  myUdpSinValid = false;
  myUdpSin.sin_family=AF_INET;
  myUdpSin.sin_addr = *myTcpSocket.inAddr();
  myUdpPort = myUdpSocket.netToHostOrder(myUdpSocket.inPort());
}

AREXPORT bool ArClientBase::disconnect(void)
{
  bool ret = startNonBlockingDisconnect();

  ArUtil::sleep(10);

  finishNonBlockingDisconnect();

  return ret;
}

AREXPORT bool ArClientBase::startNonBlockingDisconnect()
{
  if (!myQuiet)
    ArLog::log(ArLog::Normal, "Disconnected from server."); 

  bool ret = false;
  ArNetPacket packet;

  packet.setCommand(ArClientCommands::SHUTDOWN);
  ret = sendPacketTcp(&packet);
  myTcpSender.sendData();

  return ret;
}

AREXPORT void ArClientBase::finishNonBlockingDisconnect()
{
  myTcpSocket.close();
  myUdpSocket.close();
  myState = STATE_NO_CONNECTION;
}



AREXPORT  bool ArClientBase::setupPacket(ArNetPacket *packet)
{
  if (myState == STATE_NO_CONNECTION || myState == STATE_FAILED_CONNECTION)
    return false;

  packet->finalizePacket();
  return true;
} 

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

AREXPORT bool ArClientBase::sendPacketUdp(ArNetPacket *packet)
{
  if (!setupPacket(packet))
  {
    return false;
  }
  else
  {
    trackPacketSent(packet, false);
    if (myUdpSocket.sendTo(packet->getBuf(), packet->getLength(), &myUdpSin) 
        == packet->getLength())
    {
      return true;
    }
    else
    {
      return false;
    }
  }
}

AREXPORT void ArClientBase::loopOnce(void)
{
  std::list<ArFunctor *>::iterator it;
  if (myState != STATE_NO_CONNECTION && myState != STATE_FAILED_CONNECTION &&
      myState != STATE_LOST_CONNECTION)
  {
    // if we couldn't receive tcp data fail
    if (!myTcpReceiver.readData())
    {
      if (!myQuiet)
        ArLog::log(ArLog::Normal, 
                   "Lost connection to server (couldn't recv).");
      myTcpSocket.close();
      myUdpSocket.close();
      internalSwitchState(STATE_LOST_CONNECTION);
      stopRunning();
      myCallbackMutex.lock();
      for (it = myDisconnectOnErrorCBList.begin(); 
           it != myDisconnectOnErrorCBList.end(); 
           ++it)
        (*it)->invoke();
      myCallbackMutex.unlock();
  
    }
    // if we can't receive UDP just make an error log
    else if (!myTcpOnlyFrom && !myUdpReceiver.readData())
    {
      if (!myQuiet)
        ArLog::log(ArLog::Normal, "UDP Troubles, continuing");
    }
    if (!myTcpSender.sendData())
    {
      if (!myQuiet)
        ArLog::log(ArLog::Normal, 
                   "Lost connection to server (couldn't send).");
      myTcpSocket.close();
      myUdpSocket.close();
      internalSwitchState(STATE_LOST_CONNECTION);
      stopRunning();
      myCallbackMutex.lock();
      for (it = myDisconnectOnErrorCBList.begin(); 
           it != myDisconnectOnErrorCBList.end(); 
           ++it)
        (*it)->invoke();
      myCallbackMutex.unlock();
    }
  }
  myCycleCallbackMutex.lock();
  for (it = myCycleCallbacks.begin(); it != myCycleCallbacks.end(); ++it)
    (*it)->invoke();
  myCycleCallbackMutex.unlock();

}

AREXPORT void ArClientBase::run(void)
{
  runInThisThread();
}

AREXPORT void ArClientBase::runAsync(void)
{
  create(true, false);
}

AREXPORT void *ArClientBase::runThread(void *arg)
{
  threadStarted();
  while (myRunning)
  {
    loopOnce();
    ArUtil::sleep(1);
  }
  return NULL;
}


AREXPORT void ArClientBase::processPacket(ArNetPacket *packet, bool tcp)
{
  ArNetPacket retPacket;
  char buf[512];
  char passwordKey[2048];
  std::list<ArFunctor *>::iterator it;

  myDataMutex.lock();
  myLastPacketReceived.setToNow();
  myDataMutex.unlock();

  // See if we should close our connection
  if (packet->getCommand() == ArServerCommands::SHUTDOWN)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Normal, "Server shutting down and closed connection.");
    stopRunning();
    disconnect();
    internalSwitchState(STATE_LOST_CONNECTION);
    myCallbackMutex.lock();
    for (it = myServerShutdownCBList.begin(); 
         it != myServerShutdownCBList.end(); 
         ++it)
      (*it)->invoke();
    myCallbackMutex.unlock();
  }
  else if (myState == STATE_OPENED_SOCKET && 
      packet->getCommand() == ArServerCommands::INTRODUCTION)
  {
    myDataMutex.lock();
    // first read the data from the packet
    packet->bufToStr(buf, 512);
    myServerReportedUdpPort = packet->bufToUByte2();
    if (!myQuiet)
      ArLog::log(ArLog::Verbose, "Connection to version %s with udp port %u",
               buf, myServerReportedUdpPort);
    // set our expected port (its okay if its otherwise)
    myUdpSin.sin_port = ArSocket::hostToNetOrder(myServerReportedUdpPort);
    // get the keys
    myAuthKey = packet->bufToUByte4();
    myIntroKey = packet->bufToUByte4();
    packet->bufToStr(passwordKey, sizeof(passwordKey));
    // introduce ourself normally via tcp
    retPacket.empty();
    retPacket.setCommand(ArClientCommands::INTRODUCTION);
    retPacket.uByte2ToBuf(myUdpPort);
    retPacket.strToBuf(myUser.c_str());
    // old simple cleartext way
    //retPacket.strToBuf(myPassword.c_str());
    md5_state_t md5State;
    unsigned char md5Digest[16];
    
    md5_init(&md5State);
    md5_append(&md5State, (unsigned char *)myServerKey.c_str(), 
               myServerKey.size());
    md5_append(&md5State, (unsigned char *)passwordKey, strlen(passwordKey));
    md5_append(&md5State, (unsigned char *)myPassword.c_str(), 
               myPassword.size());
    md5_finish(&md5State, md5Digest);

    retPacket.dataToBuf((const char *)md5Digest, 16);
    myPassword = "";
    bool tcpOnlyFrom = myTcpOnlyFrom;
    myDataMutex.unlock();
    if (tcpOnlyFrom)
    {
      retPacket.empty();
      retPacket.setCommand(ArClientCommands::TCP_ONLY);
      sendPacketTcp(&retPacket);
    }
    sendPacketTcp(&retPacket);
    internalSwitchState(STATE_EXCHANGED_INTROS);
  }
  // if we're not at opened socket and got an intro somethings horribly wrong
  else if (myState != STATE_OPENED_SOCKET && 
      packet->getCommand() == ArServerCommands::INTRODUCTION)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Terse, "ArClientBase: introduction received when not in STATE_OPENED_SOCKET");
    return;
  }
  // if we're at opened socket and received something other than intro
  // then somethings horribly wrong
  else if (myState == STATE_OPENED_SOCKET && 
      packet->getCommand() != ArServerCommands::INTRODUCTION)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Terse, "ArClientBase: packet other than introduction received when in STATE_OPENED_SOCKET");
    return;
  }
  // if we've exchanged intros and are waiting for connection or rejection
  else if (myState == STATE_EXCHANGED_INTROS && 
           packet->getCommand() == ArServerCommands::CONNECTED)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Terse, "Client now connected to server.");
    internalSwitchState(STATE_WAITING_LIST);
    // introduce ourself via udp
    retPacket.empty();
    retPacket.setCommand(ArClientCommands::UDP_INTRODUCTION);
    myDataMutex.lock();
    retPacket.uByte4ToBuf(myAuthKey);
    myDataMutex.unlock();
    sendPacketUdp(&retPacket);
    return;
  }
  // if we've received a connected and aren't at exchanging intros
  else if (packet->getCommand() == ArServerCommands::CONNECTED)
  {
    ArLog::log(ArLog::Terse, 
 "ArClientBase:: connected packet received not during STATE_EXCHANGED_INTROS");
    return;
  }
  // if we're exchanging intros and were rejected
  else if (myState != STATE_CONNECTED &&
           packet->getCommand() == ArServerCommands::REJECTED)
  {
    myRejected = packet->bufToByte2();
    packet->bufToStr(myRejectedString, sizeof(myRejectedString));
    if (!myQuiet)
    {
      if (myRejected == 1)
        ArLog::log(ArLog::Normal, 
                   "Server rejected connection because of bad user/password");
      else if (myRejected == 2)
        ArLog::log(ArLog::Normal, 
                   "Server rejected connection since it is using the centralserver at %s", 
                   myRejectedString);
      else
        ArLog::log(ArLog::Normal, 
                   "Server rejected connection for unknown reason %d '%s'",
                   myRejected, myRejectedString);
    }
      
    internalSwitchState(STATE_REJECTED);
    return;
  }
  // if we received rejected and aren't at exchanging intros
  else if (packet->getCommand() == ArServerCommands::REJECTED)
  {
    ArLog::log(ArLog::Terse, 
               "ArClientBase:: rejected packet received after connected");
    return;
  }
  // if we're waiting for our list and get it we're connected
  else if (myState == STATE_WAITING_LIST &&
           packet->getCommand() == ArServerCommands::LIST)
  {
    internalSwitchState(STATE_CONNECTED);
    myDataMutex.lock();
    md5_state_t md5State;
    
    md5_init(&md5State);
    md5_append(&md5State, (unsigned char *)&myAuthKey, sizeof(myAuthKey));
    md5_append(&md5State, (unsigned char *)&myIntroKey, sizeof(myIntroKey));
    long rand = ArMath::random();
    md5_append(&md5State, (unsigned char *)&rand, sizeof(rand));
    unsigned int time = ArUtil::getTime();
    md5_append(&md5State, (unsigned char *)&time, sizeof(time));

    md5_finish(&md5State, myClientKey);
    myDataMutex.unlock();
    myMapsMutex.lock();
    buildList(packet);
    myMapsMutex.unlock();
    return;
  }
  // see if we got any lists when not waiting for them
  else if (packet->getCommand() == ArServerCommands::LIST ||
           packet->getCommand() == ArServerCommands::LISTSINGLE || 
           packet->getCommand() == ArServerCommands::LISTARGRET ||
           packet->getCommand() == ArServerCommands::LISTARGRETSINGLE ||
           packet->getCommand() == ArServerCommands::LISTGROUPANDFLAGS ||
           packet->getCommand() == ArServerCommands::LISTGROUPANDFLAGSSINGLE)
  {
    myMapsMutex.lock();
    buildList(packet);
    myMapsMutex.unlock();
    return;
  }
  // if we're in exhanged intros and receive a packet not for that state
  else if (myState == STATE_EXCHANGED_INTROS && 
           packet->getCommand() != ArServerCommands::CONNECTED && 
           packet->getCommand() != ArServerCommands::REJECTED)
  {
    ArLog::log(ArLog::Terse, "ArClientBase: we're in STATE_EXCHANGE_INTROS and received something other than connected or rejected.");
    return;
  }
  // if we're connected and got a udp confirmed packet then everything is good
  else if (myState == STATE_CONNECTED && 
           packet->getCommand() == ArServerCommands::UDP_CONFIRMATION)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Verbose, 
                 "Clients udp connection to server confirmed.");
    myDataMutex.lock();
    myUdpConfirmedTo = true;
    myDataMutex.unlock();
    return;
  }
  // if we're not connected and got a udp confirmation it means
  // something is wrong
  else if (packet->getCommand() == ArServerCommands::UDP_CONFIRMATION)
  {
    ArLog::log(ArLog::Terse, 
        "ArClientBase: Udp Confirmation received when not in STATE_CONNECTED");
    return;
  }
  // if we're connected and got a tcp only packet then everything is good
  else if (myState == STATE_CONNECTED && 
           packet->getCommand() == ArServerCommands::TCP_ONLY)
  {
    if (!myQuiet)
      ArLog::log(ArLog::Normal, "Client told to only use tcp.");
    myDataMutex.lock();
    myTcpOnlyTo = true;
    myDataMutex.unlock();
    return;
  }
  // if none of the above were triggered its just a normal packet
  else if (myState == STATE_CONNECTED)
  {
    std::map<unsigned int, ArClientData *>::iterator it;
    ArClientData *clientData;
    // see if we have the command
    myMapsMutex.lock();
    if ((it = myIntDataMap.find(packet->getCommand())) == myIntDataMap.end())
    {
      myMapsMutex.unlock();
      ArLog::log(ArLog::Terse, 
                 "ArClientBase got packet for %d which doesn't exist, packet was %d long", 
                 packet->getCommand(), packet->getLength());
      packet->log();
      int ijk;
      ArLog::log(ArLog::Terse, "Packet: ");
      for (ijk = 0; ijk < packet->getLength(); ijk++)
        ArLog::log(ArLog::Terse, " %d ", 
                   (unsigned char) packet->getBuf()[ijk]);
    }
    else
      myMapsMutex.unlock();

    clientData = (*it).second;
    if (clientData == NULL)
    {
      ArLog::log(ArLog::Terse,
                 "ArClientBase: null client data for command %d", 
                 packet->getCommand());    
      return;
    }
    
    clientData->lockFunctorList();
    if (clientData->getFunctorList()->begin() == 
        clientData->getFunctorList()->end())
    {
      ArLog::log(ArLog::Verbose, 
                 "ArClientBase: No functor to handle command %d",
                 packet->getCommand());
      clientData->unlockFunctorList();
      return;
    }
    else
    {
      std::list<ArFunctor1<ArNetPacket *> *>::const_iterator it;
      ArFunctor1<ArNetPacket *> *functor;
      for (it = clientData->getFunctorList()->begin(); 
           it != clientData->getFunctorList()->end();
           it++)
      {
        packet->resetRead();
        functor = (*it);
        functor->invoke(packet);
      }
      clientData->unlockFunctorList();
      trackPacketReceived(packet, tcp);
        
    }
    

  }
  else
  {
          //packet->bufToStr(&str);
    //packet->printHex();
    ArLog::log(ArLog::Verbose, "bogus packet of %u command %d long (probably after close)", 
               packet->getCommand(),  packet->getLength());
  }
  //sendPacketTcp(packet);
  
}

void ArClientBase::buildList(ArNetPacket *packet)
{
  ArClientData *clientData;
  unsigned int listLen;
  unsigned int i;
  unsigned int command;
  char name[512];
  char description[512];
  char argDesc[512];
  char retDesc[512];
  char commandGroup[512];
  char dataFlags[512];

  // if its a single list snag it and run
  if (packet->getCommand() == ArServerCommands::LISTSINGLE)
  {
    command = packet->bufToUByte2();
    packet->bufToStr(name, sizeof(name));
    packet->bufToStr(description, sizeof(description));
    clientData = new ArClientData(name, description, command, NULL);
    ArLog::log(ArLog::Verbose, "ArClientBase: new entry number %d for data %s with description %s", command, name, description);
    if (myIntDataMap.find(command) != myIntDataMap.end())
      ArLog::log(ArLog::Normal, "ArClientBase: is already an entry for number %d as data %d\n, overwriting", command, myIntDataMap[command]->getName());
    myNameIntMap[name] = command;
    myIntDataMap[command] = clientData;
    return;
  }
  else if (packet->getCommand() == ArServerCommands::LIST)
  {
    myReceivedDataList = true;
    listLen = packet->bufToUByte2();
    // otherwise loop and read them all
    for (i = 0; i < listLen; i++)
    {
      command = packet->bufToUByte2();
      packet->bufToStr(name, sizeof(name));
      packet->bufToStr(description, sizeof(description));
      clientData = new ArClientData(name, description, command, NULL);
      ArLog::log(ArLog::Verbose, "ArClientBase: new entry number %d for data %s with description %s", command, name, description);
      if (myIntDataMap.find(command) != myIntDataMap.end() && 
          strcmp(myIntDataMap[command]->getName(), name))
        ArLog::log(ArLog::Normal, "ArClientBase: is already an entry for number %d as data %d\n, overwriting", command, myIntDataMap[command]->getName());
      myNameIntMap[name] = command;
      myIntDataMap[command] = clientData;
    }
    return;
  }
  // if its a single list snag it and run
  else if (packet->getCommand() == ArServerCommands::LISTARGRETSINGLE)
  {
    command = packet->bufToUByte2();
    clientData = myIntDataMap[command];
    if (clientData == NULL)
    {
      ArLog::log(ArLog::Normal, 
                 "ArClientBase::buildList: Unknown command %s %d", 
                 getName(packet->getCommand(), true), packet->getCommand());
      return;
    }
    packet->bufToStr(argDesc, sizeof(argDesc));
    packet->bufToStr(retDesc, sizeof(retDesc));
    clientData->setArgRetDescs(argDesc, retDesc);
    return;
  }
  else if (packet->getCommand() == ArServerCommands::LISTARGRET)
  {
    myReceivedArgRetList = true;
    listLen = packet->bufToUByte2();
    // otherwise loop and read them all
    for (i = 0; i < listLen; i++)
    {
      command = packet->bufToUByte2();
      clientData = myIntDataMap[command];
      if (clientData == NULL)
      {
        ArLog::log(ArLog::Normal, 
                   "ArClientBase::buildList: Unknown command %s %d", 
                   getName(packet->getCommand(), true), packet->getCommand());
  // KMC Need to do something here because otherwise it blows up on 
  // the setArgRetDescs call below...
       return;
      }
      packet->bufToStr(argDesc, sizeof(argDesc));
      packet->bufToStr(retDesc, sizeof(retDesc));
      clientData->setArgRetDescs(argDesc, retDesc);
    }
    return;
  }
  // if its a single list snag it and run
  else if (packet->getCommand() == ArServerCommands::LISTGROUPANDFLAGSSINGLE)
  {
    command = packet->bufToUByte2();
    clientData = myIntDataMap[command];
    if (clientData == NULL)
    {
      ArLog::log(ArLog::Normal, 
                 "ArClientBase::buildList: Unknown command %s %d", 
                 getName(packet->getCommand(), true), packet->getCommand());
      return;
    }
    packet->bufToStr(commandGroup, sizeof(commandGroup));
    packet->bufToStr(dataFlags, sizeof(dataFlags));
    clientData->setCommandGroup(commandGroup);
    clientData->addDataFlags(dataFlags);
    return;
  }
  else if (packet->getCommand() == ArServerCommands::LISTGROUPANDFLAGS)
  {
    myReceivedGroupAndFlagsList = true;
    listLen = packet->bufToUByte2();
    // otherwise loop and read them all
    for (i = 0; i < listLen; i++)
    {
      command = packet->bufToUByte2();
      clientData = myIntDataMap[command];
      if (clientData == NULL)
      {
        ArLog::log(ArLog::Normal, 
                   "ArClientBase::buildList: Unknown command %s %d", 
                   getName(packet->getCommand(), true), packet->getCommand());
  // KMC Need to do something here because otherwise it blows up on 
  // the setArgRetDescs call below...
       return;
      }
      packet->bufToStr(commandGroup, sizeof(commandGroup));
      packet->bufToStr(dataFlags, sizeof(dataFlags));
      clientData->setCommandGroup(commandGroup);
      clientData->addDataFlags(dataFlags);
    }
    return;
  }
  else
  {
    ArLog::log(ArLog::Terse, 
               "ArClientBase::buildList: Unhandled packet type %s %d", 
               getName(packet->getCommand(), true), packet->getCommand());
  }
}

AREXPORT void ArClientBase::processPacketUdp(ArNetPacket *packet,
                                 struct sockaddr_in *sin)
{
  unsigned char *bytes = (unsigned char *)&sin->sin_addr.s_addr;
  long introKey;
  ArNetPacket retPacket;

  myDataMutex.lock();
  myLastPacketReceived.setToNow();
  // see if its an intro packet and we're connected (or could be but
  // not yet know it)
  if ((myState == STATE_CONNECTED || myState == STATE_EXCHANGED_INTROS ||
      myState == STATE_WAITING_LIST) && 
      packet->getCommand() == ArServerCommands::UDP_INTRODUCTION)
  {
    // see if we've already confirmed the UDP
    if (myUdpConfirmedFrom)
    {
      myDataMutex.unlock();
      return;
    }
    introKey = packet->bufToByte4();
    if (myIntroKey != introKey)
    {
      ArLog::log(ArLog::Terse, 
                 "Udp introduction packet received with wrong introKey");
      myDataMutex.unlock();
      return;
    }
    if (myServerReportedUdpPort != ArSocket::netToHostOrder(sin->sin_port))
      ArLog::log(ArLog::Verbose,
      "ArClientBase: ports don't match, said from server %d and given was %d",
             myServerReportedUdpPort, ArSocket::netToHostOrder(sin->sin_port));
    myUdpSin.sin_port = sin->sin_port;
    myUdpConfirmedFrom = true;
    // now confirm to the server we got the UDP packet
    retPacket.empty();
    retPacket.setCommand(ArClientCommands::UDP_CONFIRMATION);
    if (!myQuiet)
      ArLog::log(ArLog::Normal, "Server connected to us on udp port %d", 
                 ArSocket::netToHostOrder(myUdpSin.sin_port));
    myDataMutex.unlock();
    sendPacketTcp(&retPacket);
    return;
  }
  // if we receive an intro packet but aren't connected
  else if (packet->getCommand() == ArServerCommands::UDP_INTRODUCTION)
  {
    ArLog::log(ArLog::Terse, 
               "Udp introduction packet received while not connected");
    myDataMutex.unlock();
    return;
  }
  // if its not an intro, make sure it matchs our server
  else if (myUdpSin.sin_port == sin->sin_port &&
        myUdpSin.sin_addr.s_addr == sin->sin_addr.s_addr)
  {
    // TODO make this reject them if they're not in the user area
    myDataMutex.unlock();
    processPacket(packet, false);
    myDataMutex.lock();
  }
  // if it doesn't warn about it
  else
  {
    ArLog::log(ArLog::Normal, "Bogus UDP packet from %d.%d.%d.%d %d", 
               bytes[0], bytes[1], bytes[2], bytes[3], 
               ArSocket::netToHostOrder(sin->sin_port));
  }
  myDataMutex.unlock();
}

void ArClientBase::internalSwitchState(ClientState state)
{
  myState = state;
  myStateStarted.setToNow();
}

AREXPORT bool ArClientBase::addHandler(const char *name, 
                                       ArFunctor1 <ArNetPacket *> *functor)
{
  if (name == NULL) {
   ArLog::log(ArLog::Normal, "ArClientBase::addHandler: Cannot add NULL name");
   return false;
  }
  ArClientData *clientData;
  // see if we have this data
  myMapsMutex.lock();
  if (myNameIntMap.find(name) == myNameIntMap.end())
  {
    ArLog::log(ArLog::Normal, "ArClientBase::addHandler: There is no data by the name \"%s\" to handle", name);
    myMapsMutex.unlock();
    return false;
  }
  // since we have the data get the pointer to it
  clientData = myIntDataMap[myNameIntMap[name]];
  myMapsMutex.unlock();

  // make sure nothings gone wrong
  if (clientData == NULL)
  {
    ArLog::log(ArLog::Normal, "ArClientBase::addHandler: There was no clientData for data \"%s\"", name);
    return false;
  }
  clientData->lockFunctorList();
  // see if it already has a functor
  if (clientData->getFunctorList()->begin() != 
      clientData->getFunctorList()->end())
  {
    ArLog::log(ArLog::Verbose, "ArClientBase::addHandler: There is already a functor for data \"%s\", adding anyways", name);
    //return false;
  }
  // addthe functor
  clientData->addFunctor(functor);
  clientData->unlockFunctorList();
  return true;
}

AREXPORT bool ArClientBase::remHandler(const char *name, 
                                       ArFunctor1<ArNetPacket *> *functor)
{
  ArClientData *clientData;
  myMapsMutex.lock();
  // see if we have this client data
  if (myNameIntMap.find(name) == myNameIntMap.end())
  {
    ArLog::log(ArLog::Normal, "ArClientBase::remHandler: There is no data \"%s\"", name);
    myMapsMutex.unlock();
    return false;
  }
  if ((clientData = myIntDataMap[myNameIntMap[name]]) == NULL)
  {
    ArLog::log(ArLog::Normal, "ArClientBase::remHandler: There was no client data for data \"%s\"", name);
    myMapsMutex.unlock();
    return false;
  }
  myMapsMutex.unlock();
  // set the functor to NULL
  clientData->lockFunctorList();
  clientData->remFunctor(functor);
  clientData->unlockFunctorList();
  return true;
}


AREXPORT unsigned int ArClientBase::findCommandFromName(const char *name)
{
  std::map<std::string, unsigned int>::iterator it;
  unsigned int ret;

  myMapsMutex.lock();  
  if ((it = myNameIntMap.find(name)) == myNameIntMap.end())
  {
    ArLog::log(ArLog::Normal, 
               "Finding command for \"%s\" but no data with that name exists",
               name);
    myMapsMutex.unlock();  
    return 0;
  }
  ret = (*it).second;
  myMapsMutex.unlock();  
  return ret;
}

AREXPORT bool ArClientBase::request(const char *name, long mSec, 
                                    ArNetPacket *packet)
{
  ArLog::log(ArLog::Verbose, 
             "%sRequesting data for \"%s\"", 
             myLogPrefix.c_str(), name);
  return requestByCommand(findCommandFromName(name), mSec, packet);
}

AREXPORT bool ArClientBase::requestByCommand(unsigned int command, 
                                             long mSec, ArNetPacket *packet)
{
  ArNetPacket sending;

  sending.setCommand(ArClientCommands::REQUEST);
  sending.uByte2ToBuf(command);
  sending.byte4ToBuf(mSec);
  if (packet != NULL)
  {
    packet->resetRead();
    sending.dataToBuf(&packet->getBuf()[packet->getReadLength()],
                      packet->getLength() - packet->getReadLength());
  }
  return sendPacketTcp(&sending);
}


AREXPORT bool ArClientBase::requestStop(const char *name)
{
  ArLog::log(ArLog::Verbose, 
             "%sRequesting stop data for \"%s\"", 
             myLogPrefix.c_str(), name);
  return requestStopByCommand(findCommandFromName(name));
}

AREXPORT bool ArClientBase::requestStopByCommand(unsigned int command)
{
  ArNetPacket sending;
  sending.setCommand(ArClientCommands::REQUESTSTOP);
  sending.uByte2ToBuf(command);
  return sendPacketTcp(&sending);
}


AREXPORT bool ArClientBase::requestOnce(const char *name, 
                                        ArNetPacket *packet,
                                        bool quiet)
{
  if (!quiet) {
    ArLog::log(ArLog::Verbose, 
               "%sRequesting data once for \"%s\"", myLogPrefix.c_str(), name);
  }
  return requestOnceByCommand(findCommandFromName(name), packet);
}

AREXPORT bool ArClientBase::requestOnceUdp(
        const char *name, ArNetPacket *packet)
{
  ArLog::log(ArLog::Verbose, 
             "%sRequesting data once (UDP) for \"%s\"", 
             myLogPrefix.c_str(), name);
  return requestOnceByCommandUdp(findCommandFromName(name), packet);
}

AREXPORT bool ArClientBase::requestOnceByCommand(unsigned int command, 
                                                 ArNetPacket *packet)
{
  if (packet != NULL)
  {
    packet->setCommand(command);
    return sendPacketTcp(packet);
  }
  else
  {
    ArNetPacket tempPacket;
    tempPacket.setCommand(command);
    return sendPacketTcp(&tempPacket);
  }
}

AREXPORT bool ArClientBase::requestOnceByCommandUdp(unsigned int command, 
                                                    ArNetPacket *packet)
{
  if (packet != NULL)
  {
    packet->setCommand(command);
    if (!myTcpOnlyTo)
      return sendPacketUdp(packet);
    else
      return sendPacketTcp(packet);
  }
  else
  {
    ArNetPacket tempPacket;
    tempPacket.setCommand(command);
    if (!myTcpOnlyTo)
      return sendPacketUdp(&tempPacket);
    else
      return sendPacketTcp(&tempPacket);
  }
}

AREXPORT bool ArClientBase::requestOnceWithString(const char *name, 
                                                  const char *str)
{
  std::map<std::string, unsigned int>::iterator it;

  myDataMutex.lock();
  if ((it = myNameIntMap.find(name)) == myNameIntMap.end())
  {
    ArLog::log(ArLog::Normal, 
               "Requesting data for \"%s\" but no data with that name exists",
               name);
    myDataMutex.unlock();
    return false;
  }
  myDataMutex.unlock();
  ArLog::log(ArLog::Verbose, 
             "%sRequesting data once for \"%s\"", 
             myLogPrefix.c_str(), name);
  
  ArNetPacket tempPacket;
  tempPacket.strToBuf(str);
  tempPacket.setCommand((*it).second);
  return sendPacketTcp(&tempPacket);
}

AREXPORT bool ArClientBase::dataExists(const char *name)
{
  bool ret;
  myDataMutex.lock();
  ret = (myNameIntMap.find(name) != myNameIntMap.end());
  myDataMutex.unlock();
  return ret;
}

AREXPORT void ArClientBase::logDataList(void)
{
  std::map<unsigned int, ArClientData *>::iterator it;
  ArClientData *clientData;

  myDataMutex.lock();
  ArLog::log(ArLog::Terse, "");
  ArLog::log(ArLog::Terse, "Available data:");
  for (it = myIntDataMap.begin(); it != myIntDataMap.end(); it++)
  {
    clientData = (*it).second;
    ArLog::log(ArLog::Terse, "");
    ArLog::log(ArLog::Verbose, "Number %d, %d functors", 
               clientData->getCommand(),
               clientData->getFunctorList()->size());
    ArLog::log(ArLog::Terse, "Data: %s", clientData->getName());
    ArLog::log(ArLog::Terse, "\tDescription: %s",
               clientData->getDescription());
    ArLog::log(ArLog::Terse, "\tArgument: %s",
               clientData->getArgumentDescription());
    ArLog::log(ArLog::Terse, "\tReturn: %s",
               clientData->getReturnDescription());
    ArLog::log(ArLog::Terse, "\tCommandGroup: %s",
               clientData->getCommandGroup());
    ArLog::log(ArLog::Terse, "\tDataFlags: %s",
               clientData->getDataFlagsString());

  }
  myDataMutex.unlock();
}

AREXPORT void ArClientBase::addDisconnectOnErrorCB(ArFunctor *functor, 
                                                   ArListPos::Pos position)
{
  myCallbackMutex.lock();
  if (position == ArListPos::FIRST)
    myDisconnectOnErrorCBList.push_front(functor);
  else if (position == ArListPos::LAST)
    myDisconnectOnErrorCBList.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
               "ArClientBase::addDisconnectOnErrorCB: Invalid position");
  myCallbackMutex.unlock();
}

AREXPORT void ArClientBase::remDisconnectOnErrorCB(ArFunctor *functor)
{
  myCallbackMutex.lock();
  myDisconnectOnErrorCBList.remove(functor);
  myCallbackMutex.unlock();
}

AREXPORT void ArClientBase::addServerShutdownCB(ArFunctor *functor, 
                                                   ArListPos::Pos position)
{
  myCallbackMutex.lock();
  if (position == ArListPos::FIRST)
    myServerShutdownCBList.push_front(functor);
  else if (position == ArListPos::LAST)
    myServerShutdownCBList.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
               "ArClientBase::addServerShutdownCB: Invalid position");
  myCallbackMutex.unlock();
}

AREXPORT void ArClientBase::remServerShutdownCB(ArFunctor *functor)
{
  myCallbackMutex.lock();
  myServerShutdownCBList.remove(functor);
  myCallbackMutex.unlock();
}

AREXPORT void ArClientBase::setTcpOnlyFromServer(void)
{
  ArNetPacket packet;

  packet.setCommand(ArClientCommands::TCP_ONLY);
  sendPacketTcp(&packet);
  myDataMutex.lock();
  myTcpOnlyFrom = true;
  myDataMutex.unlock();
}

AREXPORT void ArClientBase::setTcpOnlyToServer(void)
{
  myDataMutex.lock();
  myTcpOnlyTo = true;
  myDataMutex.unlock();
}

AREXPORT bool ArClientBase::isTcpOnlyFromServer(void)
{
  bool ret;
  myDataMutex.lock();
  ret = myTcpOnlyFrom;
  myDataMutex.unlock();
  return ret;
}
  
AREXPORT bool ArClientBase::isTcpOnlyToServer(void)
{
  bool ret;
  myDataMutex.lock();
  ret = myTcpOnlyTo;
  myDataMutex.unlock();
  return ret;
}


AREXPORT ArTime ArClientBase::getLastPacketReceived(void) 
{
  ArTime ret;
  myDataMutex.lock();
  ret = myLastPacketReceived;
  myDataMutex.unlock();
  return ret;
}

AREXPORT const char *ArClientBase::getName(ArNetPacket *packet, 
                                           bool internalCall)
{
  return getName(packet->getCommand(), internalCall);
}

AREXPORT const char *ArClientBase::getName(unsigned int command,
                                           bool internalCall)
{
  const char *ret;
  if (!internalCall)
    myDataMutex.lock();
  std::map<unsigned int, ArClientData *>::iterator it;  
  if ((it = myIntDataMap.find(command)) == myIntDataMap.end())
    ret = NULL;
  else
    ret = (*it).second->getName(); 
  if (!internalCall)
    myDataMutex.unlock();
  return ret;
}

AREXPORT void ArClientBase::setServerKey(const char *serverKey, bool print)
{
  myDataMutex.lock();
  myServerKey = serverKey;
  myDataMutex.unlock();
  if (print)
    ArLog::log(ArLog::Normal, "New server key set");
}

AREXPORT void ArClientBase::getClientKey(unsigned char key[16])
{
  memcpy(key, myClientKey, 16);
}

AREXPORT const char *ArClientBase::getHost(void)
{
  const char *ret;
  myDataMutex.lock();
  ret = myHost.c_str();
  myDataMutex.unlock();
  return ret;
}

void ArClientBase::trackPacketSent(ArNetPacket *packet, bool tcp)
{
  myPacketTrackingMutex.lock();
  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();
  }
  myPacketTrackingMutex.unlock();
}

void ArClientBase::trackPacketReceived(ArNetPacket *packet, 
                                                  bool tcp)
{
  myPacketTrackingMutex.lock();
  if (myTrackingReceivedMap.find(packet->getCommand()) == 
      myTrackingReceivedMap.end())
    myTrackingReceivedMap[packet->getCommand()] = new Tracker;

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

AREXPORT void ArClientBase::logTracking(bool terse)
{
  myDataMutex.lock();
  myPacketTrackingMutex.lock();
  std::map<unsigned int, Tracker *>::iterator it;

  unsigned int command;
  Tracker *tracker = NULL;
  long seconds;

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

  const char *namePtr;
  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 (active %d seconds):", 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;

    if ((namePtr = getName(command, true)) != NULL && namePtr[0] != '\0')
      snprintf(name, sizeof(name), "%s", namePtr);
    // 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 %7ld udp rcvs %10ld udp B %7ld udp B/sec",
               "Low level Sockets Received", myTcpSocket.getRecvs(), 
               myTcpSocket.getBytesRecvd(), 
               myTcpSocket.getBytesRecvd()/seconds, myUdpSocket.getRecvs(), 
               myUdpSocket.getBytesRecvd(), 
               myUdpSocket.getBytesRecvd()/seconds);
  }

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

  ArLog::log(ArLog::Terse, "");
  ArLog::log(ArLog::Terse, "Sent tracking (active %d seconds):", 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;

    if ((namePtr = getName(command, true)) != NULL && namePtr[0] != '\0')
      snprintf(name, sizeof(name), "%s", namePtr);
    // 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 %7ld udp pkts %10ld udp B %7ld udp B/sec",
               "Low level Sockets Sent", myTcpSocket.getSends(), 
               myTcpSocket.getBytesSent(), 
               myTcpSocket.getBytesSent() / seconds, myUdpSocket.getSends(), 
               myUdpSocket.getBytesSent(), 
               myUdpSocket.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, "");
  myPacketTrackingMutex.unlock();
  myDataMutex.unlock();
}


AREXPORT void ArClientBase::resetTracking(void)
{
  myPacketTrackingMutex.lock();
  
  std::map<unsigned int, 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();
  myUdpSocket.resetTracking();
  myPacketTrackingMutex.unlock();
}

---