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

#ifndef WIN32
#include "Aria.h"
#include "ArExport.h"
#include "ArServerFileUtils.h"

#include <sys/types.h>
#include <dirent.h>
#include <ctype.h>

AREXPORT bool ArServerFileUtil::squashCase(const char *baseDir, 
                                           const char *fileName,
                                           char *result,
                                           size_t resultLen)
{
  DIR *dir;
  struct dirent *ent;

  char separator;  
#ifndef WIN32
  separator = '/';
#else
  separator = '\\';
#endif

  result[0] = '\0';
  std::list<std::string> split;
  split = splitFileName(fileName);
  std::list<std::string>::iterator it;
  std::string finding;

  /*
  for (it = split.begin(); it != split.end(); it++)
  {
    printf("@@@@@@@@ %s\n", (*it).c_str());
  }
  */
  it = split.begin();
  finding = (*it);
  
  // how this works is we start at the base dir then read through
  // until we find what the next name we need, if entry is a directory
  // and we're not at the end of our string list then we change into
  // that dir and the while loop keeps going, if the entry isn't a
  // directory and matchs and its the last in our string list we've
  // found what we want
  if ((dir = opendir(baseDir)) == NULL)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerFileUtil: No such directory '%s' for base", 
               baseDir);
    return false;
  }

  while ((ent = readdir(dir)) != NULL)
  {
    // ignore some of these
    if (ent->d_name[0] == '.')
    {
      //printf("Ignoring %s\n", ent->d_name[0]);
      continue;
    }
    //printf("NAME %s finding %s\n", ent->d_name, finding.c_str());
    
    // we've found what we were looking for
    if (ArUtil::strcasecmp(ent->d_name, finding) == 0)
    {
      size_t lenOfResult;
      lenOfResult = strlen(result);

      // make sure we can put the filename in
      if (strlen(ent->d_name) > resultLen - lenOfResult - 2)
      {
        ArLog::log(ArLog::Normal, 
                   "ArServerFileUtil::squashCase: result not long enough");
          return false;
      }
      //printf("Before %s", result);
      if (lenOfResult != 0)
      {
        result[lenOfResult] = separator;
        result[lenOfResult+1] = '\0';
      }
      // put the filename in
      strcpy(&result[strlen(result)], ent->d_name);
      //printf("after %s\n", result);
      // see if we're at the end
      it++;
      if (it != split.end())
      {
        //printf("Um.........\n");
        finding = (*it);
        std::string wholeDir;
        wholeDir = baseDir;
        wholeDir += result;
        //printf("'%s' '%s' '%s'\n", baseDir, result, wholeDir.c_str());
        if ((dir = opendir(wholeDir.c_str())) == NULL)
        {
          ArLog::log(ArLog::Normal, 
                     "ArServerFileUtil::squashCase: Error going into %s", 
                     result);
          return false;
        }
      }
      else
      {
        //printf("\n########## Got it %s\n", result);
        return true;
      }
    }
  }
  ArLog::log(ArLog::Verbose, 
             "ArServerFileUtil::squashCase: %s doesn't exist in %s", fileName, 
             baseDir);
  return false;
} 

AREXPORT bool ArServerFileUtil::getDirectory(const char *fileName, 
                                             char *result, size_t resultLen)
{
  char separator;  
#ifndef WIN32
  separator = '/';
#else
  separator = '\\';
#endif
  
  if (fileName == NULL || fileName[0] == '\0' || resultLen == 0)
  {
    ArLog::log(ArLog::Normal, "ArServerFileUtil: getDirectory, bad setup");
    return false;
  }
  
  // just play in the result buffer
  strncpy(result, fileName, resultLen - 1);
  // make sure its nulled
  result[resultLen - 1] = '\0';
  char *toPos;
  ArUtil::fixSlashes(result, resultLen);
  // see where the last directory is
  toPos = strrchr(result, separator);
  // if there's no divider it must just be a file name
  if (toPos == NULL)
  {
    result[0] = '\0';
    return true;
  }
  // otherwise just toss a null into the last separator and we're done
  else
  {    
    *toPos = '\0';
    return true;
  }
}

AREXPORT bool ArServerFileUtil::getFileName(const char *fileName, 
                                         char *result, size_t resultLen)
{
  char separator;  
#ifndef WIN32
  separator = '/';
#else
  separator = '\\';
#endif
  
  if (fileName == NULL || fileName[0] == '\0' || resultLen == 0)
  {
    ArLog::log(ArLog::Normal, "ArServerFileUtil: getFileName, bad setup");
    return false;
  }

  char *str;
  size_t fileNameLen = strlen(fileName);
  str = new char[fileNameLen + 1];
  //printf("0 %s\n", fileName);
  // just play in the result buffer
  strncpy(str, fileName, fileNameLen);
  // make sure its nulled
  str[fileNameLen] = '\0';
  //printf("1 %s\n", str);

  char *toPos;
  ArUtil::fixSlashes(str, fileNameLen + 1);
  //printf("2 %s\n", str);
  // see where the last directory is
  toPos = strrchr(str, separator);
  // if there's no divider it must just be a file name
  if (toPos == NULL)
  {
    // copy the filename in and make sure it has a null
    strncpy(result, str, resultLen - 1);
    result[resultLen - 1] = '\0';
    //printf("3 %s\n", result);
    return true;
  }
  // otherwise take the section from that separator to the end
  else
  {
    strncpy(result, &str[toPos - str + 1], resultLen - 2);
    result[resultLen - 1] = '\0';
    //printf("4 %s\n", result);

    return true;
  }
}

