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


AREXPORT ArServerBase::ArServerBase(bool addAriaExitCB, 
                                    const char * serverName) :
  myProcessPacketCB(this, &ArServerBase::processPacket),
  mySendUdpCB(this, &ArServerBase::sendUdp),
  myAriaExitCB(this, &ArServerBase::close),
  myGetFrequencyCB(this, &ArServerBase::getFrequency, 0, true)
{
  if (serverName != NULL && serverName[0] > 0)
    myServerName = serverName;
  else
    myServerName = "ArNetServer";
  setThreadName("ArServerBase");
  myTcpPort = 0;
  myUdpPort = 0;
  myRejecting = 0;
  myOpened = false;
  myUdpReceiver.setProcessPacketCB(&myProcessPacketCB);
  myNextDataNumber = 256;
  myUserInfo = NULL;
  myAriaExitCB.setName("ArServerBaseExit");
  if (addAriaExitCB)
    Aria::addExitCallback(&myAriaExitCB, 20);
}

AREXPORT ArServerBase::~ArServerBase()
{
  close();
}

AREXPORT bool ArServerBase::open(unsigned int port, const char *openOnIP)
{
  myDataMutex.lock();
  myTcpPort = port;

  if (myTcpSocket.open(myTcpPort, ArSocket::TCP, openOnIP))
  {
    myTcpSocket.setLinger(0);
    myTcpSocket.setNonBlock();
  }
  else
  {
    myOpened = false;
    myDataMutex.unlock();
    return false;
  }

  if (myUdpSocket.create(ArSocket::UDP) &&
      myUdpSocket.findValidPort(myTcpPort, openOnIP) &&
      myUdpSocket.setNonBlock())
  {
 // not possible on udp?   myUdpSocket.setLinger(0);
    myUdpPort = ArSocket::netToHostOrder(myUdpSocket.inPort());
    myUdpReceiver.setSocket(&myUdpSocket);
    if (openOnIP != NULL)
      ArLog::log(ArLog::Normal, 
                 "%s started on tcp port %d and udp port %d on ip %s.", 
                 myServerName.c_str(), myTcpPort, myUdpPort, openOnIP);
    else
      ArLog::log(ArLog::Normal, "%s started on tcp port %d and udp port %d.", 
                 myServerName.c_str(), myTcpPort, myUdpPort);
  
  }
  else
  {
    myOpened = false;
    myTcpSocket.close();
    myDataMutex.unlock();
    return false;
  }
  myOpened = true;
  myDataMutex.unlock();
  return true;
}

AREXPORT void ArServerBase::close(void)
{
  std::list<ArServerClient *>::iterator it;
  ArServerClient *client;

  myClientsMutex.lock();
  if (!myOpened)
  {
    myClientsMutex.unlock();
    return;
  }

  ArLog::log(ArLog::Normal, "Server shutting down.");
  myOpened = false;
  // now send off the client packets to shut down
  for (it = myClients.begin(); it != myClients.end(); ++it)
  {
    client = (*it);
    client->shutdown();
    printf("Sending shutdown\n");
  }

  ArUtil::sleep(10);

  while ((it = myClients.begin()) != myClients.end())
  {
    client = (*it);
    myClients.pop_front();
    delete client;
  }
  myTcpSocket.close();
  myUdpSocket.close();
  myClientsMutex.unlock();
}

void ArServerBase::acceptTcpSockets(void)
{
  ArSocket socket;

  myClientsMutex.lock();

  // loop while we have new connections to make... we need to make a
  // udp auth key for any accepted sockets and send our introduction
  // to the client
  while (myTcpSocket.accept(&socket) && socket.getFD() >= 0)
  {
    finishAcceptingSocket(&socket, false);
  }
  myClientsMutex.unlock();
}

AREXPORT void ArServerBase::makeNewServerClientFromSocket(ArSocket *socket, 
                                                          bool doNotReject)
{
  myDataMutex.lock();
  finishAcceptingSocket(socket, true, doNotReject);
  myDataMutex.unlock();
}

