path: root/private/windows/diamond/extract.c

/***    extract.c - Main program for EXTRACT.EXE
 *
 *      Microsoft Confidential
 *      Copyright (C) Microsoft Corporation 1994
 *      All Rights Reserved.
 *
 *  Author:
 *      Benjamin W. Slivka
 *
 *  History:
 *      19-Feb-1994 bens    Initial version (started with diamond.c)
 *      22-Feb-1994 bens    Implement file extract
 *      03-Mar-1994 bens    Split cabinet paths from cabinet file names
 *      08-Mar-1994 bens    Add date/time/attribute display
 *      09-Mar-1994 bens    Improve response to FDI errors
 *      16-Mar-1994 bens    More FDI error codes
 *      21-Mar-1994 bens    Log all open/close calls to see if we are
 *                              losing file handles in FDI.LIB.
 *      28-Mar-1994 bens    Handle fdintCABINET_INFO, support /A switch
 *      30-Mar-1994 bens    Move MS-DOS/Win32 knowledge to fileutil.*
 *      31-Mar-1994 bens    Add SMALL_DOS to test small model FDI client
 *      01-Apr-1994 bens    Add /D and /E switches, support full command
 *                              line behavior.
 *      07-Apr-1994 bens    Add crypto support (at least for debugging)
 *      06-May-1994 bens    Improve /D display for long filenames
 *      13-May-1994 bens    Add prompting for next cabinet, DMF support
 *      27-May-1994 bens    Include correct strings for localization
 *      03-Jun-1994 bens    Report error on correct cabinet
 *      07-Jun-1994 bens    Localization enabled
 *      21-Jun-1994 bens    Localization enabled
 *      08-Jul-1994 bens    Quantum Spill File, self-extracting cabinets!
 *      11-Jul-1994 bens    Use 24-hour time format if am/pm strings are empty
 *      26-Jul-1994 bens    Add /C switch; no switches give /? help
 *      05-Aug-1994 bens    Chicago bug 13214 (don't show partial file info
 *                          unless name matches request).  Chicago bug 13221
 *                          (truncate extracted file to specified size, in
 *                          case file already existed and was larger!).
 *                          Chicago bug 9646 (give details of Quantum
 *                          decompress failure -- out of RAM, spill file).
 *                          Implement overwrite prompt and /Y switch.
 *      14-Dec-1994 bens    Include Floppy changeline fix from
 *                              ..\dmf\dmftsr\fixchg.c
 *      12-Mar-1995 bens    Define NOT_US_PC flag to disable use of DMF hook
 *                          and FixChangeline code.  Also, check COMSPEC to
 *                          detect boot drive, instead of hard-coding C:, so
 *                          that the Quantum spill file can default to the
 *                          boot drive if no TEMP path is found.  In the far
 *                          east, the hard disk boot drive is A:, so that's
 *                          why we have to check!
 *      31-Mar-1995 jeffwe  Fix Command line ambiguity when no /D or /E
 *                          option is specified
 *       2-Apr-1995 jeffwe  Fix file time/date set to change the correct
 *                          file when rename option being used
 *
 *
 *  Notes:
 *      A self-extracting cabinet file can be created using DIAMOND.EXE and
 *      EXTRACT.EXE very simply:
 *          1) Create a cabinet file using DIAMOND.EXE
 *          2) COPY /B EXTRACT.EXE foo.cab foo.exe
 *      When EXTRACT starts executing, it compares the file size indicated
 *      in the EXE headers (MZ or PE, as appropriate) with the size of the
 *      file indicated in argv[0].  If the argv[0] size is greater, and a
 *      cabinet file appears there, then EXTRACT goes into self-extracting
 *      mode!
 */

//** Definitions for the banner -- see extract.msg:pszBANNER

#define szBANNER_VERSION          "1.00.0540"
#define szBANNER_MONTH            "02"
#define szBANNER_DAY              "01"
#define szBANNER_YEAR             "96"
#define szBANNER_COPYRIGHT_YEARS  "1994-1996"

#ifdef BIT16
#define szBANNER_BITNESS          "16"  // 16-bit version
#else
#define szBANNER_BITNESS          "32"  // 32-bit version
#endif

#ifdef NOT_US_PC
#define szBANNER_DMF_INDICATOR    "n"   // Not IBM BIOS version (i.e., NEC)
#else
#define szBANNER_DMF_INDICATOR    ""
#endif


#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <malloc.h>
#include <fcntl.h>
#include <sys\types.h>
#include <sys\stat.h>
#include <io.h>
#include <errno.h>
#include <direct.h>
#include <conio.h>

#ifdef BIT16
#include <dos.h>
#include "fixchg.h"
#else // !BIT16
//** Get minimal Win32 definitions
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef ERROR    // Override stupid "#define ERROR 0" in wingdi.h
#endif // !BIT16

#include "types.h"
#include "asrt.h"
#include "error.h"
#include "mem.h"
#include "message.h"

#include "filelist.h"
#include "fileutil.h"

#include "dmfon.h"              // DMF support

#include <extract.msg> // LOCALIZED for EXTRACT.EXE -- specify "cl /Ipath"

#ifdef BIT16
#include "chuck\fdi.h"
#else // !BIT16
#include "chuck\nt\fdi.h"
#endif // !BIT16


//** Constants

#define cbMAX_LINE          256 // Maximum output line length


#define cMAX_CAB_FILE_OPEN    2 // Maximum simultaneous opens on a single
								// cabinet file

//** Error causes for failure of spill file
typedef enum {
	seNONE,                     // No error
	seNOT_ENOUGH_MEMORY,        // Not enough RAM
	seCANNOT_CREATE,            // Cannot create spill file
	seNOT_ENOUGH_SPACE,         // Not enough space for spill file
} SPILLERR; /* se */


//** Types

typedef enum {
	actBAD,         // Invalid action
	actHELP,        // Show help
	actDEFAULT,     // Perform default action based on command line arguments
	actDIRECTORY,   // Force display of cabinet directory
	actEXTRACT,     // Force file extraction
	actCOPY,        // Do single file-to-file copy
} ACTION;   /* act */


typedef struct {
	char    achCabPath[cbFILE_NAME_MAX]; // Cabinet file path
	char    achCabFilename[cbFILE_NAME_MAX]; // Cabinet file name.ext
	char    achDiskName[cbFILE_NAME_MAX]; // User readable disk label
	USHORT  setID;
	USHORT  iCabinet;
} CABINET; /* cab */
typedef CABINET *PCABINET; /* pcab */


#ifdef ASSERT
#define sigSESSION MAKESIG('S','E','S','S')  // SESSION signature
#define AssertSess(psess) AssertStructure(psess,sigSESSION);
#else // !ASSERT
#define AssertSess(psess)
#endif // !ASSERT

typedef struct {
#ifdef ASSERT
	SIGNATURE   sig;                // structure signature sigSESSION
#endif
	ACTION      act;                // Action to perform
	HFILELIST   hflist;             // List of files specified on cmd line
	BOOL        fAllCabinets;       // TRUE => Process continutation cabs
	BOOL        fOverwrite;         // TRUE => Overwrite existing files
	BOOL        fNoLineFeed;        // TRUE if last printf did not have \n
	BOOL        fSelfExtract;       // TRUE if self-extracting
	long        cbSelfExtract;      // Size of EXE portion of self-ex cabinet
	int         ahfSelf[cMAX_CAB_FILE_OPEN]; // Cabinet file handles
	int         cErrors;            // Count of errors encountered
	HFDI        hfdi;               // FDI context
	ERF         erf;                // FDI error structure
	long        cFiles;             // Total files processed
	long        cbTotalBytes;       // Total bytes extracted
	PERROR      perr;               // Pass through FDI
	SPILLERR    se;                 // Spill file error
	long        cbSpill;            // Size of spill file requested
	char        achSelf[cbFILE_NAME_MAX]; // Name of our EXE file
	char        achMsg[cbMAX_LINE*2]; // Message formatting buffer
	char        achLine[cbMAX_LINE]; // Line formatting buffer
	char        achLocation[cbFILE_NAME_MAX]; // Output directory
	char        achFile[cbFILE_NAME_MAX]; // Current filename being extracted
	char        achDest[cbFILE_NAME_MAX]; // Forced destination file name
	char        achCabPath[cbFILE_NAME_MAX]; // Path to look for cabinet file

	BOOL        fContinuationCabinet; // TRUE => not 1st cabinet processed
	BOOL        fShowReserveInfo;   // TRUE => show RESERVEd cabinet info

	//** fNextCabCalled allows us to figure out which of the acab[] entries
	//   to use if we are processing all file in a cabinet set (i.e., if
	//   fAllCabinet is TRUE).  If fdintNEXT_CABINET has never been called,
	//   then acab[1] has the information for the next cabinet.  But if
	//   it has been called, then fdintCABINET_INFO will have been called
	//   at least twice (once for the first cabinet, and once at least for
	//   a continuation cabinet), and so acab[0] is the cabinet we need to
	//   pass to a subsequent FDICopy() call.
	BOOL        fNextCabCalled;     // TRUE => GetNextCabinet called
	CABINET     acab[2];            // Last two fdintCABINET_INFO data sets

} SESSION;  /* sess */
typedef SESSION *PSESSION;  /* psess */


/*
 ** Spill file statics for Quantum
 */
int  hfSpillFile;                       // File handle
char achSpillFile[cbFILE_NAME_MAX];     // File path

/*
 ** Global state for self-extract
 */
PSESSION    psessG;


//** Function Prototypes

FNASSERTFAILURE(fnafReport);

HFILESPEC addFileSpec(PSESSION psess, char *pszArg, PERROR perr);
BOOL      checkWildMatches(PSESSION psess, char *pszFile, PERROR perr);
BOOL      doCabinet(PSESSION psess, PERROR perr);
BOOL      doCopy(PSESSION psess, PERROR perr);
BOOL      ensureCabinet(PSESSION  psess,
						char     *pszPath,
						int       cbPath,
						char     *pszFile,
						char     *pszLabel,
						USHORT    setID,
						USHORT    iCabinet,
						BOOL      fLoop,
						BOOL      fPromptOnly,
						PERROR    perr);
BOOL      checkOverwrite(PSESSION  psess,
						 char     *pszFile,
						 PERROR    perr,
						 int      *prc);
BOOL      checkSelfExtractingCab(PSESSION  psess,
								 int       cArg,
								 char     *apszArg[],
								 PERROR    perr);
char     *getBootDrive(void);
BOOL      parseCommandLine(PSESSION psess,int cArg,char *apszArg[],PERROR perr);
void      printError(PSESSION psess, PERROR perr);
void      pszFromAttrFAT(char *psz, int cb, WORD attrFAT);
void      pszFromMSDOSTime(char *psz, int cb, WORD date, WORD time);
int       updateCabinetInfo(PSESSION psess, PFDINOTIFICATION pfdin);