std::list<std::string> ArServerFileUtil::splitFileName(
        const char *fileName)
{
  std::list<std::string> split;
  if (fileName == NULL)
    return split;

  char separator;  
#ifndef WIN32
  separator = '/';
#else
  separator = '\\';
#endif

  size_t len;
  size_t i;
  size_t last;
  bool justSepped;
  char entry[2048];
  for (i = 0, justSepped = false, last = 0, len = strlen(fileName); 
       ; 
       i++)
  {
    
    if ((fileName[i] == separator && !justSepped) 
        || fileName[i] == '\0' || i >= len)
    {
      if (i - last > 2047)
      {
        ArLog::log(ArLog::Normal, "ArServerFileUtil::splitFileName: some directory or file too long");
      }
      if (!justSepped)
      {
        strncpy(entry, &fileName[last], i - last);
        entry[i-last] = '\0';
        split.push_back(entry);
        justSepped = true;
      }
      if (fileName[i] == '\0' || i >= len)
        return split;
    }
    else if (fileName[i] == separator && justSepped)
    {
      justSepped = true;
      last = i;
    }
    else if (fileName[i] != separator && justSepped)
    {
      justSepped = false;
      last = i;
    }
  }
  ArLog::log(ArLog::Normal, "ArServerFileUtil::splitFileName: file str ('%s') happened weird", fileName);
  return split;
}

AREXPORT ArServerFileLister::ArServerFileLister(ArServerBase *server, 
                                                const char *topDir) :
  myGetDirListingCB(this, &ArServerFileLister::getDirListing)
{
  myServer = server;
  myServer->addData("getDirListing", 
                    "Gets the directory listing of a given directory (from the current working directory), you should probably use a class from ArClientFileUtils instead of calling this directly",
                    &myGetDirListingCB, "string: directory to get listing of",
                    "ubyte2: return code, 0 = good, 1 = tried to go outside allowed area, 2 = no such directory (or can't read); string: directoryListed;  IF return was 0 then ubyte2: numDirectories; repeating numDirectories (string: name; ubyte4: access_time; ubyte4: modified_time); ubyte2: numFiles; repeating numFiles (string: name; ubyte4: access_time; ubyte4: modified_time);", 
                    "FileAccess", "RETURN_SINGLE");

  // snag our base dir and make sure we have enough room for a /
  strncpy(myBaseDir, topDir, sizeof(myBaseDir) - 2);
  myBaseDir[sizeof(myBaseDir) - 2] = '\0';
  // make sure it has a slash
  ArUtil::appendSlash(myBaseDir, sizeof(myBaseDir));
  // make sure the slashes go the right direction
  ArUtil::fixSlashes(myBaseDir, sizeof(myBaseDir));  
}

AREXPORT ArServerFileLister::~ArServerFileLister()
{

}