AREXPORT void ArServerBase::finishAcceptingSocket(ArSocket *socket, 
                                                  bool skipPassword, 
                                                  bool doNotReject)
{
  ArServerClient *client;
  bool foundAuthKey;
  std::list<ArServerClient *>::iterator it;
  bool thisKeyBad;
  long authKey;
  long introKey;
  ArNetPacket packet;
  int iterations;

  ArLog::log(ArLog::Verbose, "New connection from %s", socket->getIPString());
  
  // okay, now loop until we find a key or until we've gone 10000
  // times (huge error but not worth locking up on)... basically
  // we're making sure that none of the current clients already have
  // this key... they should never have it if random is working
  // right... but...
  for (foundAuthKey = false, authKey = ArMath::random(), iterations = 0; 
       !foundAuthKey && iterations < 10000;
       iterations++, authKey = ArMath::random())
  {
    // see if any of the current clients have this authKey
    for (thisKeyBad = false, it = myClients.begin(); 
         !thisKeyBad && it != myClients.end();
         ++it)
    {
      if (authKey == (*it)->getAuthKey())
        thisKeyBad = true;
    }
    // if the key wasn't found above it means its clean, so we found
    // a good one and are done
    if (!thisKeyBad)
      foundAuthKey = true;
  }
  if (!foundAuthKey)
    authKey = 0;
  // now we pick an introKey which introduces the server to the client
  // this one isn't critical that it be unique though, so we just
  // set it straight out
  introKey = ArMath::random();
  std::string passwordKey;
  int numInPasswordKey = ArMath::random() % 100;
  int i;
  passwordKey = "";
  if (!skipPassword)
  {
    for (i = 0; i < numInPasswordKey; i++)
      passwordKey += '0' + ArMath::random() % ('z' - '0');
  }
  int reject;
  const char *rejectString;
  if (doNotReject)
  {
    reject = 0;
    rejectString = "";
  }
  else
  {
    reject = myRejecting;
    rejectString = myRejectingString.c_str();
  }
  client = new ArServerClient(socket, myUdpPort, authKey, introKey,
                              &mySendUdpCB, &myDataMap, 
                              passwordKey.c_str(), myServerKey.c_str(),
                              myUserInfo, reject, rejectString);
  // put the client onto our list of clients...
  myClients.push_front(client);
}

AREXPORT int ArServerBase::getNumClients(void)
{
  int ret;
  myClientsMutex.lock();
  ret = myClients.size();
  myClientsMutex.unlock();
  return ret;
}

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

AREXPORT void ArServerBase::runAsync(void)
{
  create();
}

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


AREXPORT bool ArServerBase::broadcastPacketTcp(ArNetPacket *packet, 
                                               const char *name)
{
  return broadcastPacketTcpWithExclusion(packet, name, NULL);
}

AREXPORT bool ArServerBase::broadcastPacketTcpWithExclusion(
        ArNetPacket *packet, const char *name, ArServerClient *excludeClient)
{
  // first find our number so each client doesn't have to
  std::map<unsigned int, ArServerData *>::iterator it;  
  unsigned int command;
  
  myDataMutex.lock();  
  for (it = myDataMap.begin(); it != myDataMap.end(); it++)
  {
    if (!strcmp((*it).second->getName(), name))
      command = (*it).second->getCommand();
  }  
  if (command == 0)
  {
    ArLog::log(ArLog::Terse, "ArServerBase::broadcastPacket: no command by name of \"%s\"", name);
    myDataMutex.unlock();  
    return false;
  }
  myDataMutex.unlock();  
  return broadcastPacketTcpByCommandWithExclusion(packet, command, 
                                                  excludeClient);
}

AREXPORT bool ArServerBase::broadcastPacketTcpByCommand(
        ArNetPacket *packet, unsigned int command)
{
  return broadcastPacketTcpByCommandWithExclusion(packet, command, NULL);
}

AREXPORT bool ArServerBase::broadcastPacketTcpByCommandWithExclusion(
        ArNetPacket *packet, unsigned int command, 
        ArServerClient *excludeClient)
{
  std::list<ArServerClient *>::iterator lit;

  ArNetPacket emptyPacket;

  myClientsMutex.lock();  
  emptyPacket.empty();

  if (!myOpened)
  {
    ArLog::log(ArLog::Verbose, "ArServerBase::broadcastPacket: server not open to send packet.");
    myClientsMutex.unlock();  
    return false;
  }

  if (packet == NULL)
    packet = &emptyPacket;

  packet->setCommand(command);
  for (lit = myClients.begin(); lit != myClients.end(); ++lit)
  {
    if (excludeClient == NULL || (*lit) != excludeClient)
      (*lit)->broadcastPacketTcp(packet);
  }

  myClientsMutex.unlock();  
  return true;
}

