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