fdi.h File Reference

#include <pshpack4.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for fdi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ERF
struct	FDICABINETINFO
struct	FDIDECRYPT
struct	FDINOTIFICATION
struct	FDISPILLFILE

Macros
#define	INCLUDED_TYPES_FCI_FDI   1
#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
#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)
#define	LZXCompressionWindowFromTCOMP(tc)   (((tc) & tcompMASK_LZX_WINDOW) >> tcompSHIFT_LZX_WINDOW)
#define	TCOMPfromLZXWindow(w)
#define	_A_NAME_IS_UTF   0x80
#define	_A_EXEC   0x40
#define	FNALLOC(fn)   void * __cdecl fn(ULONG cb)
#define	FNFREE(fn)   void __cdecl fn(void *pv)
#define	FNOPEN(fn)   INT_PTR __cdecl fn(char *pszFile, int oflag, int pmode)
#define	FNREAD(fn)   UINT __cdecl fn(INT_PTR hf, void *pv, UINT cb)
#define	FNWRITE(fn)   UINT __cdecl fn(INT_PTR hf, void *pv, UINT cb)
#define	FNCLOSE(fn)   int __cdecl fn(INT_PTR hf)
#define	FNSEEK(fn)   LONG __cdecl fn(INT_PTR hf, LONG dist, int seektype)
#define	FNFDIDECRYPT(fn)   int __cdecl fn(PFDIDECRYPT pfdid)
#define	FNFDINOTIFY(fn)
#define	cpuUNKNOWN   (-1) /* FDI does detection */
#define	cpu80286   (0) /* '286 opcodes only */
#define	cpu80386   (1) /* '386 opcodes used */

