![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to extract.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / unzip|
Return to extract.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / unzip |
1.1 root 1: /*---------------------------------------------------------------------------
2:
3: extract.c
4:
5: This file contains the high-level routines ("driver routines") for extrac-
6: ting and testing zipfile members. It calls the low-level routines in files
7: explode.c, inflate.c, unreduce.c and unshrink.c.
8:
9: ---------------------------------------------------------------------------*/
10:
11:
12: #include "unzip.h"
13: #ifdef MSWIN
14: # include "wizunzip.h"
15: # include "replace.h"
16: #endif /* MSWIN */
17:
18:
19: /************************************/
20: /* Extract Local Prototypes, etc. */
21: /************************************/
22:
23: static int store_info __((void));
24: static int extract_or_test_member __((void));
25: #ifdef CRYPT
26: static int decrypt_member __((void));
27: static int testp __((byte *hdr));
28: #endif
29:
30: static byte *mem_i_buffer;
31: static byte *mem_o_buffer;
32: static ULONG mem_i_size, mem_i_offset;
33: static ULONG mem_o_size, mem_o_offset;
34:
35: static char *VersionMsg =
36: " skipping: %-22s need %s compat. v%u.%u (can do v%u.%u)\n";
37: static char *ComprMsg =
38: " skipping: %-22s compression method %d\n";
39: static char *FilNamMsg =
40: "%s: bad filename length (%s)\n";
41: static char *ExtFieldMsg =
42: "%s: bad extra field length (%s)\n";
43: static char *OffsetMsg =
44: "file #%d: bad zipfile offset (%s)\n";
45:
46:
47:
48:
49:
50: /**************************************/
51: /* Function extract_or_test_files() */
52: /**************************************/
53:
54: int extract_or_test_files() /* return PK-type error code */
55: {
56: char **fnamev;
57: byte *cd_inptr;
58: int cd_incnt, error, error_in_archive=0;
59: int renamed, query, len, filnum=(-1), blknum=0;
60: #ifdef OS2
61: extern int longname; /* from os2unzip.c */
62: #endif
63: UWORD i, j, members_remaining, num_skipped=0, num_bad_pwd=0;
64: longint cd_bufstart, bufstart, inbuf_offset, request;
65: min_info info[DIR_BLKSIZ];
66:
67:
68: /*---------------------------------------------------------------------------
69: The basic idea of this function is as follows. Since the central di-
70: rectory lies at the end of the zipfile and the member files lie at the
71: beginning or middle or wherever, it is not very desirable to simply
72: read a central directory entry, jump to the member and extract it, and
73: then jump back to the central directory. In the case of a large zipfile
74: this would lead to a whole lot of disk-grinding, especially if each mem-
75: ber file is small. Instead, we read from the central directory the per-
76: tinent information for a block of files, then go extract/test the whole
77: block. Thus this routine contains two small(er) loops within a very
78: large outer loop: the first of the small ones reads a block of files
79: from the central directory; the second extracts or tests each file; and
80: the outer one loops over blocks. There's some file-pointer positioning
81: stuff in between, but that's about it. Btw, it's because of this jump-
82: ing around that we can afford to be lenient if an error occurs in one of
83: the member files: we should still be able to go find the other members,
84: since we know the offset of each from the beginning of the zipfile.
85:
86: Begin main loop over blocks of member files. We know the entire central
87: directory is on this disk: we would not have any of this information un-
88: less the end-of-central-directory record was on this disk, and we would
89: not have gotten to this routine unless this is also the disk on which
90: the central directory starts. In practice, this had better be the ONLY
91: disk in the archive, but maybe someday we'll add multi-disk support.
92: ---------------------------------------------------------------------------*/
93:
94: pInfo = info;
95: members_remaining = ecrec.total_entries_central_dir;
96:
97: while (members_remaining) {
98: j = 0;
99:
100: /*
101: * Loop through files in central directory, storing offsets, file
102: * attributes, and case-conversion flags until block size is reached.
103: */
104:
105: while (members_remaining && (j < DIR_BLKSIZ)) {
106: --members_remaining;
107: pInfo = &info[j];
108:
109: if (readbuf(sig, 4) <= 0) {
110: error_in_archive = 51; /* 51: unexpected EOF */
111: members_remaining = 0; /* ...so no more left to do */
112: break;
113: }
114: if (strncmp(sig, central_hdr_sig, 4)) { /* just to make sure */
115: fprintf(stderr, CentSigMsg, j); /* sig not found */
116: fprintf(stderr, ReportMsg); /* check binary transfers */
117: error_in_archive = 3; /* 3: error in zipfile */
118: members_remaining = 0; /* ...so no more left to do */
119: break;
120: }
121: /* process_cdir_file_hdr() sets pInfo->hostnum, pInfo->lcflag */
122: if ((error = process_cdir_file_hdr()) != 0) {
123: error_in_archive = error; /* only 51 (EOF) defined */
124: members_remaining = 0; /* ...so no more left to do */
125: break;
126: }
127: if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
128: if (error > error_in_archive)
129: error_in_archive = error;
130: if (error > 1) { /* fatal: no more left to do */
131: fprintf(stderr, FilNamMsg, filename, "central");
132: members_remaining = 0;
133: break;
134: }
135: }
136: if ((error = do_string(crec.extra_field_length, EXTRA_FIELD)) != 0)
137: {
138: if (error > error_in_archive)
139: error_in_archive = error;
140: if (error > 1) { /* fatal */
141: fprintf(stderr, ExtFieldMsg, filename, "central");
142: members_remaining = 0;
143: break;
144: }
145: }
146: if ((error = do_string(crec.file_comment_length, SKIP)) != 0) {
147: if (error > error_in_archive)
148: error_in_archive = error;
149: if (error > 1) { /* fatal */
150: fprintf(stderr, "\n%s: bad file comment length\n",
151: filename);
152: members_remaining = 0;
153: break;
154: }
155: }
156: if (process_all_files) {
157: if (store_info())
158: ++num_skipped;
159: else
160: ++j; /* file is OK: save info[] and continue with next */
161: } else {
162: fnamev = fnv; /* don't destroy permanent filename pointer */
163: for (--fnamev; *++fnamev;)
164: if (match(filename, *fnamev)) {
165: if (store_info())
166: ++num_skipped;
167: else
168: ++j; /* file is OK */
169: break; /* found match for filename, so stop looping */
170: } /* end if (match), for-loop (fnamev) */
171: } /* end if (process_all_files) */
172:
173: } /* end while-loop (adding files to current block) */
174:
175: /* save position in central directory so can come back later */
176: cd_bufstart = cur_zipfile_bufstart;
177: cd_inptr = inptr;
178: cd_incnt = incnt;
179:
180: /*-----------------------------------------------------------------------
181: Second loop: process files in current block, extracting or testing
182: each one.
183: -----------------------------------------------------------------------*/
184:
185: for (i = 0; i < j; ++i) {
186: filnum = i + blknum*DIR_BLKSIZ;
187: pInfo = &info[i];
188: /*
189: * if the target position is not within the current input buffer
190: * (either haven't yet read far enough, or (maybe) skipping back-
191: * ward) skip to the target position and reset readbuf().
192: */
193: /* LSEEK(pInfo->offset): */
194: request = pInfo->offset + extra_bytes;
195: inbuf_offset = request % INBUFSIZ;
196: bufstart = request - inbuf_offset;
197:
198: if (request < 0) {
199: fprintf(stderr, SeekMsg, ReportMsg);
200: error_in_archive = 3; /* 3: severe error in zipfile, */
201: continue; /* but can still go on */
202: } else if (bufstart != cur_zipfile_bufstart) {
203: cur_zipfile_bufstart = lseek(zipfd, bufstart, SEEK_SET);
204: if ((incnt = read(zipfd,(char *)inbuf,INBUFSIZ)) <= 0) {
205: fprintf(stderr, OffsetMsg, filnum, "lseek");
206: error_in_archive = 3; /* 3: error in zipfile, but */
207: continue; /* can still do next file */
208: }
209: inptr = inbuf + (int)inbuf_offset;
210: incnt -= (int)inbuf_offset;
211: } else {
212: incnt += (inptr-inbuf) - (int)inbuf_offset;
213: inptr = inbuf + (int)inbuf_offset;
214: }
215:
216: /* should be in proper position now, so check for sig */
217: if (readbuf(sig, 4) <= 0) { /* bad offset */
218: fprintf(stderr, OffsetMsg, filnum, "EOF");
219: error_in_archive = 3; /* 3: error in zipfile */
220: continue; /* but can still try next one */
221: }
222: if (strncmp(sig, local_hdr_sig, 4)) {
223: fprintf(stderr, OffsetMsg, filnum,
224: "can't find local header sig"); /* bad offset */
225: error_in_archive = 3;
226: continue;
227: }
228: if ((error = process_local_file_hdr()) != 0) {
229: fprintf(stderr, "\nfile #%d: bad local header\n", filnum);
230: error_in_archive = error; /* only 51 (EOF) defined */
231: continue; /* can still try next one */
232: }
233: if ((error = do_string(lrec.filename_length, FILENAME)) != 0) {
234: if (error > error_in_archive)
235: error_in_archive = error;
236: if (error > 1) {
237: fprintf(stderr, FilNamMsg, filename, "local");
238: continue; /* go on to next one */
239: }
240: }
241: if (extra_field != (byte *)NULL)
242: free(extra_field);
243: extra_field = (byte *)NULL;
244: if ((error = do_string(lrec.extra_field_length, EXTRA_FIELD)) != 0)
245: {
246: if (error > error_in_archive)
247: error_in_archive = error;
248: if (error > 1) {
249: fprintf(stderr, ExtFieldMsg, filename, "local");
250: continue; /* go on */
251: }
252: }
253:
254: /*
255: * just about to extract file: if extracting to disk, check if
256: * already exists, and if so, take appropriate action according to
257: * fflag/uflag/overwrite_all/etc. (we couldn't do this in upper
258: * loop because we don't store the possibly renamed filename[] in
259: * info[])
260: */
261: if (!tflag && !cflag) {
262: renamed = FALSE; /* user hasn't renamed output file yet */
263: #ifdef OS2
264: longname = FALSE; /* no long name has yet been stored */
265: #endif
266:
267: startover:
268: query = FALSE;
269: #ifdef MACOS
270: macflag = (pInfo->hostnum == MAC_);
271: #endif
272: /* mapname can create dirs if not freshening or if renamed */
273: if ((error = mapname(!fflag || renamed)) > 1) { /* skip */
274: if ((error > 2) && (error_in_archive < 2))
275: error_in_archive = 2; /* (weak) error in zipfile */
276: continue; /* go on to next file */
277: }
278:
279: switch (check_for_newer(filename)) {
280: case DOES_NOT_EXIST:
281: if (fflag && !renamed) /* don't skip if just renamed */
282: continue; /* freshen (no new files): skip */
283: break;
284: case EXISTS_AND_OLDER:
285: if (overwrite_none)
286: continue; /* never overwrite: skip file */
287: if (!overwrite_all && !force_flag)
288: query = TRUE;
289: break;
290: case EXISTS_AND_NEWER: /* (or equal) */
291: if (overwrite_none || (uflag && !renamed))
292: continue; /* skip if update/freshen & orig name */
293: if (!overwrite_all && !force_flag)
294: query = TRUE;
295: break;
296: }
297: /*#ifndef VMS*/ /* VMS creates higher version number instead of overwriting
298: * (will have to modify for VMS-style names with specific
299: * version numbers: just check V_flag? don't use stat?) */
300: if (query) {
301: #ifdef MSWIN
302: FARPROC lpfnprocReplace;
303: int ReplaceDlgRetVal; /* replace dialog return value */
304:
305: ShowCursor(FALSE); /* turn off cursor */
306: SetCursor(hSaveCursor); /* restore the cursor */
307: lpfnprocReplace = MakeProcInstance(ReplaceProc, hInst);
308: ReplaceDlgRetVal = DialogBoxParam(hInst, "Replace",
309: hWndMain, lpfnprocReplace, (DWORD)(LPSTR)filename);
310: FreeProcInstance(lpfnprocReplace);
311: hSaveCursor = SetCursor(hHourGlass);
312: ShowCursor(TRUE);
313: switch (ReplaceDlgRetVal) {
314: case IDM_REPLACE_RENAME:
315: renamed = TRUE;
316: goto startover; /* sorry for a goto */
317: case IDM_REPLACE_YES:
318: break;
319: case IDM_REPLACE_ALL:
320: overwrite_all = TRUE;
321: overwrite_none = FALSE; /* just to make sure */
322: break;
323: case IDM_REPLACE_NONE:
324: overwrite_none = TRUE;
325: overwrite_all = FALSE; /* make sure */
326: force_flag = FALSE; /* ditto */
327: /* FALL THROUGH, skip */
328: case IDM_REPLACE_NO:
329: continue;
330: }
331: #else /* !MSWIN */
332: reprompt:
333: fprintf(stderr,
334: "replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ",
335: filename);
336: FFLUSH /* for Amiga and Mac MPW */
337: fgets(answerbuf, 9, stdin);
338: switch (*answerbuf) {
339: case 'A': /* dangerous option: force caps */
340: overwrite_all = TRUE;
341: overwrite_none = FALSE; /* just to make sure */
342: break;
343: case 'r':
344: case 'R':
345: do {
346: fprintf(stderr, "new name: ");
347: FFLUSH /* for AMIGA and Mac MPW */
348: fgets(filename, FILNAMSIZ, stdin);
349: /* usually get \n here: better check for it */
350: len = strlen(filename);
351: if (filename[len-1] == '\n')
352: filename[--len] = 0;
353: } while (len == 0);
354: renamed = TRUE;
355: goto startover; /* sorry for a goto */
356: case 'y':
357: case 'Y':
358: break;
359: case 'N':
360: overwrite_none = TRUE;
361: overwrite_all = FALSE; /* make sure */
362: force_flag = FALSE; /* ditto */
363: /* FALL THROUGH, skip */
364: case 'n':
365: continue; /* skip file */
366: default:
367: fprintf(stderr, "error: invalid response [%c]\n",
368: *answerbuf); /* warn the user */
369: goto reprompt; /* why not another goto? */
370: } /* end switch (*answerbuf) */
371: #endif /* ?MSWIN */
372: } /* end if (query) */
373: /*#endif*/ /* !VMS */
374: } /* end if (extracting to disk) */
375:
376: #ifdef CRYPT
377: if (pInfo->encrypted && ((error = decrypt_member()) != 0)) {
378: if (error == 10) {
379: if (error > error_in_archive)
380: error_in_archive = error;
381: fprintf(stderr,
382: " skipping: %-22s unable to get password\n", filename);
383: } else { /* (error == 1) */
384: fprintf(stderr,
385: " skipping: %-22s incorrect password\n", filename);
386: ++num_bad_pwd;
387: }
388: continue; /* go on to next file */
389: }
390: #endif /* CRYPT */
391: disk_full = 0;
392: if ((error = extract_or_test_member()) != 0) {
393: if (error > error_in_archive)
394: error_in_archive = error; /* ...and keep going */
395: if (disk_full > 1)
396: return error_in_archive; /* (unless disk full) */
397: }
398: } /* end for-loop (i: files in current block) */
399:
400:
401: /*
402: * Jump back to where we were in the central directory, then go and do
403: * the next batch of files.
404: */
405:
406: cur_zipfile_bufstart = lseek(zipfd, cd_bufstart, SEEK_SET);
407: read(zipfd, (char *)inbuf, INBUFSIZ); /* were there b4 ==> no error */
408: inptr = cd_inptr;
409: incnt = cd_incnt;
410: ++blknum;
411:
412: #ifdef TEST
413: printf("\ncd_bufstart = %ld (%.8lXh)\n", cd_bufstart, cd_bufstart);
414: printf("cur_zipfile_bufstart = %ld (%.8lXh)\n", cur_zipfile_bufstart,
415: cur_zipfile_bufstart);
416: printf("inptr-inbuf = %d\n", inptr-inbuf);
417: printf("incnt = %d\n\n", incnt);
418: #endif
419:
420: } /* end while-loop (blocks of files in central directory) */
421:
422: /*---------------------------------------------------------------------------
423: Double-check that we're back at the end-of-central-directory record, and
424: print quick summary of results, if we were just testing the archive. We
425: send the summary to stdout so that people doing the testing in the back-
426: ground and redirecting to a file can just do a "tail" on the output file.
427: ---------------------------------------------------------------------------*/
428:
429: readbuf(sig, 4);
430: if (strncmp(sig, end_central_sig, 4)) { /* just to make sure again */
431: fprintf(stderr, EndSigMsg); /* didn't find end-of-central-dir sig */
432: fprintf(stderr, ReportMsg); /* check binary transfers */
433: if (!error_in_archive) /* don't overwrite stronger error */
434: error_in_archive = 1; /* 1: warning error */
435: }
436: if (tflag && (quietflg == 1)) {
437: int num=filnum+1 - num_bad_pwd;
438:
439: if (error_in_archive)
440: printf("At least one error was detected in %s.\n", zipfn);
441: else if (num == 0)
442: printf("Caution: zero files tested in %s.\n", zipfn);
443: else if (process_all_files && (num_skipped+num_bad_pwd == 0))
444: printf("No errors detected in %s.\n", zipfn);
445: else
446: printf("No errors detected in %s for the %d file%s tested.\n",
447: zipfn, num, (num==1)? "":"s");
448: if (num_skipped > 0)
449: printf("%d file%s skipped because of unsupported compression or\
450: encoding.\n",
451: num_skipped, (num_skipped==1)? "":"s");
452: #ifdef CRYPT
453: if (num_bad_pwd > 0)
454: printf("%d file%s skipped because of incorrect password.\n",
455: num_bad_pwd, (num_bad_pwd==1)? "":"s");
456: #endif /* CRYPT */
457: }
458: if ((num_skipped > 0) && !error_in_archive) /* files not tested or */
459: error_in_archive = 1; /* extracted: warning */
460: #ifdef CRYPT
461: if ((num_bad_pwd > 0) && !error_in_archive) /* files not tested or */
462: error_in_archive = 1; /* extracted: warning */
463: #endif /* CRYPT */
464:
465: return (error_in_archive);
466:
467: } /* end function extract_or_test_files() */
468:
469:
470:
471:
472:
473: /***************************/
474: /* Function store_info() */
475: /***************************/
476:
477: static int store_info() /* return 1 if skipping, 0 if OK */
478: {
479: ULONG tmp;
480:
481: #define UNKN_COMPR \
482: (crec.compression_method>IMPLODED && crec.compression_method!=DEFLATED)
483: #if 0 /* old */
484: # define UNKN_COMPR (crec.compression_method>IMPLODED)
485: #endif
486:
487:
488: /*---------------------------------------------------------------------------
489: Check central directory info for version/compatibility requirements.
490: ---------------------------------------------------------------------------*/
491:
492: pInfo->encrypted = crec.general_purpose_bit_flag & 1; /* bit field */
493: pInfo->ExtLocHdr = (crec.general_purpose_bit_flag & 8) == 8; /* bit */
494: pInfo->text = crec.internal_file_attributes & 1; /* bit field */
495: pInfo->crc = crec.crc32;
496: pInfo->compr_size = crec.compressed_size;
497:
498: if (crec.version_needed_to_extract[1] == VMS_) {
499: if (crec.version_needed_to_extract[0] > VMS_VERSION) {
500: fprintf(stderr, VersionMsg, filename, "VMS",
501: crec.version_needed_to_extract[0] / 10,
502: crec.version_needed_to_extract[0] % 10,
503: VMS_VERSION / 10, VMS_VERSION % 10);
504: return 1;
505: }
506: #ifndef VMS /* won't be able to use extra field, but still have data */
507: else if (!tflag && !force_flag) { /* if forcing, extract regardless */
508: fprintf(stderr,
509: "\n%s: stored in VMS format. Extract anyway? (y/n) ",
510: filename);
511: FFLUSH /* for Amiga and Mac MPW */
512: fgets(answerbuf, 9, stdin);
513: if ((*answerbuf != 'y') && (*answerbuf != 'Y'))
514: return 1;
515: }
516: #endif /* !VMS */
517: /* usual file type: don't need VMS to extract */
518: } else if (crec.version_needed_to_extract[0] > UNZIP_VERSION) {
519: fprintf(stderr, VersionMsg, filename, "PK",
520: crec.version_needed_to_extract[0] / 10,
521: crec.version_needed_to_extract[0] % 10,
522: UNZIP_VERSION / 10, UNZIP_VERSION % 10);
523: return 1;
524: }
525:
526: if UNKN_COMPR {
527: fprintf(stderr, ComprMsg, filename, crec.compression_method);
528: return 1;
529: }
530: #ifndef CRYPT
531: if (pInfo->encrypted) {
532: fprintf(stderr, " skipping: %-22s encrypted (not supported)\n",
533: filename);
534: return 1;
535: }
536: #endif /* !CRYPT */
537:
538: /*---------------------------------------------------------------------------
539: Store some central-directory information (encryption, file attributes,
540: offsets) for later use.
541: ---------------------------------------------------------------------------*/
542:
543: tmp = crec.external_file_attributes;
544:
545: pInfo->dos_attr = 32; /* set archive bit: file is not backed up */
546: switch (pInfo->hostnum) {
547: case UNIX_:
548: case VMS_:
549: pInfo->unix_attr = (unsigned) (tmp >> 16);
550: break;
551: case DOS_OS2_FAT_:
552: case OS2_HPFS_:
553: pInfo->dos_attr = (unsigned) tmp;
554: tmp = (!(tmp & 1)) << 1; /* read-only bit */
555: pInfo->unix_attr = (unsigned) (0444 | (tmp<<6) | (tmp<<3) | tmp);
556: #ifdef UNIX
557: umask( (int)(tmp=umask(0)) );
558: pInfo->unix_attr &= ~tmp;
559: #endif
560: break;
561: case MAC_:
562: pInfo->unix_attr = (unsigned) (tmp & 1); /* read-only bit */
563: break;
564: default:
565: pInfo->unix_attr = 0666;
566: break;
567: } /* end switch (host-OS-created-by) */
568:
569: pInfo->offset = (longint) crec.relative_offset_local_header;
570: return 0;
571:
572: } /* end function store_info() */
573:
574:
575:
576:
577:
578: /***************************************/
579: /* Function extract_or_test_member() */
580: /***************************************/
581:
582: static int extract_or_test_member() /* return PK-type error code */
583: {
584: #ifdef S_IFLNK
585: int symlnk=FALSE;
586: #endif /* S_IFLNK */
587: int r, error=0;
588: UWORD b;
589:
590:
591:
592: /*---------------------------------------------------------------------------
593: Initialize variables, buffers, etc.
594: ---------------------------------------------------------------------------*/
595:
596: bits_left = 0;
597: bitbuf = 0L;
598: outpos = 0L;
599: outcnt = 0;
600: outptr = outbuf;
601: zipeof = 0;
602: crc32val = 0xFFFFFFFFL;
603:
604: #ifdef S_IFLNK
605: if ((pInfo->unix_attr & S_IFMT) == S_IFLNK && (pInfo->hostnum == UNIX_)
606: && !tflag && !cflag)
607: symlnk = TRUE;
608: #endif /* S_IFLNK */
609:
610: memset(outbuf, 0xaa, OUTBUFSIZ);
611: #if (!defined(DOS_OS2) || defined(MSWIN))
612: if (aflag) /* if we have a scratchpad, clear it out */
613: #ifdef MSWIN
614: _fmemset(outout, 0xaa, OUTBUFSIZ);
615: #else /* !MSWIN */
616: memset(outout, 0xaa, OUTBUFSIZ);
617: #endif /* ?MSWIN */
618: #endif /* !DOS_OS2 || MSWIN */
619:
620: if (tflag) {
621: if (!quietflg) {
622: fprintf(stdout, " Testing: %-22s ", filename);
623: fflush(stdout);
624: }
625: } else {
626: if (cflag) { /* output to stdout (copy of it) */
627: #if (defined(MACOS) || defined(AMIGA))
628: outfd = 1;
629: #else /* !(MACOS || AMIGA) */
630: outfd = dup(1); /* GRR: change this to #define for Mac/Amiga */
631: #endif /* ?(MACOS || AMIGA) */
632: #ifdef DOS_OS2
633: if (!aflag)
634: setmode(outfd, O_BINARY);
635: #endif /* DOS_OS2 */
636: #ifdef VMS
637: if (create_output_file()) /* VMS version required for stdout! */
638: return 50; /* 50: disk full (?) */
639: #endif
640: } else
641: #ifdef S_IFLNK
642: if (!symlnk) /* symlink() takes care of file creation */
643: #endif /* !S_IFLNK */
644: {
645: if (create_output_file())
646: return 50; /* 50: disk full (?) */
647: }
648: } /* endif (!tflag) */
649:
650: /*---------------------------------------------------------------------------
651: Unpack the file.
652: ---------------------------------------------------------------------------*/
653:
654: switch (lrec.compression_method) {
655:
656: case STORED:
657: if (!tflag && (quietflg < 2)) {
658: fprintf(stdout, " Extracting: %-22s ", filename);
659: if (cflag)
660: fprintf(stdout, "\n");
661: fflush(stdout);
662: }
663: #ifdef S_IFLNK
664: /*
665: * If file came from Unix and is a symbolic link and we are extracting
666: * to disk, allocate a storage area, put the data in it, and create the
667: * link. Since we know it's a symbolic link to start with, shouldn't
668: * have to worry about overflowing unsigned ints with unsigned longs.
669: * (This doesn't do anything for compressed symlinks, but that can be
670: * added later...it also doesn't set the time or permissions of the
671: * link, but does anyone really care?)
672: */
673: if (symlnk) {
674: #if (defined(MTS) || defined(MACOS))
675: fprintf(stdout, "\n warning: symbolic link ignored\n");
676: error = 1; /* 1: warning error */
677: #else /* !(MTS || MACOS) */
678: char *orig = (char *)malloc((unsigned)lrec.uncompressed_size+1);
679: char *p = orig;
680:
681: while (ReadByte(&b))
682: *p++ = b;
683: *p = 0; /* terminate string */
684: UpdateCRC((unsigned char *)orig, p-orig);
685: if (symlink(orig, filename))
686: if ((errno == EEXIST) && overwrite_all) { /* OK to overwrite */
687: unlink(filename);
688: if (symlink(orig, filename))
689: perror("symlink error");
690: } else
691: perror("symlink error");
692: free(orig);
693: #endif /* ?(MTS || MACOS) */
694: } else
695: #endif /* S_IFLNK */
696: while (ReadByte(&b) && !disk_full)
697: OUTB(b)
698: break;
699:
700: case SHRUNK:
701: if (!tflag && (quietflg < 2)) {
702: fprintf(stdout, "UnShrinking: %-22s ", filename);
703: if (cflag)
704: fprintf(stdout, "\n");
705: fflush(stdout);
706: }
707: #ifdef S_IFLNK /* !!! This code needs to be added to unShrink, etc. !!! */
708: if (symlnk) {
709: fprintf(stdout, "\n warning: symbolic link ignored\n");
710: error = 1; /* 1: warning error */
711: }
712: #endif /* S_IFLNK */
713: unShrink();
714: break;
715:
716: case REDUCED1:
717: case REDUCED2:
718: case REDUCED3:
719: case REDUCED4:
720: if (!tflag && (quietflg < 2)) {
721: fprintf(stdout, " Expanding: %-22s ", filename);
722: if (cflag)
723: fprintf(stdout, "\n");
724: fflush(stdout);
725: }
726: #ifdef S_IFLNK /* !!! This code needs to be added to unShrink, etc. !!! */
727: if (symlnk) {
728: fprintf(stdout, "\n warning: symbolic link ignored\n");
729: error = 1; /* 1: warning error */
730: }
731: #endif /* S_IFLNK */
732: unReduce();
733: break;
734:
735: case IMPLODED:
736: if (!tflag && (quietflg < 2)) {
737: fprintf(stdout, " Exploding: %-22s ", filename);
738: if (cflag)
739: fprintf(stdout, "\n");
740: fflush(stdout);
741: }
742: #ifdef S_IFLNK /* !!! This code needs to be added to unShrink, etc. !!! */
743: if (symlnk) {
744: fprintf(stdout, "\n warning: symbolic link ignored\n");
745: error = 1; /* 1: warning error */
746: }
747: #endif /* S_IFLNK */
748: if (((r = explode()) != 0) && (r != 5)) { /* ignore 5 if seekable */
749: if ((tflag && quietflg) || (!tflag && (quietflg > 1)))
750: fprintf(stderr, " error: %s%s\n", r == 3?
751: "not enough memory to explode " :
752: "invalid compressed (imploded) data for ", filename);
753: else
754: fprintf(stderr, "\n error: %s\n", r == 3?
755: "not enough memory for explode operation" :
756: "invalid compressed data for explode format");
757: error = (r == 3)? 5 : 2;
758: }
759: break;
760:
761: case DEFLATED:
762: if (!tflag && (quietflg < 2)) {
763: fprintf(stdout, " Inflating: %-22s ", filename);
764: if (cflag)
765: fprintf(stdout, "\n");
766: fflush(stdout);
767: }
768: #ifdef S_IFLNK /* !!! This code needs to be added to unShrink, etc. !!! */
769: if (symlnk) {
770: fprintf(stdout, "\n warning: symbolic link ignored\n");
771: error = 1; /* 1: warning error */
772: }
773: #endif /* S_IFLNK */
774: if ((r = inflate()) != 0) {
775: if ((tflag && quietflg) || (!tflag && (quietflg > 1)))
776: fprintf(stderr, " error: %s%s\n", r == 3?
777: "not enough memory to inflate " :
778: "invalid compressed (deflated) data for ", filename);
779: else
780: fprintf(stderr, "\n error: %s\n", r == 3?
781: "not enough memory for inflate operation" :
782: "invalid compressed data for inflate format");
783: error = (r == 3)? 5 : 2;
784: }
785: break;
786:
787: default: /* should never get to this point */
788: fprintf(stderr, "%s: unknown compression method\n", filename);
789: /* close and delete file before return? */
790: return 1; /* 1: warning error */
791:
792: } /* end switch (compression method) */
793:
794: if (disk_full) { /* set by FlushOutput()/OUTB() macro */
795: if (disk_full > 1)
796: return 50; /* 50: disk full */
797: error = 1; /* 1: warning error */
798: }
799:
800: /*---------------------------------------------------------------------------
801: Write the last partial buffer, if any; set the file date and time; and
802: close the file (not necessarily in that order). Then make sure CRC came
803: out OK and print result.
804: ---------------------------------------------------------------------------*/
805:
806: #ifdef S_IFLNK
807: if (!symlnk) {
808: #endif /* S_IFLNK */
809: if (!disk_full && FlushOutput())
810: if (disk_full > 1)
811: return 50; /* 50: disk full */
812: else { /* disk_full == 1 */
813: fprintf(stderr, "%s: probably corrupt\n", filename);
814: error = 1; /* 1: warning error */
815: }
816:
817: if (!tflag)
818: #ifdef VMS
819: CloseOutputFile();
820: #else /* !VMS */
821: #ifdef MTS /* MTS can't set file time */
822: close(outfd);
823: #else /* !MTS */
824: set_file_time_and_close();
825: #endif /* ?MTS */
826: #endif /* ?VMS */
827:
828: #ifdef S_IFLNK
829: } /* endif (!symlnk) */
830: #endif /* S_IFLNK */
831:
832: if (error > 1) /* don't print redundant CRC error if error already */
833: return error;
834:
835: /* logical-AND crc32val for 64-bit machines */
836: if ((crc32val = ((~crc32val) & 0xFFFFFFFFL)) != lrec.crc32) {
837: /* if quietflg is set, we haven't output the filename yet: do it */
838: if (quietflg)
839: printf("%-22s: ", filename);
840: fprintf(stdout, " Bad CRC %08lx (should be %08lx)\n", crc32val,
841: lrec.crc32);
842: error = 1; /* 1: warning error */
843: } else if (tflag) {
844: if (!quietflg)
845: fprintf(stdout, " OK\n");
846: } else {
847: if ((quietflg < 2) && !error)
848: fprintf(stdout, "\n");
849: }
850:
851: return error;
852:
853: } /* end function extract_or_test_member() */
854:
855:
856:
857:
858:
859: #ifdef CRYPT
860:
861: /*******************************/
862: /* Function decrypt_member() */
863: /*******************************/
864:
865: static int decrypt_member() /* return 10 if out of memory or can't get */
866: { /* tty; 1 if password bad; 0 if password OK */
867: UWORD b;
868: int n, r;
869: static int nopwd=FALSE;
870: char *m, *prompt;
871: byte h[12];
872:
873:
874: /* get header once (turn off "encrypted" flag temporarily so we don't
875: * try to decrypt the same data twice) */
876: pInfo->encrypted = FALSE;
877: for (n = 0; n < 12; n++) {
878: ReadByte(&b);
879: h[n] = (byte) b;
880: }
881: pInfo->encrypted = TRUE;
882:
883: /* if have key already, test it; else allocate memory for it */
884: if (key) {
885: if (!testp(h))
886: return 0; /* existing password OK (else prompt for new) */
887: else if (nopwd)
888: return 1; /* user indicated no more prompting */
889: } else if ((key = (char *)malloc(PWLEN+1)) == (char *)NULL)
890: return 10;
891:
892: if ((prompt = (char *)malloc(FILNAMSIZ+15)) != (char *)NULL) {
893: sprintf(prompt, "%s password: ", filename);
894: m = prompt;
895: } else
896: m = "Enter password: ";
897:
898: /* try a few keys */
899: for (r = 0; r < 3; ++r) {
900: m = getp(m, key, PWLEN+1);
901: if (prompt != (char *)NULL) {
902: free(prompt);
903: prompt = (char *)NULL;
904: }
905: if (m == (char *)NULL)
906: return 10;
907: if (!testp(h))
908: return 0;
909: if (*key == '\0') {
910: nopwd = TRUE;
911: return 1;
912: }
913: m = "password incorrect--reenter: ";
914: }
915: return 1;
916: }
917:
918:
919:
920:
921:
922: /**********************/
923: /* Function testp() */
924: /**********************/
925:
926: static int testp(h) /* return -1 if bad password; 0 if OK */
927: byte *h;
928: {
929: UWORD b;
930: int n, t;
931: byte *p;
932:
933: /* set keys */
934: init_keys(key);
935:
936: /* check password */
937: for (n = 0; n < 12; n++)
938: b = DECRYPT(h[n]);
939:
940: #ifdef CRYPT_DEBUG
941: printf(" lrec.crc = %08lx crec.crc = %08lx pInfo->ExtLocHdr = %s\n",
942: lrec.crc32, pInfo->crc, pInfo->ExtLocHdr? "true":"false");
943: printf(" incnt = %d unzip offset into zipfile = %ld\n", incnt,
944: cur_zipfile_bufstart+(inptr-inbuf));
945: printf(" b = %02x (crc >> 24) = %02x (lrec.time >> 8) = %02x\n",
946: b, (UWORD)(lrec.crc32 >> 24), (lrec.last_mod_file_time >> 8));
947: #endif /* CRYPT_DEBUG */
948:
949: /* same test as in zipbare() in crypt.c (now check only one byte): */
950: if (b != (pInfo->ExtLocHdr? lrec.last_mod_file_time >> 8 :
951: (UWORD)(lrec.crc32 >> 24)))
952: return -1; /* bad */
953:
954: /* password OK: decrypt current buffer contents before leaving */
955: for (n = (longint)incnt > csize ? (int)csize : incnt, p = inptr; n--; p++)
956: *p = (byte) DECRYPT(*p);
957: return 0; /* OK */
958:
959: } /* end function testp() */
960:
961: #endif /* CRYPT */
962:
963:
964:
965:
966:
967: /*******************************/
968: /* Function ReadMemoryByte() */
969: /*******************************/
970:
971: int ReadMemoryByte(x) /* return PK-type error code */
972: UWORD *x;
973: {
974: if (mem_i_offset < mem_i_size) {
975: *x = (UWORD) mem_i_buffer[mem_i_offset++];
976: return 8;
977: } else
978: return 0;
979: }
980:
981:
982:
983:
984:
985: /****************************/
986: /* Function FlushMemory() */
987: /****************************/
988:
989: int FlushMemory() /* return PK-type error code */
990: {
991: if (outcnt == 0)
992: return 0;
993:
994: if (mem_o_offset + outcnt <= mem_o_size) {
995: memcpy((char *)(mem_o_buffer+(UWORD)mem_o_offset), (char *)outbuf,
996: outcnt);
997: mem_o_offset += outcnt;
998: return 0;
999: } else
1000: return 50;
1001: }
1002:
1003:
1004:
1005:
1006:
1007: /***************************/
1008: /* Function memextract() */ /* extract compressed extra field block */
1009: /***************************/
1010:
1011: int memextract(tgt, tgtsize, src, srcsize) /* return 0 if success, 1 if not */
1012: byte *tgt, *src;
1013: ULONG tgtsize, srcsize;
1014: {
1015: UWORD method, error = 0;
1016: ULONG crc, oldcrc;
1017: int r;
1018:
1019: method = makeword(src);
1020: crc = makelong(src+2);
1021:
1022: mem_i_buffer = src + 2 + 4; /* method and crc */
1023: mem_i_size = srcsize - 2 - 4;
1024: mem_i_offset = 0;
1025:
1026: mem_o_buffer = tgt;
1027: mem_o_size = tgtsize;
1028: mem_o_offset = 0;
1029:
1030: mem_mode = 1;
1031:
1032: bits_left = 0;
1033: bitbuf = 0L;
1034: outpos = 0L;
1035: outcnt = 0;
1036: outptr = outbuf;
1037: zipeof = 0;
1038:
1039: switch (method) {
1040: case STORED:
1041: memcpy(tgt, src + 2 + 4, (extent) (srcsize - 2 - 4));
1042: break;
1043: case DEFLATED:
1044: if ((r = inflate()) != 0) {
1045: fprintf(stderr, "error: %s\n", r == 3 ?
1046: "not enough memory for inflate operation" :
1047: "invalid compressed data for the inflate format");
1048: error = (r == 3)? 5 : 2;
1049: }
1050: FlushOutput();
1051: break;
1052: default:
1053: fprintf(stderr,
1054: "warning: unsupported extra field compression type--skipping\n");
1055: error = 1; /* GRR: this should be passed on up via SetEAs() */
1056: break;
1057: }
1058:
1059: mem_mode = 0;
1060:
1061: if (!error) {
1062: oldcrc = crc32val;
1063: crc32val = 0xFFFFFFFFL;
1064: UpdateCRC((unsigned char *) mem_o_buffer, (int) mem_o_size);
1065: crc32val = (~crc32val) & 0xFFFFFFFFL;
1066:
1067: if (crc32val != crc) {
1068: printf("(Bad extra field CRC %08lx, should be %08lx)\n", crc32val,
1069: crc);
1070: error = 1;
1071: }
1072: crc32val = oldcrc; /* grrr ... this ugly kludge should be fixed */
1073: }
1074:
1075: return error;
1076: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.