AREXPORT void ArServerFileLister::getDirListing(ArServerClient *client,
                                                ArNetPacket *packet)
{
  ArNetPacket sendPacket;
  size_t ui;
  size_t len;

  bool printing = false;

  char directory[2048];
  packet->bufToStr(directory, sizeof(directory));
  
  if (printing)
    printf("'%s' requested\n", directory);
  len = strlen(directory);
  // first advance to the first non space
  for (ui = 0; 
       ui < len && directory[ui] != '\0' && isspace(directory[ui]); 
       ui++);

  char *dirStr = new char[len + 3];

  // now copy in the rest
  strncpy(dirStr, directory, len - ui);
  // make sure its null terminated
  dirStr[len - ui] = '\0';
    
  if (dirStr[0] == '/' || dirStr[0] == '~' ||
      dirStr[0] == '\\' || strstr(dirStr, "..") != NULL)
  {
    ArLog::log(ArLog::Normal, "ArServerFileLister: '%s' tried to access outside allowed area", dirStr);
    delete[] dirStr;
    sendPacket.uByte2ToBuf(1);
    // put in the directory name
    sendPacket.strToBuf(directory);
    if (client != NULL)
      client->sendPacketTcp(&sendPacket);
    return;
  }

  // if its not empty make sure its set up right
  if (strlen(dirStr) > 0)
  {
    // make sure it has a slash
    ArUtil::appendSlash(dirStr, len + 2);
    // make sure the slashes go the right direction
    ArUtil::fixSlashes(dirStr, len + 2);
  }

  // put our base and where we want to go together
  std::string wholeDir;
  wholeDir = myBaseDir;
  wholeDir += dirStr;

  DIR *dir;
  struct dirent *ent;
  struct stat statBuf;
  std::set<std::string, ArStrCaseCmpOp> dirs;
  std::map<std::string, ArTypes::UByte4> dirToATime;
  std::map<std::string, ArTypes::UByte4> dirToMTime;
  std::map<std::string, ArTypes::UByte4> dirToSize;
  std::set<std::string, ArStrCaseCmpOp> files;
  std::map<std::string, ArTypes::UByte4> fileToATime;
  std::map<std::string, ArTypes::UByte4> fileToMTime;
  std::map<std::string, ArTypes::UByte4> fileToSize;
  std::set<std::string, ArStrCaseCmpOp>::iterator it;
  std::string str;
  
  if ((dir = opendir(wholeDir.c_str())) == NULL)
  {
    ArLog::log(ArLog::Normal, "ArServerFileLister: No such directory '%s' from base '%s' plus directory '%s'", 
               directory, myBaseDir, dirStr);
    delete[] dirStr;
    sendPacket.uByte2ToBuf(2);
    // put in the directory name
    sendPacket.strToBuf(directory);
    if (client != NULL)
      client->sendPacketTcp(&sendPacket);
    return;
  }
  while ((ent = readdir(dir)) != NULL)
  {
    // this works because if the first one goes it short circuits the second
    if ((it = dirs.find(ent->d_name)) != dirs.end() || 
        (it = files.find(ent->d_name)) != files.end())
    {
      ArLog::log(ArLog::Normal, 
                 "ArServerFileLister: %s duplicates '%s'", 
                 ent->d_name, (*it).c_str());
      continue;
    }      
    if (ent->d_name[0] == '.')
      continue;
    str = wholeDir.c_str();
    str += ent->d_name;
    if (printing)
      printf("name %s\n", str.c_str());
    if (stat(str.c_str(), &statBuf) == 0)
    {
      if (S_ISREG(statBuf.st_mode))
      {
        files.insert(ent->d_name);
        fileToATime[ent->d_name] = statBuf.st_atime;
        fileToMTime[ent->d_name] = statBuf.st_mtime;
        fileToSize[ent->d_name] = statBuf.st_size;
        //printf("File %s\n", ent.d_name);
      }
      if (S_ISDIR(statBuf.st_mode))
      {
        dirs.insert(ent->d_name);
        dirToATime[ent->d_name] = statBuf.st_atime;
        dirToMTime[ent->d_name] = statBuf.st_mtime;
        dirToSize[ent->d_name] = statBuf.st_size;
        //printf("Dir %s\n", ent.d_name);
      }
    }
    else
    {
      ArLog::log(ArLog::Normal, "Cannot stat %s in %s", ent->d_name, wholeDir.c_str());
    }
  }
  // we got here so the return is 0 (good)
  sendPacket.uByte2ToBuf(0);
  // put in the directory name
  sendPacket.strToBuf(directory);
  if (printing)
    printf("Sending %s\n", directory);
  if (printing)
    printf("Dirs:\n");
  // put in how many directories we have
  sendPacket.uByte2ToBuf(dirs.size());
  for (it = dirs.begin(); it != dirs.end(); it++)
  {
    sendPacket.strToBuf((*it).c_str());
    sendPacket.uByte4ToBuf(dirToATime[(*it)]);
    sendPacket.uByte4ToBuf(dirToMTime[(*it)]);
    sendPacket.uByte4ToBuf(dirToSize[(*it)]);
    
  }
  
  if (printing)
  {
    printf("\n");
    printf("Files:\n");
  }
  sendPacket.uByte2ToBuf(files.size());
  for (it = files.begin(); it != files.end(); it++)
  {
    sendPacket.strToBuf((*it).c_str());
    sendPacket.uByte4ToBuf(fileToATime[(*it)]);
    sendPacket.uByte4ToBuf(fileToMTime[(*it)]);
    sendPacket.uByte4ToBuf(fileToSize[(*it)]);
    if (printing)
    {
      time_t atime = fileToATime[(*it)];
      time_t mtime = fileToMTime[(*it)];
      printf("\tname: %s\n", (*it).c_str());
      printf("\t\tlastAccessed: %s", ctime(&atime));
      printf("\t\tlastModified: %s", ctime(&mtime));
      printf("\t\tsize: %d", fileToSize[(*it)]);
    }
  }
  delete[] dirStr;
  if (client != NULL)
    client->sendPacketTcp(&sendPacket);
}


AREXPORT ArServerFileToClient::ArServerFileToClient(ArServerBase *server, 
                                                    const char *topDir) :
  myGetFileCB(this, &ArServerFileToClient::getFile)
{
  myServer = server;
  myServer->addData("getFile", 
                    "Gets a file (use ArClientFileToClient instead of calling this directly since this interface may change)",
                    &myGetFileCB, "string: file to get; byte2: operation, 0 == get, 1 == cancel (these aren't implemented yet but will be)",
                    "ubyte2: return code, 0 = good (sending file), 1 = tried to go outside allowed area, 2 = no such file (or can't read), 3 = empty file name, 4 = error reading file (can happen after some good values) ; string: fileGotten;IF return was 0 then  ubyte4: numBytes (number of bytes in this packet, 0 means end of file; numBytes of data", 
                    "FileAccess", "RETURN_UNTIL_EMPTY");

  // snag our base dir and make sure we have enough room for a /
  strncpy(myBaseDir, topDir, sizeof(myBaseDir) - 2);
  myBaseDir[sizeof(myBaseDir) - 2] = '\0';
  // make sure it has a slash
  ArUtil::appendSlash(myBaseDir, sizeof(myBaseDir));
  // make sure the slashes go the right direction
  ArUtil::fixSlashes(myBaseDir, sizeof(myBaseDir));  
}

