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