AREXPORT bool ArServerBase::broadcastPacketUdp(ArNetPacket *packet, 
                                               const char *name)
{
  return broadcastPacketUdpWithExclusion(packet, name, NULL);
}

AREXPORT bool ArServerBase::broadcastPacketUdpWithExclusion(
        ArNetPacket *packet, const char *name, ArServerClient *excludeClient)
{
  // first find our number so each client doesn't have to
  std::map<unsigned int, ArServerData *>::iterator it;  
  unsigned int command = 0;

  myDataMutex.lock();  
  for (it = myDataMap.begin(); it != myDataMap.end(); it++)
  {
    if (!strcmp((*it).second->getName(), name))
      command = (*it).second->getCommand();
  }  
  if (command == 0)
  {
    ArLog::log(ArLog::Terse, "ArServerBase::broadcastPacket: no command by name of \"%s\"", name);
    myDataMutex.unlock();  
    return false;
  }
  myDataMutex.unlock();  
  return broadcastPacketUdpByCommandWithExclusion(packet, command, 
                                                  excludeClient);
}

AREXPORT bool ArServerBase::broadcastPacketUdpByCommand(
        ArNetPacket *packet, unsigned int command)
{
  return broadcastPacketUdpByCommandWithExclusion(packet, command, NULL);
}

AREXPORT bool ArServerBase::broadcastPacketUdpByCommandWithExclusion(
        ArNetPacket *packet, unsigned int command,
        ArServerClient *excludeClient)
{
  std::list<ArServerClient *>::iterator lit;
  ArNetPacket emptyPacket;

  myClientsMutex.lock();    
  emptyPacket.empty();

  if (!myOpened)
  {
    ArLog::log(ArLog::Verbose, "ArServerBase::broadcastPacket: server not open to send packet.");
    myClientsMutex.unlock();  
    return false;
  }

  if (packet == NULL)
    packet = &emptyPacket;

  packet->setCommand(command);
  for (lit = myClients.begin(); lit != myClients.end(); ++lit)
  {
    if (excludeClient == NULL || (*lit) != excludeClient)
      (*lit)->broadcastPacketUdp(packet);
  }
  myClientsMutex.unlock();  
  return true;
}

AREXPORT unsigned int ArServerBase::findCommandFromName(const char *name)
{
  // first find our number so each client doesn't have to
  std::map<unsigned int, ArServerData *>::iterator it;  
  unsigned int num = 0;
  myDataMutex.lock();    

  for (it = myDataMap.begin(); it != myDataMap.end(); it++)
  {
    if (!strcmp((*it).second->getName(), name))
      num = (*it).second->getCommand();
  }  
  if (num == 0)
  {
    ArLog::log(ArLog::Verbose, "ArServerBase::findCommandFromName: no command by name of \"%s\"", name);
    myDataMutex.unlock();  
    return 0;
  }
  myDataMutex.unlock();  
  return num;
}

AREXPORT void ArServerBase::loopOnce(void)
{
  std::list<ArServerClient *>::iterator it;
  // for speed we'd use a list of iterators and erase, but for clarity
  // this is easier and this won't happen that often
  std::list<ArServerClient *> removeList;
  ArServerClient *client;

  myDataMutex.lock();  
  if (!myOpened)
  {
    myDataMutex.unlock();
    return;
  }
  myDataMutex.unlock();
  acceptTcpSockets();

  myUdpReceiver.readData();

  // need a recursive lock before we can lock here but we should be
  //okay without a lock here (and have been for ages)
  //myClientsMutex.lock(); first let the clients handle new data
  for (it = myClients.begin(); it != myClients.end(); ++it)
  {
    client = (*it);
    if (!client->tcpCallback())
    {
      removeList.push_front(client);
    }
  }
  while ((it = removeList.begin()) != removeList.end())
  {
    client = (*it);
    myClients.remove(client);
    for (std::list<ArFunctor1<ArServerClient*> *>::iterator rci = myClientRemovedCallbacks.begin();
         rci != myClientRemovedCallbacks.end();
         rci++) {
      if (*rci) {
        (*rci)->invoke(client);
      }
    }

    delete client;
    removeList.pop_front();
  }
  // now let the clients send off their packets
  for (it = myClients.begin(); it != myClients.end(); ++it)
  {
    client = (*it);
    client->handleRequests();
  }
  // need a recursive lock before we can lock here but we should be
  //okay without a lock here (and have been for ages)
  //myClientsMutex.unlock();
  myCycleCallbacksMutex.lock();
  // call cycle callbacks
  for(std::list<ArFunctor*>::const_iterator f = myCycleCallbacks.begin();
          f != myCycleCallbacks.end(); f++) 
  {
    if(*f) (*f)->invoke();
  }
  myCycleCallbacksMutex.unlock();
}

