home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / WINDOWS / MISC / WZUN11SR.ZIP / UNZIP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-12  |  68.7 KB  |  1,836 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.   unzip.c
  4.  
  5.   This is nearly a complete rewrite of unzip.c, mainly to allow access to
  6.   zipfiles via the central directory (and hence to the OS bytes, so we can
  7.   make intelligent decisions about what to do with the extracted files).
  8.   Based on unzip.c 3.15+ and zipinfo.c 0.90.
  9.  
  10.   ---------------------------------------------------------------------------
  11.  
  12.   To compile (partial instructions):
  13.  
  14.      under Unix (cc):  make <system name>
  15.        (type "make" for list of valid names, or read Makefile for details)
  16.  
  17.      under MS-DOS (TurboC):  make -fMAKEFILE.DOS  for command line compiles
  18.        (or use the integrated environment and the included files TCCONFIG.TC
  19.         and UNZIP.PRJ.  Tweak for your environment.)
  20.  
  21.      under MS-DOS (MSC):  make MAKEFILE.DOS
  22.        (or use Makefile if you have MSC 6.0:  "nmake msc_dos")
  23.  
  24.      under OS/2 (MSC):  make MAKEFILE.DOS   (edit appropriately)
  25.        (or use Makefile if you have MSC 6.0:  "nmake msc_os2")
  26.  
  27.      under Atari OS:  Any Day Now.
  28.  
  29.      under VMS:  DEFINE LNK$LIBRARY SYS$LIBRARY:VAXCRTL.OLB   (see VMSNOTES)
  30.                  CC UNZIP,FILE_IO,MAPNAME,MATCH,...,UNSHRINK
  31.                  LINK UNZIP,FILE_IO,MAPNAME,MATCH,...,UNSHRINK
  32.                  UNZIP :== $DISKNAME:[DIRECTORY]UNZIP.EXE
  33.  
  34.      under Macintosh OS:   Double click on unzip.mac.  Press <Command>-M
  35.  
  36.   ---------------------------------------------------------------------------
  37.  
  38.   Version:  unzip411.arc/unzip411.tar.Z for Unix, VMS, OS/2, MS-DOS & Mac
  39.   Source:   wsmr-simtel20.army.mil (192.88.110.20) in pd1:[misc.unix]
  40.             wuarchive.wustl.edu (128.252.135.4) in /mirrors/misc/unix
  41.             (public versions, that is).  BETA source restricted to
  42.             Info-ZIP members.
  43.   ---------------------------------------------------------------------------
  44.  
  45.   Copyright, originally from version 1.2 (?):
  46.  
  47.      * Copyright 1989 Samuel H. Smith;  All rights reserved
  48.      *
  49.      * Do not distribute modified versions without my permission.
  50.      * Do not remove or alter this notice or any other copyright notice.
  51.      * If you use this in your own program you must distribute source code.
  52.      * Do not use any of this in a commercial product.
  53.  
  54.   ---------------------------------------------------------------------------
  55.  
  56.   Comments from unzip.c, version 3.11:
  57.  
  58.      * UnZip - A simple zipfile extract utility
  59.      *
  60.      * Compile-time definitions:
  61.      * See the Makefile for details, explanations, and all the current
  62.      * system makerules.
  63.      *
  64.      * If you have to add a new one for YOUR system, please forward the new
  65.      * Makefile context diff to kirsch%maxemail@uunet.uu.net for distribution.
  66.      * Be SURE to give FULL details on your system (hardware, OS, versions,
  67.      * processor, whatever) that made it unique.
  68.      *
  69.      * REVISION HISTORY : See History.41 (or whatever current version is)
  70.  
  71.   To join Info-ZIP, send a message to Info-ZIP-Request@WSMR-SIMTEL20.Army.Mil
  72.  
  73.   ---------------------------------------------------------------------------*/
  74.  
  75.  
  76.  
  77.  
  78.  
  79. #include "unzip.h"              /* includes, defines, and macros */
  80. #ifdef  MSWIN
  81. #include <windows.h>
  82. #include "wizunzip.h"
  83. /* History:
  84.  * 01/27/92  1.0    Original.
  85.  * 04/12/92     1.1    Added separate handle and buffer for outout.
  86.  *                  Change outout's typing to byte _far *.
  87.  *                  Apology: I did some of the wacky things I did
  88.  *                  with buffers and pointers because I kept running 
  89.  *                  out of local memory in the Windows version.--rah.
  90.  */
  91. #endif
  92.  
  93. #define VERSION  "v4.11 BETA of 08-23-91"
  94. #define PAKFIX   /* temporary solution to PAK-created zipfiles */
  95.  
  96.  
  97.  
  98.  
  99.  
  100. /**********************/
  101. /*  Global Variables */
  102. /**********************/
  103.  
  104. int tflag;              /* -t: test */
  105. int vflag;              /* -v: view directory (only used in unzip.c) */
  106. int cflag;              /* -c: output to stdout */
  107. int aflag;              /* -a: do ascii to ebcdic translation OR CR-LF */
  108.                         /*     to CR or LF conversion of extracted files */
  109. int dflag;              /* -d: create containing directories */
  110. int Uflag;              /* -U: leave filenames in upper or mixed case */
  111. int V_flag;             /* -V: don't strip VMS version numbers */
  112. int quietflg;           /* -q: produce a lot less output */
  113. int do_all;             /* -o: OK to overwrite files without prompting */
  114. int zflag;              /* -z: Display only the archive comment */
  115.  
  116. int lcflag;             /* convert filename to lowercase */
  117. unsigned f_attr;        /* file attributes (permissions) */
  118. longint csize;          /* used by list_files(), ReadByte(): must be signed */
  119. longint ucsize;         /* used by list_files(), unReduce(), unImplode() */
  120.  
  121. /*---------------------------------------------------------------------------
  122.     unShrink/unReduce/unImplode working storage:
  123.   ---------------------------------------------------------------------------*/
  124.  
  125. /* prefix_of (for unShrink) is biggest storage area, esp. on Crays...space */
  126. /*  is shared by lit_nodes (unImplode) and followers (unReduce) */
  127.  
  128. short prefix_of[HSIZE + 1];     /* (8193 * sizeof(short)) */
  129. #ifdef MACOS
  130. byte *suffix_of;
  131. byte *stack;
  132. #else
  133. byte suffix_of[HSIZE + 1];      /* also s-f length_nodes (smaller) */
  134. byte stack[HSIZE + 1];          /* also s-f distance_nodes (smaller) */
  135. #endif
  136.  
  137. ULONG crc32val;
  138.  
  139. UWORD mask_bits[] =
  140. {0, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
  141.     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff};
  142.  
  143. /*---------------------------------------------------------------------------
  144.     Input file variables:
  145.   ---------------------------------------------------------------------------*/
  146.  
  147. byte *inbuf, *inptr;    /* input buffer (any size is legal) and pointer */
  148. int incnt;
  149.  
  150. UWORD bitbuf;
  151. int bits_left;
  152. boolean zipeof;
  153.  
  154. int zipfd;                      /* zipfile file handle */
  155. #ifdef MSWIN
  156. char *zipfn;
  157. #else
  158. char zipfn[FILNAMSIZ];
  159. #endif
  160.  
  161. local_file_header lrec;
  162. struct stat statbuf;            /* used by main(), mapped_name() */
  163.  
  164. longint cur_zipfile_bufstart;   /* extract_or_test_files, readbuf, ReadByte */
  165.  
  166. /*---------------------------------------------------------------------------
  167.     Output stream variables:
  168.   ---------------------------------------------------------------------------*/
  169.  
  170. byte *outbuf;                   /* buffer for rle look-back */
  171. byte *outptr;
  172. #ifdef MSWIN
  173. byte _far *outout;              /* scratch pad for ASCII-native trans */
  174. #else
  175. byte *outout;                   /* scratch pad for ASCII-native trans */
  176. #endif
  177. longint outpos;                 /* absolute position in outfile */
  178. int outcnt;                     /* current position in outbuf */
  179.  
  180. int outfd;
  181. #ifdef MSWIN
  182. char *filename;
  183. #else
  184. char filename[FILNAMSIZ];
  185. #endif
  186.  
  187. /*---------------------------------------------------------------------------
  188.     unzip.c static global variables (visible only within this file):
  189.   ---------------------------------------------------------------------------*/
  190.  
  191. static char *fnames[2] =
  192. {"*", NULL};                    /* default filenames vector */
  193. static char **fnv = &fnames[0];
  194. static char sig[5];
  195. static byte *hold;
  196. static int process_all_files;
  197. static longint ziplen;
  198. static UWORD hostnum;
  199. static UWORD methnum;
  200. /* static UWORD extnum; */
  201. static central_directory_file_header crec;
  202. static end_central_dir_record ecrec;
  203.  
  204. /*---------------------------------------------------------------------------
  205.     unzip.c repeated error messages (we use all of these at least twice ==>
  206.     worth it to centralize to keep executable small):
  207.   ---------------------------------------------------------------------------*/
  208.  
  209. static char *CryptMsg =
  210.   "%s:  encrypted (can't do yet)--skipping.\n";
  211. static char *FilNamMsg =
  212.   "\n%s:  bad filename length (%s)\n";
  213. static char *ExtFieldMsg =
  214.   "\n%s:  bad extra field length (%s)\n";
  215. static char *OffsetMsg =
  216.   "\n%s:  bad zipfile offset (%s)\n";
  217. static char *EndSigMsg =
  218.   "\nwarning:  didn't find end-of-central-dir signature at end of central dir.\n";
  219. static char *CentSigMsg =
  220.   "\nerror:  expected central file header signature not found (file #%u).\n";
  221. #ifdef STUPID_DAMNED_REPORTS    /* No more damned reports! */
  222.   static char *ReportMsg =
  223.   "        (please report to info-zip@wsmr-simtel20.army.mil)\n";
  224. #endif
  225.  
  226. /* (original) Bill Davidsen version */
  227. #define QCOND    (!quietflg)    /* -xq[q] kill "extracting: ..." msgs */
  228. #define QCOND2   (which_hdr)    /* file comments with -v, -vq, -vqq */
  229.  
  230.  
  231.  
  232.  
  233. #ifndef MSWIN
  234. /*****************/
  235. /*  Main program */
  236. /*****************/
  237.  
  238. main(argc, argv)        /* return PK-type error code (except under VMS) */
  239. int argc;
  240. char *argv[];
  241. {
  242.     char *s;
  243.     int c, print_usage=TRUE;
  244.  
  245.  
  246.  
  247. #ifdef MACOS
  248. #ifdef THINK_C
  249.     #include <console.h>
  250.     #include <StdFilePkg.h>
  251.     typedef struct sf_node {        /* node in a true shannon-fano tree */
  252.         UWORD left;                 /* 0 means leaf node */
  253.         UWORD right;                /*   or value if leaf node */
  254.     } sf_node;
  255.     static char *argstr[30], args[30*64];
  256.  
  257.     extern sf_node *lit_nodes, *length_nodes, *distance_nodes;
  258.  
  259.     Point   p;
  260.     SFTypeList  sfT;
  261.     int a;
  262.     EventRecord theEvent;
  263.     short   eMask;
  264.     SFReply  fileRep;
  265.  
  266.     suffix_of = (byte *)calloc(HSIZE+1, sizeof(byte));
  267.     stack = (byte *)calloc(HSIZE+1, sizeof(byte));
  268.     length_nodes = (sf_node *) suffix_of;  /* 2*LENVALS nodes */
  269.     distance_nodes = (sf_node *) stack;    /* 2*DISTVALS nodes */
  270.    
  271.     for (a=0; a<30; a+=1)
  272.     {
  273.         argstr[a] = &args[a*64];
  274.     }
  275. start:
  276.     tflag = vflag=cflag=aflag=dflag=Uflag=quietflg=lcflag=zflag = 0;
  277.     argc = ccommand(&argv);
  278.     SetPt(&p, 40,40);
  279.  
  280.     SFGetFile(p, "\pSpecify ZIP file:", 0L, -1, sfT, 0L, &fileRep);
  281.     if (!fileRep.good)
  282.         exit(1);
  283.     macfstest(fileRep.vRefNum, true);
  284.     SetMacVol(NULL, fileRep.vRefNum);
  285.     for (a=1; a<argc; a+=1)
  286.     {
  287.         if (argv[a][0] == '-')
  288.         {
  289.             BlockMove(argv[a], argstr[a], (strlen(argv[a])>63) ? 64 : strlen(argv[a])+1);
  290.         }
  291.         else
  292.             break;
  293.     }
  294.     PtoCstr((char *)fileRep.fName);
  295.     strcpy(argstr[a], fileRep.fName);
  296.     for (;a<argc; a+=1)
  297.     {
  298.         BlockMove(argv[a], argstr[a+1], (strlen(argv[a])>63) ? 64 : strlen(argv[a])+1);
  299.     }
  300.     argc+=1;
  301.     argv = argstr;
  302.  
  303. #endif /* THINK_C */
  304. #endif /* MACOS */
  305.  
  306. /*---------------------------------------------------------------------------
  307.     Debugging info for checking on structure padding:
  308.   ---------------------------------------------------------------------------*/
  309.  
  310. #ifdef DEBUG_STRUC
  311.     printf("local_file_header size: %X\n",
  312.            sizeof(struct local_file_header));
  313.     printf("local_byte_header size: %X\n",
  314.            sizeof(struct local_byte_header));
  315.     printf("actual size of local headers: %X\n", LREC_SIZE);
  316.  
  317.     printf("central directory header size: %X\n",
  318.            sizeof(struct central_directory_file_header));
  319.     printf("central directory byte header size: %X\n",
  320.            sizeof(struct central_directory_byte_header));
  321.     printf("actual size of central dir headers: %X\n", CREC_SIZE);
  322.  
  323.     printf("end central dir record size: %X\n",
  324.            sizeof(struct end_central_dir_record));
  325.     printf("end central dir byte record size: %X\n",
  326.            sizeof(struct end_central_byte_record));
  327.     printf("actual size of end-central-dir record: %X\n", ECREC_SIZE);
  328. #endif
  329.  
  330. #ifndef KNOW_IT_WORKS  /* define this to save space, if things already work */
  331. #ifndef DOS_OS2        /* already works (no RISCy OS/2's yet...) */
  332. #ifndef NOTINT16       /* whole point is to see if this NEEDS defining */
  333.     {
  334.         int error=0;
  335.         long testsig;
  336.         static char *mach_type[3] = {"big-endian",
  337.           "structure-padding", "big-endian and structure-padding"};
  338.         strcpy((char *)&testsig,"012");
  339.         if (testsig != 0x00323130)
  340.             error = 1;
  341.         if (sizeof(central_directory_file_header) != CREC_SIZE)
  342.             error += 2;
  343.         if (error--)
  344.             fprintf(stderr, "It appears that your machine is %s.  If errors\n\
  345. occur, please try recompiling with \"NOTINT16\" defined (read the\n\
  346. Makefile, or try \"make hp\").\n\n", mach_type[error]);
  347.     }
  348. #endif /* !NOTINT16 */
  349. #endif /* !DOS_OS2 */
  350. #endif /* !KNOW_IT_WORKS */
  351.  
  352. /*---------------------------------------------------------------------------
  353.     Rip through any command-line options lurking about...
  354.   ---------------------------------------------------------------------------*/
  355.  
  356.     while (--argc > 0 && (*++argv)[0] == '-') {
  357.         s = argv[0] + 1;
  358.         while ((c = *s++) != 0) {    /* "!= 0":  prevent Turbo C warning */
  359.             switch (c) {
  360.             case ('x'): /* just ignore -x, -e options (extract) */
  361.             case ('e'):
  362.                 break;
  363.             case ('q'):
  364.                 ++quietflg;
  365.                 break;
  366.             case ('t'):
  367.                 ++tflag;
  368.                 break;
  369.             case ('v'):
  370.                 ++vflag;
  371.                 /* fall thru */
  372.             case ('l'):
  373.                 ++vflag;
  374.                 break;
  375.             case ('p'):
  376.                 ++cflag;
  377. #ifdef NATIVE
  378.                 ++aflag;
  379. #endif
  380.                 quietflg += 2;
  381.                 break;
  382.             case ('c'):
  383.                 ++cflag;
  384. #ifdef NATIVE
  385.                 ++aflag;        /* this is so you can read it on the screen */
  386. #endif
  387.                 break;
  388.             case ('a'):
  389.                 ++aflag;
  390.                 break;
  391. #ifdef VMS
  392.             case ('u'): /* switches converted to l.c. unless quoted */
  393. #endif
  394.             case ('U'): /* "uppercase flag" (i.e., don't convert) */
  395.                 ++Uflag;
  396.                 break;
  397.             case ('V'): /* Version flag:  retain VMS/DEC-20 file versions */
  398.                 ++V_flag;
  399.                 break;
  400.             case ('d'): /* create parent dirs flag */
  401. #ifdef MACOS
  402.                 if (hfsflag == true)
  403. #endif
  404.                 ++dflag;
  405.                 break;
  406.             case ('o'): /* OK to overwrite files without prompting */
  407.                 ++do_all;
  408.                 break;
  409.             case ('z'): /* Display only the archive commentp */
  410.                 ++zflag;
  411.                 break;
  412.             default:
  413.                 if (print_usage) {
  414.                     usage();
  415.                     print_usage = FALSE;
  416.                 }
  417.                 break;
  418.             }
  419.         }
  420.     }
  421.  
  422. /*---------------------------------------------------------------------------
  423.     Make sure we aren't trying to do too many things here.  [This seems like
  424.     kind of a brute-force way to do things; but aside from that, isn't the
  425.     -a option useful when listing the directory (i.e., for reading zipfile
  426.     comments)?  It's a modifier, not an action in and of itself, so perhaps
  427.     it should not be included in the test--certainly, in the case of zipfile
  428.     testing, it can just be ignored.]
  429.   ---------------------------------------------------------------------------*/
  430.  
  431.     if ((tflag && vflag) || (tflag && cflag) || (vflag && cflag) ||
  432.         (tflag && aflag) || (aflag && vflag)) {
  433.         fprintf(stderr, "only one of -t, -c, -a, or -v\n");
  434.         RETURN(10);             /* 10:  bad or illegal parameters specified */
  435.     }
  436.     if (quietflg && zflag)
  437.         quietflg = 0;
  438.     if (argc-- == 0) {
  439.         if (print_usage)
  440.             usage();
  441.         RETURN(10);             /* 10:  bad or illegal parameters specified */
  442.     }
  443. /*---------------------------------------------------------------------------
  444.     Now get the zipfile name from the command line and see if it exists as a
  445.     regular (non-directory) file.  If not, append the ".zip" suffix.  We don't
  446.     immediately check to see if this results in a good name, but we will do so
  447.     later.  In the meantime, see if there are any member filespecs on the com-
  448.     mand line, and if so, set the filename pointer to point at them.
  449.   ---------------------------------------------------------------------------*/
  450.  
  451.     strcpy(zipfn, *argv++);
  452.     if (stat(zipfn, &statbuf) || (statbuf.st_mode & S_IFMT) == S_IFDIR)
  453.         strcat(zipfn, ZSUFX);
  454.  
  455.     if (stat(zipfn, &statbuf)) {/* try again */
  456.         fprintf(stderr, "error:  can't find zipfile [ %s ]\n", zipfn);
  457.         RETURN(9);              /* 9:  file not found */
  458.     } else
  459.         ziplen = statbuf.st_size;
  460.  
  461.     if (argc != 0) {
  462.         fnv = argv;
  463.         process_all_files = FALSE;
  464.     } else
  465.         process_all_files = TRUE;       /* for speed */
  466.  
  467. /*---------------------------------------------------------------------------
  468.     Okey dokey, we have everything we need to get started.  Let's roll.
  469.   ---------------------------------------------------------------------------*/
  470.  
  471.     inbuf = (byte *) (malloc(INBUFSIZ + 4));    /* 4 extra for hold[] (below) */
  472.   outbuf = (byte *) (malloc(OUTBUFSIZ + 1));  /* 1 extra for string termin. */
  473.     if (aflag)                  /* if need an ascebc scratch, */
  474.         outout = (byte *) (malloc(OUTBUFSIZ));
  475.     else                        /*  allocate it... */
  476.         outout = outbuf;        /*  else just point to outbuf */
  477.  
  478.     if ((inbuf == NULL) || (outbuf == NULL) || (outout == NULL)) {
  479.         fprintf(stderr, "error:  can't allocate unzip buffers\n");
  480.         RETURN(4);              /* 4-8:  insufficient memory */
  481.     }
  482.     hold = &inbuf[INBUFSIZ];    /* to check for boundary-spanning signatures */
  483.  
  484. #ifdef THINK_C
  485.     if (!process_zipfile())
  486.         goto start;
  487. #else
  488.     RETURN(process_zipfile());  /* keep passing errors back... */
  489. #endif
  490.  
  491. }       /* end main() */
  492.  
  493.  
  494.  
  495.  
  496.  
  497. /*********************/
  498. /*  Function usage() */
  499. /*********************/
  500.  
  501. void usage()
  502. {
  503. #ifdef NATIVE
  504.     char *astring = "-a     convert ASCII to native character set";
  505. #else
  506. #ifdef MACOS
  507.     char *astring = "-a     convert to Mac textfile format (CR LF => CR)";
  508. #else
  509. #ifdef DOS_OS2
  510.     char *astring = "-a     convert to DOS & OS/2 textfile format (LF => CR LF)";
  511. #else
  512.     char *astring = "-a     convert to Unix/VMS textfile format (CR LF => LF)";
  513. #endif /* ?DOS_OS2 */
  514. #endif /* ?MACOS */
  515. #endif /* ?NATIVE */
  516.  
  517.  
  518.     fprintf(stderr, "UnZip:  Zipfile Extract %s;  (C) 1989 Samuel H. Smith\n",
  519.                  VERSION);
  520.     fprintf(stderr, "Courtesy of:  S.H.Smith  and  The Tool Shop BBS,  \
  521. (602) 279-2673.\n\n");
  522.     fprintf(stderr, "Versions 3.0 and later brought to you by the fine folks \
  523. at Info-ZIP\n");
  524.     fprintf(stderr, "(Info-ZIP@WSMR-SIMTEL20.Army.Mil)\n\n");
  525.     fprintf(stderr, "Usage:  unzip [ -xecptlvz[qadoUV] ] file[.zip] [filespec...]\n\
  526.   -x,-e  extract files in archive (default--i.e., this flag is optional)\n\
  527.   -c     extract files to stdout (\"CRT\")\n\
  528.   -p     extract files to stdout and no informational messages (for pipes)\n\
  529.   -t     test files\n\
  530.   -l     list files (short format)\n\
  531.   -v     verbose listing of files\n");
  532.     fprintf(stderr, "\
  533.   -z     display only the archive comment\n\
  534.   -q     perform operations quietly (up to two q's allowed)\n\
  535.   %s\n\
  536.   -d     include directory structure when extracting/listing\n\
  537.   -o     OK to overwrite files without prompting\n\
  538.   -U     don't map filenames to lowercase for selected (uppercase) OS's\n\
  539.   -V     retain file version numbers\n", astring);
  540.  
  541. #ifdef VMS
  542.     fprintf(stderr, "Remember that non-lowercase filespecs must be quoted in \
  543. VMS (e.g., \"Makefile\").\n");
  544. #endif
  545.  
  546. }       /* end function usage() */
  547.  
  548. #else
  549. /* MS Windows Setup  and Take-Down functions bracket calls to 
  550.  * process_zipfile().
  551. .* These functions allocate and free the necessary buffers, set and clear
  552.  * any global variables so that  process_zipfile()  can be called multiple
  553.  * times in the same session of WizUnzip. You'll recognize some of the 
  554.  * code from main() in SetUpToProcessZipFile().
  555.  */
  556. HANDLE hOutBuf;
  557. HANDLE hOutOut;    /* added 04/03/92 for version 1.1                        */
  558. HANDLE hInBuf;
  559. HANDLE hZipFN;
  560. HANDLE hFileName;
  561.  
  562. BOOL SetUpToProcessZipFile(int ncflag, int ntflag, int nvflag, int nUflag, 
  563.                 int nzflag, int ndflag, int noflag, int naflag, int argc, PSTR psZipFN, PSTR *FNV)
  564. {
  565. /* clear all global flags -- need to or not.
  566.  */
  567.     tflag = vflag=cflag=aflag=dflag=Uflag=quietflg=lcflag=zflag = 0;
  568.     fnv = &fnames[0];        /* assign default file name vector */
  569.  
  570.     cflag = ncflag ;  dflag = ndflag;  do_all = noflag;
  571.     tflag = ntflag ; vflag = nvflag; zflag = nzflag; Uflag = nUflag; 
  572.     aflag = naflag;
  573.  
  574.    if (!(hZipFN = LocalAlloc(LMEM_MOVEABLE, FILNAMSIZ)))
  575.    {
  576.         return FALSE;
  577.    }
  578.    zipfn = (char *)LocalLock(hZipFN);
  579.    strcpy(zipfn, psZipFN);
  580.     if (stat(zipfn, &statbuf) || (statbuf.st_mode & S_IFMT) == S_IFDIR)
  581.         strcat(zipfn, ZSUFX);
  582.  
  583.     if (stat(zipfn, &statbuf)) {/* try again */
  584.         fprintf(stderr, "error:  can't find zipfile [ %s ]\n", zipfn);
  585.         return TRUE;              /* 9:  file not found */
  586.     } else
  587.         ziplen = statbuf.st_size;
  588.  
  589.     if (argc != 0) {
  590.         fnv = FNV;
  591.         process_all_files = FALSE;
  592.     } else
  593.         process_all_files = TRUE;       /* for speed */
  594.  
  595. /*---------------------------------------------------------------------------
  596.     Okey dokey, we have everything we need to get started.  Let's roll.
  597.   ---------------------------------------------------------------------------*/
  598.  
  599.     if (hInBuf = LocalAlloc(LMEM_MOVEABLE, INBUFSIZ + 4))  /* 4 extra for hold[] (below) */
  600.     {
  601.         inbuf = (byte *) LocalLock(hInBuf);  /* lock your block        */
  602.         WinAssert(inbuf);    /* make sure we got it                    */
  603.     }
  604.     if (hOutBuf = LocalAlloc(LMEM_MOVEABLE,OUTBUFSIZ + 1)) /* 1 extra for string termin. */
  605.     {
  606.           outbuf = (byte *) LocalLock(hOutBuf);
  607.         WinAssert(outbuf);    /* make sure we got it                */
  608.         if (aflag)                /* if LF => CR,LF translation        */
  609.         {
  610.             if (hOutOut = GlobalAlloc(GMEM_MOVEABLE,OUTBUFSIZ)) 
  611.             {
  612.                 outout = (byte _far *)GlobalLock(hOutOut);
  613.                 WinAssert(outout);    /* make sure we got it                */
  614.             }
  615.         }
  616.         else    /* no translation; just re-use output buffer            */
  617.         {
  618.             outout = (byte _far *)outbuf;        /*  point to outbuf */
  619.         }
  620.     }
  621.     if ( hFileName = LocalAlloc(LMEM_MOVEABLE, FILNAMSIZ))
  622.     {
  623.         filename = (char *)LocalLock(hFileName);
  624.         WinAssert(filename);        /* make sure we got it            */
  625.     }
  626.  
  627.     if ((inbuf == NULL) || (outbuf == NULL) || (outout == NULL) ||
  628.         (zipfn == NULL) || (filename == NULL)) {
  629.         return FALSE;
  630.     }
  631.     hold = &inbuf[INBUFSIZ];    /* to check for boundary-spanning signatures */
  632.  
  633.     return TRUE;    /* set up was OK                        */
  634. }
  635.  
  636. void TakeDownFromProcessZipFile(void)
  637. {
  638.  
  639.     if (inbuf)
  640.     {
  641.         LocalUnlock(hInBuf);
  642.         inbuf = NULL;
  643.     }
  644.     if (hInBuf)
  645.     {
  646.         hInBuf = LocalFree(hInBuf);
  647.     }
  648.     if (outbuf)
  649.     {
  650.         LocalUnlock(hOutBuf);
  651.         outbuf = NULL;
  652.     }
  653.     if (hOutBuf)
  654.     {
  655.         hOutBuf = LocalFree(hOutBuf);
  656.     }
  657.     if (aflag && outout)    /* if doing LF => CR,LF translation        */
  658.     {
  659.         GlobalUnlock(hOutOut);
  660.     }
  661.     outout = NULL;            /* free now, translation or not            */
  662.     if (hOutOut)
  663.     {
  664.         hOutOut = GlobalFree(hOutOut);    /* mark buffer as freed        */
  665.     }
  666.     if (zipfn)
  667.     {
  668.         LocalUnlock(hZipFN);
  669.         zipfn = NULL;
  670.     }
  671.     if (hZipFN)
  672.     {
  673.         hZipFN = LocalFree(hZipFN);
  674.     }
  675.     if (filename)
  676.     {
  677.         LocalUnlock(hFileName);
  678.         filename = NULL;
  679.     }
  680.     if (hFileName)
  681.     {
  682.         hFileName = LocalFree(hFileName);
  683.     }
  684. }
  685. #endif
  686.  
  687.  
  688.  
  689.  
  690.  
  691. /*******************************/
  692. /*  Function process_zipfile() */
  693. /*******************************/
  694.  
  695. int process_zipfile()
  696. /* return PK-type error code */
  697. {
  698.     int error=0, error_in_archive;
  699.  
  700.  
  701.  
  702. /*---------------------------------------------------------------------------
  703.     Open the zipfile for reading and in BINARY mode to prevent CR/LF trans-
  704.     lation, which would corrupt the bitstreams.  Then find and process the
  705.     central directory; list, extract or test member files as instructed; and
  706.     close the zipfile.
  707.   ---------------------------------------------------------------------------*/
  708.  
  709. #ifdef VMS
  710.     {
  711.         int rtype;
  712.  
  713.         VMSmunch(zipfn, GET_RTYPE, (char *)&rtype);
  714.         if (rtype == FAT$C_VARIABLE) {
  715.             fprintf(stderr,
  716.      "\n     Error:  zipfile is in variable-length record format.  Please\n\
  717.      run \"bilf l %s\" to convert the zipfile to stream-LF\n\
  718.      record format.  (Both bilf.c and make_bilf.com are included\n\
  719.      in the VMS unzip distribution.)\n\n", zipfn);
  720.             return 2;           /* 2:  error in zipfile */
  721.         }
  722.         rtype = FAT$C_STREAMLF; /* Unix I/O loves it */
  723.         VMSmunch(zipfn, CHANGE_RTYPE, (char *)&rtype);
  724.     }
  725. #endif
  726.     if (open_input_file())      /* this should never happen, given the */
  727.         return (9);             /*   stat() test in main(), but... */
  728.  
  729.     if (find_end_central_dir()) /* not found; nothing to do */
  730.         return (2);             /* 2:  error in zipfile */
  731.  
  732. #ifdef TEST
  733.     printf("\n  found end-of-central-dir signature at offset %ld (%.8lXh)\n",
  734.       cur_zipfile_bufstart+(inptr-inbuf), cur_zipfile_bufstart+(inptr-inbuf) );
  735.     printf("    from beginning of file; offset %d (%.4Xh) within block\n",
  736.       inptr-inbuf, inptr-inbuf);
  737. #endif
  738.  
  739.     if ((error_in_archive = process_end_central_dir()) > 1)
  740.         return (error_in_archive);
  741.  
  742.     if (zflag)
  743. #ifdef MSWIN
  744.     {
  745.        close(zipfd);
  746.     return(0);
  747.     }
  748. #else
  749.         return (0);
  750. #endif
  751.  
  752. #ifndef PAKFIX
  753.     if (ecrec.number_this_disk == 0) {
  754. #else /* PAKFIX */
  755.     if (ecrec.number_this_disk == 0  ||  (error = (ecrec.number_this_disk == 1
  756.         && ecrec.num_disk_with_start_central_dir == 1))) {
  757.  
  758.         if (error) {
  759.             fprintf(stderr,
  760.      "\n     Warning:  zipfile claims to be disk 2 of a two-part archive;\n\
  761.      attempting to process anyway.  If no further errors occur, this\n\
  762.      archive was probably created by PAK v2.5 or earlier.  This bug\n\
  763.      has been reported to NoGate and should be fixed by mid-April 1991.\n\n");
  764.             error_in_archive = 1;  /* 1:  warning */
  765.         }
  766. #endif /* ?PAKFIX */
  767.         if (vflag)
  768.             error = list_files();       /* LIST 'EM */
  769.         else
  770.             error = extract_or_test_files();    /* EXTRACT OR TEST 'EM */
  771.         if (error > error_in_archive)   /* don't overwrite stronger error */
  772.             error_in_archive = error;   /*  with (for example) a warning */
  773.     } else {
  774.         fprintf(stderr, "\nerror:  zipfile is part of multi-disk archive \
  775. (sorry, no can do).\n");
  776. #ifdef STUPID_DAMNED_REPORTS    /* v4.11 No more damned reports! */
  777.         fprintf(stderr, ReportMsg);   /* report to info-zip */
  778. #endif
  779.         error_in_archive = 11;  /* 11:  no files found */
  780.     }
  781.  
  782.     close(zipfd);
  783. #ifdef VMS
  784.     VMSmunch(zipfn, RESTORE_RTYPE, NULL);
  785. #endif
  786.     return (error_in_archive);
  787.  
  788. }       /* end function process_zipfile() */
  789.  
  790.  
  791.  
  792.  
  793.  
  794. /************************************/
  795. /*  Function find_end_central_dir() */
  796. /************************************/
  797.  
  798. int find_end_central_dir()
  799. /* return 0 if found, 1 otherwise */
  800. {
  801.     int i, numblks;
  802.     longint tail_len;
  803.  
  804.  
  805.  
  806. /*---------------------------------------------------------------------------
  807.     Treat case of short zipfile separately.
  808.   ---------------------------------------------------------------------------*/
  809.  
  810.     if (ziplen <= INBUFSIZ) {
  811.         lseek(zipfd, 0L, SEEK_SET);
  812.         if ((incnt = read(zipfd,inbuf,(unsigned int)ziplen)) == ziplen)
  813.  
  814.             /* 'P' must be at least 22 bytes from end of zipfile */
  815.             for ( inptr = inbuf+ziplen-22  ;  inptr >= inbuf  ;  --inptr )
  816.                 if ( (ascii_to_native(*inptr) == 'P')  &&
  817.                       !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  818.                     incnt -= inptr - inbuf;
  819.                     return(0);  /* found it! */
  820.                 }               /* ...otherwise fall through & fail */
  821.  
  822. /*---------------------------------------------------------------------------
  823.     Zipfile is longer than INBUFSIZ:  may need to loop.  Start with short
  824.     block at end of zipfile (if not TOO short).
  825.   ---------------------------------------------------------------------------*/
  826.  
  827.     } else {
  828.         if ((tail_len = ziplen % INBUFSIZ) > ECREC_SIZE) {
  829.             cur_zipfile_bufstart = lseek(zipfd, ziplen-tail_len, SEEK_SET);
  830.             if ((incnt = read(zipfd,inbuf,(unsigned int)tail_len)) != tail_len)
  831.                 goto fail;      /* shut up, it's expedient. */
  832.  
  833.             /* 'P' must be at least 22 bytes from end of zipfile */
  834.             for ( inptr = inbuf+tail_len-22  ;  inptr >= inbuf  ;  --inptr )
  835.                 if ( (ascii_to_native(*inptr) == 'P')  &&
  836.                       !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  837.                     incnt -= inptr - inbuf;
  838.                     return(0);  /* found it! */
  839.                 }               /* ...otherwise search next block */
  840.             strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
  841.                                                            boundary */
  842.  
  843.         } else {
  844.             cur_zipfile_bufstart = ziplen - tail_len;
  845.         }
  846.  
  847.         /*
  848.          * Loop through blocks of zipfile data, starting at the end and going
  849.          * toward the beginning.  Need only check last 65557 bytes of zipfile:
  850.          * comment may be up to 65535 bytes long, end-of-central-directory rec-
  851.          * ord is 18 bytes (shouldn't hardcode this number, but what the hell:
  852.          * already did so above (22=18+4)), and sig itself is 4 bytes.
  853.          */
  854.  
  855.         /*          ==amt to search==   ==done==   ==rounding==     =blksiz= */
  856.         numblks = ( min(ziplen,65557) - tail_len + (INBUFSIZ-1) ) / INBUFSIZ;
  857.  
  858.         for ( i = 1  ;  i <= numblks  ;  ++i ) {
  859.             cur_zipfile_bufstart -= INBUFSIZ;
  860.             lseek(zipfd, cur_zipfile_bufstart, SEEK_SET);
  861.             if ((incnt = read(zipfd,inbuf,INBUFSIZ)) != INBUFSIZ)
  862.                 break;          /* fall through and fail */
  863.  
  864.             for ( inptr = inbuf+INBUFSIZ-1  ;  inptr >= inbuf  ;  --inptr )
  865.                 if ( (ascii_to_native(*inptr) == 'P')  &&
  866.                       !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  867.                     incnt -= inptr - inbuf;
  868.                     return(0);  /* found it! */
  869.                 }
  870.             strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
  871.                                                            boundary */
  872.         }
  873.  
  874.     } /* end if (ziplen > INBUFSIZ) */
  875.  
  876. /*---------------------------------------------------------------------------
  877.     Searched through whole region where signature should be without finding
  878.     it.  Print informational message and die a horrible death.
  879.   ---------------------------------------------------------------------------*/
  880.  
  881. fail:
  882.  
  883.     fprintf(stderr, "\nFile:  %s\n\n\
  884.      End-of-central-directory signature not found.  Either this file is not\n\
  885.      a zipfile, or it constitutes one disk of a multi-part archive.  In the\n\
  886.      latter case the central directory and zipfile comment will be found on\n\
  887.      the last disk(s) of this archive.\n", zipfn);
  888.     return(1);
  889.  
  890. }       /* end function find_end_central_dir() */
  891.  
  892.  
  893.  
  894.  
  895.  
  896. /***************************************/
  897. /*  Function process_end_central_dir() */
  898. /***************************************/
  899.  
  900. int process_end_central_dir()
  901. /* return PK-type error code */
  902. {
  903. #ifdef NOTINT16
  904.     end_central_byte_record byterec;
  905. #endif
  906.     int error=0;
  907.  
  908.  
  909.  
  910. /*---------------------------------------------------------------------------
  911.     Read the end-of-central-directory record and do any necessary machine-
  912.     type conversions (byte ordering, structure padding compensation).
  913.   ---------------------------------------------------------------------------*/
  914.  
  915. #ifndef NOTINT16
  916.     if (readbuf((char *) &ecrec, ECREC_SIZE+4) <= 0)
  917.         return (51);            /* 51:  unexpected EOF */
  918.  
  919. #else  /* NOTINT16:  read data into character array, then copy to struct */
  920.     if (readbuf((char *) byterec, ECREC_SIZE+4) <= 0)
  921.         return (51);
  922.  
  923.     ecrec.number_this_disk =
  924.         makeword(&byterec[NUMBER_THIS_DISK]);
  925.     ecrec.num_disk_with_start_central_dir =
  926.         makeword(&byterec[NUM_DISK_WITH_START_CENTRAL_DIR]);
  927.     ecrec.num_entries_centrl_dir_ths_disk =
  928.         makeword(&byterec[NUM_ENTRIES_CENTRL_DIR_THS_DISK]);
  929.     ecrec.total_entries_central_dir =
  930.         makeword(&byterec[TOTAL_ENTRIES_CENTRAL_DIR]);
  931.     ecrec.size_central_directory =
  932.         makelong(&byterec[SIZE_CENTRAL_DIRECTORY]);
  933.     ecrec.offset_start_central_directory =
  934.         makelong(&byterec[OFFSET_START_CENTRAL_DIRECTORY]);
  935.     ecrec.zipfile_comment_length =
  936.         makeword(&byterec[ZIPFILE_COMMENT_LENGTH]);
  937. #endif  /* NOTINT16 */
  938.  
  939. /*---------------------------------------------------------------------------
  940.     Get the zipfile comment, if any, and print it out.  (Comment may be up
  941.     to 64KB long.  May the fleas of a thousand camels infest the armpits of
  942.     anyone who actually takes advantage of this fact.)  Then position the
  943.     file pointer to the beginning of the central directory and fill buffer.
  944.   ---------------------------------------------------------------------------*/
  945. #ifdef MSWIN
  946.    wCommentLength =  ecrec.zipfile_comment_length; /* save for comment button */
  947.     if (ecrec.zipfile_comment_length && zflag) {
  948. #else
  949.     if (ecrec.zipfile_comment_length && !quietflg) {
  950.         if (!zflag)
  951.           printf("[%s] comment:  ", zipfn);
  952. #endif
  953.         if (do_string(ecrec.zipfile_comment_length,DISPLAY)) {
  954.             fprintf(stderr, "\nwarning:  zipfile comment truncated\n");
  955.             error = 1;          /* 1:  warning error */
  956.         }
  957.         if (!zflag)
  958.           printf("\n\n");
  959.     }
  960.     LSEEK( ULONG_(ecrec.offset_start_central_directory) )
  961.  
  962.     return (error);
  963.  
  964. }       /* end function process_end_central_dir() */
  965.  
  966.  
  967.  
  968. #ifdef MSWIN
  969.     /* Referenced from UpdateListBox() in UPDATELB.C
  970.      */
  971.     char *Headers[][2] =
  972.     {
  973.         {" Length    Date    Time    Name",
  974.          " ------    ----    ----    ----"},
  975.         {" Length  Method   Size  Ratio   Date    Time   CRC-32     Name",
  976.          " ------  ------   ----  -----   ----    ----   ------     ----"}};
  977. #endif
  978.  
  979.  
  980. /**************************/
  981. /*  Function list_files() */
  982. /**************************/
  983.  
  984. int list_files()
  985. /* return PK-type error code */
  986. {
  987.     char **fnamev;
  988.     int do_this_file = FALSE, ratio, error, error_in_archive = 0;
  989.     int which_hdr = (vflag > 1);
  990.     UWORD j, yr, mo, dy, hh, mm, members = 0;
  991.     ULONG tot_csize = 0L, tot_ucsize = 0L;
  992.     static char *method[NUM_METHODS + 1] =
  993.     {"Stored", "Shrunk", "Reduce1", "Reduce2",
  994.      "Reduce3", "Reduce4", "Implode", "Unknown"};
  995. #ifdef MSWIN
  996.     PSTR    psLBEntry;    /* list box entry                    */
  997. #else
  998.     static char *Headers[][2] =
  999.     {
  1000.         {" Length    Date    Time    Name",
  1001.          " ------    ----    ----    ----"},
  1002.         {" Length  Method   Size  Ratio   Date    Time   CRC-32     Name",
  1003.          " ------  ------   ----  -----   ----    ----   ------     ----"}};
  1004. #endif
  1005.  
  1006.  
  1007.  
  1008. /*---------------------------------------------------------------------------
  1009.     Unlike extract_or_test_files(), this routine confines itself to the cen-
  1010.     tral directory.  Thus its structure is somewhat simpler, since we can do
  1011.     just a single loop through the entire directory, listing files as we go.
  1012.  
  1013.     So to start off, print the heading line and then begin main loop through
  1014.     the central directory.  The results will look vaguely like the following:
  1015.  
  1016.   Length  Method   Size  Ratio   Date    Time   CRC-32     Name ("^" ==> case
  1017.   ------  ------   ----  -----   ----    ----   ------     ----   conversion)
  1018.    44004  Implode  13041  71%  11-02-89  19:34  8b4207f7   Makefile.UNIX
  1019.     3438  Shrunk    2209  36%  09-15-90  14:07  a2394fd8  ^dos-file.ext
  1020.   ---------------------------------------------------------------------------*/
  1021. #ifndef MSWIN
  1022.     if (quietflg < 2)
  1023.         if (Uflag)
  1024.             printf("%s\n%s\n", Headers[which_hdr][0], Headers[which_hdr][1]);
  1025.         else
  1026.             printf("%s (\"^\" ==> case\n%s   conversion)\n", 
  1027.               Headers[which_hdr][0], Headers[which_hdr][1]);
  1028.  
  1029. #endif
  1030.     for (j = 0; j < ecrec.total_entries_central_dir; ++j) {
  1031.  
  1032.         if (readbuf(sig, 4) <= 0)
  1033.             return (51);        /* 51:  unexpected EOF */
  1034.         if (strncmp(sig, CENTRAL_HDR_SIG, 4)) {  /* just to make sure */
  1035.             fprintf(stderr, CentSigMsg, j);  /* sig not found */
  1036. #ifdef STUPID_DAMNED_REPORTS    /* No more damned reports! */
  1037.             fprintf(stderr, ReportMsg);   /* report to info-zip */
  1038. #endif
  1039.             return (3);         /* 3:  error in zipfile */
  1040.         }
  1041.         if ((error = process_central_file_header()) != 0)  /* (sets lcflag) */
  1042.             return (error);     /* only 51 (EOF) defined */
  1043.  
  1044.         /*
  1045.          * We could DISPLAY the filename instead of storing (and possibly trun-
  1046.          * cating, in the case of a very long name) and printing it, but that
  1047.          * has the disadvantage of not allowing case conversion--and it's nice
  1048.          * to be able to see in the listing precisely how you have to type each
  1049.          * filename in order for unzip to consider it a match.  Speaking of
  1050.          * which, if member names were specified on the command line, check in
  1051.          * with match() to see if the current file is one of them, and make a
  1052.          * note of it if it is.
  1053.          */
  1054.  
  1055.         if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
  1056.             error_in_archive = error;  /* (uses lcflag)---^   */
  1057.             if (error > 1)      /* fatal:  can't continue */
  1058.                 return (error);
  1059.         }
  1060.         if ((error = do_string(crec.extra_field_length, SKIP)) != 0) {
  1061.             error_in_archive = error;   /* might be just warning */
  1062.             if (error > 1)      /* fatal */
  1063.                 return (error);
  1064.         }
  1065.         if (!process_all_files) {   /* check if specified on command line */
  1066.             do_this_file = FALSE;
  1067.             fnamev = fnv;       /* don't destroy permanent filename ptr */
  1068.             for (--fnamev; *++fnamev;)
  1069.                 if (match(filename, *fnamev)) {
  1070.                     do_this_file = TRUE;
  1071.                     break;      /* found match, so stop looping */
  1072.                 }
  1073.         }
  1074.         /*
  1075.          * If current file was specified on command line, or if no names were
  1076.          * specified, do the listing for this file.  Otherwise, get rid of the
  1077.          * file comment and go back for the next file.
  1078.          */
  1079.  
  1080.         if (process_all_files || do_this_file) {
  1081.  
  1082.             yr = (((crec.last_mod_file_date >> 9) & 0x7f) + 80) % 100;
  1083.             mo = (crec.last_mod_file_date >> 5) & 0x0f;
  1084.             dy = crec.last_mod_file_date & 0x1f;
  1085.             hh = (crec.last_mod_file_time >> 11) & 0x1f;
  1086.             mm = (crec.last_mod_file_time >> 5) & 0x3f;
  1087.  
  1088.             csize = (longint) ULONG_(crec.compressed_size);
  1089.             ucsize = (longint) ULONG_(crec.uncompressed_size);
  1090.             if (crec.general_purpose_bit_flag & 1)
  1091.                 csize -= 12;    /* if encrypted, don't count encrypt hdr */
  1092.  
  1093.             ratio = (ucsize == 0) ? 0 :   /* .zip can have 0-length members */
  1094.                 ((ucsize > 2000000) ?     /* risk signed overflow if mult. */
  1095.                 (int) ((ucsize-csize) / (ucsize/1000L)) + 5 :   /* big */
  1096.                 (int) ((1000L*(ucsize-csize)) / ucsize) + 5);   /* small */
  1097.  
  1098. #ifdef MSWIN
  1099. #ifdef NEED_EARLY_REDRAW
  1100.            /* turn on listbox redrawing just before adding last line
  1101.               */
  1102.             if (j == (ecrec.total_entries_central_dir-1))
  1103.         {
  1104.         int nRetVal = 
  1105.                  SendMessage(hWndList, WM_SETREDRAW, TRUE, 0L);
  1106.         }
  1107. #endif
  1108.             psLBEntry = (PSTR)LocalAlloc(LMEM_FIXED,FILNAMSIZ+LONG_FORM_FNAME_INX );
  1109.  switch (which_hdr) {
  1110.             case 0:             /* short form */
  1111.                 OemToAnsi(filename, filename);    /* translate to ANSI    */
  1112.                 wsprintf(psLBEntry, "%7ld  %02u-%02u-%02u  %02u:%02u  %c%s",
  1113.                        (long)ucsize, mo, dy, yr, hh, mm, (lcflag?'^':' '),(LPSTR) filename);
  1114.                 SendMessage(hWndList, LB_ADDSTRING, 0, (LONG)(LPSTR)psLBEntry);
  1115.     
  1116.                 break;
  1117.             case 1:             /* verbose */
  1118.                 OemToAnsi(filename, filename);    /* translate to ANSI    */
  1119.                 wsprintf(psLBEntry, 
  1120.                   "%7ld  %-7s%7ld %3d%%  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s",
  1121.                   (long)ucsize, (LPSTR)method[methnum], (long)csize, ratio/10, mo, dy, yr, hh, mm,
  1122.                   (unsigned long)ULONG_(crec.crc32), (lcflag?'^':' '), (LPSTR)filename);
  1123.                 SendMessage(hWndList, LB_ADDSTRING, 0, (LONG)(LPSTR)psLBEntry);
  1124.             }
  1125.             psLBEntry = (PSTR)LocalFree((HANDLE)psLBEntry);
  1126. #else
  1127.  switch (which_hdr) {
  1128.             case 0:             /* short form */
  1129.                printf("%7ld  %02u-%02u-%02u  %02u:%02u  %c%s\n",
  1130.                        ucsize, mo, dy, yr, hh, mm, (lcflag?'^':' '), filename);
  1131.                 break;
  1132.             case 1:             /* verbose */
  1133.                printf(
  1134.                   "%7ld  %-7s%7ld %3d%%  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s\n",
  1135.                   ucsize, method[methnum], csize, ratio/10, mo, dy, yr, hh, mm,
  1136.                   ULONG_(crec.crc32), (lcflag?'^':' '), filename);
  1137.             }
  1138. #endif
  1139.  
  1140.             error = do_string(crec.file_comment_length, (QCOND2 ? DISPLAY : SKIP));
  1141.             if (error) {
  1142.                 error_in_archive = error;  /* might be just warning */
  1143.                 if (error > 1)  /* fatal */
  1144.                     return (error);
  1145.             }
  1146.             tot_ucsize += (ULONG) ucsize;
  1147.             tot_csize += (ULONG) csize;
  1148.             ++members;
  1149.  
  1150.         } else {        /* not listing this file */
  1151.             if ((error = do_string(crec.file_comment_length, SKIP)) != 0) {
  1152.               error_in_archive = error;   /* might be warning */
  1153.               if (error > 1)      /* fatal */
  1154.                   return (error);
  1155.             }
  1156.         }
  1157.     }                   /* end for-loop (j: files in central directory) */
  1158.  
  1159. /*---------------------------------------------------------------------------
  1160.     Print footer line and totals (compressed size, uncompressed size, number
  1161.     of members in zipfile).
  1162.   ---------------------------------------------------------------------------*/
  1163.  
  1164.     ratio = (tot_ucsize == 0) ? 
  1165.         0 : ((tot_ucsize > 4000000) ?    /* risk unsigned overflow if mult. */
  1166.         (int) ((tot_ucsize - tot_csize) / (tot_ucsize/1000L)) + 5 :
  1167.         (int) ((tot_ucsize - tot_csize) * 1000L / tot_ucsize) + 5);
  1168.  
  1169.     if (quietflg < 2) {
  1170. #ifdef MSWIN
  1171.         /* Display just the totals since the dashed lines get displayed
  1172.          * in UpdateListBox(). Get just enough space to display total.
  1173.          */
  1174.         psLBEntry = (PSTR)LocalAlloc(LMEM_FIXED,LONG_FORM_FNAME_INX+12);
  1175.         switch (which_hdr) {
  1176.         case 0:         /* short */
  1177.             wsprintf(psLBEntry, "%7lu                    %-7u", 
  1178.                   (ULONG)tot_ucsize, members);
  1179.             SetWindowText(hWndTotalLine2 , (LPSTR)psLBEntry);
  1180.                break;
  1181.         case 1:         /* verbose */
  1182.             wsprintf(psLBEntry, 
  1183.                 "%7lu         %7lu %3d%%                              %-7u", 
  1184.                   (ULONG)tot_ucsize, (ULONG)tot_csize, ratio / 10, members);
  1185.             SetWindowText(hWndTotalLine2 , (LPSTR)psLBEntry);
  1186.         }
  1187.         psLBEntry = (PSTR)LocalFree((HANDLE)psLBEntry);
  1188. #else
  1189.         switch (which_hdr) {
  1190.         case 0:         /* short */
  1191.             printf("%s\n%7lu                    %-7u\n",
  1192.                    " ------                    -------",
  1193.                    tot_ucsize, members);
  1194.             break;
  1195.         case 1:         /* verbose */
  1196.             printf(
  1197.               "%s\n%7lu         %7lu %3d%%                              %-7u\n",
  1198.               " ------          ------  ---                              -------",
  1199.               tot_ucsize, tot_csize, ratio / 10, members);
  1200.         }
  1201. #endif
  1202.     }
  1203. /*---------------------------------------------------------------------------
  1204.     Double check that we're back at the end-of-central-directory record.
  1205.   ---------------------------------------------------------------------------*/
  1206.  
  1207.     readbuf(sig, 4);
  1208.     if (strncmp(sig, END_CENTRAL_SIG, 4)) {     /* just to make sure again */
  1209.         fprintf(stderr, EndSigMsg);  /* didn't find end-of-central-dir sig */
  1210. #ifdef STUPID_DAMNED_REPORTS    /* No more damned reports! */
  1211.         fprintf(stderr, ReportMsg);  /* report to info-zip */
  1212. #endif
  1213.         error_in_archive = 1;        /* 1:  warning error */
  1214.     }
  1215.     return (error_in_archive);
  1216.  
  1217. }       /* end function list_files() */
  1218.  
  1219.  
  1220.  
  1221.  
  1222.  
  1223. /*************************************/
  1224. /*  Function extract_or_test_files() */
  1225. /*************************************/
  1226.  
  1227. int extract_or_test_files()
  1228. /* return PK-type error code */
  1229. {
  1230.     char **fnamev;
  1231.     byte *cd_inptr;
  1232.     int cd_incnt, error, error_in_archive = 0;
  1233.     UWORD i, j, members_remaining;
  1234.     longint cd_bufstart, bufstart, inbuf_offset;
  1235.     struct min_info {
  1236.         unsigned f_attr;
  1237.         longint offset;
  1238.         int lcflag;
  1239.     } info[DIR_BLKSIZ];
  1240.  
  1241.  
  1242.  
  1243. /*---------------------------------------------------------------------------
  1244.     The basic idea of this function is as follows.  Since the central di-
  1245.     rectory lies at the end of the zipfile and the member files lie at the
  1246.     beginning or middle or wherever, it is not very desirable to simply
  1247.     read a central directory entry, jump to the member and extract it, and
  1248.     then jump back to the central directory.  In the case of a large zipfile
  1249.     this would lead to a whole lot of disk-grinding, especially if each mem-
  1250.     ber file is small.  Instead, we read from the central directory the per-
  1251.     tinent information for a block of files, then go extract/test the whole
  1252.     block.  Thus this routine contains two small(er) loops within a very
  1253.     large outer loop:  the first of the small ones reads a block of files
  1254.     from the central directory; the second extracts or tests each file; and
  1255.     the outer one loops over blocks.  There's some file-pointer positioning
  1256.     stuff in between, but that's about it.  Btw, it's because of this jump-
  1257.     ing around that we can afford to be lenient if an error occurs in one of
  1258.     the member files:  we should still be able to go find the other members,
  1259.     since we know the offset of each from the beginning of the zipfile.
  1260.  
  1261.     Begin main loop over blocks of member files.  We know the entire central
  1262.     directory is on this disk:  we would not have any of this information un-
  1263.     less the end-of-central-directory record was on this disk, and we would
  1264.     not have gotten to this routine unless this is also the disk on which
  1265.     the central directory starts.  In practice, this had better be the ONLY
  1266.     disk in the archive, but maybe someday we'll add multi-disk support.
  1267.   ---------------------------------------------------------------------------*/
  1268.  
  1269.     members_remaining = ecrec.total_entries_central_dir;
  1270.     while (members_remaining) {
  1271.         j = 0;
  1272.  
  1273.         /*
  1274.          * Loop through files in central directory, storing offsets, file
  1275.          * attributes, and case-conversion flags until block size is reached.
  1276.          */
  1277.  
  1278.         while (members_remaining && (j < DIR_BLKSIZ)) {
  1279.             --members_remaining;
  1280.  
  1281.             if (readbuf(sig, 4) <= 0) {
  1282.                 error_in_archive = 51;  /* 51:  unexpected EOF */
  1283.                 members_remaining = 0;  /* ...so no more left to do */
  1284.                 break;
  1285.             }
  1286.             if (strncmp(sig, CENTRAL_HDR_SIG, 4)) {  /* just to make sure */
  1287.                 fprintf(stderr, CentSigMsg, j);  /* sig not found */
  1288. #ifdef STUPID_DAMNED_REPORTS    /* No more damned reports! */
  1289.                 fprintf(stderr, ReportMsg);   /* report to info-zip */
  1290. #endif
  1291.                 error_in_archive = 3;   /* 3:  error in zipfile */
  1292.                 members_remaining = 0;  /* ...so no more left to do */
  1293.                 break;
  1294.             }
  1295.             /* (sets lcflag)-------v  */
  1296.             if ((error = process_central_file_header()) != 0) {
  1297.                 error_in_archive = error;   /* only 51 (EOF) defined */
  1298.                 members_remaining = 0;  /* ...so no more left to do */
  1299.                 break;
  1300.             }
  1301.             if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
  1302.                 if (error > error_in_archive)
  1303.                     error_in_archive = error;
  1304.                 if (error > 1) {  /* fatal:  no more left to do */
  1305.                     fprintf(stderr, FilNamMsg, filename, "central");
  1306.                     members_remaining = 0;
  1307.                     break;
  1308.                 }
  1309.             }
  1310.             if ((error = do_string(crec.extra_field_length, SKIP)) != 0) {
  1311.                 if (error > error_in_archive)
  1312.                     error_in_archive = error;
  1313.                 if (error > 1) {  /* fatal */
  1314.                     fprintf(stderr, ExtFieldMsg, filename, "central");
  1315.                     members_remaining = 0;
  1316.                     break;
  1317.                 }
  1318.             }
  1319.             if ((error = do_string(crec.file_comment_length, SKIP)) != 0) {
  1320.                 if (error > error_in_archive)
  1321.                     error_in_archive = error;
  1322.                 if (error > 1) {  /* fatal */
  1323.                     fprintf(stderr, "\n%s:  bad file comment length\n",
  1324.                             filename);
  1325.                     members_remaining = 0;
  1326.                     break;
  1327.                 }
  1328.             }
  1329.             if (process_all_files) {
  1330.                 if (crec.general_purpose_bit_flag & 1) {
  1331.                     fprintf(stderr, CryptMsg, filename);  /* encrypted: skip */
  1332.                     error_in_archive = 1;       /* 1:  warning error */
  1333.                 } else {
  1334.                     ULONG tmp = ULONG_(crec.external_file_attributes);
  1335.  
  1336.                     switch (hostnum) {
  1337.                         case UNIX_:
  1338.                           info[j].f_attr = tmp >> 16;
  1339.                           break;
  1340.                         case DOS_OS2_FAT_:
  1341.                           tmp = (!(tmp & 1)) << 1;   /* read-only bit */
  1342.                           info[j].f_attr = 0444 | tmp<<6 | tmp<<3 | tmp;
  1343. #ifdef UNIX
  1344.                           umask((int)(tmp = umask(0)));
  1345.                           info[j].f_attr &= ~tmp;
  1346. #endif
  1347.                           break;
  1348.                         case MAC_:
  1349.                           tmp &= 1;   /* read-only bit */
  1350.                           info[j].f_attr = tmp;
  1351.                           break;
  1352.                         default:
  1353.                           info[j].f_attr = 0666;
  1354.                           break;
  1355.                     }
  1356.                     info[j].lcflag = lcflag;
  1357.                     info[j++].offset = (longint)
  1358.                         ULONG_(crec.relative_offset_local_header);
  1359.                 }
  1360.             } else {
  1361.                 fnamev = fnv;   /* don't destroy permanent filename pointer */
  1362.                 for (--fnamev; *++fnamev;)
  1363.                     if (match(filename, *fnamev)) {
  1364.                         if (crec.version_needed_to_extract[0] > UNZIP_VERSION) {
  1365.                             fprintf(stderr, "%s:  requires compatibility with\
  1366.  version %u.%u to extract\n       (this handles %u.%u)--skipping.\n", filename,
  1367.                                 crec.version_needed_to_extract[0] / 10,
  1368.                                 crec.version_needed_to_extract[0] % 10,
  1369.                                 UNZIP_VERSION / 10, UNZIP_VERSION % 10);
  1370.                             error_in_archive = 1;       /* 1:  warning error */
  1371.                         } else if (crec.general_purpose_bit_flag & 1) {
  1372.                             fprintf(stderr, CryptMsg, filename);  /* encrypt */
  1373.                             error_in_archive = 1;       /* 1:  warning error */
  1374.                         } else {
  1375.                             ULONG tmp = ULONG_(crec.external_file_attributes);
  1376.  
  1377.                             switch (hostnum) {
  1378.                                 case UNIX_:
  1379.                                   info[j].f_attr = tmp >> 16;
  1380.                                   break;
  1381.                                 case DOS_OS2_FAT_:
  1382.                                   tmp = (!(tmp & 1)) << 1;  /* read-only bit */
  1383.                                   info[j].f_attr = 0444 | tmp<<6 | tmp<<3 | tmp;
  1384. #ifdef UNIX
  1385.                                   umask((int)(tmp = umask(0)));
  1386.                                   info[j].f_attr &= ~tmp;
  1387. #endif
  1388.                                   break;
  1389.                                 case MAC_:
  1390.                                   tmp &= 1;   /* read-only bit */
  1391.                                   info[j].f_attr = tmp;
  1392.                                   break;
  1393.                                 default:
  1394.                                   info[j].f_attr = 0666;
  1395.                                   break;
  1396.                             }
  1397.                             info[j].lcflag = lcflag;
  1398.                             info[j++].offset = (longint)
  1399.                                 ULONG_(crec.relative_offset_local_header);
  1400.                         }
  1401.                         break;  /* found match for filename, so stop looping */
  1402.  
  1403.                     }   /* end if (match), for-loop (fnamev) */
  1404.             }           /* end if (process_all_files) */
  1405.         }               /* end while-loop (adding files to current block) */
  1406.  
  1407.         /* save position in central directory so can come back later */
  1408.         cd_bufstart = cur_zipfile_bufstart;
  1409.         cd_inptr = inptr;
  1410.         cd_incnt = incnt;
  1411.  
  1412.         /*
  1413.          * Loop through files in block, extracting or testing each one.
  1414.          */
  1415.  
  1416.         for (i = 0; i < j; ++i) {
  1417.             /*
  1418.              * if the target position is not within the current input buffer
  1419.              * (either haven't yet read far enough, or (maybe) skipping back-
  1420.              * ward) skip to the target position and reset readbuf().
  1421.              */
  1422.  
  1423.             /* LSEEK(info[i].offset):  */
  1424.             inbuf_offset = info[i].offset % INBUFSIZ;
  1425.             bufstart = info[i].offset - inbuf_offset;
  1426.  
  1427.             if (bufstart != cur_zipfile_bufstart) {
  1428.                 cur_zipfile_bufstart = lseek(zipfd, bufstart, SEEK_SET);
  1429.                 if ((incnt = read(zipfd,inbuf,INBUFSIZ)) <= 0) {
  1430.                     fprintf(stderr, OffsetMsg, filename, "lseek");
  1431.                     error_in_archive = 3;   /* 3:  error in zipfile, but */
  1432.                     continue;               /*  can still do next file   */
  1433.                 }
  1434.                 inptr = inbuf + inbuf_offset;
  1435.                 incnt -= inbuf_offset;
  1436.             } else {
  1437.                 incnt += (inptr-inbuf) - inbuf_offset;
  1438.                 inptr = inbuf + inbuf_offset;
  1439.             }
  1440.             lcflag = info[i].lcflag;
  1441.             f_attr = info[i].f_attr;
  1442.  
  1443.             /* should be in proper position now, so check for sig */
  1444.             if (readbuf(sig, 4) <= 0) {
  1445.                 fprintf(stderr, OffsetMsg, filename, "EOF");  /* bad offset */
  1446.                 error_in_archive = 3;   /* 3:  error in zipfile */
  1447.                 continue;       /* but can still do next one */
  1448.             }
  1449.             if (strncmp(sig, LOCAL_HDR_SIG, 4)) {
  1450.                 fprintf(stderr, OffsetMsg, filename,
  1451.                         "can't find local header sig");   /* bad offset */
  1452.                 error_in_archive = 3;
  1453.                 continue;
  1454.             }
  1455.             if ((error = process_local_file_header()) != 0) {
  1456.                 fprintf(stderr, "\n%s:  bad local header\n", filename);
  1457.                 error_in_archive = error;       /* only 51 (EOF) defined */
  1458.                 continue;       /* can still do next one */
  1459.             }
  1460.             if ((error = do_string(lrec.filename_length, FILENAME)) != 0) {
  1461.                 if (error > error_in_archive)
  1462.                     error_in_archive = error;
  1463.                 if (error > 1) {
  1464.                     fprintf(stderr, FilNamMsg, filename, "local");
  1465.                     continue;   /* go on to next one */
  1466.                 }
  1467.             }
  1468.             if ((error = do_string(lrec.extra_field_length, SKIP)) != 0) {
  1469.                 if (error > error_in_archive)
  1470.                     error_in_archive = error;
  1471.                 if (error > 1) {
  1472.                     fprintf(stderr, ExtFieldMsg, filename, "local");
  1473.                     continue;   /* go on */
  1474.                 }
  1475.             }
  1476.             if ((error = extract_or_test_member()) != 0)
  1477.                 if (error > error_in_archive)
  1478.                     error_in_archive = error;       /* ...and keep going */
  1479.  
  1480.         }                       /* end for-loop (i:  files in current block) */
  1481.  
  1482.         /*
  1483.          * Jump back to where we were in the central directory, then go and do
  1484.          * the next batch of files.
  1485.          */
  1486.  
  1487.         cur_zipfile_bufstart = lseek(zipfd, cd_bufstart, SEEK_SET);
  1488.         read(zipfd, inbuf, INBUFSIZ);   /* were already there ==> no error */
  1489.         inptr = cd_inptr;
  1490.         incnt = cd_incnt;
  1491.  
  1492. #ifdef TEST
  1493.         printf("\ncd_bufstart = %ld (%.8lXh)\n", cd_bufstart, cd_bufstart);
  1494.         printf("cur_zipfile_bufstart = %ld (%.8lXh)\n", cur_zipfile_bufstart,
  1495.           cur_zipfile_bufstart);
  1496.         printf("inptr-inbuf = %d\n", inptr-inbuf);
  1497.         printf("incnt = %d\n\n", incnt);
  1498. #endif
  1499.  
  1500.     }           /* end while-loop (blocks of files in central directory) */
  1501.  
  1502. /*---------------------------------------------------------------------------
  1503.     Double check that we're back at the end-of-central-directory record, and
  1504.     print quick summary of results, if we were just testing the archive.  We
  1505.     send the summary to stdout so that people doing the testing in the back-
  1506.     ground and redirecting to a file can just do a "tail" on the output file.
  1507.   ---------------------------------------------------------------------------*/
  1508.  
  1509.     readbuf(sig, 4);
  1510.     if (strncmp(sig, END_CENTRAL_SIG, 4)) {     /* just to make sure again */
  1511.         fprintf(stderr, EndSigMsg);  /* didn't find end-of-central-dir sig */
  1512. #ifdef STUPID_DAMNED_REPORTS    /* No more damned reports! */
  1513.         fprintf(stderr, ReportMsg);  /* report to info-zip */
  1514. #endif
  1515.         if (!error_in_archive)       /* don't overwrite stronger error */
  1516.             error_in_archive = 1;    /* 1:  warning error */
  1517.     }
  1518.     if (tflag && (quietflg == 1)) {
  1519.         if (error_in_archive)
  1520.             printf("At least one error was detected in the archive.\n");
  1521.         else if (process_all_files)
  1522.             printf("No errors detected.\n");
  1523.         else
  1524.             printf("No errors detected in the tested files.\n");
  1525.     }
  1526.     return (error_in_archive);
  1527.  
  1528. }       /* end function extract_or_test_files() */
  1529.  
  1530.  
  1531.  
  1532.  
  1533.  
  1534. /**************************************/
  1535. /*  Function extract_or_test_member() */
  1536. /**************************************/
  1537.  
  1538. int extract_or_test_member()
  1539. /* return PK-type error code */
  1540. {
  1541.     int error = 0;
  1542.     UWORD b;
  1543.  
  1544.  
  1545.  
  1546. /*---------------------------------------------------------------------------
  1547.     Initialize variables, buffers, etc.
  1548.   ---------------------------------------------------------------------------*/
  1549.  
  1550.     bits_left = 0;
  1551.     bitbuf = 0;
  1552.     outpos = 0L;
  1553.     outcnt = 0;
  1554.     outptr = outbuf;
  1555.     zipeof = 0;
  1556.     crc32val = 0xFFFFFFFFL;
  1557.  
  1558.     memset(outbuf, 0, OUTBUFSIZ);
  1559.     if (aflag)                  /* if we have a scratchpad, clear it out */
  1560. #ifdef MSWIN
  1561.         _fmemset(outout, 0, OUTBUFSIZ);
  1562. #else
  1563.         memset(outout, 0, OUTBUFSIZ);
  1564. #endif
  1565.  
  1566.     if (tflag) {
  1567.         if (!quietflg) {
  1568.             fprintf(stdout, "  Testing: %-12s ", filename);
  1569.             fflush(stdout);
  1570.         }
  1571.     } else {
  1572.         if (cflag)              /* output to stdout (copy of it) */
  1573. #if defined (MACOS) || defined(AMIGA)
  1574.             outfd = 1;
  1575. #else
  1576.             outfd = dup(1);
  1577. #endif
  1578.         else {
  1579.             if ((error = mapped_name()) > 1)  /* member name conversion error */
  1580.                 return (2);     /* 2:  (weak) error in zipfile */
  1581.             if (create_output_file())   /* output to file:  read/write perms */
  1582.                 return (50);    /* 50:  disk full */
  1583.         }
  1584.     }                           /* endif (!tflag) */
  1585.  
  1586. /*---------------------------------------------------------------------------
  1587.     Unpack the file.
  1588.   ---------------------------------------------------------------------------*/
  1589.  
  1590.     switch (lrec.compression_method) {
  1591.  
  1592.     case STORED:
  1593.         if (!tflag && QCOND) {
  1594.             fprintf(stdout, " Extracting: %-12s ", filename);
  1595.             if (cflag)
  1596.                 fprintf(stdout, "\n");
  1597.             fflush(stdout);
  1598.         }
  1599.         while (ReadByte(&b))
  1600.             OUTB(b);
  1601.         break;
  1602.  
  1603.     case SHRUNK:
  1604.         if (!tflag && QCOND) {
  1605.             fprintf(stdout, "UnShrinking: %-12s ", filename);
  1606.             if (cflag)
  1607.                 fprintf(stdout, "\n");
  1608.             fflush(stdout);
  1609.         }
  1610.         unShrink();
  1611.         break;
  1612.  
  1613.     case REDUCED1:
  1614.     case REDUCED2:
  1615.     case REDUCED3:
  1616.     case REDUCED4:
  1617.         if (!tflag && QCOND) {
  1618.             fprintf(stdout, "  Expanding: %-12s ", filename);
  1619.             if (cflag)
  1620.                 fprintf(stdout, "\n");
  1621.             fflush(stdout);
  1622.         }
  1623.         unReduce();
  1624.         break;
  1625.  
  1626.     case IMPLODED:
  1627.         if (!tflag && QCOND) {
  1628.             fprintf(stdout, "  Exploding: %-12s ", filename);
  1629.             if (cflag)
  1630.                 fprintf(stdout, "\n");
  1631.             fflush(stdout);
  1632.         }
  1633.         unImplode();
  1634.         break;
  1635.  
  1636.     default:
  1637.         fprintf(stderr, "%s:  unknown compression method\n", filename);
  1638.         /* close and delete file before return?? */
  1639.         return (1);             /* 1:  warning error */
  1640.     }
  1641.  
  1642. /*---------------------------------------------------------------------------
  1643.     Write the last partial buffer, if any; set the file date and time; and
  1644.     close the file (not necessarily in that order).  Then make sure CRC came
  1645.     out OK and print result.  [Note:  crc32val must be logical-ANDed with
  1646.     32 bits of 1's, or else machines whose longs are bigger than 32 bits will
  1647.     report bad CRCs (because of the upper bits being filled with 1's instead
  1648.     of 0's).]
  1649.   ---------------------------------------------------------------------------*/
  1650.  
  1651.     if (FlushOutput())
  1652.         return (50);            /* 50:  disk full */
  1653.  
  1654.     if (!tflag)
  1655. #ifdef MTS                      /* MTS can't set file time */
  1656.         close(outfd);
  1657. #else
  1658.         set_file_time_and_close();
  1659. #endif
  1660.  
  1661.     if ((crc32val = ((~crc32val) & 0xFFFFFFFFL)) != ULONG_(lrec.crc32)) {
  1662.         /* if quietflg is set we haven't output the filename yet, do it */
  1663.         if (quietflg)
  1664.             printf("%-12s: ", filename);
  1665.         fprintf(stdout, " Bad CRC %08lx  (should be %08lx)\n", crc32val,
  1666.                 ULONG_(lrec.crc32));
  1667.         return (1);             /* 1:  warning error */
  1668.     } else if (tflag) {
  1669.         if (!quietflg)
  1670.             fprintf(stdout, " OK\n");
  1671.     } else {
  1672.         if (QCOND)
  1673.             fprintf(stdout, "\n");
  1674.     }
  1675.  
  1676.     return (error);
  1677.  
  1678. }       /* end function extract_or_test_member() */
  1679.  
  1680.  
  1681.  
  1682.  
  1683.  
  1684. /*******************************************/
  1685. /*  Function process_central_file_header() */
  1686. /*******************************************/
  1687.  
  1688. int process_central_file_header()
  1689. /* return PK-type error code */
  1690. {
  1691. #ifdef NOTINT16
  1692.     central_directory_byte_header byterec;
  1693. #endif
  1694.  
  1695.  
  1696.  
  1697. /*---------------------------------------------------------------------------
  1698.     Read the next central directory entry and do any necessary machine-type
  1699.     conversions (byte ordering, structure padding compensation--in the latter
  1700.     case, copy the data from the array into which it was read (byterec) to
  1701.     the usable struct (crec)).
  1702.   ---------------------------------------------------------------------------*/
  1703.  
  1704. #ifndef NOTINT16
  1705.     if (readbuf((char *) &crec, CREC_SIZE) <= 0)
  1706.         return (51);
  1707.  
  1708. #else  /* NOTINT16 */
  1709.     if (readbuf((char *) byterec, CREC_SIZE) <= 0)
  1710.         return (51);            /* 51:  unexpected EOF */
  1711.  
  1712.     crec.version_made_by[0] = byterec[C_VERSION_MADE_BY_0];
  1713.     crec.version_made_by[1] = byterec[C_VERSION_MADE_BY_1];
  1714.     crec.version_needed_to_extract[0] = byterec[C_VERSION_NEEDED_TO_EXTRACT_0];
  1715.     crec.version_needed_to_extract[1] = byterec[C_VERSION_NEEDED_TO_EXTRACT_1];
  1716.  
  1717.     crec.general_purpose_bit_flag =
  1718.         makeword(&byterec[C_GENERAL_PURPOSE_BIT_FLAG]);
  1719.     crec.compression_method =
  1720.         makeword(&byterec[C_COMPRESSION_METHOD]);
  1721.     crec.last_mod_file_time =
  1722.         makeword(&byterec[C_LAST_MOD_FILE_TIME]);
  1723.     crec.last_mod_file_date =
  1724.         makeword(&byterec[C_LAST_MOD_FILE_DATE]);
  1725.     crec.crc32 =
  1726.         makelong(&byterec[C_CRC32]);
  1727.     crec.compressed_size =
  1728.         makelong(&byterec[C_COMPRESSED_SIZE]);
  1729.     crec.uncompressed_size =
  1730.         makelong(&byterec[C_UNCOMPRESSED_SIZE]);
  1731.     crec.filename_length =
  1732.         makeword(&byterec[C_FILENAME_LENGTH]);
  1733.     crec.extra_field_length =
  1734.         makeword(&byterec[C_EXTRA_FIELD_LENGTH]);
  1735.     crec.file_comment_length =
  1736.         makeword(&byterec[C_FILE_COMMENT_LENGTH]);
  1737.     crec.disk_number_start =
  1738.         makeword(&byterec[C_DISK_NUMBER_START]);
  1739.     crec.internal_file_attributes =
  1740.         makeword(&byterec[C_INTERNAL_FILE_ATTRIBUTES]);
  1741.     crec.external_file_attributes =
  1742.         makelong(&byterec[C_EXTERNAL_FILE_ATTRIBUTES]); /* LONG, not word! */
  1743.     crec.relative_offset_local_header =
  1744.         makelong(&byterec[C_RELATIVE_OFFSET_LOCAL_HEADER]);
  1745. #endif  /* NOTINT16 */
  1746.  
  1747.     hostnum = min(crec.version_made_by[1], NUM_HOSTS);
  1748. /*  extnum = min( crec.version_needed_to_extract[1], NUM_HOSTS ); */
  1749.     methnum = min(crec.compression_method, NUM_METHODS);
  1750.  
  1751. /*---------------------------------------------------------------------------
  1752.     Set flag for lowercase conversion of filename, depending on which OS the
  1753.     file is coming from.  This section could be ifdef'd if some people have
  1754.     come to love DOS uppercase filenames under Unix...but really, guys, get
  1755.     a life. :)  NOTE THAT ALL SYSTEM NAMES NOW HAVE TRAILING UNDERSCORES!!!
  1756.     This is to prevent interference with compiler command-line defines such
  1757.     as -DUNIX, for example, which are then used in "#ifdef UNIX" constructs.
  1758.   ---------------------------------------------------------------------------*/
  1759.  
  1760.     lcflag = FALSE;
  1761.     if (!Uflag)                 /* as long as user hasn't specified
  1762.                                  * case-preservation */
  1763.         switch (hostnum) {
  1764.         case DOS_OS2_FAT_:
  1765.         case VMS_:
  1766.         case VM_CMS_:           /* all caps? */
  1767.         case CPM_:              /* like DOS, right? */
  1768. /*      case ATARI_:            ??? */
  1769. /*      case Z_SYSTEM_:         ??? */
  1770. /*      case TOPS20_:           (if we had such a thing...) */
  1771.  
  1772.             lcflag = TRUE;      /* convert filename to lowercase */
  1773.             break;
  1774.  
  1775.         default:                /* AMIGA_, UNIX_, (ATARI_), OS2_HPFS_, */
  1776.             break;              /*   MAC_, (Z_SYSTEM_):  no conversion */
  1777.         }
  1778.  
  1779.     return (0);
  1780.  
  1781. }       /* end function process_central_file_header() */
  1782.  
  1783.  
  1784.  
  1785.  
  1786.  
  1787. /*****************************************/
  1788. /*  Function process_local_file_header() */
  1789. /*****************************************/
  1790.  
  1791. int process_local_file_header()
  1792. /* return PK-type error code */
  1793. {
  1794. #ifdef NOTINT16
  1795.     local_byte_header byterec;
  1796. #endif
  1797.  
  1798.  
  1799.  
  1800. /*---------------------------------------------------------------------------
  1801.     Read the next local file header and do any necessary machine-type con-
  1802.     versions (byte ordering, structure padding compensation--in the latter
  1803.     case, copy the data from the array into which it was read (byterec) to
  1804.     the usable struct (lrec)).
  1805.   ---------------------------------------------------------------------------*/
  1806.  
  1807. #ifndef NOTINT16
  1808.     if (readbuf((char *) &lrec, LREC_SIZE) <= 0)
  1809.         return (51);
  1810.  
  1811. #else /* NOTINT16 */
  1812.     if (readbuf((char *) byterec, LREC_SIZE) <= 0)
  1813.         return (51);            /* 51:  unexpected EOF */
  1814.  
  1815.     lrec.version_needed_to_extract[0] = byterec[L_VERSION_NEEDED_TO_EXTRACT_0];
  1816.     lrec.version_needed_to_extract[1] = byterec[L_VERSION_NEEDED_TO_EXTRACT_1];
  1817.  
  1818.     lrec.general_purpose_bit_flag = makeword(&byterec[L_GENERAL_PURPOSE_BIT_FLAG]);
  1819.     lrec.compression_method = makeword(&byterec[L_COMPRESSION_METHOD]);
  1820.     lrec.last_mod_file_time = makeword(&byterec[L_LAST_MOD_FILE_TIME]);
  1821.     lrec.last_mod_file_date = makeword(&byterec[L_LAST_MOD_FILE_DATE]);
  1822.     lrec.crc32 = makelong(&byterec[L_CRC32]);
  1823.     lrec.compressed_size = makelong(&byterec[L_COMPRESSED_SIZE]);
  1824.     lrec.uncompressed_size = makelong(&byterec[L_UNCOMPRESSED_SIZE]);
  1825.     lrec.filename_length = makeword(&byterec[L_FILENAME_LENGTH]);
  1826.     lrec.extra_field_length = makeword(&byterec[L_EXTRA_FIELD_LENGTH]);
  1827. #endif  /* NOTINT16 */
  1828.  
  1829.     csize = (longint) ULONG_(lrec.compressed_size);
  1830.     ucsize = (longint) ULONG_(lrec.uncompressed_size);
  1831.  
  1832.     return (0);                 /* 0:  no error */
  1833.  
  1834. }       /* end function process_local_file_header() */
  1835. 
  1836.