?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed header dependencies to be fully compatible with the Windows
[wine/multimedia.git] / dlls / cabinet / cabextract.c
blob4a028aa7f02199d9dd30173c15265c0a710334cb
1 /*
2 * cabextract.c
3 *
4 * Copyright 2000-2002 Stuart Caie
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Principal author: Stuart Caie <kyzer@4u.net>
21 *
22 * Based on specification documents from Microsoft Corporation
23 * Quantum decompression researched and implemented by Matthew Russoto
24 * Huffman code adapted from unlzx by Dave Tritscher.
25 * InfoZip team's INFLATE implementation adapted to MSZIP by Dirk Stoecker.
26 * Major LZX fixes by Jae Jung.
27 */
28
29 #include "config.h"
30
31 #include <stdarg.h>
32 #include <stdlib.h>
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winerror.h"
37
38 #include "cabinet.h"
39
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(cabinet);
43
44 THOSE_ZIP_CONSTS;
45
46 /* all the file IO is abstracted into these routines:
47 * cabinet_(open|close|read|seek|skip|getoffset)
48 * file_(open|close|write)
49 */
50
51 /* try to open a cabinet file, returns success */
52 BOOL cabinet_open(struct cabinet *cab)
53 {
54 char *name = (char *)cab->filename;
55 HANDLE fh;
56
57 TRACE("(cab == ^%p)\n", cab);
58
59 if ((fh = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
60 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL )) == INVALID_HANDLE_VALUE) {
61 ERR("Couldn't open %s\n", debugstr_a(name));
62 return FALSE;
63 }
64
65 /* seek to end of file and get the length */
66 if ((cab->filelen = SetFilePointer(fh, 0, NULL, FILE_END)) == INVALID_SET_FILE_POINTER) {
67 if (GetLastError() != NO_ERROR) {
68 ERR("Seek END failed: %s", debugstr_a(name));
69 CloseHandle(fh);
70 return FALSE;
71 }
72 }
73
74 /* return to the start of the file */
75 if (SetFilePointer(fh, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
76 ERR("Seek BEGIN failed: %s", debugstr_a(name));
77 CloseHandle(fh);
78 return FALSE;
79 }
80
81 cab->fh = fh;
82 return TRUE;
83 }
84
85 /*******************************************************************
86 * cabinet_close (internal)
87 *
88 * close the file handle in a struct cabinet.
89 */
90 void cabinet_close(struct cabinet *cab) {
91 TRACE("(cab == ^%p)\n", cab);
92 if (cab->fh) CloseHandle(cab->fh);
93 cab->fh = 0;
94 }
95
96 /*******************************************************
97 * ensure_filepath2 (internal)
98 */
99 BOOL ensure_filepath2(char *path) {
100 BOOL ret = TRUE;
101 int len;
102 char *new_path;
103
104 new_path = HeapAlloc(GetProcessHeap(), 0, (strlen(path) + 1));
105 strcpy(new_path, path);
106
107 while((len = strlen(new_path)) && new_path[len - 1] == '\\')
108 new_path[len - 1] = 0;
109
110 TRACE("About to try to create directory %s\n", debugstr_a(new_path));
111 while(!CreateDirectoryA(new_path, NULL)) {
112 char *slash;
113 DWORD last_error = GetLastError();
114
115 if(last_error == ERROR_ALREADY_EXISTS)
116 break;
117
118 if(last_error != ERROR_PATH_NOT_FOUND) {
119 ret = FALSE;
120 break;
121 }
122
123 if(!(slash = strrchr(new_path, '\\'))) {
124 ret = FALSE;
125 break;
126 }
127
128 len = slash - new_path;
129 new_path[len] = 0;
130 if(! ensure_filepath2(new_path)) {
131 ret = FALSE;
132 break;
133 }
134 new_path[len] = '\\';
135 TRACE("New path in next iteration: %s\n", debugstr_a(new_path));
136 }
137
138 HeapFree(GetProcessHeap(), 0, new_path);
139 return ret;
140 }
141
142
143 /**********************************************************************
144 * ensure_filepath (internal)
145 *
146 * ensure_filepath("a\b\c\d.txt") ensures a, a\b and a\b\c exist as dirs
147 */
148 BOOL ensure_filepath(char *path) {
149 char new_path[MAX_PATH];
150 int len, i, lastslashpos = -1;
151
152 TRACE("(path == %s)\n", debugstr_a(path));
153
154 strcpy(new_path, path);
155 /* remove trailing slashes (shouldn't need to but wth...) */
156 while ((len = strlen(new_path)) && new_path[len - 1] == '\\')
157 new_path[len - 1] = 0;
158 /* find the position of the last '\\' */
159 for (i=0; i<MAX_PATH; i++) {
160 if (new_path[i] == 0) break;
161 if (new_path[i] == '\\')
162 lastslashpos = i;
163 }
164 if (lastslashpos > 0) {
165 new_path[lastslashpos] = 0;
166 /* may be trailing slashes but ensure_filepath2 will chop them */
167 return ensure_filepath2(new_path);
168 } else
169 return TRUE; /* ? */
170 }
171
172 /*******************************************************************
173 * file_open (internal)
174 *
175 * opens a file for output, returns success
176 */
177 BOOL file_open(struct cab_file *fi, BOOL lower, LPCSTR dir)
178 {
179 char c, *s, *d, *name;
180 BOOL ok = FALSE;
181
182 TRACE("(fi == ^%p, lower == %s, dir == %s)\n", fi, lower ? "TRUE" : "FALSE", debugstr_a(dir));
183
184 if (!(name = malloc(strlen(fi->filename) + (dir ? strlen(dir) : 0) + 2))) {
185 ERR("out of memory!\n");
186 return FALSE;
187 }
188
189 /* start with blank name */
190 *name = 0;
191
192 /* add output directory if needed */
193 if (dir) {
194 strcpy(name, dir);
195 strcat(name, "\\");
196 }
197
198 /* remove leading slashes */
199 s = (char *) fi->filename;
200 while (*s == '\\') s++;
201
202 /* copy from fi->filename to new name.
203 * lowercases characters if needed.
204 */
205 d = &name[strlen(name)];
206 do {
207 c = *s++;
208 *d++ = (lower ? tolower((unsigned char) c) : c);
209 } while (c);
210
211 /* create directories if needed, attempt to write file */
212 if (ensure_filepath(name)) {
213 fi->fh = CreateFileA(name, GENERIC_WRITE, 0, NULL,
214 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
215 if (fi->fh != INVALID_HANDLE_VALUE)
216 ok = TRUE;
217 else {
218 ERR("CreateFileA returned INVALID_HANDLE_VALUE\n");
219 fi->fh = 0;
220 }
221 } else
222 ERR("Couldn't ensure filepath for %s", debugstr_a(name));
223
224 if (!ok) {
225 ERR("Couldn't open file %s for writing\n", debugstr_a(name));
226 }
227
228 /* as full filename is no longer needed, free it */
229 free(name);
230
231 return ok;
232 }
233
234 /********************************************************
235 * close_file (internal)
236 *
237 * closes a completed file
238 */
239 void file_close(struct cab_file *fi)
240 {
241 TRACE("(fi == ^%p)\n", fi);
242
243 if (fi->fh) {
244 CloseHandle(fi->fh);
245 }
246 fi->fh = 0;
247 }
248
249 /******************************************************************
250 * file_write (internal)
251 *
252 * writes from buf to a file specified as a cab_file struct.
253 * returns success/failure
254 */
255 BOOL file_write(struct cab_file *fi, cab_UBYTE *buf, cab_off_t length)
256 {
257 DWORD bytes_written;
258
259 TRACE("(fi == ^%p, buf == ^%p, length == %u)\n", fi, buf, length);
260
261 if ((!WriteFile( fi->fh, (LPCVOID) buf, length, &bytes_written, FALSE) ||
262 (bytes_written != length))) {
263 ERR("Error writing file: %s\n", debugstr_a(fi->filename));
264 return FALSE;
265 }
266 return TRUE;
267 }
268
269
270 /*******************************************************************
271 * cabinet_skip (internal)
272 *
273 * advance the file pointer associated with the cab structure
274 * by distance bytes
275 */
276 void cabinet_skip(struct cabinet *cab, cab_off_t distance)
277 {
278 TRACE("(cab == ^%p, distance == %u)\n", cab, distance);
279 if (SetFilePointer(cab->fh, distance, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER) {
280 if (distance != INVALID_SET_FILE_POINTER)
281 ERR("%s", debugstr_a((char *) cab->filename));
282 }
283 }
284
285 /*******************************************************************
286 * cabinet_seek (internal)
287 *
288 * seek to the specified absolute offset in a cab
289 */
290 void cabinet_seek(struct cabinet *cab, cab_off_t offset) {
291 TRACE("(cab == ^%p, offset == %u)\n", cab, offset);
292 if (SetFilePointer(cab->fh, offset, NULL, FILE_BEGIN) != offset)
293 ERR("%s seek failure\n", debugstr_a((char *)cab->filename));
294 }
295
296 /*******************************************************************
297 * cabinet_getoffset (internal)
298 *
299 * returns the file pointer position of a cab
300 */
301 cab_off_t cabinet_getoffset(struct cabinet *cab)
302 {
303 return SetFilePointer(cab->fh, 0, NULL, FILE_CURRENT);
304 }
305
306 /*******************************************************************
307 * cabinet_read (internal)
308 *
309 * read data from a cabinet, returns success
310 */
311 BOOL cabinet_read(struct cabinet *cab, cab_UBYTE *buf, cab_off_t length)
312 {
313 DWORD bytes_read;
314 cab_off_t avail = cab->filelen - cabinet_getoffset(cab);
315
316 TRACE("(cab == ^%p, buf == ^%p, length == %u)\n", cab, buf, length);
317
318 if (length > avail) {
319 WARN("%s: WARNING; cabinet is truncated\n", debugstr_a((char *)cab->filename));
320 length = avail;
321 }
322
323 if (! ReadFile( cab->fh, (LPVOID) buf, length, &bytes_read, NULL )) {
324 ERR("%s read error\n", debugstr_a((char *) cab->filename));
325 return FALSE;
326 } else if (bytes_read != length) {
327 ERR("%s read size mismatch\n", debugstr_a((char *) cab->filename));
328 return FALSE;
329 }
330
331 return TRUE;
332 }
333
334 /**********************************************************************
335 * cabinet_read_string (internal)
336 *
337 * allocate and read an aribitrarily long string from the cabinet
338 */
339 char *cabinet_read_string(struct cabinet *cab)
340 {
341 cab_off_t len=256, base = cabinet_getoffset(cab), maxlen = cab->filelen - base;
342 BOOL ok = FALSE;
343 int i;
344 cab_UBYTE *buf = NULL;
345
346 TRACE("(cab == ^%p)\n", cab);
347
348 do {
349 if (len > maxlen) len = maxlen;
350 if (!(buf = realloc(buf, (size_t) len))) break;
351 if (!cabinet_read(cab, buf, (size_t) len)) break;
352
353 /* search for a null terminator in what we've just read */
354 for (i=0; i < len; i++) {
355 if (!buf[i]) {ok=TRUE; break;}
356 }
357
358 if (!ok) {
359 if (len == maxlen) {
360 ERR("%s: WARNING; cabinet is truncated\n", debugstr_a((char *) cab->filename));
361 break;
362 }
363 len += 256;
364 cabinet_seek(cab, base);
365 }
366 } while (!ok);
367
368 if (!ok) {
369 if (buf)
370 free(buf);
371 else
372 ERR("out of memory!\n");
373 return NULL;
374 }
375
376 /* otherwise, set the stream to just after the string and return */
377 cabinet_seek(cab, base + ((cab_off_t) strlen((char *) buf)) + 1);
378
379 return (char *) buf;
380 }
381
382 /******************************************************************
383 * cabinet_read_entries (internal)
384 *
385 * reads the header and all folder and file entries in this cabinet
386 */
387 BOOL cabinet_read_entries(struct cabinet *cab)
388 {
389 int num_folders, num_files, header_resv, folder_resv = 0, i;
390 struct cab_folder *fol, *linkfol = NULL;
391 struct cab_file *file, *linkfile = NULL;
392 cab_off_t base_offset;
393 cab_UBYTE buf[64];
394
395 TRACE("(cab == ^%p)\n", cab);
396
397 /* read in the CFHEADER */
398 base_offset = cabinet_getoffset(cab);
399 if (!cabinet_read(cab, buf, cfhead_SIZEOF)) {
400 return FALSE;
401 }
402
403 /* check basic MSCF signature */
404 if (EndGetI32(buf+cfhead_Signature) != 0x4643534d) {
405 ERR("%s: not a Microsoft cabinet file\n", debugstr_a((char *) cab->filename));
406 return FALSE;
407 }
408
409 /* get the number of folders */
410 num_folders = EndGetI16(buf+cfhead_NumFolders);
411 if (num_folders == 0) {
412 ERR("%s: no folders in cabinet\n", debugstr_a((char *) cab->filename));
413 return FALSE;
414 }
415
416 /* get the number of files */
417 num_files = EndGetI16(buf+cfhead_NumFiles);
418 if (num_files == 0) {
419 ERR("%s: no files in cabinet\n", debugstr_a((char *) cab->filename));
420 return FALSE;
421 }
422
423 /* just check the header revision */
424 if ((buf[cfhead_MajorVersion] > 1) ||
425 (buf[cfhead_MajorVersion] == 1 && buf[cfhead_MinorVersion] > 3))
426 {
427 WARN("%s: WARNING; cabinet format version > 1.3\n", debugstr_a((char *) cab->filename));
428 }
429
430 /* read the reserved-sizes part of header, if present */
431 cab->flags = EndGetI16(buf+cfhead_Flags);
432 if (cab->flags & cfheadRESERVE_PRESENT) {
433 if (!cabinet_read(cab, buf, cfheadext_SIZEOF)) return FALSE;
434 header_resv = EndGetI16(buf+cfheadext_HeaderReserved);
435 folder_resv = buf[cfheadext_FolderReserved];
436 cab->block_resv = buf[cfheadext_DataReserved];
437
438 if (header_resv > 60000) {
439 WARN("%s: WARNING; header reserved space > 60000\n", debugstr_a((char *) cab->filename));
440 }
441
442 /* skip the reserved header */
443 if (header_resv)
444 if (SetFilePointer(cab->fh, (cab_off_t) header_resv, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
445 ERR("seek failure: %s\n", debugstr_a((char *) cab->filename));
446 }
447
448 if (cab->flags & cfheadPREV_CABINET) {
449 cab->prevname = cabinet_read_string(cab);
450 if (!cab->prevname) return FALSE;
451 cab->previnfo = cabinet_read_string(cab);
452 }
453
454 if (cab->flags & cfheadNEXT_CABINET) {
455 cab->nextname = cabinet_read_string(cab);
456 if (!cab->nextname) return FALSE;
457 cab->nextinfo = cabinet_read_string(cab);
458 }
459
460 /* read folders */
461 for (i = 0; i < num_folders; i++) {
462 if (!cabinet_read(cab, buf, cffold_SIZEOF)) return FALSE;
463 if (folder_resv) cabinet_skip(cab, folder_resv);
464
465 fol = (struct cab_folder *) calloc(1, sizeof(struct cab_folder));
466 if (!fol) {
467 ERR("out of memory!\n");
468 return FALSE;
469 }
470
471 fol->cab[0] = cab;
472 fol->offset[0] = base_offset + (cab_off_t) EndGetI32(buf+cffold_DataOffset);
473 fol->num_blocks = EndGetI16(buf+cffold_NumBlocks);
474 fol->comp_type = EndGetI16(buf+cffold_CompType);
475
476 if (!linkfol)
477 cab->folders = fol;
478 else
479 linkfol->next = fol;
480
481 linkfol = fol;
482 }
483
484 /* read files */
485 for (i = 0; i < num_files; i++) {
486 if (!cabinet_read(cab, buf, cffile_SIZEOF))
487 return FALSE;
488
489 file = (struct cab_file *) calloc(1, sizeof(struct cab_file));
490 if (!file) {
491 ERR("out of memory!\n");
492 return FALSE;
493 }
494
495 file->length = EndGetI32(buf+cffile_UncompressedSize);
496 file->offset = EndGetI32(buf+cffile_FolderOffset);
497 file->index = EndGetI16(buf+cffile_FolderIndex);
498 file->time = EndGetI16(buf+cffile_Time);
499 file->date = EndGetI16(buf+cffile_Date);
500 file->attribs = EndGetI16(buf+cffile_Attribs);
501 file->filename = cabinet_read_string(cab);
502
503 if (!file->filename) {
504 free(file);
505 return FALSE;
506 }
507
508 if (!linkfile)
509 cab->files = file;
510 else
511 linkfile->next = file;
512
513 linkfile = file;
514 }
515 return TRUE;
516 }
517
518 /***********************************************************
519 * load_cab_offset (internal)
520 *
521 * validates and reads file entries from a cabinet at offset [offset] in
522 * file [name]. Returns a cabinet structure if successful, or NULL
523 * otherwise.
524 */
525 struct cabinet *load_cab_offset(LPCSTR name, cab_off_t offset)
526 {
527 struct cabinet *cab = (struct cabinet *) calloc(1, sizeof(struct cabinet));
528 int ok;
529
530 TRACE("(name == %s, offset == %u)\n", debugstr_a((char *) name), offset);
531
532 if (!cab) return NULL;
533
534 cab->filename = name;
535 if ((ok = cabinet_open(cab))) {
536 cabinet_seek(cab, offset);
537 ok = cabinet_read_entries(cab);
538 cabinet_close(cab);
539 }
540
541 if (ok) return cab;
542 free(cab);
543 return NULL;
544 }
545
546 /* MSZIP decruncher */
547
548 /* Dirk Stoecker wrote the ZIP decoder, based on the InfoZip deflate code */
549
550 /********************************************************
551 * Ziphuft_free (internal)
552 */
553 void Ziphuft_free(struct Ziphuft *t)
554 {
555 register struct Ziphuft *p, *q;
556
557 /* Go through linked list, freeing from the allocated (t[-1]) address. */
558 p = t;
559 while (p != (struct Ziphuft *)NULL)
560 {
561 q = (--p)->v.t;
562 free(p);
563 p = q;
564 }
565 }
566
567 /*********************************************************
568 * Ziphuft_build (internal)
569 */
570 cab_LONG Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e,
571 struct Ziphuft **t, cab_LONG *m, cab_decomp_state *decomp_state)
572 {
573 cab_ULONG a; /* counter for codes of length k */
574 cab_ULONG el; /* length of EOB code (value 256) */
575 cab_ULONG f; /* i repeats in table every f entries */
576 cab_LONG g; /* maximum code length */
577 cab_LONG h; /* table level */
578 register cab_ULONG i; /* counter, current code */
579 register cab_ULONG j; /* counter */
580 register cab_LONG k; /* number of bits in current code */
581 cab_LONG *l; /* stack of bits per table */
582 register cab_ULONG *p; /* pointer into ZIP(c)[],ZIP(b)[],ZIP(v)[] */
583 register struct Ziphuft *q; /* points to current table */
584 struct Ziphuft r; /* table entry for structure assignment */
585 register cab_LONG w; /* bits before this table == (l * h) */
586 cab_ULONG *xp; /* pointer into x */
587 cab_LONG y; /* number of dummy codes added */
588 cab_ULONG z; /* number of entries in current table */
589
590 l = ZIP(lx)+1;
591
592 /* Generate counts for each bit length */
593 el = n > 256 ? b[256] : ZIPBMAX; /* set length of EOB code, if any */
594
595 for(i = 0; i < ZIPBMAX+1; ++i)
596 ZIP(c)[i] = 0;
597 p = b; i = n;
598 do
599 {
600 ZIP(c)[*p]++; p++; /* assume all entries <= ZIPBMAX */
601 } while (--i);
602 if (ZIP(c)[0] == n) /* null input--all zero length codes */
603 {
604 *t = (struct Ziphuft *)NULL;
605 *m = 0;
606 return 0;
607 }
608
609 /* Find minimum and maximum length, bound *m by those */
610 for (j = 1; j <= ZIPBMAX; j++)
611 if (ZIP(c)[j])
612 break;
613 k = j; /* minimum code length */
614 if ((cab_ULONG)*m < j)
615 *m = j;
616 for (i = ZIPBMAX; i; i--)
617 if (ZIP(c)[i])
618 break;
619 g = i; /* maximum code length */
620 if ((cab_ULONG)*m > i)
621 *m = i;
622
623 /* Adjust last length count to fill out codes, if needed */
624 for (y = 1 << j; j < i; j++, y <<= 1)
625 if ((y -= ZIP(c)[j]) < 0)
626 return 2; /* bad input: more codes than bits */
627 if ((y -= ZIP(c)[i]) < 0)
628 return 2;
629 ZIP(c)[i] += y;
630
631 /* Generate starting offsets LONGo the value table for each length */
632 ZIP(x)[1] = j = 0;
633 p = ZIP(c) + 1; xp = ZIP(x) + 2;
634 while (--i)
635 { /* note that i == g from above */
636 *xp++ = (j += *p++);
637 }
638
639 /* Make a table of values in order of bit lengths */
640 p = b; i = 0;
641 do{
642 if ((j = *p++) != 0)
643 ZIP(v)[ZIP(x)[j]++] = i;
644 } while (++i < n);
645
646
647 /* Generate the Huffman codes and for each, make the table entries */
648 ZIP(x)[0] = i = 0; /* first Huffman code is zero */
649 p = ZIP(v); /* grab values in bit order */
650 h = -1; /* no tables yet--level -1 */
651 w = l[-1] = 0; /* no bits decoded yet */
652 ZIP(u)[0] = (struct Ziphuft *)NULL; /* just to keep compilers happy */
653 q = (struct Ziphuft *)NULL; /* ditto */
654 z = 0; /* ditto */
655
656 /* go through the bit lengths (k already is bits in shortest code) */
657 for (; k <= g; k++)
658 {
659 a = ZIP(c)[k];
660 while (a--)
661 {
662 /* here i is the Huffman code of length k bits for value *p */
663 /* make tables up to required level */
664 while (k > w + l[h])
665 {
666 w += l[h++]; /* add bits already decoded */
667
668 /* compute minimum size table less than or equal to *m bits */
669 z = (z = g - w) > (cab_ULONG)*m ? *m : z; /* upper limit */
670 if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
671 { /* too few codes for k-w bit table */
672 f -= a + 1; /* deduct codes from patterns left */
673 xp = ZIP(c) + k;
674 while (++j < z) /* try smaller tables up to z bits */
675 {
676 if ((f <<= 1) <= *++xp)
677 break; /* enough codes to use up j bits */
678 f -= *xp; /* else deduct codes from patterns */
679 }
680 }
681 if ((cab_ULONG)w + j > el && (cab_ULONG)w < el)
682 j = el - w; /* make EOB code end at table */
683 z = 1 << j; /* table entries for j-bit table */
684 l[h] = j; /* set table size in stack */
685
686 /* allocate and link in new table */
687 if (!(q = (struct Ziphuft *) malloc((z + 1)*sizeof(struct Ziphuft))))
688 {
689 if(h)
690 Ziphuft_free(ZIP(u)[0]);
691 return 3; /* not enough memory */
692 }
693 *t = q + 1; /* link to list for Ziphuft_free() */
694 *(t = &(q->v.t)) = (struct Ziphuft *)NULL;
695 ZIP(u)[h] = ++q; /* table starts after link */
696
697 /* connect to last table, if there is one */
698 if (h)
699 {
700 ZIP(x)[h] = i; /* save pattern for backing up */
701 r.b = (cab_UBYTE)l[h-1]; /* bits to dump before this table */
702 r.e = (cab_UBYTE)(16 + j); /* bits in this table */
703 r.v.t = q; /* pointer to this table */
704 j = (i & ((1 << w) - 1)) >> (w - l[h-1]);
705 ZIP(u)[h-1][j] = r; /* connect to last table */
706 }
707 }
708
709 /* set up table entry in r */
710 r.b = (cab_UBYTE)(k - w);
711 if (p >= ZIP(v) + n)
712 r.e = 99; /* out of values--invalid code */
713 else if (*p < s)
714 {
715 r.e = (cab_UBYTE)(*p < 256 ? 16 : 15); /* 256 is end-of-block code */
716 r.v.n = *p++; /* simple code is just the value */
717 }
718 else
719 {
720 r.e = (cab_UBYTE)e[*p - s]; /* non-simple--look up in lists */
721 r.v.n = d[*p++ - s];
722 }
723
724 /* fill code-like entries with r */
725 f = 1 << (k - w);
726 for (j = i >> w; j < z; j += f)
727 q[j] = r;
728
729 /* backwards increment the k-bit code i */
730 for (j = 1 << (k - 1); i & j; j >>= 1)
731 i ^= j;
732 i ^= j;
733
734 /* backup over finished tables */
735 while ((i & ((1 << w) - 1)) != ZIP(x)[h])
736 w -= l[--h]; /* don't need to update q */
737 }
738 }
739
740 /* return actual size of base table */
741 *m = l[0];
742
743 /* Return true (1) if we were given an incomplete table */
744 return y != 0 && g != 1;
745 }
746
747 /*********************************************************
748 * Zipinflate_codes (internal)
749 */
750 cab_LONG Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td,
751 cab_LONG bl, cab_LONG bd, cab_decomp_state *decomp_state)
752 {
753 register cab_ULONG e; /* table entry flag/number of extra bits */
754 cab_ULONG n, d; /* length and index for copy */
755 cab_ULONG w; /* current window position */
756 struct Ziphuft *t; /* pointer to table entry */
757 cab_ULONG ml, md; /* masks for bl and bd bits */
758 register cab_ULONG b; /* bit buffer */
759 register cab_ULONG k; /* number of bits in bit buffer */
760
761 /* make local copies of globals */
762 b = ZIP(bb); /* initialize bit buffer */
763 k = ZIP(bk);
764 w = ZIP(window_posn); /* initialize window position */
765
766 /* inflate the coded data */
767 ml = Zipmask[bl]; /* precompute masks for speed */
768 md = Zipmask[bd];
769
770 for(;;)
771 {
772 ZIPNEEDBITS((cab_ULONG)bl)
773 if((e = (t = tl + ((cab_ULONG)b & ml))->e) > 16)
774 do
775 {
776 if (e == 99)
777 return 1;
778 ZIPDUMPBITS(t->b)
779 e -= 16;
780 ZIPNEEDBITS(e)
781 } while ((e = (t = t->v.t + ((cab_ULONG)b & Zipmask[e]))->e) > 16);
782 ZIPDUMPBITS(t->b)
783 if (e == 16) /* then it's a literal */
784 CAB(outbuf)[w++] = (cab_UBYTE)t->v.n;
785 else /* it's an EOB or a length */
786 {
787 /* exit if end of block */
788 if(e == 15)
789 break;
790
791 /* get length of block to copy */
792 ZIPNEEDBITS(e)
793 n = t->v.n + ((cab_ULONG)b & Zipmask[e]);
794 ZIPDUMPBITS(e);
795
796 /* decode distance of block to copy */
797 ZIPNEEDBITS((cab_ULONG)bd)
798 if ((e = (t = td + ((cab_ULONG)b & md))->e) > 16)
799 do {
800 if (e == 99)
801 return 1;
802 ZIPDUMPBITS(t->b)
803 e -= 16;
804 ZIPNEEDBITS(e)
805 } while ((e = (t = t->v.t + ((cab_ULONG)b & Zipmask[e]))->e) > 16);
806 ZIPDUMPBITS(t->b)
807 ZIPNEEDBITS(e)
808 d = w - t->v.n - ((cab_ULONG)b & Zipmask[e]);
809 ZIPDUMPBITS(e)
810 do
811 {
812 n -= (e = (e = ZIPWSIZE - ((d &= ZIPWSIZE-1) > w ? d : w)) > n ?n:e);
813 do
814 {
815 CAB(outbuf)[w++] = CAB(outbuf)[d++];
816 } while (--e);
817 } while (n);
818 }
819 }
820
821 /* restore the globals from the locals */
822 ZIP(window_posn) = w; /* restore global window pointer */
823 ZIP(bb) = b; /* restore global bit buffer */
824 ZIP(bk) = k;
825
826 /* done */
827 return 0;
828 }
829
830 /***********************************************************
831 * Zipinflate_stored (internal)
832 */
833 cab_LONG Zipinflate_stored(cab_decomp_state *decomp_state)
834 /* "decompress" an inflated type 0 (stored) block. */
835 {
836 cab_ULONG n; /* number of bytes in block */
837 cab_ULONG w; /* current window position */
838 register cab_ULONG b; /* bit buffer */
839 register cab_ULONG k; /* number of bits in bit buffer */
840
841 /* make local copies of globals */
842 b = ZIP(bb); /* initialize bit buffer */
843 k = ZIP(bk);
844 w = ZIP(window_posn); /* initialize window position */
845
846 /* go to byte boundary */
847 n = k & 7;
848 ZIPDUMPBITS(n);
849
850 /* get the length and its complement */
851 ZIPNEEDBITS(16)
852 n = ((cab_ULONG)b & 0xffff);
853 ZIPDUMPBITS(16)
854 ZIPNEEDBITS(16)
855 if (n != (cab_ULONG)((~b) & 0xffff))
856 return 1; /* error in compressed data */
857 ZIPDUMPBITS(16)
858
859 /* read and output the compressed data */
860 while(n--)
861 {
862 ZIPNEEDBITS(8)
863 CAB(outbuf)[w++] = (cab_UBYTE)b;
864 ZIPDUMPBITS(8)
865 }
866
867 /* restore the globals from the locals */
868 ZIP(window_posn) = w; /* restore global window pointer */
869 ZIP(bb) = b; /* restore global bit buffer */
870 ZIP(bk) = k;
871 return 0;
872 }
873
874 /******************************************************
875 * Zipinflate_fixed (internal)
876 */
877 cab_LONG Zipinflate_fixed(cab_decomp_state *decomp_state)
878 {
879 struct Ziphuft *fixed_tl;
880 struct Ziphuft *fixed_td;
881 cab_LONG fixed_bl, fixed_bd;
882 cab_LONG i; /* temporary variable */
883 cab_ULONG *l;
884
885 l = ZIP(ll);
886
887 /* literal table */
888 for(i = 0; i < 144; i++)
889 l[i] = 8;
890 for(; i < 256; i++)
891 l[i] = 9;
892 for(; i < 280; i++)
893 l[i] = 7;
894 for(; i < 288; i++) /* make a complete, but wrong code set */
895 l[i] = 8;
896 fixed_bl = 7;
897 if((i = Ziphuft_build(l, 288, 257, (cab_UWORD *) Zipcplens,
898 (cab_UWORD *) Zipcplext, &fixed_tl, &fixed_bl, decomp_state)))
899 return i;
900
901 /* distance table */
902 for(i = 0; i < 30; i++) /* make an incomplete code set */
903 l[i] = 5;
904 fixed_bd = 5;
905 if((i = Ziphuft_build(l, 30, 0, (cab_UWORD *) Zipcpdist, (cab_UWORD *) Zipcpdext,
906 &fixed_td, &fixed_bd, decomp_state)) > 1)
907 {
908 Ziphuft_free(fixed_tl);
909 return i;
910 }
911
912 /* decompress until an end-of-block code */
913 i = Zipinflate_codes(fixed_tl, fixed_td, fixed_bl, fixed_bd, decomp_state);
914
915 Ziphuft_free(fixed_td);
916 Ziphuft_free(fixed_tl);
917 return i;
918 }
919
920 /**************************************************************
921 * Zipinflate_dynamic (internal)
922 */
923 cab_LONG Zipinflate_dynamic(cab_decomp_state *decomp_state)
924 /* decompress an inflated type 2 (dynamic Huffman codes) block. */
925 {
926 cab_LONG i; /* temporary variables */
927 cab_ULONG j;
928 cab_ULONG *ll;
929 cab_ULONG l; /* last length */
930 cab_ULONG m; /* mask for bit lengths table */
931 cab_ULONG n; /* number of lengths to get */
932 struct Ziphuft *tl; /* literal/length code table */
933 struct Ziphuft *td; /* distance code table */
934 cab_LONG bl; /* lookup bits for tl */
935 cab_LONG bd; /* lookup bits for td */
936 cab_ULONG nb; /* number of bit length codes */
937 cab_ULONG nl; /* number of literal/length codes */
938 cab_ULONG nd; /* number of distance codes */
939 register cab_ULONG b; /* bit buffer */
940 register cab_ULONG k; /* number of bits in bit buffer */
941
942 /* make local bit buffer */
943 b = ZIP(bb);
944 k = ZIP(bk);
945 ll = ZIP(ll);
946
947 /* read in table lengths */
948 ZIPNEEDBITS(5)
949 nl = 257 + ((cab_ULONG)b & 0x1f); /* number of literal/length codes */
950 ZIPDUMPBITS(5)
951 ZIPNEEDBITS(5)
952 nd = 1 + ((cab_ULONG)b & 0x1f); /* number of distance codes */
953 ZIPDUMPBITS(5)
954 ZIPNEEDBITS(4)
955 nb = 4 + ((cab_ULONG)b & 0xf); /* number of bit length codes */
956 ZIPDUMPBITS(4)
957 if(nl > 288 || nd > 32)
958 return 1; /* bad lengths */
959
960 /* read in bit-length-code lengths */
961 for(j = 0; j < nb; j++)
962 {
963 ZIPNEEDBITS(3)
964 ll[Zipborder[j]] = (cab_ULONG)b & 7;
965 ZIPDUMPBITS(3)
966 }
967 for(; j < 19; j++)
968 ll[Zipborder[j]] = 0;
969
970 /* build decoding table for trees--single level, 7 bit lookup */
971 bl = 7;
972 if((i = Ziphuft_build(ll, 19, 19, NULL, NULL, &tl, &bl, decomp_state)) != 0)
973 {
974 if(i == 1)
975 Ziphuft_free(tl);
976 return i; /* incomplete code set */
977 }
978
979 /* read in literal and distance code lengths */
980 n = nl + nd;
981 m = Zipmask[bl];
982 i = l = 0;
983 while((cab_ULONG)i < n)
984 {
985 ZIPNEEDBITS((cab_ULONG)bl)
986 j = (td = tl + ((cab_ULONG)b & m))->b;
987 ZIPDUMPBITS(j)
988 j = td->v.n;
989 if (j < 16) /* length of code in bits (0..15) */
990 ll[i++] = l = j; /* save last length in l */
991 else if (j == 16) /* repeat last length 3 to 6 times */
992 {
993 ZIPNEEDBITS(2)
994 j = 3 + ((cab_ULONG)b & 3);
995 ZIPDUMPBITS(2)
996 if((cab_ULONG)i + j > n)
997 return 1;
998 while (j--)
999 ll[i++] = l;
1000 }
1001 else if (j == 17) /* 3 to 10 zero length codes */
1002 {
1003 ZIPNEEDBITS(3)
1004 j = 3 + ((cab_ULONG)b & 7);
1005 ZIPDUMPBITS(3)
1006 if ((cab_ULONG)i + j > n)
1007 return 1;
1008 while (j--)
1009 ll[i++] = 0;
1010 l = 0;
1011 }
1012 else /* j == 18: 11 to 138 zero length codes */
1013 {
1014 ZIPNEEDBITS(7)
1015 j = 11 + ((cab_ULONG)b & 0x7f);
1016 ZIPDUMPBITS(7)
1017 if ((cab_ULONG)i + j > n)
1018 return 1;
1019 while (j--)
1020 ll[i++] = 0;
1021 l = 0;
1022 }
1023 }
1024
1025 /* free decoding table for trees */
1026 Ziphuft_free(tl);
1027
1028 /* restore the global bit buffer */
1029 ZIP(bb) = b;
1030 ZIP(bk) = k;
1031
1032 /* build the decoding tables for literal/length and distance codes */
1033 bl = ZIPLBITS;
1034 if((i = Ziphuft_build(ll, nl, 257, (cab_UWORD *) Zipcplens, (cab_UWORD *) Zipcplext,
1035 &tl, &bl, decomp_state)) != 0)
1036 {
1037 if(i == 1)
1038 Ziphuft_free(tl);
1039 return i; /* incomplete code set */
1040 }
1041 bd = ZIPDBITS;
1042 Ziphuft_build(ll + nl, nd, 0, (cab_UWORD *) Zipcpdist, (cab_UWORD *) Zipcpdext,
1043 &td, &bd, decomp_state);
1044
1045 /* decompress until an end-of-block code */
1046 if(Zipinflate_codes(tl, td, bl, bd, decomp_state))
1047 return 1;
1048
1049 /* free the decoding tables, return */
1050 Ziphuft_free(tl);
1051 Ziphuft_free(td);
1052 return 0;
1053 }
1054
1055 /*****************************************************
1056 * Zipinflate_block (internal)
1057 */
1058 cab_LONG Zipinflate_block(cab_LONG *e, cab_decomp_state *decomp_state) /* e == last block flag */
1059 { /* decompress an inflated block */
1060 cab_ULONG t; /* block type */
1061 register cab_ULONG b; /* bit buffer */
1062 register cab_ULONG k; /* number of bits in bit buffer */
1063
1064 /* make local bit buffer */
1065 b = ZIP(bb);
1066 k = ZIP(bk);
1067
1068 /* read in last block bit */
1069 ZIPNEEDBITS(1)
1070 *e = (cab_LONG)b & 1;
1071 ZIPDUMPBITS(1)
1072
1073 /* read in block type */
1074 ZIPNEEDBITS(2)
1075 t = (cab_ULONG)b & 3;
1076 ZIPDUMPBITS(2)
1077
1078 /* restore the global bit buffer */
1079 ZIP(bb) = b;
1080 ZIP(bk) = k;
1081
1082 /* inflate that block type */
1083 if(t == 2)
1084 return Zipinflate_dynamic(decomp_state);
1085 if(t == 0)
1086 return Zipinflate_stored(decomp_state);
1087 if(t == 1)
1088 return Zipinflate_fixed(decomp_state);
1089 /* bad block type */
1090 return 2;
1091 }
1092
1093 /****************************************************
1094 * ZIPdecompress (internal)
1095 */
1096 int ZIPdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
1097 {
1098 cab_LONG e; /* last block flag */
1099
1100 TRACE("(inlen == %d, outlen == %d)\n", inlen, outlen);
1101
1102 ZIP(inpos) = CAB(inbuf);
1103 ZIP(bb) = ZIP(bk) = ZIP(window_posn) = 0;
1104 if(outlen > ZIPWSIZE)
1105 return DECR_DATAFORMAT;
1106
1107 /* CK = Chris Kirmse, official Microsoft purloiner */
1108 if(ZIP(inpos)[0] != 0x43 || ZIP(inpos)[1] != 0x4B)
1109 return DECR_ILLEGALDATA;
1110 ZIP(inpos) += 2;
1111
1112 do
1113 {
1114 if(Zipinflate_block(&e, decomp_state))
1115 return DECR_ILLEGALDATA;
1116 } while(!e);
1117
1118 /* return success */
1119 return DECR_OK;
1120 }
1121
1122 /* Quantum decruncher */
1123
1124 /* This decruncher was researched and implemented by Matthew Russoto. */
1125 /* It has since been tidied up by Stuart Caie */
1126
1127 /******************************************************************
1128 * QTMinitmodel (internal)
1129 *
1130 * Initialise a model which decodes symbols from [s] to [s]+[n]-1
1131 */
1132 void QTMinitmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) {
1133 int i;
1134 m->shiftsleft = 4;
1135 m->entries = n;
1136 m->syms = sym;
1137 memset(m->tabloc, 0xFF, sizeof(m->tabloc)); /* clear out look-up table */
1138 for (i = 0; i < n; i++) {
1139 m->tabloc[i+s] = i; /* set up a look-up entry for symbol */
1140 m->syms[i].sym = i+s; /* actual symbol */
1141 m->syms[i].cumfreq = n-i; /* current frequency of that symbol */
1142 }
1143 m->syms[n].cumfreq = 0;
1144 }
1145
1146 /******************************************************************
1147 * QTMinit (internal)
1148 */
1149 int QTMinit(int window, int level, cab_decomp_state *decomp_state) {
1150 int wndsize = 1 << window, msz = window * 2, i;
1151 cab_ULONG j;
1152
1153 /* QTM supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */
1154 /* if a previously allocated window is big enough, keep it */
1155 if (window < 10 || window > 21) return DECR_DATAFORMAT;
1156 if (QTM(actual_size) < wndsize) {
1157 if (QTM(window)) free(QTM(window));
1158 QTM(window) = NULL;
1159 }
1160 if (!QTM(window)) {
1161 if (!(QTM(window) = malloc(wndsize))) return DECR_NOMEMORY;
1162 QTM(actual_size) = wndsize;
1163 }
1164 QTM(window_size) = wndsize;
1165 QTM(window_posn) = 0;
1166
1167 /* initialise static slot/extrabits tables */
1168 for (i = 0, j = 0; i < 27; i++) {
1169 CAB(q_length_extra)[i] = (i == 26) ? 0 : (i < 2 ? 0 : i - 2) >> 2;
1170 CAB(q_length_base)[i] = j; j += 1 << ((i == 26) ? 5 : CAB(q_length_extra)[i]);
1171 }
1172 for (i = 0, j = 0; i < 42; i++) {
1173 CAB(q_extra_bits)[i] = (i < 2 ? 0 : i-2) >> 1;
1174 CAB(q_position_base)[i] = j; j += 1 << CAB(q_extra_bits)[i];
1175 }
1176
1177 /* initialise arithmetic coding models */
1178
1179 QTMinitmodel(&QTM(model7), &QTM(m7sym)[0], 7, 0);
1180
1181 QTMinitmodel(&QTM(model00), &QTM(m00sym)[0], 0x40, 0x00);
1182 QTMinitmodel(&QTM(model40), &QTM(m40sym)[0], 0x40, 0x40);
1183 QTMinitmodel(&QTM(model80), &QTM(m80sym)[0], 0x40, 0x80);
1184 QTMinitmodel(&QTM(modelC0), &QTM(mC0sym)[0], 0x40, 0xC0);
1185
1186 /* model 4 depends on table size, ranges from 20 to 24 */
1187 QTMinitmodel(&QTM(model4), &QTM(m4sym)[0], (msz < 24) ? msz : 24, 0);
1188 /* model 5 depends on table size, ranges from 20 to 36 */
1189 QTMinitmodel(&QTM(model5), &QTM(m5sym)[0], (msz < 36) ? msz : 36, 0);
1190 /* model 6pos depends on table size, ranges from 20 to 42 */
1191 QTMinitmodel(&QTM(model6pos), &QTM(m6psym)[0], msz, 0);
1192 QTMinitmodel(&QTM(model6len), &QTM(m6lsym)[0], 27, 0);
1193
1194 return DECR_OK;
1195 }
1196
1197 /****************************************************************
1198 * QTMupdatemodel (internal)
1199 */
1200 void QTMupdatemodel(struct QTMmodel *model, int sym) {
1201 struct QTMmodelsym temp;
1202 int i, j;
1203
1204 for (i = 0; i < sym; i++) model->syms[i].cumfreq += 8;
1205
1206 if (model->syms[0].cumfreq > 3800) {
1207 if (--model->shiftsleft) {
1208 for (i = model->entries - 1; i >= 0; i--) {
1209 /* -1, not -2; the 0 entry saves this */
1210 model->syms[i].cumfreq >>= 1;
1211 if (model->syms[i].cumfreq <= model->syms[i+1].cumfreq) {
1212 model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1;
1213 }
1214 }
1215 }
1216 else {
1217 model->shiftsleft = 50;
1218 for (i = 0; i < model->entries ; i++) {
1219 /* no -1, want to include the 0 entry */
1220 /* this converts cumfreqs into frequencies, then shifts right */
1221 model->syms[i].cumfreq -= model->syms[i+1].cumfreq;
1222 model->syms[i].cumfreq++; /* avoid losing things entirely */
1223 model->syms[i].cumfreq >>= 1;
1224 }
1225
1226 /* now sort by frequencies, decreasing order -- this must be an
1227 * inplace selection sort, or a sort with the same (in)stability
1228 * characteristics
1229 */
1230 for (i = 0; i < model->entries - 1; i++) {
1231 for (j = i + 1; j < model->entries; j++) {
1232 if (model->syms[i].cumfreq < model->syms[j].cumfreq) {
1233 temp = model->syms[i];
1234 model->syms[i] = model->syms[j];
1235 model->syms[j] = temp;
1236 }
1237 }
1238 }
1239
1240 /* then convert frequencies back to cumfreq */
1241 for (i = model->entries - 1; i >= 0; i--) {
1242 model->syms[i].cumfreq += model->syms[i+1].cumfreq;
1243 }
1244 /* then update the other part of the table */
1245 for (i = 0; i < model->entries; i++) {
1246 model->tabloc[model->syms[i].sym] = i;
1247 }
1248 }
1249 }
1250 }
1251
1252 /*******************************************************************
1253 * QTMdecompress (internal)
1254 */
1255 int QTMdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
1256 {
1257 cab_UBYTE *inpos = CAB(inbuf);
1258 cab_UBYTE *window = QTM(window);
1259 cab_UBYTE *runsrc, *rundest;
1260
1261 cab_ULONG window_posn = QTM(window_posn);
1262 cab_ULONG window_size = QTM(window_size);
1263
1264 /* used by bitstream macros */
1265 register int bitsleft, bitrun, bitsneed;
1266 register cab_ULONG bitbuf;
1267
1268 /* used by GET_SYMBOL */
1269 cab_ULONG range;
1270 cab_UWORD symf;
1271 int i;
1272
1273 int extra, togo = outlen, match_length = 0, copy_length;
1274 cab_UBYTE selector, sym;
1275 cab_ULONG match_offset = 0;
1276
1277 cab_UWORD H = 0xFFFF, L = 0, C;
1278
1279 TRACE("(inlen == %d, outlen == %d)\n", inlen, outlen);
1280
1281 /* read initial value of C */
1282 Q_INIT_BITSTREAM;
1283 Q_READ_BITS(C, 16);
1284
1285 /* apply 2^x-1 mask */
1286 window_posn &= window_size - 1;
1287 /* runs can't straddle the window wraparound */
1288 if ((window_posn + togo) > window_size) {
1289 TRACE("straddled run\n");
1290 return DECR_DATAFORMAT;
1291 }
1292
1293 while (togo > 0) {
1294 GET_SYMBOL(model7, selector);
1295 switch (selector) {
1296 case 0:
1297 GET_SYMBOL(model00, sym); window[window_posn++] = sym; togo--;
1298 break;
1299 case 1:
1300 GET_SYMBOL(model40, sym); window[window_posn++] = sym; togo--;
1301 break;
1302 case 2:
1303 GET_SYMBOL(model80, sym); window[window_posn++] = sym; togo--;
1304 break;
1305 case 3:
1306 GET_SYMBOL(modelC0, sym); window[window_posn++] = sym; togo--;
1307 break;
1308
1309 case 4:
1310 /* selector 4 = fixed length of 3 */
1311 GET_SYMBOL(model4, sym);
1312 Q_READ_BITS(extra, CAB(q_extra_bits)[sym]);
1313 match_offset = CAB(q_position_base)[sym] + extra + 1;
1314 match_length = 3;
1315 break;
1316
1317 case 5:
1318 /* selector 5 = fixed length of 4 */
1319 GET_SYMBOL(model5, sym);
1320 Q_READ_BITS(extra, CAB(q_extra_bits)[sym]);
1321 match_offset = CAB(q_position_base)[sym] + extra + 1;
1322 match_length = 4;
1323 break;
1324
1325 case 6:
1326 /* selector 6 = variable length */
1327 GET_SYMBOL(model6len, sym);
1328 Q_READ_BITS(extra, CAB(q_length_extra)[sym]);
1329 match_length = CAB(q_length_base)[sym] + extra + 5;
1330 GET_SYMBOL(model6pos, sym);
1331 Q_READ_BITS(extra, CAB(q_extra_bits)[sym]);
1332 match_offset = CAB(q_position_base)[sym] + extra + 1;
1333 break;
1334
1335 default:
1336 TRACE("Selector is bogus\n");
1337 return DECR_ILLEGALDATA;
1338 }
1339
1340 /* if this is a match */
1341 if (selector >= 4) {
1342 rundest = window + window_posn;
1343 togo -= match_length;
1344
1345 /* copy any wrapped around source data */
1346 if (window_posn >= match_offset) {
1347 /* no wrap */
1348 runsrc = rundest - match_offset;
1349 } else {
1350 runsrc = rundest + (window_size - match_offset);
1351 copy_length = match_offset - window_posn;
1352 if (copy_length < match_length) {
1353 match_length -= copy_length;
1354 window_posn += copy_length;
1355 while (copy_length-- > 0) *rundest++ = *runsrc++;
1356 runsrc = window;
1357 }
1358 }
1359 window_posn += match_length;
1360
1361 /* copy match data - no worries about destination wraps */
1362 while (match_length-- > 0) *rundest++ = *runsrc++;
1363 }
1364 } /* while (togo > 0) */
1365
1366 if (togo != 0) {
1367 TRACE("Frame overflow, this_run = %d\n", togo);
1368 return DECR_ILLEGALDATA;
1369 }
1370
1371 memcpy(CAB(outbuf), window + ((!window_posn) ? window_size : window_posn) -
1372 outlen, outlen);
1373
1374 QTM(window_posn) = window_posn;
1375 return DECR_OK;
1376 }
1377
1378 /* LZX decruncher */
1379
1380 /* Microsoft's LZX document and their implementation of the
1381 * com.ms.util.cab Java package do not concur.
1382 *
1383 * In the LZX document, there is a table showing the correlation between
1384 * window size and the number of position slots. It states that the 1MB
1385 * window = 40 slots and the 2MB window = 42 slots. In the implementation,
1386 * 1MB = 42 slots, 2MB = 50 slots. The actual calculation is 'find the
1387 * first slot whose position base is equal to or more than the required
1388 * window size'. This would explain why other tables in the document refer
1389 * to 50 slots rather than 42.
1390 *
1391 * The constant NUM_PRIMARY_LENGTHS used in the decompression pseudocode
1392 * is not defined in the specification.
1393 *
1394 * The LZX document does not state the uncompressed block has an
1395 * uncompressed length field. Where does this length field come from, so
1396 * we can know how large the block is? The implementation has it as the 24
1397 * bits following after the 3 blocktype bits, before the alignment
1398 * padding.
1399 *
1400 * The LZX document states that aligned offset blocks have their aligned
1401 * offset huffman tree AFTER the main and length trees. The implementation
1402 * suggests that the aligned offset tree is BEFORE the main and length
1403 * trees.
1404 *
1405 * The LZX document decoding algorithm states that, in an aligned offset
1406 * block, if an extra_bits value is 1, 2 or 3, then that number of bits
1407 * should be read and the result added to the match offset. This is
1408 * correct for 1 and 2, but not 3, where just a huffman symbol (using the
1409 * aligned tree) should be read.
1410 *
1411 * Regarding the E8 preprocessing, the LZX document states 'No translation
1412 * may be performed on the last 6 bytes of the input block'. This is
1413 * correct. However, the pseudocode provided checks for the *E8 leader*
1414 * up to the last 6 bytes. If the leader appears between -10 and -7 bytes
1415 * from the end, this would cause the next four bytes to be modified, at
1416 * least one of which would be in the last 6 bytes, which is not allowed
1417 * according to the spec.
1418 *
1419 * The specification states that the huffman trees must always contain at
1420 * least one element. However, many CAB files contain blocks where the
1421 * length tree is completely empty (because there are no matches), and
1422 * this is expected to succeed.
1423 */
1424
1425
1426 /* LZX uses what it calls 'position slots' to represent match offsets.
1427 * What this means is that a small 'position slot' number and a small
1428 * offset from that slot are encoded instead of one large offset for
1429 * every match.
1430 * - lzx_position_base is an index to the position slot bases
1431 * - lzx_extra_bits states how many bits of offset-from-base data is needed.
1432 */
1433
1434 /************************************************************
1435 * LZXinit (internal)
1436 */
1437 int LZXinit(int window, cab_decomp_state *decomp_state) {
1438 cab_ULONG wndsize = 1 << window;
1439 int i, j, posn_slots;
1440
1441 /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
1442 /* if a previously allocated window is big enough, keep it */
1443 if (window < 15 || window > 21) return DECR_DATAFORMAT;
1444 if (LZX(actual_size) < wndsize) {
1445 if (LZX(window)) free(LZX(window));
1446 LZX(window) = NULL;
1447 }
1448 if (!LZX(window)) {
1449 if (!(LZX(window) = malloc(wndsize))) return DECR_NOMEMORY;
1450 LZX(actual_size) = wndsize;
1451 }
1452 LZX(window_size) = wndsize;
1453
1454 /* initialise static tables */
1455 for (i=0, j=0; i <= 50; i += 2) {
1456 CAB(extra_bits)[i] = CAB(extra_bits)[i+1] = j; /* 0,0,0,0,1,1,2,2,3,3... */
1457 if ((i != 0) && (j < 17)) j++; /* 0,0,1,2,3,4...15,16,17,17,17,17... */
1458 }
1459 for (i=0, j=0; i <= 50; i++) {
1460 CAB(lzx_position_base)[i] = j; /* 0,1,2,3,4,6,8,12,16,24,32,... */
1461 j += 1 << CAB(extra_bits)[i]; /* 1,1,1,1,2,2,4,4,8,8,16,16,32,32,... */
1462 }
1463
1464 /* calculate required position slots */
1465 if (window == 20) posn_slots = 42;
1466 else if (window == 21) posn_slots = 50;
1467 else posn_slots = window << 1;
1468
1469 /*posn_slots=i=0; while (i < wndsize) i += 1 << CAB(extra_bits)[posn_slots++]; */
1470
1471 LZX(R0) = LZX(R1) = LZX(R2) = 1;
1472 LZX(main_elements) = LZX_NUM_CHARS + (posn_slots << 3);
1473 LZX(header_read) = 0;
1474 LZX(frames_read) = 0;
1475 LZX(block_remaining) = 0;
1476 LZX(block_type) = LZX_BLOCKTYPE_INVALID;
1477 LZX(intel_curpos) = 0;
1478 LZX(intel_started) = 0;
1479 LZX(window_posn) = 0;
1480
1481 /* initialise tables to 0 (because deltas will be applied to them) */
1482 for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) LZX(MAINTREE_len)[i] = 0;
1483 for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++) LZX(LENGTH_len)[i] = 0;
1484
1485 return DECR_OK;
1486 }
1487
1488 /*************************************************************************
1489 * make_decode_table (internal)
1490 *
1491 * This function was coded by David Tritscher. It builds a fast huffman
1492 * decoding table out of just a canonical huffman code lengths table.
1493 *
1494 * PARAMS
1495 * nsyms: total number of symbols in this huffman tree.
1496 * nbits: any symbols with a code length of nbits or less can be decoded
1497 * in one lookup of the table.
1498 * length: A table to get code lengths from [0 to syms-1]
1499 * table: The table to fill up with decoded symbols and pointers.
1500 *
1501 * RETURNS
1502 * OK: 0
1503 * error: 1
1504 */
1505 int make_decode_table(cab_ULONG nsyms, cab_ULONG nbits, cab_UBYTE *length, cab_UWORD *table) {
1506 register cab_UWORD sym;
1507 register cab_ULONG leaf;
1508 register cab_UBYTE bit_num = 1;
1509 cab_ULONG fill;
1510 cab_ULONG pos = 0; /* the current position in the decode table */
1511 cab_ULONG table_mask = 1 << nbits;
1512 cab_ULONG bit_mask = table_mask >> 1; /* don't do 0 length codes */
1513 cab_ULONG next_symbol = bit_mask; /* base of allocation for long codes */
1514
1515 /* fill entries for codes short enough for a direct mapping */
1516 while (bit_num <= nbits) {
1517 for (sym = 0; sym < nsyms; sym++) {
1518 if (length[sym] == bit_num) {
1519 leaf = pos;
1520
1521 if((pos += bit_mask) > table_mask) return 1; /* table overrun */
1522
1523 /* fill all possible lookups of this symbol with the symbol itself */
1524 fill = bit_mask;
1525 while (fill-- > 0) table[leaf++] = sym;
1526 }
1527 }
1528 bit_mask >>= 1;
1529 bit_num++;
1530 }
1531
1532 /* if there are any codes longer than nbits */
1533 if (pos != table_mask) {
1534 /* clear the remainder of the table */
1535 for (sym = pos; sym < table_mask; sym++) table[sym] = 0;
1536
1537 /* give ourselves room for codes to grow by up to 16 more bits */
1538 pos <<= 16;
1539 table_mask <<= 16;
1540 bit_mask = 1 << 15;
1541
1542 while (bit_num <= 16) {
1543 for (sym = 0; sym < nsyms; sym++) {
1544 if (length[sym] == bit_num) {
1545 leaf = pos >> 16;
1546 for (fill = 0; fill < bit_num - nbits; fill++) {
1547 /* if this path hasn't been taken yet, 'allocate' two entries */
1548 if (table[leaf] == 0) {
1549 table[(next_symbol << 1)] = 0;
1550 table[(next_symbol << 1) + 1] = 0;
1551 table[leaf] = next_symbol++;
1552 }
1553 /* follow the path and select either left or right for next bit */
1554 leaf = table[leaf] << 1;
1555 if ((pos >> (15-fill)) & 1) leaf++;
1556 }
1557 table[leaf] = sym;
1558
1559 if ((pos += bit_mask) > table_mask) return 1; /* table overflow */
1560 }
1561 }
1562 bit_mask >>= 1;
1563 bit_num++;
1564 }
1565 }
1566
1567 /* full table? */
1568 if (pos == table_mask) return 0;
1569
1570 /* either erroneous table, or all elements are 0 - let's find out. */
1571 for (sym = 0; sym < nsyms; sym++) if (length[sym]) return 1;
1572 return 0;
1573 }
1574
1575 /************************************************************
1576 * lzx_read_lens (internal)
1577 */
1578 int lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb,
1579 cab_decomp_state *decomp_state) {
1580 cab_ULONG i,j, x,y;
1581 int z;
1582
1583 register cab_ULONG bitbuf = lb->bb;
1584 register int bitsleft = lb->bl;
1585 cab_UBYTE *inpos = lb->ip;
1586 cab_UWORD *hufftbl;
1587
1588 for (x = 0; x < 20; x++) {
1589 READ_BITS(y, 4);
1590 LENTABLE(PRETREE)[x] = y;
1591 }
1592 BUILD_TABLE(PRETREE);
1593
1594 for (x = first; x < last; ) {
1595 READ_HUFFSYM(PRETREE, z);
1596 if (z == 17) {
1597 READ_BITS(y, 4); y += 4;
1598 while (y--) lens[x++] = 0;
1599 }
1600 else if (z == 18) {
1601 READ_BITS(y, 5); y += 20;
1602 while (y--) lens[x++] = 0;
1603 }
1604 else if (z == 19) {
1605 READ_BITS(y, 1); y += 4;
1606 READ_HUFFSYM(PRETREE, z);
1607 z = lens[x] - z; if (z < 0) z += 17;
1608 while (y--) lens[x++] = z;
1609 }
1610 else {
1611 z = lens[x] - z; if (z < 0) z += 17;
1612 lens[x++] = z;
1613 }
1614 }
1615
1616 lb->bb = bitbuf;
1617 lb->bl = bitsleft;
1618 lb->ip = inpos;
1619 return 0;
1620 }
1621
1622 /*******************************************************
1623 * LZXdecompress (internal)
1624 */
1625 int LZXdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) {
1626 cab_UBYTE *inpos = CAB(inbuf);
1627 cab_UBYTE *endinp = inpos + inlen;
1628 cab_UBYTE *window = LZX(window);
1629 cab_UBYTE *runsrc, *rundest;
1630 cab_UWORD *hufftbl; /* used in READ_HUFFSYM macro as chosen decoding table */
1631
1632 cab_ULONG window_posn = LZX(window_posn);
1633 cab_ULONG window_size = LZX(window_size);
1634 cab_ULONG R0 = LZX(R0);
1635 cab_ULONG R1 = LZX(R1);
1636 cab_ULONG R2 = LZX(R2);
1637
1638 register cab_ULONG bitbuf;
1639 register int bitsleft;
1640 cab_ULONG match_offset, i,j,k; /* ijk used in READ_HUFFSYM macro */
1641 struct lzx_bits lb; /* used in READ_LENGTHS macro */
1642
1643 int togo = outlen, this_run, main_element, aligned_bits;
1644 int match_length, copy_length, length_footer, extra, verbatim_bits;
1645
1646 TRACE("(inlen == %d, outlen == %d)\n", inlen, outlen);
1647
1648 INIT_BITSTREAM;
1649
1650 /* read header if necessary */
1651 if (!LZX(header_read)) {
1652 i = j = 0;
1653 READ_BITS(k, 1); if (k) { READ_BITS(i,16); READ_BITS(j,16); }
1654 LZX(intel_filesize) = (i << 16) | j; /* or 0 if not encoded */
1655 LZX(header_read) = 1;
1656 }
1657
1658 /* main decoding loop */
1659 while (togo > 0) {
1660 /* last block finished, new block expected */
1661 if (LZX(block_remaining) == 0) {
1662 if (LZX(block_type) == LZX_BLOCKTYPE_UNCOMPRESSED) {
1663 if (LZX(block_length) & 1) inpos++; /* realign bitstream to word */
1664 INIT_BITSTREAM;
1665 }
1666
1667 READ_BITS(LZX(block_type), 3);
1668 READ_BITS(i, 16);
1669 READ_BITS(j, 8);
1670 LZX(block_remaining) = LZX(block_length) = (i << 8) | j;
1671
1672 switch (LZX(block_type)) {
1673 case LZX_BLOCKTYPE_ALIGNED:
1674 for (i = 0; i < 8; i++) { READ_BITS(j, 3); LENTABLE(ALIGNED)[i] = j; }
1675 BUILD_TABLE(ALIGNED);
1676 /* rest of aligned header is same as verbatim */
1677
1678 case LZX_BLOCKTYPE_VERBATIM:
1679 READ_LENGTHS(MAINTREE, 0, 256, lzx_read_lens);
1680 READ_LENGTHS(MAINTREE, 256, LZX(main_elements), lzx_read_lens);
1681 BUILD_TABLE(MAINTREE);
1682 if (LENTABLE(MAINTREE)[0xE8] != 0) LZX(intel_started) = 1;
1683
1684 READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS, lzx_read_lens);
1685 BUILD_TABLE(LENGTH);
1686 break;
1687
1688 case LZX_BLOCKTYPE_UNCOMPRESSED:
1689 LZX(intel_started) = 1; /* because we can't assume otherwise */
1690 ENSURE_BITS(16); /* get up to 16 pad bits into the buffer */
1691 if (bitsleft > 16) inpos -= 2; /* and align the bitstream! */
1692 R0 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4;
1693 R1 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4;
1694 R2 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4;
1695 break;
1696
1697 default:
1698 return DECR_ILLEGALDATA;
1699 }
1700 }
1701
1702 /* buffer exhaustion check */
1703 if (inpos > endinp) {
1704 /* it's possible to have a file where the next run is less than
1705 * 16 bits in size. In this case, the READ_HUFFSYM() macro used
1706 * in building the tables will exhaust the buffer, so we should
1707 * allow for this, but not allow those accidentally read bits to
1708 * be used (so we check that there are at least 16 bits
1709 * remaining - in this boundary case they aren't really part of
1710 * the compressed data)
1711 */
1712 if (inpos > (endinp+2) || bitsleft < 16) return DECR_ILLEGALDATA;
1713 }
1714
1715 while ((this_run = LZX(block_remaining)) > 0 && togo > 0) {
1716 if (this_run > togo) this_run = togo;
1717 togo -= this_run;
1718 LZX(block_remaining) -= this_run;
1719
1720 /* apply 2^x-1 mask */
1721 window_posn &= window_size - 1;
1722 /* runs can't straddle the window wraparound */
1723 if ((window_posn + this_run) > window_size)
1724 return DECR_DATAFORMAT;
1725
1726 switch (LZX(block_type)) {
1727
1728 case LZX_BLOCKTYPE_VERBATIM:
1729 while (this_run > 0) {
1730 READ_HUFFSYM(MAINTREE, main_element);
1731
1732 if (main_element < LZX_NUM_CHARS) {
1733 /* literal: 0 to LZX_NUM_CHARS-1 */
1734 window[window_posn++] = main_element;
1735 this_run--;
1736 }
1737 else {
1738 /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
1739 main_element -= LZX_NUM_CHARS;
1740
1741 match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
1742 if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
1743 READ_HUFFSYM(LENGTH, length_footer);
1744 match_length += length_footer;
1745 }
1746 match_length += LZX_MIN_MATCH;
1747
1748 match_offset = main_element >> 3;
1749
1750 if (match_offset > 2) {
1751 /* not repeated offset */
1752 if (match_offset != 3) {
1753 extra = CAB(extra_bits)[match_offset];
1754 READ_BITS(verbatim_bits, extra);
1755 match_offset = CAB(lzx_position_base)[match_offset]
1756 - 2 + verbatim_bits;
1757 }
1758 else {
1759 match_offset = 1;
1760 }
1761
1762 /* update repeated offset LRU queue */
1763 R2 = R1; R1 = R0; R0 = match_offset;
1764 }
1765 else if (match_offset == 0) {
1766 match_offset = R0;
1767 }
1768 else if (match_offset == 1) {
1769 match_offset = R1;
1770 R1 = R0; R0 = match_offset;
1771 }
1772 else /* match_offset == 2 */ {
1773 match_offset = R2;
1774 R2 = R0; R0 = match_offset;
1775 }
1776
1777 rundest = window + window_posn;
1778 this_run -= match_length;
1779
1780 /* copy any wrapped around source data */
1781 if (window_posn >= match_offset) {
1782 /* no wrap */
1783 runsrc = rundest - match_offset;
1784 } else {
1785 runsrc = rundest + (window_size - match_offset);
1786 copy_length = match_offset - window_posn;
1787 if (copy_length < match_length) {
1788 match_length -= copy_length;
1789 window_posn += copy_length;
1790 while (copy_length-- > 0) *rundest++ = *runsrc++;
1791 runsrc = window;
1792 }
1793 }
1794 window_posn += match_length;
1795
1796 /* copy match data - no worries about destination wraps */
1797 while (match_length-- > 0) *rundest++ = *runsrc++;
1798 }
1799 }
1800 break;
1801
1802 case LZX_BLOCKTYPE_ALIGNED:
1803 while (this_run > 0) {
1804 READ_HUFFSYM(MAINTREE, main_element);
1805
1806 if (main_element < LZX_NUM_CHARS) {
1807 /* literal: 0 to LZX_NUM_CHARS-1 */
1808 window[window_posn++] = main_element;
1809 this_run--;
1810 }
1811 else {
1812 /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
1813 main_element -= LZX_NUM_CHARS;
1814
1815 match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
1816 if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
1817 READ_HUFFSYM(LENGTH, length_footer);
1818 match_length += length_footer;
1819 }
1820 match_length += LZX_MIN_MATCH;
1821
1822 match_offset = main_element >> 3;
1823
1824 if (match_offset > 2) {
1825 /* not repeated offset */
1826 extra = CAB(extra_bits)[match_offset];
1827 match_offset = CAB(lzx_position_base)[match_offset] - 2;
1828 if (extra > 3) {
1829 /* verbatim and aligned bits */
1830 extra -= 3;
1831 READ_BITS(verbatim_bits, extra);
1832 match_offset += (verbatim_bits << 3);
1833 READ_HUFFSYM(ALIGNED, aligned_bits);
1834 match_offset += aligned_bits;
1835 }
1836 else if (extra == 3) {
1837 /* aligned bits only */
1838 READ_HUFFSYM(ALIGNED, aligned_bits);
1839 match_offset += aligned_bits;
1840 }
1841 else if (extra > 0) { /* extra==1, extra==2 */
1842 /* verbatim bits only */
1843 READ_BITS(verbatim_bits, extra);
1844 match_offset += verbatim_bits;
1845 }
1846 else /* extra == 0 */ {
1847 /* ??? */
1848 match_offset = 1;
1849 }
1850
1851 /* update repeated offset LRU queue */
1852 R2 = R1; R1 = R0; R0 = match_offset;
1853 }
1854 else if (match_offset == 0) {
1855 match_offset = R0;
1856 }
1857 else if (match_offset == 1) {
1858 match_offset = R1;
1859 R1 = R0; R0 = match_offset;
1860 }
1861 else /* match_offset == 2 */ {
1862 match_offset = R2;
1863 R2 = R0; R0 = match_offset;
1864 }
1865
1866 rundest = window + window_posn;
1867 this_run -= match_length;
1868
1869 /* copy any wrapped around source data */
1870 if (window_posn >= match_offset) {
1871 /* no wrap */
1872 runsrc = rundest - match_offset;
1873 } else {
1874 runsrc = rundest + (window_size - match_offset);
1875 copy_length = match_offset - window_posn;
1876 if (copy_length < match_length) {
1877 match_length -= copy_length;
1878 window_posn += copy_length;
1879 while (copy_length-- > 0) *rundest++ = *runsrc++;
1880 runsrc = window;
1881 }
1882 }
1883 window_posn += match_length;
1884
1885 /* copy match data - no worries about destination wraps */
1886 while (match_length-- > 0) *rundest++ = *runsrc++;
1887 }
1888 }
1889 break;
1890
1891 case LZX_BLOCKTYPE_UNCOMPRESSED:
1892 if ((inpos + this_run) > endinp) return DECR_ILLEGALDATA;
1893 memcpy(window + window_posn, inpos, (size_t) this_run);
1894 inpos += this_run; window_posn += this_run;
1895 break;
1896
1897 default:
1898 return DECR_ILLEGALDATA; /* might as well */
1899 }
1900
1901 }
1902 }
1903
1904 if (togo != 0) return DECR_ILLEGALDATA;
1905 memcpy(CAB(outbuf), window + ((!window_posn) ? window_size : window_posn) -
1906 outlen, (size_t) outlen);
1907
1908 LZX(window_posn) = window_posn;
1909 LZX(R0) = R0;
1910 LZX(R1) = R1;
1911 LZX(R2) = R2;
1912
1913 /* intel E8 decoding */
1914 if ((LZX(frames_read)++ < 32768) && LZX(intel_filesize) != 0) {
1915 if (outlen <= 6 || !LZX(intel_started)) {
1916 LZX(intel_curpos) += outlen;
1917 }
1918 else {
1919 cab_UBYTE *data = CAB(outbuf);
1920 cab_UBYTE *dataend = data + outlen - 10;
1921 cab_LONG curpos = LZX(intel_curpos);
1922 cab_LONG filesize = LZX(intel_filesize);
1923 cab_LONG abs_off, rel_off;
1924
1925 LZX(intel_curpos) = curpos + outlen;
1926
1927 while (data < dataend) {
1928 if (*data++ != 0xE8) { curpos++; continue; }
1929 abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
1930 if ((abs_off >= -curpos) && (abs_off < filesize)) {
1931 rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
1932 data[0] = (cab_UBYTE) rel_off;
1933 data[1] = (cab_UBYTE) (rel_off >> 8);
1934 data[2] = (cab_UBYTE) (rel_off >> 16);
1935 data[3] = (cab_UBYTE) (rel_off >> 24);
1936 }
1937 data += 4;
1938 curpos += 5;
1939 }
1940 }
1941 }
1942 return DECR_OK;
1943 }
1944
1945 /*********************************************************
1946 * find_cabs_in_file (internal)
1947 */
1948 struct cabinet *find_cabs_in_file(LPCSTR name, cab_UBYTE search_buf[])
1949 {
1950 struct cabinet *cab, *cab2, *firstcab = NULL, *linkcab = NULL;
1951 cab_UBYTE *pstart = &search_buf[0], *pend, *p;
1952 cab_off_t offset, caboff, cablen = 0, foffset = 0, filelen, length;
1953 int state = 0, found = 0, ok = 0;
1954
1955 TRACE("(name == %s)\n", debugstr_a((char *) name));
1956
1957 /* open the file and search for cabinet headers */
1958 if ((cab = (struct cabinet *) calloc(1, sizeof(struct cabinet)))) {
1959 cab->filename = name;
1960 if (cabinet_open(cab)) {
1961 filelen = cab->filelen;
1962 for (offset = 0; (offset < filelen); offset += length) {
1963 /* search length is either the full length of the search buffer,
1964 * or the amount of data remaining to the end of the file,
1965 * whichever is less.
1966 */
1967 length = filelen - offset;
1968 if (length > CAB_SEARCH_SIZE) length = CAB_SEARCH_SIZE;
1969
1970 /* fill the search buffer with data from disk */
1971 if (!cabinet_read(cab, search_buf, length)) break;
1972
1973 /* read through the entire buffer. */
1974 p = pstart;
1975 pend = &search_buf[length];
1976 while (p < pend) {
1977 switch (state) {
1978 /* starting state */
1979 case 0:
1980 /* we spend most of our time in this while loop, looking for
1981 * a leading 'M' of the 'MSCF' signature
1982 */
1983 while (*p++ != 0x4D && p < pend);
1984 if (p < pend) state = 1; /* if we found tht 'M', advance state */
1985 break;
1986
1987 /* verify that the next 3 bytes are 'S', 'C' and 'F' */
1988 case 1: state = (*p++ == 0x53) ? 2 : 0; break;
1989 case 2: state = (*p++ == 0x43) ? 3 : 0; break;
1990 case 3: state = (*p++ == 0x46) ? 4 : 0; break;
1991
1992 /* we don't care about bytes 4-7 */
1993 /* bytes 8-11 are the overall length of the cabinet */
1994 case 8: cablen = *p++; state++; break;
1995 case 9: cablen |= *p++ << 8; state++; break;
1996 case 10: cablen |= *p++ << 16; state++; break;
1997 case 11: cablen |= *p++ << 24; state++; break;
1998
1999 /* we don't care about bytes 12-15 */
2000 /* bytes 16-19 are the offset within the cabinet of the filedata */
2001 case 16: foffset = *p++; state++; break;
2002 case 17: foffset |= *p++ << 8; state++; break;
2003 case 18: foffset |= *p++ << 16; state++; break;
2004 case 19: foffset |= *p++ << 24;
2005 /* now we have received 20 bytes of potential cab header. */
2006 /* work out the offset in the file of this potential cabinet */
2007 caboff = offset + (p-pstart) - 20;
2008
2009 /* check that the files offset is less than the alleged length
2010 * of the cabinet, and that the offset + the alleged length are
2011 * 'roughly' within the end of overall file length
2012 */
2013 if ((foffset < cablen) &&
2014 ((caboff + foffset) < (filelen + 32)) &&
2015 ((caboff + cablen) < (filelen + 32)) )
2016 {
2017 /* found a potential result - try loading it */
2018 found++;
2019 cab2 = load_cab_offset(name, caboff);
2020 if (cab2) {
2021 /* success */
2022 ok++;
2023
2024 /* cause the search to restart after this cab's data. */
2025 offset = caboff + cablen;
2026 if (offset < cab->filelen) cabinet_seek(cab, offset);
2027 length = 0;
2028 p = pend;
2029
2030 /* link the cab into the list */
2031 if (linkcab == NULL) firstcab = cab2;
2032 else linkcab->next = cab2;
2033 linkcab = cab2;
2034 }
2035 }
2036 state = 0;
2037 break;
2038 default:
2039 p++, state++; break;
2040 }
2041 }
2042 }
2043 cabinet_close(cab);
2044 }
2045 free(cab);
2046 }
2047
2048 /* if there were cabinets that were found but are not ok, point this out */
2049 if (found > ok) {
2050 WARN("%s: found %d bad cabinets\n", debugstr_a(name), found-ok);
2051 }
2052
2053 /* if no cabinets were found, let the user know */
2054 if (!firstcab) {
2055 WARN("%s: not a Microsoft cabinet file.\n", debugstr_a(name));
2056 }
2057 return firstcab;
2058 }
2059
2060 /***********************************************************************
2061 * find_cabinet_file (internal)
2062 *
2063 * tries to find *cabname, from the directory path of origcab, correcting the
2064 * case of *cabname if necessary, If found, writes back to *cabname.
2065 */
2066 void find_cabinet_file(char **cabname, LPCSTR origcab) {
2067
2068 char *tail, *cab, *name, *nextpart, nametmp[MAX_PATH], *filepart;
2069 int found = 0;
2070
2071 TRACE("(*cabname == ^%p, origcab == %s)\n", cabname ? *cabname : NULL, debugstr_a(origcab));
2072
2073 /* ensure we have a cabinet name at all */
2074 if (!(name = *cabname)) {
2075 WARN("no cabinet name at all\n");
2076 }
2077
2078 /* find if there's a directory path in the origcab */
2079 tail = origcab ? max(strrchr(origcab, '/'), strrchr(origcab, '\\')) : NULL;
2080
2081 if ((cab = (char *) malloc(MAX_PATH))) {
2082 /* add the directory path from the original cabinet name */
2083 if (tail) {
2084 memcpy(cab, origcab, tail - origcab);
2085 cab[tail - origcab] = '\0';
2086 } else {
2087 /* default directory path of '.' */
2088 cab[0] = '.';
2089 cab[1] = '\0';
2090 }
2091
2092 do {
2093 TRACE("trying cab == %s", debugstr_a(cab));
2094
2095 /* we don't want null cabinet filenames */
2096 if (name[0] == '\0') {
2097 WARN("null cab name\n");
2098 break;
2099 }
2100
2101 /* if there is a directory component in the cabinet name,
2102 * look for that alone first
2103 */
2104 nextpart = strchr(name, '\\');
2105 if (nextpart) *nextpart = '\0';
2106
2107 found = SearchPathA(cab, name, NULL, MAX_PATH, nametmp, &filepart);
2108
2109 /* if the component was not found, look for it in the current dir */
2110 if (!found) {
2111 found = SearchPathA(".", name, NULL, MAX_PATH, nametmp, &filepart);
2112 }
2113
2114 if (found)
2115 TRACE("found: %s\n", debugstr_a(nametmp));
2116 else
2117 TRACE("not found.\n");
2118
2119 /* restore the real name and skip to the next directory component
2120 * or actual cabinet name
2121 */
2122 if (nextpart) *nextpart = '\\', name = &nextpart[1];
2123
2124 /* while there is another directory component, and while we
2125 * successfully found the current component
2126 */
2127 } while (nextpart && found);
2128
2129 /* if we found the cabinet, change the next cabinet's name.
2130 * otherwise, pretend nothing happened
2131 */
2132 if (found) {
2133 free((void *) *cabname);
2134 *cabname = cab;
2135 strncpy(cab, nametmp, found+1);
2136 TRACE("result: %s\n", debugstr_a(cab));
2137 } else {
2138 free((void *) cab);
2139 TRACE("result: nothing\n");
2140 }
2141 }
2142 }
2143
2144 /************************************************************************
2145 * process_files (internal)
2146 *
2147 * this does the tricky job of running through every file in the cabinet,
2148 * including spanning cabinets, and working out which file is in which
2149 * folder in which cabinet. It also throws out the duplicate file entries
2150 * that appear in spanning cabinets. There is memory leakage here because
2151 * those entries are not freed. See the XAD CAB client (function CAB_GetInfo
2152 * in CAB.c) for an implementation of this that correctly frees the discarded
2153 * file entries.
2154 */
2155 struct cab_file *process_files(struct cabinet *basecab) {
2156 struct cabinet *cab;
2157 struct cab_file *outfi = NULL, *linkfi = NULL, *nextfi, *fi, *cfi;
2158 struct cab_folder *fol, *firstfol, *lastfol = NULL, *predfol;
2159 int i, mergeok;
2160
2161 FIXME("(basecab == ^%p): Memory leak.\n", basecab);
2162
2163 for (cab = basecab; cab; cab = cab->nextcab) {
2164 /* firstfol = first folder in this cabinet */
2165 /* lastfol = last folder in this cabinet */
2166 /* predfol = last folder in previous cabinet (or NULL if first cabinet) */
2167 predfol = lastfol;
2168 firstfol = cab->folders;
2169 for (lastfol = firstfol; lastfol->next;) lastfol = lastfol->next;
2170 mergeok = 1;
2171
2172 for (fi = cab->files; fi; fi = nextfi) {
2173 i = fi->index;
2174 nextfi = fi->next;
2175
2176 if (i < cffileCONTINUED_FROM_PREV) {
2177 for (fol = firstfol; fol && i--; ) fol = fol->next;
2178 fi->folder = fol; /* NULL if an invalid folder index */
2179 }
2180 else {
2181 /* folder merging */
2182 if (i == cffileCONTINUED_TO_NEXT
2183 || i == cffileCONTINUED_PREV_AND_NEXT) {
2184 if (cab->nextcab && !lastfol->contfile) lastfol->contfile = fi;
2185 }
2186
2187 if (i == cffileCONTINUED_FROM_PREV
2188 || i == cffileCONTINUED_PREV_AND_NEXT) {
2189 /* these files are to be continued in yet another
2190 * cabinet, don't merge them in just yet */
2191 if (i == cffileCONTINUED_PREV_AND_NEXT) mergeok = 0;
2192
2193 /* only merge once per cabinet */
2194 if (predfol) {
2195 if ((cfi = predfol->contfile)
2196 && (cfi->offset == fi->offset)
2197 && (cfi->length == fi->length)
2198 && (strcmp(cfi->filename, fi->filename) == 0)
2199 && (predfol->comp_type == firstfol->comp_type)) {
2200 /* increase the number of splits */
2201 if ((i = ++(predfol->num_splits)) > CAB_SPLITMAX) {
2202 mergeok = 0;
2203 ERR("%s: internal error: CAB_SPLITMAX exceeded. please report this to wine-devel@winehq.org)\n",
2204 debugstr_a(basecab->filename));
2205 }
2206 else {
2207 /* copy information across from the merged folder */
2208 predfol->offset[i] = firstfol->offset[0];
2209 predfol->cab[i] = firstfol->cab[0];
2210 predfol->next = firstfol->next;
2211 predfol->contfile = firstfol->contfile;
2212
2213 if (firstfol == lastfol) lastfol = predfol;
2214 firstfol = predfol;
2215 predfol = NULL; /* don't merge again within this cabinet */
2216 }
2217 }
2218 else {
2219 /* if the folders won't merge, don't add their files */
2220 mergeok = 0;
2221 }
2222 }
2223
2224 if (mergeok) fi->folder = firstfol;
2225 }
2226 }
2227
2228 if (fi->folder) {
2229 if (linkfi) linkfi->next = fi; else outfi = fi;
2230 linkfi = fi;
2231 }
2232 } /* for (fi= .. */
2233 } /* for (cab= ...*/
2234
2235 return outfi;
2236 }
2237
2238 /****************************************************************
2239 * convertUTF (internal)
2240 *
2241 * translate UTF -> ASCII
2242 *
2243 * UTF translates two-byte unicode characters into 1, 2 or 3 bytes.
2244 * %000000000xxxxxxx -> %0xxxxxxx
2245 * %00000xxxxxyyyyyy -> %110xxxxx %10yyyyyy
2246 * %xxxxyyyyyyzzzzzz -> %1110xxxx %10yyyyyy %10zzzzzz
2247 *
2248 * Therefore, the inverse is as follows:
2249 * First char:
2250 * 0x00 - 0x7F = one byte char
2251 * 0x80 - 0xBF = invalid
2252 * 0xC0 - 0xDF = 2 byte char (next char only 0x80-0xBF is valid)
2253 * 0xE0 - 0xEF = 3 byte char (next 2 chars only 0x80-0xBF is valid)
2254 * 0xF0 - 0xFF = invalid
2255 *
2256 * FIXME: use a winapi to do this
2257 */
2258 int convertUTF(cab_UBYTE *in) {
2259 cab_UBYTE c, *out = in, *end = in + strlen((char *) in) + 1;
2260 cab_ULONG x;
2261
2262 do {
2263 /* read unicode character */
2264 if ((c = *in++) < 0x80) x = c;
2265 else {
2266 if (c < 0xC0) return 0;
2267 else if (c < 0xE0) {
2268 x = (c & 0x1F) << 6;
2269 if ((c = *in++) < 0x80 || c > 0xBF) return 0; else x |= (c & 0x3F);
2270 }
2271 else if (c < 0xF0) {
2272 x = (c & 0xF) << 12;
2273 if ((c = *in++) < 0x80 || c > 0xBF) return 0; else x |= (c & 0x3F)<<6;
2274 if ((c = *in++) < 0x80 || c > 0xBF) return 0; else x |= (c & 0x3F);
2275 }
2276 else return 0;
2277 }
2278
2279 /* terrible unicode -> ASCII conversion */
2280 if (x > 127) x = '_';
2281
2282 if (in > end) return 0; /* just in case */
2283 } while ((*out++ = (cab_UBYTE) x));
2284 return 1;
2285 }
2286
2287 /****************************************************
2288 * NONEdecompress (internal)
2289 */
2290 int NONEdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
2291 {
2292 if (inlen != outlen) return DECR_ILLEGALDATA;
2293 memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen);
2294 return DECR_OK;
2295 }
2296
2297 /**************************************************
2298 * checksum (internal)
2299 */
2300 cab_ULONG checksum(cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum) {
2301 int len;
2302 cab_ULONG ul = 0;
2303
2304 for (len = bytes >> 2; len--; data += 4) {
2305 csum ^= ((data[0]) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24));
2306 }
2307
2308 switch (bytes & 3) {
2309 case 3: ul |= *data++ << 16;
2310 case 2: ul |= *data++ << 8;
2311 case 1: ul |= *data;
2312 }
2313 csum ^= ul;
2314
2315 return csum;
2316 }
2317
2318 /**********************************************************
2319 * decompress (internal)
2320 */
2321 int decompress(struct cab_file *fi, int savemode, int fix, cab_decomp_state *decomp_state)
2322 {
2323 cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset);
2324 struct cabinet *cab = CAB(current)->cab[CAB(split)];
2325 cab_UBYTE buf[cfdata_SIZEOF], *data;
2326 cab_UWORD inlen, len, outlen, cando;
2327 cab_ULONG cksum;
2328 cab_LONG err;
2329
2330 TRACE("(fi == ^%p, savemode == %d, fix == %d)\n", fi, savemode, fix);
2331
2332 while (bytes > 0) {
2333 /* cando = the max number of bytes we can do */
2334 cando = CAB(outlen);
2335 if (cando > bytes) cando = bytes;
2336
2337 /* if cando != 0 */
2338 if (cando && savemode)
2339 file_write(fi, CAB(outpos), cando);
2340
2341 CAB(outpos) += cando;
2342 CAB(outlen) -= cando;
2343 bytes -= cando; if (!bytes) break;
2344
2345 /* we only get here if we emptied the output buffer */
2346
2347 /* read data header + data */
2348 inlen = outlen = 0;
2349 while (outlen == 0) {
2350 /* read the block header, skip the reserved part */
2351 if (!cabinet_read(cab, buf, cfdata_SIZEOF)) return DECR_INPUT;
2352 cabinet_skip(cab, cab->block_resv);
2353
2354 /* we shouldn't get blocks over CAB_INPUTMAX in size */
2355 data = CAB(inbuf) + inlen;
2356 len = EndGetI16(buf+cfdata_CompressedSize);
2357 inlen += len;
2358 if (inlen > CAB_INPUTMAX) return DECR_INPUT;
2359 if (!cabinet_read(cab, data, len)) return DECR_INPUT;
2360
2361 /* clear two bytes after read-in data */
2362 data[len+1] = data[len+2] = 0;
2363
2364 /* perform checksum test on the block (if one is stored) */
2365 cksum = EndGetI32(buf+cfdata_CheckSum);
2366 if (cksum && cksum != checksum(buf+4, 4, checksum(data, len, 0))) {
2367 /* checksum is wrong */
2368 if (fix && ((fi->folder->comp_type & cffoldCOMPTYPE_MASK)
2369 == cffoldCOMPTYPE_MSZIP))
2370 {
2371 WARN("%s: checksum failed\n", debugstr_a(fi->filename));
2372 }
2373 else {
2374 return DECR_CHECKSUM;
2375 }
2376 }
2377
2378 /* outlen=0 means this block was part of a split block */
2379 outlen = EndGetI16(buf+cfdata_UncompressedSize);
2380 if (outlen == 0) {
2381 cabinet_close(cab);
2382 cab = CAB(current)->cab[++CAB(split)];
2383 if (!cabinet_open(cab)) return DECR_INPUT;
2384 cabinet_seek(cab, CAB(current)->offset[CAB(split)]);
2385 }
2386 }
2387
2388 /* decompress block */
2389 if ((err = CAB(decompress)(inlen, outlen, decomp_state))) {
2390 if (fix && ((fi->folder->comp_type & cffoldCOMPTYPE_MASK)
2391 == cffoldCOMPTYPE_MSZIP))
2392 {
2393 ERR("%s: failed decrunching block\n", debugstr_a(fi->filename));
2394 }
2395 else {
2396 return err;
2397 }
2398 }
2399 CAB(outlen) = outlen;
2400 CAB(outpos) = CAB(outbuf);
2401 }
2402
2403 return DECR_OK;
2404 }
2405
2406 /****************************************************************
2407 * extract_file (internal)
2408 *
2409 * workhorse to extract a particular file from a cab
2410 */
2411 void extract_file(struct cab_file *fi, int lower, int fix, LPCSTR dir, cab_decomp_state *decomp_state)
2412 {
2413 struct cab_folder *fol = fi->folder, *oldfol = CAB(current);
2414 cab_LONG err = DECR_OK;
2415
2416 TRACE("(fi == ^%p, lower == %d, fix == %d, dir == %s)\n", fi, lower, fix, debugstr_a(dir));
2417
2418 /* is a change of folder needed? do we need to reset the current folder? */
2419 if (fol != oldfol || fi->offset < CAB(offset)) {
2420 cab_UWORD comptype = fol->comp_type;
2421 int ct1 = comptype & cffoldCOMPTYPE_MASK;
2422 int ct2 = oldfol ? (oldfol->comp_type & cffoldCOMPTYPE_MASK) : 0;
2423
2424 /* if the archiver has changed, call the old archiver's free() function */
2425 if (ct1 != ct2) {
2426 switch (ct2) {
2427 case cffoldCOMPTYPE_LZX:
2428 if (LZX(window)) {
2429 free(LZX(window));
2430 LZX(window) = NULL;
2431 }
2432 break;
2433 case cffoldCOMPTYPE_QUANTUM:
2434 if (QTM(window)) {
2435 free(QTM(window));
2436 QTM(window) = NULL;
2437 }
2438 break;
2439 }
2440 }
2441
2442 switch (ct1) {
2443 case cffoldCOMPTYPE_NONE:
2444 CAB(decompress) = NONEdecompress;
2445 break;
2446
2447 case cffoldCOMPTYPE_MSZIP:
2448 CAB(decompress) = ZIPdecompress;
2449 break;
2450
2451 case cffoldCOMPTYPE_QUANTUM:
2452 CAB(decompress) = QTMdecompress;
2453 err = QTMinit((comptype >> 8) & 0x1f, (comptype >> 4) & 0xF, decomp_state);
2454 break;
2455
2456 case cffoldCOMPTYPE_LZX:
2457 CAB(decompress) = LZXdecompress;
2458 err = LZXinit((comptype >> 8) & 0x1f, decomp_state);
2459 break;
2460
2461 default:
2462 err = DECR_DATAFORMAT;
2463 }
2464 if (err) goto exit_handler;
2465
2466 /* initialisation OK, set current folder and reset offset */
2467 if (oldfol) cabinet_close(oldfol->cab[CAB(split)]);
2468 if (!cabinet_open(fol->cab[0])) goto exit_handler;
2469 cabinet_seek(fol->cab[0], fol->offset[0]);
2470 CAB(current) = fol;
2471 CAB(offset) = 0;
2472 CAB(outlen) = 0; /* discard existing block */
2473 CAB(split) = 0;
2474 }
2475
2476 if (fi->offset > CAB(offset)) {
2477 /* decode bytes and send them to /dev/null */
2478 if ((err = decompress(fi, 0, fix, decomp_state))) goto exit_handler;
2479 CAB(offset) = fi->offset;
2480 }
2481
2482 if (!file_open(fi, lower, dir)) return;
2483 err = decompress(fi, 1, fix, decomp_state);
2484 if (err) CAB(current) = NULL; else CAB(offset) += fi->length;
2485 file_close(fi);
2486
2487 exit_handler:
2488 if (err) {
2489 char *errmsg, *cabname;
2490 switch (err) {
2491 case DECR_NOMEMORY:
2492 errmsg = "out of memory!\n"; break;
2493 case DECR_ILLEGALDATA:
2494 errmsg = "%s: illegal or corrupt data\n"; break;
2495 case DECR_DATAFORMAT:
2496 errmsg = "%s: unsupported data format\n"; break;
2497 case DECR_CHECKSUM:
2498 errmsg = "%s: checksum error\n"; break;
2499 case DECR_INPUT:
2500 errmsg = "%s: input error\n"; break;
2501 case DECR_OUTPUT:
2502 errmsg = "%s: output error\n"; break;
2503 default:
2504 errmsg = "%s: unknown error (BUG)\n";
2505 }
2506
2507 if (CAB(current)) {
2508 cabname = (char *) (CAB(current)->cab[CAB(split)]->filename);
2509 }
2510 else {
2511 cabname = (char *) (fi->folder->cab[0]->filename);
2512 }
2513
2514 ERR(errmsg, cabname);
2515 }
2516 }
2517
2518 /*********************************************************
2519 * print_fileinfo (internal)
2520 */
2521 void print_fileinfo(struct cab_file *fi) {
2522 int d = fi->date, t = fi->time;
2523 char *fname = NULL;
2524
2525 if (fi->attribs & cffile_A_NAME_IS_UTF) {
2526 fname = malloc(strlen(fi->filename) + 1);
2527 if (fname) {
2528 strcpy(fname, fi->filename);
2529 convertUTF((cab_UBYTE *) fname);
2530 }
2531 }
2532
2533 TRACE("%9u | %02d.%02d.%04d %02d:%02d:%02d | %s\n",
2534 fi->length,
2535 d & 0x1f, (d>>5) & 0xf, (d>>9) + 1980,
2536 t >> 11, (t>>5) & 0x3f, (t << 1) & 0x3e,
2537 fname ? fname : fi->filename
2538 );
2539
2540 if (fname) free(fname);
2541 }
2542
2543 /****************************************************************************
2544 * process_cabinet (internal)
2545 *
2546 * called to simply "extract" a cabinet file. Will find every cabinet file
2547 * in that file, search for every chained cabinet attached to those cabinets,
2548 * and will either extract the cabinets, or ? (call a callback?)
2549 *
2550 * PARAMS
2551 * cabname [I] name of the cabinet file to extract
2552 * dir [I] directory to extract to
2553 * fix [I] attempt to process broken cabinets
2554 * lower [I] ? (lower case something or other?)
2555 *
2556 * RETURNS
2557 * Success: TRUE
2558 * Failure: FALSE
2559 */
2560 BOOL process_cabinet(LPCSTR cabname, LPCSTR dir, BOOL fix, BOOL lower)
2561 {
2562 struct cabinet *basecab, *cab, *cab1, *cab2;
2563 struct cab_file *filelist, *fi;
2564
2565 /* The first result of a search will be returned, and
2566 * the remaining results will be chained to it via the cab->next structure
2567 * member.
2568 */
2569 cab_UBYTE search_buf[CAB_SEARCH_SIZE];
2570
2571 cab_decomp_state decomp_state_local;
2572 cab_decomp_state *decomp_state = &decomp_state_local;
2573
2574 /* has the list-mode header been seen before? */
2575 int viewhdr = 0;
2576
2577 ZeroMemory(decomp_state, sizeof(cab_decomp_state));
2578
2579 TRACE("Extract %s\n", debugstr_a(cabname));
2580
2581 /* load the file requested */
2582 basecab = find_cabs_in_file(cabname, search_buf);
2583 if (!basecab) return FALSE;
2584
2585 /* iterate over all cabinets found in that file */
2586 for (cab = basecab; cab; cab=cab->next) {
2587
2588 /* bi-directionally load any spanning cabinets -- backwards */
2589 for (cab1 = cab; cab1->flags & cfheadPREV_CABINET; cab1 = cab1->prevcab) {
2590 TRACE("%s: extends backwards to %s (%s)\n", debugstr_a(cabname),
2591 debugstr_a(cab1->prevname), debugstr_a(cab1->previnfo));
2592 find_cabinet_file(&(cab1->prevname), cabname);
2593 if (!(cab1->prevcab = load_cab_offset(cab1->prevname, 0))) {
2594 ERR("%s: can't read previous cabinet %s\n", debugstr_a(cabname), debugstr_a(cab1->prevname));
2595 break;
2596 }
2597 cab1->prevcab->nextcab = cab1;
2598 }
2599
2600 /* bi-directionally load any spanning cabinets -- forwards */
2601 for (cab2 = cab; cab2->flags & cfheadNEXT_CABINET; cab2 = cab2->nextcab) {
2602 TRACE("%s: extends to %s (%s)\n", debugstr_a(cabname),
2603 debugstr_a(cab2->nextname), debugstr_a(cab2->nextinfo));
2604 find_cabinet_file(&(cab2->nextname), cabname);
2605 if (!(cab2->nextcab = load_cab_offset(cab2->nextname, 0))) {
2606 ERR("%s: can't read next cabinet %s\n", debugstr_a(cabname), debugstr_a(cab2->nextname));
2607 break;
2608 }
2609 cab2->nextcab->prevcab = cab2;
2610 }
2611
2612 filelist = process_files(cab1);
2613 CAB(current) = NULL;
2614
2615 if (!viewhdr) {
2616 TRACE("File size | Date Time | Name\n");
2617 TRACE("----------+---------------------+-------------\n");
2618 viewhdr = 1;
2619 }
2620 for (fi = filelist; fi; fi = fi->next)
2621 print_fileinfo(fi);
2622 TRACE("Beginning Extraction...\n");
2623 for (fi = filelist; fi; fi = fi->next) {
2624 TRACE(" extracting: %s\n", debugstr_a(fi->filename));
2625 extract_file(fi, lower, fix, dir, decomp_state);
2626 }
2627 }
2628
2629 TRACE("Finished processing cabinet.\n");
2630
2631 return TRUE;
2632 }
Maarten's multimedia branch