AREXPORT ArServerFileToClient::~ArServerFileToClient()
{

}



AREXPORT void ArServerFileToClient::getFile(ArServerClient *client,
                                          ArNetPacket *packet)
{
  ArNetPacket sendPacket;
  size_t ui;
  size_t len;

  char fileNameRaw[2048];
  packet->bufToStr(fileNameRaw, sizeof(fileNameRaw));

  // should check for operation here, but thats not implemented yet

  char fileNameCooked[2048];
  strcpy(fileNameCooked, fileNameRaw);
  ArUtil::fixSlashes(fileNameCooked, sizeof(fileNameCooked));


  char fileName[2048];
  if (!ArServerFileUtil::squashCase(myBaseDir, fileNameCooked, 
                                    fileName, sizeof(fileName)))
  {
    ArLog::log(ArLog::Normal, 
               "ArServerFileToClient: can't open file '%s'", fileNameRaw);
    sendPacket.uByte2ToBuf(2);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    // send an empty packet so that forwarding knows we're done
    sendPacket.empty();
    client->sendPacketTcp(&sendPacket);
    return;
  }

  len = strlen(fileName);
  // first advance to the first non space
  for (ui = 0; 
       ui < len && fileName[ui] != '\0' && isspace(fileName[ui]); 
       ui++);

  char *fileStr = new char[len + 3];

  // now copy in the rest
  strncpy(fileStr, fileName, len - ui);
  // make sure its null terminated
  fileStr[len - ui] = '\0';
    
  if (fileStr[0] == '/' || fileStr[0] == '~' ||
      fileStr[0] == '\\' || strstr(fileStr, "..") != NULL)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerFileToClient: '%s' tried to access outside allowed area",
               fileStr);
    delete[] fileStr;
    sendPacket.uByte2ToBuf(1);    
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    // send an empty packet so that forwarding knows we're done
    sendPacket.empty();
    client->sendPacketTcp(&sendPacket);
    return;
  }

  if (strlen(fileStr) > 0)
  {
    ArUtil::fixSlashes(fileStr, len + 2);
  }
  else
  {
    ArLog::log(ArLog::Normal, 
               "ArServerFileToClient: can't get file, empty filename");
    delete[] fileStr;
    sendPacket.uByte2ToBuf(3);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    // send an empty packet so that forwarding knows we're done
    sendPacket.empty();
    client->sendPacketTcp(&sendPacket);
    return;
  }

  // walk from our base down and try to find the first by name
  // ignoring case
  
  // put our base and where we want to go together
  std::string wholeName;
  wholeName = myBaseDir;
  wholeName += fileStr;

  delete[] fileStr;

  ArLog::log(ArLog::Verbose, 
             "ArServerFileToClient: Trying to open %s from base %s", 
             wholeName.c_str(), myBaseDir);
  FILE *file;
  if ((file = fopen(wholeName.c_str(), "rb")) == NULL)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerFileToClient: can't open file '%s'", fileName);
    sendPacket.uByte2ToBuf(2);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    // send an empty packet so that forwarding knows we're done
    sendPacket.empty();
    client->sendPacketTcp(&sendPacket);
    return;
  }

  
  char buf[30000];
  size_t ret;
  // now send the file
  while ((ret = fread(buf, 1, sizeof(buf), file)) == sizeof(buf))
  {
    sendPacket.empty();
    sendPacket.uByte2ToBuf(0);
    sendPacket.strToBuf(fileNameRaw);
    sendPacket.uByte4ToBuf(ret);
    sendPacket.dataToBuf(buf, ret);
    client->sendPacketTcp(&sendPacket);
    //printf("Sent packet with %d\n", ret);
  }
  if (ferror(file))
  {
    ArLog::log(ArLog::Normal, "ArServerFileToClient: Error sending file %s", 
               fileName);
    sendPacket.empty();
    sendPacket.uByte2ToBuf(4);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    // send an empty packet so that forwarding knows we're done
    sendPacket.empty();
    client->sendPacketTcp(&sendPacket);
    return;
  }

  sendPacket.empty();
  sendPacket.uByte2ToBuf(0);
  sendPacket.strToBuf(fileNameRaw);
  sendPacket.uByte4ToBuf(ret);
  sendPacket.dataToBuf(buf, ret);
  //printf("Sent packet with %d\n", ret);
  client->sendPacketTcp(&sendPacket);
  
  // if the file itself was empty we just already sent one with a 0
  // left so don't send this one since it'd be redundant
  if (ret != 0)
  {
    sendPacket.empty();
    sendPacket.uByte2ToBuf(0);
    sendPacket.strToBuf(fileNameRaw);
    sendPacket.uByte4ToBuf(0);
    //printf("Sent packet end\n");
    client->sendPacketTcp(&sendPacket);
  }
  // send an empty packet so that forwarding knows we're done
  sendPacket.empty();
  client->sendPacketTcp(&sendPacket);

  fclose(file);
  if (feof(file))
  {
    ArLog::log(ArLog::Normal, "ArServerFileToClient: Sent file %s to %s", 
               fileName, client->getIPString());
  }
}

