ciderpress/linux/MDC.cpp

/*
 * CiderPress
 * Copyright (C) 2007 by faddenSoft, LLC.  All Rights Reserved.
 * See the file LICENSE for distribution terms.
 */
/*
 * Drive diskimglib.  Similar to MDC.
 */
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <limits.h>
#include <errno.h>
#include "zlib.h"
#include "../diskimg/DiskImg.h"
#include "../nufxlib/NufxLib.h"
#include "StringArray.h"

using namespace DiskImgLib;

#define nil NULL
#define ASSERT assert
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
typedef const char* LPCTSTR;

#define UNIX_LIKE
#define HAVE_DIRENT_H   // linux
#define MAX_PATH_LEN 1024

/* get a grip on this opendir/readdir stuff */
#if defined(UNIX_LIKE)
#  if defined(HAVE_DIRENT_H)
#    include <dirent.h>
#    define DIR_NAME_LEN(dirent)    ((int)strlen((dirent)->d_name))
     typedef struct dirent DIR_TYPE;
#  elif defined(HAVE_SYS_DIR_H)
#    include <sys/dir.h>
#    define DIR_NAME_LEN(direct)    ((direct)->d_namlen)
     typedef struct direct DIR_TYPE;
#  elif defined(HAVE_NDIR_H)
#    include <sys/ndir.h>
#    define DIR_NAME_LEN(direct)    ((direct)->d_namlen)
     typedef struct direct DIR_TYPE;
#  else
#    error "Port this?"
#  endif
#endif

/*
 * Globals.
 */
FILE* gLog = nil;
pid_t gPid = getpid();

struct Stats {
    long    numFiles;
    long    numDirectories;
    long    goodDiskImages;
} gStats = { 0 };

typedef struct ScanOpts {
    FILE*   outfp;
} ScanOpts;

typedef enum RecordKind {
    kRecordKindUnknown = 0,
    kRecordKindDisk,
    kRecordKindFile,
    kRecordKindForkedFile,
    kRecordKindDirectory,
    kRecordKindVolumeDirectory,
} RecordKind;


//#define kFilenameExtDelim '.'     /* separates extension from filename */

/* time_t values for bad dates */
#define kDateNone       ((time_t) -2)
#define kDateInvalid    ((time_t) -1)       // should match return from mktime()

/*
 * "buf" must hold at least 64 chars.
 */
void
FormatDate(time_t when, char* buf)
{
    if (when == kDateNone) {
        strcpy(buf, "[No Date]");
    } else if (when == kDateInvalid) {
        strcpy(buf, "<invalid>");
    } else {
        struct tm* ptm;

        ptm = localtime(&when);
        strftime(buf, 64, "%d-%b-%y %H:%M", ptm);
    }
}

#if 0
/*
 * Find the filename component of a local pathname.  Uses the fssep passed
 * in.  If the fssep is '\0' (as is the case for DOS 3.3), then the entire
 * pathname is returned.
 *
 * Always returns a pointer to a string; never returns nil.
 */
const char*
FilenameOnly(const char* pathname, char fssep)
{
    const char* retstr;
    const char* pSlash;
    char* tmpStr = nil;

    ASSERT(pathname != nil);
    if (fssep == '\0') {
        retstr = pathname;
        goto bail;
    }

    pSlash = strrchr(pathname, fssep);
    if (pSlash == nil) {
        retstr = pathname;      /* whole thing is the filename */
        goto bail;
    }

    pSlash++;
    if (*pSlash == '\0') {
        if (strlen(pathname) < 2) {
            retstr = pathname;  /* the pathname is just "/"?  Whatever */
            goto bail;
        }

        /* some bonehead put an fssep on the very end; back up before it */
        /* (not efficient, but this should be rare, and I'm feeling lazy) */
        tmpStr = strdup(pathname);
        tmpStr[strlen(pathname)-1] = '\0';
        pSlash = strrchr(tmpStr, fssep);

        if (pSlash == nil) {
            retstr = pathname;  /* just a filename with a '/' after it */
            goto bail;
        }

        pSlash++;
        if (*pSlash == '\0') {
            retstr = pathname;  /* I give up! */
            goto bail;
        }

        retstr = pathname + (pSlash - tmpStr);

    } else {
        retstr = pSlash;
    }

bail:
    free(tmpStr);
    return retstr;
}

