ReactOS 0.4.17-dev-804-g023d8af
Classes | Macros | Typedefs | Enumerations | Functions
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)
__cdecl
#define __cdecl
Definition: corecrt.h:121
FDINOTIFICATIONTYPE
FDINOTIFICATIONTYPE
Definition: fdi.h:246
INT_PTR
int32_t INT_PTR
Definition: typedefs.h:64
fn
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159

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 ))
tcompTYPE_LZX
#define tcompTYPE_LZX
Definition: fdi.h:65
tcompSHIFT_LZX_WINDOW
#define tcompSHIFT_LZX_WINDOW
Definition: fdi.h:71
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102

Definition at line 104 of file fdi.h.

◆ TCOMPfromTypeLevelMemory

#define TCOMPfromTypeLevelMemory (   t,
  l,
  m 
)
Value:
(((m) << tcompSHIFT_QUANTUM_MEM ) | \
((l) << tcompSHIFT_QUANTUM_LEVEL) | \
( t ))
l
r l[0]
Definition: byte_order.h:168
tcompSHIFT_QUANTUM_LEVEL
#define tcompSHIFT_QUANTUM_LEVEL
Definition: fdi.h:76
tcompSHIFT_QUANTUM_MEM
#define tcompSHIFT_QUANTUM_MEM
Definition: fdi.h:81
t
GLdouble GLdouble t
Definition: gl.h:2047
m
const GLfloat * m
Definition: glext.h:10848

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.

158 {
159 fdidtNEW_CABINET, /* New cabinet */
160 fdidtNEW_FOLDER, /* New folder */
161 fdidtDECRYPT, /* Decrypt a data block */
162} FDIDECRYPTTYPE;
FDIDECRYPTTYPE
FDIDECRYPTTYPE
Definition: fdi.h:158
fdidtNEW_CABINET
@ fdidtNEW_CABINET
Definition: fdi.h:159
fdidtNEW_FOLDER
@ fdidtNEW_FOLDER
Definition: fdi.h:160
fdidtDECRYPT
@ fdidtDECRYPT
Definition: fdi.h:161

◆ 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.

114 {
115 FDIERROR_NONE,
116 FDIERROR_CABINET_NOT_FOUND,
117 FDIERROR_NOT_A_CABINET,
118 FDIERROR_UNKNOWN_CABINET_VERSION,
119 FDIERROR_CORRUPT_CABINET,
120 FDIERROR_ALLOC_FAIL,
121 FDIERROR_BAD_COMPR_TYPE,
122 FDIERROR_MDI_FAIL,
123 FDIERROR_TARGET_FILE,
124 FDIERROR_RESERVE_MISMATCH,
125 FDIERROR_WRONG_CABINET,
126 FDIERROR_USER_ABORT,
127} FDIERROR;
FDIERROR
FDIERROR
Definition: fdi.h:114
FDIERROR_USER_ABORT
@ FDIERROR_USER_ABORT
Definition: fdi.h:126
FDIERROR_CORRUPT_CABINET
@ FDIERROR_CORRUPT_CABINET
Definition: fdi.h:119
FDIERROR_RESERVE_MISMATCH
@ FDIERROR_RESERVE_MISMATCH
Definition: fdi.h:124
FDIERROR_BAD_COMPR_TYPE
@ FDIERROR_BAD_COMPR_TYPE
Definition: fdi.h:121
FDIERROR_UNKNOWN_CABINET_VERSION
@ FDIERROR_UNKNOWN_CABINET_VERSION
Definition: fdi.h:118
FDIERROR_WRONG_CABINET
@ FDIERROR_WRONG_CABINET
Definition: fdi.h:125
FDIERROR_NONE
@ FDIERROR_NONE
Definition: fdi.h:115
FDIERROR_ALLOC_FAIL
@ FDIERROR_ALLOC_FAIL
Definition: fdi.h:120
FDIERROR_NOT_A_CABINET
@ FDIERROR_NOT_A_CABINET
Definition: fdi.h:117
FDIERROR_MDI_FAIL
@ FDIERROR_MDI_FAIL
Definition: fdi.h:122
FDIERROR_TARGET_FILE
@ FDIERROR_TARGET_FILE
Definition: fdi.h:123
FDIERROR_CABINET_NOT_FOUND
@ FDIERROR_CABINET_NOT_FOUND
Definition: fdi.h:116

◆ FDINOTIFICATIONTYPE

