651 lines
23 KiB
C
651 lines
23 KiB
C
/*** types.h - Common defines for FCI/FDI stuff -- goes into FCI/FDI.H
|
||
*
|
||
* Microsoft Confidential
|
||
* Copyright (C) Microsoft Corporation 1993-1994
|
||
* All Rights Reserved.
|
||
*
|
||
* History:
|
||
* 03-Mar-1993 chuckst Merged from other files
|
||
* 08-Mar-1994 bens Changed symbol to control recursive include
|
||
* 09-Mar-1994 bens Cleanups for RESERVE modifications
|
||
* 16-Mar-1994 bens Nuke padlong()
|
||
* 21-Mar-1994 bens Spruce up comments
|
||
* 22-Mar-1994 bens Add BIT16 test so we can build 16 or 32 bit!
|
||
* 26-May-1994 bens Added Quantum compression definitions
|
||
* 30-Jul-1997 msliger Correct CB_MAX_DISK from 7FFFFFF to 7FFFFFFF.
|
||
*/
|
||
|
||
#ifndef INCLUDED_TYPES_FCI_FDI
|
||
#define INCLUDED_TYPES_FCI_FDI 1
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" { /* Assume C declarations for C++ */
|
||
#endif /* __cplusplus */
|
||
|
||
|
||
//** Define away for 32-bit (NT/Chicago) build
|
||
#ifndef HUGE
|
||
#define HUGE
|
||
#endif
|
||
|
||
#ifndef FAR
|
||
#define FAR
|
||
#endif
|
||
|
||
|
||
#ifndef DIAMONDAPI
|
||
#define DIAMONDAPI __cdecl
|
||
#endif
|
||
|
||
|
||
//** Specify structure packing explicitly for clients of FDI
|
||
|
||
#ifndef _WIN64
|
||
#include <pshpack4.h>
|
||
#endif
|
||
|
||
|
||
//** Don't redefine types defined in Win16 WINDOWS.H (_INC_WINDOWS)
|
||
// or Win32 WINDOWS.H (_WINDOWS_)
|
||
//
|
||
#if !defined(_INC_WINDOWS) && !defined(_WINDOWS_)
|
||
typedef int BOOL; /* f */
|
||
typedef unsigned char BYTE; /* b */
|
||
typedef unsigned int UINT; /* ui */
|
||
typedef unsigned short USHORT; /* us */
|
||
typedef unsigned long ULONG; /* ul */
|
||
#endif // _INC_WINDOWS
|
||
|
||
typedef unsigned long CHECKSUM; /* csum */
|
||
|
||
typedef unsigned long UOFF; /* uoff - uncompressed offset */
|
||
typedef unsigned long COFF; /* coff - cabinet file offset */
|
||
|
||
|
||
#ifndef TRUE
|
||
#define TRUE 1
|
||
#endif
|
||
|
||
#ifndef FALSE
|
||
#define FALSE 0
|
||
#endif
|
||
|
||
#ifndef NULL
|
||
#define NULL 0
|
||
#endif
|
||
|
||
|
||
/*** ERF - Error structure
|
||
*
|
||
* This structure returns error information from FCI/FDI. The caller should
|
||
* not modify this structure.
|
||
*/
|
||
typedef struct {
|
||
int erfOper; // FCI/FDI error code -- see FDIERROR_XXX
|
||
// and FCIERR_XXX equates for details.
|
||
|
||
int erfType; // Optional error value filled in by FCI/FDI.
|
||
// For FCI, this is usually the C run-time
|
||
// *errno* value.
|
||
|
||
BOOL fError; // TRUE => error present
|
||
} ERF; /* erf */
|
||
typedef ERF FAR *PERF; /* perf */
|
||
|
||
#ifdef _DEBUG
|
||
// don't hide statics from map during debugging
|
||
#define STATIC
|
||
#else // !DEBUG
|
||
#define STATIC static
|
||
#endif // !DEBUG
|
||
|
||
#define CB_MAX_CHUNK 32768U
|
||
#define CB_MAX_DISK 0x7fffffffL
|
||
#define CB_MAX_FILENAME 256
|
||
#define CB_MAX_CABINET_NAME 256
|
||
#define CB_MAX_CAB_PATH 256
|
||
#define CB_MAX_DISK_NAME 256
|
||
|
||
/*** tcompXXX - Diamond compression types
|
||
*
|
||
* These are passed to FCIAddFile(), and are also stored in the CFFOLDER
|
||
* structures in cabinet files.
|
||
*
|
||
* NOTE: We reserve bits for the TYPE, QUANTUM_LEVEL, and QUANTUM_MEM
|
||
* to provide room for future expansion. Since this value is stored
|
||
* in the CFDATA records in the cabinet file, we don't want to
|
||
* have to change the format for existing compression configurations
|
||
* if we add new ones in the future. This will allows us to read
|
||
* old cabinet files in the future.
|
||
*/
|
||
|
||
typedef unsigned short TCOMP; /* tcomp */
|
||
|
||
#define tcompMASK_TYPE 0x000F // Mask for compression type
|
||
#define tcompTYPE_NONE 0x0000 // No compression
|
||
#define tcompTYPE_MSZIP 0x0001 // MSZIP
|
||
#define tcompTYPE_QUANTUM 0x0002 // Quantum
|
||
#define tcompTYPE_LZX 0x0003 // LZX
|
||
#define tcompBAD 0x000F // Unspecified compression type
|
||
|
||
#define tcompMASK_LZX_WINDOW 0x1F00 // Mask for LZX Compression Memory
|
||
#define tcompLZX_WINDOW_LO 0x0F00 // Lowest LZX Memory (15)
|
||
#define tcompLZX_WINDOW_HI 0x1500 // Highest LZX Memory (21)
|
||
#define tcompSHIFT_LZX_WINDOW 8 // Amount to shift over to get int
|
||
|
||
#define tcompMASK_QUANTUM_LEVEL 0x00F0 // Mask for Quantum Compression Level
|
||
#define tcompQUANTUM_LEVEL_LO 0x0010 // Lowest Quantum Level (1)
|
||
#define tcompQUANTUM_LEVEL_HI 0x0070 // Highest Quantum Level (7)
|
||
#define tcompSHIFT_QUANTUM_LEVEL 4 // Amount to shift over to get int
|
||
|
||
#define tcompMASK_QUANTUM_MEM 0x1F00 // Mask for Quantum Compression Memory
|
||
#define tcompQUANTUM_MEM_LO 0x0A00 // Lowest Quantum Memory (10)
|
||
#define tcompQUANTUM_MEM_HI 0x1500 // Highest Quantum Memory (21)
|
||
#define tcompSHIFT_QUANTUM_MEM 8 // Amount to shift over to get int
|
||
|
||
#define tcompMASK_RESERVED 0xE000 // Reserved bits (high 3 bits)
|
||
|
||
|
||
|
||
#define CompressionTypeFromTCOMP(tc) \
|
||
((tc) & tcompMASK_TYPE)
|
||
|
||
#define CompressionLevelFromTCOMP(tc) \
|
||
(((tc) & tcompMASK_QUANTUM_LEVEL) >> tcompSHIFT_QUANTUM_LEVEL)
|
||
|
||
#define CompressionMemoryFromTCOMP(tc) \
|
||
(((tc) & tcompMASK_QUANTUM_MEM) >> tcompSHIFT_QUANTUM_MEM)
|
||
|
||
#define TCOMPfromTypeLevelMemory(t,l,m) \
|
||
(((m) << tcompSHIFT_QUANTUM_MEM ) | \
|
||
((l) << tcompSHIFT_QUANTUM_LEVEL) | \
|
||
( t ))
|
||
|
||
#define LZXCompressionWindowFromTCOMP(tc) \
|
||
(((tc) & tcompMASK_LZX_WINDOW) >> tcompSHIFT_LZX_WINDOW)
|
||
|
||
#define TCOMPfromLZXWindow(w) \
|
||
(((w) << tcompSHIFT_LZX_WINDOW ) | \
|
||
( tcompTYPE_LZX ))
|
||
|
||
|
||
//** Revert to default structure packing
|
||
|
||
#ifndef _WIN64
|
||
#include <poppack.h>
|
||
#endif
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif /* __cplusplus */
|
||
|
||
#endif // !INCLUDED_TYPES_FCI_FDI
|
||
/*** fci_int.h - File Compression Interface definitions
|
||
*
|
||
* Microsoft Confidential
|
||
* Copyright (C) Microsoft Corporation 1993-1994
|
||
* All Rights Reserved.
|
||
*
|
||
* Author:
|
||
* Chuck Strouss
|
||
*
|
||
* History:
|
||
* 09-Jan-1994 chuckst Contents moved to bfol.h, this file is a
|
||
* placeholder for the new 'higher-level' fci
|
||
* 14-Feb-1994 bens Cleaned up some comments.
|
||
* 09-Mar-1994 bens Added error codes (moved from buildcab.h);
|
||
* Added RESERVE control
|
||
* 17-Mar-1994 bens Specify structure packing explicitly
|
||
* 21-Mar-1994 bens Cleaned up names
|
||
* 22-Mar-1994 bens Documented error cods
|
||
* 29-Mar-1994 bens Add FCIFlushFolder, renamed FCIFlushCabinet
|
||
* 18-Apr-1994 bens Changed CDECL to DIAMONDAPI
|
||
* 18-May-1994 bens Add ccab.fFailOnIncompressible field for
|
||
* Chicago M6 hack.
|
||
*/
|
||
|
||
#ifndef INCLUDED_FCI
|
||
#define INCLUDED_FCI 1
|
||
|
||
#include <basetsd.h>
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" { /* Assume C declarations for C++ */
|
||
#endif /* __cplusplus */
|
||
|
||
//** Specify structure packing explicitly for clients of FCI
|
||
|
||
#ifndef _WIN64
|
||
#pragma pack(4)
|
||
#endif
|
||
|
||
|
||
/*** FCIERROR - Error codes returned in erf.erfOper field
|
||
*
|
||
*/
|
||
typedef enum {
|
||
FCIERR_NONE, // No error
|
||
|
||
FCIERR_OPEN_SRC, // Failure opening file to be stored in cabinet
|
||
// erf.erfTyp has C run-time *errno* value
|
||
|
||
FCIERR_READ_SRC, // Failure reading file to be stored in cabinet
|
||
// erf.erfTyp has C run-time *errno* value
|
||
|
||
FCIERR_ALLOC_FAIL, // Out of memory in FCI
|
||
|
||
FCIERR_TEMP_FILE, // Could not create a temporary file
|
||
// erf.erfTyp has C run-time *errno* value
|
||
|
||
FCIERR_BAD_COMPR_TYPE, // Unknown compression type
|
||
|
||
FCIERR_CAB_FILE, // Could not create cabinet file
|
||
// erf.erfTyp has C run-time *errno* value
|
||
|
||
FCIERR_USER_ABORT, // Client requested abort
|
||
|
||
FCIERR_MCI_FAIL, // Failure compressing data
|
||
|
||
} FCIERROR;
|
||
|
||
|
||
/*
|
||
* FAT file attribute flag used by FCI/FDI to indicate that
|
||
* the filename in the CAB is a UTF string
|
||
*/
|
||
#ifndef _A_NAME_IS_UTF
|
||
#define _A_NAME_IS_UTF 0x80
|
||
#endif
|
||
|
||
/*
|
||
* FAT file attribute flag used by FCI/FDI to indicate that
|
||
* the file should be executed after extraction
|
||
*/
|
||
#ifndef _A_EXEC
|
||
#define _A_EXEC 0x40
|
||
#endif
|
||
|
||
|
||
/*** HFCI - Handle to an FCI Context
|
||
*
|
||
*/
|
||
typedef void * HFCI;
|
||
|
||
|
||
/*** CCAB - Current Cabinet
|
||
*
|
||
* This structure is used for passing in the cabinet parameters to FCI,
|
||
* and is passed back on certain FCI callbacks to provide cabinet
|
||
* information to the client.
|
||
*/
|
||
typedef struct {
|
||
// longs first
|
||
ULONG cb; // size available for cabinet on this media
|
||
ULONG cbFolderThresh; // Thresshold for forcing a new Folder
|
||
|
||
// then ints
|
||
UINT cbReserveCFHeader; // Space to reserve in CFHEADER
|
||
UINT cbReserveCFFolder; // Space to reserve in CFFOLDER
|
||
UINT cbReserveCFData; // Space to reserve in CFDATA
|
||
int iCab; // sequential numbers for cabinets
|
||
int iDisk; // Disk number
|
||
#ifndef REMOVE_CHICAGO_M6_HACK
|
||
int fFailOnIncompressible; // TRUE => Fail if a block is incompressible
|
||
#endif
|
||
|
||
// then shorts
|
||
USHORT setID; // Cabinet set ID
|
||
|
||
// then chars
|
||
char szDisk[CB_MAX_DISK_NAME]; // current disk name
|
||
char szCab[CB_MAX_CABINET_NAME]; // current cabinet name
|
||
char szCabPath[CB_MAX_CAB_PATH]; // path for creating cabinet
|
||
} CCAB; /* ccab */
|
||
typedef CCAB *PCCAB; /* pccab */
|
||
|
||
|
||
/*** FNALLOC - Memory Allocation
|
||
* FNFREE - Memory Free
|
||
*
|
||
* These are modeled after the C run-time routines malloc() and free()
|
||
* (16-bit clients please note -- the size is a ULONG, so you may need
|
||
* to write a wrapper routine for halloc!). FDI expects error
|
||
* handling to be identical to these C run-time routines.
|
||
*
|
||
* As long as you faithfully copy the semantics of malloc() and free(),
|
||
* you can supply any functions you like!
|
||
*
|
||
* WARNING: You should never assume anything about the sequence of
|
||
* PFNALLOC and PFNFREE calls -- incremental releases of
|
||
* Diamond/FDI may have radically different numbers of
|
||
* PFNALLOC calls and allocation sizes!
|
||
*/
|
||
//** Memory functions for FCI
|
||
typedef void HUGE * (FAR DIAMONDAPI *PFNFCIALLOC)(ULONG cb); /* pfna */
|
||
#define FNFCIALLOC(fn) void HUGE * FAR DIAMONDAPI fn(ULONG cb)
|
||
|
||
typedef void (FAR DIAMONDAPI *PFNFCIFREE)(void HUGE *memory); /* pfnf */
|
||
#define FNFCIFREE(fn) void FAR DIAMONDAPI fn(void HUGE *memory)
|
||
|
||
|
||
//** File I/O functions for FCI
|
||
typedef INT_PTR (FAR DIAMONDAPI *PFNFCIOPEN) (char FAR *pszFile, int oflag, int pmode, int FAR *err, void FAR *pv);
|
||
typedef UINT (FAR DIAMONDAPI *PFNFCIREAD) (INT_PTR hf, void FAR *memory, UINT cb, int FAR *err, void FAR *pv);
|
||
typedef UINT (FAR DIAMONDAPI *PFNFCIWRITE)(INT_PTR hf, void FAR *memory, UINT cb, int FAR *err, void FAR *pv);
|
||
typedef int (FAR DIAMONDAPI *PFNFCICLOSE)(INT_PTR hf, int FAR *err, void FAR *pv);
|
||
typedef long (FAR DIAMONDAPI *PFNFCISEEK) (INT_PTR hf, long dist, int seektype, int FAR *err, void FAR *pv);
|
||
typedef int (FAR DIAMONDAPI *PFNFCIDELETE) (char FAR *pszFile, int FAR *err, void FAR *pv);
|
||
|
||
#define FNFCIOPEN(fn) INT_PTR FAR DIAMONDAPI fn(char FAR *pszFile, int oflag, int pmode, int FAR *err, void FAR *pv)
|
||
#define FNFCIREAD(fn) UINT FAR DIAMONDAPI fn(INT_PTR hf, void FAR *memory, UINT cb, int FAR *err, void FAR *pv)
|
||
#define FNFCIWRITE(fn) UINT FAR DIAMONDAPI fn(INT_PTR hf, void FAR *memory, UINT cb, int FAR *err, void FAR *pv)
|
||
#define FNFCICLOSE(fn) int FAR DIAMONDAPI fn(INT_PTR hf, int FAR *err, void FAR *pv)
|
||
#define FNFCISEEK(fn) long FAR DIAMONDAPI fn(INT_PTR hf, long dist, int seektype, int FAR *err, void FAR *pv)
|
||
#define FNFCIDELETE(fn) int FAR DIAMONDAPI fn(char FAR *pszFile, int FAR *err, void FAR *pv)
|
||
|
||
|
||
/*** FNFCIGETNEXTCABINET - Callback used to request new cabinet info
|
||
*
|
||
* Entry:
|
||
* pccab - Points to copy of old ccab structure to modify
|
||
* cbPrevCab - Estimate of size of previous cabinet
|
||
* pv - Has the caller's context pointer
|
||
*
|
||
* Exit-Success:
|
||
* returns TRUE;
|
||
*
|
||
* Exit-Failure:
|
||
* returns FALSE;
|
||
*/
|
||
typedef BOOL (DIAMONDAPI *PFNFCIGETNEXTCABINET)(PCCAB pccab,
|
||
ULONG cbPrevCab,
|
||
void FAR *pv); /* pfnfcignc */
|
||
|
||
#define FNFCIGETNEXTCABINET(fn) BOOL DIAMONDAPI fn(PCCAB pccab, \
|
||
ULONG cbPrevCab, \
|
||
void FAR *pv)
|
||
|
||
|
||
/*** FNFCIFILEPLACED - Notify FCI client that file was placed
|
||
*
|
||
* Entry:
|
||
* pccab - cabinet structure to fill in, with copy of previous one
|
||
* pszFile - name of file, from cabinet
|
||
* cbFile - length of file
|
||
* fContinuation - true if this is a later segment of a continued file
|
||
* pv - the context of the client
|
||
*
|
||
* Exit-Success:
|
||
* return value anything but -1
|
||
*
|
||
* Exit-Failure:
|
||
* return value -1 means to abort
|
||
*/
|
||
typedef int (DIAMONDAPI *PFNFCIFILEPLACED)(PCCAB pccab,
|
||
char *pszFile,
|
||
long cbFile,
|
||
BOOL fContinuation,
|
||
void FAR *pv); /* pfnfcifp */
|
||
|
||
#define FNFCIFILEPLACED(fn) int DIAMONDAPI fn(PCCAB pccab, \
|
||
char *pszFile, \
|
||
long cbFile, \
|
||
BOOL fContinuation, \
|
||
void FAR *pv)
|
||
|
||
|
||
/*** FNCDIGETOPENINFO - Open source file, get date/time/attribs
|
||
*
|
||
* Entry:
|
||
* pszName -- complete path to filename
|
||
* pdate -- location to return FAT-style date code
|
||
* ptime -- location to return FAT-style time code
|
||
* pattribs -- location to return FAT-style attributes
|
||
* pv -- client's context
|
||
*
|
||
* Exit-Success:
|
||
* Return value is file handle of open file to read
|
||
*
|
||
* Exit-Failure:
|
||
* Return value is -1
|
||
*/
|
||
typedef INT_PTR (DIAMONDAPI *PFNFCIGETOPENINFO)(char *pszName,
|
||
USHORT *pdate,
|
||
USHORT *ptime,
|
||
USHORT *pattribs,
|
||
int FAR *err,
|
||
void FAR *pv); /* pfnfcigoi */
|
||
|
||
#define FNFCIGETOPENINFO(fn) INT_PTR DIAMONDAPI fn(char *pszName, \
|
||
USHORT *pdate, \
|
||
USHORT *ptime, \
|
||
USHORT *pattribs, \
|
||
int FAR *err, \
|
||
void FAR *pv)
|
||
|
||
/*** FNFCISTATUS - Status/Cabinet Size callback
|
||
*
|
||
* Entry:
|
||
* typeStatus == statusFile if compressing a block into a folder
|
||
* cb1 = Size of compressed block
|
||
* cb2 = Size of uncompressed block
|
||
*
|
||
* typeStatus == statusFolder if adding a folder to a cabinet
|
||
* cb1 = Amount of folder copied to cabinet so far
|
||
* cb2 = Total size of folder
|
||
*
|
||
* typeStatus == statusCabinet if writing out a complete cabinet
|
||
* cb1 = Estimated cabinet size that was previously
|
||
* passed to fnfciGetNextCabinet().
|
||
* cb2 = Actual cabinet size
|
||
* NOTE: Return value is desired client size for cabinet
|
||
* file. FCI updates the maximum cabinet size
|
||
* remaining using this value. This allows a client
|
||
* to generate multiple cabinets per disk, and have
|
||
* FCI limit the size correctly -- the client can do
|
||
* cluster size rounding on the cabinet size!
|
||
* The client should either return cb2, or round cb2
|
||
* up to some larger value and return that.
|
||
* Exit-Success:
|
||
* Returns anything other than -1;
|
||
* NOTE: See statusCabinet for special return values!
|
||
*
|
||
* Exit-Failure:
|
||
* Returns -1 to signal that FCI should abort;
|
||
*/
|
||
|
||
#define statusFile 0 // Add File to Folder callback
|
||
#define statusFolder 1 // Add Folder to Cabinet callback
|
||
#define statusCabinet 2 // Write out a completed cabinet callback
|
||
|
||
typedef long (DIAMONDAPI *PFNFCISTATUS)(UINT typeStatus,
|
||
ULONG cb1,
|
||
ULONG cb2,
|
||
void FAR *pv); /* pfnfcis */
|
||
|
||
#define FNFCISTATUS(fn) long DIAMONDAPI fn(UINT typeStatus, \
|
||
ULONG cb1, \
|
||
ULONG cb2, \
|
||
void FAR *pv)
|
||
|
||
|
||
/*** FNFCIGETTEMPFILE - Callback, requests temporary file name
|
||
*
|
||
* Entry:
|
||
* pszTempName - Buffer to receive complete tempfile name
|
||
* cbTempName - Size of pszTempName buffer
|
||
*
|
||
* Exit-Success:
|
||
* return TRUE
|
||
*
|
||
* Exit-Failure:
|
||
* return FALSE; could not create tempfile, or buffer too small
|
||
*
|
||
* Note:
|
||
* It is conceivable that this function may return a filename
|
||
* that will already exist by the time it is opened. For this
|
||
* reason, the caller should make several attempts to create
|
||
* temporary files before giving up.
|
||
*/
|
||
typedef BOOL (DIAMONDAPI *PFNFCIGETTEMPFILE)(char *pszTempName,
|
||
int cbTempName,
|
||
void FAR *pv); /* pfnfcigtf */
|
||
|
||
#define FNFCIGETTEMPFILE(fn) BOOL DIAMONDAPI fn(char *pszTempName, \
|
||
int cbTempName, \
|
||
void FAR *pv)
|
||
|
||
|
||
/*** FCICreate -- create an FCI context (an open CAB, an open FOL)
|
||
*
|
||
* Entry:
|
||
* perf - structure where we return error codes
|
||
* pfnfcifp - callback to inform caller of eventual dest of files
|
||
* pfna - memory allocation function callback
|
||
* pfnf - memory free function callback
|
||
* pfnfcigtf - temp file name generator callback
|
||
* pccab - pointer to cabinet/disk name & size structure
|
||
*
|
||
* Notes:
|
||
* (1) The alloc/free callbacks must remain valid throughout
|
||
* the life of the context, up to and including the call to
|
||
* FCIDestroy.
|
||
* (2) The perf pointer is stored in the compression context (HCI),
|
||
* and any errors from subsequent FCI calls are stored in the
|
||
* erf that was passed in on *this* call.
|
||
*
|
||
* Exit-Success:
|
||
* Returns non-NULL handle to an FCI context.
|
||
*
|
||
* Exit-Failure:
|
||
* Returns NULL, perf filled in.
|
||
*/
|
||
HFCI DIAMONDAPI FCICreate(PERF perf,
|
||
PFNFCIFILEPLACED pfnfcifp,
|
||
PFNFCIALLOC pfna,
|
||
PFNFCIFREE pfnf,
|
||
PFNFCIOPEN pfnopen,
|
||
PFNFCIREAD pfnread,
|
||
PFNFCIWRITE pfnwrite,
|
||
PFNFCICLOSE pfnclose,
|
||
PFNFCISEEK pfnseek,
|
||
PFNFCIDELETE pfndelete,
|
||
PFNFCIGETTEMPFILE pfnfcigtf,
|
||
PCCAB pccab,
|
||
void FAR * pv
|
||
);
|
||
|
||
|
||
/*** FCIAddFile - Add a disk file to a folder/cabinet
|
||
*
|
||
* Entry:
|
||
* hfci - FCI context handle
|
||
* pszSourceFile - Name of file to add to folder
|
||
* pszFileName - Name to store into folder/cabinet
|
||
* fExecute - Flag indicating execute on extract
|
||
* pfn_progress - Progress callback
|
||
* pfnfcignc - GetNextCabinet callback
|
||
* pfnfcis - Status callback
|
||
* pfnfcigoi - OpenInfo callback
|
||
* typeCompress - Type of compression to use for this file
|
||
* pv - pointer to caller's internal context
|
||
*
|
||
* Exit-Success:
|
||
* returns TRUE
|
||
*
|
||
* Exit-Failure:
|
||
* returns FALSE, error filled in
|
||
*
|
||
* This is the main function used to add file(s) to a cabinet
|
||
* or series of cabinets. If the current file causes the current
|
||
* folder/cabinet to overflow the disk image currently being built,
|
||
* the cabinet will be terminated, and a new cabinet/disk name will
|
||
* be prompted for via a callback. The pending folder will be trimmed
|
||
* of the data which has already been generated in the finished cabinet.
|
||
*/
|
||
BOOL DIAMONDAPI FCIAddFile(HFCI hfci,
|
||
char *pszSourceFile,
|
||
char *pszFileName,
|
||
BOOL fExecute,
|
||
PFNFCIGETNEXTCABINET pfnfcignc,
|
||
PFNFCISTATUS pfnfcis,
|
||
PFNFCIGETOPENINFO pfnfcigoi,
|
||
TCOMP typeCompress
|
||
);
|
||
|
||
|
||
/*** FCIFlushCabinet - Complete the current cabinet under construction
|
||
*
|
||
* This will cause the current cabinet (assuming it is not empty) to
|
||
* be gathered together and written to disk.
|
||
*
|
||
* Entry:
|
||
* hfci - FCI context
|
||
* fGetNextCab - TRUE => Call GetNextCab to get continuation info;
|
||
* FALSE => Don't call GetNextCab unless this cabinet
|
||
* overflows.
|
||
* pfnfcignc - callback function to get continuation cabinets
|
||
* pfnfcis - callback function for progress reporting
|
||
* pv - caller's internal context for callbacks
|
||
*
|
||
* Exit-Success:
|
||
* return code TRUE
|
||
*
|
||
* Exit-Failure:
|
||
* return code FALSE, error structure filled in
|
||
*/
|
||
BOOL DIAMONDAPI FCIFlushCabinet(HFCI hfci,
|
||
BOOL fGetNextCab,
|
||
PFNFCIGETNEXTCABINET pfnfcignc,
|
||
PFNFCISTATUS pfnfcis
|
||
);
|
||
|
||
|
||
/*** FCIFlushFolder - Complete the current folder under construction
|
||
*
|
||
* This will force the termination of the current folder, which may or
|
||
* may not cause one or more cabinet files to be completed.
|
||
*
|
||
* Entry:
|
||
* hfci - FCI context
|
||
* GetNextCab - callback function to get continuation cabinets
|
||
* pfnProgress - callback function for progress reporting
|
||
* pv - caller's internal context for callbacks
|
||
*
|
||
* Exit-Success:
|
||
* return code TRUE
|
||
*
|
||
* Exit-Failure:
|
||
* return code FALSE, error structure filled in
|
||
*/
|
||
BOOL DIAMONDAPI FCIFlushFolder(HFCI hfci,
|
||
PFNFCIGETNEXTCABINET pfnfcignc,
|
||
PFNFCISTATUS pfnfcis
|
||
);
|
||
|
||
|
||
/*** FCIDestroy - Destroy a FCI context and delete temp files
|
||
*
|
||
* Entry:
|
||
* hfci - FCI context
|
||
*
|
||
* Exit-Success:
|
||
* return code TRUE
|
||
*
|
||
* Exit-Failure:
|
||
* return code FALSE, error structure filled in
|
||
*/
|
||
BOOL DIAMONDAPI FCIDestroy (HFCI hfci);
|
||
|
||
//** Revert to default structure packing
|
||
|
||
#ifndef _WIN64
|
||
#pragma pack()
|
||
#endif
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif /* __cplusplus */
|
||
|
||
#endif // !INCLUDED_FCI
|
||
|