AREXPORT void ArServerBase::processPacket(ArNetPacket *packet, struct sockaddr_in *sin)
{
  std::list<ArServerClient *>::iterator it;
  unsigned char *bytes = (unsigned char *)&sin->sin_addr.s_addr;
  ArServerClient *client;
  struct sockaddr_in *clientSin;

  myClientsMutex.lock();
  // if its a udp packet then see if we have its owner
  if (packet->getCommand() == ArClientCommands::UDP_INTRODUCTION)
  {
    long authKey;
    bool matched;

    authKey = packet->bufToUByte4();
    for (matched = false, it = myClients.begin();
         !matched && it != myClients.end(); ++it)
    {
      client = (*it);
      if (client->getAuthKey() == authKey)
      {
        packet->resetRead();
        client->processAuthPacket(packet, sin);
      }
    }
    myClientsMutex.unlock();
    return;
  }

  // it wasn't the introduction so handle it the normal way

  // walk through our list of clients and see if it was one of them,
  // if so return
  for (it = myClients.begin(); it != myClients.end(); ++it)
  {
    client = (*it);
    clientSin = client->getUdpAddress();
    if (clientSin->sin_port == sin->sin_port &&
        clientSin->sin_addr.s_addr == sin->sin_addr.s_addr)
    {
      client->processPacket(packet, false);
      myClientsMutex.unlock();
      return;
    }
  }
  // if it wasn't one of our clients it was from somewhere bogus
  printf("UDP Packet from bogus source %d.%d.%d.%d %d\n", bytes[0], 
         bytes[1], bytes[2], bytes[3], 
         ArSocket::netToHostOrder(sin->sin_port));
  myClientsMutex.unlock();
}

AREXPORT bool ArServerBase::sendUdp(ArNetPacket *packet, struct sockaddr_in *sin)
{
  bool ret;
  // this doesn't lock since it should only be called from 
  ret = myUdpSocket.sendTo(packet->getBuf(), packet->getLength(), sin);
  return ret;
}

AREXPORT bool ArServerBase::addData(
        const char *name, const char *description,
        ArFunctor2<ArServerClient *, ArNetPacket *> * functor,
        const char *argumentDescription, const char *returnDescription, 
        const char *commandGroup, const char *dataFlags)
{
  return addDataAdvanced(name, description, functor, argumentDescription, 
                  returnDescription, commandGroup, dataFlags);
}

AREXPORT bool ArServerBase::addDataAdvanced(
        const char *name, const char *description,
        ArFunctor2<ArServerClient *, ArNetPacket *> * functor,
        const char *argumentDescription, const char *returnDescription, 
        const char *commandGroup, const char *dataFlags,
        unsigned int advancedCommandNumber,
        ArFunctor2<long, unsigned int> *requestChangedFunctor, 
        ArFunctor2<ArServerClient *, ArNetPacket *> *requestOnceFunctor)
{
  ArServerData *serverData;
  std::map<unsigned int, ArServerData *>::iterator it;

  myDataMutex.lock();

  //printf("%s %s\n", name, description);
  // if we already have one we can't do this
  for (it = myDataMap.begin(); it != myDataMap.end(); it++)
  {
    if (!strcmp((*it).second->getName(), name))
    {
      ArLog::log(ArLog::Verbose, "ArServerBase::addData: already have data for name \"%s\", could not add it.", name);
      myDataMutex.unlock();
      return false;
    }
  }
  ArLog::log(ArLog::Verbose, "ArServerBase::addData: name \"%s\" mapped to number %d", name, myNextDataNumber);
  if (advancedCommandNumber != 0)
  {
    if (advancedCommandNumber < myNextDataNumber)
    {
      ArLog::log(ArLog::Normal, "ArServerBase::addData: Advanced command number given for %s but the number is too low, it wasn't added", name);
      myDataMutex.unlock();
      return false;
    }
    else
      myNextDataNumber = advancedCommandNumber;
  }
  serverData = new ArServerData(name, description, myNextDataNumber,
                                functor, argumentDescription, 
                                returnDescription, commandGroup, dataFlags,
                                &myGetFrequencyCB, requestChangedFunctor, 
                                requestOnceFunctor);
  if (myAdditionalDataFlags.size() > 0)
    serverData->addDataFlags(myAdditionalDataFlags.c_str());
  myDataMap[myNextDataNumber] = serverData;
  myNextDataNumber++;
  myDataMutex.unlock();
  return true;
}


