home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume19 / unzip / part01 next >
Text File  |  1991-05-19  |  54KB  |  1,460 lines
  1. Newsgroups: comp.sources.misc
  2. From: David Kirschbaum <kirsch@usasoc.soc.mil>
  3. Subject:  v19i096:  unzip - Portable unzip v4.1, Part01/06
  4. Message-ID: <1991May20.012040.29123@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 8f2def4e88a30816021b5578e62b8e5b
  6. Date: Mon, 20 May 1991 01:20:40 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: David Kirschbaum <kirsch@usasoc.soc.mil>
  10. Posting-number: Volume 19, Issue 96
  11. Archive-name: unzip/part01
  12. Supersedes: unzip-3.1: Volume 14, Issue 102-106
  13.  
  14. This is unzip v4.1, a public distribution version of the Info-ZIP project's
  15. portable generic Unix unzip utility.  This version of unzip has been ported 
  16. to a wide array of Unix and other mainframes, minis, and micros (to include 
  17. MSDOS, Atari ST (kinda), and Macintosh).  Although highly compatible with 
  18. Phil Katz's PKZIP and PKUNZIP utilities of MSDOS fame, our objective has been 
  19. one of portability and other-than-MSDOS functionality.
  20.  
  21. See the Makefile (or the system-specific archives) for details on
  22. how to compile for your system.  See unzip.1 or unzip.man for usage.  
  23. (No, there isn't a manual per se.  There's plenty of space on the 
  24. Info-ZIP staff for a volunteer!)
  25.  
  26. If any changes are made to source, we'd appreciate them (context diff
  27. files only, please) with explanation as appropriate.
  28.  
  29. All E-Mail should go to Info-ZIP@WSMR-SIMTEL20.Army.Mil directly
  30. (and not to me:  I'm only the Coordinator).  However, if you're
  31. requesting something special (e.g., a copy of the "No Feelthy ..."
  32. rules for source and change submission), E-Mail me personally.
  33.  
  34. If you'd like to keep up to date with our unzip (and companion zip
  35. utility) development, join the ranks of BETA testers, add your own
  36. thoughts and contributions, etc., send your request to
  37.  
  38.  Info-ZIP-Request@WSMR-SIMTEL20.Army.Mil
  39.  
  40. and Keith Petersen'll add you to the Info-ZIP newsletter mailing list.
  41. Read unzip41.descr for some more details.
  42.  
  43. David Kirschbaum
  44. Toad Hall
  45. Info-ZIP Coordinator
  46. -----
  47. #! /bin/sh
  48. # This is a shell archive.  Remove anything before this line, then feed it
  49. # into a shell via "sh file" or similar.  To overwrite existing files,
  50. # type "sh file -c".
  51. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  52. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  53. # Contents:  MANIFEST . ./v41 ./v41/ATARI_ST ./v41/ATARI_ST/MAKEFILE.ST
  54. #   ./v41/MAC ./v41/MAC/macstat.c ./v41/MSDOS ./v41/OS2 ./v41/VMS
  55. #   ./v41/unzip.c.1
  56. # Wrapped by kent@sparky on Sun May 19 19:40:38 1991
  57. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  58. echo If this archive is complete, you will see the following message:
  59. echo '          "shar: End of archive 1 (of 6)."'
  60. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  61.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  62. else
  63.   echo shar: Extracting \"'MANIFEST'\" \(1735 characters\)
  64.   sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  65. X   File Name        Archive #    Description
  66. X----------------------------------------------------------
  67. XMANIFEST                   1    This shipping list
  68. X.                          1    
  69. X./v41                      1    
  70. X./v41/ATARI_ST             1    Atari ST-peculiar files 
  71. X./v41/ATARI_ST/MAKEFILE.ST  1    
  72. X./v41/ATARI_ST/MAKEIT      6    (for Turbo C)
  73. X./v41/ATARI_ST/README.ST   5    
  74. X./v41/ATARI_ST/TCM         6    
  75. X./v41/ATARI_ST/TLINK.OPT   5    
  76. X./v41/ATARI_ST/UNZIP.PRJ   6    
  77. X./v41/ATARI_ST/tc_cfg.uue  5    Uuencoded binary file
  78. X./v41/History.41           4    Development history
  79. X./v41/MAC                  1    Macintosh-peculiar files
  80. X./v41/MAC/macfile.c        5    
  81. X./v41/MAC/macstat.c        1    
  82. X./v41/MAC/macstat.h        6    
  83. X./v41/MSDOS                1    MSDOS-peculiar files
  84. X./v41/MSDOS/MAKEFILE.DOS   5    
  85. X./v41/MSDOS/UNZIP.PRJ      6    
  86. X./v41/MSDOS/tcconfig.uue   6    Uuencoded binary file
  87. X./v41/Makefile             4    
  88. X./v41/OS2                  1    OS2-peculiar files
  89. X./v41/OS2/Readme.os2       6    
  90. X./v41/OS2/unzip.def        6    
  91. X./v41/VMS                  1    VMS-peculiar files
  92. X./v41/VMS/DESCRIP.MMS      6    
  93. X./v41/VMS/VMS_MAKE.COM     6    
  94. X./v41/VMS/VMSnotes         5    
  95. X./v41/VMS/fatdef.h         6    
  96. X./v41/VMS/fchdef.h         6    
  97. X./v41/VMS/fjndef.h         2    
  98. X./v41/VMS/vms_attr.c       5    
  99. X./v41/file_io.c            3    
  100. X./v41/mapname.c            4    
  101. X./v41/match.c              4    
  102. X./v41/misc.c               3    
  103. X./v41/unimplod.c           3    
  104. X./v41/unreduce.c           5    
  105. X./v41/unshrink.c           5    
  106. X./v41/unzip.1              5    
  107. X./v41/unzip.c.1            1    unzip.c, part 1
  108. X./v41/unzip.c.2            2    unzip.c, part 2
  109. X./v41/unzip.h              2    
  110. X./v41/unzip.man            5    
  111. X./v41/unzip41.descr        6    Description
  112. X./v41/ziprules.txt         5    Rules for contributors
  113. END_OF_FILE
  114.   if test 1735 -ne `wc -c <'MANIFEST'`; then
  115.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  116.   fi
  117.   # end of 'MANIFEST'
  118. fi
  119. if test ! -d './v41' ; then
  120.     echo shar: Creating directory \"'./v41'\"
  121.     mkdir './v41'
  122. fi
  123. if test ! -d './v41/ATARI_ST' ; then
  124.     echo shar: Creating directory \"'./v41/ATARI_ST'\"
  125.     mkdir './v41/ATARI_ST'
  126. fi
  127. if test -f './v41/ATARI_ST/MAKEFILE.ST' -a "${1}" != "-c" ; then 
  128.   echo shar: Will not clobber existing file \"'./v41/ATARI_ST/MAKEFILE.ST'\"
  129. else
  130.   echo shar: Extracting \"'./v41/ATARI_ST/MAKEFILE.ST'\" \(1093 characters\)
  131.   sed "s/^X//" >'./v41/ATARI_ST/MAKEFILE.ST' <<'END_OF_FILE'
  132. X#  Makefile.st    Makefile for UnZip 4.0,
  133. X#  using Turbo C 2.0 for the Atari ST and
  134. X#  make from the Mark Williams C 3.9 (sorry for that mixture)
  135. X#
  136. X
  137. X# UPPERCASE file names facilitate TD's understanding of modules.
  138. X.SUFFIXES: .o .O .c .C .s
  139. X
  140. XDISK    = E:
  141. X#####################
  142. X# MACRO DEFINITIONS #
  143. X#####################
  144. X
  145. XCC    = tcc
  146. X#CFLAGS    = -DATARI_ST=1 -Y -I=$(DISK)\tc\include
  147. XCFLAGS    = -DATARI_ST=1 -I=$(DISK)\tc\include
  148. X#LFLAGS    = -L -Y
  149. XLFLAGS    =
  150. XLIB    = $(DISK)\tc\lib
  151. XLD    = tlink
  152. X
  153. XOBJS = unzip.o file_io.o mapname.o match.o misc.o\
  154. X       unimplod.o unreduce.o unshrink.o
  155. X
  156. X
  157. X###############################################
  158. X# BASIC COMPILE INSTRUCTIONS AND DEPENDENCIES #
  159. X###############################################
  160. X
  161. XALL    : unzip.prg
  162. X    echo done
  163. X
  164. Xunzip.o:      unzip.c unzip.h
  165. X
  166. Xfile_io.o:    file_io.c unzip.h
  167. X
  168. Xmapname.o:    mapname.c unzip.h
  169. X
  170. Xmatch.o:      match.c unzip.h
  171. X
  172. Xmisc.o:       misc.c unzip.h
  173. X
  174. Xunimplod.o:   unimplod.c unzip.h
  175. X
  176. Xunreduce.o:   unreduce.c unzip.h
  177. X
  178. Xunshrink.o:   unshrink.c unzip.h
  179. X
  180. Xunzip.prg:     $(OBJS)
  181. X    tlink -O=$@ $(LFLAGS) -S=4096 -C=tlink.opt
  182. X
  183. X.c.o:
  184. X    tcc $(CFLAGS) $<
  185. X
  186. END_OF_FILE
  187.   if test 1093 -ne `wc -c <'./v41/ATARI_ST/MAKEFILE.ST'`; then
  188.     echo shar: \"'./v41/ATARI_ST/MAKEFILE.ST'\" unpacked with wrong size!
  189.   fi
  190.   # end of './v41/ATARI_ST/MAKEFILE.ST'
  191. fi
  192. if test ! -d './v41/MAC' ; then
  193.     echo shar: Creating directory \"'./v41/MAC'\"
  194.     mkdir './v41/MAC'
  195. fi
  196. if test -f './v41/MAC/macstat.c' -a "${1}" != "-c" ; then 
  197.   echo shar: Will not clobber existing file \"'./v41/MAC/macstat.c'\"
  198. else
  199.   echo shar: Extracting \"'./v41/MAC/macstat.c'\" \(5947 characters\)
  200.   sed "s/^X//" >'./v41/MAC/macstat.c' <<'END_OF_FILE'
  201. X#ifdef THINK_C
  202. X#define MACOS
  203. X#include    <FileMgr.h>
  204. X#include    <HFS.h>
  205. X#include    <pascal.h>
  206. X#endif
  207. X#ifdef MPW
  208. X#define MACOS
  209. X#include    <Files.h>
  210. X#include    <Errors.h>
  211. X#define FSFCBLen    (*(short *)0x3F6)
  212. X#define hFileInfo   hfileInfo
  213. X#define CtoPstr c2pstr
  214. X#define PtoCstr p2cstr
  215. X#endif
  216. X
  217. X#ifdef MACOS
  218. X#include    <string.h>
  219. X#include    "macstat.h"
  220. Xint stat(char *path, struct stat *buf);
  221. X
  222. X/* assume that the path will contain a Mac-type pathname, i.e. ':'s, etc. */
  223. Xint stat(path, buf)
  224. Xchar *path;
  225. Xstruct stat *buf;
  226. X{
  227. X    char    temp[256];
  228. X    short   curVolume;
  229. X    long    curDir;
  230. X    short   fIsHFS = false;
  231. X    OSErr   err;
  232. X
  233. X    if (buf == (struct stat *)0L || path == (char *)0L) {
  234. X        SysBeep(1);
  235. X        return -1;
  236. X    }
  237. X    
  238. X    if (path[0] == '\0' || strlen(path)>255) {
  239. X        return -1;
  240. X    }
  241. X
  242. X    if (GetVol((StringPtr)&temp[0], &curVolume) != noErr) {
  243. X        SysBeep(1);
  244. X        return -1;
  245. X    }
  246. X    
  247. X    /* get info about the specified volume */
  248. X    if (FSFCBLen > 0)   /* HFS Disk? */
  249. X    {
  250. X        WDPBRec wdpb;
  251. X        HParamBlockRec    hpbr;
  252. X        Str255 st;
  253. X
  254. X        wdpb.ioCompletion = 0;
  255. X        wdpb.ioNamePtr = temp;
  256. X        err = PBHGetVol(&wdpb, 0);
  257. X        if (err == noErr)
  258. X        {
  259. X            hpbr.volumeParam.ioCompletion = 0;
  260. X            hpbr.volumeParam.ioNamePtr = st;
  261. X            hpbr.volumeParam.ioVRefNum = wdpb.ioVRefNum;
  262. X            hpbr.volumeParam.ioVolIndex = 0;
  263. X            err = PBHGetVInfo(&hpbr, 0);
  264. X
  265. X            if (err == noErr && hpbr.volumeParam.ioVFSID == 0
  266. X                && hpbr.volumeParam.ioVSigWord == 0x4244) {
  267. X                    fIsHFS = true;
  268. X            }
  269. X        }
  270. X    }
  271. X
  272. X
  273. X    /* number of links, at least in System 6.0x, 0 */
  274. X    buf->st_nlink = 0;
  275. X    /* user id */
  276. X    buf->st_uid = 0;
  277. X    /* group id */
  278. X    buf->st_gid = 0;
  279. X
  280. X    if (fIsHFS == true)   /* HFS? */
  281. X    {
  282. X        CInfoPBRec  cPB;
  283. X        HParamBlockRec  wPB;
  284. X        
  285. X        wPB.wdParam.ioCompletion = (ProcPtr)0L;
  286. X        wPB.wdParam.ioNamePtr = (StringPtr)temp;
  287. X        err = PBHGetVol((WDPBPtr)&wPB, false);
  288. X        if (err != noErr) {
  289. X            SysBeep(1);
  290. X            return -1;
  291. X        }
  292. X
  293. X        curVolume = wPB.wdParam.ioWDVRefNum;
  294. X        buf->st_dev = curDir = wPB.wdParam.ioWDDirID;
  295. X        
  296. X        /* get information about file */
  297. X        cPB.hFileInfo.ioCompletion = (ProcPtr)0L;
  298. X        CtoPstr(path);
  299. X        strncpy(temp,path, path[0]+1);
  300. X        PtoCstr(path);
  301. X        cPB.hFileInfo.ioNamePtr = (StringPtr)temp;
  302. X        cPB.hFileInfo.ioVRefNum = 0;
  303. X        cPB.hFileInfo.ioDirID = 0;
  304. X        cPB.hFileInfo.ioFDirIndex = 0;
  305. X        
  306. X        err = PBGetCatInfo(&cPB, false); 
  307. X        
  308. X        if (err != noErr) {
  309. X            if (err != fnfErr) {
  310. X                SysBeep(1);
  311. X            }
  312. X            return -1;
  313. X        }
  314. X        
  315. X        /* Type of file: directory or regular file */
  316. X        buf->st_mode = (cPB.hFileInfo.ioFlAttrib & ioDirMask) ? S_IFDIR : S_IFREG;
  317. X        
  318. X        /* last access time, modification time and creation time(?) */
  319. X        buf->st_atime = buf->st_mtime = cPB.hFileInfo.ioFlMdDat;
  320. X        buf->st_ctime = cPB.hFileInfo.ioFlCrDat;
  321. X        /* inode number */
  322. X        buf->st_ino = cPB.hFileInfo.ioDirID + ((long)curVolume)<<16;
  323. X        /* size of file - use only the data fork */
  324. X        buf->st_size = cPB.hFileInfo.ioFlLgLen;
  325. X        /* size of disk block */
  326. X        if (cPB.hFileInfo.ioFlClpSiz == 0) {
  327. X            HParamBlockRec hPB;
  328. X            
  329. X            hPB.volumeParam.ioCompletion = (ProcPtr)0L;
  330. X            hPB.volumeParam.ioNamePtr = (StringPtr)temp;
  331. X            hPB.volumeParam.ioVRefNum = 0;
  332. X            hPB.volumeParam.ioVolIndex = 0;
  333. X            
  334. X            err = PBHGetVInfo(&hPB, false);
  335. X            
  336. X            if (err != noErr) {
  337. X                SysBeep(1);
  338. X                return -1;
  339. X            }
  340. X            
  341. X            buf->st_blksize = hPB.volumeParam.ioVClpSiz;
  342. X        }
  343. X        else
  344. X            buf->st_blksize = cPB.hFileInfo.ioFlClpSiz;
  345. X    
  346. X        buf->st_blocks = cPB.hFileInfo.ioFlPyLen/ buf->st_blksize;
  347. X    }
  348. X    else    /* MFS? */
  349. X    {
  350. X        ParamBlockRec   pPB;
  351. X        
  352. X        buf->st_dev = 0;
  353. X        
  354. X        CtoPstr(path);
  355. X        strncpy(temp, path, path[0]+1);
  356. X        PtoCstr(path);
  357. X        pPB.fileParam.ioCompletion = (ProcPtr)0;
  358. X        pPB.fileParam.ioNamePtr = (StringPtr)temp;
  359. X        pPB.fileParam.ioVRefNum = curVolume;
  360. X        pPB.fileParam.ioFVersNum = 0;
  361. X        pPB.fileParam.ioFDirIndex = 0;
  362. X        
  363. X        err = PBGetFInfo(&pPB, false);   
  364. X        
  365. X        if (err != noErr) {
  366. X            SysBeep(1);
  367. X            return -1;
  368. X        }
  369. X        
  370. X        /* Type of file: either directory or regular file */
  371. X        buf->st_mode = (pPB.fileParam.ioFlAttrib & ioDirMask) ? S_IFDIR : S_IFREG;
  372. X        
  373. X        /* last access time, modification time and creation time(?) */
  374. X        buf->st_atime = buf->st_mtime = pPB.fileParam.ioFlMdDat;
  375. X        buf->st_ctime = pPB.fileParam.ioFlCrDat;
  376. X        /* inode number */
  377. X        buf->st_ino = pPB.fileParam.ioFlNum + ((long)curVolume)<<16;
  378. X        /* size of file - use only the data fork */
  379. X        buf->st_size = pPB.fileParam.ioFlLgLen;
  380. X        /* size of disk block */
  381. X        {
  382. X            ParamBlockRec hPB;
  383. X            
  384. X            hPB.volumeParam.ioCompletion = (ProcPtr)0;
  385. X            hPB.volumeParam.ioNamePtr = (StringPtr)temp;
  386. X            hPB.volumeParam.ioVRefNum = curVolume;
  387. X            hPB.volumeParam.ioVolIndex = 0;
  388. X            
  389. X            err = PBGetVInfo(&hPB, false);
  390. X            
  391. X            if (err != noErr) {
  392. X                SysBeep(1);
  393. X                return -1;
  394. X            }
  395. X            
  396. X            buf->st_blksize = hPB.volumeParam.ioVClpSiz;
  397. X        }
  398. X    
  399. X        /* number of disk blocks used by file - includes resource fork */
  400. X        buf->st_blocks = pPB.fileParam.ioFlPyLen/ buf->st_blksize +
  401. X                            pPB.fileParam.ioFlRPyLen/buf->st_blksize;
  402. X    }
  403. X
  404. X    return 0;
  405. X}
  406. X#else
  407. X#error 1
  408. X#endif
  409. END_OF_FILE
  410.   if test 5947 -ne `wc -c <'./v41/MAC/macstat.c'`; then
  411.     echo shar: \"'./v41/MAC/macstat.c'\" unpacked with wrong size!
  412.   fi
  413.   # end of './v41/MAC/macstat.c'
  414. fi
  415. if test ! -d './v41/MSDOS' ; then
  416.     echo shar: Creating directory \"'./v41/MSDOS'\"
  417.     mkdir './v41/MSDOS'
  418. fi
  419. if test ! -d './v41/OS2' ; then
  420.     echo shar: Creating directory \"'./v41/OS2'\"
  421.     mkdir './v41/OS2'
  422. fi
  423. if test ! -d './v41/VMS' ; then
  424.     echo shar: Creating directory \"'./v41/VMS'\"
  425.     mkdir './v41/VMS'
  426. fi
  427. if test -f './v41/unzip.c.1' -a "${1}" != "-c" ; then 
  428.   echo shar: Will not clobber existing file \"'./v41/unzip.c.1'\"
  429. else
  430.   echo shar: Extracting \"'./v41/unzip.c.1'\" \(38155 characters\)
  431.   sed "s/^X//" >'./v41/unzip.c.1' <<'END_OF_FILE'
  432. X/*---------------------------------------------------------------------------
  433. X
  434. X  unzip.c
  435. X
  436. X  This is nearly a complete rewrite of unzip.c, mainly to allow access to
  437. X  zipfiles via the central directory (and hence to the OS bytes, so we can
  438. X  make intelligent decisions about what to do with the extracted files).
  439. X  Based on unzip.c 3.15+ and zipinfo.c 0.90.
  440. X
  441. X  ---------------------------------------------------------------------------
  442. X
  443. X  To compile (partial instructions):
  444. X
  445. X     under Unix (cc):  make <system name>
  446. X       (type "make" for list of valid names, or read Makefile for details)
  447. X
  448. X     under MS-DOS (TurboC):  make -fMAKEFILE.DOS  for command line compiles
  449. X       (or use the integrated environment and the included files TCCONFIG.TC
  450. X        and UNZIP.PRJ.  Tweak for your environment.)
  451. X
  452. X     under MS-DOS (MSC):  make MAKEFILE.DOS
  453. X       (or use Makefile if you have MSC 6.0:  "nmake msc_dos")
  454. X
  455. X     under OS/2 (MSC):  make MAKEFILE.DOS   (edit appropriately)
  456. X       (or use Makefile if you have MSC 6.0:  "nmake msc_os2")
  457. X
  458. X     under Atari OS:  Any Day Now.
  459. X
  460. X     under VMS:  DEFINE LNK$LIBRARY SYS$LIBRARY:VAXCRTL.OLB   (see VMSNOTES)
  461. X                 CC UNZIP,FILE_IO,MAPNAME,MATCH,...,UNSHRINK
  462. X                 LINK UNZIP,FILE_IO,MAPNAME,MATCH,...,UNSHRINK
  463. X                 UNZIP :== $DISKNAME:[DIRECTORY]UNZIP.EXE
  464. X
  465. X     under Macintosh OS:   Double click on unzip.mac.  Press <Command>-M
  466. X
  467. X  ---------------------------------------------------------------------------
  468. X
  469. X  Version:  unzip41.arc/unzip41.tar.Z for Unix, VMS, OS/2, MS-DOS & Mac
  470. X  Source:   wsmr-simtel20.army.mil (192.88.110.20) in pd1:[misc.unix]
  471. X            wuarchive.wustl.edu (128.252.135.4) in /mirrors/misc/unix
  472. X  Source:   wsmr-simtel20.army.mil (26.2.0.74) in pd1:[misc.unix]
  473. X
  474. X  ---------------------------------------------------------------------------
  475. X
  476. X  Copyright, originally from version 1.2 (?):
  477. X
  478. X     * Copyright 1989 Samuel H. Smith;  All rights reserved
  479. X     *
  480. X     * Do not distribute modified versions without my permission.
  481. X     * Do not remove or alter this notice or any other copyright notice.
  482. X     * If you use this in your own program you must distribute source code.
  483. X     * Do not use any of this in a commercial product.
  484. X
  485. X  ---------------------------------------------------------------------------
  486. X
  487. X  Comments from unzip.c, version 3.11:
  488. X
  489. X     * UnZip - A simple zipfile extract utility
  490. X     *
  491. X     * Compile-time definitions:
  492. X     * See the Makefile for details, explanations, and all the current
  493. X     * system makerules.
  494. X     *
  495. X     * If you have to add a new one for YOUR system, please forward the new
  496. X     * Makefile context diff to kirsch%maxemail@uunet.uu.net for distribution.
  497. X     * Be SURE to give FULL details on your system (hardware, OS, versions,
  498. X     * processor, whatever) that made it unique.
  499. X     *
  500. X     * REVISION HISTORY : See History.41 (or whatever current version is)
  501. X
  502. X  To join Info-ZIP, send a message to Info-ZIP-Request@WSMR-Simtel20.Army.Mil
  503. X
  504. X  ---------------------------------------------------------------------------*/
  505. X
  506. X
  507. X
  508. X
  509. X
  510. X#include "unzip.h"              /* includes, defines, and macros */
  511. X
  512. X#define VERSION  "v4.1 of 5-13-91"
  513. X#define PAKFIX   /* temporary solution to PAK-created zipfiles */
  514. X
  515. X
  516. X
  517. X
  518. X
  519. X/**********************/
  520. X/*  Global Variables */
  521. X/**********************/
  522. X
  523. Xint tflag;              /* -t: test */
  524. Xint vflag;              /* -v: view directory (only used in unzip.c) */
  525. Xint cflag;              /* -c: output to stdout */
  526. Xint aflag;              /* -a: do ascii to ebcdic translation OR CR-LF */
  527. X                        /*     to CR or LF conversion of extracted files */
  528. Xint dflag;              /* -d: create containing directories */
  529. Xint Uflag;              /* -U: leave filenames in upper or mixed case */
  530. Xint V_flag;             /* -V: don't strip VMS version numbers */
  531. Xint quietflg;           /* -q: produce a lot less output */
  532. Xint do_all;             /* -o: OK to overwrite files without prompting */
  533. Xint zflag;              /* -z: Display only the archive comment */
  534. X
  535. Xint lcflag;             /* convert filename to lowercase */
  536. Xunsigned f_attr;        /* file attributes (permissions) */
  537. Xlongint csize;          /* used by list_files(), ReadByte(): must be signed */
  538. Xlongint ucsize;         /* used by list_files(), unReduce(), unImplode() */
  539. X
  540. X/*---------------------------------------------------------------------------
  541. X    unShrink/unReduce/unImplode working storage:
  542. X  ---------------------------------------------------------------------------*/
  543. X
  544. X/* prefix_of (for unShrink) is biggest storage area, esp. on Crays...space */
  545. X/*  is shared by lit_nodes (unImplode) and followers (unReduce) */
  546. X
  547. Xshort prefix_of[HSIZE + 1];     /* (8193 * sizeof(short)) */
  548. X#ifdef MACOS
  549. Xbyte *suffix_of;
  550. Xbyte *stack;
  551. X#else
  552. Xbyte suffix_of[HSIZE + 1];      /* also s-f length_nodes (smaller) */
  553. Xbyte stack[HSIZE + 1];          /* also s-f distance_nodes (smaller) */
  554. X#endif
  555. X
  556. XULONG crc32val;
  557. X
  558. XUWORD mask_bits[] =
  559. X{0, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
  560. X    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff};
  561. X
  562. X/*---------------------------------------------------------------------------
  563. X    Input file variables:
  564. X  ---------------------------------------------------------------------------*/
  565. X
  566. Xbyte *inbuf, *inptr;    /* input buffer (any size is legal) and pointer */
  567. Xint incnt;
  568. X
  569. XUWORD bitbuf;
  570. Xint bits_left;
  571. Xboolean zipeof;
  572. X
  573. Xint zipfd;                      /* zipfile file handle */
  574. Xchar zipfn[FILNAMSIZ];
  575. X
  576. Xlocal_file_header lrec;
  577. Xstruct stat statbuf;            /* used by main(), mapped_name() */
  578. X
  579. Xlongint cur_zipfile_bufstart;   /* extract_or_test_files, readbuf, ReadByte */
  580. X
  581. X/*---------------------------------------------------------------------------
  582. X    Output stream variables:
  583. X  ---------------------------------------------------------------------------*/
  584. X
  585. Xbyte *outbuf;                   /* buffer for rle look-back */
  586. Xbyte *outptr;
  587. Xbyte *outout;                   /* scratch pad for ASCII-native trans */
  588. Xlongint outpos;                 /* absolute position in outfile */
  589. Xint outcnt;                     /* current position in outbuf */
  590. X
  591. Xint outfd;
  592. Xchar filename[FILNAMSIZ];
  593. X
  594. X/*---------------------------------------------------------------------------
  595. X    unzip.c static global variables (visible only within this file):
  596. X  ---------------------------------------------------------------------------*/
  597. X
  598. Xstatic char *fnames[2] =
  599. X{"*", NULL};                    /* default filenames vector */
  600. Xstatic char **fnv = &fnames[0];
  601. Xstatic char sig[5];
  602. Xstatic byte *hold;
  603. Xstatic int process_all_files;
  604. Xstatic longint ziplen;
  605. Xstatic UWORD hostnum;
  606. Xstatic UWORD methnum;
  607. X/* static UWORD extnum; */
  608. Xstatic central_directory_file_header crec;
  609. Xstatic end_central_dir_record ecrec;
  610. X
  611. X/*---------------------------------------------------------------------------
  612. X    unzip.c repeated error messages (we use all of these at least twice ==>
  613. X    worth it to centralize to keep executable small):
  614. X  ---------------------------------------------------------------------------*/
  615. X
  616. Xstatic char *CryptMsg =
  617. X  "%s:  encrypted (can't do yet)--skipping.\n";
  618. Xstatic char *FilNamMsg =
  619. X  "\n%s:  bad filename length (%s)\n";
  620. Xstatic char *ExtFieldMsg =
  621. X  "\n%s:  bad extra field length (%s)\n";
  622. Xstatic char *OffsetMsg =
  623. X  "\n%s:  bad zipfile offset (%s)\n";
  624. Xstatic char *EndSigMsg =
  625. X  "\nwarning:  didn't find end-of-central-dir signature at end of central dir.\n";
  626. Xstatic char *CentSigMsg =
  627. X  "\nerror:  expected central file header signature not found (file #%u).\n";
  628. Xstatic char *ReportMsg =
  629. X  "        (please report to info-zip@wsmr-simtel20.army.mil)\n";
  630. X
  631. X/* (original) Bill Davidsen version */
  632. X#define QCOND    (!quietflg)    /* -xq[q] kill "extracting: ..." msgs */
  633. X#define QCOND2   (which_hdr)    /* file comments with -v, -vq, -vqq */
  634. X
  635. X
  636. X
  637. X
  638. X/*****************/
  639. X/*  Main program */
  640. X/*****************/
  641. X
  642. Xmain(argc, argv)        /* return PK-type error code (except under VMS) */
  643. Xint argc;
  644. Xchar *argv[];
  645. X{
  646. X    char *s;
  647. X    int c, print_usage=TRUE;
  648. X
  649. X
  650. X
  651. X#ifdef MACOS
  652. X#ifdef THINK_C
  653. X    #include <console.h>
  654. X    #include <StdFilePkg.h>
  655. X    typedef struct sf_node {        /* node in a true shannon-fano tree */
  656. X        UWORD left;                 /* 0 means leaf node */
  657. X        UWORD right;                /*   or value if leaf node */
  658. X    } sf_node;
  659. X    static char *argstr[30], args[30*64];
  660. X 
  661. X    extern sf_node *lit_nodes, *length_nodes, *distance_nodes;
  662. X 
  663. X    Point   p;
  664. X    SFTypeList  sfT;
  665. X    int a;
  666. X    EventRecord theEvent;
  667. X    short   eMask;
  668. X    SFReply  fileRep;
  669. X
  670. X    suffix_of = (byte *)calloc(HSIZE+1, sizeof(byte));
  671. X    stack = (byte *)calloc(HSIZE+1, sizeof(byte));
  672. X    length_nodes = (sf_node *) suffix_of;  /* 2*LENVALS nodes */
  673. X    distance_nodes = (sf_node *) stack;    /* 2*DISTVALS nodes */
  674. X   
  675. X    for (a=0; a<30; a+=1)
  676. X    {
  677. X        argstr[a] = &args[a*64];
  678. X    }
  679. Xstart:
  680. X    tflag = vflag=cflag=aflag=dflag=Uflag=quietflg=lcflag=zflag = 0;
  681. X    argc = ccommand(&argv);
  682. X    SetPt(&p, 40,40);
  683. X
  684. X    SFGetFile(p, "\pSpecify ZIP file:", 0L, -1, sfT, 0L, &fileRep);
  685. X    if (!fileRep.good)
  686. X        exit(1);
  687. X    macfstest(fileRep.vRefNum, true);
  688. X    SetMacVol(NULL, fileRep.vRefNum);
  689. X    for (a=1; a<argc; a+=1)
  690. X    {
  691. X        if (argv[a][0] == '-')
  692. X        {
  693. X            BlockMove(argv[a], argstr[a], (strlen(argv[a])>63) ? 64 : strlen(argv[a])+1);
  694. X        }
  695. X        else
  696. X            break;
  697. X    }
  698. X    PtoCstr((char *)fileRep.fName);
  699. X    strcpy(argstr[a], fileRep.fName);
  700. X    for (;a<argc; a+=1)
  701. X    {
  702. X        BlockMove(argv[a], argstr[a+1], (strlen(argv[a])>63) ? 64 : strlen(argv[a])+1);
  703. X    }
  704. X    argc+=1;
  705. X    argv = argstr;
  706. X
  707. X#endif /* THINK_C */
  708. X#endif /* MACOS */
  709. X
  710. X/*---------------------------------------------------------------------------
  711. X    Debugging info for checking on structure padding:
  712. X  ---------------------------------------------------------------------------*/
  713. X
  714. X#ifdef DEBUG_STRUC
  715. X    printf("local_file_header size: %X\n",
  716. X           sizeof(struct local_file_header));
  717. X    printf("local_byte_header size: %X\n",
  718. X           sizeof(struct local_byte_header));
  719. X    printf("actual size of local headers: %X\n", LREC_SIZE);
  720. X
  721. X    printf("central directory header size: %X\n",
  722. X           sizeof(struct central_directory_file_header));
  723. X    printf("central directory byte header size: %X\n",
  724. X           sizeof(struct central_directory_byte_header));
  725. X    printf("actual size of central dir headers: %X\n", CREC_SIZE);
  726. X
  727. X    printf("end central dir record size: %X\n",
  728. X           sizeof(struct end_central_dir_record));
  729. X    printf("end central dir byte record size: %X\n",
  730. X           sizeof(struct end_central_byte_record));
  731. X    printf("actual size of end-central-dir record: %X\n", ECREC_SIZE);
  732. X#endif
  733. X
  734. X#ifndef KNOW_IT_WORKS  /* define this to save space, if things already work */
  735. X#ifndef DOS_OS2        /* already works (no RISCy OS/2's yet...) */
  736. X#ifndef NOTINT16       /* whole point is to see if this NEEDS defining */
  737. X    {
  738. X        int error=0;
  739. X        long testsig;
  740. X        static char *mach_type[3] = {"big-endian",
  741. X          "structure-padding", "big-endian and structure-padding"};
  742. X        strcpy((char *)&testsig,"012");
  743. X        if (testsig != 0x00323130)
  744. X            error = 1;
  745. X        if (sizeof(central_directory_file_header) != CREC_SIZE)
  746. X            error += 2;
  747. X        if (error--)
  748. X            fprintf(stderr, "It appears that your machine is %s.  If errors\n\
  749. Xoccur, please try recompiling with \"NOTINT16\" defined (read the\n\
  750. XMakefile, or try \"make hp\").\n\n", mach_type[error]);
  751. X    }
  752. X#endif /* !NOTINT16 */
  753. X#endif /* !DOS_OS2 */
  754. X#endif /* !KNOW_IT_WORKS */
  755. X
  756. X/*---------------------------------------------------------------------------
  757. X    Rip through any command-line options lurking about...
  758. X  ---------------------------------------------------------------------------*/
  759. X
  760. X    while (--argc > 0 && (*++argv)[0] == '-') {
  761. X        s = argv[0] + 1;
  762. X        while ((c = *s++) != 0) {    /* "!= 0":  prevent Turbo C warning */
  763. X            switch (c) {
  764. X            case ('x'): /* just ignore -x, -e options (extract) */
  765. X            case ('e'):
  766. X                break;
  767. X            case ('q'):
  768. X                ++quietflg;
  769. X                break;
  770. X            case ('t'):
  771. X                ++tflag;
  772. X                break;
  773. X            case ('v'):
  774. X                ++vflag;
  775. X                /* fall thru */
  776. X            case ('l'):
  777. X                ++vflag;
  778. X                break;
  779. X            case ('p'):
  780. X                ++cflag;
  781. X#ifdef NATIVE
  782. X                ++aflag;
  783. X#endif
  784. X                quietflg += 2;
  785. X                break;
  786. X            case ('c'):
  787. X                ++cflag;
  788. X#ifdef NATIVE
  789. X                ++aflag;        /* this is so you can read it on the screen */
  790. X#endif
  791. X                break;
  792. X            case ('a'):
  793. X                ++aflag;
  794. X                break;
  795. X#ifdef VMS
  796. X            case ('u'): /* switches converted to l.c. unless quoted */
  797. X#endif
  798. X            case ('U'): /* "uppercase flag" (i.e., don't convert) */
  799. X                ++Uflag;
  800. X                break;
  801. X            case ('V'): /* Version flag:  retain VMS/DEC-20 file versions */
  802. X                ++V_flag;
  803. X                break;
  804. X            case ('d'): /* create parent dirs flag */
  805. X#ifdef MACOS
  806. X                if (hfsflag == true)
  807. X#endif
  808. X                ++dflag;
  809. X                break;
  810. X            case ('o'): /* OK to overwrite files without prompting */
  811. X                ++do_all;
  812. X                break;
  813. X            case ('z'): /* Display only the archive commentp */
  814. X                ++zflag;
  815. X                break;
  816. X            default:
  817. X                if (print_usage) {
  818. X                    usage();
  819. X                    print_usage = FALSE;
  820. X                }
  821. X                break;
  822. X            }
  823. X        }
  824. X    }
  825. X
  826. X/*---------------------------------------------------------------------------
  827. X    Make sure we aren't trying to do too many things here.  [This seems like
  828. X    kind of a brute-force way to do things; but aside from that, isn't the
  829. X    -a option useful when listing the directory (i.e., for reading zipfile
  830. X    comments)?  It's a modifier, not an action in and of itself, so perhaps
  831. X    it should not be included in the test--certainly, in the case of zipfile
  832. X    testing, it can just be ignored.]
  833. X  ---------------------------------------------------------------------------*/
  834. X
  835. X    if ((tflag && vflag) || (tflag && cflag) || (vflag && cflag) ||
  836. X        (tflag && aflag) || (aflag && vflag)) {
  837. X        fprintf(stderr, "only one of -t, -c, -a, or -v\n");
  838. X        RETURN(10);             /* 10:  bad or illegal parameters specified */
  839. X    }
  840. X    if (quietflg && zflag)
  841. X        quietflg = 0;
  842. X    if (argc-- == 0) {
  843. X        if (print_usage)
  844. X            usage();
  845. X        RETURN(10);             /* 10:  bad or illegal parameters specified */
  846. X    }
  847. X/*---------------------------------------------------------------------------
  848. X    Now get the zipfile name from the command line and see if it exists as a
  849. X    regular (non-directory) file.  If not, append the ".zip" suffix.  We don't
  850. X    immediately check to see if this results in a good name, but we will do so
  851. X    later.  In the meantime, see if there are any member filespecs on the com-
  852. X    mand line, and if so, set the filename pointer to point at them.
  853. X  ---------------------------------------------------------------------------*/
  854. X
  855. X    strcpy(zipfn, *argv++);
  856. X    if (stat(zipfn, &statbuf) || (statbuf.st_mode & S_IFMT) == S_IFDIR)
  857. X        strcat(zipfn, ZSUFX);
  858. X
  859. X    if (stat(zipfn, &statbuf)) {/* try again */
  860. X        fprintf(stderr, "error:  can't find zipfile [ %s ]\n", zipfn);
  861. X        RETURN(9);              /* 9:  file not found */
  862. X    } else
  863. X        ziplen = statbuf.st_size;
  864. X
  865. X    if (argc != 0) {
  866. X        fnv = argv;
  867. X        process_all_files = FALSE;
  868. X    } else
  869. X        process_all_files = TRUE;       /* for speed */
  870. X
  871. X/*---------------------------------------------------------------------------
  872. X    Okey dokey, we have everything we need to get started.  Let's roll.
  873. X  ---------------------------------------------------------------------------*/
  874. X
  875. X    inbuf = (byte *) (malloc(INBUFSIZ + 4));    /* 4 extra for hold[] (below) */
  876. X    outbuf = (byte *) (malloc(OUTBUFSIZ + 1));  /* 1 extra for string termin. */
  877. X    if (aflag)                  /* if need an ascebc scratch, */
  878. X        outout = (byte *) (malloc(OUTBUFSIZ));
  879. X    else                        /*  allocate it... */
  880. X        outout = outbuf;        /*  else just point to outbuf */
  881. X
  882. X    if ((inbuf == NULL) || (outbuf == NULL) || (outout == NULL)) {
  883. X        fprintf(stderr, "error:  can't allocate unzip buffers\n");
  884. X        RETURN(4);              /* 4-8:  insufficient memory */
  885. X    }
  886. X    hold = &inbuf[INBUFSIZ];    /* to check for boundary-spanning signatures */
  887. X
  888. X#ifdef THINK_C
  889. X    if (!process_zipfile())
  890. X        goto start;
  891. X#else
  892. X    RETURN(process_zipfile());  /* keep passing errors back... */
  893. X#endif
  894. X
  895. X}       /* end main() */
  896. X
  897. X
  898. X
  899. X
  900. X
  901. X/*********************/
  902. X/*  Function usage() */
  903. X/*********************/
  904. X
  905. Xvoid usage()
  906. X{
  907. X#ifdef NATIVE
  908. X    char *astring = "-a     convert ASCII to native character set";
  909. X#else
  910. X#ifdef MACOS
  911. X    char *astring = "-a     convert to Mac textfile format (CR LF => CR)";
  912. X#else
  913. X#ifdef DOS_OS2
  914. X    char *astring = "-a     convert to DOS & OS/2 textfile format (LF => CR LF)";
  915. X#else
  916. X    char *astring = "-a     convert to Unix/VMS textfile format (CR LF => LF)";
  917. X#endif /* ?DOS_OS2 */
  918. X#endif /* ?MACOS */
  919. X#endif /* ?NATIVE */
  920. X
  921. X
  922. X    fprintf(stderr, "UnZip:  Zipfile Extract %s;  (C) 1989 Samuel H. Smith\n",
  923. X                 VERSION);
  924. X    fprintf(stderr, "Courtesy of:  S.H.Smith  and  The Tool Shop BBS,  \
  925. X(602) 279-2673.\n\n");
  926. X    fprintf(stderr, "Versions 3.0 and later brought to you by the fine folks \
  927. Xat Info-ZIP\n");
  928. X    fprintf(stderr, "(Info-ZIP@WSMR-Simtel20.Army.Mil)\n\n");
  929. X    fprintf(stderr, "Usage:  unzip [ -xecptlvz[qadoUV] ] file[.zip] [filespec...]\n\
  930. X  -x,-e  extract files in archive (default--i.e., this flag is optional)\n\
  931. X  -c     extract files to stdout (\"CRT\")\n\
  932. X  -p     extract files to stdout and no informational messages (for pipes)\n\
  933. X  -t     test files\n\
  934. X  -l     list files (short format)\n\
  935. X  -v     verbose listing of files\n");
  936. X    fprintf(stderr, "\
  937. X  -z     display only the archive comment\n\
  938. X  -q     perform operations quietly (up to two q's allowed)\n\
  939. X  %s\n\
  940. X  -d     include directory structure when extracting/listing\n\
  941. X  -o     OK to overwrite files without prompting\n\
  942. X  -U     don't map filenames to lowercase for selected (uppercase) OS's\n\
  943. X  -V     retain file version numbers\n", astring);
  944. X
  945. X#ifdef VMS
  946. X    fprintf(stderr, "Remember that non-lowercase filespecs must be quoted in \
  947. XVMS (e.g., \"Makefile\").\n");
  948. X#endif
  949. X
  950. X}       /* end function usage() */
  951. X
  952. X
  953. X
  954. X
  955. X
  956. X/*******************************/
  957. X/*  Function process_zipfile() */
  958. X/*******************************/
  959. X
  960. Xint process_zipfile()
  961. X/* return PK-type error code */
  962. X{
  963. X    int error=0, error_in_archive;
  964. X
  965. X
  966. X
  967. X/*---------------------------------------------------------------------------
  968. X    Open the zipfile for reading and in BINARY mode to prevent CR/LF trans-
  969. X    lation, which would corrupt the bitstreams.  Then find and process the
  970. X    central directory; list, extract or test member files as instructed; and
  971. X    close the zipfile.
  972. X  ---------------------------------------------------------------------------*/
  973. X
  974. X#ifdef VMS
  975. X    change_zipfile_attributes(0);
  976. X#endif
  977. X    if (open_input_file())      /* this should never happen, given the */
  978. X        return (9);             /*   stat() test in main(), but... */
  979. X
  980. X    if (find_end_central_dir()) /* not found; nothing to do */
  981. X        return (2);             /* 2:  error in zipfile */
  982. X
  983. X#ifdef TEST
  984. X    printf("\n  found end-of-central-dir signature at offset %ld (%.8lXh)\n",
  985. X      cur_zipfile_bufstart+(inptr-inbuf), cur_zipfile_bufstart+(inptr-inbuf) );
  986. X    printf("    from beginning of file; offset %d (%.4Xh) within block\n",
  987. X      inptr-inbuf, inptr-inbuf);
  988. X#endif
  989. X
  990. X    if ((error_in_archive = process_end_central_dir()) > 1)
  991. X        return (error_in_archive);
  992. X
  993. X    if (zflag)
  994. X        return (0);
  995. X
  996. X#ifndef PAKFIX
  997. X    if (ecrec.number_this_disk == 0) {
  998. X#else /* PAKFIX */
  999. X    if (ecrec.number_this_disk == 0  ||  (error = (ecrec.number_this_disk == 1
  1000. X        && ecrec.num_disk_with_start_central_dir == 1))) {
  1001. X
  1002. X        if (error) {
  1003. X            fprintf(stderr,
  1004. X     "\n     Warning:  zipfile claims to be disk 2 of a two-part archive;\n\
  1005. X     attempting to process anyway.  If no further errors occur, this\n\
  1006. X     archive was probably created by PAK v2.5 or earlier.  This bug\n\
  1007. X     has been reported to NoGate and should be fixed by mid-April 1991.\n\n");
  1008. X            error_in_archive = 1;  /* 1:  warning */
  1009. X        }
  1010. X#endif /* ?PAKFIX */
  1011. X        if (vflag)
  1012. X            error = list_files();       /* LIST 'EM */
  1013. X        else
  1014. X            error = extract_or_test_files();    /* EXTRACT OR TEST 'EM */
  1015. X        if (error > error_in_archive)   /* don't overwrite stronger error */
  1016. X            error_in_archive = error;   /*  with (for example) a warning */
  1017. X    } else {
  1018. X        fprintf(stderr, "\nerror:  zipfile is part of multi-disk archive \
  1019. X(sorry, no can do).\n");
  1020. X        fprintf(stderr, ReportMsg);   /* report to info-zip */
  1021. X        error_in_archive = 11;  /* 11:  no files found */
  1022. X    }
  1023. X
  1024. X    close(zipfd);
  1025. X#ifdef VMS
  1026. X    change_zipfile_attributes(1);
  1027. X#endif
  1028. X    return (error_in_archive);
  1029. X
  1030. X}       /* end function process_zipfile() */
  1031. X
  1032. X
  1033. X
  1034. X
  1035. X
  1036. X/************************************/
  1037. X/*  Function find_end_central_dir() */
  1038. X/************************************/
  1039. X
  1040. Xint find_end_central_dir()
  1041. X/* return 0 if found, 1 otherwise */
  1042. X{
  1043. X    int i, numblks;
  1044. X    longint tail_len;
  1045. X
  1046. X
  1047. X
  1048. X/*---------------------------------------------------------------------------
  1049. X    Treat case of short zipfile separately.
  1050. X  ---------------------------------------------------------------------------*/
  1051. X
  1052. X    if (ziplen <= INBUFSIZ) {
  1053. X        lseek(zipfd, 0L, SEEK_SET);
  1054. X        if ((incnt = read(zipfd,inbuf,(unsigned int)ziplen)) == ziplen)
  1055. X
  1056. X            /* 'P' must be at least 22 bytes from end of zipfile */
  1057. X            for ( inptr = inbuf+ziplen-22  ;  inptr >= inbuf  ;  --inptr )
  1058. X                if ( (ascii_to_native(*inptr) == 'P')  &&
  1059. X                      !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  1060. X                    incnt -= inptr - inbuf;
  1061. X                    return(0);  /* found it! */
  1062. X                }               /* ...otherwise fall through & fail */
  1063. X
  1064. X/*---------------------------------------------------------------------------
  1065. X    Zipfile is longer than INBUFSIZ:  may need to loop.  Start with short
  1066. X    block at end of zipfile (if not TOO short).
  1067. X  ---------------------------------------------------------------------------*/
  1068. X
  1069. X    } else {
  1070. X        if ((tail_len = ziplen % INBUFSIZ) > ECREC_SIZE) {
  1071. X            cur_zipfile_bufstart = lseek(zipfd, ziplen-tail_len, SEEK_SET);
  1072. X            if ((incnt = read(zipfd,inbuf,(unsigned int)tail_len)) != tail_len)
  1073. X                goto fail;      /* shut up, it's expedient. */
  1074. X
  1075. X            /* 'P' must be at least 22 bytes from end of zipfile */
  1076. X            for ( inptr = inbuf+tail_len-22  ;  inptr >= inbuf  ;  --inptr )
  1077. X                if ( (ascii_to_native(*inptr) == 'P')  &&
  1078. X                      !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  1079. X                    incnt -= inptr - inbuf;
  1080. X                    return(0);  /* found it! */
  1081. X                }               /* ...otherwise search next block */
  1082. X            strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
  1083. X                                                           boundary */
  1084. X
  1085. X        } else {
  1086. X            cur_zipfile_bufstart = ziplen - tail_len;
  1087. X        }
  1088. X
  1089. X        /*
  1090. X         * Loop through blocks of zipfile data, starting at the end and going
  1091. X         * toward the beginning.  Need only check last 65557 bytes of zipfile:
  1092. X         * comment may be up to 65535 bytes long, end-of-central-directory rec-
  1093. X         * ord is 18 bytes (shouldn't hardcode this number, but what the hell:
  1094. X         * already did so above (22=18+4)), and sig itself is 4 bytes.
  1095. X         */
  1096. X
  1097. X        /*          ==amt to search==   ==done==   ==rounding==     =blksiz= */
  1098. X        numblks = ( min(ziplen,65557) - tail_len + (INBUFSIZ-1) ) / INBUFSIZ;
  1099. X
  1100. X        for ( i = 1  ;  i <= numblks  ;  ++i ) {
  1101. X            cur_zipfile_bufstart -= INBUFSIZ;
  1102. X            lseek(zipfd, cur_zipfile_bufstart, SEEK_SET);
  1103. X            if ((incnt = read(zipfd,inbuf,INBUFSIZ)) != INBUFSIZ)
  1104. X                break;          /* fall through and fail */
  1105. X
  1106. X            for ( inptr = inbuf+INBUFSIZ-1  ;  inptr >= inbuf  ;  --inptr )
  1107. X                if ( (ascii_to_native(*inptr) == 'P')  &&
  1108. X                      !strncmp((char *)inptr, END_CENTRAL_SIG, 4) ) {
  1109. X                    incnt -= inptr - inbuf;
  1110. X                    return(0);  /* found it! */
  1111. X                }
  1112. X            strncpy((char *)hold, (char *)inbuf, 3);    /* sig may span block
  1113. X                                                           boundary */
  1114. X        }
  1115. X
  1116. X    } /* end if (ziplen > INBUFSIZ) */
  1117. X
  1118. X/*---------------------------------------------------------------------------
  1119. X    Searched through whole region where signature should be without finding
  1120. X    it.  Print informational message and die a horrible death.
  1121. X  ---------------------------------------------------------------------------*/
  1122. X
  1123. Xfail:
  1124. X
  1125. X    fprintf(stderr, "\nFile:  %s\n\n\
  1126. X     End-of-central-directory signature not found.  Either this file is not\n\
  1127. X     a zipfile, or it constitutes one disk of a multi-part archive.  In the\n\
  1128. X     latter case the central directory and zipfile comment will be found on\n\
  1129. X     the last disk(s) of this archive.\n", zipfn);
  1130. X    return(1);
  1131. X
  1132. X}       /* end function find_end_central_dir() */
  1133. X
  1134. X
  1135. X
  1136. X
  1137. X
  1138. X/***************************************/
  1139. X/*  Function process_end_central_dir() */
  1140. X/***************************************/
  1141. X
  1142. Xint process_end_central_dir()
  1143. X/* return PK-type error code */
  1144. X{
  1145. X#ifdef NOTINT16
  1146. X    end_central_byte_record byterec;
  1147. X#endif
  1148. X    int error=0;
  1149. X
  1150. X
  1151. X
  1152. X/*---------------------------------------------------------------------------
  1153. X    Read the end-of-central-directory record and do any necessary machine-
  1154. X    type conversions (byte ordering, structure padding compensation).
  1155. X  ---------------------------------------------------------------------------*/
  1156. X
  1157. X#ifndef NOTINT16
  1158. X    if (readbuf((char *) &ecrec, ECREC_SIZE+4) <= 0)
  1159. X        return (51);            /* 51:  unexpected EOF */
  1160. X
  1161. X#else  /* NOTINT16:  read data into character array, then copy to struct */
  1162. X    if (readbuf((char *) byterec, ECREC_SIZE+4) <= 0)
  1163. X        return (51);
  1164. X
  1165. X    ecrec.number_this_disk =
  1166. X        makeword(&byterec[NUMBER_THIS_DISK]);
  1167. X    ecrec.num_disk_with_start_central_dir =
  1168. X        makeword(&byterec[NUM_DISK_WITH_START_CENTRAL_DIR]);
  1169. X    ecrec.num_entries_centrl_dir_ths_disk =
  1170. X        makeword(&byterec[NUM_ENTRIES_CENTRL_DIR_THS_DISK]);
  1171. X    ecrec.total_entries_central_dir =
  1172. X        makeword(&byterec[TOTAL_ENTRIES_CENTRAL_DIR]);
  1173. X    ecrec.size_central_directory =
  1174. X        makelong(&byterec[SIZE_CENTRAL_DIRECTORY]);
  1175. X    ecrec.offset_start_central_directory =
  1176. X        makelong(&byterec[OFFSET_START_CENTRAL_DIRECTORY]);
  1177. X    ecrec.zipfile_comment_length =
  1178. X        makeword(&byterec[ZIPFILE_COMMENT_LENGTH]);
  1179. X#endif  /* NOTINT16 */
  1180. X
  1181. X/*---------------------------------------------------------------------------
  1182. X    Get the zipfile comment, if any, and print it out.  (Comment may be up
  1183. X    to 64KB long.  May the fleas of a thousand camels infest the armpits of
  1184. X    anyone who actually takes advantage of this fact.)  Then position the
  1185. X    file pointer to the beginning of the central directory and fill buffer.
  1186. X  ---------------------------------------------------------------------------*/
  1187. X
  1188. X    if (ecrec.zipfile_comment_length && !quietflg) {
  1189. X        if (!zflag)
  1190. X          printf("[%s] comment:  ", zipfn);
  1191. X        if (do_string(ecrec.zipfile_comment_length,DISPLAY)) {
  1192. X            fprintf(stderr, "\nwarning:  zipfile comment truncated\n");
  1193. X            error = 1;          /* 1:  warning error */
  1194. X        }
  1195. X        if (!zflag)
  1196. X          printf("\n\n");
  1197. X    }
  1198. X    LSEEK( ULONG_(ecrec.offset_start_central_directory) )
  1199. X
  1200. X    return (error);
  1201. X
  1202. X}       /* end function process_end_central_dir() */
  1203. X
  1204. X
  1205. X
  1206. X
  1207. X
  1208. X/**************************/
  1209. X/*  Function list_files() */
  1210. X/**************************/
  1211. X
  1212. Xint list_files()
  1213. X/* return PK-type error code */
  1214. X{
  1215. X    char **fnamev;
  1216. X    int do_this_file = FALSE, ratio, error, error_in_archive = 0;
  1217. X    int which_hdr = (vflag > 1);
  1218. X    UWORD j, yr, mo, dy, hh, mm, members = 0;
  1219. X    ULONG tot_csize = 0L, tot_ucsize = 0L;
  1220. X    static char *method[NUM_METHODS + 1] =
  1221. X    {"Stored", "Shrunk", "Reduce1", "Reduce2",
  1222. X     "Reduce3", "Reduce4", "Implode", "Unknown"};
  1223. X    static char *Headers[][2] =
  1224. X    {
  1225. X        {" Length    Date    Time    Name",
  1226. X         " ------    ----    ----    ----"},
  1227. X        {" Length  Method   Size  Ratio   Date    Time   CRC-32     Name",
  1228. X         " ------  ------   ----  -----   ----    ----   ------     ----"}};
  1229. X
  1230. X
  1231. X
  1232. X/*---------------------------------------------------------------------------
  1233. X    Unlike extract_or_test_files(), this routine confines itself to the cen-
  1234. X    tral directory.  Thus its structure is somewhat simpler, since we can do
  1235. X    just a single loop through the entire directory, listing files as we go.
  1236. X
  1237. X    So to start off, print the heading line and then begin main loop through
  1238. X    the central directory.  The results will look vaguely like the following:
  1239. X
  1240. X  Length  Method   Size  Ratio   Date    Time   CRC-32     Name ("^" ==> case
  1241. X  ------  ------   ----  -----   ----    ----   ------     ----   conversion)
  1242. X   44004  Implode  13041  71%  11-02-89  19:34  8b4207f7   Makefile.UNIX
  1243. X    3438  Shrunk    2209  36%  09-15-90  14:07  a2394fd8  ^dos-file.ext
  1244. X  ---------------------------------------------------------------------------*/
  1245. X
  1246. X    if (quietflg < 2)
  1247. X        if (Uflag)
  1248. X            printf("%s\n%s\n", Headers[which_hdr][0], Headers[which_hdr][1]);
  1249. X        else
  1250. X            printf("%s (\"^\" ==> case\n%s   conversion)\n", 
  1251. X              Headers[which_hdr][0], Headers[which_hdr][1]);
  1252. X
  1253. X    for (j = 0; j < ecrec.total_entries_central_dir; ++j) {
  1254. X
  1255. X        if (readbuf(sig, 4) <= 0)
  1256. X            return (51);        /* 51:  unexpected EOF */
  1257. X        if (strncmp(sig, CENTRAL_HDR_SIG, 4)) {  /* just to make sure */
  1258. X            fprintf(stderr, CentSigMsg, j);  /* sig not found */
  1259. X            fprintf(stderr, ReportMsg);   /* report to info-zip */
  1260. X            return (3);         /* 3:  error in zipfile */
  1261. X        }
  1262. X        if ((error = process_central_file_header()) != 0)  /* (sets lcflag) */
  1263. X            return (error);     /* only 51 (EOF) defined */
  1264. X
  1265. X        /*
  1266. X         * We could DISPLAY the filename instead of storing (and possibly trun-
  1267. X         * cating, in the case of a very long name) and printing it, but that
  1268. X         * has the disadvantage of not allowing case conversion--and it's nice
  1269. X         * to be able to see in the listing precisely how you have to type each
  1270. X         * filename in order for unzip to consider it a match.  Speaking of
  1271. X         * which, if member names were specified on the command line, check in
  1272. X         * with match() to see if the current file is one of them, and make a
  1273. X         * note of it if it is.
  1274. X         */
  1275. X
  1276. X        if ((error = do_string(crec.filename_length, FILENAME)) != 0) {
  1277. X            error_in_archive = error;  /* (uses lcflag)---^   */
  1278. X            if (error > 1)      /* fatal:  can't continue */
  1279. X                return (error);
  1280. X        }
  1281. X        if ((error = do_string(crec.extra_field_length, SKIP)) != 0) {
  1282. X            error_in_archive = error;   /* might be just warning */
  1283. X            if (error > 1)      /* fatal */
  1284. X                return (error);
  1285. X        }
  1286. X        if (!process_all_files) {   /* check if specified on command line */
  1287. X            do_this_file = FALSE;
  1288. X            fnamev = fnv;       /* don't destroy permanent filename ptr */
  1289. X            for (--fnamev; *++fnamev;)
  1290. X                if (match(filename, *fnamev)) {
  1291. X                    do_this_file = TRUE;
  1292. X                    break;      /* found match, so stop looping */
  1293. X                }
  1294. X        }
  1295. X        /*
  1296. X         * If current file was specified on command line, or if no names were
  1297. X         * specified, do the listing for this file.  Otherwise, get rid of the
  1298. X         * file comment and go back for the next file.
  1299. X         */
  1300. X
  1301. X        if (process_all_files || do_this_file) {
  1302. X
  1303. X            yr = (((crec.last_mod_file_date >> 9) & 0x7f) + 80) % 100;
  1304. X            mo = (crec.last_mod_file_date >> 5) & 0x0f;
  1305. X            dy = crec.last_mod_file_date & 0x1f;
  1306. X            hh = (crec.last_mod_file_time >> 11) & 0x1f;
  1307. X            mm = (crec.last_mod_file_time >> 5) & 0x3f;
  1308. X
  1309. X            csize = (longint) ULONG_(crec.compressed_size);
  1310. X            ucsize = (longint) ULONG_(crec.uncompressed_size);
  1311. X            if (crec.general_purpose_bit_flag & 1)
  1312. X                csize -= 12;    /* if encrypted, don't count encrypt hdr */
  1313. X
  1314. X            ratio = (ucsize == 0) ? 0 :   /* .zip can have 0-length members */
  1315. X                ((ucsize > 2000000) ?     /* risk signed overflow if mult. */
  1316. X                (int) ((ucsize-csize) / (ucsize/1000L)) + 5 :   /* big */
  1317. X                (int) ((1000L*(ucsize-csize)) / ucsize) + 5);   /* small */
  1318. X
  1319. X            switch (which_hdr) {
  1320. X            case 0:             /* short form */
  1321. X                printf("%7ld  %02u-%02u-%02u  %02u:%02u  %c%s\n",
  1322. X                       ucsize, mo, dy, yr, hh, mm, (lcflag?'^':' '), filename);
  1323. X                break;
  1324. X            case 1:             /* verbose */
  1325. X                printf(
  1326. X                  "%7ld  %-7s%7ld %3d%%  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s\n",
  1327. X                  ucsize, method[methnum], csize, ratio/10, mo, dy, yr, hh, mm,
  1328. X                  ULONG_(crec.crc32), (lcflag?'^':' '), filename);
  1329. X            }
  1330. X
  1331. X            error = do_string(crec.file_comment_length, (QCOND2 ? DISPLAY : SKIP));
  1332. X            if (error) {
  1333. X                error_in_archive = error;  /* might be just warning */
  1334. X                if (error > 1)  /* fatal */
  1335. X                    return (error);
  1336. X            }
  1337. X            tot_ucsize += (ULONG) ucsize;
  1338. X            tot_csize += (ULONG) csize;
  1339. X            ++members;
  1340. X
  1341. X        } else {        /* not listing this file */
  1342. X            if ((error = do_string(crec.file_comment_length, SKIP)) != 0) {
  1343. X              error_in_archive = error;   /* might be warning */
  1344. X              if (error > 1)      /* fatal */
  1345. X                  return (error);
  1346. X            }
  1347. X        }
  1348. X    }                   /* end for-loop (j: files in central directory) */
  1349. X
  1350. X/*---------------------------------------------------------------------------
  1351. X    Print footer line and totals (compressed size, uncompressed size, number
  1352. X    of members in zipfile).
  1353. X  ---------------------------------------------------------------------------*/
  1354. X
  1355. X    ratio = (tot_ucsize == 0) ? 
  1356. X        0 : ((tot_ucsize > 4000000) ?    /* risk unsigned overflow if mult. */
  1357. X        (int) ((tot_ucsize - tot_csize) / (tot_ucsize/1000L)) + 5 :
  1358. X        (int) ((tot_ucsize - tot_csize) * 1000L / tot_ucsize) + 5);
  1359. X
  1360. X    if (quietflg < 2) {
  1361. X        switch (which_hdr) {
  1362. X        case 0:         /* short */
  1363. X            printf("%s\n%7lu                    %-7u\n",
  1364. X                   " ------                    -------",
  1365. X                   tot_ucsize, members);
  1366. X            break;
  1367. X        case 1:         /* verbose */
  1368. X            printf(
  1369. X              "%s\n%7lu         %7lu %3d%%                              %-7u\n",
  1370. X              " ------          ------  ---                              -------",
  1371. X              tot_ucsize, tot_csize, ratio / 10, members);
  1372. X        }
  1373. X    }
  1374. X/*---------------------------------------------------------------------------
  1375. X    Double check that we're back at the end-of-central-directory record.
  1376. X  ---------------------------------------------------------------------------*/
  1377. X
  1378. X    readbuf(sig, 4);
  1379. X    if (strncmp(sig, END_CENTRAL_SIG, 4)) {     /* just to make sure again */
  1380. X        fprintf(stderr, EndSigMsg);  /* didn't find end-of-central-dir sig */
  1381. X        fprintf(stderr, ReportMsg);  /* report to info-zip */
  1382. X        error_in_archive = 1;        /* 1:  warning error */
  1383. X    }
  1384. X    return (error_in_archive);
  1385. X
  1386. X}       /* end function list_files() */
  1387. X
  1388. X
  1389. X
  1390. X
  1391. X
  1392. X/*************************************/
  1393. X/*  Function extract_or_test_files() */
  1394. X/*************************************/
  1395. X
  1396. Xint extract_or_test_files()
  1397. X/* return PK-type error code */
  1398. X{
  1399. X    char **fnamev;
  1400. X    byte *cd_inptr;
  1401. X    int cd_incnt, error, error_in_archive = 0;
  1402. X    UWORD i, j, members_remaining;
  1403. X    longint cd_bufstart, bufstart, inbuf_offset;
  1404. X    struct min_info {
  1405. X        unsigned f_attr;
  1406. X        longint offset;
  1407. X        int lcflag;
  1408. X    } info[DIR_BLKSIZ];
  1409. X
  1410. X
  1411. X
  1412. X/*---------------------------------------------------------------------------
  1413. X    The basic idea of this function is as follows.  Since the central di-
  1414. X    rectory lies at the end of the zipfile and the member files lie at the
  1415. X    beginning or middle or wherever, it is not very desirable to simply
  1416. X    read a central directory entry, jump to the member and extract it, and
  1417. X    then jump back to the central directory.  In the case of a large zipfile
  1418. X    this would lead to a whole lot of disk-grinding, especially if each mem-
  1419. X    ber file is small.  Instead, we read from the central directory the per-
  1420. X    tinent information for a block of files, then go extract/test the whole
  1421. X    block.  Thus this routine contains two small(er) loops within a very
  1422. X    large outer loop:  the first of the small ones reads a block of files
  1423. X    from the central directory; the second extracts or tests each file; and
  1424. X    the outer one loops over blocks.  There's some file-pointer positioning
  1425. X    stuff in between, but that's about it.  Btw, it's because of this jump-
  1426. X    ing around that we can afford to be lenient if an error occurs in one of
  1427. X    the member files:  we should still be able to go find the other members,
  1428. X    since we know the offset of each from the beginning of the zipfile.
  1429. X
  1430. X    Begin main loop over blocks of member files.  We know the entire central
  1431. X    directory is on this disk:  we would not have any of this information un-
  1432. END_OF_FILE
  1433.   if test 38155 -ne `wc -c <'./v41/unzip.c.1'`; then
  1434.     echo shar: \"'./v41/unzip.c.1'\" unpacked with wrong size!
  1435.   fi
  1436.   # end of './v41/unzip.c.1'
  1437. fi
  1438. echo shar: End of archive 1 \(of 6\).
  1439. cp /dev/null ark1isdone
  1440. MISSING=""
  1441. for I in 1 2 3 4 5 6 ; do
  1442.     if test ! -f ark${I}isdone ; then
  1443.     MISSING="${MISSING} ${I}"
  1444.     fi
  1445. done
  1446. if test "${MISSING}" = "" ; then
  1447.     echo You have unpacked all 6 archives.
  1448.     rm -f ark[1-9]isdone
  1449. else
  1450.     echo You still must unpack the following archives:
  1451.     echo "        " ${MISSING}
  1452. fi
  1453. exit 0
  1454. exit 0 # Just in case...
  1455. -- 
  1456. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1457. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1458. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1459. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1460.