/*
 * Return the filename extension found in a full pathname.
 *
 * An extension is the stuff following the last '.' in the filename.  If
 * there is nothing following the last '.', then there is no extension.
 *
 * Returns a pointer to the '.' preceding the extension, or nil if no
 * extension was found.
 *
 * We guarantee that there is at least one character after the '.'.
 */
const char*
FindExtension(const char* pathname, char fssep)
{
    const char* pFilename;
    const char* pExt;

    /*
     * We have to isolate the filename so that we don't get excited
     * about "/foo.bar/file".
     */
    pFilename = FilenameOnly(pathname, fssep);
    ASSERT(pFilename != nil);
    pExt = strrchr(pFilename, kFilenameExtDelim);

    /* also check for "/blah/foo.", which doesn't count */
    if (pExt != nil && *(pExt+1) != '\0')
        return pExt;

    return nil;
}
#endif


/*
 * Analyze a file's characteristics.
 */
void
AnalyzeFile(const A2File* pFile, RecordKind* pRecordKind,
    unsigned long* pTotalLen, unsigned long* pTotalCompLen)
{
    if (pFile->IsVolumeDirectory()) {
        /* volume directory entry */
        ASSERT(pFile->GetRsrcLength() < 0);
        *pRecordKind = kRecordKindVolumeDirectory;
        *pTotalLen = pFile->GetDataLength();
        *pTotalCompLen = pFile->GetDataLength();
    } else if (pFile->IsDirectory()) {
        /* directory entry */
        ASSERT(pFile->GetRsrcLength() < 0);
        *pRecordKind = kRecordKindDirectory;
        *pTotalLen = pFile->GetDataLength();
        *pTotalCompLen = pFile->GetDataLength();
    } else if (pFile->GetRsrcLength() >= 0) {
        /* has resource fork */
        *pRecordKind = kRecordKindForkedFile;
        *pTotalLen = pFile->GetDataLength() + pFile->GetRsrcLength();
        *pTotalCompLen =
            pFile->GetDataSparseLength() + pFile->GetRsrcSparseLength();
    } else {
        /* just data fork */
        *pRecordKind = kRecordKindFile;
        *pTotalLen = pFile->GetDataLength();
        *pTotalCompLen = pFile->GetDataSparseLength();
    }
}

/*
 * Determine whether the access bits on the record make it a read-only
 * file or not.
 *
 * Uses a simplified view of the access flags.
 */
bool
IsRecordReadOnly(int accessBits)
{
    if (accessBits == 0x21L || accessBits == 0x01L)
        return true;
    else
        return false;
}

