Pod.cpp

Go to the documentation of this file.

/*
 * Pod.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003-2005 Chris Wallace
 *
 * Fly! Legacy 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.
 *
 * Fly! Legacy 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 Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef _MSC_VER
#pragma warning (disable:4189)    // Local variable initialized but not used
#pragma warning (disable:4710)    // Function not inlined
#endif

#include <stdarg.h>
#include <string.h>
#include "../Include/Pod.h"
#include "../Include/Utility.h"
#include "../Include/Globals.h"
#include "../Include/Endian.h"

using namespace std;


//
// Local function to convert string to upper-case
//
static void strupper (char *s)
{
  for (unsigned int i=0; i<strlen(s); i++) s[i] = toupper(s[i]);
}

//
// Local functions for extracting typical data types from stdio FILE*
//
static unsigned int freadBigUnsignedInt (FILE* f)
{
  unsigned int rc;
  fread ((char *)&rc, sizeof(unsigned int), 1, f);
  return BigEndian (rc);
}

static unsigned int freadLittleUnsignedInt (FILE* f)
{
  unsigned int rc;
  fread ((char *)&rc, sizeof(unsigned int), 1, f);
  return LittleEndian (rc);
}

static void plog (PFS *pPfs, const char* fmt, ...)
{
  if (pPfs->log != NULL) {
    va_list argp;
    va_start(argp, fmt);
    pPfs->log->Write (fmt, argp);
    va_end(argp);
  }  
}

//
// Standard C pod filesystem implementation
//

//
// Example:
//
// PFS pfs;
// pinit (&pfs, "C:\\Fly! II", false);
// paddpodfolder ("Aircraft");
// paddpodfolder ("System");
// padddiskfolder ("World");
// PFSFILE* f = popen ("World\\Flyhawk.svh");
//...
//

void pinit (PFS* pPfs, const char* root, bool searchPodFilesFirst)
{
  strcpy (pPfs->root, root);
  pPfs->searchPodFilesFirst = searchPodFilesFirst;

  // Get INI setting and open log if necessary
  pPfs->log = NULL;
  int i = 0;
  GetIniVar ("Logs", "logPodFilesystem", &i);
  if (i != 0) {
    pPfs->log = new CLogFile ("Logs\\PodFilesystem.log", "w");
  }

#ifdef POD_PERFORMANCE_METRICS
  // Initialize performance metrics
  pPfs->popenSuccess = pPfs->popenFailure = 0;
  pPfs->popenSuccessTotalTime.QuadPart = 0;
  pPfs->popenFailureTotalTime.QuadPart = 0;
#endif

  plog (pPfs, "Initialization complete");
}

void pshutdown (PFS* pPfs)
{
  plog (pPfs, "Shutting down...");

  // Deallocate all entries in the pod list
  map<string,PFSPOD*>::iterator iPod;
  for (iPod=pPfs->podList.begin(); iPod!=pPfs->podList.end(); iPod++) {
    PFSPOD *pPod = iPod->second;
    if (pPod->file != NULL) fclose (pPod->file);
    delete pPod;
  }
  
  // Delete all entries in the pod file list
  multimap<string,PFSPODFILE*>::iterator i;
  for (i=pPfs->podFileList.begin(); i!=pPfs->podFileList.end(); i++) {
    PFSPODFILE *pf = i->second;
    delete pf;
  }

  plog (pPfs, "Shutdown complete");
  
  // Close log file
  if (pPfs->log != NULL) delete pPfs->log;
}

static bool paddpodfile (PFS *pPfs, PFSPODFILE *p)
{
  bool rc = true;

  // Create pairing of filename with PFSPODFILE*
  pair<string,PFSPODFILE*>  pr;
  pr.first = p->name;
  pr.second = p;
  pPfs->podFileList.insert(pr);

  return rc;
}

static void padddiskfile (PFS *pPfs, string filename)
{
  pPfs->diskFileList.insert(filename);
}
    
static void pmountepd (PFS *pPfs, PFSPOD* pPod)
{
  // Local copy of the POD's FILE* for convenience
  FILE* f = pPod->file;

  // Read EPD header
  char volume[EPD_VOLUME_LENGTH+1];
  fread (volume, 1, EPD_VOLUME_LENGTH, f);
  unsigned int nEntries = freadLittleUnsignedInt (f);

  // Skip version number
  freadLittleUnsignedInt (f);
  
  pPod->checksum = freadLittleUnsignedInt (f);

  // Read EPD directory and add PFSPODFILE structs to the POD file list
  for (unsigned int i=0; i<nEntries; i++) {
    // Instantiate new PFSPODFILE struct
    PFSPODFILE* pFile = new PFSPODFILE;

    // Populate struct with EPD directory entry fields
    pFile->pod = pPod;
    fread (pFile->name, 1, EPD_FILENAME_LENGTH, f);
    pFile->size = freadBigUnsignedInt (f);
    pFile->offset = freadBigUnsignedInt (f);
    pFile->timestamp = freadBigUnsignedInt (f);
    pFile->checksum = freadBigUnsignedInt (f);

    // EPD files do not support mount priority, so use default of 1000
    pFile->priority = 1000;

    if (!paddpodfile (pPfs, pFile)) {
      // Pod file was rejected; delete it
      delete pFile;
    }
  }
}

static void pmountpod2 (PFS *pPfs, PFSPOD* pPod)
{
  int i, j;
  
  // Local copy of the POD's FILE* for convenience
  FILE* f = pPod->file;

  // Read POD2 header
  pPod->checksum = freadLittleUnsignedInt (f);
  char volume[POD_VOLUME_LENGTH+1];
  fread (volume, POD_VOLUME_LENGTH, 1, f);
  unsigned int nEntries = freadLittleUnsignedInt (f);
  pPod->nAuditEntries = freadLittleUnsignedInt (f);
  pPod->revision = 0;
  pPod->priority = 1000;

  // Calculate starting offset of filename string table
  unsigned int offsetStringTable = (POD_VOLUME_LENGTH
    + (4 * sizeof(unsigned int))
    + (nEntries * 20));

  
  // Read POD2 directory, and add PFSPODFILE structs to POD file list
  for (i=0; i<(int)nEntries; i++) {
    // Instantiate new PFSPODFILE struct
    PFSPODFILE* pFile = new PFSPODFILE;

    pFile->pod = pPod;
    unsigned int offsetFilename = freadLittleUnsignedInt (f);
    pFile->size = freadLittleUnsignedInt (f);
    pFile->offset = freadLittleUnsignedInt (f);
    pFile->timestamp = freadLittleUnsignedInt (f);
    pFile->checksum = freadLittleUnsignedInt (f);

    // Mount priority is not supported by the POD2 format, use default of 1000
    pFile->priority = 1000;

    // Reposition file pointer to location in string table of the filename,
    //   read the filename then reposition back to the next directory entry
    long pos = ftell (f);
    fseek (f, offsetStringTable + offsetFilename, SEEK_SET);
    char c;
    for (j=0; j<POD_FILENAME_LENGTH; j++) {
      fread (&c, 1, 1, f);
      if (c == '\0') break;
      pFile->name[j] = c;
    }
    pFile->name[j] = '\0';
    fseek (f, pos, SEEK_SET);

    if (!paddpodfile (pPfs, pFile)) {
      // Pod file was rejected; delete it
      delete pFile;
    }
  }
}

static void pmountpod3 (PFS *pPfs, PFSPOD* pPod)
{
  int i, j;
  
  // Local copy of the POD's FILE* for convenience
  FILE* f = pPod->file;

  pPod->checksum = freadLittleUnsignedInt (f);
  char volume[POD_VOLUME_LENGTH+1];
  fread (volume, POD_VOLUME_LENGTH, 1, f);
  unsigned int nEntries = freadLittleUnsignedInt (f);
  pPod->nAuditEntries = freadLittleUnsignedInt (f);
  pPod->revision = freadLittleUnsignedInt (f);
  pPod->priority = freadLittleUnsignedInt (f);
  char author[POD_AUTHOR_LENGTH+1];
  fread (author, POD_AUTHOR_LENGTH, 1, f);
  char copyright[POD_COPYRIGHT_LENGTH+1];
  fread (copyright, POD_COPYRIGHT_LENGTH, 1, f);
  unsigned int offsetDirectory = freadLittleUnsignedInt (f);

  // The following POD3 header fields are ignored:
  //    checksum
  //    string table size
  //    dependency
  //    unknown4
  //    unknown5
  
  // Calculate starting offset of filename string table
  unsigned int offsetStringTable = offsetDirectory + (nEntries * 20);

  // Reposition file pointer to start of POD directory
  fseek (f, offsetDirectory, SEEK_SET);

  for (i=0; i<(int)nEntries; i++) {
    // Instantiate new PFSPODFILE struct
    PFSPODFILE* pFile = new PFSPODFILE;

    pFile->pod = pPod;
    unsigned int offsetFilename = freadLittleUnsignedInt (f);
    pFile->size = freadLittleUnsignedInt (f);
    pFile->offset = freadLittleUnsignedInt (f);
    pFile->priority = pPod->priority;
    pFile->timestamp = freadLittleUnsignedInt (f);
    pFile->checksum  = freadLittleUnsignedInt (f);

    // Reposition file pointer to location in string table of the filename,
    //   read the filename then reposition back to the next directory entry
    long pos = ftell (f);
    fseek (f, offsetStringTable + offsetFilename, SEEK_SET);
    strcpy (pFile->name, "");
    char c;
    for (j=0; j<POD_FILENAME_LENGTH; j++) {
      fread (&c, 1, 1, f);
      if (c == '\0') break;
      pFile->name[j] = c;
    }
    pFile->name[j] = '\0';
    fseek (f, pos, SEEK_SET);

    if (!paddpodfile (pPfs, pFile)) {
      // Pod file was rejected; delete it
      delete pFile;
    }
  }
}

static PFSPOD* pmount (PFS *pPfs, const char* podname)
{
  PFSPOD* pPod = new PFSPOD;
  strcpy (pPod->name, podname);
  pPod->file = NULL;
  pPod->format = PodFormatUnknown;
  pPod->refs = 0;

  FILE* f = fopen (podname, "rb");
  if (f != NULL) {
    pPod->file = f;
    
    // Read POD type signature
    unsigned int signature = freadBigUnsignedInt (f);

    // Set pod format based on signature
    switch (signature) {
    case PodSignatureEpd:
      pPod->format = PodFormatEpd;
      pmountepd (pPfs, pPod);
      break;

    case PodSignaturePod2:
      pPod->format = PodFormatPod2;
      pmountpod2 (pPfs, pPod);
      break;

    case PodSignaturePod3:
      pPod->format = PodFormatPod3;
      pmountpod3 (pPfs, pPod);
      break;

    default:
      pPod->format = PodFormatUnknown;
    }
  } else {
    WARNINGLOG ("pmount : Could not open POD file %s", podname);
  }

  return pPod;
}

void paddpod (PFS *pPfs, const char* filename)
{
  plog (pPfs, "Adding POD: %s", filename);

  // Create full POD folder by concatenating root folder with sub-folder name
  char podname[PATH_MAX];
  strcpy (podname, pPfs->root);
  strcat (podname, "\\");
  strcat (podname, filename);

  PFSPOD *pPod = pmount (pPfs, podname);
  pPfs->podList[filename] = pPod;
}

void premovepod (PFS *pPfs, const char* filename)
{
  plog (pPfs, "Removing POD: %s", filename);

  // Find the entry in the pod list
  map<string,PFSPOD*>::iterator iter = pPfs->podList.find(filename);
  if (iter != pPfs->podList.end()) {
    PFSPOD *pPod = iter->second;
    pPfs->podList.erase(filename);
    
    // Close the associated disk file if it is open
    if (pPod->file) {
      fclose (pPod->file);
    }
    
    delete pPod;
  }
}

//
// All POD files (with .POD or .EPD extension) in the specified folder are added
//   to the POD filesystem.
//
void paddpodfolder (PFS* pPfs, const char* folder)
{
  plog (pPfs, "Adding pod folder: %s", folder);

  // Create full POD folder by concatenating root folder with sub-folder name
  char path[PATH_MAX];
  strcpy (path, pPfs->root);
  strcat (path, "\\");
  strcat (path, folder);

  // Iterate over all files in this folder.  Sub-folders are not processed recursively
  ulDir* dirp = ulOpenDir (path);
  if (dirp != NULL) {
    ulDirEnt* dp;
    while ( (dp = ulReadDir(dirp)) != NULL )
    {
      if (dp->d_isdir) {
        // This is a sub-folder, ignore it
        continue;
      } else {
        // Check the file extension
        char *c = strrchr (dp->d_name, '.');
        if ((stricmp (c, ".EPD") == 0) || (stricmp(c, ".POD") == 0)) {
          // This is a POD file, create a new PFSPOD instance and add
          //   it to the POD list for the filesystem
          char podfilename[PATH_MAX];
          strcpy (podfilename, path);
          strcat (podfilename, "\\");
          strcat (podfilename, dp->d_name);


          PFSPOD *pPod = pmount (pPfs, podfilename);
          pPfs->podList[podfilename] = pPod;

          // Update podFileList
//          map<string,PFSPODFILE*>::iterator i;
//          for (i=pPod->fileList.begin(); i!=pPod->fileList.end(); i++) {
//            pPfs->podFileList[i->second->name] = pPod;
//          }
        }
      }
    }
    ulCloseDir(dirp);
  }
}

//
// This function adds all non-POD files in the specified folder to the referenced
//   pod filesystem.  Sub-folders are recursively added as well.
//
void padddiskfolder (PFS *pPfs, const char* folder)
{
  plog (pPfs, "Adding disk folder: %s", folder);

  // Create full folder name by concatenating root folder with sub-folder name
  char path[1024];
  strcpy (path, pPfs->root);
  strcat (path, "\\");
  strcat (path, folder);

  // Iterate over all files in this folder.
  ulDir* dirp = ulOpenDir (path);
  if (dirp != NULL) {
    ulDirEnt* dp;
    while ( (dp = ulReadDir(dirp)) != NULL )
    {
      if (dp->d_isdir) {
        // This is a sub-folder, recursively add it
        if ((strcmp (dp->d_name, ".") != 0) && (strcmp (dp->d_name, "..") != 0)) {
          char subfolder[1024];
          strcpy (subfolder, folder);
          strcat (subfolder, "\\");
          strcat (subfolder, dp->d_name);
          padddiskfolder (pPfs, subfolder);
        }
      } else {
        // This is a file, check the extension
        char *c = strrchr (dp->d_name, '.');
        if ((stricmp (c, ".EPD") == 0) || (stricmp(c, ".POD") == 0)) {
          // This is a POD file, ignore it
          continue;
        } else {
          // This is not a POD file, add it to the set of disk files
          char filename[1024];
          strcpy (filename, folder);
          strcat (filename, "\\");
          strcat (filename, dp->d_name);
          strupper (filename);
          
          padddiskfile (pPfs, filename);
        }
      }
    }
    ulCloseDir(dirp);
  }
}

static PODFILE* findinpod (PFS* pPfs, const char* filename)
{
  PODFILE* p = NULL;

  // POD filenames are case-insensitive, and are stored in POD files as all upper case
  char f[PATH_MAX];
  strcpy (f, filename);
  strupper (f);

  PFSPODFILE *pf = NULL;
  multimap<string,PFSPODFILE*>::iterator i = pPfs->podFileList.lower_bound(f);
  if (i != pPfs->podFileList.end()) {
    // There is at least one file with this name in the list of pod files
    // Find the highest-priority instance and return it
    unsigned long priority = 9999;
    while (i != pPfs->podFileList.upper_bound(f)) {
      if (i->second->priority < priority) {
        char debug[PATH_MAX + 100];
        sprintf (debug, "Override %s pri %d with pri %d in %s",
                filename, priority, i->second->priority, i->second->pod->name);
        plog (pPfs, debug);
        pf = i->second;
        priority = pf->priority;
      }
      i++;
    }
  }
  
  if (pf != NULL) {
    // Instantiate new PODFILE struct
    p = new PODFILE;
    
    // Link this PODFILE struct to the underlying POD
    strcpy (p->filename, filename);
    p->source = PODFILE_SOURCE_POD;
    p->pPod = pf->pod;
    p->pFile = pf->pod->file;
    p->offset = pf->offset;
    p->pos = pf->offset;
    p->size = pf->size;
    
    // Increment reference counter of containing POD
    pf->pod->refs++;
  }

  return p;
}

static PODFILE* findondisk (PFS* pPfs, const char* filename)
{
  PODFILE* p = NULL;

  set<string>::iterator i = pPfs->diskFileList.find(filename);
  if (i != pPfs->diskFileList.end()) {
    // Found it
    p = new PODFILE;

    char fullpath[1024];
    strcpy (fullpath, pPfs->root);
    strcat (fullpath, "\\");
    strcat (fullpath, filename);

    // Open the disk file
    strcpy (p->filename, filename);
    p->pFile = fopen (fullpath, "rb");
    p->source = PODFILE_SOURCE_DISK;
    p->offset = 0;
    p->pos = 0;
    fseek (p->pFile, 0, SEEK_END);
    p->size = ftell (p->pFile);
    rewind (p->pFile);
  }

  return p;
}


//
// Search all mounted pod files for the given filename
//
// Returns: true if the file exists in a pod, false otherwise
//
static bool existsinpod (PFS *pPfs, const char* filename)
{
//  int i, j;
  bool rc = false;
  
  // Search pod file list for filename
  multimap<string,PFSPODFILE*>::iterator i = pPfs->podFileList.find(filename);
  rc = (i != pPfs->podFileList.end());
  
  return rc;
}

//
// Search the disk file list for the given filename
//
// Returns: true if the file exists on disk, false otherwise
//
static bool existsondisk (PFS *pPfs, const char* filename)
{
  bool rc = false;

  // Search for existence of the filename in the disk file list set
  set<string>::iterator i = pPfs->diskFileList.find(filename);
  rc = (i != pPfs->diskFileList.end());

  return rc;
}

bool pexists (PFS* pPfs, const char* filename)
{
  bool rc = false;

  if (pPfs->searchPodFilesFirst) {
    // Search for filename in all mounted PODs.
    rc = existsinpod (pPfs, filename);
    if (!rc) {
      // Not found in a POD, search disk files
      rc = existsondisk (pPfs, filename);
    }
  } else {
    // Search for filename in disk files
    rc = existsondisk (pPfs, filename);
    if (!rc) {
      // Not found on disk, search all mounted PODs
      rc = existsinpod (pPfs, filename);
    }
  }

  return rc;
}


PODFILE* popen (PFS* pPfs, const char* fname)
{
  PODFILE *p = NULL;

#ifdef POD_PERFORMANCE_METRICS
  // Get timestamp
  LARGE_INTEGER start, stop, delta;
  QueryPerformanceCounter (&start);
#endif

  // Convert filename to uppercase
  char filename[PATH_MAX];
  strcpy (filename, fname);
  strupper (filename);

  if (pPfs->searchPodFilesFirst) {
    // Search for filename in all mounted PODs.
    p = findinpod (pPfs, filename);
    if (p == NULL) {
      // Not found in a POD, search disk files
      p = findondisk (pPfs, filename);
    }
  } else {
    // Search for filename in disk files
    p = findondisk (pPfs, filename);
    if (p == NULL) {
      // Not found on disk, search all mounted PODs
      p = findinpod (pPfs, filename);
    }
  }

#ifdef POD_PERFORMANCE_METRICS
  // Get final timestamp and update performance metrics (logging time should not
  //   be included in measurements
  delta.QuadPart = 0;
  QueryPerformanceCounter (&stop);
  if (stop.QuadPart < start.QuadPart) {
#ifdef HAVE_MAXLONGLONG
      delta.QuadPart = stop.QuadPart + (MAXLONGLONG - start.QuadPart);
#else
      gtfo ("popen : Performance counter wraparound\n");
#endif // HAVE_MAXLONGLONG
  } else {
    delta.QuadPart = stop.QuadPart - start.QuadPart;
  }

  // Record measured interval against either success or failure metric
  if (p == NULL) {
    // popen failure
    pPfs->popenFailure++;
    pPfs->popenFailureTotalTime.QuadPart += delta.QuadPart;
  } else {
    // popen success
    pPfs->popenSuccess++;
    pPfs->popenSuccessTotalTime.QuadPart += delta.QuadPart;
  }
#endif

  // Generate log if file not found
  if (p == NULL) {
    plog (pPfs, "popen() : Failed to open %s", filename);
  }

  return p;
}

size_t pread (void* buffer, size_t size, size_t count, PODFILE* f)
{
  size_t rc = 0;
  if (f) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      // Reads to different files within the same POD may be interspersed,
      //   so the read pointer must be reset to the next expected byte for
      //   this pod file.
      fseek (f->pFile, f->pos, SEEK_SET);
      rc = fread (buffer, size, count, f->pFile);
      f->pos = ftell (f->pFile);
      break;

    case PODFILE_SOURCE_DISK:
      rc = fread (buffer, size, count, f->pFile);
      break;
    }
  }

  return rc;
}

int peof (PODFILE* f)
{
  int rc = true;
  if (f) {

    switch (f->source) {
    case PODFILE_SOURCE_POD:
      if (f->pos < (f->offset + f->size)) {
        rc = false;
      }
      break;

    case PODFILE_SOURCE_DISK:
      rc = feof (f->pFile);
      break;
    }
  }
  return rc;
}

int perror (PODFILE* f)
{
  int rc = 0;
  if (f) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      rc = ferror (f->pFile);
      break;

    case PODFILE_SOURCE_DISK:
      rc = ferror (f->pFile);
      break;
    }
  }
  return rc;
}

int pgetc (PODFILE* f)
{
  int rc = 0;
  if (f) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      // Reads to different files within the same POD may be interspersed,
      //   so the read pointer must be reset to the next expected byte for
      //   this pod file.
      fseek (f->pFile, f->pos, SEEK_SET);
      rc = fgetc (f->pFile);
      f->pos = ftell (f->pFile);
      break;

    case PODFILE_SOURCE_DISK:
      rc = fgetc (f->pFile);
      break;
    }
  }

  return rc;
}

char* pgets (char* s, int n, PODFILE* f)
{
  char* rc = NULL;
  if (f) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      // Reads to different files within the same POD may be interspersed,
      //   so the read pointer must be reset to the next expected byte for
      //   this pod file.
      fseek (f->pFile, f->pos, SEEK_SET);
      rc = fgets (s, n, f->pFile);
      f->pos = ftell (f->pFile);
      break;

    case PODFILE_SOURCE_DISK:
      rc = fgets (s, n, f->pFile);
      break;
    }
  }

  return rc;
}

int pseek (PODFILE* f, long offset, int origin)
{
  int rc = 0;
  if (f) {
    rc = fseek (f->pFile, f->offset + offset, origin);
    // Adjust position
    f->pos = ftell (f->pFile);
  }

  return rc;
}

long ptell (PODFILE* f)
{
  long rc = -1;
  if (f) rc = f->pos - f->offset;
  return rc;
}

void prewind (PODFILE* f)
{
  if (f) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      // Reset the position pointer to the starting offset for this file
      //   within the POD
      f->pos = f->offset;
      fseek (f->pFile, f->pos, SEEK_SET);
      break;

    case PODFILE_SOURCE_DISK:
      rewind (f->pFile);
      break;
    }
  }
}

void pclose (PODFILE* f)
{
  if (f != NULL) {
    switch (f->source) {
    case PODFILE_SOURCE_POD:
      {
        PFSPOD *pPod = f->pPod;
        if (pPod != NULL) {
          // Decrement pod reference count
          if (pPod->refs == 0) {
            // Ref count is already zero; generate warning
            WARNINGLOG ("pclose : Pod reference count underflow");
          } else {
            pPod->refs--;
          }
        }
      }
      break;

    case PODFILE_SOURCE_DISK:
      fclose (f->pFile);
      break;
    }
  }

  delete f;
}


//
// Dump the directory of a pod filesystem to disk
//
void pfsdump (PFS *pfs, FILE *f)
{
  // Dump out root folders for the filesystem
  fprintf (f, "Pod Filesystem Root : %s\n", pfs->root);
  fprintf (f, "  Search pod files first : %c\n", pfs->searchPodFilesFirst ? 'Y' : 'N');
  fprintf (f, "\n");

  long nTotalFiles = 0;

  // Dump out list of disk files
  fprintf (f, "FILE contents:\n");
  set<string>::iterator idf;
  for (idf=pfs->diskFileList.begin(); idf!=pfs->diskFileList.end(); idf++) {
    fprintf (f, "  %-60s\n", idf->c_str());
    nTotalFiles++;
  }
  fprintf (f, "\n");

  // Dump out list of pod files
  fprintf (f, "POD contents:\n");
  multimap<string,PFSPODFILE*>::iterator ipf;
  for (ipf=pfs->podFileList.begin(); ipf!=pfs->podFileList.end(); ipf++) {
    PFSPODFILE *pf = ipf->second;
    fprintf (f, "  %-40s %d %-30s\n", pf->name, pf->priority, pf->pod->name);
    nTotalFiles++;
  }
  fprintf (f, "\n");

  // Dump out list of pods
  fprintf (f, "POD list:\n");
  map<string,PFSPOD*>::iterator ip;
  for (ip=pfs->podList.begin(); ip!=pfs->podList.end(); ip++) {
    PFSPOD *pod = ip->second;
    fprintf (f, "Filename  : %s\n", pod->name);
    fprintf (f, "Format    : 0x%08X\n", pod->format);
  }
  fprintf (f, "\n");
  
  // Total number of files
  fprintf (f, "Total files in POD Filesystem : %d\n\n", nTotalFiles);

#ifdef POD_PERFORMANCE_METRICS
  // Calculate and display popen() statistics
  LARGE_INTEGER perf_freq;
  if (!QueryPerformanceFrequency (&perf_freq)) {
    gtfo ("CTimeManager : QueryPerformanceFrequency failed");
  }
  float freq = (float)perf_freq.QuadPart;

  float avgTicks = (float)pfs->popenSuccessTotalTime.QuadPart / (float)pfs->popenSuccess;
  float avg = (avgTicks / freq) * 1000.0f;
  fprintf (f, "Number of successful popen()  : %d\n", pfs->popenSuccess);
  fprintf (f, "Avg. ms per popen() success   : %f\n\n", avg);

  avgTicks = (float)pfs->popenFailureTotalTime.QuadPart / (float)pfs->popenFailure;
  avg = (avgTicks / freq) * 1000.0f;
  fprintf (f, "Number of failed popen()   : %d\n", pfs->popenFailure);
  fprintf (f, "Avg. ms per popen() failure: %f\n\n", avg);
#endif

/*
  // Dump out list of disk files
  fprintf (f, "FILE contents:\n");
  int nDiskFiles = pfs->fileList.getNumEntities();
  for (i=0; i<nDiskFiles; i++) {
    PFSDISKFILE *diskfile = (PFSDISKFILE *)pfs->fileList.getEntity (i);
    fprintf (f, "  %-60s\n", diskfile->filename);
  }
  nTotalFiles += nDiskFiles;
  fprintf (f, "\n");

  // Dump out list of pods
  fprintf (f, "POD list:\n");
  int nPods = pfs->podList.getNumEntities();
  for (i=0; i<nPods; i++) {
    PFSPOD *pod = (PFSPOD *)pfs->podList.getEntity (i);
    fprintf (f, "Filename  : %s\n", pod->name);
    fprintf (f, "Format    : 0x%08X\n", pod->format);

    int nFiles = pod->fileList.getNumEntities ();
    fprintf (f, "Num Files : %d\n", nFiles);
    for (j=0; j<nFiles; j++) {
      PFSPODFILE *podfile = (PFSPODFILE *) pod->fileList.getEntity (j);
      fprintf (f, "  %-60s O/S/P: 0x%08X / 0x%08X / %4d\n",
        podfile->name, podfile->offset, podfile->size, podfile->priority);
    }
    nTotalFiles += nFiles;
    fprintf (f, "\n");
  }
  fprintf (f, "\n");

  // Total number of files
  fprintf (f, "Total files in POD Filesystem : %d\n\n", nTotalFiles);
*/
}

Documentation generated by