AREXPORT void ArServerBase::addCycleCallback(ArFunctor* functor)
{
  myCycleCallbacksMutex.lock();
  myCycleCallbacks.push_back(functor);
  myCycleCallbacksMutex.unlock();
}

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

AREXPORT void ArServerBase::addClientRemovedCallback(ArFunctor1<ArServerClient *> *functor)
{
  myDataMutex.lock();
  myClientRemovedCallbacks.push_back(functor);
  myDataMutex.unlock();
}

AREXPORT void ArServerBase::remClientRemovedCallback(ArFunctor1<ArServerClient *> *functor)
{
  myDataMutex.lock();
  myClientRemovedCallbacks.remove(functor);
  myDataMutex.unlock();
}


AREXPORT bool ArServerBase::loadUserInfo(const char *fileName,
                                         const char *baseDirectory)
{
  if (myUserInfo != NULL)
  {
    delete myUserInfo;
    myUserInfo = NULL;
  }
  ArServerUserInfo *userInfo = new ArServerUserInfo;
  userInfo->setBaseDirectory(baseDirectory);
  if (!userInfo->readFile(fileName))
  {
    ArLog::log(ArLog::Terse, "ArServerBase::loadUserInfo: Could not load user info for %s", myServerName.c_str());
    delete userInfo;
    return false;
  }
  if (!userInfo->doNotUse())
  {
    ArLog::log(ArLog::Normal, "Loaded user information for %s",
               myServerName.c_str());
    myDataMutex.lock();
    myUserInfo = userInfo;
    myDataMutex.unlock();
  }
  else
  {
    ArLog::log(ArLog::Normal, 
               "Loaded user information for %s but not using it",
               myServerName.c_str());
    delete userInfo;
  }
  return true;
}

AREXPORT void ArServerBase::logUserInfo(void)
{
  myDataMutex.lock();
  if (myUserInfo == NULL)
    ArLog::log(ArLog::Terse, 
               "No user name or password needed to connect to %s",
               myServerName.c_str());
  else
    myUserInfo->logUsers();
  myDataMutex.unlock();
}

AREXPORT void ArServerBase::logCommandGroups(void)
{
  logCommandGroupsToFile(NULL);
}