enum FDINOTIFICATIONTYPE
Enumerator
fdintCABINET_INFO 
fdintPARTIAL_FILE 
fdintCOPY_FILE 
fdintCLOSE_FILE_INFO 
fdintNEXT_CABINET 
fdintENUMERATE 

Definition at line 246 of file fdi.h.

246 {
247 fdintCABINET_INFO, /* General information about cabinet */
248 fdintPARTIAL_FILE, /* First file in cabinet is continuation */
249 fdintCOPY_FILE, /* File to be copied */
250 fdintCLOSE_FILE_INFO, /* Close the file, set relevant info */
251 fdintNEXT_CABINET, /* File continued to next cabinet */
252 fdintENUMERATE, /* Enumeration status */
253} FDINOTIFICATIONTYPE;
fdintCABINET_INFO
@ fdintCABINET_INFO
Definition: fdi.h:247
fdintCOPY_FILE
@ fdintCOPY_FILE
Definition: fdi.h:249
fdintPARTIAL_FILE
@ fdintPARTIAL_FILE
Definition: fdi.h:248
fdintCLOSE_FILE_INFO
@ fdintCLOSE_FILE_INFO
Definition: fdi.h:250
fdintNEXT_CABINET
@ fdintNEXT_CABINET
Definition: fdi.h:251
fdintENUMERATE
@ fdintENUMERATE
Definition: fdi.h:252

Function Documentation

◆ FDICopy()

BOOL __cdecl FDICopy ( HFDI  hfdi,
char *  pszCabinet,
char *  pszCabPath,
int  flags,
PFNFDINOTIFY  pfnfdin,
PFNFDIDECRYPT  pfnfdid,
void *  pvUser 
)

Definition at line 2420 of file fdi.c.