//** FDI callbacks and related functions
FNALLOC(fdiAlloc);
FNFREE(fdiFree);
FNFDINOTIFY(fdiNotifyDir);
FNFDINOTIFY(fdiNotifyExt);
FNFDINOTIFY(doGetNextCab);

FNFDIDECRYPT(fdiDecryptDir);
FNFDIDECRYPT(fdiDecryptExt);

void mapFDIError(PERROR perr,PSESSION psess, char *pszCabinet, PERF perf);


//** File I/O wrapper functions
int  FAR DIAMONDAPI wrap_open(const char FAR *, int, int);
UINT FAR DIAMONDAPI wrap_read(int, void FAR *, unsigned int);
UINT FAR DIAMONDAPI wrap_write(int, const void FAR *, unsigned int);
int  FAR DIAMONDAPI wrap_close(int);
long FAR DIAMONDAPI wrap_lseek(int, long, int);

#ifdef SMALL_DOS
#define STRCPY(dst,src) _fstrcpy((char far *)dst,(char far *)src)
#else
#define STRCPY(dst,src) strcpy(dst,src)
#endif

//BUGBUG 08-Jul-1994 bens Generate debug output
//#define DEBUG_FDI   1

#ifdef DEBUG_FDI
#define dbg(a) a
#else
#define dbg(a)
#endif

//** Functions

/***    main - Extract main program
 *
 *  See DIAMOND.DOC for spec and operation.
 *
 *  NOTE: We're sloppy, and don't free resources allocated by
 *        functions we call, on the assumption that program exit
 *        will clean up memory and file handles for us.
 */
int __cdecl main(int cArg, char *apszArg[])
{
	char        ach[cbMSG_MAX];
	ERROR       err;
	PSESSION    psess;

// #define NTVCPP_DEBUG_HACK
#ifdef NTVCPP_DEBUG_HACK
	_chdir("\\elroy\\diamond\\layout\\testnew");
#endif

	AssertRegisterFunc(fnafReport);     // Register assertion reporter
	ErrClear(&err);                     // No error
	err.pszFile = NULL;                 // No file being processed, yet
	achSpillFile[0] = '\0';             // No name constructed, yet

#ifdef BIT16
#ifndef NOT_US_PC
	//** Make sure we can read DMF disks -- only for pre-Chicago systems
	EnableDMFSupport();

	//** Turn off floppy disk changeline support to make sure systems
	//   with faulty change lines don't choke on disk 2 in the case
	//   where disk 1 is non-DMF and disk 2 is DMF.
	FixChangelines();
#endif
#endif

	//** Initialize session
	psess = MemAlloc(sizeof(SESSION));
	if (!psess) {
		ErrSet(&err,pszEXTERR_NO_SESSION);
		printError(psess,&err);
		exit(1);
	}
	SetAssertSignature((psess),sigSESSION);
	psessG = psess;                     // Save for wrap_open/wrap_close
	psess->fOverwrite           = FALSE; // Default to being save
	psess->fAllCabinets         = FALSE; // Don't do continuation cabinets
	psess->fNextCabCalled       = FALSE;
	psess->fContinuationCabinet = FALSE;
	psess->fShowReserveInfo     = FALSE;
	psess->fSelfExtract         = FALSE;
	psess->hflist               = NULL;
	psess->hfdi                 = NULL;
	psess->fNoLineFeed          = 0;     // TRUE if last printf did not have \n
	psess->cFiles               = 0;     // No files, yet
	psess->cbTotalBytes         = 0;     // No bytes, yet
	psess->se                   = seNONE; // No spill file error

	//** Print Extract banner
	MsgSet(ach,pszBANNER,"%s%s%s%s%s%s%s",
			szBANNER_BITNESS,
			szBANNER_VERSION,
			szBANNER_DMF_INDICATOR,
			szBANNER_MONTH,
			szBANNER_DAY,
			szBANNER_YEAR,
			szBANNER_COPYRIGHT_YEARS);
	printf(ach);

	//** Parse command line
	if (!parseCommandLine(psess,cArg,apszArg,&err)) {
		printError(psess,&err);
		return 1;
	}

	//** Quick out if command line help is requested
	if (psess->act == actHELP) {          // Do help if any args, for now
		printf("\n");                   // Separate banner from help
		printf(pszCMD_LINE_HELP);
		return 0;
	}

	//** Quick out for COPY command
	if (psess->act == actCOPY) {
		if (!doCopy(psess,&err)) {
			printError(psess,&err);
			return 1;
		}
		//** Success
		return 0;
	}

	//** Have some work to do -- go do it
	if (!doCabinet(psess,&err)) {
		printError(psess,&err);
		//** Make sure we delete spill file
		if (hfSpillFile != -1) {
			wrap_close(hfSpillFile);    // Close and delete it
		}
		return 1;
	}

	//** See if we actually got any files
	if (psess->cFiles == 0) {
		MsgSet(psess->achMsg,pszEXT_NO_MATCHING_FILES);
		printf("%s\n",psess->achMsg);
	}
	else if (psess->act == actDIRECTORY) {
		//** Print out file and byte count
		MsgSet(psess->achMsg,
			   psess->cFiles == 1 ? pszEXT_SUMMARY1 : pszEXT_SUMMARY2,
			   "%,13ld%,13ld",
			   psess->cFiles, psess->cbTotalBytes);
		printf("%s\n",psess->achMsg);
	}

	//** Free resources
	AssertSess(psess);
	ClearAssertSignature((psess));
	MemFree(psess);

	//** Success
	return 0;
} /* main */


/***    doCopy - Copy one file
 *
 *  Entry:
 *      psess - Description of operation to perform
 *      perr  - ERROR structure
 *
 *  Exit-Success:
 *      Returns TRUE; file copied
 *
 *  Exit-Failure:
 *      Returns FALSE; error
 *
 *  NOTE:
 *      Supported SRC/DST syntax:
 *          Src     Dst     Example
 *          ----    ----    --------------------------
 *          file    dir     "foo.exe ."; "foo.exe c:\dir"
 *          file    file    "foo.exe c:bar.exe"
 */
BOOL doCopy(PSESSION psess, PERROR perr)
{
	char            achDst[cbFILE_NAME_MAX]; // Buffer for src file name
	HFILESPEC       hfspec;
	char           *pszSrc;
	char           *pszSrcJustFile;
	char           *pszDst;
	int             rc;
	struct _stat    stat;

	//** Get the source file
	hfspec = FLFirstFile(psess->hflist);
	Assert(hfspec != NULL);
	pszSrc = FLGetSource(hfspec);
	Assert(pszSrc!=NULL);
	Assert(*pszSrc);

	//** Get the destination file
	hfspec = FLNextFile(hfspec);        // We have something
	Assert(hfspec != NULL);
	pszDst = FLGetSource(hfspec);
	Assert(pszDst!=NULL);
	Assert(*pszDst);

	//** Determine if destination is a directory
	if (-1 != _stat(pszDst,&stat)) {    // File/Dir exists
		//** Destination exists
		if (stat.st_mode & _S_IFDIR) {  // It is a directory
			//** It is a directory; get just file name and extension of source
			if (!(pszSrcJustFile = getJustFileNameAndExt(pszSrc,perr))) {
				return FALSE;
			}
			//** Construct destination name
			if (!catDirAndFile(
					 achDst,            // Buffer for full path
					 sizeof(achDst),    // Size of buffer
					 pszDst,            // Destination directory
					 pszSrcJustFile,    // File name
					 NULL,              // Don't have alternate name
					 perr)) {
				return FALSE;           // Failure
			}
			//** Use constructed name
			pszDst = achDst;
		}
	}

	//** Make sure it's OK to overwrite destination file
	if (!checkOverwrite(psess,pszDst,perr,&rc)) {
		//** Ignore skip/abort return code in rc
		return TRUE;                    // Skip file copy, everything is OK
	}

	//** Tell user we're copying the file
	MsgSet(psess->achMsg,pszEXT_EXTRACTING_FILE2,"%s%s",pszSrc,pszDst);
	printf("%s\n",psess->achMsg);

	//** Do the file copy
	return CopyOneFile(pszDst,          // destination
					   pszSrc,          // source
					   TRUE,            // do the copy
					   32768U,          // copy buffer size
					   NULL,            // don't override date/time/attr
					   NULL,            // no callback context
					   perr);
} /* doCopy() */


/***    doCabinet - Show contents of one or more cabinet files
 *
 *  Entry:
 *      psess - Description of operation to perform
 *      perr  - ERROR structure
 *
 *  Exit-Success:
 *      Returns TRUE; directory displayed
 *
 *  Exit-Failure:
 *      Returns FALSE; perr filled in with details.
 */