Typedefs
typedef ULONG	CHECKSUM
typedef ULONG	UOFF
typedef ULONG	COFF
typedef struct ERF *	PERF
typedef unsigned short	TCOMP
typedef void *	HFDI
typedef struct FDICABINETINFO *	PFDICABINETINFO
typedef struct FDIDECRYPT *	PFDIDECRYPT
typedef void *(__cdecl *	PFNALLOC) (ULONG cb)
typedef void(__cdecl *	PFNFREE) (void *pv)
typedef INT_PTR(__cdecl *	PFNOPEN) (char *pszFile, int oflag, int pmode)
typedef UINT(__cdecl *	PFNREAD) (INT_PTR hf, void *pv, UINT cb)
typedef UINT(__cdecl *	PFNWRITE) (INT_PTR hf, void *pv, UINT cb)
typedef int(__cdecl *	PFNCLOSE) (INT_PTR hf)
typedef LONG(__cdecl *	PFNSEEK) (INT_PTR hf, LONG dist, int seektype)
typedef int(__cdecl *	PFNFDIDECRYPT) (PFDIDECRYPT pfdid)
typedef struct FDINOTIFICATION *	PFDINOTIFICATION
typedef INT_PTR(__cdecl *	PFNFDINOTIFY) (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
typedef struct FDISPILLFILE *	PFDISPILLFILE

Enumerations
enum	FDIERROR {   FDIERROR_NONE, FDIERROR_CABINET_NOT_FOUND, FDIERROR_NOT_A_CABINET, FDIERROR_UNKNOWN_CABINET_VERSION,   FDIERROR_CORRUPT_CABINET, FDIERROR_ALLOC_FAIL, FDIERROR_BAD_COMPR_TYPE, FDIERROR_MDI_FAIL,   FDIERROR_TARGET_FILE, FDIERROR_RESERVE_MISMATCH, FDIERROR_WRONG_CABINET, FDIERROR_USER_ABORT }
enum	FDIDECRYPTTYPE { fdidtNEW_CABINET, fdidtNEW_FOLDER, fdidtDECRYPT }
enum	FDINOTIFICATIONTYPE {   fdintCABINET_INFO, fdintPARTIAL_FILE, fdintCOPY_FILE, fdintCLOSE_FILE_INFO,   fdintNEXT_CABINET, fdintENUMERATE }

Functions
HFDI __cdecl	FDICreate (PFNALLOC, PFNFREE, PFNOPEN, PFNREAD, PFNWRITE, PFNCLOSE, PFNSEEK, int, PERF)
BOOL __cdecl	FDIIsCabinet (HFDI, INT_PTR, PFDICABINETINFO)
BOOL __cdecl	FDICopy (HFDI, char *, char *, int, PFNFDINOTIFY, PFNFDIDECRYPT, void *pvUser)
BOOL __cdecl	FDIDestroy (HFDI)
BOOL __cdecl	FDITruncateCabinet (HFDI, char *, USHORT)

Macro Definition Documentation

_A_EXEC

#define _A_EXEC   0x40

Definition at line 136 of file fdi.h.

_A_NAME_IS_UTF

#define _A_NAME_IS_UTF   0x80

Definition at line 132 of file fdi.h.

CB_MAX_CAB_PATH

#define CB_MAX_CAB_PATH   256

Definition at line 54 of file fdi.h.

CB_MAX_CABINET_NAME

#define CB_MAX_CABINET_NAME   256

Definition at line 53 of file fdi.h.

CB_MAX_CHUNK

#define CB_MAX_CHUNK   32768U

Definition at line 50 of file fdi.h.

CB_MAX_DISK

#define CB_MAX_DISK   0x7fffffffL

Definition at line 51 of file fdi.h.

CB_MAX_DISK_NAME

#define CB_MAX_DISK_NAME   256

Definition at line 55 of file fdi.h.

CB_MAX_FILENAME

#define CB_MAX_FILENAME   256

Definition at line 52 of file fdi.h.

CompressionLevelFromTCOMP

#define CompressionLevelFromTCOMP

(

tc

)

(((tc) & tcompMASK_QUANTUM_LEVEL) >> tcompSHIFT_QUANTUM_LEVEL)

Definition at line 90 of file fdi.h.

CompressionMemoryFromTCOMP

#define CompressionMemoryFromTCOMP

(

tc

)

(((tc) & tcompMASK_QUANTUM_MEM) >> tcompSHIFT_QUANTUM_MEM)

Definition at line 93 of file fdi.h.

CompressionTypeFromTCOMP

#define CompressionTypeFromTCOMP

(

tc

)

((tc) & tcompMASK_TYPE)

Definition at line 87 of file fdi.h.

cpu80286

#define cpu80286   (0) /* '286 opcodes only */

Definition at line 270 of file fdi.h.

cpu80386

#define cpu80386   (1) /* '386 opcodes used */

Definition at line 271 of file fdi.h.

cpuUNKNOWN

#define cpuUNKNOWN   (-1) /* FDI does detection */

Definition at line 269 of file fdi.h.

FNALLOC

#define FNALLOC

(

fn

)

void * __cdecl fn(ULONG cb)

Definition at line 203 of file fdi.h.

FNCLOSE

#define FNCLOSE

(

fn

)

int __cdecl fn(INT_PTR hf)

Definition at line 218 of file fdi.h.

FNFDIDECRYPT

#define FNFDIDECRYPT

(

fn

)

int __cdecl fn(PFDIDECRYPT pfdid)

Definition at line 224 of file fdi.h.

FNFDINOTIFY

#define FNFDINOTIFY

(

fn

)

Value:

INT_PTR __cdecl fn(FDINOTIFICATIONTYPE fdint, \
                       PFDINOTIFICATION pfdin)

Definition at line 257 of file fdi.h.

FNFREE

#define FNFREE

(

fn

)

void __cdecl fn(void *pv)

Definition at line 206 of file fdi.h.

FNOPEN

#define FNOPEN

(

fn

)

INT_PTR __cdecl fn(char *pszFile, int oflag, int pmode)

Definition at line 209 of file fdi.h.

FNREAD

#define FNREAD

(

fn

)

UINT __cdecl fn(INT_PTR hf, void *pv, UINT cb)

Definition at line 212 of file fdi.h.

FNSEEK

#define FNSEEK

(

fn

)

LONG __cdecl fn(INT_PTR hf, LONG dist, int seektype)

Definition at line 221 of file fdi.h.

FNWRITE

#define FNWRITE

(

fn

)

UINT __cdecl fn(INT_PTR hf, void *pv, UINT cb)

Definition at line 215 of file fdi.h.

INCLUDED_TYPES_FCI_FDI

#define INCLUDED_TYPES_FCI_FDI   1

Definition at line 29 of file fdi.h.

LZXCompressionWindowFromTCOMP

#define LZXCompressionWindowFromTCOMP

(

tc

)

(((tc) & tcompMASK_LZX_WINDOW) >> tcompSHIFT_LZX_WINDOW)

Definition at line 101 of file fdi.h.

tcompBAD

#define tcompBAD   0x000F /* Unspecified compression type */

Definition at line 66 of file fdi.h.

TCOMPfromLZXWindow

#define TCOMPfromLZXWindow

(

w

)

Value:

(((w) << tcompSHIFT_LZX_WINDOW) | \
     ( tcompTYPE_LZX              ))

Definition at line 104 of file fdi.h.

TCOMPfromTypeLevelMemory

#define TCOMPfromTypeLevelMemory	(		t,
			l,
			m
	)