AREXPORT void ArServerBase::logCommandGroupsToFile(const char *fileName)
{
  std::map<unsigned int, ArServerData *>::iterator dit;

  std::multimap<std::string, std::string> groups;
  std::multimap<std::string, std::string>::iterator git;

  myDataMutex.lock();
  for (dit = myDataMap.begin(); dit != myDataMap.end(); dit++)
  {
    std::string group;
    std::string command;
    command = (*dit).second->getName();
    if ((*dit).second->getCommandGroup() == NULL)
      group = "";
    else
      group = (*dit).second->getCommandGroup();
    
    groups.insert(std::pair<std::string, std::string>(group, command));
  }

  FILE *file = NULL;
  if (fileName != NULL)
  {
    file = fopen(fileName, "w");
  }

  char descLine[10000];
  std::string line;
  std::string lastGroup;
  bool first = true;
  bool firstGroup = true;
  std::map<std::string, std::string>::iterator dIt; 
  std::string listOfGroups = "Groups";

  for (git = groups.begin(); git != groups.end(); git++)
  {
    if (ArUtil::strcasecmp((*git).first, lastGroup) != 0 || firstGroup)
    {
      if (!firstGroup)
      {
        if (file != NULL)
          fprintf(file, "%s", line.c_str());
        else
          ArLog::log(ArLog::Terse, "%s", line.c_str());
      }
      first = true;
      firstGroup = false;
      lastGroup = (*git).first;
      listOfGroups += " ";
      if (lastGroup.size() == 0)
        listOfGroups += "None";
      else
        listOfGroups += lastGroup;
    }
    if (first)
    {
      line = "CommandGroup ";
      if ((*git).first.size() == 0)
      {
        line += "None";
      }
      else
      {
        // output the groups description if therei s one
        if ((dIt = myGroupDescription.find((*git).first)) != 
            myGroupDescription.end())
          snprintf(descLine, sizeof(descLine), 
                   "CommandGroup %s has description %s", 
                   (*git).first.c_str(), (*dIt).second.c_str());
        else
          snprintf(descLine, sizeof(descLine), 
                   "CommandGroup %s has no description", 
                   (*git).first.c_str());
        if (file != NULL)
          fprintf(file, "%s\n", descLine);
        else
          ArLog::log(ArLog::Terse, "%s", descLine);

        line += (*git).first.c_str();
      }
      line += " is";


      }
    line += " ";
    line += (*git).second.c_str();
    first = false;
  }
  if (!firstGroup && !first)
  {
    if (file != NULL)
      fprintf(file, "%s\n", line.c_str());
    else
      ArLog::log(ArLog::Terse, "%s", line.c_str());
  }
  if (file != NULL)
    fprintf(file, "%s\n", listOfGroups.c_str());
  else
    ArLog::log(ArLog::Terse, "%s", listOfGroups.c_str());
  myDataMutex.unlock();
}


AREXPORT void ArServerBase::setGroupDescription(const char *cmdGrpName, const char *cmdGrpDesc)
{
  myDataMutex.lock();
  myGroupDescription.insert(std::pair<std::string, std::string>(cmdGrpName, cmdGrpDesc));
  myDataMutex.unlock();
}





//   Created:  17-Nov-2005                                                 //
//   Purpose:  
//   Notes:                                                                //
//             Assumption: Command Group Name Map exists already.          //
//                                                                         //
//   Revision History:                                                     //
//      WHEN       WHO         WHAT and/or WHY                             //
//   17-Nov-2005   NJ    Created this function.                            //

AREXPORT void ArServerBase::logGroupDescriptions(void)
{
  // -- This wrapper insures that NULL is the only input passed to the
  //    logCommandGroupNamesToFile routine.   
  //    This is used if the log is desired over a filename.  
  logGroupDescriptionsToFile(NULL);     // NULL is the only value passed.
}

AREXPORT void ArServerBase::logGroupDescriptionsToFile(const char *fileName)
{ 
  myDataMutex.lock();
  std::map<std::string, std::string>::iterator d_itr;   // establish map iterator               
  char line[1024];
  FILE *file = NULL;
  if (fileName != NULL)
    file = fopen(fileName, "w");                        // open file if exists

  // -- Assemble output strings and send to file or log
  for (d_itr = myGroupDescription.begin(); d_itr != myGroupDescription.end(); d_itr++)
  {
    snprintf(line, sizeof(line), "%-29s %s", (*d_itr).first.c_str(), (*d_itr).second.c_str());
    
    if (file != NULL)
      fprintf(file, "%s\n", line);              // send string to file
    else
      ArLog::log(ArLog::Terse, "%s", line);     // send string to log
  }
  if (fileName != NULL)                 // task complete notification
    fclose (file);
  myDataMutex.unlock();
}       



AREXPORT void ArServerBase::setServerKey(const char *serverKey)
{
  myDataMutex.lock();
  // if this is setting it to empty and its already empty don't print
  // a message
  if ((serverKey == NULL || serverKey[0] == '\0') && myServerKey.size() > 0)
    ArLog::log(ArLog::Normal, "Clearing server key");
  if (serverKey != NULL && serverKey[0] != '\0')
    ArLog::log(ArLog::Normal, "Setting new server key");
  if (serverKey != NULL)
    myServerKey = serverKey;
  else
    myServerKey = "";
  myDataMutex.unlock();
}