BOOL doCabinet(PSESSION psess, PERROR perr)
{
	char            achFile[cbFILE_NAME_MAX]; // Buffer for cabinet file
	FDICABINETINFO  fdici;
	BOOL            fCompatibilityCabinet; // TRUE => Exactly 1 file in 1 cabinet
	int             hfCab = -1;         // File handle for peeking at cabinet
	HFILESPEC       hfspec;
	int             iCab;
	PFNFDINOTIFY    pfnfdin;
	PFNFDIDECRYPT   pfnfdid;
	char FAR       *pbMemReserve;       // Make sure we have some working mem
	char           *pszCabinet;         // Cabinet filespec
	char           *pszCabFile;         // Cabinet filename.ext
	char           *pszDestOrPattern;   // Destination or first pattern

	//** Get the cabinet name
	hfspec = FLFirstFile(psess->hflist);
	Assert(hfspec != NULL);             // Must have at least one file
	pszCabinet = FLGetSource(hfspec);
	Assert(pszCabinet!=NULL);
	Assert(*pszCabinet);

	//** Get the destination file name or first pattern, if present
	if (NULL != (hfspec = FLNextFile(hfspec))) { // We have something
		pszDestOrPattern = FLGetSource(hfspec);
		Assert(pszDestOrPattern!=NULL);
		//** NOTE: hfspec must remain pointing to this 2nd file all the
		//         way down below where we may need to change its value!
	}
	else {
		pszDestOrPattern = NULL;        // No second argument on command line
	}

	//** Remember that we have not yet created a spill file
	hfSpillFile = -1;                   // No spill file, yet

	//** Prevent FDI from sucking up all available memory
	//   Why 2048?  That's enough for 4 paths, which is more than we
	//   will ever need.
	pbMemReserve = fdiAlloc(2048);
	if (!pbMemReserve) {
		ErrSet(perr,pszFDIERR_ALLOC_FAIL,"%s",pszCabinet);
		return FALSE;
	}

	//** Create FDI context so we can get info from the cabinet file
	if (!(psess->hfdi = FDICreate(fdiAlloc,
							fdiFree,
							wrap_open,
							wrap_read,
							wrap_write,
							wrap_close,
							wrap_lseek,
							cpuUNKNOWN, // Let FDI do the CPU detection
							&(psess->erf)
						   ))) {
		//** FDICreate failed, generate error message
		mapFDIError(perr,psess,pszCabinet,&(psess->erf));
		fdiFree(pbMemReserve);          // Free reserved memory
		return FALSE;
	}
	fdiFree(pbMemReserve);              // Free it so we can use it

	//** Make sure file is a cabinet, and get cabinet info
	if (-1 == (hfCab = wrap_open(pszCabinet,_O_BINARY | _O_RDONLY,0))) {
		ErrSet(perr,pszEXTERR_CANNOT_OPEN_FILE,"%s",pszCabinet);
		goto cleanup;
	}
	if (!FDIIsCabinet(psess->hfdi,hfCab,&fdici)) {
		if (!ErrIsError(perr)) {        // Have to set error message
			ErrSet(perr,pszEXTERR_NOT_A_CABINET,"%s",pszCabinet);
		}
		goto cleanup;
	}
	wrap_close(hfCab);
	hfCab = -1;

	//** No Default Destination
	psess->achDest[0] = '\0';

	//** If no mode specified, figure out what mode we should be in:
	//
	//  The extract command has ambiguous syntax so we apply the following
	//  rules to resolve the ambiguity.
	//
	//  Most cabinet file authors use DIAMOND.EXE to create a set of
	//  cabinet files with many files in it.  A typical cabinet set would
	//  look like:
	//  (1) Cab#1
	//          foo.1
	//          foo.2
	//          foo.3 - partial
	//      Cab#2
	//          foo.3 - continued
	//          ...
	//
	//  However, there are some "old-style" customers of DIAMOND.EXE that
	//  like to compress each file independently, producing a "set" of
	//  cabinet files that each contain exactly one file, i.e.:
	//  (2) excel.ex_
	//      excel.in_
	//      setup.in_
	//
	//  The "_" character in the extension is a hint that the file is
	//  compressed.  However, this isn't useful to this program
	//
	//  Now, the question is, what does the customer want to have happen
	//  when she types "EXTRACT foo.cab bar"?  For the multi-file cabinet
	//  case (1) above, this means "seach foo.cab and extract all files
	//  that are named bar".  BUT, for the case (2), we have a compatibility
	//  constraint -- she thinks this means "extract the compressed
	//  file foo.cab and call the resulting uncompressed file bar".
	//
	//  Another question is what does the customer want to have happen
	//  when she types "EXTRACT foo.cab"?   For the multi-file cabinet
	//  case (1) above this means list the contents of the cabinet.
	//  But for case (2), we have a compatibility constraint -- customers
	//  think this means "extract the compressed file foo.cab".
	//
	//
	//  A cabinet is of type (1) if it contains more than one file,
	//  or has either a previous or next cabinet.  Otherwise, it is of
	//  type (2), i.e., the cabinet has exactly one file, and has no
	//  previous or next cabinet.

	if (psess->act == actDEFAULT) {     // No action specified on command line
		//** Determine if cabinet is of type (2) described above.
		fCompatibilityCabinet = (fdici.cFiles == 1) &&
								(! (fdici.hasprev || fdici.hasnext));

		//** Now figure out what customer really wants
		if (pszDestOrPattern)  {        // extract foo.cab bar
			psess->act = actEXTRACT;
			if (fCompatibilityCabinet) {
				// Special Case Rename (see above (2))
				strcpy(psess->achDest, pszDestOrPattern);
				if (!FLSetSource(hfspec,pszALL_FILES,perr))  {
					goto cleanup;
				}
			}
		} else {                        // extract foo.cab
			if (fCompatibilityCabinet) {
				// Special Case Extract (see above (2))
				psess->act = actEXTRACT;
			} else {
				psess->act = actDIRECTORY;
			}
		}
	}

	//** Supply a default pattern if no pattern is present
	if (!pszDestOrPattern) {
		if (addFileSpec(psess,pszALL_FILES,perr) == NULL) {
			ErrSet(perr,pszEXTERR_COULD_NOT_ADD_FILE,"%s",pszALL_FILES);
			goto cleanup;
		}
	}

	//** Now, select the appropriate FDI notification function
	Assert((psess->act == actEXTRACT) || (psess->act == actDIRECTORY));
	pfnfdin = (psess->act == actEXTRACT) ? fdiNotifyExt : fdiNotifyDir;
	if (fdici.fReserve) {               // Reserved area(s) present
		pfnfdid = (psess->act == actEXTRACT) ? fdiDecryptExt : fdiDecryptDir;
	}
	else {
		pfnfdid = NULL;                 // No reserved areas
	}

	//** Split cabinet spec into path and filename.ext
	pszCabFile = getJustFileNameAndExt(pszCabinet,perr);
	if (pszCabFile == NULL) {
		goto cleanup;                   // perr is already filled in
	}
	strcpy(achFile,pszCabFile);

	//** Need to trim off file name and keep just cabinet path
	strcpy(psess->achCabPath,pszCabinet);         // Store in our buffer
	psess->achCabPath[pszCabFile - pszCabinet] = '\0'; // Trim off file name

	psess->perr = perr;                 // Pass perr through FDI
	//** Do cabinets until there are no more, or an error occurs
	while ( (strlen(achFile) > 0) && !ErrIsError(perr) ) {
		//** Show which cabinet we are processing
		MsgSet(psess->achMsg,pszEXT_CABINET_HEADER,"%s",achFile);
		printf("\n%s\n\n",psess->achMsg);

		//** Do the cabinet
		if (!FDICopy(psess->hfdi,       // FDI context
					 achFile,           // Cabinet file name.ext
					 psess->achCabPath, // Path to cabinet
					 0,                 // Flags (???)
					 pfnfdin,           // Notifcation callback
					 pfnfdid,           // Decrypt callback
					 psess              // Our context
					)) {
			//** NOTE: psess->achCabPath *may* get changed during an
			//         fdintNEXT_CABINET callback if we had to prompt the
			//         use for a different path!

			//** FDICopy failed, construct error message
			if (!ErrIsError(perr)) {    // Need to set error message
				if (psess->fNextCabCalled) {
					//** A continuation cabinet had the problem
					catDirAndFile(
						achFile,                // Buffer for full path
						sizeof(achFile),        // Size of buffer
						psess->acab[1].achCabPath,     // Cabinet path
						psess->acab[1].achCabFilename, // Cabinet file name
						NULL,                   // Don't have alternate name
						perr);
					//** Ignore any errrors
				}
				//** Construct error message
				mapFDIError(perr,psess,achFile,&(psess->erf));

				//** Delete file if created, with the assumption that
				//   we were not able to completely write the file
				//   (for example, if the destination disk ran out of space!)
				if (psess->erf.erfOper == FDIERROR_TARGET_FILE) {
					//** Ignore errors, if any
					_unlink(psess->achFile);
				}
			}
		}
		else {
			//** OK so far, see if any more cabinets to process
			if (psess->fAllCabinets) {
				//** Skip "starts in ..." messages for subsequent cabinets
				psess->fContinuationCabinet = TRUE;

				//** Copy next cabinet file (ach[] is empty if no more!)
				iCab = psess->fNextCabCalled ? 0 : 1; // Select correct cabinet
				strcpy(achFile,psess->acab[iCab].achCabFilename);
				psess->fNextCabCalled = FALSE; // Reset flag

				//** If there is another cabinet to process, make sure it
				//   is available; psess->achCabPath may be edited if we
				//   can't find the cabinet until the user supplies another
				//   path; perr will be set if an error occurs.
				if (achFile[0] != '\0') { // Another cabinet
					ensureCabinet(psess,
								  psess->achCabPath,
								  sizeof(psess->achCabPath),
								  achFile,
								  psess->acab[iCab].achDiskName,
								  psess->acab[iCab].setID,
								  (USHORT)(psess->acab[iCab].iCabinet+1),
								  TRUE,  // Loop until right cab or abort
								  FALSE, // Check cabinet
								  perr);
		}
			}
			else {
				achFile[0] = '\0';      // Done
			}
		}
	}

cleanup:
	if (hfCab != -1) {
		wrap_close(hfCab);
	}

	if (!FDIDestroy(psess->hfdi)) {
		//** Only set error if we don't already have one
		if (!ErrIsError(perr)) {
			ErrSet(perr,pszEXTERR_FDIDESTROY_FAILED);
		}
	}
	psess->perr = NULL;

	//** Return success/failure indication
	return !ErrIsError(perr);
} /* doCabinet() */


/***    fdiNotifyDir - Callback from FDICopy for Directory display
 *
 *  Entry:
 *      fdint - type of notification
 *      pfdin - data for notification
 *
 *  Exit-Success:
 *      Return value varies (see FDI.H:PFNFDINOTIFY type)
 *
 *  Exit-Failure:
 *      Return value varies (see FDI.H:PFNFDINOTIFY type)
 */
FNFDINOTIFY(fdiNotifyDir)
{
	char        achAttr[10];
	PERROR      perr;
#ifdef SMALL_DOS
	PSESSION    psess=(PSESSION)(void *)(short)(long)pfdin->pv;
	char        szLocal[cbFILE_NAME_MAX];
#else
	PSESSION    psess=(PSESSION)pfdin->pv;
#endif

	AssertSess(psess);
	perr = psess->perr;

	switch (fdint) {
	case fdintCABINET_INFO:
		return updateCabinetInfo(psess,pfdin);

	case fdintCOPY_FILE:
		//** See if filspec matches specified patterns
#ifdef SMALL_DOS
	_fstrcpy(szLocal,pfdin->psz1);
#else
#define szLocal pfdin->psz1
#endif
		if (!checkWildMatches(psess,szLocal,perr)) {
			//** Either no match, or failure -- figure out which
			if (ErrIsError(perr)) {
				return -1;              // Error, abort
			}
			else {
				return 0;               // No error, skip this file
			}
		}

		//** Show directory
		pszFromMSDOSTime(psess->achMsg,
						 sizeof(psess->achMsg),
						 pfdin->date,
						 pfdin->time);
		pszFromAttrFAT(achAttr, sizeof(achAttr), pfdin->attribs);
		MsgSet(psess->achLine,
			   pszEXT_FILE_DETAILS,
#ifdef SMALL_DOS
			   "%s%s%,13ld%-Fs",
#else
			   "%s%s%,13ld%-s",
#endif
			   psess->achMsg,achAttr,pfdin->cb,pfdin->psz1);
		printf("%s\n",psess->achLine);

		psess->cFiles++;
		psess->cbTotalBytes += pfdin->cb;
		return 0;                       // Skip file, do not copy

	case fdintPARTIAL_FILE:
		//** Construct output filespec
#ifdef SMALL_DOS
	_fstrcpy(szLocal,pfdin->psz1);
#else
#define szLocal pfdin->psz1
#endif

		//** See if filspec matches specified patterns
		if (!checkWildMatches(psess,szLocal,perr)) {
			//** Either no match, or failure -- figure out which
			if (ErrIsError(perr)) {
				return -1;              // Error, abort
			}
			else {
				return 0;               // No error, skip this file
			}
		}

		//** Only show partial file messages for first cabinet
		if (!psess->fContinuationCabinet) { // First cabinet
			MsgSet(psess->achMsg,pszEXT_PARTIAL_FILE,
#ifdef SMALL_DOS
				"%Fs%Fs%Fs",
#else
				"%s%s%s",
#endif
					pfdin->psz1,pfdin->psz2,pfdin->psz3);
			printf("%s\n",psess->achMsg);
		}
		return 0;                       // Continue

	case fdintNEXT_CABINET:
		return doGetNextCab(fdint,pfdin);

	default:
		printf("UNKNOWN NOTIFICATION: %d\n",fdint);
		return 0;   /* ??? */
	}
} /* fdiNotifyDir() */