Value:

(((m) << tcompSHIFT_QUANTUM_MEM  ) | \
     ((l) << tcompSHIFT_QUANTUM_LEVEL) | \
     ( t                             ))

Definition at line 96 of file fdi.h.

tcompLZX_WINDOW_HI

#define tcompLZX_WINDOW_HI   0x1500 /* Highest LZX Memory (21) */

Definition at line 70 of file fdi.h.

tcompLZX_WINDOW_LO

#define tcompLZX_WINDOW_LO   0x0F00 /* Lowest LZX Memory (15) */

Definition at line 69 of file fdi.h.

tcompMASK_LZX_WINDOW

#define tcompMASK_LZX_WINDOW   0x1F00 /* Mask for LZX Compression Memory */

Definition at line 68 of file fdi.h.

tcompMASK_QUANTUM_LEVEL

#define tcompMASK_QUANTUM_LEVEL   0x00F0 /* Mask for Quantum Compression Level */

Definition at line 73 of file fdi.h.

tcompMASK_QUANTUM_MEM

#define tcompMASK_QUANTUM_MEM   0x1F00 /* Mask for Quantum Compression Memory */

Definition at line 78 of file fdi.h.

tcompMASK_RESERVED

#define tcompMASK_RESERVED   0xE000 /* Reserved bits (high 3 bits) */

Definition at line 83 of file fdi.h.

tcompMASK_TYPE

#define tcompMASK_TYPE   0x000F /* Mask for compression type */

Definition at line 61 of file fdi.h.

tcompQUANTUM_LEVEL_HI

#define tcompQUANTUM_LEVEL_HI   0x0070 /* Highest Quantum Level (7) */

Definition at line 75 of file fdi.h.

tcompQUANTUM_LEVEL_LO

#define tcompQUANTUM_LEVEL_LO   0x0010 /* Lowest Quantum Level (1) */

Definition at line 74 of file fdi.h.

tcompQUANTUM_MEM_HI

#define tcompQUANTUM_MEM_HI   0x1500 /* Highest Quantum Memory (21) */

Definition at line 80 of file fdi.h.

tcompQUANTUM_MEM_LO

#define tcompQUANTUM_MEM_LO   0x0A00 /* Lowest Quantum Memory (10) */

Definition at line 79 of file fdi.h.

tcompSHIFT_LZX_WINDOW

#define tcompSHIFT_LZX_WINDOW   8 /* Amount to shift over to get int */

Definition at line 71 of file fdi.h.

tcompSHIFT_QUANTUM_LEVEL

#define tcompSHIFT_QUANTUM_LEVEL   4 /* Amount to shift over to get int */

Definition at line 76 of file fdi.h.

tcompSHIFT_QUANTUM_MEM

#define tcompSHIFT_QUANTUM_MEM   8 /* Amount to shift over to get int */

Definition at line 81 of file fdi.h.

tcompTYPE_LZX

#define tcompTYPE_LZX   0x0003 /* LZX */

Definition at line 65 of file fdi.h.

tcompTYPE_MSZIP

#define tcompTYPE_MSZIP   0x0001 /* MSZIP */

Definition at line 63 of file fdi.h.

tcompTYPE_NONE

#define tcompTYPE_NONE   0x0000 /* No compression */

Definition at line 62 of file fdi.h.

tcompTYPE_QUANTUM

#define tcompTYPE_QUANTUM   0x0002 /* Quantum */

Definition at line 64 of file fdi.h.

Typedef Documentation

CHECKSUM

typedef ULONG CHECKSUM

Definition at line 35 of file fdi.h.

COFF

typedef ULONG COFF

Definition at line 38 of file fdi.h.

HFDI

typedef void* HFDI

Definition at line 141 of file fdi.h.

PERF

typedef struct ERF * PERF

PFDICABINETINFO

typedef struct FDICABINETINFO * PFDICABINETINFO

PFDIDECRYPT

typedef struct FDIDECRYPT * PFDIDECRYPT

PFDINOTIFICATION

typedef struct FDINOTIFICATION * PFDINOTIFICATION

PFDISPILLFILE

typedef struct FDISPILLFILE * PFDISPILLFILE

PFNALLOC

typedef void*(__cdecl * PFNALLOC) (ULONG cb)

Definition at line 202 of file fdi.h.

PFNCLOSE

typedef int(__cdecl * PFNCLOSE) (INT_PTR hf)

Definition at line 217 of file fdi.h.