AREXPORT ArServerFileFromClient::ArServerFileFromClient(ArServerBase *server, 
                                                        const char *topDir,
                                                        const char *tempDir) :
  myPutFileCB(this, &ArServerFileFromClient::putFile),
  myPutFileInterleavedCB(this, &ArServerFileFromClient::putFileInterleaved)
{
  myServer = server;
  myServer->addData("putFile", 
                    "Puts a file (use ArClientFileFromClient instead of calling this directly since this interface may change)",
                    &myPutFileCB, "uByte2: command, 0 = start file, 1 = continue file, 2 done with file, 3 = cancel put; string: file being sent; IF command == 1 then uByte4: numBytes; numBytes of data",
                    "uByte2: return code, 0 = good (got file), 1 = getting file, 2 = tried to go outside allowed area, 3 = bad directory, 4 = empty file name (or other problem with fileName), 5 = can't write temp file, 6 = error moving file from temp to perm, 7 = another client putting file, 8 = timeout (no activity for 15 seconds) and another client wanted to put the file, 9 = client adding to, finishing, or canceling a file the server doesn't have;  string: fileName",
                    "FileAccess", "RETURN_COMPLEX");

  myServer->addData("putFileInterleaved", 
                    "Puts a file (use ArClientFileFromClient instead of calling this directly since this interface may change)",
                    &myPutFileInterleavedCB, "uByte2: command, 0 = start file, 1 = continue file, 2 done with file, 3 = cancel put; string: file being sent; IF command == 1 then uByte4: numBytes; numBytes of data",
                    "uByte2: return code, 0 = good (got file), 1 = getting file, 2 = tried to go outside allowed area, 3 = bad directory, 4 = empty file name (or other problem with fileName), 5 = can't write temp file, 6 = error moving file from temp to perm, 7 = another client putting file, 8 = timeout (no activity for 15 seconds) and another client wanted to put the file, 9 = client adding to, finishing, or canceling a file the server doesn't have, 10 = gotPacket, awaiting next packet, 11 = cancelled put; string: fileName",
                    "FileAccess", "RETURN_SINGLE");

  myFileNumber = 0;
  // snag our base dir and make sure we have enough room for a /
  strncpy(myBaseDir, topDir, sizeof(myBaseDir) - 2);
  myBaseDir[sizeof(myBaseDir) - 2] = '\0';
  // make sure it has a slash
  ArUtil::appendSlash(myBaseDir, sizeof(myBaseDir));
  // make sure the slashes go the right direction
  ArUtil::fixSlashes(myBaseDir, sizeof(myBaseDir));  
  // snag our base dir and make sure we have enough room for a /
  strncpy(myTempDir, tempDir, sizeof(myTempDir) - 2);
  myTempDir[sizeof(myTempDir) - 2] = '\0';
  // make sure it has a slash
  ArUtil::appendSlash(myTempDir, sizeof(myTempDir));
  // make sure the slashes go the right direction
  ArUtil::fixSlashes(myTempDir, sizeof(myTempDir));  
}

AREXPORT ArServerFileFromClient::~ArServerFileFromClient()
{

}


AREXPORT void ArServerFileFromClient::putFile(ArServerClient *client,
                                              ArNetPacket *packet)
{
  internalPutFile(client, packet, false);
}

AREXPORT void ArServerFileFromClient::putFileInterleaved(
        ArServerClient *client, ArNetPacket *packet)
{
  internalPutFile(client, packet, true);
}