/***    fdiNotifyExt - Callback from FDICopy for file extraction
 *
 *  <<< Extract files! >>>
 *
 *  Entry:
 *      fdint - type of notification
 *      pfdin - data for notification
 *
 *  Exit-Success:
 *      Return value varies (see FDI.H:PFNFDINOTIFY type)
 *
 *  Exit-Failure:
 *      Return value varies (see FDI.H:PFNFDINOTIFY type)
 */
FNFDINOTIFY(fdiNotifyExt)
{
	int             fh;
	FILETIMEATTR    fta;
	PERROR          perr;
	char           *pszDestinationFile;
	int             rc;
#ifdef SMALL_DOS
	PSESSION        psess=(PSESSION)(void *)(short)(long)pfdin->pv;
	char            szLocal[cbFILE_NAME_MAX];
#else
	PSESSION        psess=(PSESSION)pfdin->pv;
#endif

	AssertSess(psess);
	perr = psess->perr;

	//** Reset the spill file error code;
	//   We know that FDI is OK right now if it is asking us if we want
	//   to extract this file, so reset the spill file error code.  If
	//   we did not, then it may have seNOT_ENOUGH_MEMORY (for example)
	//   as a result of Quantum trying to eat up all available memory,
	//   and a real decompression failure would be reported as an out
	//   of memory problem.
	psess->se = seNONE;

	switch (fdint) {
	case fdintCABINET_INFO:
		return updateCabinetInfo(psess,pfdin);

	case fdintCOPY_FILE:
		//** Construct output filespec
#ifdef SMALL_DOS
	_fstrcpy(szLocal,pfdin->psz1);
#else
#define szLocal pfdin->psz1
#endif
		//** See if filspec matches specified patterns
		if (!checkWildMatches(psess,szLocal,perr)) {
			//** Either no match, or failure -- figure out which
			if (ErrIsError(perr)) {
				return -1;              // Error, abort
			}
			else {
				return 0;               // No error, skip this file
			}
		}

		//** Figure out what destination file name should be
		if (psess->achDest[0] != '\0') { // Override name from cabinet
			pszDestinationFile = psess->achDest;
		}
		else {
			pszDestinationFile = szLocal;
		}

		//** Construct full destination file name
		if (!catDirAndFile(psess->achFile,      // Buffer for output filespec
						   sizeof(psess->achFile), // Size of output buffer
						   psess->achLocation,  // Output directory
						   pszDestinationFile,  // Output file name
						   NULL,                // Don't have alternate name
						   perr)) {
			return -1;                  // Abort with error;
		}

		//** Make sure output directory exists
		if (!ensureDirectory(psess->achFile,TRUE,perr)) {
			return -1;                  // perr already filled in
		}

		//** Do overwrite processing
		if (!checkOverwrite(psess,psess->achFile,perr,&rc)) {
			return rc;                  // Either Skip or Abort
		}

		//** Create file
		fh = wrap_open(psess->achFile,
					_O_BINARY | _O_RDWR | _O_CREAT, // No translation, R/W
					_S_IREAD | _S_IWRITE); // Attributes when file is closed
		if (fh == -1) {
			ErrSet(psess->perr,pszEXTERR_CANNOT_CREATE_FILE,"%s",psess->achFile);
			return -1;                  // Failure
		}

		//** Truncate file (in case it already existed and was larger)
		if (0 != _chsize(fh, 0)) {
			//** Not the best error, but avoids more localization!
			ErrSet(psess->perr,pszEXTERR_CANNOT_CREATE_FILE,"%s",psess->achFile);
			wrap_close(fh);
		}

		//** Show status
		if (pszDestinationFile == szLocal) {  // File name is not changed
			MsgSet(psess->achMsg,pszEXT_EXTRACTING_FILE,"%s",psess->achFile);
		}
		else {                          // Destination file is different
			MsgSet(psess->achMsg,pszEXT_EXTRACTING_FILE2,"%s%s",
					szLocal,psess->achFile);
		}

		printf("%s\n",psess->achMsg);
		psess->fNoLineFeed = TRUE;
		psess->cFiles++;
		psess->cbTotalBytes += pfdin->cb;
		return fh;                      // Return open file handle

	case fdintCLOSE_FILE_INFO:
		//** Close the file
		wrap_close(pfdin->hf);

		//** Construct output filespec
#ifdef SMALL_DOS
	_fstrcpy(szLocal,pfdin->psz1);
#else
#define szLocal pfdin->psz1
#endif

		//** Figure out what destination file name should be
		if (psess->achDest[0] != '\0') { // Override name from cabinet
			pszDestinationFile = psess->achDest;
		}
		else {
			pszDestinationFile = szLocal;
		}

		//** Construct full destination file name
		if (!catDirAndFile(psess->achFile,      // Buffer for output filespec
						   sizeof(psess->achFile), // Size of output buffer
						   psess->achLocation,  // Output directory
						   pszDestinationFile,  // Output file name
						   NULL,                // Don't have alternate name
						   perr)) {
			return -1;                  // Abort with error
		}


		//** Set file date, time, and attributes
		fta.date = pfdin->date;
		fta.time = pfdin->time;
		fta.attr = pfdin->attribs;
		if (!SetFileTimeAndAttr(psess->achFile, &fta, perr)) {
			return -1;                  // Abort with error
		}
		return TRUE;                    // Success

	case fdintPARTIAL_FILE:
		//** Construct output filespec
#ifdef SMALL_DOS
	_fstrcpy(szLocal,pfdin->psz1);
#else
#define szLocal pfdin->psz1
#endif
		//** See if filspec matches specified patterns
		if (!checkWildMatches(psess,szLocal,perr)) {
			//** Either no match, or failure -- figure out which
			if (ErrIsError(perr)) {
				return -1;              // Error, abort
			}
			else {
				return 0;               // No error, skip this file
			}
		}

		//** Only show partial file messages for first cabinet
		if (!psess->fContinuationCabinet) { // First cabinet
			MsgSet(psess->achMsg,pszEXT_PARTIAL_FILE,
#ifdef SMALL_DOS
				"%Fs%Fs%Fs",
#else
				"%s%s%s",
#endif
					pfdin->psz1,pfdin->psz2,pfdin->psz3);
			printf("%s\n",psess->achMsg);
		}
		return 0;                       // Continue

	case fdintNEXT_CABINET:
		return doGetNextCab(fdint,pfdin);

	default:
		printf("UNKNOWN NOTIFICATION: %d\n",fdint);
		return 0;   /* ??? */
	}
} /* fdiNotifyExt() */


/***    checkOverwrite - Check for file existence and do overwrite processing
 *
 *  Entry:
 *      psess       - Session
 *      pszFile     - File to check
 *      perr        - Error structure
 *      prc         - Gets return code
 *
 *  Exit-Success:
 *      Returns TRUE; file can be overwritten
 *
 *  Exit-Failure:
 *      Returns FALSE; perr filled in if error,
 *      *prc ==  0 -> Skip file
 *      *prc == -1 -> Abort
 */
BOOL checkOverwrite(PSESSION  psess,
					char     *pszFile,
					PERROR    perr,
					int      *prc)
{
	char            ch;
	BOOL            fGotReply;
	BOOL            fOverwrite;
	BOOL            fOverwriteAll;
	struct _stat    stat;

	//** Check to see if file already exists
	if (-1 == _stat(pszFile,&stat)) {   // File does not exist
		return TRUE;                    // Write it
	}

	//** Prompt if we're supposed to
	if (!psess->fOverwrite) {
		//** Display prompt -- no CR/LF
		MsgSet(psess->achMsg,pszEXT_OVERWRITE_PROMPT,"%s",pszFile);
		printf("%s",psess->achMsg);

		//** Get valid single character response and ENTER key;
		//      any illegal keys are just ignored
		fGotReply = FALSE;
		while (!fGotReply || (ch != '\r')) {
			ch = _getch();              // Get a keystroke
			switch (toupper(ch)) {

			case chOVERWRITE_YES:
				fGotReply     = TRUE;
				fOverwrite    = TRUE;
				fOverwriteAll = FALSE;
				printf("%c\b",ch);      // Echo character and backspace over it
				break;

			case chOVERWRITE_NO:
				fGotReply     = TRUE;
				fOverwrite    = FALSE;
				fOverwriteAll = FALSE;
				printf("%c\b",ch);      // Echo character and backspace over it
				break;

			case chOVERWRITE_ALL:
				fGotReply     = TRUE;
				fOverwrite    = TRUE;
				fOverwriteAll = TRUE;
				printf("%c\b",ch);      // Echo character and backspace over it
				break;

			default:
				break;                  // Ignore character
			}
		}

		//** Do the line feed
		printf("\n");

		//** Respect user's wish
		if (!fOverwrite) {              // Don't overwrite file
			*prc = 0;                   // Indicate skip
			return FALSE;
		}
		else {                          // Overwrite once or all
			psess->fOverwrite = fOverwriteAll; // Set accordingly
		}
	}

	//** Make sure file is writeable, if it isn't already
	if (!(stat.st_mode & _S_IWRITE)) {   // File is not writeable
		_chmod(pszFile, _S_IREAD | _S_IWRITE);
		//** Ignore error code, because the open will fail and catch it
	}

	//** Done
	return TRUE;                        // Overwrite that file
} /* checkOverwrite() */