/* ProDOS file type names; must be entirely in upper case */
static const char gFileTypeNames[256][4] = {
    "NON", "BAD", "PCD", "PTX", "TXT", "PDA", "BIN", "FNT",
    "FOT", "BA3", "DA3", "WPF", "SOS", "$0D", "$0E", "DIR",
    "RPD", "RPI", "AFD", "AFM", "AFR", "SCL", "PFS", "$17",
    "$18", "ADB", "AWP", "ASP", "$1C", "$1D", "$1E", "$1F",
    "TDM", "$21", "$22", "$23", "$24", "$25", "$26", "$27",
    "$28", "$29", "8SC", "8OB", "8IC", "8LD", "P8C", "$2F",
    "$30", "$31", "$32", "$33", "$34", "$35", "$36", "$37",
    "$38", "$39", "$3A", "$3B", "$3C", "$3D", "$3E", "$3F",
    "DIC", "OCR", "FTD", "$43", "$44", "$45", "$46", "$47",
    "$48", "$49", "$4A", "$4B", "$4C", "$4D", "$4E", "$4F",
    "GWP", "GSS", "GDB", "DRW", "GDP", "HMD", "EDU", "STN",
    "HLP", "COM", "CFG", "ANM", "MUM", "ENT", "DVU", "FIN",
    "$60", "$61", "$62", "$63", "$64", "$65", "$66", "$67",
    "$68", "$69", "$6A", "BIO", "$6C", "TDR", "PRE", "HDV",
    "$70", "$71", "$72", "$73", "$74", "$75", "$76", "$77",
    "$78", "$79", "$7A", "$7B", "$7C", "$7D", "$7E", "$7F",
    "$80", "$81", "$82", "$83", "$84", "$85", "$86", "$87",
    "$88", "$89", "$8A", "$8B", "$8C", "$8D", "$8E", "$8F",
    "$90", "$91", "$92", "$93", "$94", "$95", "$96", "$97",
    "$98", "$99", "$9A", "$9B", "$9C", "$9D", "$9E", "$9F",
    "WP ", "$A1", "$A2", "$A3", "$A4", "$A5", "$A6", "$A7",
    "$A8", "$A9", "$AA", "GSB", "TDF", "BDF", "$AE", "$AF",
    "SRC", "OBJ", "LIB", "S16", "RTL", "EXE", "PIF", "TIF",
    "NDA", "CDA", "TOL", "DVR", "LDF", "FST", "$BE", "DOC",
    "PNT", "PIC", "ANI", "PAL", "$C4", "OOG", "SCR", "CDV",
    "FON", "FND", "ICN", "$CB", "$CC", "$CD", "$CE", "$CF",
    "$D0", "$D1", "$D2", "$D3", "$D4", "MUS", "INS", "MDI",
    "SND", "$D9", "$DA", "DBM", "$DC", "DDD", "$DE", "$DF",
    "LBR", "$E1", "ATK", "$E3", "$E4", "$E5", "$E6", "$E7",
    "$E8", "$E9", "$EA", "$EB", "$EC", "$ED", "R16", "PAS",
    "CMD", "$F1", "$F2", "$F3", "$F4", "$F5", "$F6", "$F7",
    "$F8", "OS ", "INT", "IVR", "BAS", "VAR", "REL", "SYS"
};

/*
 * Return a pointer to the three-letter representation of the file type name.
 *
 * Note to self: code down below tests first char for '?'.
 */
/*static*/ const char*
GetFileTypeString(unsigned long fileType)
{
    if (fileType < NELEM(gFileTypeNames))
        return gFileTypeNames[fileType];
    else
        return "???";
}

/*  
 * Sanitize a string.  The Mac likes to stick control characters into
 * things, e.g. ^C and ^M.
 */
static void
MacSanitize(char* str)
{       
    while (*str != '\0') {
        if (*str < 0x20 || *str >= 0x7f)
            *str = '?';
        str++;
    }
}   


/*
 * Load the contents of a DiskFS.
 *
 * Recursively handle sub-volumes.
 */
