home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3609 < prev    next >
Text File  |  1991-07-10  |  49KB  |  1,619 lines
  1. Newsgroups: alt.sources
  2. Subject: zoo 2.1 source part 02/15
  3. Message-ID: <12768@bsu-cs.bsu.edu>
  4. From: dhesi@bsu-cs.bsu.edu (Rahul Dhesi)
  5. Date: 10 Jul 91 08:48:26 GMT
  6.  
  7. Checksum:  837499929 (verify with "brik -cv")
  8. Submitted-by: dhesi@bsu-cs.bsu.edu
  9. Archive-name: zoo210/part02
  10.  
  11. ---- Cut Here and feed the following to sh ----
  12. #!/bin/sh
  13. # This is part 02 of zoo210
  14. # ============= comment.c ==============
  15. if test -f 'comment.c' -a X"$1" != X"-c"; then
  16.     echo 'x - skipping comment.c (File already exists)'
  17. else
  18. echo 'x - extracting comment.c (Text)'
  19. sed 's/^X//' << 'SHAR_EOF' > 'comment.c' &&
  20. #ifndef LINT
  21. static char sccsid[]="@(#) comment.c 2.14 88/01/24 12:42:13";
  22. #endif /* LINT */
  23. X
  24. /*
  25. Copyright (C) 1986, 1987 Rahul Dhesi -- All rights reserved
  26. (C) Copyright 1988 Rahul Dhesi -- All rights reserved
  27. */
  28. X
  29. #include "options.h"
  30. #include "portable.h"
  31. /* comment() */
  32. /* Updates comments */
  33. X
  34. /* buffer size for any one comment line */
  35. #define  COMMENT_LINE_SIZE 76
  36. X
  37. #define  MAX_COMMENT_SIZE  32767
  38. #include "zooio.h"
  39. #include "various.h"
  40. X
  41. #ifndef NOSIGNAL
  42. #include <signal.h>
  43. #endif
  44. X
  45. #include "zoo.h"
  46. #include "zoofns.h"
  47. #include "errors.i"
  48. X
  49. void show_comment PARMS ((struct direntry *, ZOOFILE, int, char *));
  50. void get_comment PARMS ((struct direntry *, ZOOFILE, char *));
  51. int needed PARMS ((char *, struct direntry *, struct zoo_header *));
  52. X
  53. void comment(zoo_path, option)
  54. char *zoo_path, *option;
  55. {
  56. #ifndef NOSIGNAL  
  57. T_SIGNAL (*oldsignal)();
  58. #endif
  59. ZOOFILE zoo_file;                         /* stream for open archive */
  60. long next_ptr;                            /* pointers to within archive */
  61. long this_dir_offset;                     /* pointers to within archive */
  62. struct direntry direntry;                 /* directory entry */
  63. struct zoo_header zoo_header;
  64. int matched = 0;                          /* any files matched? */
  65. unsigned int zoo_date, zoo_time;          /* for restoring archive timestamp */
  66. char whichname[PATHSIZE];                 /* which name to use */
  67. #ifdef ZOOCOMMENT
  68. int acmt = 0;                                        /* if changing archive comment */
  69. #endif
  70. X
  71. /* on entry option points to first letter */
  72. option++;                                            /* skip 'c' */
  73. #ifdef ZOOCOMMENT
  74. while (*option != '\0') {
  75. X    if (*option == 'A') {
  76. X        acmt++;                                        /* changing archive comment */
  77. X        option++;
  78. X    } else
  79. X       prterror ('f', inv_option, *option);
  80. }
  81. #else
  82. if (*option != '\0')
  83. X    prterror ('f', inv_option, *option);
  84. #endif /* ZOOCOMMENT */
  85. X
  86. if ((zoo_file = zooopen (zoo_path, Z_RDWR)) == NOFILE)
  87. X   prterror ('f', could_not_open, zoo_path);
  88. X
  89. /* save archive timestamp */
  90. #ifdef GETUTIME
  91. getutime (zoo_path, &zoo_date, &zoo_time);
  92. #else
  93. gettime (zoo_file, &zoo_date, &zoo_time);
  94. #endif
  95. X
  96. /* read header and rewrite with updated version numbers, but ask user to pack
  97. archive first if archive comment is to be added and header type is 0 */
  98. #ifdef ZOOCOMMENT
  99. if (acmt)
  100. X    rwheader (&zoo_header, zoo_file, 0);
  101. else
  102. X    rwheader (&zoo_header, zoo_file, 1);
  103. #else
  104. rwheader (&zoo_header, zoo_file, 1);
  105. #endif
  106. X
  107. #ifdef ZOOCOMMENT
  108. /* if archive comment being added, handle it and return */
  109. if (acmt) {
  110. X    void do_acmt PARMS ((struct zoo_header *, ZOOFILE, char *));
  111. X    do_acmt (&zoo_header, zoo_file, zoo_path);
  112. #ifdef NIXTIME
  113. X    zooclose (zoo_file);
  114. X    setutime (zoo_path, zoo_date, zoo_time);    /* restore timestamp */
  115. #else
  116. X    settime (zoo_file, zoo_date, zoo_time);    /* restore timestamp */
  117. X    zooclose (zoo_file);
  118. #endif
  119. X    return;
  120. }
  121. #endif /* ZOOCOMMENT */
  122. X
  123. /* Loop through and add comments for matching files */
  124. while (1) {
  125. X   this_dir_offset = zootell (zoo_file);  /* save pos'n of this dir entry */
  126. X   readdir (&direntry, zoo_file, 1);      /* read directory entry */
  127. X   next_ptr = direntry.next;              /* ptr to next dir entry */
  128. X
  129. X   /* exit on end of directory chain or end of file */
  130. X   if (next_ptr == 0L || feof(stdin))
  131. X      break;
  132. X
  133. X    strcpy (whichname, fullpath (&direntry));        /* full pathname */
  134. X    add_version (whichname, &direntry);                /* add version suffix */
  135. X   /* add comments for matching non-deleted files */
  136. X   if (!direntry.deleted && needed (whichname, &direntry, &zoo_header)) {
  137. X      matched++;
  138. X      show_comment (&direntry, zoo_file, 1, whichname);
  139. X      get_comment (&direntry, zoo_file, whichname);
  140. X      zooseek (zoo_file, this_dir_offset, 0);
  141. #ifndef NOSIGNAL
  142. X      oldsignal = signal (SIGINT, SIG_IGN);
  143. #endif
  144. X      fwr_dir (&direntry, zoo_file);
  145. #ifndef NOSIGNAL
  146. X      signal (SIGINT, oldsignal);
  147. #endif
  148. X   }
  149. X   zooseek (zoo_file, next_ptr, 0);   /* ..seek to next dir entry */
  150. } /* end while */
  151. X
  152. #ifdef NIXTIME
  153. zooclose (zoo_file);
  154. setutime (zoo_path, zoo_date, zoo_time);    /* restore timestamp */
  155. #else
  156. settime (zoo_file, zoo_date, zoo_time);    /* restore timestamp */
  157. zooclose (zoo_file);
  158. #endif
  159. X
  160. if (!matched)
  161. X   printf ("Zoo:  %s", no_match);
  162. } /* comment */
  163. X
  164. /* show_comment() */
  165. /* shows comment on screen.  If show=1, says "Current comment is..." */
  166. X
  167. void show_comment (direntry, zoo_file, show, name)
  168. struct direntry *direntry;
  169. ZOOFILE zoo_file;
  170. int show;
  171. char *name;       /* name of file for which comment is being added */
  172. {
  173. X   if (direntry->cmt_size != 0) {
  174. X      unsigned int i;
  175. X      char ch;
  176. X      int newline = 1;
  177. X      zooseek (zoo_file, direntry->comment, 0);   
  178. X      if (show)
  179. X         printf ("Current comment for %s is:\n", name);
  180. X      for (i = 0; i < direntry->cmt_size; i++) {/* show it */
  181. X         ch = zgetc (zoo_file) & 0x7f;          /* 7 bits only */
  182. X         if (newline)
  183. X            printf (" |");    /* indent and mark comment lines thus */
  184. X         zputchar (ch);
  185. X         if (ch == '\n')
  186. X            newline = 1;
  187. X         else
  188. X            newline = 0;
  189. X      }
  190. X      if (!newline)              /* always terminate with newline */
  191. X         zputchar ('\n');
  192. X   }
  193. } /* show_comment() */
  194. X
  195. X
  196. /* get_comment() */
  197. /* Shows user old comment and updates it */
  198. X
  199. /* INPUT:
  200. X   direntry points to current directory entry.
  201. X   zoo_file is archive file.
  202. X   this_path is full pathname of file being updated/added.
  203. X
  204. X   OUTPUT:
  205. X   Comment is added to file and supplied directory entry is updated
  206. X   with comment size and seek position but directory entry is
  207. X   not written to file.  Exceptions:  If RETURN is hit as first line,
  208. X   previous comment is left unchanged.  If /END is hit, previous
  209. X   comment is superseded, even if new comment is null.
  210. */
  211. X
  212. char cmt_prompt[]="[Enter %scomment for %s then type /END]\n";
  213. X
  214. void get_comment (direntry, zoo_file, this_path)  /* update comment */
  215. register struct direntry *direntry;
  216. ZOOFILE zoo_file;
  217. char *this_path;
  218. {
  219. X   unsigned int line_count = 0;        /* count of new comment lines */
  220. X
  221. X   zooseek (zoo_file, 0L, 2);            /* ready to append new comment */
  222. #if 0
  223. X   fprintf (stderr, "[Enter comment for %s then type /END]\n", this_path);
  224. #else
  225. X   fprintf (stderr, cmt_prompt, "", this_path);
  226. #endif
  227. X   while (1) {
  228. X      char cmt_line[COMMENT_LINE_SIZE];
  229. X      int cmt_size;
  230. X      if (fgets (cmt_line, sizeof(cmt_line), stdin) == NULL)
  231. X         break;
  232. X      line_count++;
  233. X      if (line_count == 1) {                 /* first line typed */
  234. X         if (!strcmp (cmt_line, "\n"))   /* exit if first line blank */
  235. X            break;
  236. X         direntry->comment = zootell (zoo_file);
  237. X         direntry->cmt_size = 0;
  238. X      }
  239. X      if (!str_icmp (cmt_line, "/end\n"))
  240. X         break;
  241. X      cmt_size = strlen (cmt_line);
  242. X      if (MAX_COMMENT_SIZE - direntry->cmt_size > cmt_size) {
  243. X         direntry->cmt_size += (unsigned int) cmt_size;
  244. X         if (zoowrite (zoo_file, cmt_line, cmt_size) < cmt_size)
  245. X            prterror ('f', disk_full);
  246. X      }
  247. X   } /* end while */
  248. } /* get_comment() */
  249. X
  250. #ifdef ZOOCOMMENT
  251. /*
  252. do_acmt() updates archive comment by showing it to user and 
  253. requesting a new one.  Typed input terminates as with file comment,
  254. i.e., empty initial line leaves comment unchanged, case-insensitive
  255. "/end" terminates input comment.
  256. */
  257. void do_acmt (zoo_header, zoo_file, zoo_path)
  258. struct zoo_header *zoo_header;
  259. ZOOFILE zoo_file;
  260. char *zoo_path;
  261. {
  262. X   unsigned int line_count = 0;        /* count of new comment lines */
  263. X    void show_acmt PARMS ((struct zoo_header *, ZOOFILE, int));
  264. X
  265. X    show_acmt (zoo_header, zoo_file, 1);    /* show current archive comment */
  266. X   zooseek (zoo_file, 0L, 2);            /* ready to append new comment */
  267. #if 0
  268. X   fprintf (stderr, "[Enter archive comment for %s then type /END]\n", 
  269. X                            zoo_path);
  270. #else
  271. X   fprintf (stderr, cmt_prompt, "archive ", zoo_path);
  272. #endif
  273. X
  274. X   while (1) {
  275. X      char cmt_line[COMMENT_LINE_SIZE];
  276. X      int cmt_size;
  277. X      if (fgets (cmt_line, sizeof(cmt_line), stdin) == NULL)
  278. X         break;
  279. X      line_count++;
  280. X      if (line_count == 1) {                 /* first line typed */
  281. X         if (!strcmp (cmt_line, "\n"))   /* exit if first line blank */
  282. X            break;
  283. X         zoo_header->acmt_pos = zootell (zoo_file);
  284. X         zoo_header->acmt_len = 0;
  285. X      }
  286. X      if (!str_icmp (cmt_line, "/end\n"))
  287. X         break;
  288. X      cmt_size = strlen (cmt_line);
  289. X      if (MAX_COMMENT_SIZE - zoo_header->acmt_len > cmt_size) {
  290. X         zoo_header->acmt_len += (unsigned int) cmt_size;
  291. X         if (zoowrite (zoo_file, cmt_line, cmt_size) < cmt_size)
  292. X            prterror ('f', disk_full);
  293. X      }
  294. X   } /* end while */
  295. X    zooseek (zoo_file, 0L, 0);                    /* seek back to beginning */
  296. X    fwr_zooh (zoo_header, zoo_file);            /* write update zoo_header */
  297. } /* do_acmt() */
  298. #endif /* ZOOCOMMENT */
  299. X
  300. /* Prints archive comment.  If show==1, says "Current archive comment is:" */
  301. void show_acmt (zoo_header, zoo_file, show)
  302. struct zoo_header *zoo_header;
  303. ZOOFILE zoo_file;
  304. int show;
  305. {
  306. X   if (zoo_header->zoo_start != FIXED_OFFSET && zoo_header->acmt_len > 0) {
  307. X      unsigned int i;
  308. X      char ch;
  309. X      int newline = 1;
  310. X      zooseek (zoo_file, zoo_header->acmt_pos, 0);   
  311. X        if (show)
  312. X          printf ("Current archive comment is:\n");
  313. X      for (i = 0; i < zoo_header->acmt_len; i++) {/* show it */
  314. X         ch = zgetc (zoo_file) & 0x7f;          /* 7 bits only */
  315. X         if (newline)
  316. X            printf (">> ");        /* indent and mark comment lines thus */
  317. X         zputchar (ch);
  318. X         if (ch == '\n')
  319. X            newline = 1;
  320. X         else
  321. X            newline = 0;
  322. X      }
  323. X      if (!newline)              /* always terminate with newline */
  324. X         zputchar ('\n');
  325. X   }
  326. } /* show_acmt() */
  327. SHAR_EOF
  328. chmod 0644 comment.c ||
  329. echo 'restore of comment.c failed'
  330. Wc_c="`wc -c < 'comment.c'`"
  331. test 9595 -eq "$Wc_c" ||
  332.     echo 'comment.c: original size 9595, current size' "$Wc_c"
  333. fi
  334. # ============= crcdefs.c ==============
  335. if test -f 'crcdefs.c' -a X"$1" != X"-c"; then
  336.     echo 'x - skipping crcdefs.c (File already exists)'
  337. else
  338. echo 'x - extracting crcdefs.c (Text)'
  339. sed 's/^X//' << 'SHAR_EOF' > 'crcdefs.c' &&
  340. #ifndef LINT
  341. static char sccsid[]="@(#) crcdefs.c 2.1 87/12/25 12:21:58";
  342. #endif /* LINT */
  343. X
  344. #include "options.h"
  345. X
  346. /*
  347. Global definitions for CRC calculation.  I claim no copyright over
  348. the contents of this file.
  349. X
  350. X                                  -- Rahul Dhesi 1987/08/27
  351. */
  352. X
  353. unsigned int crccode;
  354. unsigned int crctab[] = {
  355. X   0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
  356. X    0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 
  357. X    0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0F00, 0xcFc1, 0xce81, 0x0e40, 
  358. X    0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 
  359. X    0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 
  360. X    0x1e00, 0xdec1, 0xdF81, 0x1F40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 
  361. X    0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 
  362. X    0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 
  363. X    0xF001, 0x30c0, 0x3180, 0xF141, 0x3300, 0xF3c1, 0xF281, 0x3240, 
  364. X   0x3600, 0xF6c1, 0xF781, 0x3740, 0xF501, 0x35c0, 0x3480, 0xF441, 
  365. X    0x3c00, 0xFcc1, 0xFd81, 0x3d40, 0xFF01, 0x3Fc0, 0x3e80, 0xFe41, 
  366. X    0xFa01, 0x3ac0, 0x3b80, 0xFb41, 0x3900, 0xF9c1, 0xF881, 0x3840, 
  367. X    0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 
  368. X    0xee01, 0x2ec0, 0x2F80, 0xeF41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 
  369. X    0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 
  370. X    0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 
  371. X    0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 
  372. X    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 
  373. X   0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaF01, 0x6Fc0, 0x6e80, 0xae41, 
  374. X    0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 
  375. X    0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 
  376. X    0xbe01, 0x7ec0, 0x7F80, 0xbF41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 
  377. X    0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 
  378. X    0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 
  379. X    0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 
  380. X    0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 
  381. X    0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5F00, 0x9Fc1, 0x9e81, 0x5e40, 
  382. X   0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 
  383. X    0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 
  384. X    0x4e00, 0x8ec1, 0x8F81, 0x4F40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 
  385. X    0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 
  386. X    0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040 
  387. };
  388. SHAR_EOF
  389. chmod 0644 crcdefs.c ||
  390. echo 'restore of crcdefs.c failed'
  391. Wc_c="`wc -c < 'crcdefs.c'`"
  392. test 2446 -eq "$Wc_c" ||
  393.     echo 'crcdefs.c: original size 2446, current size' "$Wc_c"
  394. fi
  395. # ============= debug.h ==============
  396. if test -f 'debug.h' -a X"$1" != X"-c"; then
  397.     echo 'x - skipping debug.h (File already exists)'
  398. else
  399. echo 'x - extracting debug.h (Text)'
  400. sed 's/^X//' << 'SHAR_EOF' > 'debug.h' &&
  401. /* @(#) debug.h 2.1 87/12/25 12:22:02 */
  402. X
  403. /* 
  404. The contents of this file are hereby released to the public domain.
  405. X
  406. X                           -- Rahul Dhesi 1986/11/14
  407. X
  408. defines conditional function calls 
  409. X
  410. Usage:  The statement
  411. X
  412. X   debug((printf("y = %d\n", y)))
  413. X
  414. may be placed anywhere where two or more statements could be used.  It will 
  415. print the value of y at that point.
  416. X
  417. Conditional compilation:
  418. X
  419. X   if DEBUG is defined
  420. X      define the macro debug(X) to execute statement X
  421. X   else
  422. X      define the macro debug(X) to be null
  423. X   endif
  424. */
  425. X
  426. #ifdef DEBUG
  427. #define  debug(x)    x;
  428. #else
  429. #define  debug(x)
  430. #endif
  431. X
  432. SHAR_EOF
  433. chmod 0644 debug.h ||
  434. echo 'restore of debug.h failed'
  435. Wc_c="`wc -c < 'debug.h'`"
  436. test 615 -eq "$Wc_c" ||
  437.     echo 'debug.h: original size 615, current size' "$Wc_c"
  438. fi
  439. # ============= decode.c ==============
  440. if test -f 'decode.c' -a X"$1" != X"-c"; then
  441.     echo 'x - skipping decode.c (File already exists)'
  442. else
  443. echo 'x - extracting decode.c (Text)'
  444. sed 's/^X//' << 'SHAR_EOF' > 'decode.c' &&
  445. /*$Source: /usr/home/dhesi/zoo/RCS/decode.c,v $*/
  446. /*$Id: decode.c,v 1.6 91/07/09 01:39:49 dhesi Exp $*/
  447. /***********************************************************
  448. X    decode.c
  449. X
  450. Adapted from "ar" archiver written by Haruhiko Okumura.
  451. ***********************************************************/
  452. X
  453. #include "options.h"
  454. #include "zoo.h"
  455. #include "ar.h"
  456. #include "lzh.h"
  457. X
  458. extern int decoded;        /* from huf.c */
  459. X
  460. static int j;  /* remaining bytes to copy */
  461. X
  462. void decode_start()
  463. {
  464. X    huf_decode_start();
  465. X    j = 0;
  466. X    decoded = 0;
  467. }
  468. X
  469. /*
  470. decodes; returns no. of chars decoded 
  471. */
  472. X
  473. int decode(count, buffer)
  474. uint count;
  475. uchar buffer[];
  476. X    /* The calling function must keep the number of
  477. X       bytes to be processed.  This function decodes
  478. X       either 'count' bytes or 'DICSIZ' bytes, whichever
  479. X       is smaller, into the array 'buffer[]' of size
  480. X       'DICSIZ' or more.
  481. X       Call decode_start() once for each new file
  482. X       before calling this function. */
  483. {
  484. X    static uint i;
  485. X    uint r, c;
  486. X
  487. X    r = 0;
  488. X    while (--j >= 0) {
  489. X        buffer[r] = buffer[i];
  490. X        i = (i + 1) & (DICSIZ - 1);
  491. X        if (++r == count)
  492. X            return r;
  493. X    }
  494. X    for ( ; ; ) {
  495. X        c = decode_c();
  496. X        if (decoded)
  497. X            return r;
  498. X        if (c <= UCHAR_MAX) {
  499. X            buffer[r] = c;
  500. X            if (++r == count) 
  501. X                return r;
  502. X        } else {
  503. X            j = c - (UCHAR_MAX + 1 - THRESHOLD);
  504. X            i = (r - decode_p() - 1) & (DICSIZ - 1);
  505. X            while (--j >= 0) {
  506. X                buffer[r] = buffer[i];
  507. X                i = (i + 1) & (DICSIZ - 1);
  508. X                if (++r == count)
  509. X                    return r;
  510. X            }
  511. X        }
  512. X    }
  513. }
  514. SHAR_EOF
  515. chmod 0644 decode.c ||
  516. echo 'restore of decode.c failed'
  517. Wc_c="`wc -c < 'decode.c'`"
  518. test 1444 -eq "$Wc_c" ||
  519.     echo 'decode.c: original size 1444, current size' "$Wc_c"
  520. fi
  521. # ============= descrip.mms ==============
  522. if test -f 'descrip.mms' -a X"$1" != X"-c"; then
  523.     echo 'x - skipping descrip.mms (File already exists)'
  524. else
  525. echo 'x - extracting descrip.mms (Text)'
  526. sed 's/^X//' << 'SHAR_EOF' > 'descrip.mms' &&
  527. # derived from: @(#) descrip.mms 2.2 88/01/09 12:10:49
  528. # $Source: /usr/home/dhesi/zoo/RCS/descrip.mms,v $
  529. # $Id: descrip.mms,v 1.9 91/07/07 14:58:21 dhesi Exp $
  530. #Make Zoo for VAX/VMS
  531. #
  532. #The contents of this makefile are hereby released to the public domain.
  533. #                                  -- Rahul Dhesi 1991/07/06
  534. X
  535. CC = cc
  536. CFLAGS =
  537. EXTRA = /define=(BIG_MEM,NDEBUG,VMS)
  538. ldswitch =
  539. X
  540. #List of all object files created for Zoo
  541. ZOOOBJS = addbfcrc.obj, addfname.obj, basename.obj, comment.obj,  -
  542. X crcdefs.obj, decode.obj, encode.obj, getfile.obj, huf.obj,  -
  543. X io.obj, lzc.obj, lzd.obj, lzh.obj, machine.obj, makelist.obj,  -
  544. X maketbl.obj, maketree.obj, misc.obj, misc2.obj, needed.obj,  -
  545. X nextfile.obj, options.obj, parse.obj, portable.obj, prterror.obj,  -
  546. X version.obj, vmstime.obj, zoo.obj, zooadd.obj, zooadd2.obj,  -
  547. X zoodel.obj, zooext.obj, zoolist.obj, zoopack.obj
  548. X
  549. FIZOBJS = fiz.obj, addbfcrc.obj, portable.obj, crcdefs.obj
  550. X
  551. BILFOBJS = bilf.obj
  552. X
  553. .c.obj :
  554. X    $(CC) $(CFLAGS) $(EXTRA) $*.c
  555. X
  556. zoo.exe : $(ZOOOBJS)
  557. X    link/executable=zoo.exe $(ldswitch) $(ZOOOBJS), options/opt
  558. X
  559. # bigger but perhaps more (less?) portable across machines -- 
  560. # no shared libraries
  561. zoobig.exe : $(ZOOOBJS)
  562. X    link/executable=zoobig.exe $(ldswitch) $(ZOOOBJS)
  563. X
  564. fiz : $(FIZOBJS)
  565. X    link/executable=fiz.exe $(ldswitch) $(FIZOBJS), options/opt
  566. X
  567. bilf : $(BILFOBJS)
  568. X    link/executable=bilf.exe $(ldswitch) $(BILFOBJS), options/opt
  569. X
  570. #######################################################################
  571. # DEPENDENCIES -- not guaranteed to be up-to-date
  572. #######################################################################
  573. X
  574. addbfcrc.obj : options.h
  575. addfname.obj : options.h various.h zoo.h zoofns.h zooio.h
  576. addfname.obj : zoomem.h
  577. basename.obj : assert.h debug.h options.h parse.h various.h
  578. basename.obj : zoo.h zoofns.h zooio.h
  579. comment.obj : errors.i options.h portable.h various.h
  580. comment.obj : zoo.h zoofns.h zooio.h
  581. crcdefs.obj : options.h
  582. decode.obj : ar.h lzh.h options.h zoo.h
  583. encode.obj : ar.h errors.i lzh.h
  584. encode.obj : options.h zoo.h
  585. fiz.obj : options.h portable.h various.h zoo.h zoofns.h
  586. fiz.obj : zooio.h
  587. getfile.obj : options.h various.h zoo.h zoofns.h zooio.h
  588. getfile.obj : zoomem.h
  589. huf.obj : ar.h errors.i lzh.h options.h zoo.h
  590. io.obj : ar.h errors.i lzh.h options.h portable.h zoo.h
  591. io.obj : zooio.h
  592. lzc.obj : assert.h debug.h lzconst.h options.h various.h
  593. lzc.obj : zoo.h zoofns.h zooio.h zoomem.h
  594. lzd.obj : assert.h debug.h lzconst.h options.h various.h
  595. lzd.obj : zoo.h zoofns.h zooio.h zoomem.h
  596. lzh.obj : ar.h errors.i options.h zoo.h
  597. machine.obj : options.h various.h zoo.h zoofns.h zooio.h
  598. makelist.obj : assert.h debug.h errors.i options.h
  599. makelist.obj : portable.h various.h zoo.h zoofns.h zooio.h
  600. maketbl.obj : ar.h lzh.h options.h zoo.h
  601. maketree.obj : ar.h lzh.h options.h zoo.h
  602. misc.obj : errors.i options.h portable.h various.h zoo.h zoofns.h zooio.h
  603. misc2.obj : errors.i options.h portable.h various.h zoo.h
  604. misc2.obj : zoofns.h zooio.h zoomem.h
  605. msdos.obj : errors.i options.h zoo.h zoofns.h zooio.h
  606. needed.obj : debug.h options.h portable.h various.h zoo.h
  607. needed.obj : zoofns.h zooio.h
  608. nextfile.obj : options.h various.h zoo.h
  609. options.obj : errors.i options.h various.h zoo.h zoofns.h
  610. options.obj : zooio.h
  611. parse.obj : assert.h options.h parse.h various.h zoo.h
  612. parse.obj : zoofns.h zooio.h
  613. portable.obj : assert.h debug.h machine.h options.h
  614. portable.obj : portable.h various.h zoo.h zoofns.h zooio.h
  615. prterror.obj : options.h various.h
  616. prterror.obj : zoofns.h zooio.h
  617. zoo.obj : errors.i options.h various.h zoo.h zoofns.h
  618. zoo.obj : zooio.h zoomem.h
  619. zooadd.obj : debug.h errors.i options.h parse.h portable.h
  620. zooadd.obj : various.h zoo.h zoofns.h zooio.h zoomem.h
  621. zooadd2.obj : assert.h debug.h errors.i options.h parse.h
  622. zooadd2.obj : various.h zoo.h zoofns.h zooio.h
  623. zoodel.obj : errors.i options.h portable.h various.h zoo.h zoofns.h zooio.h
  624. zooext.obj : errors.i machine.h options.h parse.h portable.h various.h zoo.h
  625. zooext.obj : zoofns.h zooio.h
  626. zoofilt.obj : options.h
  627. zoolist.obj : errors.i options.h portable.h various.h zoo.h
  628. zoolist.obj : zoofns.h zooio.h zoomem.h
  629. zoopack.obj : errors.i options.h portable.h various.h
  630. zoopack.obj : zoo.h zoofns.h zooio.h
  631. SHAR_EOF
  632. chmod 0644 descrip.mms ||
  633. echo 'restore of descrip.mms failed'
  634. Wc_c="`wc -c < 'descrip.mms'`"
  635. test 4173 -eq "$Wc_c" ||
  636.     echo 'descrip.mms: original size 4173, current size' "$Wc_c"
  637. fi
  638. # ============= encode.c ==============
  639. if test -f 'encode.c' -a X"$1" != X"-c"; then
  640.     echo 'x - skipping encode.c (File already exists)'
  641. else
  642. echo 'x - extracting encode.c (Text)'
  643. sed 's/^X//' << 'SHAR_EOF' > 'encode.c' &&
  644. /*$Source: /usr/home/dhesi/zoo/RCS/encode.c,v $*/
  645. /*$Id: encode.c,v 1.41 91/07/09 01:39:47 dhesi Exp $*/
  646. X
  647. /*
  648. Adapted from "ar" archiver written by Haruhiko Okumura.
  649. */
  650. X
  651. #include "options.h"
  652. #include "zoo.h"
  653. #include "ar.h"
  654. #include "lzh.h"
  655. X
  656. extern void prterror();
  657. extern char *out_buf_adr;
  658. X
  659. #include <assert.h>
  660. X
  661. #ifdef ANSI_HDRS
  662. # include <stdlib.h>
  663. # include <string.h>
  664. #endif
  665. X
  666. #include "errors.i"
  667. X
  668. FILE *lzh_infile;
  669. FILE *lzh_outfile;
  670. X
  671. /*
  672. sliding dictionary with percolating update
  673. */
  674. X
  675. #define PERCOLATE  1
  676. #define NIL        0
  677. #define MAX_HASH_VAL (3 * DICSIZ + (DICSIZ / 512 + 1) * UCHAR_MAX)
  678. X
  679. typedef short node;
  680. X
  681. static uchar *text, *childcount;
  682. static node pos, matchpos, avail,
  683. X    *position, *parent, *prev, *next = NULL;
  684. static int remainder, matchlen;
  685. X
  686. #if MAXMATCH <= (UCHAR_MAX + 1)
  687. X    static uchar *level;
  688. # define T_LEVEL  uchar *
  689. #else
  690. X    static ushort *level;
  691. # define T_LEVEL  ushort *
  692. #endif
  693. X
  694. static void allocate_memory()
  695. {
  696. X    if (next != NULL) return;
  697. X    /* text = (uchar *) malloc(DICSIZ * 2 + MAXMATCH); */
  698. X    text = (uchar *) out_buf_adr; /* reuse I/O buffer used elsewhere */
  699. X    level      = (T_LEVEL) malloc((DICSIZ + UCHAR_MAX + 1) * sizeof(*level));
  700. X    childcount = (uchar *)malloc((DICSIZ + UCHAR_MAX + 1) * sizeof(*childcount));
  701. #ifdef PERCOLATE
  702. X      position = (node *) malloc((DICSIZ + UCHAR_MAX + 1) * sizeof(*position));
  703. #else
  704. X      position = (node *) malloc(DICSIZ * sizeof(*position));
  705. #endif
  706. X    parent     = (node *) malloc(DICSIZ * 2 * sizeof(*parent));
  707. X    prev       = (node *) malloc(DICSIZ * 2 * sizeof(*prev));
  708. X    next       = (node *) malloc((MAX_HASH_VAL + 1) * sizeof(*next));
  709. X    if (next == NULL) prterror('f', no_memory);
  710. }
  711. X
  712. static void init_slide()
  713. {
  714. X    node i;
  715. X
  716. X    for (i = DICSIZ; i <= DICSIZ + UCHAR_MAX; i++) {
  717. X        level[i] = 1;
  718. #ifdef PERCOLATE
  719. X            position[i] = NIL;  /* sentinel */
  720. #endif
  721. X    }
  722. X    for (i = DICSIZ; i < DICSIZ * 2; i++) parent[i] = NIL;
  723. X    avail = 1;
  724. X    for (i = 1; i < DICSIZ - 1; i++) next[i] = i + 1;
  725. X    next[DICSIZ - 1] = NIL;
  726. X    for (i = DICSIZ * 2; i <= MAX_HASH_VAL; i++) next[i] = NIL;
  727. }
  728. X
  729. #define HASH(p, c) ((p) + ((c) << (DICBIT - 9)) + DICSIZ * 2)
  730. X
  731. static node child(q, c)
  732. node q;
  733. uchar c;
  734. X    /* q's child for character c (NIL if not found) */
  735. {
  736. X    node r;
  737. X
  738. X    r = next[HASH(q, c)];
  739. X    parent[NIL] = q;  /* sentinel */
  740. X    while (parent[r] != q) r = next[r];
  741. X    return r;
  742. }
  743. X
  744. static void makechild(q, c, r)
  745. node q;
  746. uchar c;
  747. node r;
  748. X    /* Let r be q's child for character c. */
  749. {
  750. X    node h, t;
  751. X
  752. X    h = HASH(q, c);
  753. X    t = next[h];  next[h] = r;  next[r] = t;
  754. X    prev[t] = r;  prev[r] = h;
  755. X    parent[r] = q;  childcount[q]++;
  756. }
  757. X
  758. void split(old)
  759. node old;
  760. {
  761. X    node new, t;
  762. X
  763. X    new = avail;  avail = next[new];  childcount[new] = 0;
  764. X    t = prev[old];  prev[new] = t;  next[t] = new;
  765. X    t = next[old];  next[new] = t;  prev[t] = new;
  766. X    parent[new] = parent[old];
  767. X    level[new] = matchlen;
  768. X    position[new] = pos;
  769. X    makechild(new, text[matchpos + matchlen], old);
  770. X    makechild(new, text[pos + matchlen], pos);
  771. }
  772. X
  773. static void insert_node()
  774. {
  775. X    node q, r, j, t;
  776. X    uchar c, *t1, *t2;
  777. X
  778. X    if (matchlen >= 4) {
  779. X        matchlen--;
  780. X        r = (matchpos + 1) | DICSIZ;
  781. X        while ((q = parent[r]) == NIL) r = next[r];
  782. X        while (level[q] >= matchlen) {
  783. X            r = q;  q = parent[q];
  784. X        }
  785. #ifdef PERCOLATE
  786. X            t = q;
  787. X            while (position[t] < 0) {
  788. X                position[t] = pos;  t = parent[t];
  789. X            }
  790. X            if (t < DICSIZ) position[t] = pos | PERC_FLAG;
  791. #else
  792. X            t = q;
  793. X            while (t < DICSIZ) {
  794. X                position[t] = pos;  t = parent[t];
  795. X            }
  796. #endif
  797. X    } else {
  798. X        q = text[pos] + DICSIZ;  c = text[pos + 1];
  799. X        if ((r = child(q, c)) == NIL) {
  800. X            makechild(q, c, pos);  matchlen = 1;
  801. X            return;
  802. X        }
  803. X        matchlen = 2;
  804. X    }
  805. X    for ( ; ; ) {
  806. X        if (r >= DICSIZ) {
  807. X            j = MAXMATCH;  matchpos = r;
  808. X        } else {
  809. X            j = level[r];
  810. X            matchpos = position[r] & ~PERC_FLAG;
  811. X        }
  812. X        if (matchpos >= pos) matchpos -= DICSIZ;
  813. X        t1 = &text[pos + matchlen];  t2 = &text[matchpos + matchlen];
  814. X        while (matchlen < j) {
  815. X            if (*t1 != *t2) {  split(r);  return;  }
  816. X            matchlen++;  t1++;  t2++;
  817. X        }
  818. X        if (matchlen >= MAXMATCH) break;
  819. X        position[r] = pos;
  820. X        q = r;
  821. X        if ((r = child(q, *t1)) == NIL) {
  822. X            makechild(q, *t1, pos);  return;
  823. X        }
  824. X        matchlen++;
  825. X    }
  826. X    t = prev[r];  prev[pos] = t;  next[t] = pos;
  827. X    t = next[r];  next[pos] = t;  prev[t] = pos;
  828. X    parent[pos] = q;  parent[r] = NIL;
  829. X    next[r] = pos;  /* special use of next[] */
  830. }
  831. X
  832. static void delete_node()
  833. {
  834. #ifdef PERCOLATE
  835. X        node q, r, s, t, u;
  836. #else
  837. X        node r, s, t, u;
  838. #endif
  839. X
  840. X    if (parent[pos] == NIL) return;
  841. X    r = prev[pos];  s = next[pos];
  842. X    next[r] = s;  prev[s] = r;
  843. X    r = parent[pos];  parent[pos] = NIL;
  844. X    if (r >= DICSIZ || --childcount[r] > 1) return;
  845. #ifdef PERCOLATE
  846. X        t = position[r] & ~PERC_FLAG;
  847. #else
  848. X        t = position[r];
  849. #endif
  850. X    if (t >= pos) t -= DICSIZ;
  851. #ifdef PERCOLATE
  852. X        s = t;  q = parent[r];
  853. X        while ((u = position[q]) & PERC_FLAG) {
  854. X            u &= ~PERC_FLAG;  if (u >= pos) u -= DICSIZ;
  855. X            if (u > s) s = u;
  856. X            position[q] = (s | DICSIZ);  q = parent[q];
  857. X        }
  858. X        if (q < DICSIZ) {
  859. X            if (u >= pos) u -= DICSIZ;
  860. X            if (u > s) s = u;
  861. X            position[q] = s | DICSIZ | PERC_FLAG;
  862. X        }
  863. #endif
  864. X    s = child(r, text[t + level[r]]);
  865. X    t = prev[s];  u = next[s];
  866. X    next[t] = u;  prev[u] = t;
  867. X    t = prev[r];  next[t] = s;  prev[s] = t;
  868. X    t = next[r];  prev[t] = s;  next[s] = t;
  869. X    parent[s] = parent[r];  parent[r] = NIL;
  870. X    next[r] = avail;  avail = r;
  871. }
  872. X
  873. static void get_next_match()
  874. {
  875. X    int n;
  876. X
  877. X    remainder--;
  878. X    if (++pos == DICSIZ * 2) {
  879. #ifdef CHECK_BREAK
  880. X        check_break();
  881. #endif
  882. X        (void) MOVE_LEFT((char *) &text[0], (char *) &text[DICSIZ], DICSIZ + MAXMATCH);
  883. X        n = fread_crc(&text[DICSIZ + MAXMATCH], DICSIZ, lzh_infile);
  884. X        remainder += n;  pos = DICSIZ;  
  885. #ifdef SHOW_DOTS
  886. X        (void) putc('.', stderr);
  887. X        (void) fflush(stderr);
  888. #endif
  889. X    }
  890. X    delete_node();  insert_node();
  891. }
  892. X
  893. /* read from infile, compress, write to outfile */
  894. void encode(infile, outfile)
  895. FILE *infile;
  896. FILE *outfile;
  897. {
  898. X    int lastmatchlen;
  899. X    node lastmatchpos;
  900. X
  901. X    /* make input/output files visible to other functions */
  902. X    lzh_infile = infile;
  903. X    lzh_outfile = outfile;
  904. X
  905. X    allocate_memory();  init_slide();  huf_encode_start();
  906. X    remainder = fread_crc(&text[DICSIZ], DICSIZ + MAXMATCH, lzh_infile);
  907. #ifdef SHOW_DOTS
  908. X    (void) putc('.', stderr);
  909. X    (void) fflush(stderr);
  910. #endif
  911. X    matchlen = 0;
  912. X    pos = DICSIZ;  insert_node();
  913. X    if (matchlen > remainder) matchlen = remainder;
  914. X    while (remainder > 0 && ! unpackable) {
  915. X        lastmatchlen = matchlen;  lastmatchpos = matchpos;
  916. X        get_next_match();
  917. X        if (matchlen > remainder) matchlen = remainder;
  918. X        if (matchlen > lastmatchlen || lastmatchlen < THRESHOLD) {
  919. #if 0
  920. X            d1log("%c", text[pos-1]);
  921. #endif
  922. X            output(text[pos - 1], 0);
  923. X        } else {
  924. #if 0
  925. X        (void) putc('.', stderr); (void) fflush(stderr);
  926. #endif
  927. X
  928. #if 0
  929. X            {
  930. X                int i; 
  931. X                d1log("\nlastmatchlen=%d, pos=%d, lastmatchpos=%d",
  932. X                            lastmatchlen, pos, lastmatchpos);
  933. X                d1log("\n[%d: ", (int) lastmatchlen);
  934. X                for (i = 0;  i < lastmatchlen;  i++)
  935. X                    d1log("%c", text[lastmatchpos + i]);
  936. X                d1log("]\n");
  937. X            }
  938. #endif
  939. X
  940. X            output((uint) (lastmatchlen + (UCHAR_MAX + 1 - THRESHOLD)),
  941. X                   (uint) ((pos - lastmatchpos - 2) & (DICSIZ - 1)));
  942. X            while (--lastmatchlen > 0) get_next_match();
  943. X            if (matchlen > remainder) matchlen = remainder;
  944. X        }
  945. X    }
  946. X    huf_encode_end();
  947. }
  948. X
  949. #ifdef NEED_MEMMOVE
  950. /* like memmove, but for moving stuff LEFT (downwards in memory) only!! */
  951. void move_left(dest, src, len)
  952. char *dest;
  953. char *src;
  954. int len;
  955. {
  956. X    while (len-- > 0)
  957. X        *dest++ = *src++;
  958. }
  959. #endif /* NEED_MEMMOVE */
  960. SHAR_EOF
  961. chmod 0644 encode.c ||
  962. echo 'restore of encode.c failed'
  963. Wc_c="`wc -c < 'encode.c'`"
  964. test 7292 -eq "$Wc_c" ||
  965.     echo 'encode.c: original size 7292, current size' "$Wc_c"
  966. fi
  967. # ============= errors.i ==============
  968. if test -f 'errors.i' -a X"$1" != X"-c"; then
  969.     echo 'x - skipping errors.i (File already exists)'
  970. else
  971. echo 'x - extracting errors.i (Text)'
  972. sed 's/^X//' << 'SHAR_EOF' > 'errors.i' &&
  973. /* @(#) errors.i 2.4 88/01/31 12:32:46 */
  974. X
  975. /*
  976. The contents of this file are hereby released to the public domain.
  977. X
  978. X                           -- Rahul Dhesi 1986/11/14
  979. */
  980. X
  981. /* defines all the errors as externs.  Declarations must be
  982. equivalent to those in prterror.c */
  983. X
  984. /* These declarations must be equivalent to those in prterror.c */
  985. extern char no_match[];
  986. extern char failed_consistency[];
  987. extern char invalid_header[];
  988. extern char internal_error[];
  989. extern char disk_full[];
  990. extern char bad_directory[];
  991. extern char no_memory[];
  992. extern char too_many_files[];
  993. extern char packfirst[];
  994. extern char garbled[];
  995. extern char start_ofs[];
  996. X
  997. #ifndef OOZ
  998. extern char wrong_version[];
  999. extern char cant_process[];
  1000. extern char option_ignored[];
  1001. extern char inv_option[];
  1002. extern char bad_crc[];
  1003. #endif
  1004. X
  1005. extern char could_not_open[];
  1006. X
  1007. SHAR_EOF
  1008. chmod 0644 errors.i ||
  1009. echo 'restore of errors.i failed'
  1010. Wc_c="`wc -c < 'errors.i'`"
  1011. test 825 -eq "$Wc_c" ||
  1012.     echo 'errors.i: original size 825, current size' "$Wc_c"
  1013. fi
  1014. # ============= file.fix ==============
  1015. if test -f 'file.fix' -a X"$1" != X"-c"; then
  1016.     echo 'x - skipping file.fix (File already exists)'
  1017. else
  1018. echo 'x - extracting file.fix (Text)'
  1019. sed 's/^X//' << 'SHAR_EOF' > 'file.fix' &&
  1020. X          Making the "file" command recognize zoo archives
  1021. X
  1022. Zoo archives have the following magic number:  Beginning at offset 20
  1023. decimal, there are four bytes with the values 0xdc, 0xa7, 0xc4, and
  1024. 0xfd.  (But if you call the first byte of a zoo archive byte 1, then
  1025. the magic bytes will be bytes 21 through 24.)
  1026. X
  1027. To make the "file" command identify zoo archives, changes can be made
  1028. as follows.
  1029. X
  1030. 4.3BSD:  See the context diff near the end of this document, suitable
  1031. for application with the "patch" utility, that works with the 4.3BSD 
  1032. "file" command on a VAX-11/785.  I don't know if this will also work 
  1033. under 4.2BSD or with any other implementation of the "file" command 
  1034. or on any other CPU.
  1035. X
  1036. System V Release 2 (as exemplified by Microport System V/AT):  At the
  1037. end of the file "/etc/magic", add the following line:
  1038. X
  1039. 20    long        0xfdc4a7dc    zoo archive
  1040. X
  1041. This should work on a little-endian machine, in which the long value
  1042. 0xfdc4a7dc is stored with the least-significant byte first.  For a big-
  1043. endian machine, you will probably need to replace it with 0xdca7c4fd.
  1044. This assumes that long occupies 4 bytes.  If not, use a data type name
  1045. that is exactly 4 bytes.
  1046. X
  1047. =====
  1048. Changes needed to make the 4.3BSD "file" command recognize zoo
  1049. archives.  Known to work on a VAX-11/785.
  1050. X
  1051. *** file.c.old    Thu Mar  6 19:34:29 1986
  1052. --- file.c    Sat Feb 21 19:28:52 1987
  1053. ***************
  1054. *** 172,181 ****
  1055. --- 172,187 ----
  1056. X      case 070707:
  1057. X          printf("cpio data\n");
  1058. X          return;
  1059. X      }
  1060. X  
  1061. +     if (buf[20] == (char) 0xdc && buf[21] == (char) 0xa7 && 
  1062. +                     buf[22] == (char) 0xc4 && buf[23] == (char) 0xfd) {
  1063. +         printf ("zoo archive\n");
  1064. +         return;
  1065. +     }
  1066. + 
  1067. X      if (buf[0] == '#' && buf[1] == '!' && shellscript(buf+2, &mbuf))
  1068. X          return;
  1069. X      if (buf[0] == '\037' && buf[1] == '\235') {
  1070. X          if (buf[2]&0x80)
  1071. X              printf("block ");
  1072. SHAR_EOF
  1073. chmod 0644 file.fix ||
  1074. echo 'restore of file.fix failed'
  1075. Wc_c="`wc -c < 'file.fix'`"
  1076. test 1814 -eq "$Wc_c" ||
  1077.     echo 'file.fix: original size 1814, current size' "$Wc_c"
  1078. fi
  1079. # ============= fiz.1 ==============
  1080. if test -f 'fiz.1' -a X"$1" != X"-c"; then
  1081.     echo 'x - skipping fiz.1 (File already exists)'
  1082. else
  1083. echo 'x - extracting fiz.1 (Text)'
  1084. sed 's/^X//' << 'SHAR_EOF' > 'fiz.1' &&
  1085. .\" @(#) fiz.1 1.2 88/01/31 23:22:04
  1086. .\"
  1087. .\" For formatting with nroff:
  1088. .\"   nroff -man fiz.1
  1089. .\"
  1090. .TH FIZ 1 "Jan 31, 1988"
  1091. .SH NAME
  1092. fiz \- analyze damaged zoo archive for data revovery
  1093. .SH SYNOPSIS
  1094. .I fiz
  1095. .RB archive[ .zoo ]
  1096. .SH DESCRIPTION
  1097. .I Fiz
  1098. is used to analyze damaged
  1099. .I zoo
  1100. archives and locate directory entries and file data in them.
  1101. The current version of 
  1102. .I fiz
  1103. is 2.0 and it is meant to be used in conjunction with
  1104. .I zoo
  1105. version 2.0.
  1106. .I Fiz
  1107. makes no assumptions about archive structure.  Instead, it simply
  1108. searches the entire subject archive for tag values
  1109. that mark the locations of directory entries and file data.
  1110. In a 
  1111. .I zoo
  1112. archive, a
  1113. .I directory entry
  1114. contains information about a stored file such as its name, whether 
  1115. compressed or not, and its timestamp.  The
  1116. .I file data
  1117. are the actual data for the archived file, and may be
  1118. either the original data, or the result of compressing the file.
  1119. .PP
  1120. For each directory entry found,
  1121. .I fiz
  1122. prints where in the archive it is located, the directory path and
  1123. filename(s) found in it, whether the directory entry appears
  1124. to be corrupted (indicated by [*CRC Error*]), and the value of
  1125. the pointer to the file data that is found in the directory entry.
  1126. For each block of file data found in the archive,
  1127. .I fiz
  1128. prints where in the archive the block begins.  In the case of
  1129. an undamaged archive, the pointer to file data found in
  1130. a directory entry will correspond to where
  1131. .I fiz
  1132. actually locates the data.  Here is some sample output from 
  1133. .I fiz:
  1134. .PP
  1135. .nf
  1136. ****************
  1137. X    2526: DIR  [changes] ==>   95
  1138. X    2587: DATA
  1139. ****************
  1140. X    3909: DIR  [copyrite] ==> 1478
  1141. X    3970: DATA
  1142. X    4769: DATA
  1143. ****************
  1144. .fi
  1145. .sp 1
  1146. In such output, 
  1147. .B DIR
  1148. indicates where 
  1149. .I fiz
  1150. found a directory entry in the archive, and
  1151. .B DATA
  1152. indicates where 
  1153. .I fiz
  1154. found file data in the archive.  Filenames located by
  1155. .I fiz
  1156. are enclosed in square brackets, and the notation
  1157. "==>   95" indicates that the directory entry found by
  1158. .I fiz
  1159. at position 2526 has a file data pointer to
  1160. position 95.  In actuality,
  1161. .I fiz
  1162. found file data at positions 2587, 3970, and
  1163. 4769.  Since 
  1164. .I fiz
  1165. found only two directory entries, and each directory entry corresponds
  1166. to one file, one of the file data positions is an artifact.
  1167. .PP
  1168. Once the locations of directory entries and file data are found, the
  1169. .B @
  1170. modifier to
  1171. .I "zoo's"
  1172. archive list and extract commands can be used and
  1173. the archive contents selectively listed or extracted,
  1174. skipping the damaged portion.  This is further described
  1175. in the documentation for
  1176. .I zoo(1).
  1177. .PP
  1178. In the above case, commands to try giving to 
  1179. .I zoo
  1180. might be
  1181. .B x@2526,2587
  1182. (extract beginning at position 2526, and get file data
  1183. from position 2587),
  1184. .B x@3090,3970
  1185. (extract at 3090, get data from 3970)
  1186. and
  1187. .B x@3909,4769
  1188. (extract at 3909, get data from 4769).  Once a correctly-matched
  1189. directory entry/file data pair is found,
  1190. .I zoo
  1191. will in most cases synchronize with and correctly extract all files
  1192. subsequently found in the archive.  Trial and error should allow
  1193. all undamaged files to be extracted.
  1194. Also note that self-extracting archives created using
  1195. .I sez
  1196. (the Self-Extracting
  1197. .I Zoo
  1198. utility for MS-DOS), which are normally executed on an MS-DOS
  1199. system for extraction, can
  1200. be extracted on non-MSDOS systems in a similar way.
  1201. .PP
  1202. .SH "SEE ALSO"
  1203. zoo(1)
  1204. .SH BUGS
  1205. Random byte patterns can occasionally be incorrectly recognized
  1206. as tag values.  This occurs very rarely, however, and trial
  1207. and error will usually permit all undamaged data to be
  1208. extracted.
  1209. .SH DIAGNOSTICS
  1210. .I Fiz
  1211. always exits with a status code of 0.
  1212. .SH "FUTURE DIRECTIONS"
  1213. Automation of data recovery from a damaged archive is potentially
  1214. achievable.  However, since damaged archives occur only rarely,
  1215. .I fiz
  1216. as it currently stands is unlikely to change much in the
  1217. near future.
  1218. .SH AUTHOR
  1219. Rahul Dhesi
  1220. SHAR_EOF
  1221. chmod 0644 fiz.1 ||
  1222. echo 'restore of fiz.1 failed'
  1223. Wc_c="`wc -c < 'fiz.1'`"
  1224. test 3849 -eq "$Wc_c" ||
  1225.     echo 'fiz.1: original size 3849, current size' "$Wc_c"
  1226. fi
  1227. # ============= fiz.c ==============
  1228. if test -f 'fiz.c' -a X"$1" != X"-c"; then
  1229.     echo 'x - skipping fiz.c (File already exists)'
  1230. else
  1231. echo 'x - extracting fiz.c (Text)'
  1232. sed 's/^X//' << 'SHAR_EOF' > 'fiz.c' &&
  1233. #ifndef LINT
  1234. static char sccsid[]="@(#) fiz.c 2.6 88/01/31 23:23:50";
  1235. #endif /* LINT */
  1236. X
  1237. /*
  1238. The contents of this file are hereby released to the public domain.
  1239. X
  1240. X                                   -- Rahul Dhesi 1987/02/06
  1241. */
  1242. X
  1243. /*
  1244. Searches for all directory entries in an archive and prints their
  1245. offsets.  Zoo 1.41 and later may then be asked to extract a specific
  1246. file by supplying the offset of the file.
  1247. */
  1248. X
  1249. #include "options.h"
  1250. #include "zooio.h"
  1251. #include "various.h"
  1252. #include "zoofns.h"
  1253. #include "portable.h"         /* I/O definitions */
  1254. #include "zoo.h"
  1255. X
  1256. void prtctrl ();
  1257. void prtch ();
  1258. X
  1259. main(argc,argv)
  1260. register int argc;
  1261. register char **argv;
  1262. {
  1263. X   char *zooname;          /* name of archive to be read */
  1264. X   ZOOFILE zoo_file;       /* the archive being examined opened for read */
  1265. X   int state;              /* to keep track of how much of tag seen */
  1266. X   int inch;               /* char just read from archive */
  1267. X
  1268. X   static char usage1[] = "Fiz 2.0 (1987/02/01) public domain Zoo archive repair utility by Rahul Dhesi\n";
  1269. X   static char usage2[] = "Usage:  fiz archive[.zoo]  (\"fiz -h\" for help)\n";
  1270. X
  1271. #ifdef SETBUF
  1272. /* set stdout to unbuffered */
  1273. setbuf (stdout, (char *) NULL);
  1274. #endif
  1275. X
  1276. X   if (argc < 2) {
  1277. X      printf("%s%s", usage1, usage2);
  1278. X      exit (1);
  1279. X   }
  1280. X
  1281. X   if (strcmp(argv[1],"-h") == 0)
  1282. X      goto givehelp;
  1283. X
  1284. X   zooname = argv[1];
  1285. X
  1286. X   /* Add default extension if none supplied */
  1287. X   {
  1288. X      char *p, *q;
  1289. X      p = zooname + strlen(zooname);         /* point to last char */
  1290. X      while (p != zooname && *p != EXT_CH)
  1291. X         --p;
  1292. X      /* either found EXT_CH or reached beginning of zooname */
  1293. X      if (*p != EXT_CH) {
  1294. X         q = malloc(strlen(zooname) + strlen(EXT_DFLT) + 2);
  1295. X         if (q == NULL) {
  1296. X            printf("Fiz:  Ran out of memory.\n");
  1297. X            exit(1);
  1298. X         }
  1299. X         strcpy(q, zooname);
  1300. X         strcat(q, EXT_DFLT);
  1301. X         zooname = q;
  1302. X      }
  1303. X   }
  1304. X
  1305. X   zoo_file = zooopen (zooname, Z_READ);
  1306. X   if (zoo_file == NOFILE) {
  1307. X      printf("Fiz:  FATAL:  Could not open %s.\n", zooname);
  1308. X      exit(1);
  1309. X   }
  1310. X
  1311. #ifdef DOUBLE_SECRET
  1312. X    { void oh_well(void); oh_well(); }
  1313. #endif
  1314. X
  1315. #define  NOSTATE  1
  1316. #define  HDR_1   0xdc
  1317. #define  HDR_2   0xa7
  1318. #define  HDR_3   0xc4
  1319. #define  HDR_4   0xfd
  1320. X
  1321. #define    DAT_1   '@'
  1322. #define    DAT_2   ')'
  1323. #define    DAT_3   '#'
  1324. #define    DAT_4   '('
  1325. X
  1326. /* finite state machine implemented here by hand */
  1327. X
  1328. X   state = NOSTATE;
  1329. X   while ((inch = zgetc(zoo_file)) != EOF) {
  1330. X      inch = inch & 0xff;
  1331. X      if (state == NOSTATE) {
  1332. X            if (inch == HDR_1)
  1333. X                state = HDR_1;
  1334. X            else if (inch == DAT_1)
  1335. X                state = DAT_1;
  1336. X        } else if (state == HDR_1 && inch == HDR_2)
  1337. X         state = HDR_2;
  1338. X      else if (state == HDR_2 && inch == HDR_3)
  1339. X         state = HDR_3;
  1340. X      else if (state == HDR_3 && inch == HDR_4)
  1341. X         state = HDR_4;
  1342. X        else if (state == DAT_1 && inch == DAT_2)
  1343. X            state = DAT_2;
  1344. X        else if (state == DAT_2 && inch == DAT_3)
  1345. X            state = DAT_3;
  1346. X        else if (state == DAT_3 && inch == DAT_4)
  1347. X            state = DAT_4;
  1348. X      else
  1349. X         state = NOSTATE;
  1350. X
  1351. X      if (state == HDR_4) {                                   /* found archive tag */
  1352. X         long save_pos;
  1353. X         struct direntry direntry;
  1354. X         save_pos = zootell(zoo_file);
  1355. X         zooseek(zoo_file, save_pos-4L, 0);                /* back to tag pos */
  1356. X         frd_dir(&direntry, zoo_file);                        /* read dir entry */
  1357. X         printf("****************\n");
  1358. X
  1359. X         printf ("%8lu: DIR ", save_pos-4L);
  1360. X
  1361. X         if (direntry.dirlen > 0) {
  1362. X            printf ("[");
  1363. X            prtctrl (direntry.dirname);
  1364. X            printf ("]");
  1365. X         }
  1366. X
  1367. X         printf(" [");
  1368. X         prtctrl (direntry.fname);
  1369. X         printf ("]");
  1370. X
  1371. X         if (direntry.namlen > 0) {
  1372. X            printf (" [");
  1373. X            prtctrl (direntry.lfname);
  1374. X            printf ("]");
  1375. X         }
  1376. X            printf (" ==> %4lu", direntry.offset);
  1377. X         if (direntry.dir_crc != 0)
  1378. X            printf (" [*bad CRC*]");
  1379. X         printf ("\n");
  1380. X         fseek (zoo_file, save_pos, 0);         /* try again from there */
  1381. X      } else if (state == DAT_4) {                /* file data */
  1382. X         printf ("%8lu: DATA\n", zootell(zoo_file) + 1);
  1383. X        }
  1384. X   }
  1385. exit (0);      /* don't fall through */
  1386. X
  1387. givehelp:
  1388. X
  1389. /*
  1390. vi macros:
  1391. to add printf:
  1392. :s/^.*$/printf("&\\n");/
  1393. To remove printf:
  1394. :s/^printf("\(.*\)\\n");/\1/
  1395. */
  1396. printf("Fiz is used to help you recover data from a damaged archive.  Fiz searches\n");
  1397. printf("the specified archive for directory entries and stored files, and prints the\n");
  1398. printf("position of each one found.  Each directory entry contains a number that\n");
  1399. printf("represents the location in the archive where the file is stored;  fiz also\n");
  1400. printf("prints this position.  All numbers printed are decimal numbers.\n\n");
  1401. X
  1402. printf("Use Zoo version 2.00 or higher to list or extract files in the damaged\n");
  1403. printf("archive starting at a position identified by fiz.  For example, you can\n");
  1404. printf("start extracting files from archive \"badarc.zoo\" at position 1098 with the\n");
  1405. printf("command:\n\n");
  1406. X
  1407. printf("     zoo x@1098 badarc\n\n");
  1408. X
  1409. printf("Zoo will ignore the first 1098 bytes of the damaged archive and you should be\n");
  1410. printf("able to recover the undamaged files from the rest of the archive.  You can\n");
  1411. printf("also manually specify where to look for the file data with a command like\n\n");
  1412. X
  1413. printf("     zoo x@1098,1153\n\n");
  1414. X
  1415. printf("which tells zoo to use the directory entry at position 1098, but to get the\n");
  1416. printf("actual file data from position 1153 (and not from where the directory entry\n");
  1417. printf("says the data ought to be).  See the manuals for fiz and zoo for more details.\n");
  1418. X
  1419. exit (0);
  1420. }
  1421. X
  1422. /*
  1423. prtctrl() prints a string with all unprintable characters converted
  1424. to printable form.  To avoid the program running astray trying to
  1425. print damaged data, no more than MAXPRT characters are printed.
  1426. Characters with the 8th bit set are printed preceded with ~.  Control
  1427. characters are printed preceded with ^.  Both ~ and ^ may preced
  1428. the character if a control character has the 8th bit set.
  1429. */
  1430. #define  MAXPRT      50
  1431. X
  1432. void prtctrl (str)
  1433. char *str;
  1434. {
  1435. X   unsigned int ch;
  1436. X   int count;
  1437. X   count = 0;
  1438. X
  1439. X   while (count < MAXPRT && *str != '\0') {
  1440. X      ch = (unsigned) *str;
  1441. X      prtch(ch);
  1442. X      str++;
  1443. X      count++;
  1444. X   }
  1445. }
  1446. X
  1447. /*
  1448. Does the actual character printing for prtctrl()
  1449. */
  1450. void prtch(ch)
  1451. unsigned int ch;
  1452. {
  1453. X   /* assumes ASCII character set */
  1454. X   if (ch < ' ') {                        /* ^@ through ^_ */
  1455. X      printf("^%c", ch + 0x40);
  1456. X   } else if (ch == 0x7f) {               /* DEL */
  1457. X      printf("^?");
  1458. X   } else if (ch > 0x7f) {                /* 8th bit set */
  1459. X      printf("~");                        /* .. so precede with ~ */
  1460. X      prtch(ch & 0x7f);                   /* slick recursive call */
  1461. X   } else
  1462. X      printf("%c", ch);                   /* plain char */
  1463. }
  1464. SHAR_EOF
  1465. chmod 0644 fiz.c ||
  1466. echo 'restore of fiz.c failed'
  1467. Wc_c="`wc -c < 'fiz.c'`"
  1468. test 6784 -eq "$Wc_c" ||
  1469.     echo 'fiz.c: original size 6784, current size' "$Wc_c"
  1470. fi
  1471. # ============= fiz.man ==============
  1472. if test -f 'fiz.man' -a X"$1" != X"-c"; then
  1473.     echo 'x - skipping fiz.man (File already exists)'
  1474. else
  1475. echo 'x - extracting fiz.man (Text)'
  1476. sed 's/^X//' << 'SHAR_EOF' > 'fiz.man' &&
  1477. X
  1478. X
  1479. X
  1480. FIZ(1)              **IX Programmer's Manual               FIZ(1)
  1481. X
  1482. X
  1483. X
  1484. NAME
  1485. X     fiz - analyze damaged zoo archive for data revovery
  1486. X
  1487. SYNOPSIS
  1488. X     fiz archive[.zoo]
  1489. X
  1490. DESCRIPTION
  1491. X     Fiz is used to analyze damaged zoo archives and locate
  1492. X     directory entries and file data in them.  The current ver-
  1493. X     sion of fiz is 2.0 and it is meant to be used in conjunction
  1494. X     with zoo version 2.0.  Fiz makes no assumptions about
  1495. X     archive structure.  Instead, it simply searches the entire
  1496. X     subject archive for tag values that mark the locations of
  1497. X     directory entries and file data.  In a zoo archive, a direc-
  1498. X     tory entry contains information about a stored file such as
  1499. X     its name, whether compressed or not, and its timestamp.  The
  1500. X     file data are the actual data for the archived file, and may
  1501. X     be either the original data, or the result of compressing
  1502. X     the file.
  1503. X
  1504. X     For each directory entry found, fiz prints where in the
  1505. X     archive it is located, the directory path and filename(s)
  1506. X     found in it, whether the directory entry appears to be cor-
  1507. X     rupted (indicated by [*CRC Error*]), and the value of the
  1508. X     pointer to the file data that is found in the directory
  1509. X     entry.  For each block of file data found in the archive,
  1510. X     fiz prints where in the archive the block begins.  In the
  1511. X     case of an undamaged archive, the pointer to file data found
  1512. X     in a directory entry will correspond to where fiz actually
  1513. X     locates the data.  Here is some sample output from fiz:
  1514. X
  1515. X     ****************
  1516. X         2526: DIR  [changes] ==>   95
  1517. X         2587: DATA
  1518. X     ****************
  1519. X         3909: DIR  [copyrite] ==> 1478
  1520. X         3970: DATA
  1521. X         4769: DATA
  1522. X     ****************
  1523. X
  1524. X     In such output, DIR indicates where fiz found a directory
  1525. X     entry in the archive, and DATA indicates where fiz found
  1526. X     file data in the archive.  Filenames located by fiz are
  1527. X     enclosed in square brackets, and the notation "==>   95"
  1528. X     indicates that the directory entry found by fiz at position
  1529. X     2526 has a file data pointer to position 95.  In actuality,
  1530. X     fiz found file data at positions 2587, 3970, and 4769.
  1531. X     Since fiz found only two directory entries, and each direc-
  1532. X     tory entry corresponds to one file, one of the file data
  1533. X     positions is an artifact.
  1534. X
  1535. X
  1536. X
  1537. X
  1538. X
  1539. Printed 2/7/88            Jan 31, 1988                          1
  1540. X
  1541. X
  1542. X
  1543. X
  1544. X
  1545. X
  1546. FIZ(1)              **IX Programmer's Manual               FIZ(1)
  1547. X
  1548. X
  1549. X
  1550. X     Once the locations of directory entries and file data are
  1551. X     found, the @ modifier to zoo's archive list and extract com-
  1552. X     mands can be used and the archive contents selectively
  1553. X     listed or extracted, skipping the damaged portion.  This is
  1554. X     further described in the documentation for zoo(1).
  1555. X
  1556. X     In the above case, commands to try giving to zoo might be
  1557. X     x@2526,2587 (extract beginning at position 2526, and get
  1558. X     file data from position 2587), x@3090,3970 (extract at 3090,
  1559. X     get data from 3970) and x@3909,4769 (extract at 3909, get
  1560. X     data from 4769).  Once a correctly-matched directory
  1561. X     entry/file data pair is found, zoo will in most cases syn-
  1562. X     chronize with and correctly extract all files subsequently
  1563. X     found in the archive.  Trial and error should allow all
  1564. X     undamaged files to be extracted.  Also note that self-
  1565. X     extracting archives created using sez (the Self-Extracting
  1566. X     Zoo utility for MS-DOS), which are normally executed on an
  1567. X     MS-DOS system for extraction, can be extracted on non-MSDOS
  1568. X     systems in a similar way.
  1569. X
  1570. SEE ALSO
  1571. X     zoo(1)
  1572. X
  1573. BUGS
  1574. X     Random byte patterns can occasionally be incorrectly recog-
  1575. X     nized as tag values.  This occurs very rarely, however, and
  1576. X     trial and error will usually permit all undamaged data to be
  1577. X     extracted.
  1578. X
  1579. DIAGNOSTICS
  1580. X     Fiz always exits with a status code of 0.
  1581. X
  1582. FUTURE DIRECTIONS
  1583. X     Automation of data recovery from a damaged archive is poten-
  1584. X     tially achievable.  However, since damaged archives occur
  1585. X     only rarely, fiz as it currently stands is unlikely to
  1586. X     change much in the near future.
  1587. X
  1588. AUTHOR
  1589. X     Rahul Dhesi
  1590. X
  1591. X
  1592. X
  1593. X
  1594. X
  1595. X
  1596. X
  1597. X
  1598. X
  1599. X
  1600. X
  1601. X
  1602. X
  1603. X
  1604. X
  1605. Printed 2/7/88            Jan 31, 1988                          2
  1606. X
  1607. X
  1608. X
  1609. SHAR_EOF
  1610. chmod 0644 fiz.man ||
  1611. echo 'restore of fiz.man failed'
  1612. Wc_c="`wc -c < 'fiz.man'`"
  1613. test 4227 -eq "$Wc_c" ||
  1614.     echo 'fiz.man: original size 4227, current size' "$Wc_c"
  1615. fi
  1616. true || echo 'restore of generic.c failed'
  1617. echo End of part 2, continue with part 3
  1618. exit 0
  1619.