/***    updateCabinetInfo - update history of cabinets seen
 *
 *  Entry:
 *      psess - Session
 *      pfdin - FDI info structurue
 *
 *  Exit:
 *      Returns 0;
 */
int updateCabinetInfo(PSESSION psess, PFDINOTIFICATION pfdin)
{
	AssertSess(psess);

	//** Save older cabinet info
	psess->acab[0] = psess->acab[1];

	//** Save new cabinet info
	STRCPY(psess->acab[1].achCabPath     ,pfdin->psz3);
	STRCPY(psess->acab[1].achCabFilename ,pfdin->psz1);
	STRCPY(psess->acab[1].achDiskName    ,pfdin->psz2);
	psess->acab[1].setID    = pfdin->setID;
	psess->acab[1].iCabinet = pfdin->iCabinet;
	return 0;
}


/***    ensureCabinet - Make sure desired cabinet is available
 *
 *  Make sure requested cabinet is available.
 *
 *  Entry:
 *      psess       - Session
 *      pszPath     - Path buffer (modified if necessary on output)
 *      cbPath      - Size of path buffer
 *      pszFile     - Cabinet file name
 *      pszLabel    - Label for disk with cabinet file
 *      setID       - setID for cabinet
 *      iCabinet    - iCabinet for cabinet
 *      fLoop       - TRUE => Loop until right cabinet or user aborts
 *                    FALSE => Only try once
 *      fPromptOnly - TRUE => Caller knows cabinet is bad, just prompt
 *                    FALSE => Check cabinet, prompt if necessary
 *      perr        - Error structure
 *
 *  Exit-Success:
 *      Returns TRUE; desired cabinet is present
 *
 *  Exit-Failure:
 *      Returns FALSE; perr filled in.
 *      Returns -1; user aborted
 */
BOOL ensureCabinet(PSESSION  psess,
				   char     *pszPath,
				   int       cbPath,
				   char     *pszFile,
				   char     *pszLabel,
				   USHORT    setID,
				   USHORT    iCabinet,
				   BOOL      fLoop,
				   BOOL      fPromptOnly,
				   PERROR    perr)
{
	char            ach[cbFILE_NAME_MAX];
	int             cch;
	int             cLoop=0;
	char            chDrive;
	BOOL            fCabinetExists;
	FDICABINETINFO  fdici;
	int         hfCab;

	AssertSess(psess);

	do {
		cLoop++;                        // Count loops
		ErrClear(perr);         // Make sure no error is set
		//** Construct fully qualified cabinet file path
		if (!catDirAndFile(ach,         // Buffer for output filespec
						   sizeof(ach), // Size of output buffer
						   pszPath,     // Path
						   pszFile,     // Filename
						   NULL,        // Don't have alternate name
						   perr)) {
			return FALSE;               // Abort with error
		}

		//** Check cabinet only if asked
		if (!fPromptOnly) {
			//** Make sure cabinet is the one we want
			if (-1 == (hfCab = wrap_open(ach,_O_BINARY | _O_RDONLY,0))) {
				ErrSet(perr,pszEXTERR_CANNOT_OPEN_FILE,"%s",ach);
			}
			else if (!FDIIsCabinet(psess->hfdi,hfCab,&fdici)) {
				if (!ErrIsError(perr)) {        // Have to set error message
					ErrSet(perr,pszEXTERR_NOT_A_CABINET,"%s",ach);
				}
			}
			else if ((fdici.setID    != setID) ||
					 (fdici.iCabinet != iCabinet)) {
				ErrSet(perr,pszFDIERR_WRONG_CABINET,"%s",ach);
			}

			//** Close the cabinet file (if we got it opened)
			if (hfCab != -1) {
				wrap_close(hfCab);
				fCabinetExists = TRUE;
			}
			else {
				fCabinetExists = FALSE;
			}

			//** Did we get the cabinet we wanted?
			if (!ErrIsError(perr)) {
				return TRUE;                // Yup, return success
			}

			//** Don't show message if first time and cabinet not there,
			//   since this is the common case cabinets on separate floppy
			//   disks, and we don't want to whine before we ask them to
			//   insert the right floppy.
			//
			if ((cLoop > 1) || fCabinetExists) {
				MsgSet(psess->achMsg,pszEXTERR_ERROR,"%s",perr->ach);
				printf("\n%s\n",psess->achMsg);
			}
		}

		//** Tell user what we want
		if (IsPathRemovable(ach,&chDrive)) {
			MsgSet(psess->achMsg,pszEXT_FLOPPY_PROMPT,"%s%s%c",
					pszFile,pszLabel,chDrive);
		}
		else {
			MsgSet(psess->achMsg,pszEXT_NOFLOPPY_PROMPT,"%s%s%c",
					pszFile,pszLabel);
		}
		printf("%s\n",psess->achMsg);

		//** Get response
		if (!gets(ach)) {                   // Error or EOF
			ErrSet(perr,pszEXTERR_ABORT);
			return -1;                      // User abort
		}
		if (strlen(ach) > 0) {
			strcpy(pszPath,ach);            // Update path
			cch = strlen(pszPath);
			//** Make sure path has path separator, since FDI requires it
			cch += appendPathSeparator(&(pszPath[cch-1]));

			//** Update path for next FDICopy() call!
			if (cch >= sizeof(psess->achCabPath)) {
				Assert(0);
				return -1;              // Path too big
			}
			strcpy(psess->achCabPath,pszPath);
		}
	}
	while (fLoop);
	//** Did not guarantee desired cabinet
	return FALSE;
} /* ensureCabinet() */


/***    doGetNextCab - Get next cabinet
 *
 *  Make sure requested cabinet is available.
 *
 *  Entry:
 *      fdint - type of notification
 *      pfdin - data for notification
 *
 *  Exit-Success:
 *      Returns anything but -1;
 *
 *  Exit-Failure:
 *      Returns -1 => abort FDICopy() call.
 */
FNFDINOTIFY(doGetNextCab)
{
	char        ach[cbFILE_NAME_MAX];
	static int  cErrors=0;          // Count of errors for single attempt
	PERROR      perr;
	int         rc;

#ifdef SMALL_DOS
	PSESSION    psess=(PSESSION)(void *)(short)(long)pfdin->pv;
	static char szCabPath[cbFILE_NAME_MAX];
	static char szCabFile[cbFILE_NAME_MAX];
	static char szCabLabel[cbFILE_NAME_MAX];
#else
	PSESSION    psess=(PSESSION)pfdin->pv;
#endif

	AssertSess(psess);
	perr = psess->perr;

	//** Skip "starts in ..." messages for subsequent cabinets
	psess->fContinuationCabinet = TRUE;

	//** Keep track of GetNextCabinet calls so we can determine
	//   what cabinet to expect next.
	psess->fNextCabCalled = TRUE;

	//** If there is no problem to report, just let FDI do the checks
	if (pfdin->fdie == FDIERROR_NONE) {
		cErrors = 0;
		return 0;
	}

	//** If FDI didn't get the correct cabinet last time it called us,
	//   it calls us again with a specific error code.  Tell the user
	//   something intelligible.
	//
	//   pfdin->psz1 = cabinet filename
	//   pfdin->psz2 = disk user-readable name
	//   pfdin->psz3 = current cabinet path

#ifdef SMALL_DOS
	_fstrcpy(szCabFile ,pfdin->psz1);
	_fstrcpy(szCabLabel,pfdin->psz2);
	_fstrcpy(szCabPath ,pfdin->psz3);
#else
#define szCabFile  pfdin->psz1
#define szCabLabel pfdin->psz2
#define szCabPath  pfdin->psz3
#endif

	cErrors++;                          // Count of errors on this cabinet
	switch (pfdin->fdie) {
	case FDIERROR_USER_ABORT:
		Assert(0);  //** Should never be called with this error code
		break;

	default:
		//** Construct full path name of cabinet
		if (!catDirAndFile(ach,         // Buffer for output filespec
						   sizeof(ach), // Size of output buffer
						   szCabPath,   // Path
						   szCabLabel,  // Filename
						   NULL,        // Don't have alternate name
						   perr)) {
			return -1;                  // Abort with error
		}
		//** Construct error string
		mapFDIError(perr,psess,ach,&(psess->erf));
		//** Reset error
		psess->erf.erfOper = FDIERROR_NONE;
	} /* switch */

	//** Tell user what the problem is, except in the case where the
	//   file was not found *and* this was the first try at finding
	//   the cabinet.
	if ((cErrors > 1) || (pfdin->fdie != FDIERROR_CABINET_NOT_FOUND)) {
		MsgSet(psess->achMsg,pszEXTERR_ERROR,"%s",perr->ach);
		printf("\n%s\n",psess->achMsg);
	}

	//** Tell user to swap disks or type in new path
	rc = ensureCabinet(psess,
					   szCabPath,       // cabinet path
					   cbFILE_NAME_MAX,
					   szCabFile,       // cabinet file name
					   szCabLabel,      // User-readable label
					   pfdin->setID,    // Required setID
					   pfdin->iCabinet, // Required iCabinet
					   FALSE,           // Do not loop
					   TRUE,            // Skip check, just prompt
					   perr);

#ifdef SMALL_DOS
	//** Copy possibly modified cabinet path back to FDI structure
	_fstrcpy(pfdin->psz3,szCabPath);
#endif

	//** Return result
	return rc;
} /* doGetNextCab() */


/***    fdiDecryptDir - Callback from FDICopy for decryption
 *
 *  <<< Just indicate calls made >>>
 *
 *  NOTE: See fdi.h for details.
 *
 *  Entry:
 *      pfdid - data for decryption
 *
 *  Exit-Success:
 *      Return TRUE;
 *
 *  Exit-Failure:
 *      Return -1;
 */