AREXPORT void ArServerFileFromClient::internalPutFile(ArServerClient *client, 
                                                      ArNetPacket *packet,
                                                      bool interleaved)
{
  ArNetPacket sendPacket;
  std::list<ArFunctor *>::iterator fit;
  std::map<std::string, FileInfo *>::iterator it;
  FileInfo *info;
  std::string fileName;
  char fileNameRaw[2048];
  fileNameRaw[0] = '\0';
  ArTypes::UByte2 doing;
  doing = packet->bufToUByte2();
  packet->bufToStr(fileNameRaw, sizeof(fileNameRaw));
  if (doing == 0)
  {
    char directoryRaw[2048];
    directoryRaw[0] = '\0';
    char fileNamePart[2048];
    fileNamePart[0] = '\0';
    if (!ArServerFileUtil::getDirectory(fileNameRaw, 
                                        directoryRaw, sizeof(directoryRaw)) ||
        !ArServerFileUtil::getFileName(fileNameRaw, 
                                       fileNamePart, sizeof(fileNamePart)))
    {
      ArLog::log(ArLog::Normal, 
                 "ArServerFileFromClient: Problem with filename '%s'", 
                 fileNameRaw);
      sendPacket.uByte2ToBuf(4);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      // just added this 4/5/06
      return;
    }
    
    char directory[2048];
    printf("DirectoryRaw %s\n", directoryRaw);
    if (strlen(directoryRaw) == 0)
    {
      strcpy(directory, ".");
    }
    else if (!ArServerFileUtil::squashCase(myBaseDir, directoryRaw, directory, 
                                        sizeof(directory)))
      {
        ArLog::log(ArLog::Normal, 
                   "ArServerFileFromClient: Bad directory for '%s'", 
                 fileNameRaw);
      sendPacket.uByte2ToBuf(3);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      return;
    }

    char tmpDir[2048];
    tmpDir[0] = '\0';
    //sprintf(tmpDir, "%s", tmpDir, directory);
    strcpy(tmpDir, directory);
    ArUtil::appendSlash(tmpDir, sizeof(tmpDir));
    char squashedFileName[2048];
    
    if (ArServerFileUtil::squashCase(tmpDir, fileNamePart, 
                                     squashedFileName, 
                                     sizeof(squashedFileName)))
    {
      fileName = tmpDir;
      fileName += squashedFileName;
      //printf("squashed from %s %s\n", tmpDir, squashedFileName);
    }
    else
    {
      fileName = tmpDir;
      fileName += fileNamePart;
      //printf("unsquashed from %s %s\n", tmpDir, fileNamePart);
    }
    
    ArLog::log(ArLog::Normal, 
               "ArServerFileFromClient: Checking file %s (as %s)",
               fileNameRaw, fileName.c_str());
    for (it = myMap.begin(); it != myMap.end(); it++)
    {
      info = (*it).second;
      // see if a client is messing with this file
      if (ArUtil::strcasecmp(info->myRealFileName, fileName) == 0)
      {
        // see if the other one messing with this timed out, if so let 'em know
        if (info->myLastActivity.secSince() > 15)
        {
          ArLog::log(ArLog::Normal, 
                     "ArServerFileFromClient: Another client wants to start putting file '%s' and old client was inactive", 
                     (*it).first.c_str());
          if (!interleaved)
          {
            sendPacket.uByte2ToBuf(8);
            sendPacket.strToBuf((*it).first.c_str());
            // NOT_EXCLUDING this isn't excluding anymore because it
            // used to cause problems...  this may cause some
            // problems, but hopefully the event doesn't happen much,
            // and at least this way things'll be able to retry easier
            myServer->broadcastPacketTcp(&sendPacket, "putFile");//, client);
          }
          myMap.erase((*it).first);
          delete info;
          break;
        }
        // otherwise let this guy know its busy
        else
        {
          ArLog::log(ArLog::Normal, 
                     "ArServerFileFromClient: Another client putting file '%s'", 
                     fileNameRaw);
          sendPacket.uByte2ToBuf(7);
          sendPacket.strToBuf(fileNameRaw);
          client->sendPacketTcp(&sendPacket);
          return;
        }
      }
    }
    ArLog::log(ArLog::Normal, 
               "ArServerFileFromClient: Receiving file %s (as %s)", 
               fileNameRaw, fileName.c_str());
    char tempFileName[3200];
    tempFileName[0] = '\0';
    sprintf(tempFileName, "%sArServerFileFromClient.%d.%d", myTempDir, getpid(), myFileNumber);
    myFileNumber++;

    printf("Using temp file name %s\n", tempFileName);
    // see if we can open the temp file
    FILE *file;
    if ((file = fopen(tempFileName, "wb")) != NULL)
    {
      info = new FileInfo;
      info->myRealFileName = fileName;      
      info->myTempFileName = tempFileName;
      info->myFile = file;
      info->myStartedTransfer.setToNow();
      info->myLastActivity.setToNow();
      myMap[fileNameRaw] = info;
      if (interleaved)
      {
        //printf("Sending continue\n");
        sendPacket.uByte2ToBuf(10);
        sendPacket.strToBuf(fileNameRaw);
        client->sendPacketTcp(&sendPacket);
      }
    }
    else
    {
      ArLog::log(ArLog::Normal, 
                 "ArServerFileFromClient: Can't open tmp file for '%s' (tried '%s')", 
                 fileNameRaw, tempFileName);
      sendPacket.uByte2ToBuf(5);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      return;
    }
  }
  else if (doing == 1)
  {
    // see if we can find this file
    if ((it = myMap.find(fileNameRaw)) == myMap.end())
    {
      ArLog::log(ArLog::Normal, "ArServerFileUtil: Couldn't find entry for '%s'", fileNameRaw);
      sendPacket.uByte2ToBuf(9);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      return;
    }
    info = (*it).second;
    // write the data to the file and increment last activity
    ArTypes::UByte4 numBytes;
    char buf[32000];
    numBytes = packet->bufToUByte4();
    packet->bufToData(buf, numBytes);
    fwrite(buf, 1, numBytes, info->myFile);
    info->myLastActivity.setToNow();
    if (interleaved)
    {
      sendPacket.uByte2ToBuf(10);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
    }
    ArLog::log(ArLog::Verbose, "Continuing put file %s (%d bytes)", 
               fileNameRaw, numBytes);
    
  }
  else if (doing == 2)
  {
    // see if we can find this file
    if ((it = myMap.find(fileNameRaw)) == myMap.end())
    {
      ArLog::log(ArLog::Normal, "ArServerFileUtil: Couldn't find entry for '%s'", fileNameRaw);
      sendPacket.uByte2ToBuf(9);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      return;
    }
    info = (*it).second;
    fclose(info->myFile);
    info->myFile = NULL;

    char systemBuf[6400];
#ifndef WIN32
    char *mvName = "mv";
#else
    char *mvName = "move";
#endif
    sprintf(systemBuf, "%s \"%s\" \"%s\"", mvName, info->myTempFileName.c_str(), 
            info->myRealFileName.c_str());
    

    myMovingFileName = info->myRealFileName;

    // call our pre move callbacks
    for (fit = myPreMoveCallbacks.begin(); 
         fit != myPreMoveCallbacks.end(); 
         fit++)
      (*fit)->invoke();

    // move file
    int ret;
    if ((ret = system(systemBuf)) == 0)
    {
      sendPacket.uByte2ToBuf(0);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      ArLog::log(ArLog::Normal, "Done with file %s from %s", fileNameRaw,
                 client->getIPString());
      myMap.erase((*it).first);
      delete info;
    }
    else
    {
      sendPacket.uByte2ToBuf(6);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      unlink(info->myTempFileName.c_str());
      myMap.erase((*it).first);
      delete info;
      ArLog::log(ArLog::Normal, "Couldn't move temp file for %s (ret of '%s' is %d)", fileNameRaw, systemBuf, ret);
    }

    // call our post move callbacks
    for (fit = myPostMoveCallbacks.begin(); 
         fit != myPostMoveCallbacks.end(); 
         fit++)
      (*fit)->invoke();

    myMovingFileName = "";
  }
  else if (doing == 3)
  {
    if ((it = myMap.find(fileNameRaw)) == myMap.end())
    {
      ArLog::log(ArLog::Normal, "ArServerFileUtil: Couldn't find entry to cancel for '%s'", fileNameRaw);
      sendPacket.uByte2ToBuf(9);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
      return;
    }
    info = (*it).second;
    fclose(info->myFile);
    info->myFile = NULL;

    unlink(info->myTempFileName.c_str());
    myMap.erase((*it).first);
    delete info;

    ArLog::log(ArLog::Normal, "Cancelling file %s", fileNameRaw);
    if (interleaved)
    {
      sendPacket.uByte2ToBuf(11);
      sendPacket.strToBuf(fileNameRaw);
      client->sendPacketTcp(&sendPacket);
    }
  }
  else
  {
    ArLog::log(ArLog::Normal, "Unknown command %d for file %s", doing, 
               fileNameRaw);
  }
}

