ciderpress/linux/MDC.cpp
Andy McFadden 1362c73a7e Gutenberg tweaks
Changed the catalog scan offset so we don't overrun the buffer.

Changed a strcpy() to strncpy().

Added Gutenberg to the list of formats MDC outputs.
2015-01-09 18:24:09 -08:00

895 lines
25 KiB
C++

/*
* 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;
}