FNFDIDECRYPT(fdiDecryptDir)
{
	PERROR      perr;
#ifdef SMALL_DOS
	PSESSION    psess=(PSESSION)(void *)(short)(long)pfdid->pvUser;
#else
	PSESSION    psess=(PSESSION)pfdid->pvUser;
#endif

	AssertSess(psess);
	perr = psess->perr;

	//** Bail out if we're not supposed to show info
	if (!psess->fShowReserveInfo) {
		return TRUE;
	}

	switch (pfdid->fdidt) {
		case fdidtNEW_CABINET:
			MsgSet(psess->achMsg,pszEXT_DECRYPT_HEADER,
				   "%08lx%u%x%d",
				   pfdid->cabinet.pHeaderReserve,
				   pfdid->cabinet.cbHeaderReserve,
				   pfdid->cabinet.setID,
				   pfdid->cabinet.iCabinet);
			printf("%s\n",psess->achMsg);
			break;

		case fdidtNEW_FOLDER:
			MsgSet(psess->achMsg,pszEXT_DECRYPT_FOLDER,
				   "%08lx%u%d",
				   pfdid->folder.pFolderReserve,
				   pfdid->folder.cbFolderReserve,
				   pfdid->folder.iFolder);
			printf("%s\n",psess->achMsg);
			break;

		case fdidtDECRYPT:
			MsgSet(psess->achMsg,pszEXT_DECRYPT_DATA,
				   "%08lx%u%08lx%u%d%u",
				   pfdid->decrypt.pDataReserve,
				   pfdid->decrypt.cbDataReserve,
				   pfdid->decrypt.pbData,
				   pfdid->decrypt.cbData,
				   pfdid->decrypt.fSplit,
				   pfdid->decrypt.cbPartial);
			printf("%s\n",psess->achMsg);
			break;

		default:
			printf("UNKNOWN DECRYPT COMMAND: %d\n",pfdid->fdidt);
			return -1;                      // Abort
	};
	return TRUE;
} /* fdiDecryptDir() */


/***    fdiDecryptExt - Callback from FDICopy for real decryption
 *
 *  NOTE: See fdi.h for details.
 *
 *  Entry:
 *      pfdid - data for decryption
 *
 *  Exit-Success:
 *      Return TRUE;
 *
 *  Exit-Failure:
 *      Return -1;
 */
FNFDIDECRYPT(fdiDecryptExt)
{
	return fdiDecryptDir(pfdid);
} /* fdiDecryptExt() */


/***    checkWildMatchs - Check filespec against list of filespec patterns
 *
 *  Entry:
 *      psess   - SESSION -- has list of filespec patterns
 *      pszFile - Filespec to test (may have path characters)
 *      perr    - ERROR structure
 *
 *  Exit-Success:
 *      Returns TRUE, pszFile matched a pattern
 *
 *  Exit-Failure:
 *      Returns FALSE, pszFile did not match a pattern -or- an error occurred.
 *      Use ErrIsError(perr) to determine if an error occured.
 */
BOOL checkWildMatches(PSESSION psess, char *pszFile, PERROR perr)
{
	HFILESPEC   hfspec;                 // Use to walk list of file patterns
	char       *pszNameExt;             // Name.Ext piece
	char       *pszWild;                // Filespec pattern

	//** Get name.ext piece
	pszNameExt = getJustFileNameAndExt(pszFile,perr);
	if (!pszNameExt) {
		return FALSE;                   // perr already filled in
	}

	//** Loop through list of filespec patterns
	hfspec = FLFirstFile(psess->hflist);
	Assert(hfspec != NULL);             // Skip over cabinet filespec
	hfspec = FLNextFile(hfspec);
	Assert(hfspec != NULL);             // First wildcard spec
	while (hfspec != NULL) {            // Check patterns
		pszWild = FLGetSource(hfspec);
		Assert(pszWild!=NULL);
		Assert(*pszWild);
		if (IsWildMatch(pszNameExt,pszWild,perr)) {
			return TRUE;                // Got a match!
		}
		hfspec = FLNextFile(hfspec);    // Try next pattern
	}

	//** Failure -- none of the patterns matched
	return FALSE;
} /* checkWildMatches() */


/***    fdiAlloc - memory allocator for FDI
 *
 *  Entry:
 *      cb - size of block to allocate
 *
 *  Exit-Success:
 *      returns non-NULL pointer to block of size at least cb.
 *
 *  Exit-Failure:
 *      returns NULL
 */
FNALLOC(fdiAlloc)
{
	void HUGE *pv;

	//** Do allocation
#ifdef  BIT16
	pv = _halloc(cb,1);     // Use 16-bit function
#else // !BIT16
	pv = malloc(cb);        // Use 32-bit function
#endif // !BIT16

	//** Remember if error occured, to improve quality of error messages
	if (pv == NULL) {
		psessG->se = seNOT_ENOUGH_MEMORY;
	}

	//** Return buffer (or failure indication)
	return pv;
} /* fdiAlloc() */


/***    fdiFree - memory free function for FDI
 *
 *  Entry:
 *      pv - memory allocated by fciAlloc to be freed
 *
 *  Exit:
 *      Frees memory
 */
FNFREE(fdiFree)
{
#ifdef  BIT16
	//** Use 16-bit function
	_hfree(pv);
#else // !BIT16
	//** Use 32-bit function
	free(pv);
#endif // !BIT16
}


/***    STATELOC - States for /L (location) parsing
 *
 */
typedef enum {
	slNONE,                         // No /L seen
	slEXPECTING,                    // Just saw /L, need a location
	slGOT,                          // We have parsed "/L location"
} STATELOC; /* sl */


/***    parseCommandLine - Parse the command line arguments
 *
 *  Entry:
 *      psess   - SESSION
 *      cArg    - Count of arguments, including program name
 *      apszArg - Array of argument strings
 *      perr    - ERROR structure
 *
 *  Exit-Success:
 *      Returns TRUE, psess filled in.
 *
 *  Exit-Failure:
 *      Returns actBAD, perr filled in with error.
 */
BOOL parseCommandLine(PSESSION psess, int cArg, char *apszArg[], PERROR perr)
{
	int         cFile=0;        // Count of non-directive file names seen
	char        ch;             // Switch value
	int         i;
	char       *pch;
	STATELOC    sl=slNONE;      // Location parsing state

	AssertSess(psess);
	psess->act = actDEFAULT;            // We don't know what we are doing; yet
	psess->achLocation[0] = '\0';       // Default to current directory

	//** Empty file handle table
	for (i=0; i<cMAX_CAB_FILE_OPEN; i++) {
		psess->ahfSelf[i] = -1;     // No open handle
	}

	//** See if we are a self-extracting cabinet
	if (!checkSelfExtractingCab(psess,cArg,apszArg,perr)) {
		return FALSE;                   // An error occurred, perr filled in
	}
	if (psess->fSelfExtract) {
		//** Save our file name and use it as the cabinet file name
		strcpy(psess->achSelf,apszArg[0]);  // Save our name
		if (addFileSpec(psess,apszArg[0],perr) == NULL) {
			ErrSet(perr,pszEXTERR_COULD_NOT_ADD_FILE,"%s",apszArg[0]);
			return FALSE;
		}
		cFile++;                        // Count files

	}

	//** Parse args, skipping program name
	for (i=1; i<cArg; i++) {
		if ((apszArg[i][0] == chSWITCH1) ||
			(apszArg[i][0] == chSWITCH2) ) {
			//** Have a switch to parse, make sure switch is OK here
			if (sl == slEXPECTING) {
				ErrSet(perr,pszEXTERR_MISSING_LOCATION);
				return FALSE;
			}

			//** Process switches (support string to ease typing)
			for (pch=&apszArg[i][1]; *pch; pch++) {
				ch = toupper(*pch);         // Switch character
				switch (ch) {
					case chSWITCH_HELP:
						psess->act = actHELP;       // Show help
						return TRUE;

					case chSWITCH_ALL:
						psess->fAllCabinets = TRUE;
						break;

					case chSWITCH_COPY:
						if (psess->act != actDEFAULT) {
							ErrSet(perr,pszEXTERR_CONFLICTING_SWITCH,"%c",*pch);
							return FALSE;
						}
						psess->act = actCOPY;
						break;

					case chSWITCH_DIRECTORY:
						if (psess->act != actDEFAULT) {
							ErrSet(perr,pszEXTERR_CONFLICTING_SWITCH,"%c",*pch);
							return FALSE;
						}
						psess->act = actDIRECTORY;
						break;

					case chSWITCH_EXTRACT:
						if (psess->act != actDEFAULT) {
							ErrSet(perr,pszEXTERR_CONFLICTING_SWITCH,"%c",*pch);
							return FALSE;
						}
						psess->act = actEXTRACT;
						break;

					case chSWITCH_LOCATION:
						//** Make sure we only got location once
						if (sl == slGOT) {
							ErrSet(perr,pszEXTERR_LOCATION_TWICE);
							return FALSE;
						}
						sl = slEXPECTING;
						break;

					case chSWITCH_OVERWRITE:
						psess->fOverwrite = TRUE;
						break;

					case chSWITCH_RESERVE:
						psess->fShowReserveInfo = TRUE;
						break;

					default:
						ErrSet(perr,pszEXTERR_BAD_SWITCH,"%s",apszArg[i]);
						return FALSE;
						break;
				}
			}
		}
		//** Not a command line switch
		else if (sl == slEXPECTING) {
			//** Get the location (output directory)
			STRCPY(psess->achLocation,apszArg[i]);  // Save location
			sl = slGOT;                 // Done eating location
		}
		else {
			//** We have a file name, add it to our list
			if (addFileSpec(psess,apszArg[i],perr) == NULL) {
				ErrSet(perr,pszEXTERR_COULD_NOT_ADD_FILE,"%s",apszArg[i]);
				return FALSE;
			}
			cFile++;                    // Count files
		}
	}

	//** If no arguments and not self-extracting, show help
	if ((cArg == 1) && !psess->fSelfExtract) {
		psess->act = actHELP;           // Show help
		return TRUE;
	}

	//** Make sure no trailing /L without location
	if (sl == slEXPECTING) {
		ErrSet(perr,pszEXTERR_MISSING_LOCATION);
		return FALSE;
	}

	//** Make sure we got right number of arguments for COPY case
	if ((psess->act == actCOPY) && (cFile != 2)) {
		//** General purpose error, to minimize localization effort
		ErrSet(perr,pszEXTERR_BAD_PARAMETERS);
		return FALSE;
	}

	//** Make sure we got at least one filespec
	if (cFile == 0) {
		ErrSet(perr,pszEXTERR_MISSING_CABINET);
		return FALSE;
	}

	//** Special processing for self-extract
	if (psess->fSelfExtract) {
		psess->fAllCabinets = TRUE;     // Always do all cabinets
		//** Force EXTRACT if no /E or /D specified
		if (psess->act == actDEFAULT) {
			psess->act = actEXTRACT;
		}
	}

	//** Success
	return TRUE;
}

/***    checkSelfExtractingCab - See if we are a self-extracting cabinet
 *
 *  Entry:
 *      psess   - SESSION
 *      cArg    - Count of arguments, including program name
 *      apszArg - Array of argument strings
 *      perr    - ERROR structure
 *
 *  Exit-Success:
 *      Returns TRUE, psess filled in.
 *          psess->fSelfExtract set to TRUE if self-extracting
 *          psess->cbSelfExtract set to EXE size if self-extracting (this is
 *              the offset to the start of the cabinet file header).
 *
 *  Exit-Failure:
 *      Returns actBAD, perr filled in with error.
 *
 *  Notes:
 *      The strategy is to get the EXE file size indicated in the appropriate
 *      EXE header, and if the actual size of our EXE file is larger than that,
 *      we assume that there is a cabinet file tacked on to the end, and we
 *      extract the files from that!
 */