AREXPORT void ArServerFileFromClient::addPreMoveCallback(
        ArFunctor *functor, ArListPos::Pos position)
{
  if (position == ArListPos::FIRST)
    myPreMoveCallbacks.push_front(functor);
  else if (position == ArListPos::LAST)
    myPreMoveCallbacks.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
       "ArServerFileFromClient::addPreMoveCallback: Invalid position.");
}

AREXPORT void ArServerFileFromClient::remPreMoveCallback(
        ArFunctor *functor)
{
  myPreMoveCallbacks.remove(functor);
}

AREXPORT void ArServerFileFromClient::addPostMoveCallback(
        ArFunctor *functor, ArListPos::Pos position)
{
  if (position == ArListPos::FIRST)
    myPostMoveCallbacks.push_front(functor);
  else if (position == ArListPos::LAST)
    myPostMoveCallbacks.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
       "ArServerFileFromClient::addPostMoveCallback: Invalid position.");
}

AREXPORT void ArServerFileFromClient::remPostMoveCallback(
        ArFunctor *functor)
{
  myPostMoveCallbacks.remove(functor);
}


AREXPORT ArServerDeleteFileOnServer::ArServerDeleteFileOnServer(
        ArServerBase *server, const char *topDir) :
  myDeleteFileCB(this, &ArServerDeleteFileOnServer::deleteFile)
{
  myServer = server;
  myServer->addData("deleteFile", 
                    "Deletes a file (use ArClientDeleteFileOnServer instead of calling this directly since this interface may change)",
                    &myDeleteFileCB, "string: file to delete",
                    "ubyte2: return code, 0 = good (deleted file file), 1 = tried to go outside allowed area, 2 = no such file (or can't read it), 3 = empty file name, string: fileDeleted", 
                    "FileAccess", "RETURN_SINGLE");

  // snag our base dir and make sure we have enough room for a /
  strncpy(myBaseDir, topDir, sizeof(myBaseDir) - 2);
  myBaseDir[sizeof(myBaseDir) - 2] = '\0';
  // make sure it has a slash
  ArUtil::appendSlash(myBaseDir, sizeof(myBaseDir));
  // make sure the slashes go the right direction
  ArUtil::fixSlashes(myBaseDir, sizeof(myBaseDir));  
}

