home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / zip19 / part07 < prev    next >
Encoding:
Text File  |  1992-08-22  |  60.6 KB  |  1,900 lines
  1. Newsgroups: comp.sources.misc
  2. From: zip-bugs@cs.ucla.edu (Info-ZIP group)
  3. Subject:  v31i099:  zip19 - Info-ZIP portable Zip, version 1.9, Part07/11
  4. Message-ID: <1992Aug23.064739.29343@sparky.imd.sterling.com>
  5. X-Md4-Signature: 78834c85a8bc38b5c3e178b5fc3ec576
  6. Date: Sun, 23 Aug 1992 06:47:39 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: zip-bugs@cs.ucla.edu (Info-ZIP group)
  10. Posting-number: Volume 31, Issue 99
  11. Archive-name: zip19/part07
  12. Supersedes: zip: Volume 23, Issue 88-96
  13. Environment: UNIX, VMS, OS/2, MS-DOS, MACINTOSH, WIN-NT, LINUX, MINIX, XOS, !AMIGA, ATARI, symlink, SGI, DEC, Cray, Convex, Amdahl, Sun, PC
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  msdos/makefile.gcc.UU vms/vms.c vms/vms_zip.rnh zipsplit.c
  22. # Wrapped by kent@sparky on Sun Aug 23 01:00:45 1992
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 7 (of 11)."'
  26. if test -f 'msdos/makefile.gcc.UU' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'msdos/makefile.gcc.UU'\"
  28. else
  29.   echo shar: Extracting \"'msdos/makefile.gcc.UU'\" \(2879 characters\)
  30.   sed "s/^X//" >'msdos/makefile.gcc.UU' <<'END_OF_FILE'
  31. Xbegin 666 msdos/makefile.gcc
  32. XM(R!-86ME9FEL92!F;W(@6FEP+"!::7!#;&]A:RP@6FEP3F]T92!A;F0@6FEP
  33. XM4W!L:70@9F]R#0HC(&1J9V-C(#$N,#8-"@T*0U)94%1//0T*0TQ/04L]#0I#
  34. XM4D9,04<]#0H-"B,@("HJ*B!&;W(@96YC<GEP=&EO;B!V97)S:6]N+"!R96UO
  35. XM=F4@=&AE(",@870@=&AE(&9R;VYT(&]F(&YE>'0@,R!L:6YE<R J*BH-"B-#
  36. XM4EE05$\]8W)Y<'0N;PT*(T-,3T%+/7II<&-L;V%K+F5X90T*(T-21DQ!1STM
  37. XM1$-265!4#0H-"B,@+2TM+2TM+2TM+2TM+2!D:F=C8R M+2TM+2TM+2TM+2TM
  38. XM#0I#1DQ!1U,]+5=A;&P@+4\R("U$3D]?05--("0H0U)&3$%'*0T*551)3$9,
  39. XM04=3/2U$551)3" D*$-&3$%'4RD@+6\-"D-#/6=C8PT*3$0]9V-C#0I,1$9,
  40. XM04=3/2US#0H-"B,@=F%R:6%B;&5S#0I/0DI:(#T@>FEP+F\@>FEP9FEL92YO
  41. XM('II<'5P+F\@9FEL96EO+F\@=71I;"YO(&=L;V)A;',N;R D*$-265!43RD-
  42. XM"@T*3T)*52 ]('II<&9I;&5?+F\@>FEP=7!?+F\@9FEL96EO7RYO('5T:6Q?
  43. XM+F\@9VQO8F%L<RYO#0I/0DI.(#T@>FEP;F]T92YO(" D*$]"2E4I#0I/0DI#
  44. XM(#T@>FEP8VQO86LN;R D*$]"2E4I(&-R>7!T7RYO#0I/0DI3(#T@>FEP<W!L
  45. XM:70N;R D*$]"2E4I#0H-"GII<',Z"7II<"!Z:7!N;W1E('II<'-P;&ET("0H
  46. XM0TQ/04LI#0H-"GII<"YO.@D@(" @("!Z:7 N:"!Z:7!E<G(N:"!T86EL;W(N
  47. XM:"!R979I<VEO;BYH('II<"YC#0H-"GII<&9I;&4N;SH@(" @>FEP+F@@>FEP
  48. XM97)R+F@@=&%I;&]R+F@@>FEP9FEL92YC#0H-"GII<'5P+F\Z(" @(" @>FEP
  49. XM+F@@>FEP97)R+F@@=&%I;&]R+F@@<F5V:7-I;VXN:"!Z:7!U<"YC#0H-"F9I
  50. XM;&5I;RYO.B @(" @>FEP+F@@>FEP97)R+F@@=&%I;&]R+F@@9FEL96EO+F,-
  51. XM"@T*=71I;"YO.B @(" @("!Z:7 N:"!Z:7!E<G(N:"!T86EL;W(N:"!U=&EL
  52. XM+F,-"@T*9VQO8F%L<RYO.B @("!Z:7 N:"!Z:7!E<G(N:"!T86EL;W(N:"!G
  53. XM;&]B86QS+F,-"@T*9&5F;&%T92YO.B @("!Z:7 N:"!Z:7!E<G(N:"!T86EL
  54. XM;W(N:"!D969L871E+F,-"@T*=')E97,N;SH@(" @("!Z:7 N:"!Z:7!E<G(N
  55. XM:"!T86EL;W(N:"!T<F5E<RYC#0H-"F)I=',N;SH@(" @(" @>FEP+F@@>FEP
  56. XM97)R+F@@=&%I;&]R+F@@8FET<RYC#0H-"F-R>7!T+F\Z(" @(" @>FEP+F@@
  57. XM>FEP97)R+F@@=&%I;&]R+F@@8W)Y<'0N8PT*#0IZ:7!C;&]A:RYO.B @('II
  58. XM<"YH('II<&5R<BYH('1A:6QO<BYH(')E=FES:6]N+F@@>FEP8VQO86LN8PT*
  59. XM#0IZ:7!N;W1E+F\Z(" @('II<"YH('II<&5R<BYH('1A:6QO<BYH(')E=FES
  60. XM:6]N+F@@>FEP;F]T92YC#0H-"GII<'-P;&ET+F\Z(" @>FEP<W!L:70N8R!Z
  61. XM:7 N:"!Z:7!E<G(N:"!T86EL;W(N:"!R979I<VEO;BYH#0H-"GII<&9I;&5?
  62. XM+F\Z(" @>FEP9FEL92YC('II<"YH('II<&5R<BYH('1A:6QO<BYH#0H))"A#
  63. XM0RD@+6,@)"A55$E,1DQ!1U,I("1 ('II<&9I;&4N8PT*#0IZ:7!U<%\N;SH@
  64. XM(" @('II<'5P+F,@>FEP+F@@>FEP97)R+F@@=&%I;&]R+F@-"@DD*$-#*2 M
  65. XM8R D*%5424Q&3$%'4RD@)$ @>FEP=7 N8PT*#0IF:6QE:6]?+F\Z(" @(&9I
  66. XM;&5I;RYC('II<"YH('II<&5R<BYH('1A:6QO<BYH#0H))"A#0RD@+6,@)"A5
  67. XM5$E,1DQ!1U,I("1 (&9I;&5I;RYC#0H-"G5T:6Q?+F\Z(" @('5T:6PN8R!Z
  68. XM:7 N:"!Z:7!E<G(N:"!T86EL;W(N: T*"20H0T,I("UC("0H551)3$9,04=3
  69. XM*2 D0"!F:6QE:6\N8PT*#0IC<GEP=%\N;SH@(" @(&-R>7!T+F,@>FEP+F@-
  70. XM"@DD*$-#*2 M8R D*%5424Q&3$%'4RD@)$ @8W)Y<'0N8PT*#0IZ:7 Z("0H
  71. XM3T)*6BD@)"A/0DI)*0T*"20H3$0I("0H3$1&3$%'4RD@)"A/0DI:*2 D*$]"
  72. XM2DDI("UO("1 #0H)86]U=#)E>&4@)$ -"@ED96P@)$ -"@T*>FEP8VQO86LZ
  73. XM("0H3T)*0RD-"@DD*$Q$*2 D*$Q$1DQ!1U,I("0H3T)*0RD@+6\@)$ -"@EA
  74. XM;W5T,F5X92 D0 T*"61E;" D0 T*#0IZ:7!N;W1E.B D*$]"2DXI#0H))"A,
  75. XM1"D@)"A,1$9,04=3*2 D*$]"2DXI("UO("1 #0H)86]U=#)E>&4@)$ -"@ED
  76. XM96P@)$ -"@T*>FEP<W!L:70Z("0H3T)*4RD-"@DD*$Q$*2 D*$Q$1D%'4RD@
  77. XF)"A/0DI3*2 M;R D0 T*"6%O=70R97AE("1 #0H)9&5L("1 #0I$
  78. X 
  79. Xend
  80. END_OF_FILE
  81.   if test 2879 -ne `wc -c <'msdos/makefile.gcc.UU'`; then
  82.     echo shar: \"'msdos/makefile.gcc.UU'\" unpacked with wrong size!
  83.   else
  84.     echo shar: Uudecoding \"'msdos/makefile.gcc'\" \(2063 characters\)
  85.     cat msdos/makefile.gcc.UU | uudecode
  86.     if test 2063 -ne `wc -c <'msdos/makefile.gcc'`; then
  87.       echo shar: \"'msdos/makefile.gcc'\" uudecoded with wrong size!
  88.     else
  89.       rm msdos/makefile.gcc.UU
  90.     fi
  91.   fi
  92.   # end of 'msdos/makefile.gcc.UU'
  93. fi
  94. if test -f 'vms/vms.c' -a "${1}" != "-c" ; then 
  95.   echo shar: Will not clobber existing file \"'vms/vms.c'\"
  96. else
  97.   echo shar: Extracting \"'vms/vms.c'\" \(18616 characters\)
  98.   sed "s/^X//" >'vms/vms.c' <<'END_OF_FILE'
  99. X/*************************************************************************
  100. X *                                                                       *
  101. X * VMS portions copyright (C) 1992 Igor Mandrichenko.                    *
  102. X * Permission is granted to any individual or institution to use, copy,  *
  103. X * or redistribute this software so long as all of the original files    *
  104. X * are included unmodified, that it is not sold for profit, and that     *
  105. X * this copyright notice is retained.                                    *
  106. X *                                                                       *
  107. X *************************************************************************/
  108. X
  109. X/*
  110. X *  vms.c (zip) by Igor Mandrichenko    Version 2.1-1
  111. X *
  112. X *  Revision history:
  113. X *  ...
  114. X *  2.1-1       16-feb-1992     I.Mandrichenko  
  115. X *      Get file size from XABFHC and check bytes rest in file before
  116. X *      reading. 
  117. X *  2.1-2       2-mar-1992      I.Mandrichenko
  118. X *      Make code more standard
  119. X *  2.2         21-jun-1992     I.Mandrichenko
  120. X *      Free all allocated space, use more static storage.
  121. X *      Use memcompress() from bits.c (deflation) for block compression.
  122. X *      To revert to old compression method #define OLD_COMPRESS
  123. X */
  124. X
  125. X#ifdef VMS                      /* For VMS only ! */
  126. X
  127. X#define OLD_COMPRESS    /*To use old compression method define it.*/
  128. X
  129. X#include <rms.h>
  130. X#include <descrip.h>
  131. X#include <syidef.h>
  132. X
  133. X#ifndef VAXC
  134. X                                /* This definition may be missed */
  135. Xstruct XAB {
  136. X    unsigned char xab$b_cod;
  137. X    unsigned char xab$b_bln;
  138. X    short int xabdef$$_fill_1;
  139. X    char *xab$l_nxt;
  140. X};
  141. X
  142. X#endif
  143. X
  144. X#ifndef SYI$_VERSION
  145. X#define SYI$_VERSION 4096       /* VMS 5.4 definition */
  146. X#endif
  147. X
  148. X#include "zip.h"
  149. X
  150. X#define ERR(s)  !((s)&1)
  151. X
  152. X#define RET_ERROR 1
  153. X#define RET_SUCCESS 0
  154. X#define RET_EOF 0
  155. X
  156. X#define Kbyte 1024
  157. X
  158. Xtypedef struct XAB *xabptr;
  159. X
  160. X/*
  161. X*   Extra record format
  162. X*   ===================
  163. X*   signature       (2 bytes)   = 'I','M'
  164. X*   size            (2 bytes)
  165. X*   block signature (4 bytes)
  166. X*   flags           (2 butes)
  167. X*   uncomprssed size(2 bytes)
  168. X*   reserved        (4 bytes)
  169. X*   data            (size-12 bytes)
  170. X*   ....
  171. X*/
  172. X
  173. X
  174. X/*
  175. X*   Extra field signature and block signatures
  176. X*/
  177. X#define SIGNATURE "IM"
  178. X#define EXTBSL  4               /* Block signature length   */
  179. X#define RESL    8
  180. X
  181. X#define BC_MASK         07      /* 3 bits for compression type */       
  182. X#define BC_STORED       0       /* Stored */
  183. X#define BC_00           1       /* 0byte -> 0bit compression */
  184. X#define BC_DEFL         2       /* Deflated */
  185. X
  186. Xstruct extra_block
  187. X{       ush     im_sig;
  188. X        ush     size;
  189. X        ulg     block_sig;
  190. X        ush     flags;
  191. X        ush     length;
  192. X        ulg     reserved;
  193. X        uch     body[1];        /* The actual size is unknown */
  194. X};
  195. X
  196. X#define FABSIG  "VFAB"
  197. X#define XALLSIG "VALL"
  198. X#define XFHCSIG "VFHC"
  199. X#define XDATSIG "VDAT"
  200. X#define XRDTSIG "VRDT"
  201. X#define XPROSIG "VPRO"
  202. X#define XKEYSIG "VKEY"
  203. X#define VERSIG  "VMSV"
  204. X/*
  205. X*   Block sizes
  206. X*/
  207. X#define FABL    (cc$rms_fab.fab$b_bln)
  208. X#define RABL    (cc$rms_rab.rab$b_bln)
  209. X#define XALLL   (cc$rms_xaball.xab$b_bln)
  210. X#define XDATL   (cc$rms_xabdat.xab$b_bln)
  211. X#define XFHCL   (cc$rms_xabfhc.xab$b_bln)
  212. X#define XKEYL   (cc$rms_xabkey.xab$b_bln)
  213. X#define XPROL   (cc$rms_xabpro.xab$b_bln)
  214. X#define XRDTL   (cc$rms_xabrdt.xab$b_bln)
  215. X#define XSUML   (cc$rms_xabsum.xab$b_bln)
  216. X#define EXTHL   (4+EXTBSL+RESL)
  217. X#define EXTL0   ((FABL + EXTHL)+        \
  218. X                (XFHCL + EXTHL)+        \
  219. X                (XPROL + EXTHL)+        \
  220. X                (XDATL + EXTHL)+        \
  221. X                (XRDTL + EXTHL))
  222. X
  223. X#ifdef OLD_COMPRESS
  224. X#define PAD     sizeof(uch)
  225. X#else
  226. X#define PAD     10*sizeof(ush)          /* Two extra bytes for compr. header */
  227. X#endif
  228. X
  229. X#define PAD0    (5*PAD)                 /* Reserve space for the case when
  230. X                                        *  compression failes */
  231. Xstatic int _compress();
  232. X
  233. X/***********************************
  234. X *   Function get_vms_attributes   *
  235. X ***********************************/
  236. X
  237. Xstatic uch *_compress_block();
  238. Xstatic int get_vms_version();
  239. X
  240. Xint get_vms_attributes(z)
  241. X  struct zlist *z;
  242. X/*
  243. X *      Get file VMS file attributes and store them into extent fields.
  244. X *      Store VMS version also.
  245. X *      On error leave z intact.
  246. X */
  247. X{
  248. X    int status;
  249. X    uch *extra=(uch*)NULL, *scan;
  250. X    extent extra_l;
  251. X    static struct FAB fab;
  252. X    static struct XABSUM xabsum;
  253. X    static struct XABFHC xabfhc;
  254. X    static struct XABDAT xabdat;
  255. X    static struct XABPRO xabpro;
  256. X    static struct XABRDT xabrdt;
  257. X    xabptr x = (xabptr)NULL, xab_chain = (xabptr)NULL, last_xab = (xabptr)NULL;
  258. X    int nk, na;
  259. X    int i;
  260. X    int rc=RET_ERROR;
  261. X    char verbuf[80];
  262. X    int verlen = 0;
  263. X
  264. X    /*
  265. X    *   Initialize RMS control blocks and link them
  266. X    */
  267. X
  268. X    fab =    cc$rms_fab;
  269. X    xabsum = cc$rms_xabsum;
  270. X    xabdat = cc$rms_xabdat;
  271. X    xabfhc = cc$rms_xabfhc;
  272. X    xabpro = cc$rms_xabpro;
  273. X    xabrdt = cc$rms_xabrdt;
  274. X
  275. X
  276. X    fab.fab$l_xab = (char*)&xabsum;
  277. X    /*
  278. X    *   Open the file and read summary information.
  279. X    */
  280. X    fab.fab$b_fns = strlen(z->name);
  281. X    fab.fab$l_fna = z->name;
  282. X
  283. X    status = sys$open(&fab);
  284. X    if (ERR(status))
  285. X    {
  286. X#ifdef DEBUG
  287. X        printf("get_vms_attributes: sys$open for file %s:\n  error status = %d\n",
  288. X               z->name, status);
  289. X#endif
  290. X        goto err_exit;
  291. X    }
  292. X
  293. X    nk = xabsum.xab$b_nok;
  294. X    na = xabsum.xab$b_noa;
  295. X#ifdef DEBUG
  296. X    printf("%d keys, %d alls\n", nk, na);
  297. X#endif
  298. X
  299. X    /*
  300. X    *   Allocate XABKEY and XABALL blocks ind link them
  301. X    */
  302. X
  303. X    xabfhc.xab$l_nxt = (char*)&xabdat;
  304. X    xabdat.xab$l_nxt = (char*)&xabpro;
  305. X    xabpro.xab$l_nxt = (char*)&xabrdt;
  306. X    xabrdt.xab$l_nxt = (char*)0L;
  307. X
  308. X    xab_chain = (xabptr)(&xabfhc);
  309. X    last_xab  = (xabptr)(&xabrdt);
  310. X
  311. X#define INIT(ptr,size,init)     \
  312. X        if( (ptr = (uch*)malloc(size)) == NULL )        \
  313. X        {                                               \
  314. X              printf( "get_vms_attributes: Insufficient memory.\n" );   \
  315. X                      goto err_exit;                    \
  316. X        }                                               \
  317. X        *(ptr) = (init);
  318. X    /*
  319. X    *   Allocate and initialize all needed XABKEYs and XABALLs
  320. X    */
  321. X    for (i = 0; i < nk; i++)
  322. X    {
  323. X        struct XABKEY *k;
  324. X        INIT(k, XKEYL, cc$rms_xabkey);
  325. X        k->xab$b_ref = i;
  326. X        if (last_xab != 0L)
  327. X            last_xab->xab$l_nxt = (char*)k;
  328. X        last_xab = (xabptr)k;
  329. X    }
  330. X    for (i = 0; i < na; i++)
  331. X    {
  332. X        struct XABALL *a;
  333. X        INIT(a, XALLL, cc$rms_xaball);
  334. X        a->xab$b_aid = i;
  335. X        if (last_xab != 0L)
  336. X            last_xab->xab$l_nxt = (char*)a;
  337. X        last_xab = (xabptr)a;
  338. X    }
  339. X
  340. X    fab.fab$l_xab = (char*)xab_chain;
  341. X#ifdef DEBUG
  342. X    printf("Dump of XAB chain before DISPLAY:\n");
  343. X    for (x = xab_chain; x != 0L; x = x->xab$l_nxt)
  344. X        dump_rms_block(x);
  345. X#endif
  346. X    /*
  347. X    *   Get information on the file structure etc.
  348. X    */
  349. X    status = sys$display(&fab, 0, 0);
  350. X    if (ERR(status))
  351. X    {
  352. X#ifdef DEBUG
  353. X        printf("get_vms_attributes: sys$display for file %s:\n  error status = %d\n",
  354. X               z->name, status);
  355. X#endif
  356. X        goto err_exit;
  357. X    }
  358. X
  359. X#ifdef DEBUG
  360. X    printf("\nDump of XAB chain after DISPLAY:\n");
  361. X    for (x = xab_chain; x != 0L; x = x->xab$l_nxt)
  362. X        dump_rms_block(x);
  363. X#endif
  364. X
  365. X    fab.fab$l_xab = 0;  /* Keep XABs */
  366. X    status = sys$close(&fab);
  367. X    if (ERR(status))
  368. X    {
  369. X#ifdef DEBUG
  370. X        printf("get_vms_attributes: sys$close for file %s:\n  error status = %d\n",
  371. X               z->name, status);
  372. X#endif
  373. X        goto err_exit;
  374. X    }
  375. X
  376. X    extra_l = EXTL0 + nk * (XKEYL + EXTHL) + na * (XALLL + EXTHL);
  377. X#ifndef OLD_COMPRESS
  378. X    extra_l += PAD0 + (nk+na) * PAD;
  379. X#endif
  380. X
  381. X    if( verlen = get_vms_version(verbuf,sizeof(verbuf)) )
  382. X    {   extra_l += verlen + EXTHL;
  383. X#ifndef OLD_COMPRESS
  384. X        extra_l += PAD;
  385. X#endif
  386. X    }
  387. X
  388. X    if ((scan = extra = (uch *) malloc(extra_l)) == (uch*)NULL)
  389. X    {
  390. X#ifdef DEBUG
  391. X        printf("get_vms_attributes: Insufficient memory to allocate extra buffer\n");
  392. X#endif
  393. X        goto err_exit;
  394. X    }
  395. X
  396. X
  397. X    if( verlen > 0 )
  398. X        scan = _compress_block(scan,verbuf, verlen, VERSIG);
  399. X
  400. X    /*
  401. X     *  Zero all unusable fields to improve compression
  402. X     */
  403. X    fab.fab$b_fns = fab.fab$b_shr = fab.fab$b_dns = fab.fab$b_fac = 0;
  404. X    fab.fab$w_ifi = 0;
  405. X    fab.fab$l_stv = fab.fab$l_sts = fab.fab$l_ctx = 0;
  406. X    fab.fab$l_fna = fab.fab$l_nam = fab.fab$l_xab = fab.fab$l_dna = (char*)0L;
  407. X
  408. X#ifdef DEBUG
  409. X    dump_rms_block( &fab );
  410. X#endif
  411. X    scan = _compress_block(scan,&fab, FABL, FABSIG);
  412. X    for (x = xab_chain; x != 0L;)
  413. X    {
  414. X        int bln;
  415. X        char *sig;
  416. X        xabptr next;
  417. X
  418. X        next = (xabptr)(x->xab$l_nxt);
  419. X        x->xab$l_nxt = 0;
  420. X
  421. X        switch (x->xab$b_cod)
  422. X        {
  423. X            case XAB$C_ALL:
  424. X                bln = XALLL;
  425. X                sig = XALLSIG;
  426. X                break;
  427. X            case XAB$C_KEY:
  428. X                bln = XKEYL;
  429. X                sig = XKEYSIG;
  430. X                break;
  431. X            case XAB$C_PRO:
  432. X                bln = XPROL;
  433. X                sig = XPROSIG;
  434. X                break;
  435. X            case XAB$C_FHC:
  436. X                bln = XFHCL;
  437. X                sig = XFHCSIG;
  438. X                break;
  439. X            case XAB$C_DAT:
  440. X                bln = XDATL;
  441. X                sig = XDATSIG;
  442. X                break;
  443. X            case XAB$C_RDT:
  444. X                bln = XRDTL;
  445. X                sig = XRDTSIG;
  446. X                break;
  447. X            default:
  448. X                bln = 0;
  449. X                sig = 0L;
  450. X                break;
  451. X        }
  452. X        if (bln > 0)
  453. X            scan = _compress_block(scan,x, bln, sig);
  454. X        x = next;
  455. X    }
  456. X
  457. X    z->ext = z->cext = scan-extra;
  458. X    z->extra = z->cextra = (char*)extra;
  459. X    rc = RET_SUCCESS;
  460. X
  461. Xerr_exit:
  462. X    /*
  463. X    * Give up all allocated blocks
  464. X    */
  465. X    for(x = (struct XAB *)xab_chain; x != 0L; )
  466. X    {   struct XAB *next;
  467. X        next = (xabptr)(x->xab$l_nxt);
  468. X        if( x->xab$b_cod == XAB$C_ALL || x->xab$b_cod == XAB$C_KEY )
  469. X                free(x);
  470. X        x = next;
  471. X    }
  472. X    return rc;
  473. X}
  474. X
  475. Xstatic int get_vms_version(verbuf,len)
  476. Xchar *verbuf;
  477. Xint len;
  478. X{   int i = SYI$_VERSION;
  479. X    int verlen = 0;
  480. X    struct dsc$descriptor version;
  481. X    char *m;
  482. X
  483. X    version.dsc$a_pointer = verbuf;
  484. X    version.dsc$w_length  = len-1;
  485. X    version.dsc$b_dtype   = DSC$K_DTYPE_B;
  486. X    version.dsc$b_class   = DSC$K_CLASS_S;
  487. X
  488. X    if (ERR(lib$getsyi(&i, 0, &version, &verlen, 0, 0)) || verlen == 0)
  489. X        return 0;
  490. X
  491. X    /* Cut out trailing spaces "V5.4-3   " -> "V5.4-3" */
  492. X    for(m=verbuf+verlen,i=verlen-1; i>0 && verbuf[i]==' '; --i) 
  493. X        --m;
  494. X    *m = 0;
  495. X
  496. X    /* Cut out release number "V5.4-3" -> "V5.4" */
  497. X    if( (m=strrchr(verbuf,'-')) != (char*)NULL )
  498. X        *m = 0;
  499. X    return strlen(verbuf)+1;    /* Transmit ending 0 too */
  500. X}
  501. X
  502. X#define CTXSIG ((ulg)('CtXx'))
  503. X
  504. Xtypedef struct user_context
  505. X{
  506. X    ulg sig;
  507. X    struct FAB *fab;
  508. X    struct RAB *rab;
  509. X    ulg size,rest;
  510. X    int status;
  511. X} Ctx, *Ctxptr;
  512. X
  513. XCtx init_ctx =  
  514. X{       CTXSIG,
  515. X        0L,
  516. X        0L,
  517. X        0L,
  518. X        0L,
  519. X        0
  520. X};
  521. X
  522. X#define CTXL    sizeof(Ctx)
  523. X#define CHECK_RAB(_r) ( (_r) != 0 &&                            \
  524. X                        (_r) -> rab$b_bid == RAB$C_BID &&       \
  525. X                        (_r) -> rab$b_bln == RAB$C_BLN &&       \
  526. X                        (_r) -> rab$l_ctx != 0L     &&          \
  527. X                        (_r) -> rab$l_fab != 0L )
  528. X
  529. X/**************************
  530. X *   Function vms_open    *
  531. X **************************/
  532. Xstruct RAB *vms_open(name)
  533. X    char *name;
  534. X{
  535. X    struct RAB *rab;
  536. X    struct FAB *fab;
  537. X    struct XABFHC *fhc;
  538. X    Ctxptr ctx;
  539. X
  540. X    if ((fab = (struct FAB *) malloc(FABL)) == (struct FAB *)NULL)
  541. X        return 0;
  542. X    if ((rab = (struct RAB *) malloc(RABL)) == (struct RAB *)NULL)
  543. X    {
  544. X        free(fab);
  545. X        return 0;
  546. X    }
  547. X    if ((fhc = (struct XABFHC *) malloc(XFHCL)) == (struct XABFHC *)NULL)
  548. X    {
  549. X        free(rab);
  550. X        free(fab);
  551. X        return 0;
  552. X    }
  553. X    if ((ctx = (Ctxptr) malloc(CTXL)) == (Ctxptr)NULL)
  554. X    {
  555. X        free(fhc);
  556. X        free(fab);
  557. X        free(rab);
  558. X        return 0;
  559. X    }
  560. X    *fab = cc$rms_fab;
  561. X    *rab = cc$rms_rab;
  562. X    *fhc = cc$rms_xabfhc;
  563. X
  564. X    fab->fab$l_fna = name;
  565. X    fab->fab$b_fns = strlen(name);
  566. X    fab->fab$b_fac = FAB$M_GET | FAB$M_BIO;
  567. X    fab->fab$l_xab = (char*)fhc;
  568. X
  569. X    if (ERR(sys$open(fab)))
  570. X    {
  571. X        sys$close(fab);
  572. X        free(fhc);
  573. X        free(fab);
  574. X        free(rab);
  575. X        free(ctx);
  576. X        return 0;
  577. X    }
  578. X
  579. X    rab->rab$l_fab = fab;
  580. X    rab->rab$l_rop = RAB$M_BIO;
  581. X
  582. X    if (ERR(sys$connect(rab)))
  583. X    {
  584. X        sys$close(fab);
  585. X        free(fab);
  586. X        free(rab);
  587. X        free(ctx);
  588. X        return 0;
  589. X    }
  590. X
  591. X    *ctx = init_ctx;
  592. X    ctx->rab = rab;
  593. X    ctx->fab = fab;
  594. X
  595. X    if( fhc->xab$l_ebk > 0 )
  596. X        ctx->size = ctx->rest = ( fhc->xab$l_ebk-1 ) * 512 + fhc->xab$w_ffb;
  597. X    else
  598. X        ctx->size = ctx->rest = 0;
  599. X    free(fhc);
  600. X    fab -> fab$l_xab = 0;
  601. X    rab->rab$l_ctx = (long)ctx;
  602. X    return rab;
  603. X}
  604. X
  605. X/**************************
  606. X *   Function vms_close   *
  607. X **************************/
  608. Xint vms_close(rab)
  609. X    struct RAB *rab;
  610. X{
  611. X    struct FAB *fab;
  612. X    Ctxptr ctx;
  613. X
  614. X    if (!CHECK_RAB(rab))
  615. X        return RET_ERROR;
  616. X    fab = (ctx = (Ctxptr)(rab->rab$l_ctx))->fab;
  617. X    sys$close(fab);
  618. X
  619. X    free(fab);
  620. X    free(rab);
  621. X    free(ctx);
  622. X
  623. X    return RET_SUCCESS;
  624. X}
  625. X
  626. X/**************************
  627. X *   Function vms_rewind  *
  628. X **************************/
  629. Xint vms_rewind(rab)
  630. X    struct RAB *rab;
  631. X{
  632. X    Ctxptr ctx;
  633. X
  634. X    int status;
  635. X    if (!CHECK_RAB(rab))
  636. X        return RET_ERROR;
  637. X
  638. X    ctx = (Ctxptr) (rab->rab$l_ctx);
  639. X    if (ERR(status = sys$rewind(rab)))
  640. X    {
  641. X        ctx->status = status;
  642. X        return RET_ERROR;
  643. X    }
  644. X
  645. X    ctx->status = 0;
  646. X    ctx->rest = ctx->size;
  647. X    
  648. X    return RET_SUCCESS;
  649. X}
  650. X
  651. X/**************************
  652. X *   Function vms_read    *
  653. X **************************/
  654. Xint vms_read(rab, buf, size)
  655. X    struct RAB *rab;
  656. Xchar *buf;
  657. Xint size;
  658. X/*
  659. X*       size must be greater or equal to 512 !
  660. X*/
  661. X{
  662. X    int status;
  663. X    Ctxptr ctx;
  664. X
  665. X    ctx = (Ctxptr)rab->rab$l_ctx;
  666. X
  667. X    if (!CHECK_RAB(rab))
  668. X        return 0;
  669. X
  670. X    if (ctx -> rest <= 0)
  671. X        return 0;               /* Eof */
  672. X
  673. X    if(size > 16*Kbyte)         /* RMS can not read too much */
  674. X        size = 16*Kbyte;
  675. X    else
  676. X        size &= ~511L;
  677. X
  678. X    rab->rab$l_ubf = buf;
  679. X    rab->rab$w_usz = size;
  680. X    status = sys$read(rab);
  681. X    if (!ERR(status) && rab->rab$w_rsz > 0)
  682. X    {
  683. X        ctx -> status = 0;
  684. X        ctx -> rest -= rab->rab$w_rsz;
  685. X        return rab->rab$w_rsz;
  686. X    }
  687. X    else
  688. X    {
  689. X        ctx->status = (status==RMS$_EOF ? 0:status);
  690. X        if(status == RMS$_EOF)
  691. X                ctx -> rest = 0L;
  692. X        return 0;
  693. X    }
  694. X}
  695. X
  696. X/**************************
  697. X *   Function vms_error   *
  698. X **************************/
  699. Xint vms_error(rab)
  700. X    struct RAB *rab;
  701. X{
  702. X    if (!CHECK_RAB(rab))
  703. X        return RET_ERROR;
  704. X    return ((Ctxptr) (rab->rab$l_ctx))->status;
  705. X}
  706. X
  707. X
  708. Xdump_rms_block(p)
  709. X    unsigned char *p;
  710. X{
  711. X    unsigned char bid, len;
  712. X    int err;
  713. X    char *type;
  714. X    char buf[132];
  715. X    int i;
  716. X
  717. X    err = 0;
  718. X    bid = p[0];
  719. X    len = p[1];
  720. X    switch (bid)
  721. X    {
  722. X        case FAB$C_BID:
  723. X            type = "FAB";
  724. X            break;
  725. X        case XAB$C_ALL:
  726. X            type = "xabALL";
  727. X            break;
  728. X        case XAB$C_KEY:
  729. X            type = "xabKEY";
  730. X            break;
  731. X        case XAB$C_DAT:
  732. X            type = "xabDAT";
  733. X            break;
  734. X        case XAB$C_RDT:
  735. X            type = "xabRDT";
  736. X            break;
  737. X        case XAB$C_FHC:
  738. X            type = "xabFHC";
  739. X            break;
  740. X        case XAB$C_PRO:
  741. X            type = "xabPRO";
  742. X            break;
  743. X        default:
  744. X            type = "Unknown";
  745. X            err = 1;
  746. X            break;
  747. X    }
  748. X    printf("Block @%08X of type %s (%d).", p, type, bid);
  749. X    if (err)
  750. X    {
  751. X        printf("\n");
  752. X        return;
  753. X    }
  754. X    printf(" Size = %d\n", len);
  755. X    printf(" Offset - Hex - Dec\n");
  756. X    for (i = 0; i < len; i += 8)
  757. X    {
  758. X        int j;
  759. X        printf("%3d - ", i);
  760. X        for (j = 0; j < 8; j++)
  761. X            if (i + j < len)
  762. X                printf("%02X ", p[i + j]);
  763. X            else
  764. X                printf("   ");
  765. X        printf(" - ");
  766. X        for (j = 0; j < 8; j++)
  767. X            if (i + j < len)
  768. X                printf("%03d ", p[i + j]);
  769. X            else
  770. X                printf("    ");
  771. X        printf("\n");
  772. X    }
  773. X}
  774. X
  775. X#ifdef OLD_COMPRESS
  776. X# define BC_METHOD      BC_00
  777. X# define        COMP_BLK(to,tos,from,froms) _compress( from,to,froms )
  778. X#else
  779. X# define BC_METHOD      BC_DEFL
  780. X# define        COMP_BLK(to,tos,from,froms) memcompress(to,tos,from,froms)
  781. X#endif
  782. X
  783. Xstatic uch *_compress_block(to,from,size,sig)
  784. Xregister struct extra_block *to;
  785. Xuch *from,*sig;
  786. Xint size;
  787. X{                               
  788. X        ulg cl;
  789. X        to -> im_sig =  *(ush*)SIGNATURE;
  790. X        to -> block_sig =       *(ulg*)(sig);
  791. X        to -> flags =           BC_METHOD;
  792. X        to -> length =  size;
  793. X#ifdef DEBUG
  794. X        printf("\nmemcompr(%d,%d,%d,%d)\n",&(to->body[0]),size+PAD,from,size);
  795. X#endif
  796. X        cl = COMP_BLK( &(to->body[0]), size+PAD, from, size );
  797. X#ifdef DEBUG
  798. X        printf("Compressed to %d\n",cl);
  799. X#endif
  800. X        if( cl >= size )
  801. X        {       memcpy(&(to->body[0]), from, size);
  802. X                to->flags = BC_STORED;
  803. X                cl = size;
  804. X#ifdef DEBUG
  805. X                printf("Storing block...\n");
  806. X#endif
  807. X        }
  808. X        return (uch*)(to) + (to->size = cl + EXTBSL + RESL) + 4;
  809. X}
  810. X
  811. X#define NBITS 32
  812. X
  813. Xstatic int _compress(from,to,size)
  814. Xuch *from,*to;
  815. Xint size;
  816. X{
  817. X    int off=0;
  818. X    ulg bitbuf=0;
  819. X    int bitcnt=0;
  820. X    int i;
  821. X
  822. X#define _BIT(val,len)   {                       \
  823. X        if(bitcnt + (len) > NBITS)              \
  824. X            while(bitcnt >= 8)                  \
  825. X            {                                   \
  826. X                to[off++] = (uch)bitbuf;        \
  827. X                bitbuf >>= 8;                   \
  828. X                bitcnt -= 8;                    \
  829. X            }                                   \
  830. X        bitbuf |= ((ulg)(val))<<bitcnt;         \
  831. X        bitcnt += len;                          \
  832. X    }
  833. X
  834. X#define _FLUSH  {                               \
  835. X            while(bitcnt>0)                     \
  836. X            {                                   \
  837. X                to[off++] = (uch)bitbuf;        \
  838. X                bitbuf >>= 8;                   \
  839. X                bitcnt -= 8;                    \
  840. X            }                                   \
  841. X        }
  842. X
  843. X    for(i=0; i<size; i++)
  844. X    {
  845. X        if( from[i] )
  846. X        {
  847. X                _BIT(1,1);
  848. X                _BIT(from[i],8);
  849. X        }
  850. X        else
  851. X            _BIT(0,1);
  852. X    }
  853. X    _FLUSH;
  854. X    return off;
  855. X}
  856. X
  857. X#endif                          /* ?VMS */
  858. END_OF_FILE
  859.   if test 18616 -ne `wc -c <'vms/vms.c'`; then
  860.     echo shar: \"'vms/vms.c'\" unpacked with wrong size!
  861.   fi
  862.   # end of 'vms/vms.c'
  863. fi
  864. if test -f 'vms/vms_zip.rnh' -a "${1}" != "-c" ; then 
  865.   echo shar: Will not clobber existing file \"'vms/vms_zip.rnh'\"
  866. else
  867.   echo shar: Extracting \"'vms/vms_zip.rnh'\" \(18026 characters\)
  868.   sed "s/^X//" >'vms/vms_zip.rnh' <<'END_OF_FILE'
  869. X.!
  870. X.!  File:    ZIP.RNH
  871. X.!
  872. X.!  Author:    Hunter Goatley
  873. X.!
  874. X.!  Date:    October 22, 1991
  875. X.!
  876. X.!  Description:
  877. X.!
  878. X.!    RUNOFF source file for portable ZIP on-line help for VMS.
  879. X.!    Adapted from ZIP.DOC, distributed with ZIP.
  880. X.!
  881. X.!    To build:    $ RUNOFF ZIP.RNH
  882. X.!            $ LIBR/HELP/INSERT libr ZIP
  883. X.!
  884. X.!  Modification history:
  885. X.!
  886. X.!    Hunter Goatley        22-OCT-1991 20:45
  887. X.!        Genesis.
  888. X.!    Jean-loup Gailly    25 March 92
  889. X.!        Adaptation to zip 1.6.
  890. X.!    Igor Mandrichenko    9-JUN-1992
  891. X.!        Added explanation of -V option.
  892. X.!    Jean-loup Gailly    14 June 92
  893. X.!        Adaptation to zip 1.8.
  894. X.!    Jean-loup Gailly    20 Aug 92
  895. X.!        Adaptation to zip 1.9.
  896. X.!
  897. X.noflags
  898. X.lm4 .rm72
  899. X.indent -4
  900. X1 ZIP
  901. X.br
  902. XZip is a compression and file packaging utility for Unix, MSDOS, OS/2, and
  903. XVMS.  It is analogous to a combination of tar and compress and is
  904. Xcompatible with PKZIP (Phil Katz ZIP) for MSDOS systems.
  905. X.sk
  906. XThere is a companion to Zip called UnZip (of course).  Zip and UnZip can
  907. Xwork with files produced by PKZIP under MSDOS, and PKZIP and PKUNZIP can
  908. Xwork with files produced by Zip.
  909. X.sk
  910. XZip 1.9 is compatible with PKZIP 1.93a.
  911. XNote that pkunzip 1.10 cannot extract files produced by pkzip 1.93a
  912. Xor zip 1.9. You must use pkzip 1.93a or unzip 5.0 to extract them.
  913. X.sk
  914. XFor a brief help on Zip and Unzip, run each without specifying any
  915. Xparameters on the command line.
  916. X.sk
  917. XZip puts one or more compressed files into a single "zip file" along with
  918. Xinformation about the files, including the name, path if requested, date
  919. Xand time last modified, protection, and check information to verify the
  920. Xfidelity of each entry.  Zip can pack an entire directory structure in a
  921. Xzip file with a single command.  Compression ratios of 2:1 to 3:1 are
  922. Xcommon for text files.  Zip has has one compression method (deflation) and
  923. Xcan also store files without compression. It automatically chooses the better
  924. Xof the two for each file to be compressed.
  925. X.sk
  926. XZip is useful for packaging a set of files to send to someone or for
  927. Xdistribution; for archiving or backing up files; and for saving disk space
  928. Xby temporarily compressing unused files or directories.
  929. X.sk
  930. XFormat:
  931. X.sk;.lm+1;.literal
  932. XZIP [-options] [-b path] [-n suffixes] [-t mmddyy] zipfile file(s) [-x list]
  933. X.end literal;.lm-1
  934. X.!------------------------------------------------------------------------------
  935. X.indent -4
  936. X2 Options
  937. X.br
  938. XThe default action of Zip is to add or replace zipfile entries from list, which
  939. Xcan include the special name -@ to read names from SYS$INPUT.  The following
  940. Xlist of options was taken from the on-line help generated when Zip is run
  941. Xwithout any command-line parameters:
  942. X.sk
  943. X.literal
  944. X  -f   freshen: only changed files
  945. X  -d   delete entries in zipfile
  946. X  -k   simulate PKZIP made zipfile
  947. X  -h   show this help
  948. X  -r   recurse into directories
  949. X  -q   quiet operation
  950. X  -c   add one-line comments
  951. X  -b   use "path" for temp files
  952. X  -o   make zipfile as old as latest entry
  953. X  -w   append the VMS version number to name stored in zip file
  954. X  -x   exclude the names that follow from those operated on
  955. X  -u   update: only changed or new files
  956. X  -m   move into zipfile (delete files)
  957. X  -g   allow growing existing zipfile
  958. X  -l   translate end-of-lines
  959. X  -j   junk (don't record) directory names
  960. X  -0   store only
  961. X  -1   compress faster
  962. X  -9   compress better
  963. X  -n   don't compress theses suffixes
  964. X  -z   add zipfile comment
  965. X  -t   only do files after "mmddyy"
  966. X  -L   show software license
  967. X  -V   save VMS file attributes
  968. X.end literal
  969. X.!------------------------------------------------------------------------------
  970. X.indent -4
  971. X2 How_To_Use_Zip
  972. X.br
  973. XThe simplest use of Zip is as follows:
  974. X.sk;.indent 10;$ zip stuff *
  975. X.sk
  976. XThis will create the file "STUFF.ZIP" (assuming it does not exist) and put
  977. Xall the files in the current directory in STUFF.ZIP in a compressed form.
  978. XThe .ZIP suffix is added automatically, unless that file name given
  979. Xcontains a dot already.  This allows specifying suffixes other than ".ZIP".
  980. X.sk
  981. XTo zip up an entire directory, the command:
  982. X.sk;.indent 10
  983. X$ zip -r foo *.*
  984. X.sk
  985. Xwill create the file "FOO.ZIP" containing all the files and directories in
  986. Xthe in the current directory.  The "r" option means recurse through the
  987. Xdirectory structure.
  988. X.sk
  989. XYou may want to make a zip file that contains the files in [.FOO], but not
  990. Xrecord the directory name, FOO.  You can use the -j (junk path) option to
  991. Xleave off the path:
  992. X.sk;.indent 10
  993. X$ zip -j foo [.foo]*.*
  994. X.sk
  995. XYou might be zipping to save disk space, in which case you could:
  996. X.sk;.indent 10
  997. X$ zip -rm foo *.txt
  998. X.sk
  999. Xwhere the "m" option means "move".  This will delete all files matching
  1000. X*.txt after making FOO.ZIP.  No deletions will be done until the zip has
  1001. Xcompleted with no errors.  This option is obviously more dangerous and
  1002. Xshould be used with care.
  1003. X.sk
  1004. XIf the zip file already exists, these commands will replace existing or add
  1005. Xnew entries to the zip file.  For example, if you were really short on disk
  1006. Xspace, you might not have enough room simultaneously to hold the directory
  1007. X[.FOO] and the compressed FOO.ZIP.  In this case, you could do it in steps.
  1008. XIf [.FOO] contained the subdirectories [.TOM], [.DICK], and [.HARRY], then
  1009. Xyou could:
  1010. X.sk;
  1011. X.indent 10;$ zip -rm foo [.foo.tom]
  1012. X.indent 10;$ zip -rm foo [.foo.dick]
  1013. X.indent 10;$ zip -rm foo [.foo.harry]
  1014. X.sk
  1015. Xwhere the first command would create FOO.ZIP, and the next two would add to
  1016. Xit.  At the completion of each zip command, the files in the directory just
  1017. Xzipped would be deleted, making room in which the next Zip command could
  1018. Xwork.
  1019. X.!------------------------------------------------------------------------------
  1020. X.indent -4
  1021. X2 Modifying_Existing_Zip_Files
  1022. X.br
  1023. XWhen given the name of an existing zip file with the above commands, Zip
  1024. Xwill replace identically named entries in the Zip file or add entries for
  1025. Xnew names.  For example, if FOO.ZIP exists and contains foo/file1 and
  1026. Xfoo/file2, and the directory [.FOO] contains the files foo/file1 and
  1027. Xfoo/file3, then:
  1028. X.sk;.indent 10
  1029. X$ zip -r foo foo
  1030. X.sk
  1031. Xwill replace foo/file1 in foo.zip and add foo/file3 to FOO.ZIP.  After
  1032. Xthis, FOO.ZIP contains foo/file1, foo/file2, and foo/file3, with foo/file2
  1033. Xunchanged from before.
  1034. X.sk
  1035. XWhen changing an existing zip file, Zip will write a temporary file with
  1036. Xthe new contents, and only replace the old one when the zip has completed
  1037. Xwith no errors. You can use
  1038. Xthe -b option to specify a different path (usually a different dev- ice) to
  1039. Xput the temporary files in.  For example:
  1040. X.sk;.indent 10
  1041. X$ zip -b scratch$:[tmp] stuff *
  1042. X.sk
  1043. Xwill put the temporary zip file and the temporary compression files in the
  1044. Xdirectory "SCRATCH$:[TMP]", copying over STUFF.ZIP in the current directory
  1045. Xwhen done.
  1046. X.sk
  1047. XIf you are only adding entries to a zip file, not replacing, and the -g
  1048. Xoption is given, then Zip grows (appends to) the file instead of copying
  1049. Xit.  The danger of this is that if the operation fails, the original zip
  1050. Xfile is corrupted and lost.
  1051. X.sk
  1052. XThere are two other ways to change or add entries in a zip file that are
  1053. Xrestrictions of simple addition or replacement.  The first is -u (update)
  1054. Xwhich will add new entries to the zip file as before but will replace
  1055. Xexisting entries only if the modified date of the file is more recent than
  1056. Xthe date recorded for that name in the zip file.  For example:
  1057. X.sk;.indent 10
  1058. X$ zip -u stuff *
  1059. X.sk
  1060. Xwill add any new files in the current directory, and update any changed
  1061. Xfiles in the zip file STUFF.ZIP.  Note that Zip will not try to pack
  1062. XSTUFF.ZIP into itself when you do this. Zip will always exclude the zip
  1063. Xfile from the files on which to be operated.
  1064. X.sk
  1065. XThe second restriction is -f (freshen) which, like update, will only
  1066. Xreplace entries with newer files; unlike update, will not add files that
  1067. Xare not already in the zip file. For this option, you may want to simply
  1068. Xfreshen all of the files that are in the specified zip file.  To do this
  1069. Xyou would simply:
  1070. X.sk;.indent 10
  1071. X$ zip -f foo
  1072. X.sk
  1073. XNote that the -f option with no arguments freshens all the entries in the
  1074. Xzip file.  The same is true of -u, and hence "zip -u foo" and "zip -f foo"
  1075. Xboth do the same thing.
  1076. X.sk
  1077. XThis command should be run from the same directory from which the original
  1078. Xzip command was run, since paths stored in zip files are always relative.
  1079. X.sk
  1080. XAnother restriction that can be used with adding, updating, or freshening
  1081. Xis -t (time), which will not operate on files modified earlier than the
  1082. Xspecified date.  For example:
  1083. X.sk;.indent 10
  1084. X$ zip -rt 120791 infamy [.FOO]*.*
  1085. X.sk
  1086. Xwill add all the files in [.FOO] and its subdirectories that were last
  1087. Xmodified on December 7, 1991, or later to the zip file INFAMY.ZIP.
  1088. X.sk
  1089. XAlso, files can be explicitly excluded using the -x option:
  1090. X.sk;.indent 10
  1091. X$ zip -r foo [.FOO] -x *.obj
  1092. X.sk
  1093. Xwhich will zip up the contents of [.FOO] into FOO.ZIP but exclude all the
  1094. Xfiles that end in ".OBJ".
  1095. X.sk
  1096. XThe last operation is -d (delete) which will remove entries from a zip
  1097. Xfile.  An example might be:
  1098. X.sk;.indent 10
  1099. X$ zip -d foo foo/harry/*.* *.obj
  1100. X.sk
  1101. Xwhich will remove all of the files that start with "foo/harry/" and all of
  1102. Xthe files that end with ".OBJ" (in any path).
  1103. X.sk
  1104. XUnder MSDOS, -d is case sensitive when it matches names in the zip file.
  1105. XThis allows deleting names that were zipped on other systems, but requires
  1106. Xthat the names be entered in upper case if they were zipped on an MSDOS
  1107. Xsystem, so that the names can be found in the zip file and deleted.
  1108. X.!------------------------------------------------------------------------------
  1109. X.indent -4
  1110. X2 More_Options
  1111. X.br
  1112. XAs mentioned before, Zip will use the best of two methods: deflate or store.
  1113. XThe option -0 will force Zip to use store on all files. For example:
  1114. X.sk;.indent 10
  1115. Xzip -r0 foo foo
  1116. X.sk
  1117. Xwill zip up the directory foo into foo.zip using only store.
  1118. X.sk
  1119. XThe speed of deflation can also be controlled with options -1 (fastest
  1120. Xmethod but less compression) to -9 (best compression but slower). The
  1121. Xdefault value is -5. For example:
  1122. X.sk;.indent 10
  1123. Xzip -r8 foo foo
  1124. X.sk
  1125. XIn nearly all cases, a file that is already compressed cannot be compressed
  1126. Xfurther by Zip, or if it can, the effect is minimal.  The -n option
  1127. Xprevents Zip from trying to compress files that have the
  1128. Xgiven suffixes.  Such files are simply stored (0%
  1129. Xcompression) in the
  1130. Xoutput zip file, so that Zip doesn't waste its time trying to compress
  1131. Xthem. The suffixes are separated by
  1132. Xeither colons or semicolons.  For example, in DCL:
  1133. X.sk
  1134. X.indent 10;$ zip -rn ".Z:.zip:.tiff:.gif:.snd" foo [.FOO]*.*
  1135. X.sk
  1136. Xwill put everything in [.FOO] into FOO.ZIP, but will store any files that end
  1137. Xin .Z, .ZIP, .TIFF, .GIF, or .SND without trying to compress them.  (Image and
  1138. Xsound files often have their own specialized compression methods.)
  1139. XThe default suffix list is ".Z:.zip;.zoo:.arc:.lzh:.arj".
  1140. XThe environment variable ZIPOPT can be used to change this default. For
  1141. Xexample:
  1142. X.sk
  1143. X.indent 10;$ ZIPOPT == "-n .Z:.zip:.tiff:.gif:.snd"
  1144. X.sk
  1145. XThe variable ZIPOPT can be used for any option and can include several
  1146. Xoptions.
  1147. X.sk
  1148. XUnder Unix and under OS/2 (if files from a HPFS are stored), Zip will store
  1149. Xthe full path (relative to the current path) and name of the file (or just
  1150. Xthe name if -j is specified) in the zip file along with the Unix
  1151. Xattributes, and it will mark the entry as made under Unix.  If the zip file
  1152. Xis intended for PKUNZIP under MSDOS, then the -k (Katz) option should be
  1153. Xused to attempt to convert the names and paths to conform to MSDOS, store
  1154. Xonly the MSDOS attribute (just the user write attribute from Unix), and
  1155. Xmark the entry as made under MSDOS (even though it wasn't).
  1156. X.sk
  1157. XThe -o (older) option will set the "last modified" time of the zip file to
  1158. Xthe latest "last modified" time of the entries in the zip file.  This can
  1159. Xbe used without any other operations, if desired.  For example:
  1160. X.sk;.indent 10
  1161. X$ zip -o foo
  1162. X.sk
  1163. Xwill change the last modified time of FOO.ZIP to the latest time of the
  1164. Xentries in FOO.ZIP.
  1165. X.sk
  1166. XThe -e and -c options operate on all files updated or added to the zip
  1167. Xfile.  Encryption (-e) will prompt for a password on the terminal and will
  1168. Xnot echo the password as it is typed (if stderr is not a TTY, Zip will exit
  1169. Xwith an error). New zip entries will be encrypted using that password.  For
  1170. Xadded peace of mind, you can use -ee, which will prompt for the password
  1171. Xtwice, checking that the two are the same before using it.
  1172. X.sk
  1173. XOne-line comments can be added for each file with the -c option.  The zip
  1174. Xfile operations (adding or updating) will be done first, and you will then
  1175. Xbe prompted for a one-line comment for each file.  You can then enter the
  1176. Xcomment followed by return, or just return for no comment.
  1177. X.sk
  1178. XThe -z option will prompt you for a multi-line comment for the entire zip
  1179. Xfile.  This option can be used by itself, or in combination with other
  1180. Xoptions.  The comment is ended by a line containing just a period, or an
  1181. Xend of file condition (^D on Unix, ^Z on MSDOS, OS/2, and VAX/VMS).
  1182. X.sk
  1183. XThe -q (quiet) option eliminates the informational messages and comment
  1184. Xprompts while Zip is operating.  This might be used in shell scripts, for
  1185. Xexample, or if the zip operation is being performed as a background task
  1186. X("$ spawn/nowait zip -q foo *.c").
  1187. X.sk
  1188. XZip can take a list of file names to operate on from SYS$INPUT using the
  1189. X"-@"
  1190. Xoption.
  1191. X.!  In Unix, this option can be used with the find command to extend
  1192. X.!greatly the functionality of Zip. For example, to zip up all the C source
  1193. X.!files in the current directory and its subdirectories, you can:
  1194. X.!.sk
  1195. X.!find . -type f -name "*.[ch]" -print | zip source -@
  1196. X.!.sk
  1197. X.!Note that the pattern must be quoted to keep the shell from expanding it.
  1198. X.sk
  1199. XUnder VMS only, the -w option will append the version number of the files
  1200. Xto the name and zip up multiple versions of files.  Without -w, Zip will
  1201. Xonly use the most recent version of the specified file(s).
  1202. X.sk
  1203. XOne more option that valid only under VMS is -V option. This option saves
  1204. Xall (hopefully) file attributes needed to make EXACT copy of the
  1205. Xfile after extraction from archive. To extract a file with saved attributes
  1206. Xuse UnZip version 4.2 or later. Note that to specify this option you should
  1207. Xquote it ("-V"). Be carefull: it's rather hard (if possible at all) to extract
  1208. Xa file archived on VMS with this option specified on other systems. See 
  1209. Xdocumentation on UnZip for further information.
  1210. X.sk
  1211. XThe -l option translates the Unix end-of-line character LF into the
  1212. XMSDOS convention CR LF. This option should not be used on binary files.
  1213. XThis option can be used on Unix if the zip file is intended for PKUNZIP
  1214. Xunder MSDOS.
  1215. X.sk
  1216. XIf Zip is run with the -h option, or with no arguments and standard output is
  1217. Xa terminal, the license and the command-argument and option help is shown.
  1218. XThe -L option just shows the license.
  1219. X.!------------------------------------------------------------------------------
  1220. X.indent -4
  1221. X2 Copyright
  1222. X.br
  1223. X     Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, Jean-loup Gailly,
  1224. X     Igor Mandrichenko and Kai Uwe Rommel. Permission is granted to any
  1225. X     individual or institution to use, copy, or redistribute this software
  1226. X     so long as all of the original files are included unmodified,
  1227. X     that it is not sold for profit, and that this copyright
  1228. X     notice is retained.
  1229. X.!------------------------------------------------------------------------------
  1230. X.indent -4
  1231. X2 Acknowledgements
  1232. X.br
  1233. X     Thanks to R. P. Byrne for his Shrink.Pas program which
  1234. X     inspired this project; to Phil Katz for making the zip file format,
  1235. X     compression format, and .ZIP filename extension all public
  1236. X     domain; to Steve Burg and Phil Katz for help on unclear points of
  1237. X     the deflate format; to Keith Petersen for providing a mailing list and
  1238. X     ftp site for the INFO-ZIP group to use; and most importantly, to
  1239. X     the INFO-ZIP group itself (listed in the file
  1240. X     infozip.who) without whose tireless testing and bug-fixing
  1241. X     efforts a portable Zip would not have been possible.
  1242. X     Finally we should thank (blame) the INFO-ZIP moderator,
  1243. X     David Kirschbaum for getting us into this mess in the first
  1244. X     place.
  1245. X.!------------------------------------------------------------------------------
  1246. X.indent -4
  1247. X2 Bugs
  1248. X.sk
  1249. X     WARNING: zip files produced by this version of zip must not be
  1250. X     *updated* by zip 1.0 or pkzip 1.10 or pkzip 1.93a, if they contain
  1251. X     encrypted members, or if they have been produced in a pipe or on a non
  1252. X     seekable device. The old versions of zip or pkzip would destroy the
  1253. X     zip structure. The old versions can list the contents of the zip file
  1254. X     but cannot extract it anyway (because of the new compression algorithm).
  1255. X     If you do not use encryption and use regular disk files, you do
  1256. X     not have to care about this problem.
  1257. X.sk
  1258. X     Under VMS, not all of the odd file formats are treated properly.  Only
  1259. X     zip files of format stream-LF and fixed length 512 are expected to work
  1260. X     with Zip.  Others can be converted using Rahul Dhesi's BILF
  1261. X     program.  This version of Zip does handle some of the
  1262. X     conversion internally.
  1263. X     When using Kermit to transfer zip files from Vax to MSDOS, type "set
  1264. X     file type block" on the Vax.  When transfering from MSDOS to Vax, type
  1265. X     "set file type fixed" on the Vax.  In both cases, type "set file type
  1266. X     binary" on MSDOS.
  1267. X.sk
  1268. X     Under VMS, zip hangs for file specification that uses DECnet
  1269. X     syntax (foo::*.*).
  1270. X.sk
  1271. X     LIKE ANYTHING ELSE THAT'S FREE, ZIP AND ITS ASSOCIATED UTILITIES
  1272. X     ARE PROVIDED AS IS AND COME WITH NO WARRANTY OF ANY
  1273. X     KIND, EITHER EXPRESSED OR IMPLIED. IN NO EVENT WILL THE
  1274. X     COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES RESULTING FROM
  1275. X     THE USE OF THIS SOFTWARE.
  1276. X.sk
  1277. X     That having been said, please send any problems or comments
  1278. X     via email to the Internet address zip-bugs@cs.ucla.edu.  For
  1279. X     bug reports, please include the version of Zip, the make
  1280. X     options you used to compile it, the machine and operating
  1281. X     system you are using, and as much additional information as
  1282. X     possible.  Thank you for your support.
  1283. X.!------------------------------------------------------------------------------
  1284. END_OF_FILE
  1285.   if test 18026 -ne `wc -c <'vms/vms_zip.rnh'`; then
  1286.     echo shar: \"'vms/vms_zip.rnh'\" unpacked with wrong size!
  1287.   fi
  1288.   # end of 'vms/vms_zip.rnh'
  1289. fi
  1290. if test -f 'zipsplit.c' -a "${1}" != "-c" ; then 
  1291.   echo shar: Will not clobber existing file \"'zipsplit.c'\"
  1292. else
  1293.   echo shar: Extracting \"'zipsplit.c'\" \(17114 characters\)
  1294.   sed "s/^X//" >'zipsplit.c' <<'END_OF_FILE'
  1295. X/*
  1296. X
  1297. X Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly,
  1298. X Kai Uwe Rommel and Igor Mandrichenko.
  1299. X Permission is granted to any individual or institution to use, copy, or
  1300. X redistribute this software so long as all of the original files are included
  1301. X unmodified, that it is not sold for profit, and that this copyright notice
  1302. X is retained.
  1303. X
  1304. X*/
  1305. X
  1306. X/*
  1307. X *  zipsplit.c by Mark Adler.
  1308. X */
  1309. X
  1310. X#define UTIL
  1311. X#include "revision.h"
  1312. X#include "zip.h"
  1313. X#include <signal.h>
  1314. X
  1315. X#define DEFSIZ 36000L   /* Default split size (change in help() too) */
  1316. X#ifdef MSDOS
  1317. X#  define NL 2          /* Number of bytes written for a \n */
  1318. X#else /* !MSDOS */
  1319. X#  define NL 1          /* Number of bytes written for a \n */
  1320. X#endif /* ?MSDOS */
  1321. X#define INDEX "zipsplit.idx"    /* Name of index file */
  1322. X
  1323. X
  1324. X/* Local functions */
  1325. X#ifdef PROTO
  1326. X   local void handler(int);
  1327. X   local void license(void);
  1328. X   local void help(void);
  1329. X   local extent simple(ulg *, extent, ulg, ulg);
  1330. X   local int descmp(voidp *, voidp *);
  1331. X   local extent greedy(ulg *, extent, ulg, ulg);
  1332. X   void main(int, char **);
  1333. X#endif /* PROTO */
  1334. X
  1335. X
  1336. X/* Output zip files */
  1337. Xlocal char template[16];        /* name template for output files */
  1338. Xlocal int zipsmade = 0;         /* number of zip files made */
  1339. Xlocal int indexmade = 0;        /* true if index file made */
  1340. Xlocal char *path = NULL;        /* space for full name */
  1341. Xlocal char *name;               /* where name goes in path[] */
  1342. X
  1343. X
  1344. Xvoid err(c, h)
  1345. Xint c;                  /* error code from the ZE_ class */
  1346. Xchar *h;                /* message about how it happened */
  1347. X/* Issue a message for the error, clean up files and memory, and exit. */
  1348. X{
  1349. X  if (PERR(c))
  1350. X    perror("zipsplit error");
  1351. X  fprintf(stderr, "zipsplit error: %s (%s)\n", errors[c-1], h);
  1352. X  if (indexmade)
  1353. X  {
  1354. X    strcpy(name, INDEX);
  1355. X    destroy(path);
  1356. X  }
  1357. X  for (; zipsmade; zipsmade--)
  1358. X  {
  1359. X    sprintf(name, template, zipsmade);
  1360. X    destroy(path);
  1361. X  }
  1362. X  if (path != NULL)
  1363. X    free((voidp *)path);
  1364. X  if (zipfile != NULL)
  1365. X    free((voidp *)zipfile);
  1366. X#ifdef VMS
  1367. X  exit(0);
  1368. X#else /* !VMS */
  1369. X  exit(c);
  1370. X#endif /* ?VMS */
  1371. X}
  1372. X
  1373. X
  1374. X
  1375. Xlocal void handler(s)
  1376. Xint s;                  /* signal number (ignored) */
  1377. X/* Upon getting a user interrupt, abort cleanly using err(). */
  1378. X{
  1379. X#ifndef MSDOS
  1380. X  putc('\n', stderr);
  1381. X#endif /* !MSDOS */
  1382. X  err(ZE_ABORT, "aborting");
  1383. X  s++;                                  /* keep some compilers happy */
  1384. X}
  1385. X
  1386. X
  1387. Xvoid warn(a, b)
  1388. Xchar *a, *b;            /* message strings juxtaposed in output */
  1389. X/* Print a warning message to stderr and return. */
  1390. X{
  1391. X  fprintf(stderr, "zipsplit warning: %s%s\n", a, b);
  1392. X}
  1393. X
  1394. X
  1395. Xlocal void license()
  1396. X/* Print license information to stdout. */
  1397. X{
  1398. X  extent i;             /* counter for copyright array */
  1399. X
  1400. X  for (i = 0; i < sizeof(copyright)/sizeof(char *); i++) {
  1401. X    printf(copyright[i], "zipsplit");
  1402. X    putchar('\n');
  1403. X  }
  1404. X  for (i = 0; i < sizeof(disclaimer)/sizeof(char *); i++)
  1405. X    puts(disclaimer[i]);
  1406. X}
  1407. X
  1408. X
  1409. Xlocal void help()
  1410. X/* Print help (along with license info) to stdout. */
  1411. X{
  1412. X  extent i;             /* counter for help array */
  1413. X
  1414. X  /* help array */
  1415. X  static char *text[] = {
  1416. X"",
  1417. X"ZipSplit %d.%d (%s)",
  1418. X"Usage:  zipsplit [-ti] [-n size] [-b path] zipfile",
  1419. X"  -t   report how many files it will take, but don't make them",
  1420. X"  -i   make index (zipsplit.idx) and count its size against first zip file",
  1421. X"  -n   make zip files no larger than \"size\" (default = 36000)",
  1422. X"  -b   use \"path\" for the output zip files",
  1423. X"  -s   do a sequential split even if it takes more zip files",
  1424. X"  -h   show this help               -L   show software license"
  1425. X  };
  1426. X
  1427. X  for (i = 0; i < sizeof(copyright)/sizeof(char *); i++) {
  1428. X    printf(copyright[i], "zipsplit");
  1429. X    putchar('\n');
  1430. X  }
  1431. X  for (i = 0; i < sizeof(text)/sizeof(char *); i++)
  1432. X  {
  1433. X    printf(text[i], REVISION / 10, REVISION % 10, REVDATE);
  1434. X    putchar('\n');
  1435. X  }
  1436. X}
  1437. X
  1438. X
  1439. Xlocal extent simple(a, n, c, d)
  1440. Xulg *a;         /* items to put in bins, return value: destination bins */
  1441. Xextent n;       /* number of items */
  1442. Xulg c;          /* capacity of each bin */
  1443. Xulg d;          /* amount to deduct from first bin */
  1444. X/* Return the number of bins of capacity c that are needed to contain the
  1445. X   integers in a[0..n-1] placed sequentially into the bins.  The value d
  1446. X   is deducted initially from the first bin (space for index).  The entries
  1447. X   in a[] are replaced by the destination bins. */
  1448. X{
  1449. X  extent k;     /* current bin number */
  1450. X  ulg t;        /* space used in current bin */
  1451. X
  1452. X  t = k = 0;
  1453. X  while (n--)
  1454. X  {
  1455. X    if (*a + t > c - (k == 0 ? d : 0))
  1456. X    {
  1457. X      k++;
  1458. X      t = 0;
  1459. X    }
  1460. X    t += *a;
  1461. X    *(ulg huge *)a++ = k;
  1462. X  }
  1463. X  return k + 1;
  1464. X}
  1465. X
  1466. X
  1467. Xlocal int descmp(a, b)
  1468. Xvoidp *a, *b;           /* pointers to pointers to ulg's to compare */
  1469. X/* Used by qsort() in greedy() to do a descending sort. */
  1470. X{
  1471. X  return **(ulg **)a < **(ulg **)b ? 1 : (**(ulg **)a > **(ulg **)b ? -1 : 0);
  1472. X}
  1473. X
  1474. X
  1475. Xlocal extent greedy(a, n, c, d)
  1476. Xulg *a;         /* items to put in bins, return value: destination bins */
  1477. Xextent n;       /* number of items */
  1478. Xulg c;          /* capacity of each bin */
  1479. Xulg d;          /* amount to deduct from first bin */
  1480. X/* Return the number of bins of capacity c that are needed to contain the
  1481. X   items with sizes a[0..n-1] placed non-sequentially into the bins.  The
  1482. X   value d is deducted initially from the first bin (space for index).
  1483. X   The entries in a[] are replaced by the destination bins. */
  1484. X{
  1485. X  ulg *b;       /* space left in each bin (malloc'ed for each m) */
  1486. X  ulg *e;       /* copy of argument a[] (malloc'ed) */
  1487. X  extent i;     /* steps through items */
  1488. X  extent j;     /* steps through bins */
  1489. X  extent k;     /* best bin to put current item in */
  1490. X  extent m;     /* current number of bins */
  1491. X  ulg **s;      /* pointers to e[], sorted descending (malloc'ed) */
  1492. X  ulg t;        /* space left in best bin (index k) */
  1493. X
  1494. X  /* Algorithm:
  1495. X     1. Copy a[] to e[] and sort pointers to e[0..n-1] (in s[]), in
  1496. X        descending order.
  1497. X     2. Compute total of s[] and set m to the smallest number of bins of
  1498. X        capacity c that can hold the total.
  1499. X     3. Allocate m bins.
  1500. X     4. For each item in s[], starting with the largest, put it in the
  1501. X        bin with the smallest current capacity greater than or equal to the
  1502. X        item's size.  If no bin has enough room, increment m and go to step 4.
  1503. X     5. Else, all items ended up in a bin--return m.
  1504. X  */
  1505. X
  1506. X  /* Copy a[] to e[], put pointers to e[] in s[], and sort s[].  Also compute
  1507. X     the initial number of bins (minus 1). */
  1508. X  if ((e = (ulg *)malloc(n * sizeof(ulg))) == NULL ||
  1509. X      (s = (ulg **)malloc(n * sizeof(ulg *))) == NULL)
  1510. X  {
  1511. X    if (e != NULL)
  1512. X      free((voidp *)e);
  1513. X    err(ZE_MEM, "was trying a smart split");
  1514. X    return 0;                           /* only to make compiler happy */
  1515. X  }
  1516. X  memcpy((char *)e, (char *)a, n * sizeof(ulg));
  1517. X  for (t = i = 0; i < n; i++)
  1518. X    t += *(s[i] = e + i);
  1519. X  m = (extent)((t + c - 1) / c) - 1;    /* pre-decrement for loop */
  1520. X  qsort((char *)s, n, sizeof(ulg *), descmp);
  1521. X
  1522. X  /* Stuff bins until successful */
  1523. X  do {
  1524. X    /* Increment the number of bins, allocate and initialize bins */
  1525. X    if ((b = (ulg *)malloc(++m * sizeof(ulg))) == NULL)
  1526. X    {
  1527. X      free((voidp *)s);
  1528. X      free((voidp *)e);
  1529. X      err(ZE_MEM, "was trying a smart split");
  1530. X    }
  1531. X    b[0] = c - d;                       /* leave space in first bin */
  1532. X    for (j = 1; j < m; j++)
  1533. X      b[j] = c;
  1534. X
  1535. X    /* Fill the bins greedily */
  1536. X    for (i = 0; i < n; i++)
  1537. X    {
  1538. X      /* Find smallest bin that will hold item i (size s[i]) */
  1539. X      t = c + 1;
  1540. X      for (k = j = 0; j < m; j++)
  1541. X        if (*s[i] <= b[j] && b[j] < t)
  1542. X          t = b[k = j];
  1543. X
  1544. X      /* If no bins big enough for *s[i], try next m */
  1545. X      if (t == c + 1)
  1546. X        break;
  1547. X
  1548. X      /* Diminish that bin and save where it goes */
  1549. X      b[k] -= *s[i];
  1550. X      a[(int)((ulg huge *)(s[i]) - (ulg huge *)e)] = k;
  1551. X    }
  1552. X
  1553. X    /* Clean up */
  1554. X    free((voidp *)b);
  1555. X
  1556. X    /* Do until all items put in a bin */
  1557. X  } while (i < n);
  1558. X
  1559. X  /* Done--clean up and return the number of bins needed */
  1560. X  free((voidp *)s);
  1561. X  free((voidp *)e);
  1562. X  return m;
  1563. X}
  1564. X
  1565. X
  1566. Xvoid main(argc, argv)
  1567. Xint argc;               /* number of tokens in command line */
  1568. Xchar **argv;            /* command line tokens */
  1569. X/* Split a zip file into several zip files less than a specified size.  See
  1570. X   the command help in help() above. */
  1571. X{
  1572. X  ulg *a;               /* malloc'ed list of sizes, dest bins */
  1573. X  extent *b;            /* heads of bin linked lists (malloc'ed) */
  1574. X  ulg c;                /* bin capacity, start of central directory */
  1575. X  int d;                /* if true, just report the number of disks */
  1576. X  FILE *e;              /* input zip file */
  1577. X  FILE *f;              /* output index and zip files */
  1578. X  extent g;             /* number of bins from greedy(), entry to write */
  1579. X  int h;                /* how to split--true means simple split, counter */
  1580. X  ulg i;                /* size of index file or zero if none */
  1581. X  extent j;             /* steps through zip entries, bins */
  1582. X  int k;                /* next argument type */
  1583. X  ulg *p;               /* malloc'ed list of sizes, dest bins for greedy() */
  1584. X  char *q;              /* steps through option characters */
  1585. X  int r;                /* temporary variable, counter */
  1586. X  extent s;             /* number of bins needed */
  1587. X  ulg t;                /* total of sizes, end of central directory */
  1588. X  struct zlist far **w; /* malloc'ed table for zfiles linked list */
  1589. X  int x;                /* if true, make an index file */
  1590. X  struct zlist far *z;  /* steps through zfiles linked list */
  1591. X
  1592. X
  1593. X  /* If no args, show help */
  1594. X  if (argc == 1)
  1595. X  {
  1596. X    help();
  1597. X    exit(0);
  1598. X  }
  1599. X
  1600. X  init_upper();           /* build case map table */
  1601. X
  1602. X  /* Go through args */
  1603. X  signal(SIGINT, handler);
  1604. X  signal(SIGTERM, handler);
  1605. X  k = h = x = d = 0;
  1606. X  c = DEFSIZ;
  1607. X  for (r = 1; r < argc; r++)
  1608. X    if (*argv[r] == '-')
  1609. X      if (argv[r][1])
  1610. X        for (q = argv[r]+1; *q; q++)
  1611. X          switch(*q)
  1612. X          {
  1613. X            case 'b':   /* Specify path for output files */
  1614. X              if (k)
  1615. X                err(ZE_PARMS, "options are separate and precede zip file");
  1616. X              else
  1617. X                k = 1;          /* Next non-option is path */
  1618. X              break;
  1619. X            case 'h':   /* Show help */
  1620. X              help();  exit(0);
  1621. X            case 'i':   /* Make an index file */
  1622. X              x = 1;
  1623. X              break;
  1624. X            case 'l': case 'L':  /* Show copyright and disclaimer */
  1625. X              license();  exit(0);
  1626. X            case 'n':   /* Specify maximum size of resulting zip files */
  1627. X              if (k)
  1628. X                err(ZE_PARMS, "options are separate and precede zip file");
  1629. X              else
  1630. X                k = 2;          /* Next non-option is size */
  1631. X              break;
  1632. X            case 's':
  1633. X              h = 1;    /* Only try simple */
  1634. X              break;
  1635. X            case 't':   /* Just report number of disks */
  1636. X              d = 1;
  1637. X              break;
  1638. X            default:
  1639. X              err(ZE_PARMS, "unknown option");
  1640. X          }
  1641. X      else
  1642. X        err(ZE_PARMS, "zip file cannot be stdin");
  1643. X    else
  1644. X      if (k == 0)
  1645. X        if (zipfile == NULL)
  1646. X        {
  1647. X          if ((zipfile = ziptyp(argv[r])) == NULL)
  1648. X            err(ZE_MEM, "was processing arguments");
  1649. X        }
  1650. X        else
  1651. X          err(ZE_PARMS, "can only specify one zip file");
  1652. X      else if (k == 1)
  1653. X      {
  1654. X        tempath = argv[r];
  1655. X        k = 0;
  1656. X      }
  1657. X      else              /* k must be 2 */
  1658. X      {
  1659. X        if ((c = (ulg)atol(argv[r])) < 100)     /* 100 is smallest zip file */
  1660. X          err(ZE_PARMS, "invalid size given");
  1661. X        k = 0;
  1662. X      }
  1663. X  if (zipfile == NULL)
  1664. X    err(ZE_PARMS, "need to specify zip file");
  1665. X
  1666. X
  1667. X  /* Read zip file */
  1668. X  if ((r = readzipfile()) != ZE_OK)
  1669. X    err(r, zipfile);
  1670. X  if (zfiles == NULL)
  1671. X    err(ZE_NAME, zipfile);
  1672. X
  1673. X  /* Make a list of sizes and check against capacity.  Also compute the
  1674. X     size of the index file. */
  1675. X  c -= ENDHEAD + 4;                     /* subtract overhead/zipfile */
  1676. X  if ((a = (ulg *)malloc(zcount * sizeof(ulg))) == NULL ||
  1677. X      (w = (struct zlist far **)malloc(zcount * sizeof(struct zlist far *))) ==
  1678. X       NULL)
  1679. X  {
  1680. X    if (a != NULL)
  1681. X      free((voidp *)a);
  1682. X    err(ZE_MEM, "was computing split");
  1683. X    return;
  1684. X  }
  1685. X  i = t = 0;
  1686. X  for (j = 0, z = zfiles; j < zcount; j++, z = z->nxt)
  1687. X  {
  1688. X    w[j] = z;
  1689. X    if (x)
  1690. X      i += z->nam + 6 + NL;
  1691. X    t += a[j] = 8 + LOCHEAD + CENHEAD +
  1692. X           2 * (ulg)z->nam + 2 * (ulg)z->ext + z->com + z->siz;
  1693. X    if (a[j] > c)
  1694. X    {
  1695. X      free((voidp *)w);  free((voidp *)a);
  1696. X      err(ZE_BIG, z->zname);
  1697. X    }
  1698. X  }
  1699. X
  1700. X  /* Decide on split to use, report number of files */
  1701. X  if (h)
  1702. X    s = simple(a, zcount, c, i);
  1703. X  else
  1704. X  {
  1705. X    if ((p = (ulg *)malloc(zcount * sizeof(ulg))) == NULL)
  1706. X    {
  1707. X      free((voidp *)w);  free((voidp *)a);
  1708. X      err(ZE_MEM, "was computing split");
  1709. X    }
  1710. X    memcpy((char *)p, (char *)a, zcount * sizeof(ulg));
  1711. X    s = simple(a, zcount, c, i);
  1712. X    g = greedy(p, zcount, c, i);
  1713. X    if (s <= g)
  1714. X      free((voidp *)p);
  1715. X    else
  1716. X    {
  1717. X      free((voidp *)a);
  1718. X      a = p;
  1719. X      s = g;
  1720. X    }
  1721. X  }
  1722. X  printf("%d zip files w%s be made (%d%% efficiency)\n",
  1723. X         s, d ? "ould" : "ill", ((200 * ((t + c - 1)/c)) / s + 1) >> 1);
  1724. X  if (d)
  1725. X  {
  1726. X    free((voidp *)w);  free((voidp *)a);
  1727. X    free((voidp *)zipfile);
  1728. X    zipfile = NULL;
  1729. X    return;
  1730. X  }
  1731. X
  1732. X  /* Set up path for output files */
  1733. X  if ((path = malloc(tempath == NULL ? 13 : strlen(tempath) + 14)) == NULL)
  1734. X    err(ZE_MEM, "was making output file names");
  1735. X  if (tempath == NULL)
  1736. X     name = path;
  1737. X  else
  1738. X  {
  1739. X    strcpy(path, tempath);
  1740. X    if (path[0] && path[strlen(path) - 1] != '/')
  1741. X      strcat(path, "/");
  1742. X    name = path + strlen(path);
  1743. X  }
  1744. X
  1745. X  /* Write the index file */
  1746. X  if (x)
  1747. X  {
  1748. X    strcpy(name, INDEX);
  1749. X    printf("creating %s\n", path);
  1750. X    indexmade = 1;
  1751. X    if ((f = fopen(path, "w")) == NULL)
  1752. X    {
  1753. X      free((voidp *)w);  free((voidp *)a);
  1754. X      err(ZE_CREAT, path);
  1755. X    }
  1756. X    for (j = 0; j < zcount; j++)
  1757. X      fprintf(f, "%5ld %s\n", a[j] + 1, w[j]->zname);
  1758. X    if ((j = ferror(f)) != 0 || fclose(f))
  1759. X    {
  1760. X      if (j)
  1761. X        fclose(f);
  1762. X      free((voidp *)w);  free((voidp *)a);
  1763. X      err(ZE_WRITE, path);
  1764. X    }
  1765. X  }
  1766. X
  1767. X  /* Make linked lists of results */
  1768. X  if ((b = (extent *)malloc(s * sizeof(extent))) == NULL)
  1769. X  {
  1770. X    free((voidp *)w);  free((voidp *)a);
  1771. X    err(ZE_MEM, "was computing split");
  1772. X  }
  1773. X  for (j = 0; j < s; j++)
  1774. X    b[j] = (extent)-1;
  1775. X  j = zcount;
  1776. X  while (j--)
  1777. X  {
  1778. X    g = (extent)a[j];
  1779. X    a[j] = b[g];
  1780. X    b[g] = j;
  1781. X  }
  1782. X
  1783. X  /* Make a name template for the zip files that is eight or less characters
  1784. X     before the .zip, and that will not overwrite the original zip file. */
  1785. X  for (k = 1, j = s; j >= 10; j /= 10)
  1786. X    k++;
  1787. X  if (k > 7)
  1788. X  {
  1789. X    free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1790. X    err(ZE_PARMS, "way too many zip files must be made");
  1791. X  }
  1792. X#ifdef VMS
  1793. X  if ((q = strrchr(zipfile, ']')) != NULL)
  1794. X#else /* !VMS */
  1795. X  if ((q = strrchr(zipfile, '/')) != NULL)
  1796. X#endif /* ?VMS */
  1797. X    q++;
  1798. X  else
  1799. X    q = zipfile;
  1800. X  r = 0;
  1801. X  while ((g = *q++) != 0 && g != '.' && r < 8 - k)
  1802. X    template[r++] = (char)g;
  1803. X  if (r == 0)
  1804. X    template[r++] = '_';
  1805. X  else if (g >= '0' && g <= '9')
  1806. X    template[r - 1] = (char)(template[r - 1] == '_' ? '-' : '_');
  1807. X  sprintf(template + r, "%%0%dd.zip", k);
  1808. X
  1809. X  /* Make the zip files from the linked lists of entry numbers */
  1810. X  if ((e = fopen(zipfile, FOPR)) == NULL)
  1811. X  {
  1812. X    free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1813. X    err(ZE_NAME, zipfile);
  1814. X  }
  1815. X  free((voidp *)zipfile);
  1816. X  zipfile = NULL;
  1817. X  for (j = 0; j < s; j++)
  1818. X  {
  1819. X    sprintf(name, template, j + 1);
  1820. X    printf("creating %s\n", path);
  1821. X    zipsmade = j + 1;
  1822. X    if ((f = fopen(path, FOPW)) == NULL)
  1823. X    {
  1824. X      free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1825. X      err(ZE_CREAT, path);
  1826. X    }
  1827. X    tempzn = 0;
  1828. X    for (g = b[j]; g != (extent)-1; g = (extent)a[g])
  1829. X    {
  1830. X      if (fseek(e, w[g]->off, SEEK_SET))
  1831. X      {
  1832. X        free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1833. X        err(ferror(e) ? ZE_READ : ZE_EOF, zipfile);
  1834. X      }
  1835. X      if ((r = zipcopy(w[g], e, f)) != ZE_OK)
  1836. X      {
  1837. X        free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1838. X        if (r == ZE_TEMP)
  1839. X          err(ZE_WRITE, path);
  1840. X        else
  1841. X          err(r, zipfile);
  1842. X      }
  1843. X    }
  1844. X    if ((c = ftell(f)) == -1L)
  1845. X    {
  1846. X      free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1847. X      err(ZE_WRITE, path);
  1848. X    }
  1849. X    for (g = b[j], k = 0; g != (extent)-1; g = (extent)a[g], k++)
  1850. X      if ((r = putcentral(w[g], f)) != ZE_OK)
  1851. X      {
  1852. X        free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1853. X        err(ZE_WRITE, path);
  1854. X      }
  1855. X    if ((t = ftell(f)) == -1L)
  1856. X    {
  1857. X      free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1858. X      err(ZE_WRITE, path);
  1859. X    }
  1860. X    if ((r = putend(k, t - c, c, (extent)0, (char *)NULL, f)) != ZE_OK)
  1861. X    {
  1862. X      free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1863. X      err(ZE_WRITE, path);
  1864. X    }
  1865. X    if (ferror(f) || fclose(f))
  1866. X    {
  1867. X      free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1868. X      err(ZE_WRITE, path);
  1869. X    }
  1870. X  }
  1871. X  free((voidp *)b);  free((voidp *)w);  free((voidp *)a);
  1872. X  fclose(e);
  1873. X
  1874. X  /* Done! */
  1875. X  exit(0);
  1876. X}
  1877. END_OF_FILE
  1878.   if test 17114 -ne `wc -c <'zipsplit.c'`; then
  1879.     echo shar: \"'zipsplit.c'\" unpacked with wrong size!
  1880.   fi
  1881.   # end of 'zipsplit.c'
  1882. fi
  1883. echo shar: End of archive 7 \(of 11\).
  1884. cp /dev/null ark7isdone
  1885. MISSING=""
  1886. for I in 1 2 3 4 5 6 7 8 9 10 11 ; do
  1887.     if test ! -f ark${I}isdone ; then
  1888.     MISSING="${MISSING} ${I}"
  1889.     fi
  1890. done
  1891. if test "${MISSING}" = "" ; then
  1892.     echo You have unpacked all 11 archives.
  1893.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1894. else
  1895.     echo You still must unpack the following archives:
  1896.     echo "        " ${MISSING}
  1897. fi
  1898. exit 0
  1899. exit 0 # Just in case...
  1900.