BOOL checkSelfExtractingCab(PSESSION  psess,
							int       cArg,
							char     *apszArg[],
							PERROR    perr)
{
	long    cbFile;                     // EXE file size
	long    cbFromHeader;               // Size indicated by EXE header
	int     hf;
#ifdef BIT16
	long    info;
#else // !BIT16
	char    achFile[cbFILE_NAME_MAX];
	IMAGE_DOS_HEADER   idh;             // MS-DOS header
	IMAGE_NT_HEADERS   inh;             // Complete PE header
#endif // !BIT16


	//** Open our EXE file
#ifdef BIT16
 // printf("opening EXE file: %s\n",apszArg[0]);
	hf = wrap_open(apszArg[0],_O_RDONLY,0);
#else
 // printf("Geting EXE file name\n");
	if (!GetModuleFileName(NULL,achFile,sizeof(achFile))) {
		return TRUE;
	}
 // printf("opening EXE file: %s\n",achFile);
	hf = wrap_open(achFile,_O_RDONLY,0);
#endif
	if (hf == -1) {
		return TRUE;                    // Something is bogus, just skip selfex
	}

	//** Get the expected EXE file size
#ifdef BIT16
	//** Do it the MS-DOS way
 // printf("seek to EXE size\n");
	if (-1 == wrap_lseek(hf,2,SEEK_SET)) {
		goto Exit;
	}
 // printf("reading EXE size\n");
	if (sizeof(info) != wrap_read(hf,&info,sizeof(info))) {
		goto Exit;
	}
	//** OK, we've got the page count and count of bytes in the last page;
	//      convert to a file size.
	cbFromHeader = ((info>>16)-1)*512 + (info&0xFFFF);
 // printf("Original EXE size = %8ld\n",cbFromHeader);
#else // !BIT16
	//** Do it the Win32 way

 // printf("reading MS-DOS header\n");
	//** Get MS-DOS header
	if (sizeof(idh) != wrap_read(hf,&idh,sizeof(idh))) {
		goto Exit;
	}

 // printf("seeking to NT header at %ld\n",idh.e_lfanew);
	//** Seek to and read NT header
	if (-1 == wrap_lseek(hf,idh.e_lfanew,SEEK_SET)) {
		goto Exit;
	}

 // printf("reading NT header\n");
	if (sizeof(inh) != wrap_read(hf,&inh,sizeof(inh))) {
		goto Exit;
	}

	cbFromHeader = inh.OptionalHeader.SizeOfImage;
 // printf("Original EXE size = %8ld\n",inh.OptionalHeader.SizeOfImage);
#endif // !BIT16

	//** Get actual file size
	cbFile = wrap_lseek(hf,0,SEEK_END);
 // printf("Current EXE size  = %8ld\n",cbFile);

	//** Modify state IF we are doing self-extract
	if (cbFile > cbFromHeader) {
		psess->fSelfExtract = TRUE;
		psess->cbSelfExtract = cbFromHeader;
	}

	//** Success
Exit:
	wrap_close(hf);
	return TRUE;
} /* checkSelfExtractingCab() */



/***    addFileSpec - Add filename to session list
 *
 *  Entry:
 *      psess  - Session to update
 *      pszArg - File name to add
 *      perr   - ERROR structure
 *
 *  Exit-Success:
 *      Returns HFILESPEC, psess updated.
 *
 *  Exit-Failure:
 *      Returns NULL, perr filled in with error.
 */
HFILESPEC addFileSpec(PSESSION psess, char *pszArg, PERROR perr)
{
	HFILESPEC   hfspec;

	AssertSess(psess);
	//** Make sure a list exists
	if (psess->hflist == NULL) {
		if (!(psess->hflist = FLCreateList(perr))) {
			return FALSE;
		}
	}

	//** Add file to list
	if (!(hfspec = FLAddFile(psess->hflist, pszArg, NULL, perr))) {
		return NULL;
	}

	//** Success
	return hfspec;
} /* addFileSpec() */


#ifdef ASSERT
/***    fnafReport - Report assertion failure
 *
 *      NOTE: See asrt.h for entry/exit conditions.
 */
FNASSERTFAILURE(fnafReport)
{
		printf("\n%s:(%d) Assertion Failed: %s\n",pszFile,iLine,pszMsg);
		exit(1);
}
#endif // ASSERT


/***    printError - Display error on stdout
 *
 *  Entry
 *      perr - ERROR structure to print
 *
 *  Exit-Success
 *      Writes error message to stdout.
 */
void printError(PSESSION psess, PERROR perr)
{
	//** Make sure error starts on a new line
	if (psess->fNoLineFeed) {
		printf("\n");
		psess->fNoLineFeed = FALSE;
	}

	//** General error
	Assert(perr->pszFile == NULL);
	MsgSet(psess->achMsg,pszEXTERR_ERROR,"%s",perr->ach);
	printf("%s\n",psess->achMsg);
} /* printError() */


/***    pszFromMSDOSTime - Convert MS-DOS file date/time to string
 *
 *  Entry:
 *      psz  - Buffer to receive formatted date/time
 *      cb   - Length of psz buffer
 *      date - MS-DOS FAT file system date format (see below)
 *      time - MS-DOS FAT file system time format (see below)
 *
 *  Exit:
 *      *psz filled in
 *
 *  NOTE: This is the interpretation of the MS-DOS date/time values:
 *
 *      Time Bits cBits Meaning
 *      --------- ----- ----------------------------------------
 *       0 -  4     5   Number of two-second increments (0 - 29)
 *       5 - 10     6   Minutes (0 - 59)
 *      11 - 15     5   Hours (0 - 23)
 *
 *      Date Bits cBits Meaning
 *      --------- ----- ----------------------------------------
 *       0 -  4     5   Day (1 - 31)
 *       5 -  8     4   Month (1 - 12)
 *       9 - 15     7   Year since 1980 (for example, 1994 is stored as 14)
 */
void pszFromMSDOSTime(char *psz, int cb, WORD date, WORD time)
{
	int     sec;
	int     min;
	int     hour;
	int     day;
	int     month;
	int     year;
	char   *pszAMPM;                    // AM/PM string

	sec   = (time & 0x1f) << 1;         // 0, 2, ..., 58
	min   = (time >>  5) & 0x3f;        // 0, 1, ..., 59
	hour  = (time >> 11) & 0x1f;        // 0, 1, ..., 23

	//** Determine 12-hour vs. 24-hour clock
	if (strlen(pszEXT_TIME_PM) == 0) {
		//** 24 hour clock
		Assert(strlen(pszEXT_TIME_AM) == 0);
		pszAMPM = pszEXT_TIME_PM;
	}
	else {
		//** Get am/pm extension, and map 0 to 12
		if (hour >= 12) {
			pszAMPM = pszEXT_TIME_PM;
			hour -= 12;
		}
		else {
			pszAMPM = pszEXT_TIME_AM;
		}
		if (hour == 0) {
			hour = 12;
		}
	}

	day   = (date & 0x1f);
	month = (date >> 5) & 0x0f;
	year  = ((date >> 9) & 0x7f) + 1980;

	MsgSet(psz,pszEXT_DATE_TIME, "%02d%02d%02d%2d%02d%02d%s",
			month, day, year, hour, min, sec, pszAMPM);
} /* pszFromMSDOSTime() */


/***    pszFromAttrFAT - Convert FAT file attributes to string
 *
 *  Entry:
 *      attrFAT - file attributes
 *
 *  Exit:
 *      *psz filled in  "----".."A-R-".."AHRS"
 */
void pszFromAttrFAT(char *psz, int cb, WORD attrFAT)
{
	STRCPY(psz,"----");
	if (attrFAT & _A_ARCH)
		psz[0] = 'A';
	if (attrFAT & _A_HIDDEN)
		psz[1] = 'H';
	if (attrFAT & _A_RDONLY)
		psz[2] = 'R';
	if (attrFAT & _A_SYSTEM)
		psz[3] = 'S';
	return;
} /* pszFromAttrFAT() */


/***    mapFDIError - Create error message from FDI error codes
 *
 *  Entry:
 *      perr       - ERROR structure to recieve message
 *      psess      - Our context
 *      pszCabinet - Cabinet file being processed
 *      perf       - FDI error structure
 *
 *  Exit:
 *      perr filled in with formatted message
 */
void mapFDIError(PERROR perr,PSESSION psess, char *pszCabinet, PERF perf)
{
	switch (perf->erfOper) {

	case FDIERROR_NONE:
		Assert(0);
		break;

	case FDIERROR_CABINET_NOT_FOUND:
		ErrSet(perr,pszFDIERR_CAB_NOT_FOUND,"%s",pszCabinet);
		break;

	case FDIERROR_NOT_A_CABINET:
		ErrSet(perr,pszFDIERR_NOT_A_CABINET,"%s",pszCabinet);
		break;

	case FDIERROR_UNKNOWN_CABINET_VERSION:
		ErrSet(perr,pszFDIERR_BAD_CAB_VER,"%s%04x",pszCabinet,perf->erfType);
		break;

	case FDIERROR_CORRUPT_CABINET:
		ErrSet(perr,pszFDIERR_CORRUPT_CAB,"%s",pszCabinet);
		break;

	case FDIERROR_ALLOC_FAIL:
		ErrSet(perr,pszFDIERR_ALLOC_FAIL,"%s",pszCabinet);
		break;

	case FDIERROR_BAD_COMPR_TYPE:
		ErrSet(perr,pszFDIERR_BAD_COMPR_TYPE,"%s",pszCabinet);
		break;

	case FDIERROR_MDI_FAIL:
		//** Improve detail of failure message

		switch (psess->se) {

		case seNONE:
			//** Some other decompression error (corrupted data?)
			ErrSet(perr,pszFDIERR_MDI_FAIL,"%s",pszCabinet);
			break;

		case seNOT_ENOUGH_MEMORY:
			//** Not enough RAM for decompressor itself
			ErrSet(perr,pszFDIERR_ALLOC_FAIL,"%s",pszCabinet);
			break;

		case seCANNOT_CREATE:
			//** Could not create a Quantum temporary spill file
			ErrSet(perr,pszFDIERR_SPILL_CREATE,"%s%s",pszCabinet,achSpillFile);
			break;

		case seNOT_ENOUGH_SPACE:
			//** TMP directory did not have enough space for Quantum
			//   spill file.
			ErrSet(perr,pszFDIERR_SPILL_SIZE,"%s%s%ld",pszCabinet,
													   achSpillFile,
													   psess->cbSpill);
			break;

		default:
			Assert(0);
		}
		break;

	case FDIERROR_TARGET_FILE:
		ErrSet(perr,pszFDIERR_TARGET_FILE,"%s%s",psess->achFile,pszCabinet);
		break;

	case FDIERROR_RESERVE_MISMATCH:
		ErrSet(perr,pszFDIERR_RESERVE_MISMATCH,"%s",pszCabinet);
		break;

	case FDIERROR_WRONG_CABINET:
		ErrSet(perr,pszFDIERR_WRONG_CABINET,"%s",pszCabinet);
		break;

	case FDIERROR_USER_ABORT:
		ErrSet(perr,pszFDIERR_USER_ABORT,"%s",pszCabinet);
		break;

	default:
		ErrSet(perr,pszFDIERR_UNKNOWN_ERROR,"%d%s",perf->erfOper,pszCabinet);
		break;
	}
} /* mapFDIError() */