int
LoadDiskFSContents(DiskFS* pDiskFS, const char* volName,
    ScanOpts* pScanOpts)
{
    static const char* kBlankFileName = "<blank filename>";
    DiskFS::SubVolume* pSubVol = nil;
    A2File* pFile;

    ASSERT(pDiskFS != nil);
    pFile = pDiskFS->GetNextFile(nil);
    while (pFile != nil) {
        char subVolName[128] = "";
        char dispName[128] = "";
        //CString subVolName, dispName;
        RecordKind recordKind;
        unsigned long totalLen, totalCompLen;
        char tmpbuf[16];

        AnalyzeFile(pFile, &recordKind, &totalLen, &totalCompLen);
        if (recordKind == kRecordKindVolumeDirectory) {
            /* skip these */
            pFile = pDiskFS->GetNextFile(pFile);
            continue;
        }

        /* prepend volName for sub-volumes; must be valid Win32 dirname */
        if (volName[0] != '\0')
            snprintf(subVolName, sizeof(subVolName), "_%s", volName);

        const char* ccp = pFile->GetPathName();
        ASSERT(ccp != nil);
        if (strlen(ccp) == 0)
            ccp = kBlankFileName;

        if (subVolName[0] == '\0') {
            strncpy(dispName, ccp, sizeof(dispName));
            dispName[sizeof(dispName) - 1] = '\0';
        } else {
            snprintf(dispName, sizeof(dispName), "%s:%s", subVolName, ccp);
            //dispName = subVolName;
            //dispName += ':';
            //dispName += ccp;
        }
        ccp = dispName;

        int len = strlen(ccp);
        if (len <= 32) {
            fprintf(pScanOpts->outfp, "%c%-32.32s ",
                IsRecordReadOnly(pFile->GetAccess()) ? '*' : ' ',
                ccp);
        } else {
            fprintf(pScanOpts->outfp, "%c..%-30.30s ",
                IsRecordReadOnly(pFile->GetAccess()) ? '*' : ' ',
                ccp + len - 30);
        }
        switch (recordKind) {
        case kRecordKindUnknown:
            fprintf(pScanOpts->outfp, "%s- $%04X  ",
                GetFileTypeString(pFile->GetFileType()),
                pFile->GetAuxType());
            break;
        case kRecordKindDisk:
            snprintf(tmpbuf, sizeof(tmpbuf), "%ldk", totalLen / 1024);
            fprintf(pScanOpts->outfp, "Disk %-6s ", tmpbuf);
            break;
        case kRecordKindFile:
        case kRecordKindForkedFile:
        case kRecordKindDirectory:
            if (pDiskFS->GetDiskImg()->GetFSFormat() == DiskImg::kFormatMacHFS)
            {
                if (recordKind != kRecordKindDirectory &&
                    pFile->GetFileType() >= 0 && pFile->GetFileType() <= 0xff &&
                    pFile->GetAuxType() >= 0 && pFile->GetAuxType() <= 0xffff)
                {
                    /* ProDOS type embedded in HFS */
                    fprintf(pScanOpts->outfp, "%s%c $%04X  ",
                        GetFileTypeString(pFile->GetFileType()),
                        recordKind == kRecordKindForkedFile ? '+' : ' ',
                        pFile->GetAuxType());
                } else {
                    char typeStr[5];
                    char creatorStr[5];
                    unsigned long val;

                    val = pFile->GetAuxType();
                    creatorStr[0] = (unsigned char) (val >> 24);
                    creatorStr[1] = (unsigned char) (val >> 16);
                    creatorStr[2] = (unsigned char) (val >> 8);
                    creatorStr[3] = (unsigned char) val;
                    creatorStr[4] = '\0';

                    val = pFile->GetFileType();
                    typeStr[0] = (unsigned char) (val >> 24);
                    typeStr[1] = (unsigned char) (val >> 16);
                    typeStr[2] = (unsigned char) (val >> 8);
                    typeStr[3] = (unsigned char) val;
                    typeStr[4] = '\0';

                    MacSanitize(creatorStr);
                    MacSanitize(typeStr);

                    if (recordKind == kRecordKindDirectory) {
                        fprintf(pScanOpts->outfp, "DIR   %-4s  ", creatorStr);
                    } else {
                        fprintf(pScanOpts->outfp, "%-4s%c %-4s  ",
                            typeStr,
                            pFile->GetRsrcLength() > 0 ? '+' : ' ',
                            creatorStr);
                    }
                }
            } else {
                fprintf(pScanOpts->outfp, "%s%c $%04X  ",
                    GetFileTypeString(pFile->GetFileType()),
                    recordKind == kRecordKindForkedFile ? '+' : ' ',
                    pFile->GetAuxType());
            }
            break;
        default:
            ASSERT(0);
            fprintf(pScanOpts->outfp, "ERROR  ");
            break;
        }

        char date[64];
        if (pFile->GetModWhen() == 0)
            FormatDate(kDateNone, date);
        else
            FormatDate(pFile->GetModWhen(), date);
        fprintf(pScanOpts->outfp, "%-15s  ", (LPCTSTR) date);

        const char* fmtStr;
        switch (pFile->GetFSFormat()) {
        case DiskImg::kFormatDOS33:
        case DiskImg::kFormatDOS32:
        case DiskImg::kFormatUNIDOS:
            fmtStr = "DOS   ";
            break;
        case DiskImg::kFormatProDOS:
            fmtStr = "ProDOS";
            break;
        case DiskImg::kFormatPascal:
            fmtStr = "Pascal";
            break;
        case DiskImg::kFormatMacHFS:
            fmtStr = "HFS   ";
            break;
        case DiskImg::kFormatCPM:
            fmtStr = "CP/M  ";
            break;
        case DiskImg::kFormatMSDOS:
            fmtStr = "MS-DOS";
            break;
        case DiskImg::kFormatRDOS33:
        case DiskImg::kFormatRDOS32:
        case DiskImg::kFormatRDOS3:
            fmtStr = "RDOS  ";
            break;
        case DiskImg::kFormatGutenberg:
            fmtStr = "Gutenb";
            break;
        default:
            fmtStr = "???   ";
            break;
        }
        if (pFile->GetQuality() == A2File::kQualityDamaged)
            fmtStr = "BROKEN";

        fprintf(pScanOpts->outfp, "%s ", fmtStr);


#if 0
        /* compute the percent size */
        if ((!totalLen && totalCompLen) || (totalLen && !totalCompLen))
            fprintf(pScanOpts->outfp, "---   ");       /* weird */
        else if (totalLen < totalCompLen)
            fprintf(pScanOpts->outfp, ">100%% ");      /* compression failed? */
        else {
            sprintf(tmpbuf, "%02d%%", ComputePercent(totalCompLen, totalLen));
            fprintf(pScanOpts->outfp, "%4s  ", tmpbuf);
        }
#endif

        if (!totalLen && totalCompLen)
            fprintf(pScanOpts->outfp, "   ????");      /* weird */
        else
            fprintf(pScanOpts->outfp, "%8ld", totalLen);

        fprintf(pScanOpts->outfp, "\n");

        pFile = pDiskFS->GetNextFile(pFile);
    }

    /*
     * Load all sub-volumes.
     */
    pSubVol = pDiskFS->GetNextSubVolume(nil);
    while (pSubVol != nil) {
        const char* subVolName;
        int ret;

        subVolName = pSubVol->GetDiskFS()->GetVolumeName();
        if (subVolName == nil)
            subVolName = "+++";     // could probably do better than this

        ret = LoadDiskFSContents(pSubVol->GetDiskFS(), subVolName, pScanOpts);
        if (ret != 0)
            return ret;
        pSubVol = pDiskFS->GetNextSubVolume(pSubVol);
    }

    return 0;
}

