Return to unzip.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / unzip

Annotation of coherent/b/bin/unzip/unzip.c, revision 1.1

1.1     ! root        1: /*---------------------------------------------------------------------------
        !             2: 
        !             3:   unzip.c
        !             4: 
        !             5:   UnZip - a zipfile extraction utility.  See below for make instructions, or
        !             6:   read the comments in Makefile and the various Contents files for more de-
        !             7:   tailed explanations.  To report a bug, send a *complete* description to
        !             8:   [email protected]; include machine type, operating system and version,
        !             9:   compiler and version, and reasonably detailed error messages or problem
        !            10:   report.  To join Info-ZIP, send a message to [email protected].
        !            11: 
        !            12:   UnZip 5.x is a greatly expanded and partially rewritten successor to 4.x,
        !            13:   which in turn was almost a complete rewrite of version 3.x.  For a detailed
        !            14:   revision history, see UnzpHist.zip at Info-ZIP headquarters (below).  For a 
        !            15:   (partial) list of the many (near infinite) contributors, see "CONTRIBS" in
        !            16:   the UnZip source distribution.
        !            17: 
        !            18:   ---------------------------------------------------------------------------
        !            19: 
        !            20:   To compile (partial instructions):
        !            21: 
        !            22:      under Unix (cc):  make <system name>
        !            23:        (type "make list" for a list of valid names, or read Makefile for 
        !            24:        details.  "make unzip" works for most systems.  If you have a NEW
        !            25:        system, not covered by any of the existing targets, send FULL infor-
        !            26:        mation--hardware, OS, versions, etc.--to [email protected])
        !            27: 
        !            28:      under MS-DOS (MSC, Turbo C, or Borland C++):  use the makefiles or
        !            29:        project files in the MSDOS sub-archive; edit or otherwise modify
        !            30:        as appropriate.  For MSC, use NMAKE.
        !            31: 
        !            32:      under MS Windows 3.x:  get wunz12sr.{zip | zoo | whatever} and use
        !            33:        the included makefile
        !            34: 
        !            35:      under OS/2 (MSC, gcc, IBM C Set/2, Watcom C):  make -f makefile.os2
        !            36:        (from OS2 sub-archive; for MSC, use NMAKE)
        !            37: 
        !            38:      under VMS (VAX C or GNU C):  @make_unzip_vaxc  or  @make_unzip_gcc
        !            39:        (from VMS sub-archive; can also use MMS or MAKE/VMS; see VMS.notes)
        !            40: 
        !            41:      under Macintosh OS:  Double click on unzip.make.  Press <Command>-M.
        !            42:        (from MAC sub-archive)
        !            43: 
        !            44:      under Windows NT:  use makefile.nt (from NT sub-archive)
        !            45: 
        !            46:      under AmigaDOS:  try one of the makefiles in the AMIGA sub-archive;
        !            47:        may need some work yet...
        !            48: 
        !            49:      under Atari TOS:  needs considerable work yet...
        !            50: 
        !            51:   ---------------------------------------------------------------------------
        !            52: 
        !            53:   Version:  unz50p1.{tar.Z | zip | zoo} for Unix, VMS, OS/2, MS-DOS, Windows,
        !            54:               Windows NT, Macintosh and Amiga.  Decryption requires sources
        !            55:               in zcrypt19.zip, and Windows (not NT) support requires sources
        !            56:               in wunz12sr.zip.  See accompanying file "Where" in the main
        !            57:               source distribution for ftp, uucp and mail-server sites.
        !            58:   Copyrights:  see accompanying file "COPYING" in UnZip source distribution.
        !            59: 
        !            60:   ---------------------------------------------------------------------------*/
        !            61: 
        !            62: 
        !            63: 
        !            64: 
        !            65: 
        !            66: #include "unzip.h"               /* includes, defines, and macros */
        !            67: #ifdef MSWIN
        !            68: #  include "wizunzip.h"          /* see History.500 for version history */
        !            69: #endif
        !            70: 
        !            71: #define VERSION  "5.0p1 of 12 January 1993"
        !            72: /* #define VERSION  "v5.0p BETA of 8-21-92" */   /* internal beta level */
        !            73: #define PAKFIX   /* temporary(?) solution to PAK-created zipfiles */
        !            74: 
        !            75: 
        !            76: 
        !            77: 
        !            78: 
        !            79: /**********************/
        !            80: /*  Global Variables  */
        !            81: /**********************/
        !            82: 
        !            83: int aflag=0;          /* -a: do ASCII to EBCDIC translation, or CR-LF  */
        !            84:                       /*     to CR or LF conversion of extracted files */
        !            85: /* int bflag=0; RESERVED for -b: extract as binary */
        !            86: int cflag=0;          /* -c: output to stdout */
        !            87: int fflag=0;          /* -f: "freshen" (extract only newer files) */
        !            88: int jflag=0;          /* -j: junk pathnames */
        !            89: int overwrite_none=0; /* -n: never overwrite files (no prompting) */
        !            90: int overwrite_all=0;  /* -o: OK to overwrite files without prompting */
        !            91: int force_flag=0;     /* (shares -o for now): force to override errors, etc. */
        !            92: int quietflg=0;       /* -q: produce a lot less output */
        !            93: #ifdef DOS_OS2
        !            94:    int sflag=1;       /* -s: allow spaces (blanks) in filenames */
        !            95: #endif /* DOS_OS2 */
        !            96: int tflag=0;          /* -t: test */
        !            97: int uflag=0;          /* -u: "update" (extract only newer & brand-new files) */
        !            98: static int U_flag=0;  /* -U: leave filenames in upper or mixed case */
        !            99: static int vflag=0;   /* -v: view directory (only used in unzip.c) */
        !           100: int V_flag=0;         /* -V: don't strip VMS version numbers */
        !           101: #ifdef VMS
        !           102:    int secinf=0;      /* -X: keep owner/protection */
        !           103: #endif /* VMS */
        !           104: int zflag=0;          /* -z: display only the archive comment */
        !           105: int process_all_files=0;
        !           106: 
        !           107: longint csize;        /* used by list_files(), ReadByte(): must be signed */
        !           108: longint ucsize;       /* used by list_files(), unReduce(), explode() */
        !           109: 
        !           110: char *fnames[2] = {"*", NULL};   /* default filenames vector */
        !           111: char **fnv = fnames;
        !           112: char sig[5];
        !           113: char answerbuf[10];
        !           114: 
        !           115: min_info info[DIR_BLKSIZ], *pInfo=info;
        !           116: 
        !           117: #ifdef OS2
        !           118:    int longname;              /* used in extract.c, mapname.c and file_io.c */
        !           119:    char longfilename[FILNAMSIZ];
        !           120: #endif /* OS2 */
        !           121: 
        !           122: #ifdef CRYPT
        !           123:    char *key = (char *)NULL;  /* password with which to decrypt data, or NULL */
        !           124: #endif /* CRYPT */
        !           125: 
        !           126: /*---------------------------------------------------------------------------
        !           127:     unShrink/unReduce/explode/inflate working storage and globals:
        !           128:   ---------------------------------------------------------------------------*/
        !           129: 
        !           130: union work area;              /* see unzip.h for the definition of work */
        !           131: ULONG crc32val;
        !           132: 
        !           133: UWORD mask_bits[] = {
        !           134:     0x0000,
        !           135:     0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
        !           136:     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
        !           137: };
        !           138: 
        !           139: /*---------------------------------------------------------------------------
        !           140:     Input file variables:
        !           141:   ---------------------------------------------------------------------------*/
        !           142: 
        !           143: byte *inbuf, *inptr;     /* input buffer (any size is legal) and pointer */
        !           144: int incnt;
        !           145: 
        !           146: ULONG bitbuf;
        !           147: int bits_left;
        !           148: boolean zipeof;
        !           149: 
        !           150: int zipfd;               /* zipfile file handle */
        !           151: #ifdef MSWIN
        !           152:    char *zipfn;
        !           153: #else
        !           154:    char zipfn[FILNAMSIZ];
        !           155: #endif
        !           156: 
        !           157: char local_hdr_sig[5] = "\120";    /* remaining signature bytes come later   */
        !           158: char central_hdr_sig[5] = "\120";  /*  (must initialize at runtime so unzip  */
        !           159: char end_central_sig[5] = "\120";  /*  executable won't look like a zipfile) */
        !           160: /* char extd_local_sig[5] = "\120";  NOT USED YET */
        !           161: 
        !           162: cdir_file_hdr crec;      /* used in unzip.c, extract.c, misc.c */
        !           163: local_file_hdr lrec;     /* used in unzip.c, extract.c */
        !           164: ecdir_rec ecrec;         /* used in unzip.c, extract.c */
        !           165: struct stat statbuf;     /* used by main(), mapped_name(), check_for_newer() */
        !           166: 
        !           167: longint extra_bytes = 0;        /* used in unzip.c, misc.c */
        !           168: longint cur_zipfile_bufstart;   /* extract_or_test_files, readbuf, ReadByte */
        !           169:   
        !           170: #ifdef MACOS
        !           171:    short  gnVRefNum;
        !           172:    long  glDirID;
        !           173:    OSType  gostCreator;
        !           174:    OSType  gostType;
        !           175:    boolean  fMacZipped;
        !           176:    boolean  macflag;
        !           177:    CursHandle  rghCursor[4];    /* status cursors */
        !           178:    short  giCursor = 0;
        !           179: #endif
        !           180: 
        !           181: /*---------------------------------------------------------------------------
        !           182:     Output stream variables:
        !           183:   ---------------------------------------------------------------------------*/
        !           184: 
        !           185: byte *outbuf;                   /* buffer for rle look-back */
        !           186: byte *outptr;
        !           187: #ifdef MSWIN
        !           188:    byte __far *outout;
        !           189:    char *filename;
        !           190: #else /* !MSWIN */
        !           191:    byte *outout;                /* scratch pad for ASCII-native trans */
        !           192:    char filename[FILNAMSIZ];
        !           193: #endif /* ?MSWIN */
        !           194: byte *extra_field = (byte *)NULL;  /* used by VMS, Mac and OS/2 versions */
        !           195: longint outpos;                 /* absolute position in outfile */
        !           196: int outcnt;                     /* current position in outbuf */
        !           197: int outfd;
        !           198: int mem_mode = 0;
        !           199: int disk_full;
        !           200: 
        !           201: /*---------------------------------------------------------------------------
        !           202:     unzip.c static global variables (visible only within this file):
        !           203:   ---------------------------------------------------------------------------*/
        !           204: 
        !           205: static byte *hold;
        !           206: static char unkn[10];
        !           207: static longint ziplen;
        !           208: static UWORD methnum;
        !           209: 
        !           210: /*---------------------------------------------------------------------------
        !           211:     unzip.c repeated error messages (we use all of these at least twice)
        !           212:   ---------------------------------------------------------------------------*/
        !           213: 
        !           214: char *EndSigMsg = "\nwarning:\
        !           215:   didn't find end-of-central-dir signature at end of central dir.\n";
        !           216: char *CentSigMsg =
        !           217:   "error:  expected central file header signature not found (file #%u).\n";
        !           218: char *SeekMsg =
        !           219:   "error:  attempt to seek before beginning of zipfile\n%s";
        !           220: 
        !           221: #ifdef VMS
        !           222: char *ReportMsg = "\
        !           223:   (please check that you have transferred or created the zipfile in the\n\
        !           224:   appropriate BINARY mode--this includes ftp, Kermit, AND unzip'd zipfiles)\n";
        !           225: #else /* !VMS */
        !           226: char *ReportMsg = "\
        !           227:   (please check that you have transferred or created the zipfile in the\n\
        !           228:   appropriate BINARY mode and that you have compiled unzip properly)\n";
        !           229: #endif /* ?VMS */
        !           230: 
        !           231: 
        !           232: #ifdef MSWIN
        !           233: /* MS Windows Setup  and Take-Down functions bracket calls to 
        !           234:  * process_zipfile().
        !           235:  * These functions allocate and free the necessary buffers, set and clear
        !           236:  * any global variables so that  process_zipfile()  can be called multiple
        !           237:  * times in the same session of WizUnzip. You'll recognize some of the 
        !           238:  * code from main() in SetUpToProcessZipFile().
        !           239:  */
        !           240: HANDLE hOutBuf;
        !           241: HANDLE hOutOut;   /* added 04/03/92 for version 1.1 */
        !           242: HANDLE hInBuf;
        !           243: HANDLE hZipFN;
        !           244: HANDLE hFileName;
        !           245: 
        !           246: BOOL FSetUpToProcessZipFile(int ncflag, int ntflag, int nvflag, int nUflag, 
        !           247:        int nzflag, int ndflag, int noflag, int naflag, int argc,
        !           248:        LPSTR lpszZipFN, PSTR *FNV)
        !           249: {
        !           250:     /* clear all global flags -- need to or not. */
        !           251: 
        !           252:     tflag = vflag=cflag=aflag=U_flag=quietflg=zflag = 0;
        !           253:     overwrite_all=overwrite_none=0;
        !           254:     fnv = &fnames[0];       /* assign default file name vector */
        !           255: 
        !           256:     cflag = ncflag ; overwrite_all = noflag;
        !           257:     tflag = ntflag ; vflag = nvflag; zflag = nzflag; U_flag = nUflag;
        !           258:     aflag = naflag;
        !           259:     sflag = 1;
        !           260: 
        !           261:     local_hdr_sig[0] = central_hdr_sig[0] = end_central_sig[0] = '\120';
        !           262:     local_hdr_sig[1] = central_hdr_sig[1] = end_central_sig[1] = '\0';
        !           263: 
        !           264:     if (!(hZipFN = LocalAlloc(LMEM_MOVEABLE, FILNAMSIZ)))
        !           265:         return FALSE;
        !           266: 
        !           267:     zipfn = (char *)LocalLock(hZipFN);
        !           268:     lstrcpy(zipfn, lpszZipFN);
        !           269:     if (stat(zipfn, &statbuf) || (statbuf.st_mode & S_IFMT) == S_IFDIR)
        !           270:         strcat(zipfn, ZSUFX);
        !           271: 
        !           272:     if (stat(zipfn, &statbuf)) {  /* try again */
        !           273:         fprintf(stderr, "error:  can't find zipfile [ %s ]\n", zipfn);
        !           274:         return TRUE;              /* 9:  file not found */
        !           275:     } else
        !           276:         ziplen = statbuf.st_size;
        !           277: 
        !           278:     if (argc != 0) {
        !           279:         fnv = FNV;
        !           280:         process_all_files = FALSE;
        !           281:     } else
        !           282:         process_all_files = TRUE;       /* for speed */
        !           283: 
        !           284: /*---------------------------------------------------------------------------
        !           285:     Okey dokey, we have everything we need to get started.  Let's roll.
        !           286:   ---------------------------------------------------------------------------*/
        !           287: 
        !           288:     if (hInBuf = LocalAlloc(LMEM_MOVEABLE, INBUFSIZ+4)) {  /* 4 extra: hold[] */
        !           289:         inbuf = (byte *) LocalLock(hInBuf);
        !           290:         WinAssert(inbuf);
        !           291:     }
        !           292:     if (hOutBuf = LocalAlloc(LMEM_MOVEABLE, OUTBUFSIZ+1)) {  /* extra: ASCIIZ */
        !           293:         outbuf = (byte *)LocalLock(hOutBuf);
        !           294:         WinAssert(outbuf);
        !           295:         if (aflag) {   /* if LF => CR,LF translation */
        !           296:             if (hOutOut = GlobalAlloc(GMEM_MOVEABLE,OUTBUFSIZ)) {
        !           297:                 outout = (byte _far *)GlobalLock(hOutOut);
        !           298:                 WinAssert(outout);
        !           299:             }
        !           300:         } else    /* no translation; just re-use output buffer */
        !           301:             outout = (byte _far *)outbuf;  /*  point to outbuf */
        !           302:     }
        !           303:     if ( hFileName = LocalAlloc(LMEM_MOVEABLE, FILNAMSIZ)) {
        !           304:         filename = (char *)LocalLock(hFileName);
        !           305:         WinAssert(filename);
        !           306:     }
        !           307: 
        !           308:     if ((inbuf == NULL) || (outbuf == NULL) || (outout == NULL) ||
        !           309:         (zipfn == NULL) || (filename == NULL))
        !           310:         return FALSE;
        !           311: 
        !           312:     hold = &inbuf[INBUFSIZ];   /* to check for boundary-spanning signatures */
        !           313: 
        !           314:     return TRUE;    /* set up was OK */
        !           315: }
        !           316: 
        !           317: void TakeDownFromProcessZipFile(void)
        !           318: {
        !           319:     if (inbuf) {
        !           320:         LocalUnlock(hInBuf);
        !           321:         inbuf = NULL;
        !           322:     }
        !           323:     if (hInBuf)
        !           324:         hInBuf = LocalFree(hInBuf);
        !           325: 
        !           326:     if (outbuf) {
        !           327:         LocalUnlock(hOutBuf);
        !           328:         outbuf = NULL;
        !           329:     }
        !           330:     if (hOutBuf)
        !           331:         hOutBuf = LocalFree(hOutBuf);
        !           332: 
        !           333:     if (aflag && outout)    /* if doing LF => CR,LF translation */
        !           334:         GlobalUnlock(hOutOut);
        !           335:     outout = NULL;          /* free now, translation or not     */
        !           336:     if (hOutOut)
        !           337:         hOutOut = GlobalFree(hOutOut);  /* mark buffer as freed */
        !           338: 
        !           339:     if (zipfn) {
        !           340:         LocalUnlock(hZipFN);
        !           341:         zipfn = NULL;
        !           342:     }
        !           343:     if (hZipFN)
        !           344:         hZipFN = LocalFree(hZipFN);
        !           345: 
        !           346:     if (filename) {
        !           347:         LocalUnlock(hFileName);
        !           348:         filename = NULL;
        !           349:     }
        !           350:     if (hFileName)
        !           351:         hFileName = LocalFree(hFileName);
        !           352: }
        !           353: 
        !           354: #else /* !MSWIN */
        !           355: 
        !           356: /******************/
        !           357: /*  Main program  */
        !           358: /******************/
        !           359: 
        !           360: int main(argc, argv)   /* return PK-type error code (except under VMS) */
        !           361:     int argc;
        !           362:     char *argv[];
        !           363: {
        !           364:     char *s;
        !           365:     int c, error=FALSE, negative=0;
        !           366: 
        !           367: 
        !           368: /*---------------------------------------------------------------------------
        !           369:     Macintosh initialization code.
        !           370:   ---------------------------------------------------------------------------*/
        !           371: 
        !           372: #ifdef MACOS
        !           373: #ifdef THINK_C
        !           374: #   include <console.h>
        !           375:     static char *argstr[30], args[30*64];
        !           376:     Point p;
        !           377:     SFTypeList sfT;
        !           378:     EventRecord theEvent;
        !           379:     short eMask;
        !           380:     SFReply fileRep;
        !           381: #endif /* THINK_C */
        !           382:     int a;
        !           383: 
        !           384:     for (a = 0;  a < 4;  ++a)
        !           385:         rghCursor[a] = GetCursor(a+128);
        !           386:     giCursor = 0;
        !           387: 
        !           388:     area.Slide = (byte *)calloc(8193, sizeof(short)+sizeof(char)+sizeof(char));
        !           389:     area.shrink.Prefix_of = (short *)area.Slide;
        !           390:     area.shrink.Suffix_of = area.Slide + (sizeof(short)*(HSIZE+1));
        !           391:     area.shrink.Stack = area.Slide + (sizeof(short) + sizeof(char))*(HSIZE+1);
        !           392: 
        !           393: #ifdef THINK_C   
        !           394:     for (a = 0;  a < 30;  ++a)
        !           395:         argstr[a] = &args[a*64];
        !           396: start:
        !           397:     tflag=vflag=cflag=aflag=jflag=U_flag=quietflg=fflag=uflag=zflag = 0;
        !           398:     local_hdr_sig[1] = central_hdr_sig[1] = end_central_sig[1] = '\0';
        !           399: /*  extd_local_sig[1] = '\0';  */
        !           400:     error = FALSE;
        !           401: 
        !           402:     argc = ccommand(&argv);
        !           403:     SetPt(&p, 40, 40);
        !           404: 
        !           405:     SFGetFile(p, "\pSpecify ZIP file:", 0L, -1, sfT, 0L, &fileRep);
        !           406:     if (fileRep.good) {
        !           407:         macfstest(fileRep.vRefNum);
        !           408:         ResolveMacVol(fileRep.vRefNum, &gnVRefNum, &glDirID, NULL);
        !           409:         for (a = 1;  a < argc;  ++a)
        !           410:             if (argv[a][0] == '-')
        !           411:                 BlockMove(argv[a], argstr[a], (strlen(argv[a]) > 63) ? 64 :
        !           412:                    strlen(argv[a])+1);
        !           413:             else
        !           414:                 break;
        !           415:         PtoCstr((char *)fileRep.fName);
        !           416:         strcpy(argstr[a], (char *)fileRep.fName);
        !           417:         for (;  a < argc;  ++a)
        !           418:             BlockMove(argv[a], argstr[a+1], (strlen(argv[a]) > 63) ? 64 :
        !           419:                strlen(argv[a])+1);
        !           420:         ++argc;
        !           421:         argv = argstr;
        !           422: 
        !           423:         if (hfsflag == FALSE)  /* can't support directories:  junk pathnames */
        !           424:             jflag = 1;
        !           425:     }
        !           426: #endif /* THINK_C */
        !           427: #endif /* MACOS */
        !           428: 
        !           429: /*---------------------------------------------------------------------------
        !           430:     Set signal handler for restoring echo, warn of zipfile corruption, etc.
        !           431:   ---------------------------------------------------------------------------*/
        !           432: 
        !           433:     signal(SIGINT, handler);
        !           434:     signal(SIGTERM, handler);
        !           435: #ifdef SIGBUS
        !           436:     signal(SIGBUS, handler);
        !           437: #endif
        !           438: #ifdef SIGSEGV
        !           439:     signal(SIGSEGV, handler);
        !           440: #endif
        !           441: 
        !           442: /*---------------------------------------------------------------------------
        !           443:     Debugging info for checking on structure padding:
        !           444:   ---------------------------------------------------------------------------*/
        !           445: 
        !           446: #ifdef DEBUG_STRUC
        !           447:     printf("local_file_hdr size: %X\n",
        !           448:            sizeof(local_file_hdr));
        !           449:     printf("local_byte_hdr size: %X\n",
        !           450:            sizeof(local_byte_hdr));
        !           451:     printf("actual size of local headers: %X\n", LREC_SIZE);
        !           452: 
        !           453:     printf("central directory header size: %X\n",
        !           454:            sizeof(cdir_file_hdr));
        !           455:     printf("central directory byte header size: %X\n",
        !           456:            sizeof(cdir_byte_hdr));
        !           457:     printf("actual size of central dir headers: %X\n", CREC_SIZE);
        !           458: 
        !           459:     printf("end central dir record size: %X\n",
        !           460:            sizeof(ecdir_rec));
        !           461:     printf("end central dir byte record size: %X\n",
        !           462:            sizeof(ec_byte_rec));
        !           463:     printf("actual size of end-central-dir record: %X\n", ECREC_SIZE);
        !           464: #endif /* DEBUG_STRUC */
        !           465: 
        !           466: /*---------------------------------------------------------------------------
        !           467:     Put environment-variable options into the queue, then rip through any
        !           468:     command-line options lurking about...
        !           469:   ---------------------------------------------------------------------------*/
        !           470: 
        !           471:     envargs(&argc, &argv, ENV_UNZIP);
        !           472: 
        !           473:     while (--argc > 0 && (*++argv)[0] == '-') {
        !           474:         s = argv[0] + 1;
        !           475:         while ((c = *s++) != 0) {    /* "!= 0":  prevent Turbo C warning */
        !           476:             switch (c) {
        !           477:                 case ('-'):
        !           478:                     ++negative;
        !           479:                     break;
        !           480:                 case ('a'):
        !           481:                     if (negative)
        !           482:                         aflag = FALSE, negative = 0;
        !           483:                     else
        !           484:                         aflag = TRUE;
        !           485:                     break;
        !           486: #if 0
        !           487:                 case ('b'):    /* force binary mode */
        !           488:                     if (negative)
        !           489:                         bflag = FALSE, negative = 0;
        !           490:                     else
        !           491:                         bflag = TRUE;
        !           492:                     break;
        !           493: #endif
        !           494:                 case ('c'):
        !           495:                     if (negative) {
        !           496:                         cflag = FALSE, negative = 0;
        !           497: #ifdef NATIVE
        !           498:                         aflag = FALSE;
        !           499: #endif
        !           500:                     } else {
        !           501:                         cflag = TRUE;
        !           502: #ifdef NATIVE
        !           503:                         aflag = TRUE;  /* so you can read it on the screen */
        !           504: #endif
        !           505:                     }
        !           506:                     break;
        !           507:                 case ('d'):    /* re-create directory structure (default) */
        !           508:                     if (negative)
        !           509:                         jflag = TRUE, negative = 0;
        !           510:                     break;
        !           511:                 case ('e'):    /* just ignore -e, -x options (extract) */
        !           512:                     break;
        !           513:                 case ('f'):    /* "freshen" (extract only newer files) */
        !           514:                     if (negative)
        !           515:                         fflag = uflag = FALSE, negative = 0;
        !           516:                     else
        !           517:                         fflag = uflag = TRUE;
        !           518:                     break;
        !           519:                 case ('j'):    /* junk pathnames/directory structure */
        !           520:                     if (negative)
        !           521:                         jflag = FALSE, negative = 0;
        !           522:                     else
        !           523:                         jflag = TRUE;
        !           524:                     break;
        !           525:                 case ('l'):
        !           526:                     if (negative) {
        !           527:                         vflag = MAX(vflag-negative,0);
        !           528:                         negative = 0;
        !           529:                     } else
        !           530:                         ++vflag;
        !           531:                     break;
        !           532:                 case ('n'):    /* don't overwrite any files */
        !           533:                     if (negative)
        !           534:                         overwrite_none = FALSE, negative = 0;
        !           535:                     else
        !           536:                         overwrite_none = TRUE;
        !           537:                     break;
        !           538:                 case ('o'):    /* OK to overwrite files without prompting */
        !           539:                     if (negative) {
        !           540:                         overwrite_all = MAX(overwrite_all-negative,0);
        !           541:                         force_flag = MAX(force_flag-negative,0);
        !           542:                         negative = 0;
        !           543:                     } else {
        !           544:                         ++overwrite_all;
        !           545:                         ++force_flag;  /* (share -o for now) force to cont. */
        !           546:                     }
        !           547:                     break;
        !           548:                 case ('p'):    /* pipes:  stdout, no tranlation, no messages */
        !           549:                     if (negative) {
        !           550:                         cflag = FALSE;
        !           551:                         quietflg = MAX(quietflg-999,0);
        !           552:                         negative = 0;
        !           553:                     } else {
        !           554:                         cflag = TRUE;
        !           555:                         quietflg += 999;
        !           556:                     }
        !           557:                     break;
        !           558:                 case ('q'):    /* quiet:  fewer comments/messages */
        !           559:                     if (negative) {
        !           560:                         quietflg = MAX(quietflg-negative,0);
        !           561:                         negative = 0;
        !           562:                     } else
        !           563:                         ++quietflg;
        !           564:                     break;
        !           565: #ifdef DOS_OS2
        !           566:                 case ('s'):    /* spaces in filenames:  allow by default */
        !           567:                     if (negative)
        !           568:                         sflag = TRUE, negative = 0;
        !           569:                     else
        !           570:                         sflag = FALSE;
        !           571:                     break;
        !           572: #endif
        !           573:                 case ('t'):
        !           574:                     if (negative)
        !           575:                         tflag = FALSE, negative = 0;
        !           576:                     else
        !           577:                         tflag = TRUE;
        !           578:                     break;
        !           579:                 case ('U'):    /* Uppercase (don't convert to all-lower) */
        !           580:                     if (negative)
        !           581:                         U_flag = FALSE, negative = 0;
        !           582:                     else
        !           583:                         U_flag = TRUE;
        !           584:                     break;
        !           585:                 case ('u'):    /* update (extract only new and newer files) */
        !           586:                     if (negative)
        !           587:                         uflag = FALSE, negative = 0;
        !           588:                     else
        !           589:                         uflag = TRUE;
        !           590:                     break;
        !           591:                 case ('V'):    /* Version (retain VMS/DEC-20 file versions) */
        !           592:                     if (negative)
        !           593:                         V_flag = FALSE, negative = 0;
        !           594:                     else
        !           595:                         V_flag = TRUE;
        !           596:                     break;
        !           597:                 case ('v'):    /* verbose */
        !           598:                     if (negative) {
        !           599:                         vflag = MAX(vflag-negative,0);
        !           600:                         negative = 0;
        !           601:                     } else if (vflag)
        !           602:                         ++vflag;
        !           603:                     else
        !           604:                         vflag = 2;
        !           605:                     break;
        !           606: #ifdef VMS
        !           607:                 case ('X'):   /* restore owner/protection info (need privs?) */
        !           608:                     if (negative)
        !           609:                         secinf = FALSE, negative = 0;
        !           610:                     else
        !           611:                         secinf = TRUE;
        !           612:                     break;
        !           613: #endif /* VMS */
        !           614:                 case ('x'):    /* extract:  default */
        !           615:                     break;
        !           616:                 case ('z'):    /* display only the archive comment */
        !           617:                     if (negative) {
        !           618:                         zflag = MAX(zflag-negative,0);
        !           619:                         negative = 0;
        !           620:                     } else
        !           621:                         ++zflag;
        !           622:                     break;
        !           623:                 default:
        !           624:                     error = TRUE;
        !           625:                     break;
        !           626: 
        !           627:             } /* end switch */
        !           628:         } /* end while (not end of argument string) */
        !           629:     } /* end while (not done with switches) */
        !           630: 
        !           631: /*---------------------------------------------------------------------------
        !           632:     Make sure we aren't trying to do too many things here.  [This seems like
        !           633:     kind of a brute-force way to do things; but aside from that, isn't the
        !           634:     -a option useful when listing the directory (i.e., for reading zipfile
        !           635:     comments)?  It's a modifier, not an action in and of itself, so perhaps
        !           636:     it should not be included in the test--certainly, in the case of zipfile
        !           637:     testing, it can just be ignored.]
        !           638:   ---------------------------------------------------------------------------*/
        !           639: 
        !           640:     if ((aflag && tflag) || (aflag && vflag) || (cflag && tflag) ||
        !           641:         (cflag && uflag) || (cflag && vflag) || (tflag && uflag) ||
        !           642:         (tflag && vflag) || (uflag && vflag) || (fflag && overwrite_none)) {
        !           643:         fprintf(stderr, "error:\
        !           644:   -at, -av, -ct, -cu, -cv, -fn, -tu, -tv, -uv combinations not allowed\n");
        !           645:         error = TRUE;
        !           646:     }
        !           647:     if (quietflg && zflag)
        !           648:         quietflg = 0;
        !           649:     if (overwrite_all && overwrite_none) {
        !           650:         fprintf(stderr, "caution:  both -n and -o specified; ignoring -o\n");
        !           651:         overwrite_all = FALSE;
        !           652:     }
        !           653:     if ((argc-- == 0) || error)
        !           654:         RETURN(usage(error));
        !           655: 
        !           656: /*---------------------------------------------------------------------------
        !           657:     Now get the zipfile name from the command line and see if it exists as a
        !           658:     regular (non-directory) file.  If not, append the ".zip" suffix.  We don't
        !           659:     immediately check to see if this results in a good name, but we will do so
        !           660:     later.  In the meantime, see if there are any member filespecs on the com-
        !           661:     mand line, and if so, set the filename pointer to point at them.
        !           662:   ---------------------------------------------------------------------------*/
        !           663: 
        !           664:     strcpy(zipfn, *argv++);
        !           665:     if (stat(zipfn, &statbuf) || (statbuf.st_mode & S_IFMT) == S_IFDIR)
        !           666:         strcat(zipfn, ZSUFX);
        !           667: #if (defined(UNIX) && !defined(VMS)) /* Unix executables have no extension-- */
        !           668:     else if (statbuf.st_mode & S_IXUSR)  /* might find zip, not zip.zip; etc */
        !           669:         fprintf(stderr, "\nnote:  file [ %s ] may be an executable\n\n", zipfn);
        !           670: #endif /* UNIX && !VMS */
        !           671: 
        !           672:     if (stat(zipfn, &statbuf)) {/* try again */
        !           673:         fprintf(stderr, "error:  can't find zipfile [ %s ]\n", zipfn);
        !           674:         RETURN(9);              /* 9:  file not found */
        !           675:     } else
        !           676:         ziplen = statbuf.st_size;
        !           677: 
        !           678:     if (argc != 0) {
        !           679:         fnv = argv;
        !           680:         process_all_files = FALSE;
        !           681:     } else
        !           682:         process_all_files = TRUE;       /* for speed */
        !           683: 
        !           684: /*---------------------------------------------------------------------------
        !           685:     Okey dokey, we have everything we need to get started.  Let's roll.
        !           686:   ---------------------------------------------------------------------------*/
        !           687: 
        !           688:     inbuf = (byte *) malloc(INBUFSIZ + 4);     /* 4 extra for hold[] (below) */
        !           689:     outbuf = (byte *) malloc(OUTBUFSIZ + 1);   /* 1 extra for string termin. */
        !           690: #ifndef DOS_OS2
        !           691:     if (aflag)                  /* if need an ascebc scratch, */
        !           692:         outout = (byte *) malloc(OUTBUFSIZ);
        !           693:     else                        /*  allocate it... */
        !           694: #endif /* !DOS_OS2 */
        !           695:         outout = outbuf;        /*  else just point to outbuf */
        !           696: 
        !           697:     if ((inbuf == (byte *)NULL) || (outbuf == (byte *)NULL) ||
        !           698:         (outout == (byte *)NULL)) {
        !           699:         fprintf(stderr, "error:  can't allocate unzip buffers\n");
        !           700:         RETURN(4);              /* 4-8:  insufficient memory */
        !           701:     }
        !           702:     hold = &inbuf[INBUFSIZ];    /* to check for boundary-spanning signatures */
        !           703: 
        !           704:     RETURN(process_zipfile());  /* keep passing errors back... */
        !           705: 
        !           706: } /* end main() */
        !           707: 
        !           708: 
        !           709: 
        !           710: 
        !           711: 
        !           712: /**********************/
        !           713: /*  Function usage()  */
        !           714: /**********************/
        !           715: 
        !           716: int usage(error)   /* return PK-type error code */
        !           717:     int error;
        !           718: {
        !           719: #ifdef NATIVE
        !           720: #ifdef EBCDIC
        !           721:     char *astring = "-a  convert ASCII to EBCDIC";
        !           722: #else /* !EBCDIC */
        !           723:     char *astring = "-a  convert ASCII to native chars";
        !           724: #endif /* ?EBCDIC */
        !           725: /*  char *astring = "-a  convert ASCII to " NATIVE;  (ANSI C concatenation)  */
        !           726:     char *loc_str = "";
        !           727: #else /* !NATIVE */
        !           728: #ifdef DOS_OS2
        !           729:     char *astring = "-a  convert text (LF => CR LF)";
        !           730:     char *loc_str = "-s  spaces in filenames => _";
        !           731: #else /* !DOS_OS2 */
        !           732: #ifdef MACOS
        !           733:     char *astring = "-a  convert text (CR LF => CR)";
        !           734:     char *loc_str = "";
        !           735: #else /* !MACOS:  UNIX, VMS */
        !           736:     char *astring = "-a  convert text (CR LF => LF)";
        !           737: #ifdef VMS
        !           738:     char *loc_str = "-X  restore owner/protection info";
        !           739: #else /* !VMS */
        !           740:     char *loc_str = "";
        !           741: #endif /* ?VMS */
        !           742: #endif /* ?MACOS */
        !           743: #endif /* ?DOS_OS2 */
        !           744: #endif /* ?NATIVE */
        !           745:     FILE *usagefp;
        !           746: 
        !           747: 
        !           748: /*---------------------------------------------------------------------------
        !           749:     If user requested usage, send it to stdout; else send to stderr.
        !           750:   ---------------------------------------------------------------------------*/
        !           751: 
        !           752:     if (error)
        !           753:         usagefp = (FILE *) stderr;
        !           754:     else
        !           755:         usagefp = (FILE *) stdout;
        !           756: 
        !           757:     fprintf(usagefp, "\
        !           758: UnZip %s, by Info-ZIP.  Portions (c) 1989 by S. H. Smith.\n\
        !           759: Bug reports ONLY to zip-bugs%%[email protected]; see README for detail\
        !           760: s\n\n", VERSION);
        !           761: 
        !           762:     fprintf(usagefp, "\
        !           763: Usage: unzip [ -options[modifiers] ] file[.zip] [filespec...]\n\
        !           764:   -x  extract files (default)                -l  list files (short format)\n\
        !           765:   -c  extract files to stdout/screen (CRT)   -v  list files (verbose format)\n\
        !           766:   -f  freshen existing files, create none    -p  extract to pipe, no messages\n\
        !           767:   -u  update files, create if necessary      -t  test archive integrity\n\
        !           768:                                              -z  display archive comment\n\
        !           769: modifiers:\n\
        !           770:   -n  never overwrite existing files         %s\n", loc_str);
        !           771:     fprintf(usagefp, "\
        !           772:   -o  overwrite files WITHOUT prompting      %s\n\
        !           773:   -j  junk paths (don't make directories)    -U  don't make names lowercase\n\
        !           774:   -q  quiet mode (-qq => quieter)            -V  retain VMS version numbers\
        !           775: \n\n\
        !           776: Examples: (See manual for more information)\n\
        !           777:   unzip data1 ReadMe   => extracts file ReadMe from zipfile data1.zip\n\
        !           778:   unzip -p foo | more  => send contents of foo.zip via pipe into program more\n\
        !           779:   unzip -fo foo        => quietly replace existing files if archive files newer\
        !           780: \n", astring);
        !           781: 
        !           782: #ifdef VMS
        !           783:     fprintf(usagefp, "\
        !           784:   unzip \"-V\" foo \"Bar\" => must quote uppercase options and filenames in VMS\
        !           785: \n");
        !           786: #endif
        !           787: 
        !           788:     if (error)
        !           789:         return 10;    /* 10:  bad or illegal parameters specified */
        !           790:     else
        !           791:         return 0;     /* just wanted usage screen: no error */
        !           792: 
        !           793: } /* end function usage() */
        !           794: 
        !           795: #endif /* ?MSWIN */
        !           796: 
        !           797: 
        !           798: 
        !           799: 
        !           800: /********************************/
        !           801: /*  Function process_zipfile()  */
        !           802: /********************************/
        !           803: 
        !           804: int process_zipfile()    /* return PK-type error code */
        !           805: {
        !           806:     int error=0, error_in_archive;
        !           807:     longint real_ecrec_offset, expect_ecrec_offset;
        !           808: 
        !           809: 
        !           810: /*---------------------------------------------------------------------------
        !           811:     Open the zipfile for reading and in BINARY mode to prevent CR/LF trans-
        !           812:     lation, which would corrupt the bitstreams.
        !           813:   ---------------------------------------------------------------------------*/
        !           814: 
        !           815: #ifdef VMS
        !           816:     if (check_format())         /* check for variable-length format */
        !           817:         return 2;               /* 2:  error in zipfile */
        !           818: #endif /* VMS */
        !           819: 
        !           820:     if (open_input_file())      /* this should never happen, given the */
        !           821:         return 9;               /*   stat() test in main(), but... */
        !           822: 
        !           823: /*---------------------------------------------------------------------------
        !           824:     Reconstruct the various PK signature strings, and find and process the
        !           825:     end-of-central-directory header.
        !           826:   ---------------------------------------------------------------------------*/
        !           827: 
        !           828:     strcat(local_hdr_sig, LOCAL_HDR_SIG);
        !           829:     strcat(central_hdr_sig, CENTRAL_HDR_SIG);
        !           830:     strcat(end_central_sig, END_CENTRAL_SIG);
        !           831: /*  strcat(extd_local_sig, EXTD_LOCAL_SIG);  */
        !           832: 
        !           833:     if (find_end_central_dir()) {   /* not found; nothing to do */
        !           834:         close(zipfd);
        !           835:         return 2;                   /* 2:  error in zipfile */
        !           836:     }
        !           837: 
        !           838:     real_ecrec_offset = cur_zipfile_bufstart+(inptr-inbuf);
        !           839: #ifdef TEST
        !           840:     printf("\n  found end-of-central-dir signature at offset %ld (%.8lXh)\n",
        !           841:       real_ecrec_offset, real_ecrec_offset);
        !           842:     printf("    from beginning of file; offset %d (%.4Xh) within block\n",
        !           843:       inptr-inbuf, inptr-inbuf);
        !           844: #endif
        !           845: 
        !           846:     if ((error_in_archive = process_end_central_dir()) > 1) {
        !           847:         close(zipfd);
        !           848:         return error_in_archive;
        !           849:     }
        !           850: 
        !           851:     if (zflag) {
        !           852:         close(zipfd);
        !           853:         return 0;
        !           854:     }
        !           855: 
        !           856: /*---------------------------------------------------------------------------
        !           857:     Test the end-of-central-directory info for incompatibilities and incon-
        !           858:     sistencies.
        !           859:   ---------------------------------------------------------------------------*/
        !           860: 
        !           861: #ifndef PAKFIX
        !           862:     if (ecrec.number_this_disk == 0) {
        !           863: #else /* PAKFIX */
        !           864:     error = ((ecrec.number_this_disk == 1) &&
        !           865:              (ecrec.num_disk_with_start_central_dir == 1));
        !           866:     if ((ecrec.number_this_disk == 0) || error) {
        !           867:         if (error) {
        !           868:             fprintf(stderr,
        !           869:      "\n     Warning:  zipfile claims to be disk 2 of a two-part archive;\n\
        !           870:      attempting to process anyway.  If no further errors occur, this\n\
        !           871:      archive was probably created by PAK v2.51 or earlier.  This bug\n\
        !           872:      was reported to NoGate in March 1991 and was supposed to have been\n\
        !           873:      fixed by mid-1991; as of mid-1992 it still hadn't been.\n\n");
        !           874:             error_in_archive = 1;  /* 1:  warning */
        !           875:         }
        !           876: #endif /* ?PAKFIX */
        !           877:         expect_ecrec_offset = ecrec.offset_start_central_directory +
        !           878:                               ecrec.size_central_directory;
        !           879:         if ((extra_bytes = real_ecrec_offset - expect_ecrec_offset) < 0) {
        !           880:             fprintf(stderr, "\nerror:  missing %ld bytes in zipfile (\
        !           881: attempting to process anyway)\n\n", -extra_bytes);
        !           882:             error_in_archive = 2;       /* 2:  (weak) error in zipfile */
        !           883:         } else if (extra_bytes > 0) {
        !           884:             if ((ecrec.offset_start_central_directory == 0) &&
        !           885:                 (ecrec.size_central_directory != 0))   /* zip 1.5 -go bug */
        !           886:             {
        !           887:                 fprintf(stderr, "\nerror:  NULL central directory offset (\
        !           888: attempting to process anyway)\n\n");
        !           889:                 ecrec.offset_start_central_directory = extra_bytes;
        !           890:                 extra_bytes = 0;
        !           891:                 error_in_archive = 2;   /* 2:  (weak) error in zipfile */
        !           892:             } else {
        !           893:                 fprintf(stderr, "\nwarning:  extra %ld bytes at beginning or\
        !           894:  within zipfile\n          (attempting to process anyway)\n\n", extra_bytes);
        !           895:                 error_in_archive = 1;   /* 1:  warning error */
        !           896:             }
        !           897:         }
        !           898: 
        !           899:     /*-----------------------------------------------------------------------
        !           900:         Check for empty zipfile and exit now if so.
        !           901:       -----------------------------------------------------------------------*/
        !           902: 
        !           903:         if (expect_ecrec_offset == 0L  &&  ecrec.size_central_directory == 0) {
        !           904:             fprintf(stderr, "warning:  zipfile is empty\n");
        !           905:             close(zipfd);
        !           906:             return (error_in_archive > 1)? error_in_archive : 1;
        !           907:         }
        !           908: 
        !           909:     /*-----------------------------------------------------------------------
        !           910:         Compensate for missing or extra bytes, and seek to where the start
        !           911:         of central directory should be.  If header not found, uncompensate
        !           912:         and try again (necessary for at least some Atari archives created
        !           913:         with STZIP, as well as archives created by J.H. Holm's ZIPSPLIT).
        !           914:       -----------------------------------------------------------------------*/
        !           915: 
        !           916:         LSEEK( ecrec.offset_start_central_directory )
        !           917:         if ((readbuf(sig, 4) <= 0) || strncmp(sig, central_hdr_sig, 4)) {
        !           918:             longint tmp = extra_bytes;
        !           919: 
        !           920:             extra_bytes = 0;
        !           921:             LSEEK( ecrec.offset_start_central_directory )
        !           922:             if ((readbuf(sig, 4) <= 0) || strncmp(sig, central_hdr_sig, 4)) {
        !           923:                 fprintf(stderr,
        !           924:             "error:  start of central directory not found; zipfile corrupt.\n");
        !           925:                 fprintf(stderr, ReportMsg);
        !           926:                 close(zipfd);
        !           927:                 return 3;           /* 3:  severe error in zipfile */
        !           928:             }
        !           929:             fprintf(stderr, "error:  reported length of central directory is \
        !           930: %d bytes too\n        long (Atari STZIP zipfile?  J.H. Holm ZIPSPLIT zipfile?)\
        !           931: .\n        Compensating...\n\n", -tmp);
        !           932:             error_in_archive = 2;   /* 2:  (weak) error in zipfile */
        !           933:         }
        !           934: 
        !           935:     /*-----------------------------------------------------------------------
        !           936:         Seek to the start of the central directory one last time, since we
        !           937:         have just read the first entry's signature bytes; then list, extract
        !           938:         or test member files as instructed, and close the zipfile.
        !           939:       -----------------------------------------------------------------------*/
        !           940: 
        !           941:         LSEEK( ecrec.offset_start_central_directory )
        !           942:         if (vflag)
        !           943:             error = list_files();               /* LIST 'EM */
        !           944:         else
        !           945:             error = extract_or_test_files();    /* EXTRACT OR TEST 'EM */
        !           946:         if (error > error_in_archive)   /* don't overwrite stronger error */
        !           947:             error_in_archive = error;   /*  with (for example) a warning */
        !           948:     } else {
        !           949:         fprintf(stderr, "\nerror:  zipfile is part of multi-disk archive \
        !           950: (sorry, not supported).\n");
        !           951:     /*  fprintf(stderr, "Please report to [email protected]\n");  */
        !           952:         error_in_archive = 11;  /* 11:  no files found */
        !           953:     }
        !           954: 
        !           955:     close(zipfd);
        !           956:     return error_in_archive;
        !           957: 
        !           958: } /* end function process_zipfile() */
        !           959: 
        !           960: 
        !           961: 
        !           962: 
        !           963: 
        !           964: /************************************/
        !           965: /*  Function find_end_central_dir() */
        !           966: /************************************/
        !           967: 
        !           968: int find_end_central_dir()   /* return 0 if found, 1 otherwise */
        !           969: {
        !           970:     int i, numblks;
        !           971:     longint tail_len;
        !           972: 
        !           973: 
        !           974: 
        !           975: /*---------------------------------------------------------------------------
        !           976:     Treat case of short zipfile separately.
        !           977:   ---------------------------------------------------------------------------*/
        !           978: 
        !           979:     if (ziplen <= INBUFSIZ) {
        !           980:         lseek(zipfd, 0L, SEEK_SET);
        !           981:         if ((incnt = read(zipfd,(char *)inbuf,(unsigned int)ziplen)) ==
        !           982:              (int)ziplen)
        !           983: 
        !           984:             /* 'P' must be at least 22 bytes from end of zipfile */
        !           985:             for (inptr = inbuf+(int)ziplen-22;  inptr >= inbuf;  --inptr)
        !           986:                 if ((ascii_to_native(*inptr) == 'P')  &&
        !           987:                      !strncmp((char *)inptr, end_central_sig, 4)) {
        !           988:                     incnt -= inptr - inbuf;
        !           989:                     return 0;   /* found it! */
        !           990:                 }               /* ...otherwise fall through & fail */
        !           991: 
        !           992: /*---------------------------------------------------------------------------
        !           993:     Zipfile is longer than INBUFSIZ:  may need to loop.  Start with short
        !           994:     block at end of zipfile (if not TOO short).
        !           995:   ---------------------------------------------------------------------------*/
        !           996: 
        !           997:     } else {
        !           998:         if ((tail_len = ziplen % INBUFSIZ) > ECREC_SIZE) {
        !           999:             cur_zipfile_bufstart = lseek(zipfd, ziplen-tail_len, SEEK_SET);
        !          1000:             if ((incnt = read(zipfd,(char *)inbuf,(unsigned int)tail_len)) !=
        !          1001:                  (int)tail_len)
        !          1002:                 goto fail;      /* shut up; it's expedient. */
        !          1003: 
        !          1004:             /* 'P' must be at least 22 bytes from end of zipfile */
        !          1005:             for (inptr = inbuf+(int)tail_len-22;  inptr >= inbuf;  --inptr)
        !          1006:                 if ((ascii_to_native(*inptr) == 'P')  &&
        !          1007:                      !strncmp((char *)inptr, end_central_sig, 4)) {
        !          1008:                     incnt -= inptr - inbuf;
        !          1009:                     return 0;   /* found it */
        !          1010:                 }               /* ...otherwise search next block */
        !          1011:             strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
        !          1012:                                                            boundary */
        !          1013:         } else {
        !          1014:             cur_zipfile_bufstart = ziplen - tail_len;
        !          1015:         }
        !          1016: 
        !          1017:     /*-----------------------------------------------------------------------
        !          1018:         Loop through blocks of zipfile data, starting at the end and going
        !          1019:         toward the beginning.  Need only check last 65557 bytes of zipfile:
        !          1020:         comment may be up to 65535 bytes long, end-of-central-directory rec-
        !          1021:         ord is 18 bytes (shouldn't hardcode this number, but what the hell:
        !          1022:         already did so above (22=18+4)), and sig itself is 4 bytes.
        !          1023:       -----------------------------------------------------------------------*/
        !          1024: 
        !          1025:         numblks = (int)
        !          1026:                   ((MIN(ziplen,65557L) - tail_len + (INBUFSIZ-1)) / INBUFSIZ);
        !          1027:         /*          =amount to search=   ==done==   ==rounding==    =blksiz= */
        !          1028: 
        !          1029:         for (i = 1;  i <= numblks;  ++i) {
        !          1030:             cur_zipfile_bufstart -= INBUFSIZ;
        !          1031:             lseek(zipfd, cur_zipfile_bufstart, SEEK_SET);
        !          1032:             if ((incnt = read(zipfd,(char *)inbuf,INBUFSIZ)) != INBUFSIZ)
        !          1033:                 break;          /* fall through and fail */
        !          1034: 
        !          1035:             for (inptr = inbuf+INBUFSIZ-1;  inptr >= inbuf;  --inptr)
        !          1036:                 if ((ascii_to_native(*inptr) == 'P')  &&
        !          1037:                      !strncmp((char *)inptr, end_central_sig, 4)) {
        !          1038:                     incnt -= inptr - inbuf;
        !          1039:                     return 0;   /* found it */
        !          1040:                 }
        !          1041:             strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
        !          1042:                                                            boundary */
        !          1043:         }
        !          1044: 
        !          1045:     } /* end if (ziplen > INBUFSIZ) */
        !          1046: 
        !          1047: /*---------------------------------------------------------------------------
        !          1048:     Searched through whole region where signature should be without finding
        !          1049:     it.  Print informational message and die a horrible death.
        !          1050:   ---------------------------------------------------------------------------*/
        !          1051: 
        !          1052: fail:
        !          1053: #ifdef MSWIN
        !          1054:     MessageBeep(1);
        !          1055: #endif
        !          1056: 
        !          1057:     fprintf(stderr, "\nFile:  %s\n\n\
        !          1058:      End-of-central-directory signature not found.  Either this file is not\n\
        !          1059:      a zipfile, or it constitutes one disk of a multi-part archive.  In the\n\
        !          1060:      latter case the central directory and zipfile comment will be found on\n\
        !          1061:      the last disk(s) of this archive.\n", zipfn);
        !          1062:     return 1;
        !          1063: 
        !          1064: } /* end function find_end_central_dir() */
        !          1065: 
        !          1066: 
        !          1067: 
        !          1068: 
        !          1069: 
        !          1070: /***************************************/
        !          1071: /*  Function process_end_central_dir() */
        !          1072: /***************************************/
        !          1073: 
        !          1074: int process_end_central_dir()    /* return PK-type error code */
        !          1075: {
        !          1076:     ec_byte_rec byterec;
        !          1077:     int error=0;
        !          1078: 
        !          1079: 
        !          1080: /*---------------------------------------------------------------------------
        !          1081:     Read the end-of-central-directory record and do any necessary machine-
        !          1082:     type conversions (byte ordering, structure padding compensation) by
        !          1083:     reading data into character array, then copying to struct.
        !          1084:   ---------------------------------------------------------------------------*/
        !          1085: 
        !          1086:     if (readbuf((char *) byterec, ECREC_SIZE+4) <= 0)
        !          1087:         return 51;
        !          1088: 
        !          1089:     ecrec.number_this_disk =
        !          1090:         makeword(&byterec[NUMBER_THIS_DISK]);
        !          1091:     ecrec.num_disk_with_start_central_dir =
        !          1092:         makeword(&byterec[NUM_DISK_WITH_START_CENTRAL_DIR]);
        !          1093:     ecrec.num_entries_centrl_dir_ths_disk =
        !          1094:         makeword(&byterec[NUM_ENTRIES_CENTRL_DIR_THS_DISK]);
        !          1095:     ecrec.total_entries_central_dir =
        !          1096:         makeword(&byterec[TOTAL_ENTRIES_CENTRAL_DIR]);
        !          1097:     ecrec.size_central_directory =
        !          1098:         makelong(&byterec[SIZE_CENTRAL_DIRECTORY]);
        !          1099:     ecrec.offset_start_central_directory =
        !          1100:         makelong(&byterec[OFFSET_START_CENTRAL_DIRECTORY]);
        !          1101:     ecrec.zipfile_comment_length =
        !          1102:         makeword(&byterec[ZIPFILE_COMMENT_LENGTH]);
        !          1103: 
        !          1104: /*---------------------------------------------------------------------------
        !          1105:     Get the zipfile comment, if any, and print it out.  (Comment may be up
        !          1106:     to 64KB long.  May the fleas of a thousand camels infest the armpits of
        !          1107:     anyone who actually takes advantage of this fact.)  Then position the
        !          1108:     file pointer to the beginning of the central directory and fill buffer.
        !          1109:   ---------------------------------------------------------------------------*/
        !          1110: 
        !          1111: #ifdef MSWIN
        !          1112:     cchComment = ecrec.zipfile_comment_length; /* save for comment button */
        !          1113:     if (ecrec.zipfile_comment_length && zflag) {
        !          1114: #else /* !MSWIN */
        !          1115:     if (ecrec.zipfile_comment_length && !quietflg) {
        !          1116:         if (!zflag)
        !          1117:           printf("[%s] comment:\n", zipfn);
        !          1118: #endif /* ?MSWIN */
        !          1119:         if (do_string(ecrec.zipfile_comment_length,DISPLAY)) {
        !          1120:             fprintf(stderr, "\ncaution:  zipfile comment truncated\n");
        !          1121:             error = 1;          /* 1:  warning error */
        !          1122:         }
        !          1123:     }
        !          1124: 
        !          1125:     return error;
        !          1126: 
        !          1127: } /* end function process_end_central_dir() */
        !          1128: 
        !          1129: 
        !          1130: 
        !          1131: 
        !          1132: 
        !          1133: /* also referenced in UpdateListBox() in updatelb.c (Windows version) */
        !          1134: char *Headers[][2] = {
        !          1135:     {" Length    Date    Time    Name",
        !          1136:      " ------    ----    ----    ----"},
        !          1137:     {" Length  Method   Size  Ratio   Date    Time   CRC-32     Name",
        !          1138:      " ------  ------   ----  -----   ----    ----   ------     ----"}
        !          1139: };
        !          1140: 
        !          1141: /*************************/
        !          1142: /* Function list_files() */
        !          1143: /*************************/
        !          1144: 
        !          1145: int list_files()    /* return PK-type error code */
        !          1146: {
        !          1147:     char **fnamev;
        !          1148:     int do_this_file=FALSE, ratio, error, error_in_archive=0;
        !          1149:     int which_hdr=(vflag>1), date_format;
        !          1150:     UWORD j, yr, mo, dy, hh, mm, members=0;
        !          1151:     ULONG tot_csize=0L, tot_ucsize=0L;
        !          1152: #ifdef OS2
        !          1153:     ULONG tot_easize=0L, tot_eafiles=0L, ea_size;
        !          1154: #endif
        !          1155: #ifdef MSWIN
        !          1156:     PSTR psLBEntry;  /* list box entry */
        !          1157: #endif
        !          1158:     min_info info;
        !          1159:     static char *method[NUM_METHODS+1] =
        !          1160:         {"Stored", "Shrunk", "Reduce1", "Reduce2", "Reduce3", "Reduce4",
        !          1161:          "Implode", "Token", "Deflate", unkn};
        !          1162: 
        !          1163: 
        !          1164: 
        !          1165: /*---------------------------------------------------------------------------
        !          1166:     Unlike extract_or_test_files(), this routine confines itself to the cen-
        !          1167:     tral directory.  Thus its structure is somewhat simpler, since we can do
        !          1168:     just a single loop through the entire directory, listing files as we go.
        !          1169: 
        !          1170:     So to start off, print the heading line and then begin main loop through
        !          1171:     the central directory.  The results will look vaguely like the following:
        !          1172: 
        !          1173:   Length  Method   Size  Ratio   Date    Time   CRC-32     Name ("^" ==> case
        !          1174:   ------  ------   ----  -----   ----    ----   ------     ----   conversion)
        !          1175:    44004  Implode  13041  71%  11-02-89  19:34  8b4207f7   Makefile.UNIX
        !          1176:     3438  Shrunk    2209  36%  09-15-90  14:07  a2394fd8  ^dos-file.ext
        !          1177:   ---------------------------------------------------------------------------*/
        !          1178: 
        !          1179:     pInfo = &info;
        !          1180:     date_format = dateformat();
        !          1181: 
        !          1182: #ifndef MSWIN
        !          1183:     if (quietflg < 2)
        !          1184:         if (U_flag)
        !          1185:             printf("%s\n%s\n", Headers[which_hdr][0], Headers[which_hdr][1]);
        !          1186:         else
        !          1187:             printf("%s (\"^\" ==> case\n%s   conversion)\n", 
        !          1188:               Headers[which_hdr][0], Headers[which_hdr][1]);
        !          1189: #endif /* !MSWIN */
        !          1190: 
        !          1191:     for (j = 0; j < ecrec.total_entries_central_dir; ++j) {
        !          1192: 
        !          1193:         if (readbuf(sig, 4) <= 0)
        !          1194:             return 51;          /* 51:  unexpected EOF */
        !          1195:         if (strncmp(sig, central_hdr_sig, 4)) {  /* just to make sure */
        !          1196:             fprintf(stderr, CentSigMsg, j);  /* sig not found */
        !          1197:             fprintf(stderr, ReportMsg);   /* check binary transfers */
        !          1198:             return 3;           /* 3:  error in zipfile */
        !          1199:         }
        !          1200:         if ((error = process_cdir_file_hdr()) != 0)  /* (sets pInfo->lcflag) */
        !          1201:             return error;       /* only 51 (EOF) defined */
        !          1202: 
        !          1203:         /*
        !          1204:          * We could DISPLAY the filename instead of storing (and possibly trun-
        !          1205:          * cating, in the case of a very long name) and printing it, but that
        !          1206:          * has the disadvantage of not allowing case conversion--and it's nice
        !          1207:          * to be able to see in the listing precisely how you have to type each
        !          1208:          * filename in order for unzip to consider it a match.  Speaking of
        !          1209:          * which, if member names were specified on the command line, check in
        !          1210:          * with match() to see if the current file is one of them, and make a
        !          1211:          * note of it if it is.
        !          1212:          */
        !          1213: 
        !          1214:         if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
        !          1215:             error_in_archive = error;  /*             ^--(uses pInfo->lcflag) */
        !          1216:             if (error > 1)      /* fatal:  can't continue */
        !          1217:                 return error;
        !          1218:         }
        !          1219:         if (extra_field != (byte *)NULL)
        !          1220:             free(extra_field);
        !          1221:         extra_field = (byte *)NULL;
        !          1222:         if ((error = do_string(crec.extra_field_length, EXTRA_FIELD)) != 0) {
        !          1223:             error_in_archive = error;  
        !          1224:             if (error > 1)      /* fatal:  can't continue */
        !          1225:                 return error;
        !          1226:         }
        !          1227:         if (!process_all_files) {   /* check if specified on command line */
        !          1228:             do_this_file = FALSE;
        !          1229:             fnamev = fnv;       /* don't destroy permanent filename ptr */
        !          1230:             for (--fnamev; *++fnamev;)
        !          1231:                 if (match(filename, *fnamev)) {
        !          1232:                     do_this_file = TRUE;
        !          1233:                     break;      /* found match, so stop looping */
        !          1234:                 }
        !          1235:         }
        !          1236:         /*
        !          1237:          * If current file was specified on command line, or if no names were
        !          1238:          * specified, do the listing for this file.  Otherwise, get rid of the
        !          1239:          * file comment and go back for the next file.
        !          1240:          */
        !          1241: 
        !          1242:         if (process_all_files || do_this_file) {
        !          1243: 
        !          1244:             yr = (((crec.last_mod_file_date >> 9) & 0x7f) + 80) % (unsigned)100;
        !          1245:             mo = (crec.last_mod_file_date >> 5) & 0x0f;
        !          1246:             dy = crec.last_mod_file_date & 0x1f;
        !          1247: 
        !          1248:             /* twist date so it displays according to national convention */
        !          1249:             switch (date_format) {
        !          1250:                 case DF_YMD:
        !          1251:                     hh = mo; mo = yr; yr = dy; dy = hh; break;
        !          1252:                 case DF_DMY:
        !          1253:                     hh = mo; mo = dy; dy = hh;
        !          1254:             }
        !          1255:             hh = (crec.last_mod_file_time >> 11) & 0x1f;
        !          1256:             mm = (crec.last_mod_file_time >> 5) & 0x3f;
        !          1257: 
        !          1258:             csize = (longint) crec.compressed_size;
        !          1259:             ucsize = (longint) crec.uncompressed_size;
        !          1260:             if (crec.general_purpose_bit_flag & 1)
        !          1261:                 csize -= 12;    /* if encrypted, don't count encrypt hdr */
        !          1262: 
        !          1263:             ratio = (ucsize == 0) ? 0 :   /* .zip can have 0-length members */
        !          1264:                 ((ucsize > 2000000L) ?    /* risk signed overflow if mult. */
        !          1265:                 (int) ((ucsize-csize) / (ucsize/1000L)) + 5 :   /* big */
        !          1266:                 (int) ((1000L*(ucsize-csize)) / ucsize) + 5);   /* small */
        !          1267: 
        !          1268: #if 0       /* GRR/Euro:  add this?  define p above */
        !          1269: #if (defined(DOS_OS2) || (defined(UNIX) && !defined(VMS)))
        !          1270:             for (p = filename;  *p;  ++p)
        !          1271:                 if (!isprint(*p))
        !          1272:                     *p = '?';  /* change non-printable chars to '?' */
        !          1273: #endif /* DOS_OS2 || UNIX */
        !          1274: #endif /* 0 */
        !          1275: 
        !          1276: #ifdef MSWIN
        !          1277: #ifdef NEED_EARLY_REDRAW
        !          1278:             /* turn on listbox redrawing just before adding last line */
        !          1279:             if (j == (ecrec.total_entries_central_dir-1))
        !          1280:                 (void)SendMessage(hWndList, WM_SETREDRAW, TRUE, 0L);
        !          1281: #endif /* NEED_EARLY_REDRAW */
        !          1282:             psLBEntry =
        !          1283:               (PSTR)LocalAlloc(LMEM_FIXED, FILNAMSIZ+LONG_FORM_FNAME_INX);
        !          1284:             switch (which_hdr) {
        !          1285:                 case 0:   /* short form */
        !          1286:                     OemToAnsi(filename, filename);  /* translate to ANSI */
        !          1287:                     wsprintf(psLBEntry, "%7ld  %02u-%02u-%02u  %02u:%02u  %c%s",
        !          1288:                       (long)ucsize, mo, dy, yr, hh, mm, (pInfo->lcflag?'^':' '),
        !          1289:                       (LPSTR)filename);
        !          1290:                     SendMessage(hWndList, LB_ADDSTRING, 0,
        !          1291:                       (LONG)(LPSTR)psLBEntry);
        !          1292:                     break;
        !          1293:                 case 1:   /* verbose */
        !          1294:                     OemToAnsi(filename, filename);  /* translate to ANSI */
        !          1295:                     wsprintf(psLBEntry, 
        !          1296:                  "%7ld  %-7s%7ld %3d%%  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s",
        !          1297:                       (long)ucsize, (LPSTR)method[methnum], (long)csize,
        !          1298:                       ratio/10, mo, dy, yr, hh, mm, (unsigned long)crec.crc32,
        !          1299:                       (pInfo->lcflag?'^':' '), (LPSTR)filename);
        !          1300:                     SendMessage(hWndList, LB_ADDSTRING, 0,
        !          1301:                       (LONG)(LPSTR)psLBEntry);
        !          1302:             }
        !          1303:             LocalFree((HANDLE)psLBEntry);
        !          1304: #else /* !MSWIN */
        !          1305:             switch (which_hdr) {
        !          1306:                 case 0:   /* short form */
        !          1307:                     printf("%7ld  %02u-%02u-%02u  %02u:%02u  %c%s\n",
        !          1308:                       ucsize, mo, dy, yr, hh, mm, (pInfo->lcflag?'^':' '),
        !          1309:                       filename);
        !          1310:                     break;
        !          1311:                 case 1:   /* verbose */
        !          1312:                     printf(
        !          1313:               "%7ld  %-7s%7ld %3d%%  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s\n",
        !          1314:                       ucsize, method[methnum], csize, ratio/10, mo, dy, yr,
        !          1315:                       hh, mm, crec.crc32, (pInfo->lcflag?'^':' '), filename);
        !          1316:             }
        !          1317: #endif /* ?MSWIN */
        !          1318: 
        !          1319:             error = do_string(crec.file_comment_length, (QCOND? DISPLAY:SKIP));
        !          1320:             if (error) {
        !          1321:                 error_in_archive = error;  /* might be just warning */
        !          1322:                 if (error > 1)  /* fatal */
        !          1323:                     return error;
        !          1324:             }
        !          1325:             tot_ucsize += (ULONG) ucsize;
        !          1326:             tot_csize += (ULONG) csize;
        !          1327:             ++members;
        !          1328: #ifdef OS2
        !          1329:             if ((ea_size = SizeOfEAs(extra_field)) != 0) {
        !          1330:                 tot_easize += ea_size;
        !          1331:                 tot_eafiles++;
        !          1332:             }
        !          1333: #endif
        !          1334:         } else {        /* not listing this file */
        !          1335:             SKIP_(crec.file_comment_length)
        !          1336:         }
        !          1337:     }                   /* end for-loop (j: files in central directory) */
        !          1338: 
        !          1339: /*---------------------------------------------------------------------------
        !          1340:     Print footer line and totals (compressed size, uncompressed size, number
        !          1341:     of members in zipfile).
        !          1342:   ---------------------------------------------------------------------------*/
        !          1343: 
        !          1344:     ratio = (tot_ucsize == 0) ? 
        !          1345:         0 : ((tot_ucsize > 4000000L) ?   /* risk unsigned overflow if mult. */
        !          1346:         (int) ((tot_ucsize - tot_csize) / (tot_ucsize/1000L)) + 5 :
        !          1347:         (int) ((tot_ucsize - tot_csize) * 1000L / tot_ucsize) + 5);
        !          1348: 
        !          1349:     if (quietflg < 2) {
        !          1350: #ifdef MSWIN
        !          1351:         /* Display just the totals since the dashed lines get displayed
        !          1352:          * in UpdateListBox(). Get just enough space to display total.
        !          1353:          */
        !          1354:         switch (which_hdr) {
        !          1355:             case 0:         /* short */
        !          1356:                 wsprintf(lpumb->szTotalsLine, "%7lu                    %-7u", 
        !          1357:                   (ULONG)tot_ucsize, members);
        !          1358:                 break;
        !          1359:             case 1:         /* verbose */
        !          1360:                 wsprintf(lpumb->szTotalsLine, 
        !          1361:                   "%7lu         %7lu %3d%%                              %-7u", 
        !          1362:                   (ULONG)tot_ucsize, (ULONG)tot_csize, ratio / 10, members);
        !          1363:                 break;
        !          1364:         }
        !          1365: #else /* !MSWIN */
        !          1366:         switch (which_hdr) {
        !          1367:         case 0:         /* short */
        !          1368:             printf("%s\n%7lu                    %-7u\n",
        !          1369:                    " ------                    -------",
        !          1370:                    tot_ucsize, members);
        !          1371:             break;
        !          1372:         case 1:         /* verbose */
        !          1373:             printf(
        !          1374:               "%s\n%7lu         %7lu %3d%%                              %-7u\n",
        !          1375:               " ------          ------  ---                              -------",
        !          1376:               tot_ucsize, tot_csize, ratio / 10, members);
        !          1377:         }
        !          1378: #endif /* ?MSWIN */
        !          1379: #ifdef OS2
        !          1380:         if (tot_eafiles && tot_easize)
        !          1381:             printf("\n%ld file%s %ld bytes of EA's attached.\n", tot_eafiles, 
        !          1382:               tot_eafiles == 1 ? " has" : "s have a total of", tot_easize);
        !          1383: #endif
        !          1384:     }
        !          1385: /*---------------------------------------------------------------------------
        !          1386:     Double check that we're back at the end-of-central-directory record.
        !          1387:   ---------------------------------------------------------------------------*/
        !          1388: 
        !          1389:     readbuf(sig, 4);
        !          1390:     if (strncmp(sig, end_central_sig, 4)) {     /* just to make sure again */
        !          1391:         fprintf(stderr, EndSigMsg);  /* didn't find end-of-central-dir sig */
        !          1392: /*      fprintf(stderr, ReportMsg);   */
        !          1393:         error_in_archive = 1;        /* 1:  warning error */
        !          1394:     }
        !          1395:     return error_in_archive;
        !          1396: 
        !          1397: } /* end function list_files() */
        !          1398: 
        !          1399: 
        !          1400: 
        !          1401: 
        !          1402: 
        !          1403: /**************************************/
        !          1404: /*  Function process_cdir_file_hdr()  */
        !          1405: /**************************************/
        !          1406: 
        !          1407: int process_cdir_file_hdr()    /* return PK-type error code */
        !          1408: {
        !          1409:     cdir_byte_hdr byterec;
        !          1410: 
        !          1411: 
        !          1412: /*---------------------------------------------------------------------------
        !          1413:     Read the next central directory entry and do any necessary machine-type
        !          1414:     conversions (byte ordering, structure padding compensation--do so by
        !          1415:     copying the data from the array into which it was read (byterec) to the
        !          1416:     usable struct (crec)).
        !          1417:   ---------------------------------------------------------------------------*/
        !          1418: 
        !          1419:     if (readbuf((char *) byterec, CREC_SIZE) <= 0)
        !          1420:         return 51;   /* 51:  unexpected EOF */
        !          1421: 
        !          1422:     crec.version_made_by[0] = byterec[C_VERSION_MADE_BY_0];
        !          1423:     crec.version_made_by[1] = byterec[C_VERSION_MADE_BY_1];
        !          1424:     crec.version_needed_to_extract[0] = byterec[C_VERSION_NEEDED_TO_EXTRACT_0];
        !          1425:     crec.version_needed_to_extract[1] = byterec[C_VERSION_NEEDED_TO_EXTRACT_1];
        !          1426: 
        !          1427:     crec.general_purpose_bit_flag =
        !          1428:         makeword(&byterec[C_GENERAL_PURPOSE_BIT_FLAG]);
        !          1429:     crec.compression_method =
        !          1430:         makeword(&byterec[C_COMPRESSION_METHOD]);
        !          1431:     crec.last_mod_file_time =
        !          1432:         makeword(&byterec[C_LAST_MOD_FILE_TIME]);
        !          1433:     crec.last_mod_file_date =
        !          1434:         makeword(&byterec[C_LAST_MOD_FILE_DATE]);
        !          1435:     crec.crc32 =
        !          1436:         makelong(&byterec[C_CRC32]);
        !          1437:     crec.compressed_size =
        !          1438:         makelong(&byterec[C_COMPRESSED_SIZE]);
        !          1439:     crec.uncompressed_size =
        !          1440:         makelong(&byterec[C_UNCOMPRESSED_SIZE]);
        !          1441:     crec.filename_length =
        !          1442:         makeword(&byterec[C_FILENAME_LENGTH]);
        !          1443:     crec.extra_field_length =
        !          1444:         makeword(&byterec[C_EXTRA_FIELD_LENGTH]);
        !          1445:     crec.file_comment_length =
        !          1446:         makeword(&byterec[C_FILE_COMMENT_LENGTH]);
        !          1447:     crec.disk_number_start =
        !          1448:         makeword(&byterec[C_DISK_NUMBER_START]);
        !          1449:     crec.internal_file_attributes =
        !          1450:         makeword(&byterec[C_INTERNAL_FILE_ATTRIBUTES]);
        !          1451:     crec.external_file_attributes =
        !          1452:         makelong(&byterec[C_EXTERNAL_FILE_ATTRIBUTES]);  /* LONG, not word! */
        !          1453:     crec.relative_offset_local_header =
        !          1454:         makelong(&byterec[C_RELATIVE_OFFSET_LOCAL_HEADER]);
        !          1455: 
        !          1456:     pInfo->hostnum = MIN(crec.version_made_by[1], NUM_HOSTS);
        !          1457: /*  extnum = MIN(crec.version_needed_to_extract[1], NUM_HOSTS); */
        !          1458:     methnum = MIN(crec.compression_method, NUM_METHODS);
        !          1459:     if (methnum == NUM_METHODS)
        !          1460:         sprintf(unkn, "Unk:%03d", crec.compression_method);
        !          1461: 
        !          1462: /*---------------------------------------------------------------------------
        !          1463:     Set flag for lowercase conversion of filename, depending on which OS the
        !          1464:     file is coming from.  This section could be ifdef'd if some people have
        !          1465:     come to love DOS uppercase filenames under Unix...but really, guys, get
        !          1466:     a life. :)  NOTE THAT ALL SYSTEM NAMES NOW HAVE TRAILING UNDERSCORES!!!
        !          1467:     This is to prevent interference with compiler command-line defines such
        !          1468:     as -DUNIX, for example, which are then used in "#ifdef UNIX" constructs.
        !          1469:   ---------------------------------------------------------------------------*/
        !          1470: 
        !          1471:     pInfo->lcflag = 0;
        !          1472:     if (!U_flag)   /* as long as user hasn't specified case-preservation */
        !          1473:         switch (pInfo->hostnum) {
        !          1474:             case DOS_OS2_FAT_:
        !          1475:         /*  case VMS_:              VMS Zip converts filenames to lowercase */
        !          1476:             case VM_CMS_:           /* all caps? */
        !          1477:             case CPM_:              /* like DOS, right? */
        !          1478:         /*  case ATARI_:            ? */
        !          1479:         /*  case Z_SYSTEM_:         ? */
        !          1480:         /*  case TOPS20_:           (if we had such a thing...) */
        !          1481:                 pInfo->lcflag = 1;  /* convert filename to lowercase */
        !          1482:                 break;
        !          1483: 
        !          1484:             default:                /* AMIGA_, UNIX_, (ATARI_), OS2_HPFS_, */
        !          1485:                 break;              /*   MAC_, (Z_SYSTEM_):  no conversion */
        !          1486:         }
        !          1487: 
        !          1488:     return 0;
        !          1489: 
        !          1490: } /* end function process_cdir_file_hdr() */
        !          1491: 
        !          1492: 
        !          1493: 
        !          1494: 
        !          1495: 
        !          1496: /***************************************/
        !          1497: /*  Function process_local_file_hdr()  */
        !          1498: /***************************************/
        !          1499: 
        !          1500: int process_local_file_hdr()    /* return PK-type error code */
        !          1501: {
        !          1502:     local_byte_hdr byterec;
        !          1503: 
        !          1504: 
        !          1505: /*---------------------------------------------------------------------------
        !          1506:     Read the next local file header and do any necessary machine-type con-
        !          1507:     versions (byte ordering, structure padding compensation--do so by copy-
        !          1508:     ing the data from the array into which it was read (byterec) to the
        !          1509:     usable struct (lrec)).
        !          1510:   ---------------------------------------------------------------------------*/
        !          1511: 
        !          1512:     if (readbuf((char *) byterec, LREC_SIZE) <= 0)
        !          1513:         return 51;   /* 51:  unexpected EOF */
        !          1514: 
        !          1515:     lrec.version_needed_to_extract[0] = byterec[L_VERSION_NEEDED_TO_EXTRACT_0];
        !          1516:     lrec.version_needed_to_extract[1] = byterec[L_VERSION_NEEDED_TO_EXTRACT_1];
        !          1517: 
        !          1518:     lrec.general_purpose_bit_flag = makeword(&byterec[L_GENERAL_PURPOSE_BIT_FLAG]);
        !          1519:     lrec.compression_method = makeword(&byterec[L_COMPRESSION_METHOD]);
        !          1520:     lrec.last_mod_file_time = makeword(&byterec[L_LAST_MOD_FILE_TIME]);
        !          1521:     lrec.last_mod_file_date = makeword(&byterec[L_LAST_MOD_FILE_DATE]);
        !          1522:     lrec.crc32 = makelong(&byterec[L_CRC32]);
        !          1523:     lrec.compressed_size = makelong(&byterec[L_COMPRESSED_SIZE]);
        !          1524:     lrec.uncompressed_size = makelong(&byterec[L_UNCOMPRESSED_SIZE]);
        !          1525:     lrec.filename_length = makeword(&byterec[L_FILENAME_LENGTH]);
        !          1526:     lrec.extra_field_length = makeword(&byterec[L_EXTRA_FIELD_LENGTH]);
        !          1527: 
        !          1528:     csize = (longint) lrec.compressed_size;
        !          1529:     ucsize = (longint) lrec.uncompressed_size;
        !          1530: 
        !          1531:     if ((lrec.general_purpose_bit_flag & 8) != 0) {
        !          1532:         /* Can't trust local header, use central directory: */
        !          1533:       lrec.crc32 = pInfo->crc;
        !          1534:         lrec.compressed_size = pInfo->compr_size;
        !          1535:         csize = (longint) lrec.compressed_size;
        !          1536:     }
        !          1537: 
        !          1538:     return 0;                 /* 0:  no error */
        !          1539: 
        !          1540: } /* end function process_local_file_hdr() */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.