home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / unzip50 / part02 < prev    next >
Encoding:
Text File  |  1992-08-22  |  58.1 KB  |  1,534 lines
  1. Newsgroups: comp.sources.misc
  2. From: zip-bugs@cs.ucla.edu (Info-ZIP group)
  3. Subject:  v31i105:  unzip50 - Info-ZIP portable UnZip, version 5.0, Part02/14
  4. Message-ID: <1992Aug24.025225.24144@sparky.imd.sterling.com>
  5. X-Md4-Signature: 67455a16af9b9121c5ef733b92dfe9e3
  6. Date: Mon, 24 Aug 1992 02:52:25 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: zip-bugs@cs.ucla.edu (Info-ZIP group)
  10. Posting-number: Volume 31, Issue 105
  11. Archive-name: unzip50/part02
  12. Supersedes: unzip: Volume 29, Issue 31-42
  13. Environment: UNIX, VMS, OS/2, MS-DOS, MACINTOSH, WIN-NT, LINUX, MINIX, COHERENT AMIGA?, !ATARI, symlink, SGI, DEC, Cray, Convex, Amdahl, Sun
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  MAC/aztec.make.UU extract.c mapname.c
  22. # Wrapped by kent@sparky on Sun Aug 23 21:09:31 1992
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 2 (of 14)."'
  26. if test -f 'MAC/aztec.make.UU' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'MAC/aztec.make.UU'\"
  28. else
  29.   echo shar: Extracting \"'MAC/aztec.make.UU'\" \(1805 characters\)
  30.   sed "s/^X//" >'MAC/aztec.make.UU' <<'END_OF_FILE'
  31. Xbegin 666 MAC/aztec.make
  32. XM(R @(%1H:7,@35!7(&UA:V5F:6QE(&ES(&1E<VEG;F5D('1O(&)E('5S960@
  33. XM=&\@8V]M<&EL92!A;B!-4%<@=F5R<VEO;@HC(" @;V8@=6YZ:7 @=7-I;F<@
  34. XM=&AE($%Z=&5C($,@8V]M<&EL97(L('9E<G-I;VX@-2XR82X@4VEM<&QY(')E
  35. XM;F%M90HC(" @=&AI<R!F:6QE(&%S('5N>FEP+FUA:V4@86YD(&1O(&%N($U0
  36. XM5R!B=6EL9"X*"@HC(" @1FEL93H@(" @(" @=6YZ:7 N;6%K90HC(" @5&%R
  37. XM9V5T.B @(" @56YZ:7 *(R @(%-O=7)C97,Z(" @('5N>FEP+F,*(R @(" @
  38. XM(" @(" @(" @(&-R>7!T+F,*(R @(" @(" @(" @(" @(&5N=F%R9W,N8PHC
  39. XM(" @(" @(" @(" @(" @97AP;&]D92YC"B,@(" @(" @(" @(" @("!E>'1R
  40. XM86-T+F,*(R @(" @(" @(" @(" @(&9I;&5?:6\N8PHC(" @(" @(" @(" @
  41. XM(" @:6YF;&%T92YC"B,@(" @(" @(" @(" @("!M86-F:6QE+F,*(R @(" @
  42. XM(" @(" @(" @(&UA8W-T870N8PHC(" @(" @(" @(" @(" @;6%P;F%M92YC
  43. XM"B,@(" @(" @(" @(" @("!M871C:"YC"B,@(" @(" @(" @(" @("!M:7-C
  44. XM+F,*(R @(" @(" @(" @(" @('5N<F5D=6-E+F,*(R @(" @(" @(" @(" @
  45. XM('5N<VAR:6YK+F,*(R @($-R96%T960Z(" @(%1U97-D87DL($UA>2 U+" Q
  46. XM.3DR(#<Z,#4Z,# @4$T*"@I#1DQ!1U,@/2 M9"!-4%<@(R M9"!#4EE05 H*
  47. XM3$9,04=3(#T@+6T*"@HN;R#$("YC('5N>FEP+F@@=6YZ:7 N;6%K90H@(" @
  48. XM(" @($,@>T-&3$%'4WT@+6\@>T1E9F%U;'1]+F\@>T1E9F%U;'1]+F,*"BYO
  49. XM(,0@+F%S;0H@(" @(" @(&%S("UO('M$969A=6QT?2YO('M$969A=6QT?2YA
  50. XM<VT*"D]"2D5#5%,@/2"V"B @(" @(" @=6YZ:7 N;R"V"B,@(" @(" @8W)Y
  51. XM<'0N;R"V"B @(" @(" @96YV87)G<RYO(+8*(" @(" @("!E>'!L;V1E+F\@
  52. XMM@H@(" @(" @(&5X=')A8W0N;R"V"B @(" @(" @9FEL95]I;RYO(+8*(" @
  53. XM(" @("!I;F9L871E+F\@M@H@(" @(" @(&UA8V9I;&4N;R"V"B @(" @(" @
  54. XM;6%C<W1A="YO(+8*(" @(" @("!M87!N86UE+F\@M@H@(" @(" @(&UA=&-H
  55. XM+F\@M@H@(" @(" @(&UI<V,N;R"V"B @(" @(" @=6YR961U8V4N;R"V"B @
  56. XM(" @(" @=6YS:')I;FLN;PH*56YZ:7 @Q"![3T)*14-44WT@=6YZ:7 N<@H@
  57. XM(" @(" @(&QN('M,1DQ!1U-]("UO(%5N>FEP('M/0DI%0U13?2 M;&T@+6QM
  58. XM<'<@+6QC"B @(" @(" @<F5Z("UA<'!E;F0@+6\@56YZ:7 @=6YZ:7 N<@H*
  59. XM=6YZ:7 N<B#$('5N>FEP+G1H:6YK8RYR<W)C"B @(" @(" @9&5R97H@=6YZ
  60. X9:7 N=&AI;FMC+G)S<F,@/B!U;GII<"YR"G)C
  61. X 
  62. Xend
  63. END_OF_FILE
  64.  if test 1805 -ne `wc -c <'MAC/aztec.make.UU'`; then
  65.     echo shar: \"'MAC/aztec.make.UU'\" unpacked with wrong size!
  66.   else
  67.     echo shar: Uudecoding \"'MAC/aztec.make'\" \(1285 characters\)
  68.     cat MAC/aztec.make.UU | uudecode
  69.     if test 1285 -ne `wc -c <'MAC/aztec.make'`; then
  70.       echo shar: \"'MAC/aztec.make'\" uudecoded with wrong size!
  71.     else
  72.       rm MAC/aztec.make.UU
  73.     fi
  74.   fi
  75.   # end of 'MAC/aztec.make.UU'
  76. fi
  77. if test -f 'extract.c' -a "${1}" != "-c" ; then 
  78.   echo shar: Will not clobber existing file \"'extract.c'\"
  79. else
  80.   echo shar: Extracting \"'extract.c'\" \(37529 characters\)
  81.   sed "s/^X//" >'extract.c' <<'END_OF_FILE'
  82. X/*---------------------------------------------------------------------------
  83. X
  84. X  extract.c
  85. X
  86. X  This file contains the high-level routines ("driver routines") for extrac-
  87. X  ting and testing zipfile members.  It calls the low-level routines in files
  88. X  inflate.c, unimplod.c, unreduce.c and unshrink.c.
  89. X
  90. X  ---------------------------------------------------------------------------*/
  91. X
  92. X
  93. X#include "unzip.h"
  94. X#ifdef  MSWIN
  95. X#  include "wizunzip.h"
  96. X#  include "replace.h"
  97. X#endif /* MSWIN */
  98. X
  99. X
  100. X/************************************/
  101. X/*  Extract Local Prototypes, etc.  */
  102. X/************************************/
  103. X
  104. Xstatic int store_info __((void));
  105. Xstatic int extract_or_test_member __((void));
  106. X#ifdef CRYPT
  107. X   static int decrypt_member __((void));
  108. X   static int testp __((byte *hdr));
  109. X#endif
  110. X
  111. Xstatic byte *mem_i_buffer;
  112. Xstatic byte *mem_o_buffer;
  113. Xstatic ULONG mem_i_size, mem_i_offset;
  114. Xstatic ULONG mem_o_size, mem_o_offset;
  115. X
  116. Xstatic char *VersionMsg =
  117. X  " skipping: %-22s  need %s compat. v%u.%u (can do v%u.%u)\n";
  118. Xstatic char *ComprMsg =
  119. X  " skipping: %-22s  compression method %d\n";
  120. Xstatic char *FilNamMsg =
  121. X  "%s:  bad filename length (%s)\n";
  122. Xstatic char *ExtFieldMsg =
  123. X  "%s:  bad extra field length (%s)\n";
  124. Xstatic char *OffsetMsg =
  125. X  "file #%d:  bad zipfile offset (%s)\n";
  126. X
  127. X
  128. X
  129. X
  130. X
  131. X/**************************************/
  132. X/*  Function extract_or_test_files()  */
  133. X/**************************************/
  134. X
  135. Xint extract_or_test_files()    /* return PK-type error code */
  136. X{
  137. X    char **fnamev;
  138. X    byte *cd_inptr;
  139. X    int cd_incnt, error, error_in_archive=0;
  140. X    int renamed, query, len, filnum=(-1), blknum=0;
  141. X#ifdef OS2
  142. X    extern int longname;  /* from os2unzip.c */
  143. X#endif
  144. X    UWORD i, j, members_remaining, num_skipped=0, num_bad_pwd=0;
  145. X    longint cd_bufstart, bufstart, inbuf_offset, request;
  146. X    min_info info[DIR_BLKSIZ];
  147. X
  148. X
  149. X/*---------------------------------------------------------------------------
  150. X    The basic idea of this function is as follows.  Since the central di-
  151. X    rectory lies at the end of the zipfile and the member files lie at the
  152. X    beginning or middle or wherever, it is not very desirable to simply
  153. X    read a central directory entry, jump to the member and extract it, and
  154. X    then jump back to the central directory.  In the case of a large zipfile
  155. X    this would lead to a whole lot of disk-grinding, especially if each mem-
  156. X    ber file is small.  Instead, we read from the central directory the per-
  157. X    tinent information for a block of files, then go extract/test the whole
  158. X    block.  Thus this routine contains two small(er) loops within a very
  159. X    large outer loop:  the first of the small ones reads a block of files
  160. X    from the central directory; the second extracts or tests each file; and
  161. X    the outer one loops over blocks.  There's some file-pointer positioning
  162. X    stuff in between, but that's about it.  Btw, it's because of this jump-
  163. X    ing around that we can afford to be lenient if an error occurs in one of
  164. X    the member files:  we should still be able to go find the other members,
  165. X    since we know the offset of each from the beginning of the zipfile.
  166. X
  167. X    Begin main loop over blocks of member files.  We know the entire central
  168. X    directory is on this disk:  we would not have any of this information un-
  169. X    less the end-of-central-directory record was on this disk, and we would
  170. X    not have gotten to this routine unless this is also the disk on which
  171. X    the central directory starts.  In practice, this had better be the ONLY
  172. X    disk in the archive, but maybe someday we'll add multi-disk support.
  173. X  ---------------------------------------------------------------------------*/
  174. X
  175. X    pInfo = info;
  176. X    members_remaining = ecrec.total_entries_central_dir;
  177. X
  178. X    while (members_remaining) {
  179. X        j = 0;
  180. X
  181. X        /*
  182. X         * Loop through files in central directory, storing offsets, file
  183. X         * attributes, and case-conversion flags until block size is reached.
  184. X         */
  185. X
  186. X        while (members_remaining && (j < DIR_BLKSIZ)) {
  187. X            --members_remaining;
  188. X            pInfo = &info[j];
  189. X
  190. X            if (readbuf(sig, 4) <= 0) {
  191. X                error_in_archive = 51;  /* 51:  unexpected EOF */
  192. X                members_remaining = 0;  /* ...so no more left to do */
  193. X                break;
  194. X            }
  195. X            if (strncmp(sig, central_hdr_sig, 4)) {  /* just to make sure */
  196. X                fprintf(stderr, CentSigMsg, j);  /* sig not found */
  197. X                fprintf(stderr, ReportMsg);   /* check binary transfers */
  198. X                error_in_archive = 3;   /* 3:  error in zipfile */
  199. X                members_remaining = 0;  /* ...so no more left to do */
  200. X                break;
  201. X            }
  202. X            /* process_cdir_file_hdr() sets pInfo->hostnum, pInfo->lcflag */
  203. X            if ((error = process_cdir_file_hdr()) != 0) {
  204. X                error_in_archive = error;   /* only 51 (EOF) defined */
  205. X                members_remaining = 0;  /* ...so no more left to do */
  206. X                break;
  207. X            }
  208. X            if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
  209. X                if (error > error_in_archive)
  210. X                    error_in_archive = error;
  211. X                if (error > 1) {  /* fatal:  no more left to do */
  212. X                    fprintf(stderr, FilNamMsg, filename, "central");
  213. X                    members_remaining = 0;
  214. X                    break;
  215. X                }
  216. X            }
  217. X            if ((error = do_string(crec.extra_field_length, EXTRA_FIELD)) != 0)
  218. X            {
  219. X                if (error > error_in_archive)
  220. X                    error_in_archive = error;
  221. X                if (error > 1) {  /* fatal */
  222. X                    fprintf(stderr, ExtFieldMsg, filename, "central");
  223. X                    members_remaining = 0;
  224. X                    break;
  225. X                }
  226. X            }
  227. X            if ((error = do_string(crec.file_comment_length, SKIP)) != 0) {
  228. X                if (error > error_in_archive)
  229. X                    error_in_archive = error;
  230. X                if (error > 1) {  /* fatal */
  231. X                    fprintf(stderr, "\n%s:  bad file comment length\n",
  232. X                            filename);
  233. X                    members_remaining = 0;
  234. X                    break;
  235. X                }
  236. X            }
  237. X            if (process_all_files) {
  238. X                if (store_info())
  239. X                    ++num_skipped;
  240. X                else
  241. X                    ++j;  /* file is OK: save info[] and continue with next */
  242. X            } else {
  243. X                fnamev = fnv;   /* don't destroy permanent filename pointer */
  244. X                for (--fnamev; *++fnamev;)
  245. X                    if (match(filename, *fnamev)) {
  246. X                        if (store_info())
  247. X                            ++num_skipped;
  248. X                        else
  249. X                            ++j;   /* file is OK */
  250. X                        break;  /* found match for filename, so stop looping */
  251. X                    } /* end if (match), for-loop (fnamev) */
  252. X            } /* end if (process_all_files) */
  253. X
  254. X        } /* end while-loop (adding files to current block) */
  255. X
  256. X        /* save position in central directory so can come back later */
  257. X        cd_bufstart = cur_zipfile_bufstart;
  258. X        cd_inptr = inptr;
  259. X        cd_incnt = incnt;
  260. X
  261. X    /*-----------------------------------------------------------------------
  262. X        Second loop:  process files in current block, extracting or testing
  263. X        each one.
  264. X      -----------------------------------------------------------------------*/
  265. X
  266. X        for (i = 0; i < j; ++i) {
  267. X            filnum = i + blknum*DIR_BLKSIZ;
  268. X            pInfo = &info[i];
  269. X            /*
  270. X             * if the target position is not within the current input buffer
  271. X             * (either haven't yet read far enough, or (maybe) skipping back-
  272. X             * ward) skip to the target position and reset readbuf().
  273. X             */
  274. X            /* LSEEK(pInfo->offset):  */
  275. X            request = pInfo->offset + extra_bytes;
  276. X            inbuf_offset = request % INBUFSIZ;
  277. X            bufstart = request - inbuf_offset;
  278. X
  279. X            if (request < 0) {
  280. X                fprintf(stderr, SeekMsg, ReportMsg);
  281. X                error_in_archive = 3;       /* 3:  severe error in zipfile, */
  282. X                continue;                   /*  but can still go on */
  283. X            } else if (bufstart != cur_zipfile_bufstart) {
  284. X                cur_zipfile_bufstart = lseek(zipfd, bufstart, SEEK_SET);
  285. X                if ((incnt = read(zipfd,(char *)inbuf,INBUFSIZ)) <= 0) {
  286. X                    fprintf(stderr, OffsetMsg, filnum, "lseek");
  287. X                    error_in_archive = 3;   /* 3:  error in zipfile, but */
  288. X                    continue;               /*  can still do next file   */
  289. X                }
  290. X                inptr = inbuf + (int)inbuf_offset;
  291. X                incnt -= (int)inbuf_offset;
  292. X            } else {
  293. X                incnt += (inptr-inbuf) - (int)inbuf_offset;
  294. X                inptr = inbuf + (int)inbuf_offset;
  295. X            }
  296. X
  297. X            /* should be in proper position now, so check for sig */
  298. X            if (readbuf(sig, 4) <= 0) {  /* bad offset */
  299. X                fprintf(stderr, OffsetMsg, filnum, "EOF");
  300. X                error_in_archive = 3;    /* 3:  error in zipfile */
  301. X                continue;       /* but can still try next one */
  302. X            }
  303. X            if (strncmp(sig, local_hdr_sig, 4)) {
  304. X                fprintf(stderr, OffsetMsg, filnum,
  305. X                        "can't find local header sig");   /* bad offset */
  306. X                error_in_archive = 3;
  307. X                continue;
  308. X            }
  309. X            if ((error = process_local_file_hdr()) != 0) {
  310. X                fprintf(stderr, "\nfile #%d:  bad local header\n", filnum);
  311. X                error_in_archive = error;       /* only 51 (EOF) defined */
  312. X                continue;       /* can still try next one */
  313. X            }
  314. X            if ((error = do_string(lrec.filename_length, FILENAME)) != 0) {
  315. X                if (error > error_in_archive)
  316. X                    error_in_archive = error;
  317. X                if (error > 1) {
  318. X                    fprintf(stderr, FilNamMsg, filename, "local");
  319. X                    continue;   /* go on to next one */
  320. X                }
  321. X            }
  322. X            if (extra_field != (byte *)NULL)
  323. X                free(extra_field);
  324. X            extra_field = (byte *)NULL;
  325. X            if ((error = do_string(lrec.extra_field_length, EXTRA_FIELD)) != 0)
  326. X            {
  327. X                if (error > error_in_archive)
  328. X                    error_in_archive = error;
  329. X                if (error > 1) {
  330. X                    fprintf(stderr, ExtFieldMsg, filename, "local");
  331. X                    continue;   /* go on */
  332. X                }
  333. X            }
  334. X
  335. X            /*
  336. X             * just about to extract file:  if extracting to disk, check if
  337. X             * already exists, and if so, take appropriate action according to
  338. X             * fflag/uflag/overwrite_all/etc. (we couldn't do this in upper
  339. X             * loop because we don't store the possibly renamed filename[] in
  340. X             * info[])
  341. X             */
  342. X            if (!tflag && !cflag) {
  343. X                renamed = FALSE;   /* user hasn't renamed output file yet */
  344. X#ifdef OS2
  345. X                longname = FALSE;  /* no long name has yet been stored */
  346. X#endif
  347. X
  348. Xstartover:
  349. X                query = FALSE;
  350. X#ifdef MACOS
  351. X                macflag = (pInfo->hostnum == MAC_);
  352. X#endif
  353. X                /* mapname can create dirs if not freshening or if renamed */
  354. X                if ((error = mapname(!fflag || renamed)) > 1) {    /* skip */
  355. X                    if ((error > 2) && (error_in_archive < 2))
  356. X                        error_in_archive = 2;   /* (weak) error in zipfile */
  357. X                    continue;   /* go on to next file */
  358. X                }
  359. X
  360. X                switch (check_for_newer(filename)) {
  361. X                    case DOES_NOT_EXIST:
  362. X                        if (fflag && !renamed)  /* don't skip if just renamed */
  363. X                            continue;   /* freshen (no new files):  skip */
  364. X                        break;
  365. X                    case EXISTS_AND_OLDER:
  366. X                        if (overwrite_none)
  367. X                            continue;   /* never overwrite:  skip file */
  368. X                        if (!overwrite_all && !force_flag)
  369. X                            query = TRUE;
  370. X                        break;
  371. X                    case EXISTS_AND_NEWER:             /* (or equal) */
  372. X                        if (overwrite_none || (uflag && !renamed))
  373. X                            continue;  /* skip if update/freshen & orig name */
  374. X                        if (!overwrite_all && !force_flag)
  375. X                            query = TRUE;
  376. X                        break;
  377. X                }
  378. X/*#ifndef VMS*/ /* VMS creates higher version number instead of overwriting
  379. X                 * (will have to modify for VMS-style names with specific
  380. X                 *  version numbers:  just check V_flag?  don't use stat?) */
  381. X                if (query) {
  382. X#ifdef MSWIN
  383. X                    FARPROC lpfnprocReplace;
  384. X                    int ReplaceDlgRetVal;   /* replace dialog return value */
  385. X
  386. X                    ShowCursor(FALSE);      /* turn off cursor */
  387. X                    SetCursor(hSaveCursor); /* restore the cursor */
  388. X                    lpfnprocReplace = MakeProcInstance(ReplaceProc, hInst);
  389. X                    ReplaceDlgRetVal = DialogBoxParam(hInst, "Replace",
  390. X                      hWndMain, lpfnprocReplace, (DWORD)(LPSTR)filename);
  391. X                    FreeProcInstance(lpfnprocReplace);
  392. X                    hSaveCursor = SetCursor(hHourGlass);
  393. X                    ShowCursor(TRUE);
  394. X                    switch (ReplaceDlgRetVal) {
  395. X                        case IDM_REPLACE_RENAME:
  396. X                            renamed = TRUE;
  397. X                            goto startover;   /* sorry for a goto */
  398. X                        case IDM_REPLACE_YES:
  399. X                            break;
  400. X                        case IDM_REPLACE_ALL:
  401. X                            overwrite_all = TRUE;
  402. X                            overwrite_none = FALSE;  /* just to make sure */
  403. X                            break;
  404. X                        case IDM_REPLACE_NONE:
  405. X                            overwrite_none = TRUE;
  406. X                            overwrite_all = FALSE;  /* make sure */
  407. X                            force_flag = FALSE;     /* ditto */
  408. X                            /* FALL THROUGH, skip */
  409. X                        case IDM_REPLACE_NO:
  410. X                            continue;
  411. X                    }
  412. X#else /* !MSWIN */
  413. Xreprompt:
  414. X                    fprintf(stderr,
  415. X                      "replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ",
  416. X                      filename);
  417. X                    FFLUSH   /* for Amiga and Mac MPW */
  418. X                    fgets(answerbuf, 9, stdin);
  419. X                    switch (*answerbuf) {
  420. X                        case 'A':   /* dangerous option:  force caps */
  421. X                            overwrite_all = TRUE;
  422. X                            overwrite_none = FALSE;  /* just to make sure */
  423. X                            break;
  424. X                        case 'r':
  425. X                        case 'R':
  426. X                            do {
  427. X                                fprintf(stderr, "new name: ");
  428. X                                FFLUSH   /* for AMIGA and Mac MPW */
  429. X                                fgets(filename, FILNAMSIZ, stdin);
  430. X                                /* usually get \n here:  better check for it */
  431. X                                len = strlen(filename);
  432. X                                if (filename[len-1] == '\n')
  433. X                                    filename[--len] = 0;
  434. X                            } while (len == 0);
  435. X                            renamed = TRUE;
  436. X                            goto startover;   /* sorry for a goto */
  437. X                        case 'y':
  438. X                        case 'Y':
  439. X                            break;
  440. X                        case 'N':
  441. X                            overwrite_none = TRUE;
  442. X                            overwrite_all = FALSE;  /* make sure */
  443. X                            force_flag = FALSE;     /* ditto */
  444. X                            /* FALL THROUGH, skip */
  445. X                        case 'n':
  446. X                            continue;   /* skip file */
  447. X                        default:
  448. X                            fprintf(stderr, "error:  invalid response [%c]\n",
  449. X                              *answerbuf);   /* warn the user */
  450. X                            goto reprompt;   /* why not another goto? */
  451. X                    } /* end switch (*answerbuf) */
  452. X#endif /* ?MSWIN */
  453. X                } /* end if (query) */
  454. X/*#endif*/ /* !VMS */
  455. X            } /* end if (extracting to disk) */
  456. X
  457. X#ifdef CRYPT
  458. X            if (pInfo->encrypted && ((error = decrypt_member()) != 0)) {
  459. X                if (error == 10) {
  460. X                    if (error > error_in_archive)
  461. X                        error_in_archive = error;
  462. X                    fprintf(stderr,
  463. X                      " skipping: %-22s  unable to get password\n", filename);
  464. X                } else {  /* (error == 1) */
  465. X                    fprintf(stderr,
  466. X                      " skipping: %-22s  incorrect password\n", filename);
  467. X                    ++num_bad_pwd;
  468. X                }
  469. X                continue;   /* go on to next file */
  470. X            }
  471. X#endif /* CRYPT */
  472. X            disk_full = 0;
  473. X            if ((error = extract_or_test_member()) != 0) {
  474. X                if (error > error_in_archive)
  475. X                    error_in_archive = error;       /* ...and keep going */
  476. X                if (disk_full > 1)
  477. X                    return error_in_archive;        /* (unless disk full) */
  478. X            }
  479. X        } /* end for-loop (i:  files in current block) */
  480. X
  481. X
  482. X        /*
  483. X         * Jump back to where we were in the central directory, then go and do
  484. X         * the next batch of files.
  485. X         */
  486. X
  487. X        cur_zipfile_bufstart = lseek(zipfd, cd_bufstart, SEEK_SET);
  488. X        read(zipfd, (char *)inbuf, INBUFSIZ);  /* were there b4 ==> no error */
  489. X        inptr = cd_inptr;
  490. X        incnt = cd_incnt;
  491. X        ++blknum;
  492. X
  493. X#ifdef TEST
  494. X        printf("\ncd_bufstart = %ld (%.8lXh)\n", cd_bufstart, cd_bufstart);
  495. X        printf("cur_zipfile_bufstart = %ld (%.8lXh)\n", cur_zipfile_bufstart,
  496. X          cur_zipfile_bufstart);
  497. X        printf("inptr-inbuf = %d\n", inptr-inbuf);
  498. X        printf("incnt = %d\n\n", incnt);
  499. X#endif
  500. X
  501. X    } /* end while-loop (blocks of files in central directory) */
  502. X
  503. X/*---------------------------------------------------------------------------
  504. X    Double-check that we're back at the end-of-central-directory record, and
  505. X    print quick summary of results, if we were just testing the archive.  We
  506. X    send the summary to stdout so that people doing the testing in the back-
  507. X    ground and redirecting to a file can just do a "tail" on the output file.
  508. X  ---------------------------------------------------------------------------*/
  509. X
  510. X    readbuf(sig, 4);
  511. X    if (strncmp(sig, end_central_sig, 4)) {     /* just to make sure again */
  512. X        fprintf(stderr, EndSigMsg);  /* didn't find end-of-central-dir sig */
  513. X        fprintf(stderr, ReportMsg);  /* check binary transfers */
  514. X        if (!error_in_archive)       /* don't overwrite stronger error */
  515. X            error_in_archive = 1;    /* 1:  warning error */
  516. X    }
  517. X    if (tflag && (quietflg == 1)) {
  518. X        int num=filnum+1 - num_bad_pwd;
  519. X
  520. X        if (error_in_archive)
  521. X            printf("At least one error was detected in %s.\n", zipfn);
  522. X        else if (num == 0)
  523. X            printf("Caution:  zero files tested in %s.\n", zipfn);
  524. X        else if (process_all_files && (num_skipped+num_bad_pwd == 0))
  525. X            printf("No errors detected in %s.\n", zipfn);
  526. X        else
  527. X            printf("No errors detected in %s for the %d file%s tested.\n",
  528. X              zipfn, num, (num==1)? "":"s");
  529. X        if (num_skipped > 0)
  530. X            printf("%d file%s skipped because of unsupported compression or\
  531. X encoding.\n",
  532. X              num_skipped, (num_skipped==1)? "":"s");
  533. X#ifdef CRYPT
  534. X        if (num_bad_pwd > 0)
  535. X            printf("%d file%s skipped because of incorrect password.\n",
  536. X              num_bad_pwd, (num_bad_pwd==1)? "":"s");
  537. X#endif /* CRYPT */
  538. X    }
  539. X    if ((num_skipped > 0) && !error_in_archive)   /* files not tested or  */
  540. X        error_in_archive = 1;                     /*  extracted:  warning */
  541. X#ifdef CRYPT
  542. X    if ((num_bad_pwd > 0) && !error_in_archive)   /* files not tested or  */
  543. X        error_in_archive = 1;                     /*  extracted:  warning */
  544. X#endif /* CRYPT */
  545. X
  546. X    return (error_in_archive);
  547. X
  548. X} /* end function extract_or_test_files() */
  549. X
  550. X
  551. X
  552. X
  553. X
  554. X/***************************/
  555. X/*  Function store_info()  */
  556. X/***************************/
  557. X
  558. Xstatic int store_info()   /* return 1 if skipping, 0 if OK */
  559. X{
  560. X    ULONG tmp;
  561. X
  562. X#define UNKN_COMPR \
  563. X   (crec.compression_method>IMPLODED && crec.compression_method!=DEFLATED)
  564. X#if 0  /* old */
  565. X#  define UNKN_COMPR   (crec.compression_method>IMPLODED)
  566. X#endif
  567. X
  568. X
  569. X/*---------------------------------------------------------------------------
  570. X    Check central directory info for version/compatibility requirements.
  571. X  ---------------------------------------------------------------------------*/
  572. X
  573. X    pInfo->encrypted = crec.general_purpose_bit_flag & 1;    /* bit field */
  574. X    pInfo->ExtLocHdr = (crec.general_purpose_bit_flag & 8) == 8;  /* bit */
  575. X    pInfo->text = crec.internal_file_attributes & 1;         /* bit field */
  576. X    pInfo->crc = crec.crc32;
  577. X    pInfo->compr_size = crec.compressed_size;
  578. X
  579. X    if (crec.version_needed_to_extract[1] == VMS_) {
  580. X        if (crec.version_needed_to_extract[0] > VMS_VERSION) {
  581. X            fprintf(stderr, VersionMsg, filename, "VMS",
  582. X              crec.version_needed_to_extract[0] / 10,
  583. X              crec.version_needed_to_extract[0] % 10,
  584. X              VMS_VERSION / 10, VMS_VERSION % 10);
  585. X            return 1;
  586. X        }
  587. X#ifndef VMS   /* won't be able to use extra field, but still have data */
  588. X        else if (!tflag && !force_flag) {  /* if forcing, extract regardless */
  589. X            fprintf(stderr,
  590. X              "\n%s:  stored in VMS format.  Extract anyway? (y/n) ",
  591. X              filename);
  592. X            FFLUSH   /* for Amiga and Mac MPW */
  593. X            fgets(answerbuf, 9, stdin);
  594. X            if ((*answerbuf != 'y') && (*answerbuf != 'Y'))
  595. X                return 1;
  596. X        }
  597. X#endif /* !VMS */
  598. X    /* usual file type:  don't need VMS to extract */
  599. X    } else if (crec.version_needed_to_extract[0] > UNZIP_VERSION) {
  600. X        fprintf(stderr, VersionMsg, filename, "PK",
  601. X          crec.version_needed_to_extract[0] / 10,
  602. X          crec.version_needed_to_extract[0] % 10,
  603. X          UNZIP_VERSION / 10, UNZIP_VERSION % 10);
  604. X        return 1;
  605. X    }
  606. X
  607. X    if UNKN_COMPR {
  608. X        fprintf(stderr, ComprMsg, filename, crec.compression_method);
  609. X        return 1;
  610. X    }
  611. X#ifndef CRYPT
  612. X    if (pInfo->encrypted) {
  613. X        fprintf(stderr, " skipping: %-22s  encrypted (not supported)\n",
  614. X          filename);
  615. X        return 1;
  616. X    }
  617. X#endif /* !CRYPT */
  618. X
  619. X/*---------------------------------------------------------------------------
  620. X    Store some central-directory information (encryption, file attributes,
  621. X    offsets) for later use.
  622. X  ---------------------------------------------------------------------------*/
  623. X
  624. X    tmp = crec.external_file_attributes;
  625. X
  626. X    pInfo->dos_attr = 32;   /* set archive bit:  file is not backed up */
  627. X    switch (pInfo->hostnum) {
  628. X        case UNIX_:
  629. X        case VMS_:
  630. X            pInfo->unix_attr = (unsigned) (tmp >> 16);
  631. X            break;
  632. X        case DOS_OS2_FAT_:
  633. X        case OS2_HPFS_:
  634. X            pInfo->dos_attr = (unsigned) tmp;
  635. X            tmp = (!(tmp & 1)) << 1;   /* read-only bit */
  636. X            pInfo->unix_attr = (unsigned) (0444 | (tmp<<6) | (tmp<<3) | tmp);
  637. X#ifdef UNIX
  638. X            umask( (int)(tmp=umask(0)) );
  639. X            pInfo->unix_attr &= ~tmp;
  640. X#endif
  641. X            break;
  642. X        case MAC_:
  643. X            pInfo->unix_attr = (unsigned) (tmp & 1);   /* read-only bit */
  644. X            break;
  645. X        default:
  646. X            pInfo->unix_attr = 0666;
  647. X            break;
  648. X    } /* end switch (host-OS-created-by) */
  649. X
  650. X    pInfo->offset = (longint) crec.relative_offset_local_header;
  651. X    return 0;
  652. X
  653. X} /* end function store_info() */
  654. X
  655. X
  656. X
  657. X
  658. X
  659. X/***************************************/
  660. X/*  Function extract_or_test_member()  */
  661. X/***************************************/
  662. X
  663. Xstatic int extract_or_test_member()    /* return PK-type error code */
  664. X{
  665. X#ifdef S_IFLNK
  666. X    int symlnk=FALSE;
  667. X#endif /* S_IFLNK */
  668. X    int error=0;
  669. X    UWORD b;
  670. X
  671. X
  672. X
  673. X/*---------------------------------------------------------------------------
  674. X    Initialize variables, buffers, etc.
  675. X  ---------------------------------------------------------------------------*/
  676. X
  677. X    bits_left = 0;
  678. X    bitbuf = 0L;
  679. X    outpos = 0L;
  680. X    outcnt = 0;
  681. X    outptr = outbuf;
  682. X    zipeof = 0;
  683. X    crc32val = 0xFFFFFFFFL;
  684. X
  685. X#ifdef S_IFLNK
  686. X    if ((pInfo->unix_attr & S_IFMT) == S_IFLNK  &&  (pInfo->hostnum == UNIX_)
  687. X        && !tflag && !cflag)
  688. X        symlnk = TRUE;
  689. X#endif /* S_IFLNK */
  690. X
  691. X    memset(outbuf, 0xaa, OUTBUFSIZ);
  692. X#if (!defined(DOS_OS2) || defined(MSWIN))
  693. X    if (aflag)                  /* if we have a scratchpad, clear it out */
  694. X#ifdef MSWIN
  695. X        _fmemset(outout, 0xaa, OUTBUFSIZ);
  696. X#else /* !MSWIN */
  697. X        memset(outout, 0xaa, OUTBUFSIZ);
  698. X#endif /* ?MSWIN */
  699. X#endif /* !DOS_OS2 || MSWIN */
  700. X
  701. X    if (tflag) {
  702. X        if (!quietflg) {
  703. X            fprintf(stdout, "  Testing: %-22s ", filename);
  704. X            fflush(stdout);
  705. X        }
  706. X    } else {
  707. X        if (cflag) {            /* output to stdout (copy of it) */
  708. X#if (defined(MACOS) || defined(AMIGA))
  709. X            outfd = 1;
  710. X#else /* !(MACOS || AMIGA) */
  711. X            outfd = dup(1);     /* GRR: change this to #define for Mac/Amiga */
  712. X#endif /* ?(MACOS || AMIGA) */
  713. X#ifdef DOS_OS2
  714. X            if (!aflag)
  715. X                setmode(outfd, O_BINARY);
  716. X#endif /* DOS_OS2 */
  717. X#ifdef VMS
  718. X            if (create_output_file())   /* VMS version required for stdout! */
  719. X                return 50;      /* 50:  disk full (?) */
  720. X#endif
  721. X        } else
  722. X#ifdef S_IFLNK
  723. X        if (!symlnk)    /* symlink() takes care of file creation */
  724. X#endif /* !S_IFLNK */
  725. X        {
  726. X            if (create_output_file())
  727. X                return 50;      /* 50:  disk full (?) */
  728. X        }
  729. X    } /* endif (!tflag) */
  730. X
  731. X/*---------------------------------------------------------------------------
  732. X    Unpack the file.
  733. X  ---------------------------------------------------------------------------*/
  734. X
  735. X    switch (lrec.compression_method) {
  736. X
  737. X    case STORED:
  738. X        if (!tflag && (quietflg < 2)) {
  739. X            fprintf(stdout, " Extracting: %-22s ", filename);
  740. X            if (cflag)
  741. X                fprintf(stdout, "\n");
  742. X            fflush(stdout);
  743. X        }
  744. X#ifdef S_IFLNK
  745. X        /*
  746. X         * If file came from Unix and is a symbolic link and we are extracting
  747. X         * to disk, allocate a storage area, put the data in it, and create the
  748. X         * link.  Since we know it's a symbolic link to start with, shouldn't
  749. X         * have to worry about overflowing unsigned ints with unsigned longs.
  750. X         * (This doesn't do anything for compressed symlinks, but that can be
  751. X         * added later...it also doesn't set the time or permissions of the
  752. X         * link, but does anyone really care?)
  753. X         */
  754. X        if (symlnk) {
  755. X#if (defined(MTS) || defined(MACOS))
  756. X            fprintf(stdout, "\n  warning:  symbolic link ignored\n");
  757. X            error = 1;          /* 1:  warning error */
  758. X#else /* !(MTS || MACOS) */
  759. X            char *orig = (char *)malloc((unsigned)lrec.uncompressed_size+1);
  760. X            char *p = orig;
  761. X
  762. X            while (ReadByte(&b))
  763. X                *p++ = b;
  764. X            *p = 0;   /* terminate string */
  765. X            UpdateCRC((unsigned char *)orig, p-orig);
  766. X            if (symlink(orig, filename))
  767. X                if ((errno == EEXIST) && overwrite_all) {  /* OK to overwrite */
  768. X                    unlink(filename);
  769. X                    if (symlink(orig, filename))
  770. X                        perror("symlink error");
  771. X                } else
  772. X                    perror("symlink error");
  773. X            free(orig);
  774. X#endif /* ?(MTS || MACOS) */
  775. X        } else
  776. X#endif /* S_IFLNK */
  777. X        while (ReadByte(&b) && !disk_full)
  778. X            OUTB(b)
  779. X        break;
  780. X
  781. X    case SHRUNK:
  782. X        if (!tflag && (quietflg < 2)) {
  783. X            fprintf(stdout, "UnShrinking: %-22s ", filename);
  784. X            if (cflag)
  785. X                fprintf(stdout, "\n");
  786. X            fflush(stdout);
  787. X        }
  788. X#ifdef S_IFLNK   /* !!! This code needs to be added to unShrink, etc. !!! */
  789. X        if (symlnk) {
  790. X            fprintf(stdout, "\n  warning:  symbolic link ignored\n");
  791. X            error = 1;          /* 1:  warning error */
  792. X        }
  793. X#endif /* S_IFLNK */
  794. X        unShrink();
  795. X        break;
  796. X
  797. X    case REDUCED1:
  798. X    case REDUCED2:
  799. X    case REDUCED3:
  800. X    case REDUCED4:
  801. X        if (!tflag && (quietflg < 2)) {
  802. X            fprintf(stdout, "  Expanding: %-22s ", filename);
  803. X            if (cflag)
  804. X                fprintf(stdout, "\n");
  805. X            fflush(stdout);
  806. X        }
  807. X#ifdef S_IFLNK   /* !!! This code needs to be added to unShrink, etc. !!! */
  808. X        if (symlnk) {
  809. X            fprintf(stdout, "\n  warning:  symbolic link ignored\n");
  810. X            error = 1;          /* 1:  warning error */
  811. X        }
  812. X#endif /* S_IFLNK */
  813. X        unReduce();
  814. X        break;
  815. X
  816. X    case IMPLODED:
  817. X        if (!tflag && (quietflg < 2)) {
  818. X            fprintf(stdout, "  Exploding: %-22s ", filename);
  819. X            if (cflag)
  820. X                fprintf(stdout, "\n");
  821. X            fflush(stdout);
  822. X        }
  823. X#ifdef S_IFLNK   /* !!! This code needs to be added to unShrink, etc. !!! */
  824. X        if (symlnk) {
  825. X            fprintf(stdout, "\n  warning:  symbolic link ignored\n");
  826. X            error = 1;          /* 1:  warning error */
  827. X        }
  828. X#endif /* S_IFLNK */
  829. X        explode();   /* ignore return code for now */
  830. X        break;
  831. X
  832. X    case DEFLATED:
  833. X        if (!tflag && (quietflg < 2)) {
  834. X            fprintf(stdout, "  Inflating: %-22s ", filename);
  835. X            if (cflag)
  836. X                fprintf(stdout, "\n");
  837. X            fflush(stdout);
  838. X        }
  839. X#ifdef S_IFLNK   /* !!! This code needs to be added to unShrink, etc. !!! */
  840. X        if (symlnk) {
  841. X            fprintf(stdout, "\n  warning:  symbolic link ignored\n");
  842. X            error = 1;          /* 1:  warning error */
  843. X        }
  844. X#endif /* S_IFLNK */
  845. X        inflate();
  846. X        break;
  847. X
  848. X    default:   /* should never get to this point */
  849. X        fprintf(stderr, "%s:  unknown compression method\n", filename);
  850. X        /* close and delete file before return? */
  851. X        return 1;               /* 1:  warning error */
  852. X
  853. X    } /* end switch (compression method) */
  854. X
  855. X    if (disk_full) {            /* set by FlushOutput()/OUTB() macro */
  856. X        if (disk_full > 1)
  857. X            return 50;          /* 50:  disk full */
  858. X        error = 1;              /* 1:  warning error */
  859. X    }
  860. X
  861. X/*---------------------------------------------------------------------------
  862. X    Write the last partial buffer, if any; set the file date and time; and
  863. X    close the file (not necessarily in that order).  Then make sure CRC came
  864. X    out OK and print result.
  865. X  ---------------------------------------------------------------------------*/
  866. X
  867. X#ifdef S_IFLNK
  868. X    if (!symlnk) {
  869. X#endif /* S_IFLNK */
  870. X    if (!disk_full && FlushOutput())
  871. X        if (disk_full > 1)
  872. X            return 50;          /* 50:  disk full */
  873. X        else {                  /* disk_full == 1 */
  874. X            fprintf(stderr, "%s:  probably corrupt\n", filename);
  875. X            error = 1;          /* 1:  warning error */
  876. X        }
  877. X
  878. X    if (!tflag)
  879. X#ifdef VMS
  880. X        CloseOutputFile();
  881. X#else /* !VMS */
  882. X#ifdef MTS                      /* MTS can't set file time */
  883. X        close(outfd);
  884. X#else /* !MTS */
  885. X        set_file_time_and_close();
  886. X#endif /* ?MTS */
  887. X#endif /* ?VMS */
  888. X
  889. X#ifdef S_IFLNK
  890. X    } /* endif (!symlnk) */
  891. X#endif /* S_IFLNK */
  892. X
  893. X    /* logical-AND crc32val for 64-bit machines */
  894. X    if ((crc32val = ((~crc32val) & 0xFFFFFFFFL)) != lrec.crc32) {
  895. X        /* if quietflg is set, we haven't output the filename yet:  do it */
  896. X        if (quietflg)
  897. X            printf("%-22s: ", filename);
  898. X        fprintf(stdout, " Bad CRC %08lx  (should be %08lx)\n", crc32val,
  899. X                lrec.crc32);
  900. X        error = 1;              /* 1:  warning error */
  901. X    } else if (tflag) {
  902. X        if (!quietflg)
  903. X            fprintf(stdout, " OK\n");
  904. X    } else {
  905. X        if ((quietflg < 2) && !error)
  906. X            fprintf(stdout, "\n");
  907. X    }
  908. X
  909. X    return error;
  910. X
  911. X}       /* end function extract_or_test_member() */
  912. X
  913. X
  914. X
  915. X
  916. X
  917. X#ifdef CRYPT
  918. X
  919. X/*******************************/
  920. X/*  Function decrypt_member()  */
  921. X/*******************************/
  922. X
  923. Xstatic int decrypt_member()   /* return 10 if out of memory or can't get */
  924. X{                             /*  tty; 1 if password bad; 0 if password OK */
  925. X    UWORD b;
  926. X    int n, r;
  927. X    static int nopwd=FALSE;
  928. X    char *m, *prompt;
  929. X    byte h[12];
  930. X
  931. X
  932. X    /* get header once */
  933. X    for (n = 0; n < 12; n++) {
  934. X        ReadByte(&b);
  935. X        h[n] = (byte) b;
  936. X    }
  937. X
  938. X    /* if have key already, test it; else allocate memory for it */
  939. X    if (key) {
  940. X        if (!testp(h))
  941. X            return 0;      /* existing password OK (else prompt for new) */
  942. X        else if (nopwd)
  943. X            return 1;      /* user indicated no more prompting */
  944. X    } else if ((key = (char *)malloc(PWLEN+1)) == (char *)NULL)
  945. X        return 10;
  946. X
  947. X    if ((prompt = (char *)malloc(FILNAMSIZ+15)) != (char *)NULL) {
  948. X        sprintf(prompt, "%s password: ", filename);
  949. X        m = prompt;
  950. X    } else
  951. X        m = "Enter password: ";
  952. X
  953. X    /* try a few keys */
  954. X    for (r = 0;  r < 3;  ++r) {
  955. X        m = getp(m, key, PWLEN+1);
  956. X        if (prompt != (char *)NULL) {
  957. X            free(prompt);
  958. X            prompt = (char *)NULL;
  959. X        }
  960. X        if (m == (char *)NULL)
  961. X            return 10;
  962. X        if (!testp(h))
  963. X            return 0;
  964. X        if (*key == '\0') {
  965. X            nopwd = TRUE;
  966. X            return 1;
  967. X        }
  968. X        m = "password incorrect--reenter: ";
  969. X    }
  970. X    return 1;
  971. X}
  972. X
  973. X
  974. X
  975. X
  976. X
  977. X/**********************/
  978. X/*  Function testp()  */
  979. X/**********************/
  980. X
  981. Xstatic int testp(h)   /* return -1 if bad password; 0 if OK */
  982. X    byte *h;
  983. X{
  984. X    UWORD b, c;
  985. X    int n, t;
  986. X    byte *p;
  987. X
  988. X    /* set keys */
  989. X    init_keys(key);
  990. X
  991. X    /* check password */
  992. X    for (n = 0; n < 11; n++)
  993. X        c = DECRYPT(h[n]);
  994. X    b = DECRYPT(h[11]);
  995. X
  996. X#ifdef CRYPT_DEBUG
  997. X    printf("   lrec.crc = %08lx  crec.crc = %08lx  pInfo->ExtLocHdr = %s\n",
  998. X      lrec.crc32, pInfo->crc, pInfo->ExtLocHdr? "true":"false");
  999. X    printf("   incnt = %d  unzip offset into zipfile = %ld\n", incnt,
  1000. X      cur_zipfile_bufstart+(inptr-inbuf));
  1001. X    printf("   (c | (b<<8)) = %04x  (crc >> 16) = %04x  lrec.time = %04x\n",
  1002. X      (UWORD)(c | (b<<8)), (UWORD)(lrec.crc32 >> 16), lrec.last_mod_file_time);
  1003. X#endif /* CRYPT_DEBUG */
  1004. X
  1005. X    /* same test as in zipbare() in crypt.c: */
  1006. X    if ((UWORD)(c | (b<<8)) != (pInfo->ExtLocHdr? lrec.last_mod_file_time :
  1007. X        (UWORD)(lrec.crc32 >> 16)))
  1008. X        return -1;  /* bad */
  1009. X
  1010. X    /* password OK:  decrypt current buffer contents before leaving */
  1011. X    for (n = (longint)incnt > csize ? (int)csize : incnt, p = inptr; n--; p++)
  1012. X        *p = (byte) DECRYPT(*p);
  1013. X    return 0;       /* OK */
  1014. X
  1015. X} /* end function testp() */
  1016. X
  1017. X#endif /* CRYPT */
  1018. X
  1019. X
  1020. X
  1021. X
  1022. X
  1023. X/*******************************/
  1024. X/*  Function ReadMemoryByte()  */
  1025. X/*******************************/
  1026. X
  1027. Xint ReadMemoryByte(x)   /* return PK-type error code */
  1028. X    UWORD *x;
  1029. X{
  1030. X    if (mem_i_offset < mem_i_size) {
  1031. X        *x = (UWORD) mem_i_buffer[mem_i_offset++];
  1032. X        return 8;
  1033. X    } else
  1034. X        return 0;
  1035. X}
  1036. X
  1037. X
  1038. X
  1039. X
  1040. X
  1041. X/****************************/
  1042. X/*  Function FlushMemory()  */
  1043. X/****************************/
  1044. X
  1045. Xint FlushMemory()   /* return PK-type error code */
  1046. X{
  1047. X    if (outcnt == 0)
  1048. X        return 0;
  1049. X
  1050. X    if (mem_o_offset + outcnt <= mem_o_size) {
  1051. X        memcpy((char *)(mem_o_buffer+mem_o_offset), (char *)outbuf, outcnt);
  1052. X        mem_o_offset += outcnt;
  1053. X        return 0;
  1054. X    } else
  1055. X        return 50;
  1056. X}
  1057. X
  1058. X
  1059. X
  1060. X
  1061. X
  1062. X/***************************/
  1063. X/*  Function memextract()  */   /* extract compressed extra field block */
  1064. X/***************************/
  1065. X
  1066. Xint memextract(tgt, tgtsize, src, srcsize)  /* return 0 if success, 1 if not */
  1067. X    byte *tgt, *src;
  1068. X    ULONG tgtsize, srcsize;
  1069. X{
  1070. X    UWORD method, error = 0;
  1071. X    ULONG crc, oldcrc;
  1072. X
  1073. X    method = makeword(src);
  1074. X    crc = makelong(src+2);
  1075. X
  1076. X    mem_i_buffer = src + 2 + 4;      /* method and crc */
  1077. X    mem_i_size   = srcsize - 2 - 4;
  1078. X    mem_i_offset = 0;
  1079. X  
  1080. X    mem_o_buffer = tgt;
  1081. X    mem_o_size   = tgtsize;
  1082. X    mem_o_offset = 0;
  1083. X
  1084. X    mem_mode = 1;
  1085. X
  1086. X    bits_left = 0;
  1087. X    bitbuf = 0L;
  1088. X    outpos = 0L;
  1089. X    outcnt = 0;
  1090. X    outptr = outbuf;
  1091. X    zipeof = 0;
  1092. X
  1093. X    switch (method) {
  1094. X        case STORED:
  1095. X            memcpy(tgt, src + 2 + 4, (extent) (srcsize - 2 - 4));
  1096. X            break;
  1097. X        case DEFLATED:
  1098. X            inflate();
  1099. X            FlushOutput();
  1100. X            break;
  1101. X        default:
  1102. X            fprintf(stderr,
  1103. X              "warning:  unsupported extra field compression type--skipping\n");
  1104. X            error = 1;   /* GRR:  this should be passed on up via SetEAs() */
  1105. X            break;
  1106. X    }
  1107. X
  1108. X    mem_mode = 0;
  1109. X
  1110. X    if (!error) {
  1111. X        oldcrc = crc32val;
  1112. X        crc32val = 0xFFFFFFFFL;
  1113. X        UpdateCRC((unsigned char *) mem_o_buffer, (int) mem_o_size);
  1114. X        crc32val = (~crc32val) & 0xFFFFFFFFL;
  1115. X
  1116. X        if (crc32val != crc) {
  1117. X            printf("(Bad extra field CRC %08lx, should be %08lx)\n", crc32val,
  1118. X              crc);
  1119. X            error = 1;
  1120. X        }
  1121. X        crc32val = oldcrc; /* grrr ... this ugly kludge should be fixed */
  1122. X    }
  1123. X
  1124. X    return error;
  1125. X}
  1126. END_OF_FILE
  1127.   if test 37529 -ne `wc -c <'extract.c'`; then
  1128.     echo shar: \"'extract.c'\" unpacked with wrong size!
  1129.   fi
  1130.   # end of 'extract.c'
  1131. fi
  1132. if test -f 'mapname.c' -a "${1}" != "-c" ; then 
  1133.   echo shar: Will not clobber existing file \"'mapname.c'\"
  1134. else
  1135.   echo shar: Extracting \"'mapname.c'\" \(15624 characters\)
  1136.   sed "s/^X//" >'mapname.c' <<'END_OF_FILE'
  1137. X/*---------------------------------------------------------------------------
  1138. X
  1139. X  mapname.c
  1140. X
  1141. X  This routine changes DEC-20, VAX/VMS, and DOS-style filenames into normal
  1142. X  Unix names (and vice versa, in some cases); it also creates any necessary 
  1143. X  directories, if the -d switch was specified.
  1144. X
  1145. X  ---------------------------------------------------------------------------
  1146. X
  1147. X  Notes:
  1148. X
  1149. X     - This routine REALLY needs to be rewritten (different routines for
  1150. X       each output OS, with different rules for different parts of the path
  1151. X       name).  If each zip program stores local-format names (like the VMS
  1152. X       one did at one time), it would probably be best to convert to an in-
  1153. X       termediate format first (assuming we're not extracting under the same
  1154. X       OS as that under which the zipfile was created), then from that to
  1155. X       the current operating system's format.
  1156. X     - The strcpy and strcat operations on both cdp and filename may over-
  1157. X       write memory, since they don't check lengths.  With a kilobyte in
  1158. X       which to work, this is probably not that big a deal, but it could
  1159. X       cause problems eventually.
  1160. X
  1161. X  ---------------------------------------------------------------------------*/
  1162. X
  1163. X
  1164. X#include "unzip.h"
  1165. X
  1166. X
  1167. X/*******************/
  1168. X/* Mapname Defines */
  1169. X/*******************/
  1170. X
  1171. X#ifdef VMS
  1172. X#  define PERMS   0
  1173. X#else
  1174. X#  define PERMS   0777
  1175. X#endif
  1176. X
  1177. X#ifndef NO_MKDIR
  1178. X#  if (defined(DOS_OS2) && !defined(__GO32__))
  1179. X#    if (_MSC_VER >= 600)       /* have special MSC mkdir prototype */
  1180. X#      include <direct.h>
  1181. X#    else                       /* own prototype because dir.h conflicts? */
  1182. X       int mkdir(const char *path);
  1183. X#    endif /* ?(MSC 6.0 or later) */
  1184. X#    define MKDIR(path,mode)   mkdir(path)
  1185. X#  else /* !DOS_OS2 || __GO32__ */
  1186. X#    ifdef MACOS
  1187. X#      define MKDIR(path,mode)   macmkdir(path,gnVRefNum,glDirID)
  1188. X#    else /* !MACOS */
  1189. X#      define MKDIR(path,mode)   mkdir(path,mode)
  1190. X#    endif /* ?MACOS */
  1191. X#  endif /* ?(DOS_OS2 && !__GO32__)  */
  1192. X#endif /* !NO_MKDIR */
  1193. X
  1194. X
  1195. X
  1196. X
  1197. X/************************/
  1198. X/*  Function mapname()  */
  1199. X/************************/
  1200. X
  1201. Xint mapname(create_dirs)   /* return 0 if no error, 1 if caution (filename */
  1202. X    int create_dirs;       /*  truncated), 2 if warning (skip file because */
  1203. X{                          /*  dir doesn't exist), 3 if error (skip file) */
  1204. X#ifdef NO_MKDIR
  1205. X    char command[FILNAMSIZ+40]; /* buffer for system() call */
  1206. X#endif
  1207. X#ifdef VMS
  1208. X    int stat_val;               /* temp. holder for stat() return value */
  1209. X    char *dp, *xp;              /* pointers to directory name */
  1210. X    char *np;                   /* pointer into filename */
  1211. X#endif /* VMS */
  1212. X#ifdef DOS_VMS
  1213. X    char *last_dot=NULL;        /* last dot not converted to underscore */
  1214. X#endif /* DOS_VMS */
  1215. X#ifdef OS2
  1216. X    char *last;
  1217. X    extern char longfilename[]; /*  AFTER file created and closed */
  1218. X    extern int longname;        /* used also in file_io.c:  set EAs */
  1219. X    int longdir;
  1220. X#endif /* OS2 */
  1221. X    char name[FILNAMSIZ];       /* file name buffer */
  1222. X    char *pp, *cp, *cdp;        /* character pointers */
  1223. X    char delim = '\0';          /* directory delimiter */
  1224. X    int quote = FALSE;          /* flags */
  1225. X    int indir = FALSE;
  1226. X    int done = FALSE;
  1227. X    int created = FALSE;
  1228. X    register unsigned workch;   /* hold the character being tested */
  1229. X
  1230. X
  1231. X/*---------------------------------------------------------------------------
  1232. X    Initialize various pointers and counters and stuff.
  1233. X  ---------------------------------------------------------------------------*/
  1234. X
  1235. X#ifdef MAP_DEBUG
  1236. X    fprintf(stderr, "%s ", filename);   /* echo name of this file */
  1237. X#endif
  1238. X    cdp = (char *)NULL;
  1239. X    pp = name;                  /* point to translation buffer */
  1240. X    *name = '\0';               /* initialize buffer */
  1241. X    if (!jflag) {               /* -j => junk pathnames */
  1242. X        cdp = (char *)malloc(strlen(filename) + 3);   /* place for holding */
  1243. X        if (cdp == (char *)NULL) {                    /*  directory name */
  1244. X            fprintf(stderr, "mapname:  out of memory [%s]\n", filename);
  1245. X            return 3;
  1246. X        }
  1247. X#ifdef VMS
  1248. X        *cdp++ = '[';
  1249. X        xp = cdp;               /* always points to last non-NULL char */
  1250. X        *cdp++ = '.';
  1251. X#endif /* VMS */
  1252. X#ifdef MACOS
  1253. X        *cdp = ':';             /* the Mac uses ':' as a directory separator */
  1254. X        cdp[1] = '\0';
  1255. X#else /* !MACOS */
  1256. X        *cdp = '\0';
  1257. X#endif /* ?MACOS */
  1258. X    }
  1259. X
  1260. X/*---------------------------------------------------------------------------
  1261. X    Begin main loop through characters in filename.
  1262. X  ---------------------------------------------------------------------------*/
  1263. X
  1264. X    for (cp = filename; (workch = (unsigned char) *cp++) != 0  &&  !done;) {
  1265. X
  1266. X        if (quote) {                 /* if char quoted, */
  1267. X            *pp++ = (char) workch;   /*  include it literally */
  1268. X            quote = FALSE;
  1269. X        } else if (indir) {          /* if in directory name, */
  1270. X            if (workch == (unsigned)delim)  /*  look for end delimiter */
  1271. X                indir = FALSE;
  1272. X        } else
  1273. X            switch (workch) {
  1274. X            case '<':                /* discard DEC-20 directory name */
  1275. X                indir = TRUE;
  1276. X                delim = '>';
  1277. X                break;
  1278. X            case '[':                /* discard VMS directory name */
  1279. X                indir = TRUE;
  1280. X                delim = ']';
  1281. X                break;
  1282. X            case '/':                /* discard Unix path name  */
  1283. X            case '\\':               /*  or MS-DOS path name... */
  1284. X                                     /*  iff -j flag was given  */
  1285. X                /*
  1286. X                 * Special processing case:  if -j flag was not specified on
  1287. X                 * command line and create_dirs is TRUE, create any necessary
  1288. X                 * directories included in the pathname.  Creation of dirs is
  1289. X                 * straightforward on BSD and MS-DOS machines but requires use
  1290. X                 * of the system() command on SysV systems (or any others which
  1291. X                 * don't have mkdir()).  The stat() check is necessary with
  1292. X                 * MSC because it doesn't have an EEXIST errno, and it saves
  1293. X                 * the overhead of multiple system() calls on SysV machines.
  1294. X                 */
  1295. X
  1296. X                if (!jflag) {
  1297. X                    *pp = '\0';
  1298. X#ifdef VMS
  1299. X                    dp = name;
  1300. X                    while (*++xp = *dp++);  /* copy name to cdp */
  1301. X                    last_dot = NULL;        /* dir name:  no dots allowed */
  1302. X                    strcpy(xp, ".dir");     /* add extension for stat check */
  1303. X                    stat_val = stat(cdp, &statbuf);
  1304. X                    *xp = '\0';             /* remove extension for all else */
  1305. X                    if (stat_val) {         /* doesn't exist, so create */
  1306. X#else /* !VMS */
  1307. X#ifdef MSDOS
  1308. X                    if (last_dot != NULL) {  /* one dot in dir name is legal */
  1309. X                        *last_dot = '.';
  1310. X                        last_dot = NULL;
  1311. X                    }
  1312. X#endif /* MSDOS */
  1313. X                    strcat(cdp, name);
  1314. X#ifdef OS2
  1315. X                    if ((longdir = !IsFileNameValid(cdp)) != 0) {
  1316. X                        last = strrchr(cdp, '/');
  1317. X                        strcpy(longfilename, last ? last + 1 : cdp);
  1318. X                        fprintf(stderr, "renaming directory \"%s\"", cdp);
  1319. X                        ChangeNameForFAT(cdp);
  1320. X                        fprintf(stderr, " to \"%s\"\n", cdp);
  1321. X                    }
  1322. X#endif /* OS2 */
  1323. X                    if (stat(cdp, &statbuf)) {  /* doesn't exist, so create */
  1324. X#endif /* ?VMS */
  1325. X                        if (!create_dirs) /* told not to create (freshening) */
  1326. X                            return 2;
  1327. X#ifdef NO_MKDIR
  1328. X                        sprintf(command,
  1329. X                          "IFS=\" \t\n\" /bin/mkdir %s 2>/dev/null", cdp);
  1330. X                        if (system(command)) {
  1331. X#else /* !NO_MKDIR */
  1332. X                        if (MKDIR(cdp, PERMS) == -1) {
  1333. X#endif /* ?NO_MKDIR */
  1334. X                            perror(cdp);
  1335. X                            free(cdp);
  1336. X                            fprintf(stderr, "mapame:  unable to process [%s]\n",
  1337. X                              filename);
  1338. X                            return 3;
  1339. X                        }
  1340. X                        created = TRUE;
  1341. X#ifdef OS2
  1342. X                        if (longdir)
  1343. X                            SetLongNameEA(cdp, longfilename);
  1344. X#endif /* OS2 */
  1345. X                    } else if (!(statbuf.st_mode & S_IFDIR)) {
  1346. X                        fprintf(stderr,
  1347. X                          "mapname:  %s exists but is not a directory\n", cdp);
  1348. X                        free(cdp);
  1349. X                        fprintf(stderr, "mapame:  unable to process [%s]\n",
  1350. X                          filename);
  1351. X                        return 3;
  1352. X                    }
  1353. X#ifdef VMS
  1354. X                    *xp = '/';  /* for now... (mkdir()) */
  1355. X#else /* !VMS */
  1356. X#ifdef MACOS
  1357. X                    strcat(cdp, ":");
  1358. X#else /* !MACOS */
  1359. X                    strcat(cdp, "/");
  1360. X#endif /* ?MACOS */
  1361. X#endif /* ?VMS */
  1362. X                }
  1363. X                pp = name;
  1364. X                break;
  1365. X            case ':':
  1366. X#ifdef UNIX                       /* colon is a valid character in Unix */
  1367. X                *pp++ = workch;   /*  filenames, so keep it; anywhere else, */
  1368. X#else /* !UNIX */                 /*  change it to an underscore (should  */
  1369. X                *pp++ = '_';      /*  NOT have stored drive/node names!!) */
  1370. X#endif /* ?UNIX */
  1371. X             /* pp = name;  (OLD) discard DEC dev: or node:: name */
  1372. X                break;
  1373. X            case '.':                   /* DEC-20 generation number or */
  1374. X#ifdef DOS_VMS                          /*  MS-DOS or VMS separator */
  1375. X                last_dot = pp;          /* point at last dot so far... */
  1376. X                *pp++ = '_';            /* convert dot to underscore */
  1377. X#else /* !DOS_VMS */
  1378. X                *pp++ = workch;
  1379. X#endif /* ?DOS_VMS */
  1380. X                break;
  1381. X            case ';':                   /* VMS generation or DEC-20 attrib */
  1382. X#ifdef MACOS
  1383. X                if (V_flag || macflag)
  1384. X#else /* !MACOS */
  1385. X                if (V_flag)                 /* if requested, save VMS ";##" */
  1386. X#endif /* ?MACOS */                         /*  version info or Macintosh */
  1387. X                    *pp++ = (char) workch;  /*  (?) info; otherwise discard */
  1388. X                else                        /*  everything starting with */
  1389. X                    done = TRUE;            /*  semicolon.  (Worry about */
  1390. X                break;                      /*  DEC-20 later.) */
  1391. X            case '\026':                /* control-V quote for special chars */
  1392. X                quote = TRUE;           /* set flag for next character */
  1393. X                break;
  1394. X            case ' ':
  1395. X#if (defined(VMS) || defined(MTS))
  1396. X                *pp++ = '_';            /* change spaces to underscore */
  1397. X#else /* !(VMS || MTS) */               /*  under VMS and MTS, and under DOS */
  1398. X#ifdef DOS_OS2                          /*  and OS/2 if -s not specified. */
  1399. X                if (!sflag)
  1400. X                    *pp++ = '_';
  1401. X                else
  1402. X#endif /* DOS_OS2 */
  1403. X                *pp++ = (char) workch;  /* otherwise, leave as spaces */
  1404. X#endif /* ?(VMS || MTS) */
  1405. X                break;
  1406. X            default:
  1407. X#ifdef MACOS
  1408. X                if ((macflag && ((unsigned)workch > 0x1F)) || isprint(workch))
  1409. X#else /* !MACOS */
  1410. X#if (defined(DOS_OS2) || (defined(UNIX) && !defined(VMS)))  /* allow non-US */
  1411. X                if (isprint(workch) || (128 <= workch && workch <= 254))
  1412. X#else /* !(DOS_OS2 || UNIX) */
  1413. X                if (isprint(workch))    /* other printable, just keep */
  1414. X#endif /* ?(DOS_OS2 || UNIX) */
  1415. X#endif /* ?MACOS */
  1416. X                    *pp++ = (char) workch;
  1417. X            } /* end switch */
  1418. X    } /* end for loop */
  1419. X    *pp = '\0';                         /* done with name:  terminate it */
  1420. X#ifdef DOS_VMS                          /*  and put a dot back in if VMS */
  1421. X    if (last_dot != NULL)               /*  or MS-DOS */
  1422. X        *last_dot = '.';
  1423. X#endif /* DOS_VMS */
  1424. X
  1425. X/*---------------------------------------------------------------------------
  1426. X    We COULD check for existing names right now, create a "unique" name, etc.
  1427. X    At present, we do this in extract_or_test_files() (immediately after we
  1428. X    return from here).  If conversion went bad, the name'll either be nulled
  1429. X    out (in which case we'll return non-0), or following procedures won't be
  1430. X    able to create the extracted file and other error msgs will result.
  1431. X  ---------------------------------------------------------------------------*/
  1432. X
  1433. X    if (filename[strlen(filename) - 1] == '/') {
  1434. X        /* A directory was extracted. It had a trailing /, 
  1435. X         * don't report the error below. */
  1436. X        if (created) {
  1437. X            printf("   Creating: %s", filename);
  1438. X#ifdef OS2
  1439. X            SetPathInfo(filename, lrec.last_mod_file_date,
  1440. X                                  lrec.last_mod_file_time, -1);
  1441. X            if (extra_field)
  1442. X                SetEAs(filename, extra_field);
  1443. X#endif
  1444. X            printf("\n");
  1445. X        }
  1446. X        return 2; /* but skip file */
  1447. X    }
  1448. X
  1449. X    if (*name == '\0') {
  1450. X        fprintf(stderr, "mapname:  conversion of [%s] failed\n", filename);
  1451. X        return 3;
  1452. X    }
  1453. X
  1454. X#ifdef OS2
  1455. X    if (!longname && ((longname = !IsFileNameValid(name)) != 0)) {
  1456. X        /* in case of second call after user renamed the file, skip this */
  1457. X        last = strrchr(name, '/');      /* THIS time, save for file_io */
  1458. X        last = last ? last + 1 : name;  /* only last component */
  1459. X        strcpy(longfilename, last);
  1460. X        fprintf(stderr, "renaming \"%s\"", name);
  1461. X        ChangeNameForFAT(last);
  1462. X        fprintf(stderr, " to \"%s\"\n", name);
  1463. X    }
  1464. X#endif /* OS2 */
  1465. X
  1466. X#ifdef VMS
  1467. X    /* convert filename to legal VMS one, substituting underscores for
  1468. X     * all invalid characters */
  1469. X    for (np = name;  *np;  ++np)
  1470. X        if (!(isdigit(*np) || isalpha(*np) || (*np == '$') ||
  1471. X            (*np == '-') || (*np == '_') || (*np == '.') || (*np == ';')))
  1472. X            *np = '_';
  1473. X#endif /* VMS */
  1474. X
  1475. X    if (!jflag) {
  1476. X#ifdef VMS
  1477. X        *xp++ = ']';                 /* proper end-of-dir-name delimiter */
  1478. X        if (xp == cdp) {             /* no path-name stuff, so... */
  1479. X            strcpy(filename, name);  /* copy file name into global */
  1480. X            cdp -= 2;                /*   prepare to free malloc'd space */
  1481. X        } else {                     /* we've added path-name stuff... */
  1482. X            *xp = '\0';              /*   so terminate and convert to */
  1483. X            dp = cdp;                /*   VMS subdir separators (skip */
  1484. X            while (*++dp)            /*   first char:  better not be */
  1485. X                if (*dp == '/')      /*   "/"):  change all slashes */
  1486. X                    *dp = '.';       /*   to dots */
  1487. X            cdp -= 2;                /*   include leading bracket and dot */
  1488. X            strcpy(filename, cdp);   /* copy VMS-style path name into global */
  1489. X            strcat(filename, name);  /* concatenate file name to global */
  1490. X        }
  1491. X#else /* !VMS */
  1492. X        strcpy(filename, cdp);       /* either "" or slash-terminated path */
  1493. X        strcat(filename, name);      /* append file name to path name */
  1494. X#endif /* ?VMS */
  1495. X        free(cdp);
  1496. X    } else
  1497. X        strcpy(filename, name);      /* copy converted name into global */
  1498. X
  1499. X#if PATH_MAX < (FILNAMSIZ - 1)
  1500. X    /* check the length of the file name and truncate if necessary */
  1501. X    if (PATH_MAX < strlen(filename)) {
  1502. X        fprintf(stderr, "caution:  truncating filename\n");
  1503. X        filename[PATH_MAX] = '\0';
  1504. X        fprintf(stderr, "[ %s ]\n", filename);
  1505. X        return 1;             /* 1:  warning error */
  1506. X    }
  1507. X#endif
  1508. X
  1509. X    return 0;
  1510. X}
  1511. END_OF_FILE
  1512.   if test 15624 -ne `wc -c <'mapname.c'`; then
  1513.     echo shar: \"'mapname.c'\" unpacked with wrong size!
  1514.   fi
  1515.   # end of 'mapname.c'
  1516. fi
  1517. echo shar: End of archive 2 \(of 14\).
  1518. cp /dev/null ark2isdone
  1519. MISSING=""
  1520. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
  1521.     if test ! -f ark${I}isdone ; then
  1522.     MISSING="${MISSING} ${I}"
  1523.     fi
  1524. done
  1525. if test "${MISSING}" = "" ; then
  1526.     echo You have unpacked all 14 archives.
  1527.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1528. else
  1529.     echo You still must unpack the following archives:
  1530.     echo "        " ${MISSING}
  1531. fi
  1532. exit 0
  1533. exit 0 # Just in case...
  1534.