2428{
2429 FDICABINETINFO fdici;
2430 FDINOTIFICATION fdin;
2431 INT_PTR cabhf, filehf = 0;
2432 unsigned int i;
2433 char fullpath[MAX_PATH];
2434 size_t pathlen, filenamelen;
2435 char emptystring = '\0';
2436 cab_UBYTE buf[64];
2437 struct fdi_folder *fol = NULL, *linkfol = NULL;
2438 struct fdi_file *file = NULL, *linkfile = NULL;
2439 fdi_decomp_state *decomp_state;
2440 FDI_Int *fdi = get_fdi_ptr( hfdi );
2441
2442 TRACE("(hfdi == ^%p, pszCabinet == %s, pszCabPath == %s, flags == %x, "
2443 "pfnfdin == ^%p, pfnfdid == ^%p, pvUser == ^%p)\n",
2444 hfdi, debugstr_a(pszCabinet), debugstr_a(pszCabPath), flags, pfnfdin, pfnfdid, pvUser);
2445
2446 if (!fdi) return FALSE;
2447
2448 if (!(decomp_state = fdi->alloc(sizeof(fdi_decomp_state))))
2449 {
2450 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2451 return FALSE;
2452 }
2453 ZeroMemory(decomp_state, sizeof(fdi_decomp_state));
2454
2455 pathlen = pszCabPath ? strlen(pszCabPath) : 0;
2456 filenamelen = pszCabinet ? strlen(pszCabinet) : 0;
2457
2458 /* slight overestimation here to save CPU cycles in the developer's brain */
2459 if ((pathlen + filenamelen + 3) > MAX_PATH) {
2460 ERR("MAX_PATH exceeded.\n");
2461 fdi->free(decomp_state);
2462 set_error( fdi, FDIERROR_CABINET_NOT_FOUND, ERROR_FILE_NOT_FOUND );
2463 return FALSE;
2464 }
2465
2466 /* paste the path and filename together */
2467 fullpath[0] = '\0';
2468 if (pathlen)
2469 strcpy(fullpath, pszCabPath);
2470 if (filenamelen)
2471 strcat(fullpath, pszCabinet);
2472
2473 TRACE("full cab path/file name: %s\n", debugstr_a(fullpath));
2474
2475 /* get a handle to the cabfile */
2476 cabhf = fdi->open(fullpath, _O_RDONLY|_O_BINARY, _S_IREAD | _S_IWRITE);
2477 if (cabhf == -1) {
2478 fdi->free(decomp_state);
2479 set_error( fdi, FDIERROR_CABINET_NOT_FOUND, 0 );
2480 SetLastError(ERROR_FILE_NOT_FOUND);
2481 return FALSE;
2482 }
2483
2484 /* check if it's really a cabfile. Note that this doesn't implement the bug */
2485 if (!FDI_read_entries(fdi, cabhf, &fdici, &(CAB(mii)))) {
2486 WARN("FDI_read_entries failed: %u\n", fdi->perf->erfOper);
2487 fdi->free(decomp_state);
2488 fdi->close(cabhf);
2489 return FALSE;
2490 }
2491
2492 /* cabinet notification */
2493 ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
2494 fdin.setID = fdici.setID;
2495 fdin.iCabinet = fdici.iCabinet;
2496 fdin.pv = pvUser;
2497 fdin.psz1 = (CAB(mii).nextname) ? CAB(mii).nextname : &emptystring;
2498 fdin.psz2 = (CAB(mii).nextinfo) ? CAB(mii).nextinfo : &emptystring;
2499 fdin.psz3 = pszCabPath;
2500
2501 if (pfnfdin(fdintCABINET_INFO, &fdin) == -1) {
2502 set_error( fdi, FDIERROR_USER_ABORT, 0 );
2503 goto bail_and_fail;
2504 }
2505
2506 CAB(setID) = fdici.setID;
2507 CAB(iCabinet) = fdici.iCabinet;
2508 CAB(cabhf) = cabhf;
2509
2510 /* read folders */
2511 for (i = 0; i < fdici.cFolders; i++) {
2512 if (fdi->read(cabhf, buf, cffold_SIZEOF) != cffold_SIZEOF) {
2513 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2514 goto bail_and_fail;
2515 }
2516
2517 if (CAB(mii).folder_resv > 0)
2518 fdi->seek(cabhf, CAB(mii).folder_resv, SEEK_CUR);
2519
2520 fol = fdi->alloc(sizeof(struct fdi_folder));
2521 if (!fol) {
2522 ERR("out of memory!\n");
2523 set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
2524 goto bail_and_fail;
2525 }
2526 ZeroMemory(fol, sizeof(struct fdi_folder));
2527 if (!CAB(firstfol)) CAB(firstfol) = fol;
2528
2529 fol->offset = (cab_off_t) EndGetI32(buf+cffold_DataOffset);
2530 fol->num_blocks = EndGetI16(buf+cffold_NumBlocks);
2531 fol->comp_type = EndGetI16(buf+cffold_CompType);
2532
2533 if (linkfol)
2534 linkfol->next = fol;
2535 linkfol = fol;
2536 }
2537
2538 /* read files */
2539 for (i = 0; i < fdici.cFiles; i++) {
2540 if (fdi->read(cabhf, buf, cffile_SIZEOF) != cffile_SIZEOF) {
2541 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2542 goto bail_and_fail;
2543 }
2544
2545 file = fdi->alloc(sizeof(struct fdi_file));
2546 if (!file) {
2547 ERR("out of memory!\n");
2548 set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
2549 goto bail_and_fail;
2550 }
2551 ZeroMemory(file, sizeof(struct fdi_file));
2552 if (!CAB(firstfile)) CAB(firstfile) = file;
2553
2554 file->length = EndGetI32(buf+cffile_UncompressedSize);
2555 file->offset = EndGetI32(buf+cffile_FolderOffset);
2556 file->index = EndGetI16(buf+cffile_FolderIndex);
2557 file->time = EndGetI16(buf+cffile_Time);
2558 file->date = EndGetI16(buf+cffile_Date);
2559 file->attribs = EndGetI16(buf+cffile_Attribs);
2560 file->filename = FDI_read_string(fdi, cabhf, fdici.cbCabinet);
2561
2562 if (!file->filename) {
2563 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2564 goto bail_and_fail;
2565 }
2566
2567 if (linkfile)
2568 linkfile->next = file;
2569 linkfile = file;
2570 }
2571
2572 for (file = CAB(firstfile); (file); file = file->next) {
2573
2574 /*
2575 * FIXME: This implementation keeps multiple cabinet files open at once
2576 * when encountering a split cabinet. It is a quirk of this implementation
2577 * that sometimes we decrypt the same block of data more than once, to find
2578 * the right starting point for a file, moving the file-pointer backwards.
2579 * If we kept a cache of certain file-pointer information, we could eliminate
2580 * that behavior... in fact I am not sure that the caching we already have
2581 * is not sufficient.
2582 *
2583 * The current implementation seems to work fine in straightforward situations
2584 * where all the cabinet files needed for decryption are simultaneously
2585 * available. But presumably, the API is supposed to support cabinets which
2586 * are split across multiple CDROMS; we may need to change our implementation
2587 * to strictly serialize its file usage so that it opens only one cabinet
2588 * at a time. Some experimentation with Windows is needed to figure out the
2589 * precise semantics required. The relevant code is here and in fdi_decomp().
2590 */
2591
2592 /* partial-file notification */
2593 if ((file->index & cffileCONTINUED_FROM_PREV) == cffileCONTINUED_FROM_PREV) {
2594 /*
2595 * FIXME: Need to create a Cabinet with a single file spanning multiple files
2596 * and perform some tests to figure out the right behavior. The SDK says
2597 * FDICopy will notify the user of the filename and "disk name" (info) of
2598 * the cabinet where the spanning file /started/.
2599 *
2600 * That would certainly be convenient for the API-user, who could abort,
2601 * everything (or parallelize, if that's allowed (it is in wine)), and call
2602 * FDICopy again with the provided filename, so as to avoid partial file
2603 * notification and successfully unpack. This task could be quite unpleasant
2604 * from wine's perspective: the information specifying the "start cabinet" for
2605 * a file is associated nowhere with the file header and is not to be found in
2606 * the cabinet header. We have only the index of the cabinet wherein the folder
2607 * begins, which contains the file. To find that cabinet, we must consider the
2608 * index of the current cabinet, and chain backwards, cabinet-by-cabinet (for
2609 * each cabinet refers to its "next" and "previous" cabinet only, like a linked
2610 * list).
2611 *
2612 * Bear in mind that, in the spirit of CABINET.DLL, we must assume that any
2613 * cabinet other than the active one might be at another filepath than the
2614 * current one, or on another CDROM. This could get rather dicey, especially
2615 * if we imagine parallelized access to the FDICopy API.
2616 *
2617 * The current implementation punts -- it just returns the previous cabinet and
2618 * its info from the header of this cabinet. This provides the right answer in
2619 * 95% of the cases; it's worth checking if Microsoft cuts the same corner before
2620 * we "fix" it.
2621 */
2622 ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
2623 fdin.pv = pvUser;
2624 fdin.psz1 = (char *)file->filename;
2625 fdin.psz2 = (CAB(mii).prevname) ? CAB(mii).prevname : &emptystring;
2626 fdin.psz3 = (CAB(mii).previnfo) ? CAB(mii).previnfo : &emptystring;
2627
2628 if (pfnfdin(fdintPARTIAL_FILE, &fdin) == -1) {
2629 set_error( fdi, FDIERROR_USER_ABORT, 0 );
2630 goto bail_and_fail;
2631 }
2632 /* I don't think we are supposed to decompress partial files. This prevents it. */
2633 file->oppressed = TRUE;
2634 }
2635 if (file->oppressed) {
2636 filehf = 0;
2637 } else {
2638 ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
2639 fdin.pv = pvUser;
2640 fdin.psz1 = (char *)file->filename;
2641 fdin.cb = file->length;
2642 fdin.date = file->date;
2643 fdin.time = file->time;
2644 fdin.attribs = file->attribs;
2645 fdin.iFolder = file->index;
2646 if ((filehf = ((*pfnfdin)(fdintCOPY_FILE, &fdin))) == -1) {
2647 set_error( fdi, FDIERROR_USER_ABORT, 0 );
2648 filehf = 0;
2649 goto bail_and_fail;
2650 }
2651 }
2652
2653 /* find the folder for this file if necc. */
2654 if (filehf) {
2655 fol = CAB(firstfol);
2656 if ((file->index & cffileCONTINUED_TO_NEXT) == cffileCONTINUED_TO_NEXT) {
2657 /* pick the last folder */
2658 while (fol->next) fol = fol->next;
2659 } else {
2660 unsigned int i2;
2661
2662 for (i2 = 0; (i2 < file->index); i2++)
2663 if (fol->next) /* bug resistance, should always be true */
2664 fol = fol->next;
2665 }
2666 }
2667
2668 if (filehf) {
2669 cab_UWORD comptype = fol->comp_type;
2670 int ct1 = comptype & cffoldCOMPTYPE_MASK;
2671 int ct2 = CAB(current) ? (CAB(current)->comp_type & cffoldCOMPTYPE_MASK) : 0;
2672 int err = 0;
2673
2674 TRACE("Extracting file %s as requested by callee.\n", debugstr_a(file->filename));
2675
2676 /* set up decomp_state */
2677 CAB(fdi) = fdi;
2678 CAB(filehf) = filehf;
2679
2680 /* Was there a change of folder? Compression type? Did we somehow go backwards? */
2681 if ((ct1 != ct2) || (CAB(current) != fol) || (file->offset < CAB(offset))) {
2682
2683 TRACE("Resetting folder for file %s.\n", debugstr_a(file->filename));
2684
2685 /* free stuff for the old decompressor */
2686 switch (ct2) {
2687 case cffoldCOMPTYPE_LZX:
2688 if (LZX(window)) {
2689 fdi->free(LZX(window));
2690 LZX(window) = NULL;
2691 }
2692 break;
2693 case cffoldCOMPTYPE_QUANTUM:
2694 if (QTM(window)) {
2695 fdi->free(QTM(window));
2696 QTM(window) = NULL;
2697 }
2698 break;
2699 }
2700
2701 CAB(decomp_cab) = NULL;
2702 CAB(fdi)->seek(CAB(cabhf), fol->offset, SEEK_SET);
2703 CAB(offset) = 0;
2704 CAB(outlen) = 0;
2705
2706 /* initialize the new decompressor */
2707 switch (ct1) {
2708 case cffoldCOMPTYPE_NONE:
2709 CAB(decompress) = NONEfdi_decomp;
2710 break;
2711 case cffoldCOMPTYPE_MSZIP:
2712 CAB(decompress) = ZIPfdi_decomp;
2713 break;
2714 case cffoldCOMPTYPE_QUANTUM:
2715 CAB(decompress) = QTMfdi_decomp;
2716 err = QTMfdi_init((comptype >> 8) & 0x1f, (comptype >> 4) & 0xF, decomp_state);
2717 break;
2718 case cffoldCOMPTYPE_LZX:
2719 CAB(decompress) = LZXfdi_decomp;
2720 err = LZXfdi_init((comptype >> 8) & 0x1f, decomp_state);
2721 break;
2722 default:
2723 err = DECR_DATAFORMAT;
2724 }
2725 }
2726
2727 CAB(current) = fol;
2728
2729 switch (err) {
2730 case DECR_OK:
2731 break;
2732 case DECR_NOMEMORY:
2733 set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
2734 goto bail_and_fail;
2735 default:
2736 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2737 goto bail_and_fail;
2738 }
2739
2740 if (file->offset > CAB(offset)) {
2741 /* decode bytes and send them to /dev/null */
2742 switch (fdi_decomp(file, 0, decomp_state, pszCabPath, pfnfdin, pvUser)) {
2743 case DECR_OK:
2744 break;
2745 case DECR_USERABORT:
2746 set_error( fdi, FDIERROR_USER_ABORT, 0 );
2747 goto bail_and_fail;
2748 case DECR_NOMEMORY:
2749 set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
2750 goto bail_and_fail;
2751 default:
2752 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2753 goto bail_and_fail;
2754 }
2755 CAB(offset) = file->offset;
2756 }
2757
2758 /* now do the actual decompression */
2759 err = fdi_decomp(file, 1, decomp_state, pszCabPath, pfnfdin, pvUser);
2760 if (err) CAB(current) = NULL; else CAB(offset) += file->length;
2761
2762 /* fdintCLOSE_FILE_INFO notification */
2763 ZeroMemory(&fdin, sizeof(FDINOTIFICATION));
2764 fdin.pv = pvUser;
2765 fdin.psz1 = (char *)file->filename;
2766 fdin.hf = filehf;
2767 fdin.cb = (file->attribs & cffile_A_EXEC) != 0; /* FIXME: is that right? */
2768 fdin.date = file->date;
2769 fdin.time = file->time;
2770 fdin.attribs = file->attribs; /* FIXME: filter _A_EXEC? */
2771 fdin.iFolder = file->index;
2772 ((*pfnfdin)(fdintCLOSE_FILE_INFO, &fdin));
2773 filehf = 0;
2774
2775 switch (err) {
2776 case DECR_OK:
2777 break;
2778 case DECR_USERABORT:
2779 set_error( fdi, FDIERROR_USER_ABORT, 0 );
2780 goto bail_and_fail;
2781 case DECR_NOMEMORY:
2782 set_error( fdi, FDIERROR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
2783 goto bail_and_fail;
2784 default:
2785 set_error( fdi, FDIERROR_CORRUPT_CABINET, 0 );
2786 goto bail_and_fail;
2787 }
2788 }
2789 }
2790
2791 if (fol) free_decompression_temps(fdi, fol, decomp_state);
2792 free_decompression_mem(fdi, decomp_state);
2793
2794 return TRUE;
2795
2796 bail_and_fail: /* here we free ram before error returns */
2797
2798 if (fol) free_decompression_temps(fdi, fol, decomp_state);
2799
2800 if (filehf) fdi->close(filehf);
2801
2802 free_decompression_mem(fdi, decomp_state);
2803
2804 return FALSE;
2805}
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
_S_IWRITE
#define _S_IWRITE
Definition: stat.h:85
_S_IREAD
#define _S_IREAD
Definition: stat.h:84
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
cab_UWORD
UINT16 cab_UWORD
Definition: mszip.h:26
cab_UBYTE
unsigned char cab_UBYTE
Definition: mszip.h:25
cffile_Attribs
#define cffile_Attribs
Definition: cabinet.h:74
cffoldCOMPTYPE_MSZIP
#define cffoldCOMPTYPE_MSZIP
Definition: cabinet.h:84
cffold_NumBlocks
#define cffold_NumBlocks
Definition: cabinet.h:66
cffile_Time
#define cffile_Time
Definition: cabinet.h:73
cffold_SIZEOF
#define cffold_SIZEOF
Definition: cabinet.h:68
cffile_SIZEOF
#define cffile_SIZEOF
Definition: cabinet.h:75
cffileCONTINUED_FROM_PREV
#define cffileCONTINUED_FROM_PREV
Definition: cabinet.h:90
cffile_A_EXEC
#define cffile_A_EXEC
Definition: cabinet.h:97
cffile_FolderOffset
#define cffile_FolderOffset
Definition: cabinet.h:70
cffile_FolderIndex
#define cffile_FolderIndex
Definition: cabinet.h:71
cffoldCOMPTYPE_LZX
#define cffoldCOMPTYPE_LZX
Definition: cabinet.h:86
cffoldCOMPTYPE_MASK
#define cffoldCOMPTYPE_MASK
Definition: cabinet.h:82
cffoldCOMPTYPE_QUANTUM
#define cffoldCOMPTYPE_QUANTUM
Definition: cabinet.h:85
cffile_Date
#define cffile_Date
Definition: cabinet.h:72
cffileCONTINUED_TO_NEXT
#define cffileCONTINUED_TO_NEXT
Definition: cabinet.h:91
cffile_UncompressedSize
#define cffile_UncompressedSize
Definition: cabinet.h:69
cab_off_t
UINT32 cab_off_t
Definition: cabinet.h:41
cffoldCOMPTYPE_NONE
#define cffoldCOMPTYPE_NONE
Definition: cabinet.h:83
cffold_DataOffset
#define cffold_DataOffset
Definition: cabinet.h:65
cffold_CompType
#define cffold_CompType
Definition: cabinet.h:67
FDI_read_string
static char * FDI_read_string(FDI_Int *fdi, INT_PTR hf, long cabsize)
Definition: fdi.c:476
LZXfdi_decomp
static int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
Definition: fdi.c:1606
get_fdi_ptr
static FDI_Int * get_fdi_ptr(HFDI hfdi)
Definition: fdi.c:195
set_error
static void set_error(FDI_Int *fdi, int oper, int err)
Definition: fdi.c:187
NONEfdi_decomp
static int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
Definition: fdi.c:852
DECR_USERABORT
#define DECR_USERABORT
Definition: fdi.c:185
FDI_read_entries
static BOOL FDI_read_entries(FDI_Int *fdi, INT_PTR hf, PFDICABINETINFO pfdici, PMORE_ISCAB_INFO pmii)
Definition: fdi.c:532
QTMfdi_init
static int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state)
Definition: fdi.c:739
free_decompression_temps
static void free_decompression_temps(FDI_Int *fdi, const struct fdi_folder *fol, fdi_decomp_state *decomp_state)
Definition: fdi.c:2206
EndGetI16
#define EndGetI16(a)
Definition: fdi.c:172
LZXfdi_init
static int LZXfdi_init(int window, fdi_decomp_state *decomp_state)
Definition: fdi.c:791
LZX
#define LZX(x)
Definition: fdi.c:177
CAB
#define CAB(x)
Definition: fdi.c:174
EndGetI32
#define EndGetI32(a)
Definition: fdi.c:171
DECR_OK
#define DECR_OK
Definition: fdi.c:178
ZIPfdi_decomp
static int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
Definition: fdi.c:1406
QTMfdi_decomp
static int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
Definition: fdi.c:1434
DECR_DATAFORMAT
#define DECR_DATAFORMAT
Definition: fdi.c:179
DECR_NOMEMORY
#define DECR_NOMEMORY
Definition: fdi.c:181
free_decompression_mem
static void free_decompression_mem(FDI_Int *fdi, fdi_decomp_state *decomp_state)
Definition: fdi.c:2225
fdi_decomp
static int fdi_decomp(const struct fdi_file *fi, int savemode, fdi_decomp_state *decomp_state, char *pszCabPath, PFNFDINOTIFY pfnfdin, void *pvUser)
Definition: fdi.c:1938
QTM
#define QTM(x)
Definition: fdi.c:176
SetLastError
#define SetLastError(x)
Definition: compat.h:752
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
_O_BINARY
#define _O_BINARY
Definition: fcntl.h:27
_O_RDONLY
#define _O_RDONLY
Definition: fcntl.h:13
SEEK_CUR
#define SEEK_CUR
Definition: stdio.h:44
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597
offset
GLintptr offset
Definition: glext.h:5920
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
flags
GLbitfield flags
Definition: glext.h:7161
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
if
if(dx< 0)
Definition: linetemp.h:194
ZeroMemory
#define ZeroMemory
Definition: minwinbase.h:31
current
struct task_struct * current
Definition: linux.c:32
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
window
static IHTMLWindow2 * window
Definition: events.c:77
err
#define err(...)
Definition: reactos_support_code.h:30
strcat
strcat
Definition: string.h:92
strcpy
strcpy
Definition: string.h:131
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
ERF::erfOper
int erfOper
Definition: fci.h:45
FDICABINETINFO::setID
USHORT setID
Definition: fdi.h:149
FDICABINETINFO::iCabinet
USHORT iCabinet
Definition: fdi.h:150
FDICABINETINFO::cFiles
USHORT cFiles
Definition: fdi.h:148
FDICABINETINFO::cFolders
USHORT cFolders
Definition: fdi.h:147
FDICABINETINFO::cbCabinet
LONG cbCabinet
Definition: fdi.h:146
FDINOTIFICATION::setID
USHORT setID
Definition: fdi.h:239
FDINOTIFICATION::iCabinet
USHORT iCabinet
Definition: fdi.h:240
FDINOTIFICATION::psz3
char * psz3
Definition: fdi.h:230
FDINOTIFICATION::psz2
char * psz2
Definition: fdi.h:229
FDINOTIFICATION::time
USHORT time
Definition: fdi.h:236
FDINOTIFICATION::pv
void * pv
Definition: fdi.h:231
FDINOTIFICATION::iFolder
USHORT iFolder
Definition: fdi.h:241
FDINOTIFICATION::hf
INT_PTR hf
Definition: fdi.h:233
FDINOTIFICATION::psz1
char * psz1
Definition: fdi.h:228
FDINOTIFICATION::date
USHORT date
Definition: fdi.h:235
FDINOTIFICATION::attribs
USHORT attribs
Definition: fdi.h:237
FDINOTIFICATION::cb
LONG cb
Definition: fdi.h:227
FDI_Int
Definition: mszip.h:30
FDI_Int::open
PFNOPEN open
Definition: fdi.c:118
FDI_Int::close
PFNCLOSE close
Definition: fdi.c:121
FDI_Int::perf
PERF perf
Definition: mszip.h:39
FDI_Int::free
PFNFREE free
Definition: fdi.c:117
FDI_Int::seek
PFNSEEK seek
Definition: fdi.c:122
FDI_Int::alloc
PFNALLOC alloc
Definition: fdi.c:116
FDI_Int::read
PFNREAD read
Definition: fdi.c:119
fdi_cds_fwd
Definition: mszip.h:100
fdi_file
Definition: fdi.c:78
fdi_folder
Definition: fdi.c:89
fdi_folder::comp_type
cab_UWORD comp_type
Definition: fdi.c:92
fdi_folder::next
struct fdi_folder * next
Definition: fdi.c:90
fdi_folder::num_blocks
cab_UWORD num_blocks
Definition: fdi.c:95
fdi_folder::offset
cab_off_t offset
Definition: fdi.c:91
file
Definition: fci.c:123
file::offset
cab_ULONG offset
Definition: fci.c:126
file::date
cab_UWORD date
Definition: fci.c:128
file::attribs
cab_UWORD attribs
Definition: fci.c:130
file::time
cab_UWORD time
Definition: fci.c:129

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