/*
 * Open a disk image and dump the contents.
 *
 * Returns 0 on success, nonzero on failure.
 */
int
ScanDiskImage(const char* pathName, ScanOpts* pScanOpts)
{
    ASSERT(pathName != nil);
    ASSERT(pScanOpts != nil);
    ASSERT(pScanOpts->outfp != nil);

    DIError dierr;
    char errMsg[256] = "";
    DiskImg diskImg;
    DiskFS* pDiskFS = nil;

    dierr = diskImg.OpenImage(pathName, '/', true);
    if (dierr != kDIErrNone) {
        snprintf(errMsg, sizeof(errMsg), "Unable to open '%s': %s",
            pathName, DIStrError(dierr));
        goto bail;
    }

    dierr = diskImg.AnalyzeImage();
    if (dierr != kDIErrNone) {
        snprintf(errMsg, sizeof(errMsg), "Analysis of '%s' failed: %s",
            pathName, DIStrError(dierr));
        goto bail;
    }

    if (diskImg.GetFSFormat() == DiskImg::kFormatUnknown ||
        diskImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown)
    {
        snprintf(errMsg, sizeof(errMsg), "Unable to identify filesystem on '%s'",
            pathName);
        goto bail;
    }

    /* create an appropriate DiskFS object */
    pDiskFS = diskImg.OpenAppropriateDiskFS();
    if (pDiskFS == nil) {
        /* unknown FS should've been caught above! */
        ASSERT(false);
        snprintf(errMsg, sizeof(errMsg), "Format of '%s' not recognized.",
            pathName);
        goto bail;
    }

    pDiskFS->SetScanForSubVolumes(DiskFS::kScanSubEnabled);

    /* object created; prep it */
    dierr = pDiskFS->Initialize(&diskImg, DiskFS::kInitFull);
    if (dierr != kDIErrNone) {
        snprintf(errMsg, sizeof(errMsg),
            "Error reading list of files from disk: %s", DIStrError(dierr));
        goto bail;
    }

    fprintf(pScanOpts->outfp, "File: %s\n", pathName);

    int kbytes;
    if (pDiskFS->GetDiskImg()->GetHasBlocks())
        kbytes = pDiskFS->GetDiskImg()->GetNumBlocks() / 2;
    else if (pDiskFS->GetDiskImg()->GetHasSectors())
        kbytes = (pDiskFS->GetDiskImg()->GetNumTracks() *
                pDiskFS->GetDiskImg()->GetNumSectPerTrack()) / 4;
    else
        kbytes = 0;
    fprintf(pScanOpts->outfp, "Disk: %s%s (%dKB)\n", pDiskFS->GetVolumeID(),
        pDiskFS->GetFSDamaged() ? " [*]" : "", kbytes);

    fprintf(pScanOpts->outfp,
        " Name                             Type Auxtyp Modified"
        "         Format   Length\n");
    fprintf(pScanOpts->outfp,
        "------------------------------------------------------"
        "------------------------\n");
    if (LoadDiskFSContents(pDiskFS, "", pScanOpts) != 0) {
        snprintf(errMsg, sizeof(errMsg),
            "Failed while loading contents of '%s'.", pathName);
        goto bail;
    }
    fprintf(pScanOpts->outfp,
        "------------------------------------------------------"
        "------------------------\n\n");

    gStats.goodDiskImages++;

bail:
    delete pDiskFS;

    if (errMsg[0] != '\0') {
        fprintf(pScanOpts->outfp, "Unable to process '%s'\n", pathName);
        fprintf(pScanOpts->outfp, "  %s\n\n", (LPCTSTR) errMsg);
        return -1;
    } else {
        return 0;
    }
}