PFNFDIDECRYPT

typedef int(__cdecl * PFNFDIDECRYPT) (PFDIDECRYPT pfdid)

Definition at line 223 of file fdi.h.

PFNFDINOTIFY

typedef INT_PTR(__cdecl * PFNFDINOTIFY) (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

Definition at line 255 of file fdi.h.

PFNFREE

typedef void(__cdecl * PFNFREE) (void *pv)

Definition at line 205 of file fdi.h.

PFNOPEN

typedef INT_PTR(__cdecl * PFNOPEN) (char *pszFile, int oflag, int pmode)

Definition at line 208 of file fdi.h.

PFNREAD

typedef UINT(__cdecl * PFNREAD) (INT_PTR hf, void *pv, UINT cb)

Definition at line 211 of file fdi.h.

PFNSEEK

typedef LONG(__cdecl * PFNSEEK) (INT_PTR hf, LONG dist, int seektype)

Definition at line 220 of file fdi.h.

PFNWRITE

typedef UINT(__cdecl * PFNWRITE) (INT_PTR hf, void *pv, UINT cb)

Definition at line 214 of file fdi.h.

TCOMP

typedef unsigned short TCOMP

Definition at line 59 of file fdi.h.

UOFF

typedef ULONG UOFF

Definition at line 37 of file fdi.h.

Enumeration Type Documentation

FDIDECRYPTTYPE

enum FDIDECRYPTTYPE

Enumerator
fdidtNEW_CABINET
fdidtNEW_FOLDER
fdidtDECRYPT

Definition at line 158 of file fdi.h.

             {
    fdidtNEW_CABINET,  /* New cabinet */
    fdidtNEW_FOLDER,   /* New folder */
    fdidtDECRYPT,      /* Decrypt a data block */
} FDIDECRYPTTYPE;

FDIERROR

enum FDIERROR

Enumerator
FDIERROR_NONE
FDIERROR_CABINET_NOT_FOUND
FDIERROR_NOT_A_CABINET
FDIERROR_UNKNOWN_CABINET_VERSION
FDIERROR_CORRUPT_CABINET
FDIERROR_ALLOC_FAIL
FDIERROR_BAD_COMPR_TYPE
FDIERROR_MDI_FAIL
FDIERROR_TARGET_FILE
FDIERROR_RESERVE_MISMATCH
FDIERROR_WRONG_CABINET
FDIERROR_USER_ABORT

Definition at line 114 of file fdi.h.

             {
    FDIERROR_NONE,
    FDIERROR_CABINET_NOT_FOUND,
    FDIERROR_NOT_A_CABINET,
    FDIERROR_UNKNOWN_CABINET_VERSION,
    FDIERROR_CORRUPT_CABINET,
    FDIERROR_ALLOC_FAIL,
    FDIERROR_BAD_COMPR_TYPE,
    FDIERROR_MDI_FAIL,
    FDIERROR_TARGET_FILE,
    FDIERROR_RESERVE_MISMATCH,
    FDIERROR_WRONG_CABINET,
    FDIERROR_USER_ABORT,
} FDIERROR;

FDINOTIFICATIONTYPE

enum FDINOTIFICATIONTYPE

Enumerator
fdintCABINET_INFO
fdintPARTIAL_FILE
fdintCOPY_FILE
fdintCLOSE_FILE_INFO
fdintNEXT_CABINET
fdintENUMERATE

Definition at line 246 of file fdi.h.

             {
    fdintCABINET_INFO,     /* General information about cabinet */
    fdintPARTIAL_FILE,     /* First file in cabinet is continuation */
    fdintCOPY_FILE,        /* File to be copied */
    fdintCLOSE_FILE_INFO,  /* Close the file, set relevant info */
    fdintNEXT_CABINET,     /* File continued to next cabinet */
    fdintENUMERATE,        /* Enumeration status */
} FDINOTIFICATIONTYPE;

Function Documentation

FDICopy()

BOOL __cdecl FDICopy	(	HFDI	,
		char *	,
		char *	,
		int	,
		PFNFDINOTIFY	,
		PFNFDIDECRYPT	,
		void *	pvUser
	)

Definition at line 2431 of file fdi.c.

{ 
  FDICABINETINFO    fdici;
  FDINOTIFICATION   fdin;
  INT_PTR           cabhf, filehf = 0;
  unsigned int      i;
  char              fullpath[MAX_PATH];
  size_t            pathlen, filenamelen;
  char              emptystring = '\0';
  cab_UBYTE         buf[64];
  struct fdi_folder *fol = NULL, *linkfol = NULL; 
  struct fdi_file   *file = NULL, *linkfile = NULL;
  fdi_decomp_state *decomp_state;
  FDI_Int *fdi = get_fdi_ptr( hfdi );

  TRACE("(hfdi == ^%p, pszCabinet == %s, pszCabPath == %s, flags == %x, "
        "pfnfdin == ^%p, pfnfdid == ^%p, pvUser == ^%p)\n",
        hfdi, debugstr_a(pszCabinet), debugstr_a(pszCabPath), flags, pfnfdin, pfnfdid, pvUser);

  if (!fdi) return FALSE;

  if (!(decomp_state = fdi->alloc(sizeof(fdi_decomp_state))))
  {
      SetLastError(ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
  }
  ZeroMemory(decomp_state, sizeof(fdi_decomp_state));

  pathlen = pszCabPath ? strlen(pszCabPath) : 0;
  filenamelen = pszCabinet ? strlen(pszCabinet) : 0;

  /* slight overestimation here to save CPU cycles in the developer's brain */
  if ((pathlen + filenamelen + 3) > MAX_PATH) {
    ERR("MAX_PATH exceeded.\n");
    fdi->free(decomp_state);
    set_error( fdi, FDIERROR_CABINET_NOT_FOUND, ERROR_FILE_NOT_FOUND );
    return FALSE;
  }

  /* paste the path and filename together */
  fullpath[0] = '\0';
  if (pathlen)
    strcpy(fullpath, pszCabPath);
  if (filenamelen)
    strcat(fullpath, pszCabinet);

  TRACE("full cab path/file name: %s\n", debugstr_a(fullpath));

  /* get a handle to the cabfile */
  cabhf = fdi->open(fullpath, _O_RDONLY|_O_BINARY, _S_IREAD | _S_IWRITE);
  if (cabhf == -1) {
    fdi->free(decomp_state);
    set_error( fdi, FDIERROR_CABINET_NOT_FOUND, 0 );
    SetLastError(ERROR_FILE_NOT_FOUND);
    return FALSE;
  }

  /* check if it's really a cabfile. Note that this doesn't implement the bug */
  if (!FDI_read_entries(fdi, cabhf, &fdici, &(CAB(mii)))) {
    WARN("FDI_read_entries failed: %u\n", fdi->perf->erfOper);
    fdi->free(decomp_state);
    fdi->close(cabhf);
    return FALSE;
  }

  /* cabinet notification */
  ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
  fdin.setID = fdici.setID;
  fdin.iCabinet = fdici.iCabinet;
  fdin.pv = pvUser;
  fdin.psz1 = (CAB(mii).nextname) ? CAB(mii).nextname : &emptystring;
  fdin.psz2 = (CAB(mii).nextinfo) ? CAB(mii).nextinfo : &emptystring;
  fdin.psz3 = pszCabPath;

  if (pfnfdin(fdintCABINET_INFO, &fdin) == -1) {
    set_error( fdi, FDIERROR_USER_ABORT, 0 );
    goto bail_and_fail;
  }

  CAB(setID) = fdici.setID;
  CAB(iCabinet) = fdici.iCabinet;
  CAB(cabhf) = cabhf;

  /* read folders */
  for (i = 0; i < fdici.cFolders; i++) {
    if (fdi->read(cabhf, buf, cffold_SIZEOF) != cffold_SIZEOF) {
      set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
      goto bail_and_fail;
    }

    if (CAB(mii).folder_resv > 0)
      fdi->seek(cabhf, CAB(mii).folder_resv, SEEK_CUR);

    fol = fdi->alloc(sizeof(struct fdi_folder));
    if (!fol) {
      ERR("out of memory!\n");
      set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
      goto bail_and_fail;
    }
    ZeroMemory(fol, sizeof(struct fdi_folder));
    if (!CAB(firstfol)) CAB(firstfol) = fol;

    fol->offset = (cab_off_t) EndGetI32(buf+cffold_DataOffset);
    fol->num_blocks = EndGetI16(buf+cffold_NumBlocks);
    fol->comp_type  = EndGetI16(buf+cffold_CompType);

    if (linkfol)
      linkfol->next = fol; 
    linkfol = fol;
  }

  /* read files */
  for (i = 0; i < fdici.cFiles; i++) {
    if (fdi->read(cabhf, buf, cffile_SIZEOF) != cffile_SIZEOF) {
      set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
      goto bail_and_fail;
    }

    file = fdi->alloc(sizeof(struct fdi_file));
    if (!file) { 
      ERR("out of memory!\n"); 
      set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
      goto bail_and_fail;
    }
    ZeroMemory(file, sizeof(struct fdi_file));
    if (!CAB(firstfile)) CAB(firstfile) = file;
      
    file->length   = EndGetI32(buf+cffile_UncompressedSize);
    file->offset   = EndGetI32(buf+cffile_FolderOffset);
    file->index    = EndGetI16(buf+cffile_FolderIndex);
    file->time     = EndGetI16(buf+cffile_Time);
    file->date     = EndGetI16(buf+cffile_Date);
    file->attribs  = EndGetI16(buf+cffile_Attribs);
    file->filename = FDI_read_string(fdi, cabhf, fdici.cbCabinet);

    if (!file->filename) {
      set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
      goto bail_and_fail;
    }

    if (linkfile)
      linkfile->next = file;
    linkfile = file;
  }

  for (file = CAB(firstfile); (file); file = file->next) {

    /*
     * FIXME: This implementation keeps multiple cabinet files open at once
     * when encountering a split cabinet.  It is a quirk of this implementation
     * that sometimes we decrypt the same block of data more than once, to find
     * the right starting point for a file, moving the file-pointer backwards.
     * If we kept a cache of certain file-pointer information, we could eliminate
     * that behavior... in fact I am not sure that the caching we already have
     * is not sufficient.
     * 
     * The current implementation seems to work fine in straightforward situations
     * where all the cabinet files needed for decryption are simultaneously
     * available.  But presumably, the API is supposed to support cabinets which
     * are split across multiple CDROMS; we may need to change our implementation
     * to strictly serialize its file usage so that it opens only one cabinet
     * at a time.  Some experimentation with Windows is needed to figure out the
     * precise semantics required.  The relevant code is here and in fdi_decomp().
     */

    /* partial-file notification */
    if ((file->index & cffileCONTINUED_FROM_PREV) == cffileCONTINUED_FROM_PREV) {
      /*
       * FIXME: Need to create a Cabinet with a single file spanning multiple files
       * and perform some tests to figure out the right behavior.  The SDK says
       * FDICopy will notify the user of the filename and "disk name" (info) of
       * the cabinet where the spanning file /started/.
       *
       * That would certainly be convenient for the API-user, who could abort,
       * everything (or parallelize, if that's allowed (it is in wine)), and call
       * FDICopy again with the provided filename, so as to avoid partial file
       * notification and successfully unpack.  This task could be quite unpleasant
       * from wine's perspective: the information specifying the "start cabinet" for
       * a file is associated nowhere with the file header and is not to be found in
       * the cabinet header.  We have only the index of the cabinet wherein the folder
       * begins, which contains the file.  To find that cabinet, we must consider the
       * index of the current cabinet, and chain backwards, cabinet-by-cabinet (for
       * each cabinet refers to its "next" and "previous" cabinet only, like a linked
       * list).
       *
       * Bear in mind that, in the spirit of CABINET.DLL, we must assume that any
       * cabinet other than the active one might be at another filepath than the
       * current one, or on another CDROM. This could get rather dicey, especially
       * if we imagine parallelized access to the FDICopy API.
       *
       * The current implementation punts -- it just returns the previous cabinet and
       * its info from the header of this cabinet.  This provides the right answer in
       * 95% of the cases; it's worth checking if Microsoft cuts the same corner before
       * we "fix" it.
       */
      ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
      fdin.pv = pvUser;
      fdin.psz1 = (char *)file->filename;
      fdin.psz2 = (CAB(mii).prevname) ? CAB(mii).prevname : &emptystring;
      fdin.psz3 = (CAB(mii).previnfo) ? CAB(mii).previnfo : &emptystring;

      if (pfnfdin(fdintPARTIAL_FILE, &fdin) == -1) {
        set_error( fdi, FDIERROR_USER_ABORT, 0 );
        goto bail_and_fail;
      }
      /* I don't think we are supposed to decompress partial files.  This prevents it. */
      file->oppressed = TRUE;
    }
    if (file->oppressed) {
      filehf = 0;
    } else {
      ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
      fdin.pv = pvUser;
      fdin.psz1 = (char *)file->filename;
      fdin.cb = file->length;
      fdin.date = file->date;
      fdin.time = file->time;
      fdin.attribs = file->attribs;
      fdin.iFolder = file->index;
      if ((filehf = ((*pfnfdin)(fdintCOPY_FILE, &fdin))) == -1) {
        set_error( fdi, FDIERROR_USER_ABORT, 0 );
        filehf = 0;
        goto bail_and_fail;
      }
    }

    /* find the folder for this file if necc. */
    if (filehf) {
      fol = CAB(firstfol);
      if ((file->index & cffileCONTINUED_TO_NEXT) == cffileCONTINUED_TO_NEXT) {
        /* pick the last folder */
        while (fol->next) fol = fol->next;
      } else {
        unsigned int i2;

        for (i2 = 0; (i2 < file->index); i2++)
          if (fol->next) /* bug resistance, should always be true */
            fol = fol->next;
      }
    }

    if (filehf) {
      cab_UWORD comptype = fol->comp_type;
      int ct1 = comptype & cffoldCOMPTYPE_MASK;
      int ct2 = CAB(current) ? (CAB(current)->comp_type & cffoldCOMPTYPE_MASK) : 0;
      int err = 0;

      TRACE("Extracting file %s as requested by callee.\n", debugstr_a(file->filename));

      /* set up decomp_state */
      CAB(fdi) = fdi;
      CAB(filehf) = filehf;

      /* Was there a change of folder?  Compression type?  Did we somehow go backwards? */
      if ((ct1 != ct2) || (CAB(current) != fol) || (file->offset < CAB(offset))) {

        TRACE("Resetting folder for file %s.\n", debugstr_a(file->filename));

        /* free stuff for the old decompressor */
        switch (ct2) {
        case cffoldCOMPTYPE_LZX:
          if (LZX(window)) {
            fdi->free(LZX(window));
            LZX(window) = NULL;
          }
          break;
        case cffoldCOMPTYPE_QUANTUM:
          if (QTM(window)) {
            fdi->free(QTM(window));
            QTM(window) = NULL;
          }
          break;
        }

        CAB(decomp_cab) = NULL;
        CAB(fdi)->seek(CAB(cabhf), fol->offset, SEEK_SET);
        CAB(offset) = 0;
        CAB(outlen) = 0;

        /* initialize the new decompressor */
        switch (ct1) {
        case cffoldCOMPTYPE_NONE:
          CAB(decompress) = NONEfdi_decomp;
          break;
        case cffoldCOMPTYPE_MSZIP:
          CAB(decompress) = ZIPfdi_decomp;
          break;
        case cffoldCOMPTYPE_QUANTUM:
          CAB(decompress) = QTMfdi_decomp;
          err = QTMfdi_init((comptype >> 8) & 0x1f, (comptype >> 4) & 0xF, decomp_state);
          break;
        case cffoldCOMPTYPE_LZX:
          CAB(decompress) = LZXfdi_decomp;
          err = LZXfdi_init((comptype >> 8) & 0x1f, decomp_state);
          break;
        default:
          err = DECR_DATAFORMAT;
        }
      }

      CAB(current) = fol;

      switch (err) {
        case DECR_OK:
          break;
        case DECR_NOMEMORY:
          set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
          goto bail_and_fail;
        default:
          set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
          goto bail_and_fail;
      }

      if (file->offset > CAB(offset)) {
        /* decode bytes and send them to /dev/null */
        switch (fdi_decomp(file, 0, decomp_state, pszCabPath, pfnfdin, pvUser)) {
          case DECR_OK:
            break;
          case DECR_USERABORT:
            set_error( fdi, FDIERROR_USER_ABORT, 0 );
            goto bail_and_fail;
          case DECR_NOMEMORY:
            set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
            goto bail_and_fail;
          default:
            set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
            goto bail_and_fail;
        }
        CAB(offset) = file->offset;
      }

      /* now do the actual decompression */
      err = fdi_decomp(file, 1, decomp_state, pszCabPath, pfnfdin, pvUser);
      if (err) CAB(current) = NULL; else CAB(offset) += file->length;

      /* fdintCLOSE_FILE_INFO notification */
      ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
      fdin.pv = pvUser;
      fdin.psz1 = (char *)file->filename;
      fdin.hf = filehf;
      fdin.cb = (file->attribs & cffile_A_EXEC) != 0; /* FIXME: is that right? */
      fdin.date = file->date;
      fdin.time = file->time;
      fdin.attribs = file->attribs; /* FIXME: filter _A_EXEC? */
      fdin.iFolder = file->index;
      ((*pfnfdin)(fdintCLOSE_FILE_INFO, &fdin));
      filehf = 0;

      switch (err) {
        case DECR_OK:
          break;
        case DECR_USERABORT:
          set_error( fdi, FDIERROR_USER_ABORT, 0 );
          goto bail_and_fail;
        case DECR_NOMEMORY:
          set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
          goto bail_and_fail;
        default:
          set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
          goto bail_and_fail;
      }
    }
  }

  if (fol) free_decompression_temps(fdi, fol, decomp_state);
  free_decompression_mem(fdi, decomp_state);
 
  return TRUE;

  bail_and_fail: /* here we free ram before error returns */

  if (fol) free_decompression_temps(fdi, fol, decomp_state);

  if (filehf) fdi->close(filehf);

  free_decompression_mem(fdi, decomp_state);

  return FALSE;
}

Referenced by Extract(), extract_cabinet(), extract_cabinet_stream(), and test_FDICopy().

FDICreate()

HFDI __cdecl FDICreate	(	PFNALLOC	,
		PFNFREE	,
		PFNOPEN	,
		PFNREAD	,
		PFNWRITE	,
		PFNCLOSE	,
		PFNSEEK	,
		int	,
		PERF
	)

Definition at line 412 of file fdi.c.

{
  FDI_Int *fdi;

  TRACE("(pfnalloc == ^%p, pfnfree == ^%p, pfnopen == ^%p, pfnread == ^%p, pfnwrite == ^%p, "
        "pfnclose == ^%p, pfnseek == ^%p, cpuType == %d, perf == ^%p)\n",
        pfnalloc, pfnfree, pfnopen, pfnread, pfnwrite, pfnclose, pfnseek,
        cpuType, perf);

  if ((!pfnalloc) || (!pfnfree)) {
    perf->erfOper = FDIERROR_NONE;
    perf->erfType = ERROR_BAD_ARGUMENTS;
    perf->fError = TRUE;

    SetLastError(ERROR_BAD_ARGUMENTS);
    return NULL;
  }

  if (!((fdi = pfnalloc(sizeof(FDI_Int))))) {
    perf->erfOper = FDIERROR_ALLOC_FAIL;
    perf->erfType = 0;
    perf->fError = TRUE;
    return NULL;
  }

  fdi->magic = FDI_INT_MAGIC;
  fdi->alloc = pfnalloc;
  fdi->free  = pfnfree;
  fdi->open  = pfnopen;
  fdi->read  = pfnread;
  fdi->write = pfnwrite;
  fdi->close = pfnclose;
  fdi->seek  = pfnseek;
  /* no-brainer: we ignore the cpu type; this is only used
     for the 16-bit versions in Windows anyhow... */
  fdi->perf = perf;

  return (HFDI)fdi;
}

Referenced by Extract(), extract_cabinet(), extract_cabinet_stream(), test_FDICopy(), test_FDICreate(), test_FDIDestroy(), and test_FDIIsCabinet().

FDIDestroy()

BOOL __cdecl FDIDestroy

(

HFDI

)

Definition at line 2831 of file fdi.c.

{
    FDI_Int *fdi = get_fdi_ptr( hfdi );

    TRACE("(hfdi == ^%p)\n", hfdi);
    if (!fdi) return FALSE;
    fdi->magic = 0; /* paranoia */
    fdi->free(fdi);
    return TRUE;
}

Referenced by Extract(), extract_cabinet(), extract_cabinet_stream(), test_FDICopy(), test_FDICreate(), test_FDIDestroy(), and test_FDIIsCabinet().

FDIIsCabinet()

BOOL __cdecl FDIIsCabinet	(	HFDI	,
		INT_PTR	,
		PFDICABINETINFO
	)

Definition at line 696 of file fdi.c.

{
  BOOL rv;
  FDI_Int *fdi = get_fdi_ptr( hfdi );

  TRACE("(hfdi == ^%p, hf == ^%ld, pfdici == ^%p)\n", hfdi, hf, pfdici);

  if (!fdi) return FALSE;

  if (!pfdici) {
    SetLastError(ERROR_BAD_ARGUMENTS);
    return FALSE;
  }
  rv = FDI_read_entries(fdi, hf, pfdici, NULL);

  if (rv)
    pfdici->hasnext = FALSE; /* yuck. duplicate apparent cabinet.dll bug */

  return rv;
}

Referenced by test_FDICopy(), and test_FDIIsCabinet().

FDITruncateCabinet()

BOOL __cdecl FDITruncateCabinet	(	HFDI	,
		char *	,
		USHORT
	)

Definition at line 2861 of file fdi.c.

{
  FDI_Int *fdi = get_fdi_ptr( hfdi );

  FIXME("(hfdi == ^%p, pszCabinetName == %s, iFolderToDelete == %hu): stub\n",
    hfdi, debugstr_a(pszCabinetName), iFolderToDelete);

  if (!fdi) return FALSE;

  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  return FALSE;
}