◆ FDICreate()

HFDI __cdecl FDICreate ( PFNALLOC  pfnalloc,
PFNFREE  pfnfree,
PFNOPEN  pfnopen,
PFNREAD  pfnread,
PFNWRITE  pfnwrite,
PFNCLOSE  pfnclose,
PFNSEEK  pfnseek,
int  cpuType,
PERF  perf 
)

Definition at line 412 of file fdi.c.

422{
423 FDI_Int *fdi;
424
425 TRACE("(pfnalloc == ^%p, pfnfree == ^%p, pfnopen == ^%p, pfnread == ^%p, pfnwrite == ^%p, "
426 "pfnclose == ^%p, pfnseek == ^%p, cpuType == %d, perf == ^%p)\n",
427 pfnalloc, pfnfree, pfnopen, pfnread, pfnwrite, pfnclose, pfnseek,
428 cpuType, perf);
429
430 if ((!pfnalloc) || (!pfnfree)) {
431 perf->erfOper = FDIERROR_NONE;
432 perf->erfType = ERROR_BAD_ARGUMENTS;
433 perf->fError = TRUE;
434
435 SetLastError(ERROR_BAD_ARGUMENTS);
436 return NULL;
437 }
438
439 if (!((fdi = pfnalloc(sizeof(FDI_Int))))) {
440 perf->erfOper = FDIERROR_ALLOC_FAIL;
441 perf->erfType = 0;
442 perf->fError = TRUE;
443 return NULL;
444 }
445
446 fdi->magic = FDI_INT_MAGIC;
447 fdi->alloc = pfnalloc;
448 fdi->free = pfnfree;
449 fdi->open = pfnopen;
450 fdi->read = pfnread;
451 fdi->write = pfnwrite;
452 fdi->close = pfnclose;
453 fdi->seek = pfnseek;
454 /* no-brainer: we ignore the cpu type; this is only used
455 for the 16-bit versions in Windows anyhow... */
456 fdi->perf = perf;
457
458 return (HFDI)fdi;
459}
FDI_INT_MAGIC
#define FDI_INT_MAGIC
Definition: fdi.c:126
ERF::erfType
int erfType
Definition: fci.h:46
ERF::fError
BOOL fError
Definition: fci.h:47
FDI_Int::write
PFNWRITE write
Definition: fdi.c:120
FDI_Int::magic
unsigned int magic
Definition: fdi.c:115
ERROR_BAD_ARGUMENTS
#define ERROR_BAD_ARGUMENTS
Definition: winerror.h:354

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