/*
 * Check a file's status.
 *
 * [ Someday we may want to modify this to handle symbolic links. ]
 */
int
CheckFileStatus(const char* pathname, struct stat* psb, bool* pExists,
    bool* pIsReadable, bool* pIsDir)
{
    int result = 0;
    int cc;

    assert(pathname != nil);
    assert(psb != nil);
    assert(pExists != nil);
    assert(pIsReadable != nil);
    assert(pIsDir != nil);

    *pExists = true;
    *pIsReadable = true;
    *pIsDir = false;

    cc = stat(pathname, psb);
    if (cc) {
        if (errno == ENOENT)
            *pExists = false;
        else
            result = -1;        // stat failed
        goto bail;
    }

    if (S_ISDIR(psb->st_mode))
        *pIsDir = true;

    /*
     * Test if we can read this file.  How do we do that?  The easy but slow
     * way is to call access(2), the harder way is to figure out
     * what user/group we are and compare the appropriate file mode.
     */
    if (access(pathname, R_OK) < 0)
        *pIsReadable = false;

bail:
    return result;
}


/* forward decl */
int ProcessFile(const char* pathname, ScanOpts* pScanOpts);

/*
 * UNIX-style recursive directory descent.  Scan the contents of a directory.
 * If a subdirectory is found, follow it; otherwise, call ProcessFile to
 * handle the file.
 */
int
ProcessDirectory(const char* dirName, ScanOpts* pScanOpts)
{
    StringArray strArray;
    int result = -1;
    DIR* dirp = nil;
    DIR_TYPE* entry;
    char nbuf[MAX_PATH_LEN];    /* malloc might be better; this soaks stack */
    char fssep;
    int len;

    assert(pScanOpts != nil);
    assert(dirName != nil);

#ifdef _DEBUG
    fprintf(gLog, "+++ Processing directory '%s'\n", dirName);
#endif

    dirp = opendir(dirName);
    if (dirp == nil) {
        //err = errno ? errno : -1;
        goto bail;
    }

    fssep = '/';

    /* could use readdir_r, but we don't care about reentrancy here */
    while ((entry = readdir(dirp)) != nil) {
        /* skip the dotsies */
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
            continue;

        len = strlen(dirName);
        if (len + DIR_NAME_LEN(entry) +2 > MAX_PATH_LEN) {
            fprintf(stderr, "ERROR: Filename exceeds %d bytes: %s%c%s\n",
                MAX_PATH_LEN, dirName, fssep, entry->d_name);
            goto bail;
        }

        /* form the new name, inserting an fssep if needed */
        strcpy(nbuf, dirName);
        if (dirName[len-1] != fssep)
            nbuf[len++] = fssep;
        strcpy(nbuf+len, entry->d_name);

        strArray.Add(nbuf);
    }

    /* sort the list, then process the files */
    strArray.Sort(StringArray::CmpAscendingAlpha);
    for (int i = 0; i < strArray.GetCount(); i++)
        (void) ProcessFile(strArray.GetEntry(i), pScanOpts);

    result = 0;

bail:
    if (dirp != nil)
        (void)closedir(dirp);
    return result;
}