AREXPORT ArServerDeleteFileOnServer::~ArServerDeleteFileOnServer()
{

}



AREXPORT void ArServerDeleteFileOnServer::deleteFile(ArServerClient *client,
                                          ArNetPacket *packet)
{
  ArNetPacket sendPacket;
  size_t ui;
  size_t len;
  std::list<ArFunctor *>::iterator fit;
  char fileNameRaw[2048];
  packet->bufToStr(fileNameRaw, sizeof(fileNameRaw));

  // should check for operation here, but thats not implemented yet

  char fileNameCooked[2048];
  strcpy(fileNameCooked, fileNameRaw);
  ArUtil::fixSlashes(fileNameCooked, sizeof(fileNameCooked));


  char fileName[2048];
  if (!ArServerFileUtil::squashCase(myBaseDir, fileNameCooked, 
                                    fileName, sizeof(fileName)))
  {
    ArLog::log(ArLog::Normal, 
               "ArServerDeleteFileOnServer: can't read file '%s'", 
               fileNameRaw);
    sendPacket.uByte2ToBuf(2);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    return;
  }

  len = strlen(fileName);
  // first advance to the first non space
  for (ui = 0; 
       ui < len && fileName[ui] != '\0' && isspace(fileName[ui]); 
       ui++);

  char *fileStr = new char[len + 3];

  // now copy in the rest
  strncpy(fileStr, fileName, len - ui);
  // make sure its null terminated
  fileStr[len - ui] = '\0';
    
  if (fileStr[0] == '/' || fileStr[0] == '~' ||
      fileStr[0] == '\\' || strstr(fileStr, "..") != NULL)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerDeleteFileOnServer: '%s' tried to access outside allowed area",
               fileStr);
    delete[] fileStr;
    sendPacket.uByte2ToBuf(1);    
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    return;
  }

  if (strlen(fileStr) > 0)
  {
    ArUtil::fixSlashes(fileStr, len + 2);
  }
  else
  {
    ArLog::log(ArLog::Normal, 
       "ArServerDeleteFileOnServer: can't delete file, empty filename");
    delete[] fileStr;
    sendPacket.uByte2ToBuf(3);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
    return;
  }

  // walk from our base down and try to find the first by name
  // ignoring case
  
  // put our base and where we want to go together
  std::string wholeName;
  wholeName = myBaseDir;
  wholeName += fileStr;

  delete[] fileStr;

  ArLog::log(ArLog::Verbose, 
             "ArServerDeleteFileOnServer: Trying to delete %s from base %s", 
             wholeName.c_str(), myBaseDir);

  myDeletingFileName = fileNameRaw;

  // call our pre delete callbacks
  for (fit = myPreDeleteCallbacks.begin(); 
       fit != myPreDeleteCallbacks.end(); 
       fit++)
    (*fit)->invoke();

  if (unlink(wholeName.c_str()) == 0)
  {
    ArLog::log(ArLog::Normal, 
               "ArServerDeleteFileOnServer: Deleted file %s for %s", 
               fileName, client->getIPString());
    sendPacket.uByte2ToBuf(0);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
  }
  else
  {
    ArLog::log(ArLog::Normal, 
               "ArServerDeleteFileOnServer: can't unlink file '%s'", fileName);
    sendPacket.uByte2ToBuf(2);
    sendPacket.strToBuf(fileNameRaw);
    client->sendPacketTcp(&sendPacket);
  }

  // call our post delete callbacks
  for (fit = myPostDeleteCallbacks.begin(); 
       fit != myPostDeleteCallbacks.end(); 
       fit++)
    (*fit)->invoke();

  myDeletingFileName = "";  
}

AREXPORT void ArServerDeleteFileOnServer::addPreDeleteCallback(
        ArFunctor *functor, ArListPos::Pos position)
{
  if (position == ArListPos::FIRST)
    myPreDeleteCallbacks.push_front(functor);
  else if (position == ArListPos::LAST)
    myPreDeleteCallbacks.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
       "ArServerDeleteFileOnServer::addPreDeleteCallback: Invalid position.");
}

AREXPORT void ArServerDeleteFileOnServer::remPreDeleteCallback(
        ArFunctor *functor)
{
  myPreDeleteCallbacks.remove(functor);
}

AREXPORT void ArServerDeleteFileOnServer::addPostDeleteCallback(
        ArFunctor *functor, ArListPos::Pos position)
{
  if (position == ArListPos::FIRST)
    myPostDeleteCallbacks.push_front(functor);
  else if (position == ArListPos::LAST)
    myPostDeleteCallbacks.push_back(functor);
  else
    ArLog::log(ArLog::Terse, 
       "ArServerDeleteFileOnServer::addPostDeleteCallback: Invalid position.");
}

AREXPORT void ArServerDeleteFileOnServer::remPostDeleteCallback(
        ArFunctor *functor)
{
  myPostDeleteCallbacks.remove(functor);
}

#endif // WIN32

---