◆ FDIDestroy()

BOOL __cdecl FDIDestroy ( HFDI  hfdi)

Definition at line 2820 of file fdi.c.

2821{
2822 FDI_Int *fdi = get_fdi_ptr( hfdi );
2823
2824 TRACE("(hfdi == ^%p)\n", hfdi);
2825 if (!fdi) return FALSE;
2826 fdi->magic = 0; /* paranoia */
2827 fdi->free(fdi);
2828 return TRUE;
2829}

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

◆ FDIIsCabinet()

BOOL __cdecl FDIIsCabinet ( HFDI  hfdi,
INT_PTR  hf,
PFDICABINETINFO  pfdici 
)

Definition at line 696 of file fdi.c.

697{
698 BOOL rv;
699 FDI_Int *fdi = get_fdi_ptr( hfdi );
700
701 TRACE("(hfdi == ^%p, hf == ^%Id, pfdici == ^%p)\n", hfdi, hf, pfdici);
702
703 if (!fdi) return FALSE;
704
705 if (!pfdici) {
706 SetLastError(ERROR_BAD_ARGUMENTS);
707 return FALSE;
708 }
709 rv = FDI_read_entries(fdi, hf, pfdici, NULL);
710
711 if (rv)
712 pfdici->hasnext = FALSE; /* yuck. duplicate apparent cabinet.dll bug */
713
714 return rv;
715}
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
FDICABINETINFO::hasnext
BOOL hasnext
Definition: fdi.h:153

Referenced by ExtractCabinet(), test_FDICopy(), and test_FDIIsCabinet().

◆ FDITruncateCabinet()

BOOL __cdecl FDITruncateCabinet ( HFDI  hfdi,
char *  pszCabinetName,
USHORT  iFolderToDelete 
)

Definition at line 2850 of file fdi.c.

2854{
2855 FDI_Int *fdi = get_fdi_ptr( hfdi );
2856
2857 FIXME("(hfdi == ^%p, pszCabinetName == %s, iFolderToDelete == %hu): stub\n",
2858 hfdi, debugstr_a(pszCabinetName), iFolderToDelete);
2859
2860 if (!fdi) return FALSE;
2861
2862 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2863 return FALSE;
2864}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
ERROR_CALL_NOT_IMPLEMENTED
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102