/*
 * Process a file.
 *
 * Returns with an error if the file doesn't exist or isn't readable.
 */
int
ProcessFile(const char* pathname, ScanOpts* pScanOpts)
{
    int result = -1;
    bool exists, isDir, isReadable;
    struct stat sb;

    assert(pathname != nil);
    assert(pScanOpts != nil);

#ifdef _DEBUG
    fprintf(gLog, "+++ Processing file or dir '%s'\n", pathname);
#endif

    if (CheckFileStatus(pathname, &sb, &exists, &isReadable, &isDir) != 0) {
        fprintf(stderr, "ERROR: unexpected error while examining '%s'\n",
            pathname);
        goto bail;
    }

    if (!exists) {
        fprintf(stderr, "ERROR: couldn't find '%s'\n", pathname);
        goto bail;
    }
    if (!isReadable) {
        fprintf(stderr, "ERROR: file '%s' isn't readable\n", pathname);
        goto bail;
    }

    if (isDir) {
        result = ProcessDirectory(pathname, pScanOpts);
        gStats.numDirectories++;
    } else {
        result = ScanDiskImage(pathname, pScanOpts);
        gStats.numFiles++;
    }

bail:
    return result;
}


/*
 * Handle a debug message from the DiskImg library.
 */
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
    ASSERT(file != nil);
    ASSERT(msg != nil);

#ifdef _DEBUG
    fprintf(gLog, "%05u %s", gPid, msg);
#endif
}
/*
 * Handle a global error message from the NufxLib library by shoving it
 * through the DiskImgLib message function.
 */
NuResult
NufxErrorMsgHandler(NuArchive* /*pArchive*/, void* vErrorMessage)
{
    const NuErrorMessage* pErrorMessage = (const NuErrorMessage*) vErrorMessage;

    if (pErrorMessage->isDebug) {
        Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
            "<nufxlib> [D] %s\n", pErrorMessage->message);
    } else {
        Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
            "<nufxlib> %s\n", pErrorMessage->message);
    }

    return kNuOK;
}

/*
 * Process every argument.
 */
int
main(int argc, char** argv)
{
    ScanOpts scanOpts;
    scanOpts.outfp = stdout;

#ifdef _DEBUG
    const char* kLogFile = "mdc-log.txt";
    gLog = fopen(kLogFile, "w");
    if (gLog == nil) {
        fprintf(stderr, "ERROR: unable to open log file\n");
        exit(1);
    }
#endif

    int32_t major, minor, bug;
    Global::GetVersion(&major, &minor, &bug);

    printf("MDC for Linux v3.0.0 (DiskImg library v%d.%d.%d)\n",
        major, minor, bug);
    printf("Copyright (C) 2006 by faddenSoft, LLC.  All rights reserved.\n");
    printf("MDC is part of CiderPress, available from http://www.faddensoft.com/.\n");
    NuGetVersion(&major, &minor, &bug, nil, nil);
    printf("Linked against NufxLib v%d.%d.%d and zlib version %s.\n",
        major, minor, bug, zlibVersion());

    if (argc == 1) {
        fprintf(stderr, "\nUsage: mdc file ...\n");
        goto done;
    }

#ifdef _DEBUG
    printf("Log file is '%s'\n", kLogFile);
#endif
    printf("\n");

    Global::SetDebugMsgHandler(MsgHandler);
    Global::AppInit();

    NuSetGlobalErrorMessageHandler(NufxErrorMsgHandler);

    time_t start;
    start = time(NULL);
    printf("Run started at %.24s\n\n", ctime(&start));

    while (--argc) {
        ProcessFile(*++argv, &scanOpts);
    }

    printf("Scan completed in %ld seconds:\n", time(NULL) - start);
    printf("  Directories : %ld\n", gStats.numDirectories);
    printf("  Files       : %ld (%ld good disk images)\n", gStats.numFiles,
        gStats.goodDiskImages);

    Global::AppCleanup();

done:
#ifdef _DEBUG
    fclose(gLog);
#endif

    return 0;
}