2 * File Decompression Interface
4 * Copyright 2000-2002 Stuart Caie
5 * Copyright 2002 Patrik Stridvall
6 * Copyright 2003 Greg Turner
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 * This is a largely redundant reimplementation of the stuff in cabextract.c. It
24 * would be theoretically preferable to have only one, shared implementation, however
25 * there are semantic differences which may discourage efforts to unify the two. It
26 * should be possible, if awkward, to go back and reimplement cabextract.c using FDI.
27 * But this approach would be quite a bit less performant. Probably a better way
28 * would be to create a "library" of routines in cabextract.c which do the actual
29 * decompression, and have both fdi.c and cabextract share those routines. The rest
30 * of the code is not sufficiently similar to merit a shared implementation.
32 * The worst thing about this API is the bug. "The bug" is this: when you extract a
33 * cabinet, it /always/ informs you (via the hasnext field of PFDICABINETINFO), that
34 * there is no subsequent cabinet, even if there is one. wine faithfully reproduces
39 * Wine does not implement the AFAIK undocumented "enumerate" callback during
40 * FDICopy. It is implemented in Windows and therefore worth investigating...
42 * Lots of pointers flying around here... am I leaking RAM?
46 * Probably, I need to weed out some dead code-paths.
50 * The fdintNEXT_CABINET callbacks are probably not working quite as they should.
51 * There are several FIXMEs in the source describing some of the deficiencies in
52 * some detail. Additionally, we do not do a very good job of returning the right
53 * error codes to this callback.
55 * FDICopy and fdi_decomp are incomprehensibly large; separating these into smaller
56 * functions would be nice.
72 #include "wine/debug.h"
74 WINE_DEFAULT_DEBUG_CHANNEL(cabinet
);
79 struct fdi_file
*next
; /* next file in sequence */
80 LPSTR filename
; /* output name of file */
81 int fh
; /* open file handle or NULL */
82 cab_ULONG length
; /* uncompressed length of file */
83 cab_ULONG offset
; /* uncompressed offset in folder */
84 cab_UWORD index
; /* magic index number of folder */
85 cab_UWORD time
, date
, attribs
; /* MS-DOS time/date/attributes */
86 BOOL oppressed
; /* never to be processed */
90 struct fdi_folder
*next
;
91 cab_off_t offset
; /* offset to data blocks (32 bit) */
92 cab_UWORD comp_type
; /* compression format/window size */
93 cab_ULONG comp_size
; /* compressed size of folder */
94 cab_UBYTE num_splits
; /* number of split blocks + 1 */
95 cab_UWORD num_blocks
; /* total number of blocks */
99 * this structure fills the gaps between what is available in a PFDICABINETINFO
100 * vs what is needed by FDICopy. Memory allocated for these becomes the responsibility
101 * of the caller to free. Yes, I am aware that this is totally, utterly inelegant.
102 * To make things even more unnecessarily confusing, we now attach these to the
106 char *prevname
, *previnfo
;
107 char *nextname
, *nextinfo
;
108 BOOL hasnext
; /* bug free indicator */
109 int folder_resv
, header_resv
;
110 cab_UBYTE block_resv
;
111 } MORE_ISCAB_INFO
, *PMORE_ISCAB_INFO
;
126 #define FDI_INT_MAGIC 0xfdfdfd05
129 * ugh, well, this ended up being pretty damn silly...
130 * now that I've conceded to build equivalent structures to struct cab.*,
131 * I should have just used those, or, better yet, unified the two... sue me.
132 * (Note to Microsoft: That's a joke. Please /don't/ actually sue me! -gmt).
133 * Nevertheless, I've come this far, it works, so I'm not gonna change it
134 * for now. This implementation has significant semantic differences anyhow.
137 typedef struct fdi_cds_fwd
{
138 FDI_Int
*fdi
; /* the hfdi we are using */
139 INT_PTR filehf
, cabhf
; /* file handle we are using */
140 struct fdi_folder
*current
; /* current folder we're extracting from */
141 cab_ULONG offset
; /* uncompressed offset within folder */
142 cab_UBYTE
*outpos
; /* (high level) start of data to use up */
143 cab_UWORD outlen
; /* (high level) amount of data to use up */
144 int (*decompress
)(int, int, struct fdi_cds_fwd
*); /* chosen compress fn */
145 cab_UBYTE inbuf
[CAB_INPUTMAX
+2]; /* +2 for lzx bitbuffer overflows! */
146 cab_UBYTE outbuf
[CAB_BLOCKMAX
];
152 /* some temp variables for use during decompression */
153 cab_UBYTE q_length_base
[27], q_length_extra
[27], q_extra_bits
[42];
154 cab_ULONG q_position_base
[42];
155 cab_ULONG lzx_position_base
[51];
156 cab_UBYTE extra_bits
[51];
157 USHORT setID
; /* Cabinet set ID */
158 USHORT iCabinet
; /* Cabinet number in set (0 based) */
159 struct fdi_cds_fwd
*decomp_cab
;
161 struct fdi_folder
*firstfol
;
162 struct fdi_file
*firstfile
;
163 struct fdi_cds_fwd
*next
;
166 #define ZIPNEEDBITS(n) {while(k<(n)){cab_LONG c=*(ZIP(inpos)++);\
167 b|=((cab_ULONG)c)<<k;k+=8;}}
168 #define ZIPDUMPBITS(n) {b>>=(n);k-=(n);}
170 /* endian-neutral reading of little-endian data */
171 #define EndGetI32(a) ((((a)[3])<<24)|(((a)[2])<<16)|(((a)[1])<<8)|((a)[0]))
172 #define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
174 #define CAB(x) (decomp_state->x)
175 #define ZIP(x) (decomp_state->methods.zip.x)
176 #define QTM(x) (decomp_state->methods.qtm.x)
177 #define LZX(x) (decomp_state->methods.lzx.x)
179 #define DECR_DATAFORMAT (1)
180 #define DECR_ILLEGALDATA (2)
181 #define DECR_NOMEMORY (3)
182 #define DECR_CHECKSUM (4)
183 #define DECR_INPUT (5)
184 #define DECR_OUTPUT (6)
185 #define DECR_USERABORT (7)
187 static void set_error( FDI_Int
*fdi
, int oper
, int err
)
189 fdi
->perf
->erfOper
= oper
;
190 fdi
->perf
->erfType
= err
;
191 fdi
->perf
->fError
= TRUE
;
192 if (err
) SetLastError( err
);
195 static FDI_Int
*get_fdi_ptr( HFDI hfdi
)
197 FDI_Int
*fdi
= (FDI_Int
*)hfdi
;
199 if (!fdi
|| fdi
->magic
!= FDI_INT_MAGIC
)
201 SetLastError( ERROR_INVALID_HANDLE
);
207 /****************************************************************
208 * QTMupdatemodel (internal)
210 static void QTMupdatemodel(struct QTMmodel
*model
, int sym
) {
211 struct QTMmodelsym temp
;
214 for (i
= 0; i
< sym
; i
++) model
->syms
[i
].cumfreq
+= 8;
216 if (model
->syms
[0].cumfreq
> 3800) {
217 if (--model
->shiftsleft
) {
218 for (i
= model
->entries
- 1; i
>= 0; i
--) {
219 /* -1, not -2; the 0 entry saves this */
220 model
->syms
[i
].cumfreq
>>= 1;
221 if (model
->syms
[i
].cumfreq
<= model
->syms
[i
+1].cumfreq
) {
222 model
->syms
[i
].cumfreq
= model
->syms
[i
+1].cumfreq
+ 1;
227 model
->shiftsleft
= 50;
228 for (i
= 0; i
< model
->entries
; i
++) {
229 /* no -1, want to include the 0 entry */
230 /* this converts cumfreqs into frequencies, then shifts right */
231 model
->syms
[i
].cumfreq
-= model
->syms
[i
+1].cumfreq
;
232 model
->syms
[i
].cumfreq
++; /* avoid losing things entirely */
233 model
->syms
[i
].cumfreq
>>= 1;
236 /* now sort by frequencies, decreasing order -- this must be an
237 * inplace selection sort, or a sort with the same (in)stability
240 for (i
= 0; i
< model
->entries
- 1; i
++) {
241 for (j
= i
+ 1; j
< model
->entries
; j
++) {
242 if (model
->syms
[i
].cumfreq
< model
->syms
[j
].cumfreq
) {
243 temp
= model
->syms
[i
];
244 model
->syms
[i
] = model
->syms
[j
];
245 model
->syms
[j
] = temp
;
250 /* then convert frequencies back to cumfreq */
251 for (i
= model
->entries
- 1; i
>= 0; i
--) {
252 model
->syms
[i
].cumfreq
+= model
->syms
[i
+1].cumfreq
;
254 /* then update the other part of the table */
255 for (i
= 0; i
< model
->entries
; i
++) {
256 model
->tabloc
[model
->syms
[i
].sym
] = i
;
262 /*************************************************************************
263 * make_decode_table (internal)
265 * This function was coded by David Tritscher. It builds a fast huffman
266 * decoding table out of just a canonical huffman code lengths table.
269 * nsyms: total number of symbols in this huffman tree.
270 * nbits: any symbols with a code length of nbits or less can be decoded
271 * in one lookup of the table.
272 * length: A table to get code lengths from [0 to syms-1]
273 * table: The table to fill up with decoded symbols and pointers.
279 static int make_decode_table(cab_ULONG nsyms
, cab_ULONG nbits
,
280 const cab_UBYTE
*length
, cab_UWORD
*table
) {
281 register cab_UWORD sym
;
282 register cab_ULONG leaf
;
283 register cab_UBYTE bit_num
= 1;
285 cab_ULONG pos
= 0; /* the current position in the decode table */
286 cab_ULONG table_mask
= 1 << nbits
;
287 cab_ULONG bit_mask
= table_mask
>> 1; /* don't do 0 length codes */
288 cab_ULONG next_symbol
= bit_mask
; /* base of allocation for long codes */
290 /* fill entries for codes short enough for a direct mapping */
291 while (bit_num
<= nbits
) {
292 for (sym
= 0; sym
< nsyms
; sym
++) {
293 if (length
[sym
] == bit_num
) {
296 if((pos
+= bit_mask
) > table_mask
) return 1; /* table overrun */
298 /* fill all possible lookups of this symbol with the symbol itself */
300 while (fill
-- > 0) table
[leaf
++] = sym
;
307 /* if there are any codes longer than nbits */
308 if (pos
!= table_mask
) {
309 /* clear the remainder of the table */
310 for (sym
= pos
; sym
< table_mask
; sym
++) table
[sym
] = 0;
312 /* give ourselves room for codes to grow by up to 16 more bits */
317 while (bit_num
<= 16) {
318 for (sym
= 0; sym
< nsyms
; sym
++) {
319 if (length
[sym
] == bit_num
) {
321 for (fill
= 0; fill
< bit_num
- nbits
; fill
++) {
322 /* if this path hasn't been taken yet, 'allocate' two entries */
323 if (table
[leaf
] == 0) {
324 table
[(next_symbol
<< 1)] = 0;
325 table
[(next_symbol
<< 1) + 1] = 0;
326 table
[leaf
] = next_symbol
++;
328 /* follow the path and select either left or right for next bit */
329 leaf
= table
[leaf
] << 1;
330 if ((pos
>> (15-fill
)) & 1) leaf
++;
334 if ((pos
+= bit_mask
) > table_mask
) return 1; /* table overflow */
343 if (pos
== table_mask
) return 0;
345 /* either erroneous table, or all elements are 0 - let's find out. */
346 for (sym
= 0; sym
< nsyms
; sym
++) if (length
[sym
]) return 1;
350 /*************************************************************************
351 * checksum (internal)
353 static cab_ULONG
checksum(const cab_UBYTE
*data
, cab_UWORD bytes
, cab_ULONG csum
) {
357 for (len
= bytes
>> 2; len
--; data
+= 4) {
358 csum
^= ((data
[0]) | (data
[1]<<8) | (data
[2]<<16) | (data
[3]<<24));
362 case 3: ul
|= *data
++ << 16;
364 case 2: ul
|= *data
++ << 8;
373 /***********************************************************************
374 * FDICreate (CABINET.20)
376 * Provided with several callbacks (all of them are mandatory),
377 * returns a handle which can be used to perform operations
381 * pfnalloc [I] A pointer to a function which allocates ram. Uses
382 * the same interface as malloc.
383 * pfnfree [I] A pointer to a function which frees ram. Uses the
384 * same interface as free.
385 * pfnopen [I] A pointer to a function which opens a file. Uses
386 * the same interface as _open.
387 * pfnread [I] A pointer to a function which reads from a file into
388 * a caller-provided buffer. Uses the same interface
390 * pfnwrite [I] A pointer to a function which writes to a file from
391 * a caller-provided buffer. Uses the same interface
393 * pfnclose [I] A pointer to a function which closes a file handle.
394 * Uses the same interface as _close.
395 * pfnseek [I] A pointer to a function which seeks in a file.
396 * Uses the same interface as _lseek.
397 * cpuType [I] The type of CPU; ignored in wine (recommended value:
398 * cpuUNKNOWN, aka -1).
399 * perf [IO] A pointer to an ERF structure. When FDICreate
400 * returns an error condition, error information may
401 * be found here as well as from GetLastError.
404 * On success, returns an FDI handle of type HFDI.
405 * On failure, the NULL file handle is returned. Error
406 * info can be retrieved from perf.
412 HFDI __cdecl
FDICreate(
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
,
430 if ((!pfnalloc
) || (!pfnfree
)) {
431 perf
->erfOper
= FDIERROR_NONE
;
432 perf
->erfType
= ERROR_BAD_ARGUMENTS
;
435 SetLastError(ERROR_BAD_ARGUMENTS
);
439 if (!((fdi
= pfnalloc(sizeof(FDI_Int
))))) {
440 perf
->erfOper
= FDIERROR_ALLOC_FAIL
;
446 fdi
->magic
= FDI_INT_MAGIC
;
447 fdi
->alloc
= pfnalloc
;
451 fdi
->write
= pfnwrite
;
452 fdi
->close
= pfnclose
;
454 /* no-brainer: we ignore the cpu type; this is only used
455 for the 16-bit versions in Windows anyhow... */
461 /*******************************************************************
462 * FDI_getoffset (internal)
464 * returns the file pointer position of a file handle.
466 static LONG
FDI_getoffset(FDI_Int
*fdi
, INT_PTR hf
)
468 return fdi
->seek(hf
, 0, SEEK_CUR
);
471 /**********************************************************************
472 * FDI_read_string (internal)
474 * allocate and read an arbitrarily long string from the cabinet
476 static char *FDI_read_string(FDI_Int
*fdi
, INT_PTR hf
, long cabsize
)
479 base
= FDI_getoffset(fdi
, hf
),
480 maxlen
= cabsize
- base
;
483 cab_UBYTE
*buf
= NULL
;
485 TRACE("(fdi == %p, hf == %ld, cabsize == %ld)\n", fdi
, hf
, cabsize
);
488 if (len
> maxlen
) len
= maxlen
;
489 if (!(buf
= fdi
->alloc(len
))) break;
490 if (!fdi
->read(hf
, buf
, len
)) break;
492 /* search for a null terminator in what we've just read */
493 for (i
=0; i
< len
; i
++) {
494 if (!buf
[i
]) {ok
=TRUE
; break;}
499 ERR("cabinet is truncated\n");
502 /* The buffer is too small for the string. Reset the file to the point
503 * were we started, free the buffer and increase the size for the next try
505 fdi
->seek(hf
, base
, SEEK_SET
);
516 ERR("out of memory!\n");
520 /* otherwise, set the stream to just after the string and return */
521 fdi
->seek(hf
, base
+ strlen((char *)buf
) + 1, SEEK_SET
);
526 /******************************************************************
527 * FDI_read_entries (internal)
529 * process the cabinet header in the style of FDIIsCabinet, but
530 * without the sanity checks (and bug)
532 static BOOL
FDI_read_entries(
535 PFDICABINETINFO pfdici
,
536 PMORE_ISCAB_INFO pmii
)
538 int num_folders
, num_files
, header_resv
, folder_resv
= 0;
539 LONG base_offset
, cabsize
;
540 USHORT setid
, cabidx
, flags
;
541 cab_UBYTE buf
[64], block_resv
;
542 char *prevname
= NULL
, *previnfo
= NULL
, *nextname
= NULL
, *nextinfo
= NULL
;
544 TRACE("(fdi == ^%p, hf == %ld, pfdici == ^%p)\n", fdi
, hf
, pfdici
);
547 * FIXME: I just noticed that I am memorizing the initial file pointer
548 * offset and restoring it before reading in the rest of the header
549 * information in the cabinet. Perhaps that's correct -- that is, perhaps
550 * this API is supposed to support "streaming" cabinets which are embedded
551 * in other files, or cabinets which begin at file offsets other than zero.
552 * Otherwise, I should instead go to the absolute beginning of the file.
553 * (Either way, the semantics of wine's FDICopy require me to leave the
554 * file pointer where it is afterwards -- If Windows does not do so, we
555 * ought to duplicate the native behavior in the FDIIsCabinet API, not here.
557 * So, the answer lies in Windows; will native cabinet.dll recognize a
558 * cabinet "file" embedded in another file? Note that cabextract.c does
559 * support this, which implies that Microsoft's might. I haven't tried it
560 * yet so I don't know. ATM, most of wine's FDI cabinet routines (except
561 * this one) would not work in this way. To fix it, we could just make the
562 * various references to absolute file positions in the code relative to an
563 * initial "beginning" offset. Because the FDICopy API doesn't take a
564 * file-handle like this one, we would therein need to search through the
565 * file for the beginning of the cabinet (as we also do in cabextract.c).
566 * Note that this limits us to a maximum of one cabinet per. file: the first.
568 * So, in summary: either the code below is wrong, or the rest of fdi.c is
569 * wrong... I cannot imagine that both are correct ;) One of these flaws
570 * should be fixed after determining the behavior on Windows. We ought
571 * to check both FDIIsCabinet and FDICopy for the right behavior.
576 /* get basic offset & size info */
577 base_offset
= FDI_getoffset(fdi
, hf
);
579 if (fdi
->seek(hf
, 0, SEEK_END
) == -1) {
580 if (pmii
) set_error( fdi
, FDIERROR_NOT_A_CABINET
, 0 );
584 cabsize
= FDI_getoffset(fdi
, hf
);
586 if ((cabsize
== -1) || (base_offset
== -1) ||
587 ( fdi
->seek(hf
, base_offset
, SEEK_SET
) == -1 )) {
588 if (pmii
) set_error( fdi
, FDIERROR_NOT_A_CABINET
, 0 );
592 /* read in the CFHEADER */
593 if (fdi
->read(hf
, buf
, cfhead_SIZEOF
) != cfhead_SIZEOF
) {
594 if (pmii
) set_error( fdi
, FDIERROR_NOT_A_CABINET
, 0 );
598 /* check basic MSCF signature */
599 if (EndGetI32(buf
+cfhead_Signature
) != 0x4643534d) {
600 if (pmii
) set_error( fdi
, FDIERROR_NOT_A_CABINET
, 0 );
604 /* get the number of folders */
605 num_folders
= EndGetI16(buf
+cfhead_NumFolders
);
607 /* get the number of files */
608 num_files
= EndGetI16(buf
+cfhead_NumFiles
);
611 setid
= EndGetI16(buf
+cfhead_SetID
);
613 /* cabinet (set) index */
614 cabidx
= EndGetI16(buf
+cfhead_CabinetIndex
);
616 /* check the header revision */
617 if ((buf
[cfhead_MajorVersion
] > 1) ||
618 (buf
[cfhead_MajorVersion
] == 1 && buf
[cfhead_MinorVersion
] > 3))
620 WARN("cabinet format version > 1.3\n");
621 if (pmii
) set_error( fdi
, FDIERROR_UNKNOWN_CABINET_VERSION
, 0 /* ? */ );
625 /* pull the flags out */
626 flags
= EndGetI16(buf
+cfhead_Flags
);
628 /* read the reserved-sizes part of header, if present */
629 if (flags
& cfheadRESERVE_PRESENT
) {
630 if (fdi
->read(hf
, buf
, cfheadext_SIZEOF
) != cfheadext_SIZEOF
) {
631 ERR("bunk reserve-sizes?\n");
632 if (pmii
) set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 /* ? */ );
636 header_resv
= EndGetI16(buf
+cfheadext_HeaderReserved
);
637 if (pmii
) pmii
->header_resv
= header_resv
;
638 folder_resv
= buf
[cfheadext_FolderReserved
];
639 if (pmii
) pmii
->folder_resv
= folder_resv
;
640 block_resv
= buf
[cfheadext_DataReserved
];
641 if (pmii
) pmii
->block_resv
= block_resv
;
643 if (header_resv
> 60000) {
644 WARN("WARNING; header reserved space > 60000\n");
647 /* skip the reserved header */
648 if ((header_resv
) && (fdi
->seek(hf
, header_resv
, SEEK_CUR
) == -1)) {
649 ERR("seek failure: header_resv\n");
650 if (pmii
) set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 /* ? */ );
655 if (flags
& cfheadPREV_CABINET
) {
656 prevname
= FDI_read_string(fdi
, hf
, cabsize
);
658 if (pmii
) set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 /* ? */ );
662 pmii
->prevname
= prevname
;
665 previnfo
= FDI_read_string(fdi
, hf
, cabsize
);
668 pmii
->previnfo
= previnfo
;
674 if (flags
& cfheadNEXT_CABINET
) {
676 pmii
->hasnext
= TRUE
;
677 nextname
= FDI_read_string(fdi
, hf
, cabsize
);
679 if ((flags
& cfheadPREV_CABINET
) && pmii
) {
680 if (pmii
->prevname
) fdi
->free(prevname
);
681 if (pmii
->previnfo
) fdi
->free(previnfo
);
683 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 /* ? */ );
687 pmii
->nextname
= nextname
;
690 nextinfo
= FDI_read_string(fdi
, hf
, cabsize
);
693 pmii
->nextinfo
= nextinfo
;
699 /* we could process the whole cabinet searching for problems;
700 instead lets stop here. Now let's fill out the paperwork */
701 pfdici
->cbCabinet
= cabsize
;
702 pfdici
->cFolders
= num_folders
;
703 pfdici
->cFiles
= num_files
;
704 pfdici
->setID
= setid
;
705 pfdici
->iCabinet
= cabidx
;
706 pfdici
->fReserve
= (flags
& cfheadRESERVE_PRESENT
) != 0;
707 pfdici
->hasprev
= (flags
& cfheadPREV_CABINET
) != 0;
708 pfdici
->hasnext
= (flags
& cfheadNEXT_CABINET
) != 0;
712 /***********************************************************************
713 * FDIIsCabinet (CABINET.21)
715 * Informs the caller as to whether or not the provided file handle is
716 * really a cabinet or not, filling out the provided PFDICABINETINFO
717 * structure with information about the cabinet. Brief explanations of
718 * the elements of this structure are available as comments accompanying
719 * its definition in wine's include/fdi.h.
722 * hfdi [I] An HFDI from FDICreate
723 * hf [I] The file handle about which the caller inquires
724 * pfdici [IO] Pointer to a PFDICABINETINFO structure which will
725 * be filled out with information about the cabinet
726 * file indicated by hf if, indeed, it is determined
730 * TRUE if the file is a cabinet. The info pointed to by pfdici will
732 * FALSE if the file is not a cabinet, or if an error was encountered
733 * while processing the cabinet. The PERF structure provided to
734 * FDICreate can be queried for more error information.
739 BOOL __cdecl
FDIIsCabinet(HFDI hfdi
, INT_PTR hf
, PFDICABINETINFO pfdici
)
742 FDI_Int
*fdi
= get_fdi_ptr( hfdi
);
744 TRACE("(hfdi == ^%p, hf == ^%ld, pfdici == ^%p)\n", hfdi
, hf
, pfdici
);
746 if (!fdi
) return FALSE
;
749 SetLastError(ERROR_INVALID_HANDLE
);
754 SetLastError(ERROR_BAD_ARGUMENTS
);
757 rv
= FDI_read_entries(fdi
, hf
, pfdici
, NULL
);
760 pfdici
->hasnext
= FALSE
; /* yuck. duplicate apparent cabinet.dll bug */
765 /******************************************************************
766 * QTMfdi_initmodel (internal)
768 * Initialize a model which decodes symbols from [s] to [s]+[n]-1
770 static void QTMfdi_initmodel(struct QTMmodel
*m
, struct QTMmodelsym
*sym
, int n
, int s
) {
775 memset(m
->tabloc
, 0xFF, sizeof(m
->tabloc
)); /* clear out look-up table */
776 for (i
= 0; i
< n
; i
++) {
777 m
->tabloc
[i
+s
] = i
; /* set up a look-up entry for symbol */
778 m
->syms
[i
].sym
= i
+s
; /* actual symbol */
779 m
->syms
[i
].cumfreq
= n
-i
; /* current frequency of that symbol */
781 m
->syms
[n
].cumfreq
= 0;
784 /******************************************************************
785 * QTMfdi_init (internal)
787 static int QTMfdi_init(int window
, int level
, fdi_decomp_state
*decomp_state
) {
788 unsigned int wndsize
= 1 << window
;
789 int msz
= window
* 2, i
;
792 /* QTM supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */
793 /* if a previously allocated window is big enough, keep it */
794 if (window
< 10 || window
> 21) return DECR_DATAFORMAT
;
795 if (QTM(actual_size
) < wndsize
) {
796 if (QTM(window
)) CAB(fdi
)->free(QTM(window
));
800 if (!(QTM(window
) = CAB(fdi
)->alloc(wndsize
))) return DECR_NOMEMORY
;
801 QTM(actual_size
) = wndsize
;
803 QTM(window_size
) = wndsize
;
804 QTM(window_posn
) = 0;
806 /* initialize static slot/extrabits tables */
807 for (i
= 0, j
= 0; i
< 27; i
++) {
808 CAB(q_length_extra
)[i
] = (i
== 26) ? 0 : (i
< 2 ? 0 : i
- 2) >> 2;
809 CAB(q_length_base
)[i
] = j
; j
+= 1 << ((i
== 26) ? 5 : CAB(q_length_extra
)[i
]);
811 for (i
= 0, j
= 0; i
< 42; i
++) {
812 CAB(q_extra_bits
)[i
] = (i
< 2 ? 0 : i
-2) >> 1;
813 CAB(q_position_base
)[i
] = j
; j
+= 1 << CAB(q_extra_bits
)[i
];
816 /* initialize arithmetic coding models */
818 QTMfdi_initmodel(&QTM(model7
), QTM(m7sym
), 7, 0);
820 QTMfdi_initmodel(&QTM(model00
), QTM(m00sym
), 0x40, 0x00);
821 QTMfdi_initmodel(&QTM(model40
), QTM(m40sym
), 0x40, 0x40);
822 QTMfdi_initmodel(&QTM(model80
), QTM(m80sym
), 0x40, 0x80);
823 QTMfdi_initmodel(&QTM(modelC0
), QTM(mC0sym
), 0x40, 0xC0);
825 /* model 4 depends on table size, ranges from 20 to 24 */
826 QTMfdi_initmodel(&QTM(model4
), QTM(m4sym
), (msz
< 24) ? msz
: 24, 0);
827 /* model 5 depends on table size, ranges from 20 to 36 */
828 QTMfdi_initmodel(&QTM(model5
), QTM(m5sym
), (msz
< 36) ? msz
: 36, 0);
829 /* model 6pos depends on table size, ranges from 20 to 42 */
830 QTMfdi_initmodel(&QTM(model6pos
), QTM(m6psym
), msz
, 0);
831 QTMfdi_initmodel(&QTM(model6len
), QTM(m6lsym
), 27, 0);
836 /************************************************************
837 * LZXfdi_init (internal)
839 static int LZXfdi_init(int window
, fdi_decomp_state
*decomp_state
) {
840 static const cab_UBYTE bits
[] =
841 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
842 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14,
843 15, 15, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
845 static const cab_ULONG base
[] =
846 { 0, 1, 2, 3, 4, 6, 8, 12,
847 16, 24, 32, 48, 64, 96, 128, 192,
848 256, 384, 512, 768, 1024, 1536, 2048, 3072,
849 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152,
850 65536, 98304, 131072, 196608, 262144, 393216, 524288, 655360,
851 786432, 917504, 1048576, 1179648, 1310720, 1441792, 1572864, 1703936,
852 1835008, 1966080, 2097152};
853 cab_ULONG wndsize
= 1 << window
;
856 /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
857 /* if a previously allocated window is big enough, keep it */
858 if (window
< 15 || window
> 21) return DECR_DATAFORMAT
;
859 if (LZX(actual_size
) < wndsize
) {
860 if (LZX(window
)) CAB(fdi
)->free(LZX(window
));
864 if (!(LZX(window
) = CAB(fdi
)->alloc(wndsize
))) return DECR_NOMEMORY
;
865 LZX(actual_size
) = wndsize
;
867 LZX(window_size
) = wndsize
;
869 /* initialize static tables */
870 memcpy(CAB(extra_bits
), bits
, sizeof(bits
));
871 memcpy(CAB(lzx_position_base
), base
, sizeof(base
));
873 /* calculate required position slots */
874 if (window
== 20) posn_slots
= 42;
875 else if (window
== 21) posn_slots
= 50;
876 else posn_slots
= window
<< 1;
878 /*posn_slots=i=0; while (i < wndsize) i += 1 << CAB(extra_bits)[posn_slots++]; */
880 LZX(R0
) = LZX(R1
) = LZX(R2
) = 1;
881 LZX(main_elements
) = LZX_NUM_CHARS
+ (posn_slots
<< 3);
882 LZX(header_read
) = 0;
883 LZX(frames_read
) = 0;
884 LZX(block_remaining
) = 0;
885 LZX(block_type
) = LZX_BLOCKTYPE_INVALID
;
886 LZX(intel_curpos
) = 0;
887 LZX(intel_started
) = 0;
888 LZX(window_posn
) = 0;
890 /* initialize tables to 0 (because deltas will be applied to them) */
891 memset(LZX(MAINTREE_len
), 0, sizeof(LZX(MAINTREE_len
)));
892 memset(LZX(LENGTH_len
), 0, sizeof(LZX(LENGTH_len
)));
897 /****************************************************
898 * NONEfdi_decomp(internal)
900 static int NONEfdi_decomp(int inlen
, int outlen
, fdi_decomp_state
*decomp_state
)
902 if (inlen
!= outlen
) return DECR_ILLEGALDATA
;
903 if (outlen
> CAB_BLOCKMAX
) return DECR_DATAFORMAT
;
904 memcpy(CAB(outbuf
), CAB(inbuf
), (size_t) inlen
);
908 /********************************************************
909 * Ziphuft_free (internal)
911 static void fdi_Ziphuft_free(FDI_Int
*fdi
, struct Ziphuft
*t
)
913 register struct Ziphuft
*p
, *q
;
915 /* Go through linked list, freeing from the allocated (t[-1]) address. */
925 /*********************************************************
926 * fdi_Ziphuft_build (internal)
928 static cab_LONG
fdi_Ziphuft_build(cab_ULONG
*b
, cab_ULONG n
, cab_ULONG s
, const cab_UWORD
*d
, const cab_UWORD
*e
,
929 struct Ziphuft
**t
, cab_LONG
*m
, fdi_decomp_state
*decomp_state
)
931 cab_ULONG a
; /* counter for codes of length k */
932 cab_ULONG el
; /* length of EOB code (value 256) */
933 cab_ULONG f
; /* i repeats in table every f entries */
934 cab_LONG g
; /* maximum code length */
935 cab_LONG h
; /* table level */
936 register cab_ULONG i
; /* counter, current code */
937 register cab_ULONG j
; /* counter */
938 register cab_LONG k
; /* number of bits in current code */
939 cab_LONG
*l
; /* stack of bits per table */
940 register cab_ULONG
*p
; /* pointer into ZIP(c)[],ZIP(b)[],ZIP(v)[] */
941 register struct Ziphuft
*q
; /* points to current table */
942 struct Ziphuft r
; /* table entry for structure assignment */
943 register cab_LONG w
; /* bits before this table == (l * h) */
944 cab_ULONG
*xp
; /* pointer into x */
945 cab_LONG y
; /* number of dummy codes added */
946 cab_ULONG z
; /* number of entries in current table */
950 /* Generate counts for each bit length */
951 el
= n
> 256 ? b
[256] : ZIPBMAX
; /* set length of EOB code, if any */
953 for(i
= 0; i
< ZIPBMAX
+1; ++i
)
958 ZIP(c
)[*p
]++; p
++; /* assume all entries <= ZIPBMAX */
960 if (ZIP(c
)[0] == n
) /* null input--all zero length codes */
967 /* Find minimum and maximum length, bound *m by those */
968 for (j
= 1; j
<= ZIPBMAX
; j
++)
971 k
= j
; /* minimum code length */
972 if ((cab_ULONG
)*m
< j
)
974 for (i
= ZIPBMAX
; i
; i
--)
977 g
= i
; /* maximum code length */
978 if ((cab_ULONG
)*m
> i
)
981 /* Adjust last length count to fill out codes, if needed */
982 for (y
= 1 << j
; j
< i
; j
++, y
<<= 1)
983 if ((y
-= ZIP(c
)[j
]) < 0)
984 return 2; /* bad input: more codes than bits */
985 if ((y
-= ZIP(c
)[i
]) < 0)
989 /* Generate starting offsets LONGo the value table for each length */
991 p
= ZIP(c
) + 1; xp
= ZIP(x
) + 2;
993 { /* note that i == g from above */
997 /* Make a table of values in order of bit lengths */
1000 if ((j
= *p
++) != 0)
1001 ZIP(v
)[ZIP(x
)[j
]++] = i
;
1005 /* Generate the Huffman codes and for each, make the table entries */
1006 ZIP(x
)[0] = i
= 0; /* first Huffman code is zero */
1007 p
= ZIP(v
); /* grab values in bit order */
1008 h
= -1; /* no tables yet--level -1 */
1009 w
= l
[-1] = 0; /* no bits decoded yet */
1010 ZIP(u
)[0] = NULL
; /* just to keep compilers happy */
1011 q
= NULL
; /* ditto */
1014 /* go through the bit lengths (k already is bits in shortest code) */
1020 /* here i is the Huffman code of length k bits for value *p */
1021 /* make tables up to required level */
1022 while (k
> w
+ l
[h
])
1024 w
+= l
[h
++]; /* add bits already decoded */
1026 /* compute minimum size table less than or equal to *m bits */
1027 if ((z
= g
- w
) > (cab_ULONG
)*m
) /* upper limit */
1029 if ((f
= 1 << (j
= k
- w
)) > a
+ 1) /* try a k-w bit table */
1030 { /* too few codes for k-w bit table */
1031 f
-= a
+ 1; /* deduct codes from patterns left */
1033 while (++j
< z
) /* try smaller tables up to z bits */
1035 if ((f
<<= 1) <= *++xp
)
1036 break; /* enough codes to use up j bits */
1037 f
-= *xp
; /* else deduct codes from patterns */
1040 if ((cab_ULONG
)w
+ j
> el
&& (cab_ULONG
)w
< el
)
1041 j
= el
- w
; /* make EOB code end at table */
1042 z
= 1 << j
; /* table entries for j-bit table */
1043 l
[h
] = j
; /* set table size in stack */
1045 /* allocate and link in new table */
1046 if (!(q
= CAB(fdi
)->alloc((z
+ 1)*sizeof(struct Ziphuft
))))
1049 fdi_Ziphuft_free(CAB(fdi
), ZIP(u
)[0]);
1050 return 3; /* not enough memory */
1052 *t
= q
+ 1; /* link to list for Ziphuft_free() */
1053 *(t
= &(q
->v
.t
)) = NULL
;
1054 ZIP(u
)[h
] = ++q
; /* table starts after link */
1056 /* connect to last table, if there is one */
1059 ZIP(x
)[h
] = i
; /* save pattern for backing up */
1060 r
.b
= (cab_UBYTE
)l
[h
-1]; /* bits to dump before this table */
1061 r
.e
= (cab_UBYTE
)(16 + j
); /* bits in this table */
1062 r
.v
.t
= q
; /* pointer to this table */
1063 j
= (i
& ((1 << w
) - 1)) >> (w
- l
[h
-1]);
1064 ZIP(u
)[h
-1][j
] = r
; /* connect to last table */
1068 /* set up table entry in r */
1069 r
.b
= (cab_UBYTE
)(k
- w
);
1070 if (p
>= ZIP(v
) + n
)
1071 r
.e
= 99; /* out of values--invalid code */
1074 r
.e
= (cab_UBYTE
)(*p
< 256 ? 16 : 15); /* 256 is end-of-block code */
1075 r
.v
.n
= *p
++; /* simple code is just the value */
1079 r
.e
= (cab_UBYTE
)e
[*p
- s
]; /* non-simple--look up in lists */
1080 r
.v
.n
= d
[*p
++ - s
];
1083 /* fill code-like entries with r */
1085 for (j
= i
>> w
; j
< z
; j
+= f
)
1088 /* backwards increment the k-bit code i */
1089 for (j
= 1 << (k
- 1); i
& j
; j
>>= 1)
1093 /* backup over finished tables */
1094 while ((i
& ((1 << w
) - 1)) != ZIP(x
)[h
])
1095 w
-= l
[--h
]; /* don't need to update q */
1099 /* return actual size of base table */
1102 /* Return true (1) if we were given an incomplete table */
1103 return y
!= 0 && g
!= 1;
1106 /*********************************************************
1107 * fdi_Zipinflate_codes (internal)
1109 static cab_LONG
fdi_Zipinflate_codes(const struct Ziphuft
*tl
, const struct Ziphuft
*td
,
1110 cab_LONG bl
, cab_LONG bd
, fdi_decomp_state
*decomp_state
)
1112 register cab_ULONG e
; /* table entry flag/number of extra bits */
1113 cab_ULONG n
, d
; /* length and index for copy */
1114 cab_ULONG w
; /* current window position */
1115 const struct Ziphuft
*t
; /* pointer to table entry */
1116 cab_ULONG ml
, md
; /* masks for bl and bd bits */
1117 register cab_ULONG b
; /* bit buffer */
1118 register cab_ULONG k
; /* number of bits in bit buffer */
1120 /* make local copies of globals */
1121 b
= ZIP(bb
); /* initialize bit buffer */
1123 w
= ZIP(window_posn
); /* initialize window position */
1125 /* inflate the coded data */
1126 ml
= Zipmask
[bl
]; /* precompute masks for speed */
1131 ZIPNEEDBITS((cab_ULONG
)bl
)
1132 if((e
= (t
= tl
+ (b
& ml
))->e
) > 16)
1140 } while ((e
= (t
= t
->v
.t
+ (b
& Zipmask
[e
]))->e
) > 16);
1142 if (e
== 16) /* then it's a literal */
1143 CAB(outbuf
)[w
++] = (cab_UBYTE
)t
->v
.n
;
1144 else /* it's an EOB or a length */
1146 /* exit if end of block */
1150 /* get length of block to copy */
1152 n
= t
->v
.n
+ (b
& Zipmask
[e
]);
1155 /* decode distance of block to copy */
1156 ZIPNEEDBITS((cab_ULONG
)bd
)
1157 if ((e
= (t
= td
+ (b
& md
))->e
) > 16)
1164 } while ((e
= (t
= t
->v
.t
+ (b
& Zipmask
[e
]))->e
) > 16);
1167 d
= w
- t
->v
.n
- (b
& Zipmask
[e
]);
1172 e
= ZIPWSIZE
- max(d
, w
);
1177 CAB(outbuf
)[w
++] = CAB(outbuf
)[d
++];
1183 /* restore the globals from the locals */
1184 ZIP(window_posn
) = w
; /* restore global window pointer */
1185 ZIP(bb
) = b
; /* restore global bit buffer */
1192 /***********************************************************
1193 * Zipinflate_stored (internal)
1195 static cab_LONG
fdi_Zipinflate_stored(fdi_decomp_state
*decomp_state
)
1196 /* "decompress" an inflated type 0 (stored) block. */
1198 cab_ULONG n
; /* number of bytes in block */
1199 cab_ULONG w
; /* current window position */
1200 register cab_ULONG b
; /* bit buffer */
1201 register cab_ULONG k
; /* number of bits in bit buffer */
1203 /* make local copies of globals */
1204 b
= ZIP(bb
); /* initialize bit buffer */
1206 w
= ZIP(window_posn
); /* initialize window position */
1208 /* go to byte boundary */
1212 /* get the length and its complement */
1217 if (n
!= ((~b
) & 0xffff))
1218 return 1; /* error in compressed data */
1221 /* read and output the compressed data */
1225 CAB(outbuf
)[w
++] = (cab_UBYTE
)b
;
1229 /* restore the globals from the locals */
1230 ZIP(window_posn
) = w
; /* restore global window pointer */
1231 ZIP(bb
) = b
; /* restore global bit buffer */
1236 /******************************************************
1237 * fdi_Zipinflate_fixed (internal)
1239 static cab_LONG
fdi_Zipinflate_fixed(fdi_decomp_state
*decomp_state
)
1241 struct Ziphuft
*fixed_tl
;
1242 struct Ziphuft
*fixed_td
;
1243 cab_LONG fixed_bl
, fixed_bd
;
1244 cab_LONG i
; /* temporary variable */
1250 for(i
= 0; i
< 144; i
++)
1256 for(; i
< 288; i
++) /* make a complete, but wrong code set */
1259 if((i
= fdi_Ziphuft_build(l
, 288, 257, Zipcplens
, Zipcplext
, &fixed_tl
, &fixed_bl
, decomp_state
)))
1262 /* distance table */
1263 for(i
= 0; i
< 30; i
++) /* make an incomplete code set */
1266 if((i
= fdi_Ziphuft_build(l
, 30, 0, Zipcpdist
, Zipcpdext
, &fixed_td
, &fixed_bd
, decomp_state
)) > 1)
1268 fdi_Ziphuft_free(CAB(fdi
), fixed_tl
);
1272 /* decompress until an end-of-block code */
1273 i
= fdi_Zipinflate_codes(fixed_tl
, fixed_td
, fixed_bl
, fixed_bd
, decomp_state
);
1275 fdi_Ziphuft_free(CAB(fdi
), fixed_td
);
1276 fdi_Ziphuft_free(CAB(fdi
), fixed_tl
);
1280 /**************************************************************
1281 * fdi_Zipinflate_dynamic (internal)
1283 static cab_LONG
fdi_Zipinflate_dynamic(fdi_decomp_state
*decomp_state
)
1284 /* decompress an inflated type 2 (dynamic Huffman codes) block. */
1286 cab_LONG i
; /* temporary variables */
1289 cab_ULONG l
; /* last length */
1290 cab_ULONG m
; /* mask for bit lengths table */
1291 cab_ULONG n
; /* number of lengths to get */
1292 struct Ziphuft
*tl
; /* literal/length code table */
1293 struct Ziphuft
*td
; /* distance code table */
1294 cab_LONG bl
; /* lookup bits for tl */
1295 cab_LONG bd
; /* lookup bits for td */
1296 cab_ULONG nb
; /* number of bit length codes */
1297 cab_ULONG nl
; /* number of literal/length codes */
1298 cab_ULONG nd
; /* number of distance codes */
1299 register cab_ULONG b
; /* bit buffer */
1300 register cab_ULONG k
; /* number of bits in bit buffer */
1302 /* make local bit buffer */
1307 /* read in table lengths */
1309 nl
= 257 + (b
& 0x1f); /* number of literal/length codes */
1312 nd
= 1 + (b
& 0x1f); /* number of distance codes */
1315 nb
= 4 + (b
& 0xf); /* number of bit length codes */
1317 if(nl
> 288 || nd
> 32)
1318 return 1; /* bad lengths */
1320 /* read in bit-length-code lengths */
1321 for(j
= 0; j
< nb
; j
++)
1324 ll
[Zipborder
[j
]] = b
& 7;
1328 ll
[Zipborder
[j
]] = 0;
1330 /* build decoding table for trees--single level, 7 bit lookup */
1332 if((i
= fdi_Ziphuft_build(ll
, 19, 19, NULL
, NULL
, &tl
, &bl
, decomp_state
)) != 0)
1335 fdi_Ziphuft_free(CAB(fdi
), tl
);
1336 return i
; /* incomplete code set */
1339 /* read in literal and distance code lengths */
1343 while((cab_ULONG
)i
< n
)
1345 ZIPNEEDBITS((cab_ULONG
)bl
)
1346 j
= (td
= tl
+ (b
& m
))->b
;
1349 if (j
< 16) /* length of code in bits (0..15) */
1350 ll
[i
++] = l
= j
; /* save last length in l */
1351 else if (j
== 16) /* repeat last length 3 to 6 times */
1356 if((cab_ULONG
)i
+ j
> n
)
1361 else if (j
== 17) /* 3 to 10 zero length codes */
1366 if ((cab_ULONG
)i
+ j
> n
)
1372 else /* j == 18: 11 to 138 zero length codes */
1375 j
= 11 + (b
& 0x7f);
1377 if ((cab_ULONG
)i
+ j
> n
)
1385 /* free decoding table for trees */
1386 fdi_Ziphuft_free(CAB(fdi
), tl
);
1388 /* restore the global bit buffer */
1392 /* build the decoding tables for literal/length and distance codes */
1394 if((i
= fdi_Ziphuft_build(ll
, nl
, 257, Zipcplens
, Zipcplext
, &tl
, &bl
, decomp_state
)) != 0)
1397 fdi_Ziphuft_free(CAB(fdi
), tl
);
1398 return i
; /* incomplete code set */
1401 fdi_Ziphuft_build(ll
+ nl
, nd
, 0, Zipcpdist
, Zipcpdext
, &td
, &bd
, decomp_state
);
1403 /* decompress until an end-of-block code */
1404 if(fdi_Zipinflate_codes(tl
, td
, bl
, bd
, decomp_state
))
1407 /* free the decoding tables, return */
1408 fdi_Ziphuft_free(CAB(fdi
), tl
);
1409 fdi_Ziphuft_free(CAB(fdi
), td
);
1413 /*****************************************************
1414 * fdi_Zipinflate_block (internal)
1416 static cab_LONG
fdi_Zipinflate_block(cab_LONG
*e
, fdi_decomp_state
*decomp_state
) /* e == last block flag */
1417 { /* decompress an inflated block */
1418 cab_ULONG t
; /* block type */
1419 register cab_ULONG b
; /* bit buffer */
1420 register cab_ULONG k
; /* number of bits in bit buffer */
1422 /* make local bit buffer */
1426 /* read in last block bit */
1428 *e
= (cab_LONG
)b
& 1;
1431 /* read in block type */
1436 /* restore the global bit buffer */
1440 /* inflate that block type */
1442 return fdi_Zipinflate_dynamic(decomp_state
);
1444 return fdi_Zipinflate_stored(decomp_state
);
1446 return fdi_Zipinflate_fixed(decomp_state
);
1447 /* bad block type */
1451 /****************************************************
1452 * ZIPfdi_decomp(internal)
1454 static int ZIPfdi_decomp(int inlen
, int outlen
, fdi_decomp_state
*decomp_state
)
1456 cab_LONG e
; /* last block flag */
1458 TRACE("(inlen == %d, outlen == %d)\n", inlen
, outlen
);
1460 ZIP(inpos
) = CAB(inbuf
);
1461 ZIP(bb
) = ZIP(bk
) = ZIP(window_posn
) = 0;
1462 if(outlen
> ZIPWSIZE
)
1463 return DECR_DATAFORMAT
;
1465 /* CK = Chris Kirmse, official Microsoft purloiner */
1466 if(ZIP(inpos
)[0] != 0x43 || ZIP(inpos
)[1] != 0x4B)
1467 return DECR_ILLEGALDATA
;
1471 if(fdi_Zipinflate_block(&e
, decomp_state
))
1472 return DECR_ILLEGALDATA
;
1475 /* return success */
1479 /*******************************************************************
1480 * QTMfdi_decomp(internal)
1482 static int QTMfdi_decomp(int inlen
, int outlen
, fdi_decomp_state
*decomp_state
)
1484 cab_UBYTE
*inpos
= CAB(inbuf
);
1485 cab_UBYTE
*window
= QTM(window
);
1486 cab_UBYTE
*runsrc
, *rundest
;
1487 cab_ULONG window_posn
= QTM(window_posn
);
1488 cab_ULONG window_size
= QTM(window_size
);
1490 /* used by bitstream macros */
1491 register int bitsleft
, bitrun
, bitsneed
;
1492 register cab_ULONG bitbuf
;
1494 /* used by GET_SYMBOL */
1499 int extra
, togo
= outlen
, match_length
= 0, copy_length
;
1500 cab_UBYTE selector
, sym
;
1501 cab_ULONG match_offset
= 0;
1503 cab_UWORD H
= 0xFFFF, L
= 0, C
;
1505 TRACE("(inlen == %d, outlen == %d)\n", inlen
, outlen
);
1507 /* read initial value of C */
1511 /* apply 2^x-1 mask */
1512 window_posn
&= window_size
- 1;
1513 /* runs can't straddle the window wraparound */
1514 if ((window_posn
+ togo
) > window_size
) {
1515 TRACE("straddled run\n");
1516 return DECR_DATAFORMAT
;
1520 GET_SYMBOL(model7
, selector
);
1523 GET_SYMBOL(model00
, sym
); window
[window_posn
++] = sym
; togo
--;
1526 GET_SYMBOL(model40
, sym
); window
[window_posn
++] = sym
; togo
--;
1529 GET_SYMBOL(model80
, sym
); window
[window_posn
++] = sym
; togo
--;
1532 GET_SYMBOL(modelC0
, sym
); window
[window_posn
++] = sym
; togo
--;
1536 /* selector 4 = fixed length of 3 */
1537 GET_SYMBOL(model4
, sym
);
1538 Q_READ_BITS(extra
, CAB(q_extra_bits
)[sym
]);
1539 match_offset
= CAB(q_position_base
)[sym
] + extra
+ 1;
1544 /* selector 5 = fixed length of 4 */
1545 GET_SYMBOL(model5
, sym
);
1546 Q_READ_BITS(extra
, CAB(q_extra_bits
)[sym
]);
1547 match_offset
= CAB(q_position_base
)[sym
] + extra
+ 1;
1552 /* selector 6 = variable length */
1553 GET_SYMBOL(model6len
, sym
);
1554 Q_READ_BITS(extra
, CAB(q_length_extra
)[sym
]);
1555 match_length
= CAB(q_length_base
)[sym
] + extra
+ 5;
1556 GET_SYMBOL(model6pos
, sym
);
1557 Q_READ_BITS(extra
, CAB(q_extra_bits
)[sym
]);
1558 match_offset
= CAB(q_position_base
)[sym
] + extra
+ 1;
1562 TRACE("Selector is bogus\n");
1563 return DECR_ILLEGALDATA
;
1566 /* if this is a match */
1567 if (selector
>= 4) {
1568 rundest
= window
+ window_posn
;
1569 togo
-= match_length
;
1571 /* copy any wrapped around source data */
1572 if (window_posn
>= match_offset
) {
1574 runsrc
= rundest
- match_offset
;
1576 runsrc
= rundest
+ (window_size
- match_offset
);
1577 copy_length
= match_offset
- window_posn
;
1578 if (copy_length
< match_length
) {
1579 match_length
-= copy_length
;
1580 window_posn
+= copy_length
;
1581 while (copy_length
-- > 0) *rundest
++ = *runsrc
++;
1585 window_posn
+= match_length
;
1587 /* copy match data - no worries about destination wraps */
1588 while (match_length
-- > 0) *rundest
++ = *runsrc
++;
1590 } /* while (togo > 0) */
1593 TRACE("Frame overflow, this_run = %d\n", togo
);
1594 return DECR_ILLEGALDATA
;
1597 memcpy(CAB(outbuf
), window
+ ((!window_posn
) ? window_size
: window_posn
) -
1600 QTM(window_posn
) = window_posn
;
1604 /************************************************************
1605 * fdi_lzx_read_lens (internal)
1607 static int fdi_lzx_read_lens(cab_UBYTE
*lens
, cab_ULONG first
, cab_ULONG last
, struct lzx_bits
*lb
,
1608 fdi_decomp_state
*decomp_state
) {
1612 register cab_ULONG bitbuf
= lb
->bb
;
1613 register int bitsleft
= lb
->bl
;
1614 cab_UBYTE
*inpos
= lb
->ip
;
1617 for (x
= 0; x
< 20; x
++) {
1619 LENTABLE(PRETREE
)[x
] = y
;
1621 BUILD_TABLE(PRETREE
);
1623 for (x
= first
; x
< last
; ) {
1624 READ_HUFFSYM(PRETREE
, z
);
1626 READ_BITS(y
, 4); y
+= 4;
1627 while (y
--) lens
[x
++] = 0;
1630 READ_BITS(y
, 5); y
+= 20;
1631 while (y
--) lens
[x
++] = 0;
1634 READ_BITS(y
, 1); y
+= 4;
1635 READ_HUFFSYM(PRETREE
, z
);
1636 z
= lens
[x
] - z
; if (z
< 0) z
+= 17;
1637 while (y
--) lens
[x
++] = z
;
1640 z
= lens
[x
] - z
; if (z
< 0) z
+= 17;
1651 /*******************************************************
1652 * LZXfdi_decomp(internal)
1654 static int LZXfdi_decomp(int inlen
, int outlen
, fdi_decomp_state
*decomp_state
) {
1655 cab_UBYTE
*inpos
= CAB(inbuf
);
1656 const cab_UBYTE
*endinp
= inpos
+ inlen
;
1657 cab_UBYTE
*window
= LZX(window
);
1658 cab_UBYTE
*runsrc
, *rundest
;
1659 cab_UWORD
*hufftbl
; /* used in READ_HUFFSYM macro as chosen decoding table */
1661 cab_ULONG window_posn
= LZX(window_posn
);
1662 cab_ULONG window_size
= LZX(window_size
);
1663 cab_ULONG R0
= LZX(R0
);
1664 cab_ULONG R1
= LZX(R1
);
1665 cab_ULONG R2
= LZX(R2
);
1667 register cab_ULONG bitbuf
;
1668 register int bitsleft
;
1669 cab_ULONG match_offset
, i
,j
,k
; /* ijk used in READ_HUFFSYM macro */
1670 struct lzx_bits lb
; /* used in READ_LENGTHS macro */
1672 int togo
= outlen
, this_run
, main_element
, aligned_bits
;
1673 int match_length
, copy_length
, length_footer
, extra
, verbatim_bits
;
1675 TRACE("(inlen == %d, outlen == %d)\n", inlen
, outlen
);
1679 /* read header if necessary */
1680 if (!LZX(header_read
)) {
1682 READ_BITS(k
, 1); if (k
) { READ_BITS(i
,16); READ_BITS(j
,16); }
1683 LZX(intel_filesize
) = (i
<< 16) | j
; /* or 0 if not encoded */
1684 LZX(header_read
) = 1;
1687 /* main decoding loop */
1689 /* last block finished, new block expected */
1690 if (LZX(block_remaining
) == 0) {
1691 if (LZX(block_type
) == LZX_BLOCKTYPE_UNCOMPRESSED
) {
1692 if (LZX(block_length
) & 1) inpos
++; /* realign bitstream to word */
1696 READ_BITS(LZX(block_type
), 3);
1699 LZX(block_remaining
) = LZX(block_length
) = (i
<< 8) | j
;
1701 switch (LZX(block_type
)) {
1702 case LZX_BLOCKTYPE_ALIGNED
:
1703 for (i
= 0; i
< 8; i
++) { READ_BITS(j
, 3); LENTABLE(ALIGNED
)[i
] = j
; }
1704 BUILD_TABLE(ALIGNED
);
1705 /* rest of aligned header is same as verbatim */
1707 case LZX_BLOCKTYPE_VERBATIM
:
1708 READ_LENGTHS(MAINTREE
, 0, 256, fdi_lzx_read_lens
);
1709 READ_LENGTHS(MAINTREE
, 256, LZX(main_elements
), fdi_lzx_read_lens
);
1710 BUILD_TABLE(MAINTREE
);
1711 if (LENTABLE(MAINTREE
)[0xE8] != 0) LZX(intel_started
) = 1;
1713 READ_LENGTHS(LENGTH
, 0, LZX_NUM_SECONDARY_LENGTHS
, fdi_lzx_read_lens
);
1714 BUILD_TABLE(LENGTH
);
1717 case LZX_BLOCKTYPE_UNCOMPRESSED
:
1718 LZX(intel_started
) = 1; /* because we can't assume otherwise */
1719 ENSURE_BITS(16); /* get up to 16 pad bits into the buffer */
1720 if (bitsleft
> 16) inpos
-= 2; /* and align the bitstream! */
1721 R0
= inpos
[0]|(inpos
[1]<<8)|(inpos
[2]<<16)|(inpos
[3]<<24);inpos
+=4;
1722 R1
= inpos
[0]|(inpos
[1]<<8)|(inpos
[2]<<16)|(inpos
[3]<<24);inpos
+=4;
1723 R2
= inpos
[0]|(inpos
[1]<<8)|(inpos
[2]<<16)|(inpos
[3]<<24);inpos
+=4;
1727 return DECR_ILLEGALDATA
;
1731 /* buffer exhaustion check */
1732 if (inpos
> endinp
) {
1733 /* it's possible to have a file where the next run is less than
1734 * 16 bits in size. In this case, the READ_HUFFSYM() macro used
1735 * in building the tables will exhaust the buffer, so we should
1736 * allow for this, but not allow those accidentally read bits to
1737 * be used (so we check that there are at least 16 bits
1738 * remaining - in this boundary case they aren't really part of
1739 * the compressed data)
1741 if (inpos
> (endinp
+2) || bitsleft
< 16) return DECR_ILLEGALDATA
;
1744 while ((this_run
= LZX(block_remaining
)) > 0 && togo
> 0) {
1745 if (this_run
> togo
) this_run
= togo
;
1747 LZX(block_remaining
) -= this_run
;
1749 /* apply 2^x-1 mask */
1750 window_posn
&= window_size
- 1;
1751 /* runs can't straddle the window wraparound */
1752 if ((window_posn
+ this_run
) > window_size
)
1753 return DECR_DATAFORMAT
;
1755 switch (LZX(block_type
)) {
1757 case LZX_BLOCKTYPE_VERBATIM
:
1758 while (this_run
> 0) {
1759 READ_HUFFSYM(MAINTREE
, main_element
);
1761 if (main_element
< LZX_NUM_CHARS
) {
1762 /* literal: 0 to LZX_NUM_CHARS-1 */
1763 window
[window_posn
++] = main_element
;
1767 /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
1768 main_element
-= LZX_NUM_CHARS
;
1770 match_length
= main_element
& LZX_NUM_PRIMARY_LENGTHS
;
1771 if (match_length
== LZX_NUM_PRIMARY_LENGTHS
) {
1772 READ_HUFFSYM(LENGTH
, length_footer
);
1773 match_length
+= length_footer
;
1775 match_length
+= LZX_MIN_MATCH
;
1777 match_offset
= main_element
>> 3;
1779 if (match_offset
> 2) {
1780 /* not repeated offset */
1781 if (match_offset
!= 3) {
1782 extra
= CAB(extra_bits
)[match_offset
];
1783 READ_BITS(verbatim_bits
, extra
);
1784 match_offset
= CAB(lzx_position_base
)[match_offset
]
1785 - 2 + verbatim_bits
;
1791 /* update repeated offset LRU queue */
1792 R2
= R1
; R1
= R0
; R0
= match_offset
;
1794 else if (match_offset
== 0) {
1797 else if (match_offset
== 1) {
1799 R1
= R0
; R0
= match_offset
;
1801 else /* match_offset == 2 */ {
1803 R2
= R0
; R0
= match_offset
;
1806 rundest
= window
+ window_posn
;
1807 this_run
-= match_length
;
1809 /* copy any wrapped around source data */
1810 if (window_posn
>= match_offset
) {
1812 runsrc
= rundest
- match_offset
;
1814 runsrc
= rundest
+ (window_size
- match_offset
);
1815 copy_length
= match_offset
- window_posn
;
1816 if (copy_length
< match_length
) {
1817 match_length
-= copy_length
;
1818 window_posn
+= copy_length
;
1819 while (copy_length
-- > 0) *rundest
++ = *runsrc
++;
1823 window_posn
+= match_length
;
1825 /* copy match data - no worries about destination wraps */
1826 while (match_length
-- > 0) *rundest
++ = *runsrc
++;
1831 case LZX_BLOCKTYPE_ALIGNED
:
1832 while (this_run
> 0) {
1833 READ_HUFFSYM(MAINTREE
, main_element
);
1835 if (main_element
< LZX_NUM_CHARS
) {
1836 /* literal: 0 to LZX_NUM_CHARS-1 */
1837 window
[window_posn
++] = main_element
;
1841 /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
1842 main_element
-= LZX_NUM_CHARS
;
1844 match_length
= main_element
& LZX_NUM_PRIMARY_LENGTHS
;
1845 if (match_length
== LZX_NUM_PRIMARY_LENGTHS
) {
1846 READ_HUFFSYM(LENGTH
, length_footer
);
1847 match_length
+= length_footer
;
1849 match_length
+= LZX_MIN_MATCH
;
1851 match_offset
= main_element
>> 3;
1853 if (match_offset
> 2) {
1854 /* not repeated offset */
1855 extra
= CAB(extra_bits
)[match_offset
];
1856 match_offset
= CAB(lzx_position_base
)[match_offset
] - 2;
1858 /* verbatim and aligned bits */
1860 READ_BITS(verbatim_bits
, extra
);
1861 match_offset
+= (verbatim_bits
<< 3);
1862 READ_HUFFSYM(ALIGNED
, aligned_bits
);
1863 match_offset
+= aligned_bits
;
1865 else if (extra
== 3) {
1866 /* aligned bits only */
1867 READ_HUFFSYM(ALIGNED
, aligned_bits
);
1868 match_offset
+= aligned_bits
;
1870 else if (extra
> 0) { /* extra==1, extra==2 */
1871 /* verbatim bits only */
1872 READ_BITS(verbatim_bits
, extra
);
1873 match_offset
+= verbatim_bits
;
1875 else /* extra == 0 */ {
1880 /* update repeated offset LRU queue */
1881 R2
= R1
; R1
= R0
; R0
= match_offset
;
1883 else if (match_offset
== 0) {
1886 else if (match_offset
== 1) {
1888 R1
= R0
; R0
= match_offset
;
1890 else /* match_offset == 2 */ {
1892 R2
= R0
; R0
= match_offset
;
1895 rundest
= window
+ window_posn
;
1896 this_run
-= match_length
;
1898 /* copy any wrapped around source data */
1899 if (window_posn
>= match_offset
) {
1901 runsrc
= rundest
- match_offset
;
1903 runsrc
= rundest
+ (window_size
- match_offset
);
1904 copy_length
= match_offset
- window_posn
;
1905 if (copy_length
< match_length
) {
1906 match_length
-= copy_length
;
1907 window_posn
+= copy_length
;
1908 while (copy_length
-- > 0) *rundest
++ = *runsrc
++;
1912 window_posn
+= match_length
;
1914 /* copy match data - no worries about destination wraps */
1915 while (match_length
-- > 0) *rundest
++ = *runsrc
++;
1920 case LZX_BLOCKTYPE_UNCOMPRESSED
:
1921 if ((inpos
+ this_run
) > endinp
) return DECR_ILLEGALDATA
;
1922 memcpy(window
+ window_posn
, inpos
, (size_t) this_run
);
1923 inpos
+= this_run
; window_posn
+= this_run
;
1927 return DECR_ILLEGALDATA
; /* might as well */
1933 if (togo
!= 0) return DECR_ILLEGALDATA
;
1934 memcpy(CAB(outbuf
), window
+ ((!window_posn
) ? window_size
: window_posn
) -
1935 outlen
, (size_t) outlen
);
1937 LZX(window_posn
) = window_posn
;
1942 /* intel E8 decoding */
1943 if ((LZX(frames_read
)++ < 32768) && LZX(intel_filesize
) != 0) {
1944 if (outlen
<= 6 || !LZX(intel_started
)) {
1945 LZX(intel_curpos
) += outlen
;
1948 cab_UBYTE
*data
= CAB(outbuf
);
1949 cab_UBYTE
*dataend
= data
+ outlen
- 10;
1950 cab_LONG curpos
= LZX(intel_curpos
);
1951 cab_LONG filesize
= LZX(intel_filesize
);
1952 cab_LONG abs_off
, rel_off
;
1954 LZX(intel_curpos
) = curpos
+ outlen
;
1956 while (data
< dataend
) {
1957 if (*data
++ != 0xE8) { curpos
++; continue; }
1958 abs_off
= data
[0] | (data
[1]<<8) | (data
[2]<<16) | (data
[3]<<24);
1959 if ((abs_off
>= -curpos
) && (abs_off
< filesize
)) {
1960 rel_off
= (abs_off
>= 0) ? abs_off
- curpos
: abs_off
+ filesize
;
1961 data
[0] = (cab_UBYTE
) rel_off
;
1962 data
[1] = (cab_UBYTE
) (rel_off
>> 8);
1963 data
[2] = (cab_UBYTE
) (rel_off
>> 16);
1964 data
[3] = (cab_UBYTE
) (rel_off
>> 24);
1974 /**********************************************************
1975 * fdi_decomp (internal)
1977 * Decompress the requested number of bytes. If savemode is zero,
1978 * do not save the output anywhere, just plow through blocks until we
1979 * reach the specified (uncompressed) distance from the starting point,
1980 * and remember the position of the cabfile pointer (and which cabfile)
1981 * after we are done; otherwise, save the data out to CAB(filehf),
1982 * decompressing the requested number of bytes and writing them out. This
1983 * is also where we jump to additional cabinets in the case of split
1984 * cab's, and provide (some of) the NEXT_CABINET notification semantics.
1986 static int fdi_decomp(const struct fdi_file
*fi
, int savemode
, fdi_decomp_state
*decomp_state
,
1987 char *pszCabPath
, PFNFDINOTIFY pfnfdin
, void *pvUser
)
1989 cab_ULONG bytes
= savemode
? fi
->length
: fi
->offset
- CAB(offset
);
1990 cab_UBYTE buf
[cfdata_SIZEOF
], *data
;
1991 cab_UWORD inlen
, len
, outlen
, cando
;
1994 fdi_decomp_state
*cab
= (savemode
&& CAB(decomp_cab
)) ? CAB(decomp_cab
) : decomp_state
;
1996 TRACE("(fi == ^%p, savemode == %d, bytes == %d)\n", fi
, savemode
, bytes
);
1999 /* cando = the max number of bytes we can do */
2000 cando
= CAB(outlen
);
2001 if (cando
> bytes
) cando
= bytes
;
2004 if (cando
&& savemode
)
2005 CAB(fdi
)->write(CAB(filehf
), CAB(outpos
), cando
);
2007 CAB(outpos
) += cando
;
2008 CAB(outlen
) -= cando
;
2009 bytes
-= cando
; if (!bytes
) break;
2011 /* we only get here if we emptied the output buffer */
2013 /* read data header + data */
2015 while (outlen
== 0) {
2016 /* read the block header, skip the reserved part */
2017 if (CAB(fdi
)->read(cab
->cabhf
, buf
, cfdata_SIZEOF
) != cfdata_SIZEOF
)
2020 if (CAB(fdi
)->seek(cab
->cabhf
, cab
->mii
.block_resv
, SEEK_CUR
) == -1)
2023 /* we shouldn't get blocks over CAB_INPUTMAX in size */
2024 data
= CAB(inbuf
) + inlen
;
2025 len
= EndGetI16(buf
+cfdata_CompressedSize
);
2027 if (inlen
> CAB_INPUTMAX
) return DECR_INPUT
;
2028 if (CAB(fdi
)->read(cab
->cabhf
, data
, len
) != len
)
2031 /* clear two bytes after read-in data */
2032 data
[len
+1] = data
[len
+2] = 0;
2034 /* perform checksum test on the block (if one is stored) */
2035 cksum
= EndGetI32(buf
+cfdata_CheckSum
);
2036 if (cksum
&& cksum
!= checksum(buf
+4, 4, checksum(data
, len
, 0)))
2037 return DECR_CHECKSUM
; /* checksum is wrong */
2039 outlen
= EndGetI16(buf
+cfdata_UncompressedSize
);
2041 /* outlen=0 means this block was the last contiguous part
2042 of a split block, continued in the next cabinet */
2044 int pathlen
, filenamelen
;
2046 char fullpath
[MAX_PATH
], userpath
[256];
2047 FDINOTIFICATION fdin
;
2048 FDICABINETINFO fdici
;
2049 char emptystring
= '\0';
2051 int success
= FALSE
;
2052 struct fdi_folder
*fol
= NULL
, *linkfol
= NULL
;
2053 struct fdi_file
*file
= NULL
, *linkfile
= NULL
;
2057 /* set up the next decomp_state... */
2061 if (!cab
->mii
.hasnext
) return DECR_INPUT
;
2063 if (!((cab
->next
= CAB(fdi
)->alloc(sizeof(fdi_decomp_state
)))))
2064 return DECR_NOMEMORY
;
2066 ZeroMemory(cab
->next
, sizeof(fdi_decomp_state
));
2068 /* copy pszCabPath to userpath */
2069 ZeroMemory(userpath
, 256);
2070 pathlen
= pszCabPath
? strlen(pszCabPath
) : 0;
2072 if (pathlen
< 256) /* else we are in a weird place... let's leave it blank and see if the user fixes it */
2073 strcpy(userpath
, pszCabPath
);
2076 /* initial fdintNEXT_CABINET notification */
2077 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2078 fdin
.psz1
= cab
->mii
.nextname
? cab
->mii
.nextname
: &emptystring
;
2079 fdin
.psz2
= cab
->mii
.nextinfo
? cab
->mii
.nextinfo
: &emptystring
;
2080 fdin
.psz3
= userpath
;
2081 fdin
.fdie
= FDIERROR_NONE
;
2084 if (((*pfnfdin
)(fdintNEXT_CABINET
, &fdin
))) return DECR_USERABORT
;
2088 pathlen
= strlen(userpath
);
2089 filenamelen
= cab
->mii
.nextname
? strlen(cab
->mii
.nextname
) : 0;
2091 /* slight overestimation here to save CPU cycles in the developer's brain */
2092 if ((pathlen
+ filenamelen
+ 3) > MAX_PATH
) {
2093 ERR("MAX_PATH exceeded.\n");
2094 return DECR_ILLEGALDATA
;
2097 /* paste the path and filename together */
2100 strcpy(fullpath
, userpath
);
2101 if (fullpath
[pathlen
- 1] != '\\')
2102 strcat(fullpath
, "\\");
2105 strcat(fullpath
, cab
->mii
.nextname
);
2107 TRACE("full cab path/file name: %s\n", debugstr_a(fullpath
));
2109 /* try to get a handle to the cabfile */
2110 cabhf
= CAB(fdi
)->open(fullpath
, _O_RDONLY
|_O_BINARY
, _S_IREAD
| _S_IWRITE
);
2112 /* no file. allow the user to try again */
2113 fdin
.fdie
= FDIERROR_CABINET_NOT_FOUND
;
2114 if (((*pfnfdin
)(fdintNEXT_CABINET
, &fdin
))) return DECR_USERABORT
;
2119 ERR("PFDI_OPEN returned zero for %s.\n", fullpath
);
2120 fdin
.fdie
= FDIERROR_CABINET_NOT_FOUND
;
2121 if (((*pfnfdin
)(fdintNEXT_CABINET
, &fdin
))) return DECR_USERABORT
;
2125 /* check if it's really a cabfile. Note that this doesn't implement the bug */
2126 if (!FDI_read_entries(CAB(fdi
), cabhf
, &fdici
, &(cab
->next
->mii
))) {
2127 WARN("FDIIsCabinet failed.\n");
2128 CAB(fdi
)->close(cabhf
);
2129 fdin
.fdie
= FDIERROR_NOT_A_CABINET
;
2130 if (((*pfnfdin
)(fdintNEXT_CABINET
, &fdin
))) return DECR_USERABORT
;
2134 if ((fdici
.setID
!= cab
->setID
) || (fdici
.iCabinet
!= (cab
->iCabinet
+ 1))) {
2135 WARN("Wrong Cabinet.\n");
2136 CAB(fdi
)->close(cabhf
);
2137 fdin
.fdie
= FDIERROR_WRONG_CABINET
;
2138 if (((*pfnfdin
)(fdintNEXT_CABINET
, &fdin
))) return DECR_USERABORT
;
2146 /* cabinet notification */
2147 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2148 fdin
.setID
= fdici
.setID
;
2149 fdin
.iCabinet
= fdici
.iCabinet
;
2151 fdin
.psz1
= (cab
->next
->mii
.nextname
) ? cab
->next
->mii
.nextname
: &emptystring
;
2152 fdin
.psz2
= (cab
->next
->mii
.nextinfo
) ? cab
->next
->mii
.nextinfo
: &emptystring
;
2153 fdin
.psz3
= pszCabPath
;
2155 if (((*pfnfdin
)(fdintCABINET_INFO
, &fdin
))) return DECR_USERABORT
;
2157 cab
->next
->setID
= fdici
.setID
;
2158 cab
->next
->iCabinet
= fdici
.iCabinet
;
2159 cab
->next
->fdi
= CAB(fdi
);
2160 cab
->next
->filehf
= CAB(filehf
);
2161 cab
->next
->cabhf
= cabhf
;
2162 cab
->next
->decompress
= CAB(decompress
); /* crude, but unused anyhow */
2164 cab
= cab
->next
; /* advance to the next cabinet */
2167 for (i
= 0; i
< fdici
.cFolders
; i
++) {
2168 if (CAB(fdi
)->read(cab
->cabhf
, buf2
, cffold_SIZEOF
) != cffold_SIZEOF
)
2171 if (cab
->mii
.folder_resv
> 0)
2172 CAB(fdi
)->seek(cab
->cabhf
, cab
->mii
.folder_resv
, SEEK_CUR
);
2174 fol
= CAB(fdi
)->alloc(sizeof(struct fdi_folder
));
2176 ERR("out of memory!\n");
2177 return DECR_NOMEMORY
;
2179 ZeroMemory(fol
, sizeof(struct fdi_folder
));
2180 if (!(cab
->firstfol
)) cab
->firstfol
= fol
;
2182 fol
->offset
= (cab_off_t
) EndGetI32(buf2
+cffold_DataOffset
);
2183 fol
->num_blocks
= EndGetI16(buf2
+cffold_NumBlocks
);
2184 fol
->comp_type
= EndGetI16(buf2
+cffold_CompType
);
2187 linkfol
->next
= fol
;
2192 for (i
= 0; i
< fdici
.cFiles
; i
++) {
2193 if (CAB(fdi
)->read(cab
->cabhf
, buf2
, cffile_SIZEOF
) != cffile_SIZEOF
)
2196 file
= CAB(fdi
)->alloc(sizeof(struct fdi_file
));
2198 ERR("out of memory!\n");
2199 return DECR_NOMEMORY
;
2201 ZeroMemory(file
, sizeof(struct fdi_file
));
2202 if (!(cab
->firstfile
)) cab
->firstfile
= file
;
2204 file
->length
= EndGetI32(buf2
+cffile_UncompressedSize
);
2205 file
->offset
= EndGetI32(buf2
+cffile_FolderOffset
);
2206 file
->index
= EndGetI16(buf2
+cffile_FolderIndex
);
2207 file
->time
= EndGetI16(buf2
+cffile_Time
);
2208 file
->date
= EndGetI16(buf2
+cffile_Date
);
2209 file
->attribs
= EndGetI16(buf2
+cffile_Attribs
);
2210 file
->filename
= FDI_read_string(CAB(fdi
), cab
->cabhf
, fdici
.cbCabinet
);
2212 if (!file
->filename
) return DECR_INPUT
;
2215 linkfile
->next
= file
;
2220 cab
= cab
->next
; /* advance to the next cabinet */
2222 /* iterate files -- if we encounter the continued file, process it --
2223 otherwise, jump to the label above and keep looking */
2225 for (file
= cab
->firstfile
; (file
); file
= file
->next
) {
2226 if ((file
->index
& cffileCONTINUED_FROM_PREV
) == cffileCONTINUED_FROM_PREV
) {
2227 /* check to ensure a real match */
2228 if (lstrcmpiA(fi
->filename
, file
->filename
) == 0) {
2230 if (CAB(fdi
)->seek(cab
->cabhf
, cab
->firstfol
->offset
, SEEK_SET
) == -1)
2236 if (!success
) goto tryanothercab
; /* FIXME: shouldn't this trigger
2237 "Wrong Cabinet" notification? */
2241 /* decompress block */
2242 if ((err
= CAB(decompress
)(inlen
, outlen
, decomp_state
)))
2244 CAB(outlen
) = outlen
;
2245 CAB(outpos
) = CAB(outbuf
);
2248 CAB(decomp_cab
) = cab
;
2252 static void free_decompression_temps(FDI_Int
*fdi
, const struct fdi_folder
*fol
,
2253 fdi_decomp_state
*decomp_state
)
2255 switch (fol
->comp_type
& cffoldCOMPTYPE_MASK
) {
2256 case cffoldCOMPTYPE_LZX
:
2258 fdi
->free(LZX(window
));
2262 case cffoldCOMPTYPE_QUANTUM
:
2264 fdi
->free(QTM(window
));
2271 static void free_decompression_mem(FDI_Int
*fdi
, fdi_decomp_state
*decomp_state
)
2273 struct fdi_folder
*fol
;
2274 while (decomp_state
) {
2275 fdi_decomp_state
*prev_fds
;
2277 fdi
->close(CAB(cabhf
));
2279 /* free the storage remembered by mii */
2280 if (CAB(mii
).nextname
) fdi
->free(CAB(mii
).nextname
);
2281 if (CAB(mii
).nextinfo
) fdi
->free(CAB(mii
).nextinfo
);
2282 if (CAB(mii
).prevname
) fdi
->free(CAB(mii
).prevname
);
2283 if (CAB(mii
).previnfo
) fdi
->free(CAB(mii
).previnfo
);
2285 while (CAB(firstfol
)) {
2286 fol
= CAB(firstfol
);
2287 CAB(firstfol
) = CAB(firstfol
)->next
;
2290 while (CAB(firstfile
)) {
2291 struct fdi_file
*file
= CAB(firstfile
);
2292 if (file
->filename
) fdi
->free(file
->filename
);
2293 CAB(firstfile
) = CAB(firstfile
)->next
;
2296 prev_fds
= decomp_state
;
2297 decomp_state
= CAB(next
);
2298 fdi
->free(prev_fds
);
2302 /***********************************************************************
2303 * FDICopy (CABINET.22)
2305 * Iterates through the files in the Cabinet file indicated by name and
2306 * file-location. May chain forward to additional cabinets (typically
2307 * only one) if files which begin in this Cabinet are continued in another
2308 * cabinet. For each file which is partially contained in this cabinet,
2309 * and partially contained in a prior cabinet, provides fdintPARTIAL_FILE
2310 * notification to the pfnfdin callback. For each file which begins in
2311 * this cabinet, fdintCOPY_FILE notification is provided to the pfnfdin
2312 * callback, and the file is optionally decompressed and saved to disk.
2313 * Notification is not provided for files which are not at least partially
2314 * contained in the specified cabinet file.
2316 * See below for a thorough explanation of the various notification
2320 * hfdi [I] An HFDI from FDICreate
2321 * pszCabinet [I] C-style string containing the filename of the cabinet
2322 * pszCabPath [I] C-style string containing the file path of the cabinet
2323 * flags [I] "Decoder parameters". Ignored. Suggested value: 0.
2324 * pfnfdin [I] Pointer to a notification function. See CALLBACKS below.
2325 * pfnfdid [I] Pointer to a decryption function. Ignored. Suggested
2327 * pvUser [I] arbitrary void * value which is passed to callbacks.
2330 * TRUE if successful.
2331 * FALSE if unsuccessful (error information is provided in the ERF structure
2332 * associated with the provided decompression handle by FDICreate).
2336 * Two pointers to callback functions are provided as parameters to FDICopy:
2337 * pfnfdin(of type PFNFDINOTIFY), and pfnfdid (of type PFNFDIDECRYPT). These
2338 * types are as follows:
2340 * typedef INT_PTR (__cdecl *PFNFDINOTIFY) ( FDINOTIFICATIONTYPE fdint,
2341 * PFDINOTIFICATION pfdin );
2343 * typedef int (__cdecl *PFNFDIDECRYPT) ( PFDIDECRYPT pfdid );
2345 * You can create functions of this type using the FNFDINOTIFY() and
2346 * FNFDIDECRYPT() macros, respectively. For example:
2348 * FNFDINOTIFY(mycallback) {
2349 * / * use variables fdint and pfdin to process notification * /
2352 * The second callback, which could be used for decrypting encrypted data,
2353 * is not used at all.
2355 * Each notification informs the user of some event which has occurred during
2356 * decompression of the cabinet file; each notification is also an opportunity
2357 * for the callee to abort decompression. The information provided to the
2358 * callback and the meaning of the callback's return value vary drastically
2359 * across the various types of notification. The type of notification is the
2360 * fdint parameter; all other information is provided to the callback in
2361 * notification-specific parts of the FDINOTIFICATION structure pointed to by
2362 * pfdin. The only part of that structure which is assigned for every callback
2363 * is the pv element, which contains the arbitrary value which was passed to
2364 * FDICopy in the pvUser argument (psz1 is also used each time, but its meaning
2365 * is highly dependent on fdint).
2367 * If you encounter unknown notifications, you should return zero if you want
2368 * decompression to continue (or -1 to abort). All strings used in the
2369 * callbacks are regular C-style strings. Detailed descriptions of each
2370 * notification type follow:
2372 * fdintCABINET_INFO:
2374 * This is the first notification provided after calling FDICopy, and provides
2375 * the user with various information about the cabinet. Note that this is
2376 * called for each cabinet FDICopy opens, not just the first one. In the
2377 * structure pointed to by pfdin, psz1 contains a pointer to the name of the
2378 * next cabinet file in the set after the one just loaded (if any), psz2
2379 * contains a pointer to the name or "info" of the next disk, psz3
2380 * contains a pointer to the file-path of the current cabinet, setID
2381 * contains an arbitrary constant associated with this set of cabinet files,
2382 * and iCabinet contains the numerical index of the current cabinet within
2383 * that set. Return zero, or -1 to abort.
2385 * fdintPARTIAL_FILE:
2387 * This notification is provided when FDICopy encounters a part of a file
2388 * contained in this cabinet which is missing its beginning. Files can be
2389 * split across cabinets, so this is not necessarily an abnormality; it just
2390 * means that the file in question begins in another cabinet. No file
2391 * corresponding to this notification is extracted from the cabinet. In the
2392 * structure pointed to by pfdin, psz1 contains a pointer to the name of the
2393 * partial file, psz2 contains a pointer to the file name of the cabinet in
2394 * which this file begins, and psz3 contains a pointer to the disk name or
2395 * "info" of the cabinet where the file begins. Return zero, or -1 to abort.
2399 * This notification is provided when FDICopy encounters a file which starts
2400 * in the cabinet file, provided to FDICopy in pszCabinet. (FDICopy will not
2401 * look for files in cabinets after the first one). One notification will be
2402 * sent for each such file, before the file is decompressed. By returning
2403 * zero, the callback can instruct FDICopy to skip the file. In the structure
2404 * pointed to by pfdin, psz1 contains a pointer to the file's name, cb contains
2405 * the size of the file (uncompressed), attribs contains the file attributes,
2406 * and date and time contain the date and time of the file. attributes, date,
2407 * and time are of the 16-bit ms-dos variety. Return -1 to abort decompression
2408 * for the entire cabinet, 0 to skip just this file but continue scanning the
2409 * cabinet for more files, or an FDIClose()-compatible file-handle.
2411 * fdintCLOSE_FILE_INFO:
2413 * This notification is important, don't forget to implement it. This
2414 * notification indicates that a file has been successfully uncompressed and
2415 * written to disk. Upon receipt of this notification, the callee is expected
2416 * to close the file handle, to set the attributes and date/time of the
2417 * closed file, and possibly to execute the file. In the structure pointed to
2418 * by pfdin, psz1 contains a pointer to the name of the file, hf will be the
2419 * open file handle (close it), cb contains 1 or zero, indicating respectively
2420 * that the callee should or should not execute the file, and date, time
2421 * and attributes will be set as in fdintCOPY_FILE. Bizarrely, the Cabinet SDK
2422 * specifies that _A_EXEC will be xor'ed out of attributes! wine does not do
2423 * do so. Return TRUE, or FALSE to abort decompression.
2425 * fdintNEXT_CABINET:
2427 * This notification is called when FDICopy must load in another cabinet. This
2428 * can occur when a file's data is "split" across multiple cabinets. The
2429 * callee has the opportunity to request that FDICopy look in a different file
2430 * path for the specified cabinet file, by writing that data into a provided
2431 * buffer (see below for more information). This notification will be received
2432 * more than once per-cabinet in the instance that FDICopy failed to find a
2433 * valid cabinet at the location specified by the first per-cabinet
2434 * fdintNEXT_CABINET notification. In such instances, the fdie element of the
2435 * structure pointed to by pfdin indicates the error which prevented FDICopy
2436 * from proceeding successfully. Return zero to indicate success, or -1 to
2437 * indicate failure and abort FDICopy.
2439 * Upon receipt of this notification, the structure pointed to by pfdin will
2440 * contain the following values: psz1 pointing to the name of the cabinet
2441 * which FDICopy is attempting to open, psz2 pointing to the name ("info") of
2442 * the next disk, psz3 pointing to the presumed file-location of the cabinet,
2443 * and fdie containing either FDIERROR_NONE, or one of the following:
2445 * FDIERROR_CABINET_NOT_FOUND, FDIERROR_NOT_A_CABINET,
2446 * FDIERROR_UNKNOWN_CABINET_VERSION, FDIERROR_CORRUPT_CABINET,
2447 * FDIERROR_BAD_COMPR_TYPE, FDIERROR_RESERVE_MISMATCH, and
2448 * FDIERROR_WRONG_CABINET.
2450 * The callee may choose to change the path where FDICopy will look for the
2451 * cabinet after this notification. To do so, the caller may write the new
2452 * pathname to the buffer pointed to by psz3, which is 256 characters in
2453 * length, including the terminating null character, before returning zero.
2457 * Undocumented and unimplemented in wine, this seems to be sent each time
2458 * a cabinet is opened, along with the fdintCABINET_INFO notification. It
2459 * probably has an interface similar to that of fdintCABINET_INFO; maybe this
2460 * provides information about the current cabinet instead of the next one....
2461 * this is just a guess, it has not been looked at closely.
2466 BOOL __cdecl
FDICopy(
2471 PFNFDINOTIFY pfnfdin
,
2472 PFNFDIDECRYPT pfnfdid
,
2475 FDICABINETINFO fdici
;
2476 FDINOTIFICATION fdin
;
2477 INT_PTR cabhf
, filehf
= 0;
2479 char fullpath
[MAX_PATH
];
2480 size_t pathlen
, filenamelen
;
2481 char emptystring
= '\0';
2483 struct fdi_folder
*fol
= NULL
, *linkfol
= NULL
;
2484 struct fdi_file
*file
= NULL
, *linkfile
= NULL
;
2485 fdi_decomp_state
*decomp_state
;
2486 FDI_Int
*fdi
= get_fdi_ptr( hfdi
);
2488 TRACE("(hfdi == ^%p, pszCabinet == %s, pszCabPath == %s, flags == %x, "
2489 "pfnfdin == ^%p, pfnfdid == ^%p, pvUser == ^%p)\n",
2490 hfdi
, debugstr_a(pszCabinet
), debugstr_a(pszCabPath
), flags
, pfnfdin
, pfnfdid
, pvUser
);
2492 if (!fdi
) return FALSE
;
2494 if (!(decomp_state
= fdi
->alloc(sizeof(fdi_decomp_state
))))
2496 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2499 ZeroMemory(decomp_state
, sizeof(fdi_decomp_state
));
2501 pathlen
= pszCabPath
? strlen(pszCabPath
) : 0;
2502 filenamelen
= pszCabinet
? strlen(pszCabinet
) : 0;
2504 /* slight overestimation here to save CPU cycles in the developer's brain */
2505 if ((pathlen
+ filenamelen
+ 3) > MAX_PATH
) {
2506 ERR("MAX_PATH exceeded.\n");
2507 fdi
->free(decomp_state
);
2508 set_error( fdi
, FDIERROR_CABINET_NOT_FOUND
, ERROR_FILE_NOT_FOUND
);
2512 /* paste the path and filename together */
2515 strcpy(fullpath
, pszCabPath
);
2517 strcat(fullpath
, pszCabinet
);
2519 TRACE("full cab path/file name: %s\n", debugstr_a(fullpath
));
2521 /* get a handle to the cabfile */
2522 cabhf
= fdi
->open(fullpath
, _O_RDONLY
|_O_BINARY
, _S_IREAD
| _S_IWRITE
);
2524 fdi
->free(decomp_state
);
2525 set_error( fdi
, FDIERROR_CABINET_NOT_FOUND
, 0 );
2526 SetLastError(ERROR_FILE_NOT_FOUND
);
2530 /* check if it's really a cabfile. Note that this doesn't implement the bug */
2531 if (!FDI_read_entries(fdi
, cabhf
, &fdici
, &(CAB(mii
)))) {
2532 WARN("FDI_read_entries failed: %u\n", fdi
->perf
->erfOper
);
2533 fdi
->free(decomp_state
);
2538 /* cabinet notification */
2539 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2540 fdin
.setID
= fdici
.setID
;
2541 fdin
.iCabinet
= fdici
.iCabinet
;
2543 fdin
.psz1
= (CAB(mii
).nextname
) ? CAB(mii
).nextname
: &emptystring
;
2544 fdin
.psz2
= (CAB(mii
).nextinfo
) ? CAB(mii
).nextinfo
: &emptystring
;
2545 fdin
.psz3
= pszCabPath
;
2547 if (((*pfnfdin
)(fdintCABINET_INFO
, &fdin
))) {
2548 set_error( fdi
, FDIERROR_USER_ABORT
, 0 );
2552 CAB(setID
) = fdici
.setID
;
2553 CAB(iCabinet
) = fdici
.iCabinet
;
2557 for (i
= 0; i
< fdici
.cFolders
; i
++) {
2558 if (fdi
->read(cabhf
, buf
, cffold_SIZEOF
) != cffold_SIZEOF
) {
2559 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2563 if (CAB(mii
).folder_resv
> 0)
2564 fdi
->seek(cabhf
, CAB(mii
).folder_resv
, SEEK_CUR
);
2566 fol
= fdi
->alloc(sizeof(struct fdi_folder
));
2568 ERR("out of memory!\n");
2569 set_error( fdi
, FDIERROR_ALLOC_FAIL
, ERROR_NOT_ENOUGH_MEMORY
);
2572 ZeroMemory(fol
, sizeof(struct fdi_folder
));
2573 if (!CAB(firstfol
)) CAB(firstfol
) = fol
;
2575 fol
->offset
= (cab_off_t
) EndGetI32(buf
+cffold_DataOffset
);
2576 fol
->num_blocks
= EndGetI16(buf
+cffold_NumBlocks
);
2577 fol
->comp_type
= EndGetI16(buf
+cffold_CompType
);
2580 linkfol
->next
= fol
;
2585 for (i
= 0; i
< fdici
.cFiles
; i
++) {
2586 if (fdi
->read(cabhf
, buf
, cffile_SIZEOF
) != cffile_SIZEOF
) {
2587 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2591 file
= fdi
->alloc(sizeof(struct fdi_file
));
2593 ERR("out of memory!\n");
2594 set_error( fdi
, FDIERROR_ALLOC_FAIL
, ERROR_NOT_ENOUGH_MEMORY
);
2597 ZeroMemory(file
, sizeof(struct fdi_file
));
2598 if (!CAB(firstfile
)) CAB(firstfile
) = file
;
2600 file
->length
= EndGetI32(buf
+cffile_UncompressedSize
);
2601 file
->offset
= EndGetI32(buf
+cffile_FolderOffset
);
2602 file
->index
= EndGetI16(buf
+cffile_FolderIndex
);
2603 file
->time
= EndGetI16(buf
+cffile_Time
);
2604 file
->date
= EndGetI16(buf
+cffile_Date
);
2605 file
->attribs
= EndGetI16(buf
+cffile_Attribs
);
2606 file
->filename
= FDI_read_string(fdi
, cabhf
, fdici
.cbCabinet
);
2608 if (!file
->filename
) {
2609 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2614 linkfile
->next
= file
;
2618 for (file
= CAB(firstfile
); (file
); file
= file
->next
) {
2621 * FIXME: This implementation keeps multiple cabinet files open at once
2622 * when encountering a split cabinet. It is a quirk of this implementation
2623 * that sometimes we decrypt the same block of data more than once, to find
2624 * the right starting point for a file, moving the file-pointer backwards.
2625 * If we kept a cache of certain file-pointer information, we could eliminate
2626 * that behavior... in fact I am not sure that the caching we already have
2627 * is not sufficient.
2629 * The current implementation seems to work fine in straightforward situations
2630 * where all the cabinet files needed for decryption are simultaneously
2631 * available. But presumably, the API is supposed to support cabinets which
2632 * are split across multiple CDROMS; we may need to change our implementation
2633 * to strictly serialize it's file usage so that it opens only one cabinet
2634 * at a time. Some experimentation with Windows is needed to figure out the
2635 * precise semantics required. The relevant code is here and in fdi_decomp().
2638 /* partial-file notification */
2639 if ((file
->index
& cffileCONTINUED_FROM_PREV
) == cffileCONTINUED_FROM_PREV
) {
2641 * FIXME: Need to create a Cabinet with a single file spanning multiple files
2642 * and perform some tests to figure out the right behavior. The SDK says
2643 * FDICopy will notify the user of the filename and "disk name" (info) of
2644 * the cabinet where the spanning file /started/.
2646 * That would certainly be convenient for the API-user, who could abort,
2647 * everything (or parallelize, if that's allowed (it is in wine)), and call
2648 * FDICopy again with the provided filename, so as to avoid partial file
2649 * notification and successfully unpack. This task could be quite unpleasant
2650 * from wine's perspective: the information specifying the "start cabinet" for
2651 * a file is associated nowhere with the file header and is not to be found in
2652 * the cabinet header. We have only the index of the cabinet wherein the folder
2653 * begins, which contains the file. To find that cabinet, we must consider the
2654 * index of the current cabinet, and chain backwards, cabinet-by-cabinet (for
2655 * each cabinet refers to its "next" and "previous" cabinet only, like a linked
2658 * Bear in mind that, in the spirit of CABINET.DLL, we must assume that any
2659 * cabinet other than the active one might be at another filepath than the
2660 * current one, or on another CDROM. This could get rather dicey, especially
2661 * if we imagine parallelized access to the FDICopy API.
2663 * The current implementation punts -- it just returns the previous cabinet and
2664 * it's info from the header of this cabinet. This provides the right answer in
2665 * 95% of the cases; its worth checking if Microsoft cuts the same corner before
2668 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2670 fdin
.psz1
= (char *)file
->filename
;
2671 fdin
.psz2
= (CAB(mii
).prevname
) ? CAB(mii
).prevname
: &emptystring
;
2672 fdin
.psz3
= (CAB(mii
).previnfo
) ? CAB(mii
).previnfo
: &emptystring
;
2674 if (((*pfnfdin
)(fdintPARTIAL_FILE
, &fdin
))) {
2675 set_error( fdi
, FDIERROR_USER_ABORT
, 0 );
2678 /* I don't think we are supposed to decompress partial files. This prevents it. */
2679 file
->oppressed
= TRUE
;
2681 if (file
->oppressed
) {
2684 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2686 fdin
.psz1
= (char *)file
->filename
;
2687 fdin
.cb
= file
->length
;
2688 fdin
.date
= file
->date
;
2689 fdin
.time
= file
->time
;
2690 fdin
.attribs
= file
->attribs
;
2691 if ((filehf
= ((*pfnfdin
)(fdintCOPY_FILE
, &fdin
))) == -1) {
2692 set_error( fdi
, FDIERROR_USER_ABORT
, 0 );
2698 /* find the folder for this file if necc. */
2700 fol
= CAB(firstfol
);
2701 if ((file
->index
& cffileCONTINUED_TO_NEXT
) == cffileCONTINUED_TO_NEXT
) {
2702 /* pick the last folder */
2703 while (fol
->next
) fol
= fol
->next
;
2707 for (i2
= 0; (i2
< file
->index
); i2
++)
2708 if (fol
->next
) /* bug resistance, should always be true */
2714 cab_UWORD comptype
= fol
->comp_type
;
2715 int ct1
= comptype
& cffoldCOMPTYPE_MASK
;
2716 int ct2
= CAB(current
) ? (CAB(current
)->comp_type
& cffoldCOMPTYPE_MASK
) : 0;
2719 TRACE("Extracting file %s as requested by callee.\n", debugstr_a(file
->filename
));
2721 /* set up decomp_state */
2723 CAB(filehf
) = filehf
;
2725 /* Was there a change of folder? Compression type? Did we somehow go backwards? */
2726 if ((ct1
!= ct2
) || (CAB(current
) != fol
) || (file
->offset
< CAB(offset
))) {
2728 TRACE("Resetting folder for file %s.\n", debugstr_a(file
->filename
));
2730 /* free stuff for the old decompressor */
2732 case cffoldCOMPTYPE_LZX
:
2734 fdi
->free(LZX(window
));
2738 case cffoldCOMPTYPE_QUANTUM
:
2740 fdi
->free(QTM(window
));
2746 CAB(decomp_cab
) = NULL
;
2747 CAB(fdi
)->seek(CAB(cabhf
), fol
->offset
, SEEK_SET
);
2751 /* initialize the new decompressor */
2753 case cffoldCOMPTYPE_NONE
:
2754 CAB(decompress
) = NONEfdi_decomp
;
2756 case cffoldCOMPTYPE_MSZIP
:
2757 CAB(decompress
) = ZIPfdi_decomp
;
2759 case cffoldCOMPTYPE_QUANTUM
:
2760 CAB(decompress
) = QTMfdi_decomp
;
2761 err
= QTMfdi_init((comptype
>> 8) & 0x1f, (comptype
>> 4) & 0xF, decomp_state
);
2763 case cffoldCOMPTYPE_LZX
:
2764 CAB(decompress
) = LZXfdi_decomp
;
2765 err
= LZXfdi_init((comptype
>> 8) & 0x1f, decomp_state
);
2768 err
= DECR_DATAFORMAT
;
2778 set_error( fdi
, FDIERROR_ALLOC_FAIL
, ERROR_NOT_ENOUGH_MEMORY
);
2781 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2785 if (file
->offset
> CAB(offset
)) {
2786 /* decode bytes and send them to /dev/null */
2787 switch (fdi_decomp(file
, 0, decomp_state
, pszCabPath
, pfnfdin
, pvUser
)) {
2790 case DECR_USERABORT
:
2791 set_error( fdi
, FDIERROR_USER_ABORT
, 0 );
2794 set_error( fdi
, FDIERROR_ALLOC_FAIL
, ERROR_NOT_ENOUGH_MEMORY
);
2797 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2800 CAB(offset
) = file
->offset
;
2803 /* now do the actual decompression */
2804 err
= fdi_decomp(file
, 1, decomp_state
, pszCabPath
, pfnfdin
, pvUser
);
2805 if (err
) CAB(current
) = NULL
; else CAB(offset
) += file
->length
;
2807 /* fdintCLOSE_FILE_INFO notification */
2808 ZeroMemory(&fdin
, sizeof(FDINOTIFICATION
));
2810 fdin
.psz1
= (char *)file
->filename
;
2812 fdin
.cb
= (file
->attribs
& cffile_A_EXEC
) != 0; /* FIXME: is that right? */
2813 fdin
.date
= file
->date
;
2814 fdin
.time
= file
->time
;
2815 fdin
.attribs
= file
->attribs
; /* FIXME: filter _A_EXEC? */
2816 ((*pfnfdin
)(fdintCLOSE_FILE_INFO
, &fdin
));
2822 case DECR_USERABORT
:
2823 set_error( fdi
, FDIERROR_USER_ABORT
, 0 );
2826 set_error( fdi
, FDIERROR_ALLOC_FAIL
, ERROR_NOT_ENOUGH_MEMORY
);
2829 set_error( fdi
, FDIERROR_CORRUPT_CABINET
, 0 );
2835 if (fol
) free_decompression_temps(fdi
, fol
, decomp_state
);
2836 free_decompression_mem(fdi
, decomp_state
);
2840 bail_and_fail
: /* here we free ram before error returns */
2842 if (fol
) free_decompression_temps(fdi
, fol
, decomp_state
);
2844 if (filehf
) fdi
->close(filehf
);
2846 free_decompression_mem(fdi
, decomp_state
);
2851 /***********************************************************************
2852 * FDIDestroy (CABINET.23)
2854 * Frees a handle created by FDICreate. Do /not/ call this in the middle
2855 * of FDICopy. Only reason for failure would be an invalid handle.
2858 * hfdi [I] The HFDI to free
2864 BOOL __cdecl
FDIDestroy(HFDI hfdi
)
2866 FDI_Int
*fdi
= get_fdi_ptr( hfdi
);
2868 TRACE("(hfdi == ^%p)\n", hfdi
);
2869 if (!fdi
) return FALSE
;
2870 fdi
->magic
= 0; /* paranoia */
2875 /***********************************************************************
2876 * FDITruncateCabinet (CABINET.24)
2878 * Removes all folders of a cabinet file after and including the
2879 * specified folder number.
2882 * hfdi [I] Handle to the FDI context.
2883 * pszCabinetName [I] Filename of the cabinet.
2884 * iFolderToDelete [I] Index of the first folder to delete.
2891 * The PFNWRITE function supplied to FDICreate must truncate the
2892 * file at the current position if the number of bytes to write is 0.
2894 BOOL __cdecl
FDITruncateCabinet(
2896 char *pszCabinetName
,
2897 USHORT iFolderToDelete
)
2899 FDI_Int
*fdi
= get_fdi_ptr( hfdi
);
2901 FIXME("(hfdi == ^%p, pszCabinetName == %s, iFolderToDelete == %hu): stub\n",
2902 hfdi
, debugstr_a(pszCabinetName
), iFolderToDelete
);
2904 if (!fdi
) return FALSE
;
2906 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);