/***    wrap_close - close an open file
 *
 */
int  FAR DIAMONDAPI wrap_close(int fh)
{
	int     i;
	int     rc;

#ifdef SMALL_DOS
	rc = _dos_close(fh);
	if (rc != 0) {          // Map random MS-DOS error code to -1 failure
		rc = -1;
	}
#else
	rc = _close(fh);
#endif

	//** See if we have to destroy the spill file
	if (fh == hfSpillFile) {
		_unlink(achSpillFile);          // Delete spill file
		hfSpillFile = -1;               // Remember spill file is gone
	}

	//** Take handle off list if we are self-extracting
	if (psessG->fSelfExtract) {
		//** See if this is a handle to our EXE/cabinet file;
		for (i=0;
			 (i<cMAX_CAB_FILE_OPEN) && (psessG->ahfSelf[i] != fh);
			 i++) { ; }
		if (i < cMAX_CAB_FILE_OPEN) {   // Found a match
			psessG->ahfSelf[i] = -1;    // Take it off our list
			dbg( printf("\nDBG: Close self as handle %d (slot %d)\n",fh,i) );
		}
	}

	//** Done
	dbg( printf("DBG: %d=CLOSE on handle %d\n",rc,fh) );
	return  rc;
} /* wrap_close */


/***    wrap_lseek - seek on a file
 *
 */
long FAR DIAMONDAPI wrap_lseek(int fh, long pos, int func)
{
	long    cbAdjust=0;                 // Assume file is 0-based
	int     i;
	long    rc;

	//** See if we are self-extracting
	if (psessG->fSelfExtract) {
		//** See if this is a handle to our EXE/cabinet file;
		for (i=0;
			 (i<cMAX_CAB_FILE_OPEN) && (psessG->ahfSelf[i] != fh);
			 i++) { ; }
		if (i < cMAX_CAB_FILE_OPEN) {   // Found a match
			cbAdjust = psessG->cbSelfExtract; // So return value gets adjusted
			if (func == SEEK_SET) {     // Need to adjust absolute position
				pos += cbAdjust;            // Shift up to account for EXE
				dbg(printf("\nDBG: Seek self to %ld as handle %d (slot %d)\n",pos,fh,i));
			}
		}
	}

#ifdef SMALL_DOS
	rc = _dos_seek(fh,pos,func);
#else
	rc = _lseek(fh,pos,func);
#endif
	//** If seek didn't fail, adjust return value for self-extract case
	if (rc != -1) {
		rc -= cbAdjust;
	}

	dbg( printf("DBG: %ld=LSEEK on handle %d, pos=%ld, func=%d\n",rc,fh,pos,func) );
	return rc;
} /* wrap_lseek() */


/***    wrap_open - open a file
 *
 */
int  FAR DIAMONDAPI wrap_open(const char FAR *sz, int mode, int share)
{
	int             i;
	int             rc;
	char FAR       *psz;
	PFDISPILLFILE   pfdisf;             // FDI spill file info
#ifdef SMALL_DOS
	int     ignore;
	char    szLocal[cbFILE_NAME_MAX];
#endif

	//** See if FDI is asking for a spill file (for Quantum)
	if (*sz == '*') {                   // Yes, we need to create a spill file
		Assert(hfSpillFile == -1);      // Only support one at a time
		achSpillFile[0] = '\0';         // No name constructed, yet
		pfdisf = (PFDISPILLFILE)sz;     // Get pointer to spill file size
		//** Try boot drive if no TEMP variable defined
		//   NOTE: We assume the boot drive is more likely to be writeable
		//         than the current directory, since the customer may be
		//         running EXTRACT.EXE off a write-protected floppy (which
		//         also wouldn't have enough space), or a read-only network
		//         drive.
		psz = _tempnam(getBootDrive(),"esf"); // Get a temporary file name
		if (psz == NULL) {
			psessG->se = seCANNOT_CREATE;
			return -1;                  // Could not create
		}
		strcpy(achSpillFile,psz);       // Remember name for wrap_close
		free(psz);                      // Free temporary name buffer

		mode = _O_CREAT | _O_BINARY | _O_RDWR; // Force open mode
		psz = achSpillFile;             // Use spill file name
	}
	else {
		psz = (char FAR *)sz;           // Use passed-in name
	}

	//** Open/create file
#ifdef SMALL_DOS
	_fstrcpy(szLocal,psz);
	if (mode & _O_CREAT) {
		ignore = _dos_creat(szLocal,_A_NORMAL,&rc);
	}
	else {
		//** Keep only relevant bits for _dos_open!
		mode &= _O_RDONLY | _O_WRONLY | _O_RDWR;
		ignore = _dos_open(szLocal,mode,&rc);
	}
	if (ignore != 0) {
		rc = -1;
	}
#else
	rc = _open(psz,mode,share);
#endif

	//** If this is the spill file, make sure the file was created,
	//   make sure it is the requested size, and save the handle.
	//   If we cannot do this, we set a flag to remember what the
	//   problem was, so that we can report the error intelligently.
	if (*sz == '*') {                   // Need to size spill file
		if (-1 == rc) {                 // Could not create it
			psessG->se = seCANNOT_CREATE;
			return rc;
		}
		//** Remember file handle, so that wrap_close can do the delete
		hfSpillFile = rc;

		//** Don't need to seek/write if zero length requested
		if (pfdisf->cbFile > 0) {
			//** Seek to size minus 1
			if (-1L == wrap_lseek(rc,pfdisf->cbFile-1,SEEK_SET)) {
				psessG->se = seNOT_ENOUGH_SPACE;
				psessG->cbSpill = pfdisf->cbFile;
				wrap_close(rc);             // Close and destroy spill file
				return -1;
			}

			//** Write one byte
			if (1 != wrap_write(rc,"b",1)) {
				psessG->se = seNOT_ENOUGH_SPACE;
				psessG->cbSpill = pfdisf->cbFile;
				wrap_close(rc);
				return -1;
			}
		}
		//** Spill file created successfully
		psessG->se = seNONE;                // No error
	}
#ifndef BIT16
#define _f_stricmp(a,b) _stricmp(a,b)
#endif
	else if (psessG->fSelfExtract && !_f_stricmp(sz,psessG->achSelf)) {
		//** Self-extracting and this is our EXE/cabinet file;
		//   Find a slot to store the file handle.
		for (i=0;
			 (i<cMAX_CAB_FILE_OPEN) && (psessG->ahfSelf[i] != -1);
			 i++) { ; }
		if (i >= cMAX_CAB_FILE_OPEN) {
			Assert(0);
			wrap_close(rc);
			return -1;
		}
		dbg( printf("\nDBG: Opened self (%s) as handle %d (slot %d)\n",sz,rc,i) );

		//** Save the new handle
		psessG->ahfSelf[i] = rc;

		//** Position the file handle to the start of the cabinet file header!
		//   NOTE: Since we just added the handle to the list, wrap_lseek()
		//         will know to do the EXE size adjustment!
		wrap_lseek(rc,0,SEEK_SET);
	}

	//** Done
	dbg( printf("DBG: %d=OPEN file %s, mode=%d, share=%d\n",rc,sz,mode,share) );
	return rc;
} /* wrap_open() */


/***    wrap_read - read a file
 *
 */
UINT FAR DIAMONDAPI wrap_read(int fh, void FAR *pb, unsigned int cb)
{
	int     rc;

#ifdef SMALL_DOS
	UINT ignore;
	ignore = _dos_read(fh,pb,cb,&rc);
	if (ignore != 0) {
		rc = -1;
	}
#else
	rc = _read(fh,pb,cb);
#endif
	dbg( printf("DBG: %d=READ on handle %d, pb=%08lx, cb=%u\n",rc,fh,pb,cb) );
	return rc;
} /* wrap_read() */


/***    wrap_write - write a file
 *
 */
UINT FAR DIAMONDAPI wrap_write(int fh, const void FAR *pb, unsigned int cb)
{
	int     rc;

#ifdef SMALL_DOS
	UINT ignore;
	ignore = _dos_write(fh,pb,cb,&rc);
	if (ignore != 0) {
		rc = -1;
	}
#else
	rc = _write(fh,pb,cb);
#endif
	dbg( printf("DBG: %d=WRITE on handle %d, pb=%08lx, cb=%u\n",rc,fh,pb,cb) );
	return rc;
} /* wrap_write() */


/***    getBootDrive - Returns boot drive path (e.g., "C:\")
 *
 *  Entry:
 *      none
 *
 *  Exit:
 *      Returns pointer to static buffer with bootdrive ("C:\")
 */
char *getBootDrive(void)
{
   char         ch;
   char        *psz;
   static char  szBootDrive[]="C:\\";

   //** Default to Drive C
   *szBootDrive = 'C';

   //** Get COMSPEC -- we're assuming it's drive letter is the boot drive!
   psz = getenv("COMSPEC");
   if ( psz               &&            // COMSPEC exists
		*psz              &&            // It is not empty
		(*(psz+1) == ':')) {            // Has the right format -- "?:..."
		//** We could try to validate that this is really the boot drive,
		//   but we'll just trust that COMSPEC is correct.  A test for the
		//   drive being in the range A..C would work for the US, but in
		//   Japan the boot drive can be anything between A..G, and maybe
		//   even higher.  So, we'll just make sure it's a drive letter.
		ch = tolower(*psz);
		if (('a' <= ch) && (ch <= 'z')) {
			*szBootDrive = ch;          // Use COMSPEC drive letter
		}
	}

   //** Return path of root of boot drive
   return szBootDrive;
} /* getBootDrive() */


#ifdef BIT16
//** Get Changeline fix code
//BUGBUG 14-Dec-1994 bens Include *.c file to avoid makefile change!
#include "fixchg.c"
#endif