AREXPORT void ArServerBase::rejectSinceUsingCentralServer(
        const char *centralServerIPString)
{
  myDataMutex.lock();
  myRejecting = 2;
  myRejectingString = centralServerIPString;
  myDataMutex.unlock();
}

AREXPORT void ArServerBase::logTracking(bool terse)
{
  std::list<ArServerClient *>::iterator lit;

  myClientsMutex.lock();  

  for (lit = myClients.begin(); lit != myClients.end(); ++lit)
    (*lit)->logTracking(terse);

  ArLog::log(ArLog::Terse, "");
  
  if (!terse)
  {
    ArLog::log(ArLog::Terse, "%-85s %7ld udp rcvs %10ld udp B",
               "Low Level UDP Received (all conns)", myUdpSocket.getRecvs(), 
               myUdpSocket.getBytesRecvd());
    ArLog::log(ArLog::Terse, "%-85s %7ld udp snds %10ld udp B",
               "Low Level UDP Sent (all conns)", myUdpSocket.getSends(), 
               myUdpSocket.getBytesSent());

    ArLog::log(ArLog::Terse, "");
  }
  myClientsMutex.unlock();  
}

AREXPORT void ArServerBase::resetTracking(void)
{
  std::list<ArServerClient *>::iterator lit;

  myClientsMutex.lock();  

  for (lit = myClients.begin(); lit != myClients.end(); ++lit)
    (*lit)->resetTracking();
  myClientsMutex.unlock();  
  myDataMutex.lock();
  myUdpSocket.resetTracking();
  myDataMutex.unlock();
}

AREXPORT const ArServerUserInfo* ArServerBase::getUserInfo(void) const
{
  return myUserInfo;
}

AREXPORT void ArServerBase::setUserInfo(const ArServerUserInfo *userInfo)
{
  myDataMutex.lock();
  myUserInfo = userInfo;
  myDataMutex.unlock();
}
AREXPORT long ArServerBase::getFrequency(unsigned int command,
                                         bool internalCall)
{
  std::list<ArServerClient *>::iterator it;
  long ret = -2;
  long clientFreq;

  if (!internalCall)
    myClientsMutex.lock();
  
  for (it = myClients.begin(); it != myClients.end(); it++)
  {
    clientFreq = (*it)->getFrequency(command);
    // if the ret is an interval and so is this client but this client
    // is a smalelr interval
    if (clientFreq >= 0 && (ret < 0 || (ret >= 0 && clientFreq < ret)))
      ret = clientFreq;
    // if this client just wants the data when pushed but ret is still
    // at never then set it to when pushed
    else if (clientFreq == -1 && ret == -2)
      ret = -1;
  }
  
  if (!internalCall)
    myClientsMutex.unlock();

  return ret;
}

AREXPORT void ArServerBase::setAdditionalDataFlags(
        const char *additionalDataFlags)
{
  myDataMutex.lock();
  if (additionalDataFlags == NULL || additionalDataFlags[0] == '\0')
    myAdditionalDataFlags = "";
  else  
    myAdditionalDataFlags = additionalDataFlags;
  myDataMutex.unlock();
}


AREXPORT bool ArServerBase::dataHasFlag(const char *name, 
                                        const char *dataFlag)
{
  unsigned int command;
  if ((command = findCommandFromName(name)) == 0)
  {
    ArLog::log(ArLog::Verbose, 
           "ArServerBase::dataHasFlag: %s is not data that is on the server", 
               name);
    return false;
  }

  return dataHasFlagByCommand(findCommandFromName(name), dataFlag);
}

AREXPORT bool ArServerBase::dataHasFlagByCommand(unsigned int command, 
                                                 const char *dataFlag)
{
  std::map<unsigned int, ArServerData *>::iterator dIt;
  bool ret;

  myDataMutex.lock();
  if ((dIt = myDataMap.find(command)) == myDataMap.end())
    ret = false;
  else
    ret = (*dIt).second->hasDataFlag(dataFlag);
  myDataMutex.unlock();
  
  return ret;
}

AREXPORT unsigned int ArServerBase::getTcpPort(void)
{
  return myTcpPort;
}

AREXPORT unsigned int ArServerBase::getUdpPort(void)
{
  return myUdpPort;  
}

---