home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / compress / zoosrc20.zoo / portable.c < prev    next >
C/C++ Source or Header  |  1989-07-25  |  22KB  |  715 lines
  1. #ifndef LINT
  2. /* @(#) portable.c 2.24 88/08/24 01:22:06 */
  3. static char sccsid[]="@(#) portable.c 2.24 88/08/24 01:22:06";
  4. #endif /* LINT */
  5.  
  6. #include "options.h"
  7. /*
  8. Copyright (C) 1986, 1987 Rahul Dhesi -- All rights reserved
  9. (C) Copyright 1988 Rahul Dhesi -- All rights reserved
  10. */
  11. /**********************
  12. portable.c contains functions needed to make Zoo portable to various
  13. implementations of C.
  14.  
  15. Note:  Provided a 2's complement machine is used, all functions in
  16. this file are themselves machine-independent and need not be changed
  17. when implementing Zoo on a different machine.  Some code will choke
  18. on 1's complement machines--I think.  
  19.  
  20. For machine-dependent declarations see files "machine.h" and "options.h". 
  21.  
  22. For machine-dependent functions see file "machine.c"
  23. */
  24.  
  25. #include "zooio.h"
  26.  
  27. #include "various.h"
  28. #include "zoofns.h"
  29.  
  30. #include "machine.h"
  31. #include "zoo.h"
  32. #include "debug.h"
  33. #include "assert.h"
  34.  
  35. #ifdef NEEDCTYP
  36. #include <ctype.h>              /* for tolower() */
  37. #endif
  38.  
  39. #include "portable.h"
  40.  
  41. #ifdef TRACE_IO
  42. extern int verbose;
  43. #endif
  44.  
  45. /* Functions defined for use within this file only.  */
  46. #ifdef LINT_ARGS
  47. long to_long (BYTE[]);
  48. int to_int (BYTE[]);
  49. void b_to_zooh(struct zoo_header *, BYTE[]);
  50. void b_to_dir(struct direntry *, BYTE[]);
  51. int dir_to_b(BYTE[], struct direntry *);
  52. void zooh_to_b(BYTE[], struct zoo_header *);
  53. void splitlong(BYTE[], long);
  54. void splitint(BYTE[], int);
  55. #else
  56. long to_long ();
  57. int to_int ();
  58. void b_to_zooh();
  59. void b_to_dir();
  60. int dir_to_b();
  61. void zooh_to_b();
  62. void splitlong();
  63. void splitint();
  64. #endif
  65.  
  66. #ifdef TRACE_IO
  67. void show_h PARMS ((struct zoo_header *));
  68. void show_dir PARMS ((struct direntry *));
  69. #endif /* TRACE_IO */
  70.  
  71. extern unsigned int crccode;
  72.  
  73. /************************************************************************/
  74. /* I/O functions */
  75. /************************************************************************/
  76.  
  77. /* some functions get defined only if they aren't already macros */
  78.  
  79. #ifndef zooread
  80. int zooread (file, buffer, count)
  81. ZOOFILE file; char *buffer; int count;
  82. { return (fread (buffer, 1, count, file)); }
  83. #endif /* zooread */
  84.  
  85. #ifndef FIZ
  86. #ifndef zoowrite
  87. int zoowrite (file, buffer, count)
  88. ZOOFILE file; char *buffer; int count;
  89. { 
  90.     if (file == NULLFILE)
  91.        return (count);
  92.     else
  93.         return (fwrite (buffer, 1, count, file)); 
  94. }
  95. #endif /* zoowrite */
  96.  
  97. ZOOFILE zoocreate (fname)
  98. char *fname;
  99. { return ((ZOOFILE) fopen (fname, Z_NEW)); }
  100.  
  101. /* truncates a file -- can be empty */
  102. /* force use of argument to keep Turbo C happy */
  103. int zootrunc (file) ZOOFILE file; {return ((int) file); }
  104. #endif /* FIZ */
  105.  
  106. #ifndef zooseek
  107. long zooseek (file, offset, whence)
  108. ZOOFILE file; long offset; int whence;
  109. { return (fseek (file, offset, whence)); }
  110. #endif /* zooseek */
  111.  
  112. ZOOFILE zooopen (fname, option)
  113. char *fname; char *option;
  114. { return ((ZOOFILE) fopen (fname, option)); }
  115.  
  116. #ifndef zootell
  117. long zootell (file)
  118. ZOOFILE file;
  119. { return ftell (file); }
  120. #endif /* zootell */
  121.  
  122. int zooclose (file)
  123. ZOOFILE file;
  124. { return fclose (file); }
  125.  
  126. /************************************************************************/
  127. /*** Following are functions that make up for various implementations ***/
  128. /*** of C not having certain library routines.                        ***/
  129. /************************************************************************/
  130.  
  131. #ifndef FIZ
  132. #ifndef STRLWR
  133. /**********************
  134. strlwr() converts a string to lowercase and returns a pointer to the string
  135. */
  136. char *strlwr (str)
  137. char *str;
  138. {
  139.    register char *s;
  140.    s = str;
  141.    while (*s != '\0') {
  142.       *s = toascii(*s);
  143.       if (isupper(*s))
  144.          *s = tolower(*s);
  145.       s++;
  146.    }
  147.    return (str);
  148. }
  149. #endif /* STRLWR */
  150.  
  151. /**********************
  152. strcmpi() compares strings just like strcmp() but it does it without regard to
  153. case.
  154. */
  155. int strcmpi (s1, s2)
  156. register char *s1, *s2;
  157. {
  158.    for ( ; tolower(*s1) == tolower(*s2);  s1++, s2++)
  159.       if (*s1 == '\0')
  160.          return(0);
  161.    return(tolower(*s1) - tolower(*s2));
  162. }
  163.  
  164. #ifndef MEMSET
  165. /**********************
  166. memset() exists in Microsoft C and UNIX System V but not in Xenix.  It sets
  167. the first "cnt" bytes of "dest" to the character "c" and returns a pointer to
  168. "dest".
  169. */
  170. char * memset (dest, c, cnt)
  171. char *dest;
  172. int c;
  173. unsigned cnt;
  174. {
  175.    register unsigned i;
  176.    for (i = 0; i < cnt; i++) {
  177.       *(dest + i) = c;
  178.    }
  179.    return (dest);
  180. }
  181. #endif /* MEMSET */
  182.  
  183. #ifndef FPUTCHAR
  184. /**********************
  185. fputchar() writes a character to stdout.  It is identical to putchar
  186. but is a function, not a macro.
  187. */
  188. int fputchar (c)
  189. int c;
  190. {
  191.    return (fputc(c, stdout));
  192. }
  193. #endif /* FPUTCHAR */
  194. #endif /* FIZ */
  195.  
  196. /***********************************************************************/
  197. /*** Following are declarations and functions that are written in a  ***/
  198. /*** machine-independent way but they implement machine-dependent    ***/
  199. /*** activities                                                      ***/
  200. /***********************************************************************/
  201.  
  202. #ifndef TURBOC
  203. /**********************
  204. to_long() converts four consecutive bytes, in order of increasing
  205. significance, to a long integer.  It is used to make Zoo independent of the
  206. byte order of the system.  
  207. */
  208. long to_long(data)
  209. BYTE data[];
  210. {
  211.    return (long) ((unsigned long) data[0] | ((unsigned long) data[1] << 8) |
  212.          ((unsigned long) data[2] << 16) | ((unsigned long) data[3] << 24));
  213. }
  214.  
  215. #ifndef FIZ
  216. /********************
  217. splitlong() converts a long integer to four consecutive BYTEs in order
  218. of increasing significance.
  219. */
  220. void splitlong(bytes, bigword)
  221. BYTE bytes[];
  222. long bigword;
  223. {
  224.    int i;
  225.    for (i = 0; i < 4; i++) {
  226.       bytes[i] = bigword & 0xff;
  227.       bigword = (unsigned long) bigword >> 8;
  228.    }
  229. }     
  230. #endif /* FIZ */
  231.  
  232. /*******************
  233. splitint() converts an integer to two consecutive BYTEs in order
  234. of increasing significance.
  235. */
  236. void splitint(bytes, word)
  237. BYTE bytes[];
  238. int word;
  239. {
  240.    bytes[0] = word & 0xff;
  241.    word = (unsigned int) word >> 8;
  242.    bytes[1] = word & 0xff;
  243. }
  244.  
  245. /**********************
  246. to_int() converts two consecutive bytes, in order of increasing
  247. significance, to an integer, in a machine-independent manner
  248. */
  249. int to_int(data)
  250. BYTE data[];
  251. {
  252.    return (int) ((unsigned int) data[0] | ((unsigned int) data[1] << 8));
  253. }
  254.  
  255. #else /* else of ifndef TURBOC */
  256.  
  257. long to_long(data)
  258. BYTE data[];
  259. {
  260.    return ( * (long *) data );
  261. }
  262.  
  263. #ifndef FIZ
  264. /********************
  265. splitlong() converts a long integer to four consecutive BYTEs in order
  266. of increasing significance.
  267. */
  268. void splitlong(bytes, bigword)
  269. BYTE bytes[];
  270. long bigword;
  271. {
  272.    * (long *) bytes = bigword;
  273. }
  274. #endif /* FIZ */
  275.  
  276. /*******************
  277. splitint() converts an integer to two consecutive BYTEs in order
  278. of increasing significance.
  279. */
  280. void splitint(bytes, word)
  281. BYTE bytes[];
  282. int word;
  283. {
  284.    * (int *) bytes = word;
  285. }
  286.  
  287. /**********************
  288. to_int() converts two consecutive bytes, in order of increasing
  289. significance, to an integer.
  290. */
  291. int to_int(data)
  292. BYTE data[];
  293. {
  294.    return (*(int *) data);
  295. }
  296.  
  297. #endif /* ifndef TURBOC .. else ... */
  298.  
  299. #ifndef FIZ
  300. /**********************
  301. Function frd_zooh() reads the header of a Zoo archive in a machine-
  302. independent manner, from a ZOOFILE.
  303. */
  304. int frd_zooh(zoo_header, zoo_file)
  305. struct zoo_header *zoo_header;
  306. ZOOFILE zoo_file;
  307. {
  308.    int status;
  309.    BYTE bytes[SIZ_ZOOH];         /* canonical header representation */
  310. #ifdef TRACE_IO
  311.    if (verbose) {
  312.       printf("At file position [%8lx] ", ftell(zoo_file));
  313.    }
  314. #endif
  315.    status = zooread (zoo_file, (char *) bytes, SIZ_ZOOH);
  316.    b_to_zooh (zoo_header, bytes);   /* convert array to structure */
  317. #ifdef TRACE_IO
  318.    if (verbose) {
  319.       printf("frd_zooh: reading\n");
  320.       show_h(zoo_header);
  321.    }
  322. #endif
  323.    if (status < MINZOOHSIZ)
  324.       return (-1);
  325.    else
  326.       return (0);
  327. }
  328. #endif /* FIZ */
  329.  
  330. /**********************
  331. Function frd_dir() reads a directory entry in a machine-independent manner,
  332. from a ZOOFILE.
  333. */
  334. int frd_dir(direntry, zoo_file) 
  335. struct direntry *direntry; 
  336. ZOOFILE zoo_file;
  337. {
  338.    int status;
  339.    BYTE bytes[MAXDIRSIZE];    /* big enough to hold variable part too */
  340.  
  341.    /* To simplify things, we read the maximum possible size of the
  342.    directory entry including the variable size and discard what is not
  343.    needed */
  344. #ifdef TRACE_IO
  345.    if (verbose) {
  346.       printf("At file position [%8lx] ", ftell(zoo_file));
  347.    }
  348. #endif
  349.    status = zooread (zoo_file, (char *) bytes, MAXDIRSIZE);
  350.    if (status < SIZ_DIR)
  351.       return (-1);
  352.    b_to_dir (direntry, bytes);
  353. #ifdef TRACE_IO
  354.    if (verbose) {
  355.       printf("frd_dir: reading\n");
  356.       show_dir(direntry);
  357.    }
  358. #endif
  359.    return (0);
  360. }
  361.  
  362. #ifndef FIZ
  363. /***********************
  364. Function fwr_dir() writes a directory entry in a machine-independent manner
  365. to a ZOOFILE.  Return value is -1 on error, else 0.
  366. */
  367. int fwr_dir(direntry, zoo_file)
  368. struct direntry *direntry;
  369. ZOOFILE zoo_file;
  370. {
  371.    int size;
  372.    BYTE bytes[MAXDIRSIZE];
  373.    assert (direntry->type <= 2);
  374.    size = dir_to_b (bytes, direntry);
  375. #ifdef TRACE_IO
  376.    if (verbose) {
  377.       printf("At file position [%8lx] ", ftell(zoo_file));
  378.       printf("fwr_dir: writing\n");
  379.       show_dir(direntry);
  380.    }
  381. #endif
  382.  
  383.    if (zoowrite (zoo_file, (char *) bytes, size) != size)
  384.       return (-1);
  385.    else
  386.       return (0);
  387. }
  388.  
  389. /***********************
  390. Function fwr_zooh() writes an archive header in a machine-independent manner
  391. to a ZOOFILE.  Return value is -1 if error else 0.
  392. */
  393. int fwr_zooh(zoo_header, zoo_file)
  394. struct zoo_header *zoo_header;
  395. ZOOFILE zoo_file;
  396. {
  397.    BYTE bytes[SIZ_ZOOH];    /* was SIZ_DIR -- probably a typo */
  398.     int hsize;                    /* how much to write -- depends on header type */
  399.     hsize = MINZOOHSIZ;                /* in case it's an old type 0 header */
  400.     if (zoo_header->type > 0)        /* but if it's a newer header... */
  401.         hsize = SIZ_ZOOH;                /* ...size of new type 1 header */
  402.    zooh_to_b (bytes, zoo_header);
  403.    if (zoowrite (zoo_file, (char *) bytes, hsize) != hsize)
  404.       return (-1);
  405.    else
  406.       return (0);
  407. }
  408.  
  409. /***********************
  410. b_to_zooh() converts an array of BYTE to a zoo_header structure.
  411. */
  412. void b_to_zooh (zoo_header, bytes)
  413. struct zoo_header *zoo_header;
  414. BYTE bytes[];
  415. {
  416.    int i;
  417.    for (i = 0; i < SIZ_TEXT; i++)                     /* copy text */
  418.       zoo_header->text[i] = bytes[TEXT_I + i];
  419.    zoo_header->zoo_tag = to_long(&bytes[ZTAG_I]);     /* copy zoo_tag */
  420.    zoo_header->zoo_start = to_long(&bytes[ZST_I]);    /* copy zoo_start */
  421.    zoo_header->zoo_minus = to_long(&bytes[ZSTM_I]);
  422.    zoo_header->major_ver = bytes[MAJV_I];          /* copy versions */
  423.    zoo_header->minor_ver = bytes[MINV_I];
  424.     /* default is no archive comment and a header type of 0 */
  425.     zoo_header->type = 0;
  426.     zoo_header->acmt_pos = 0L;
  427.     zoo_header->acmt_len = 0;
  428.     zoo_header->vdata        = 0;
  429.     if (zoo_header->zoo_start != FIXED_OFFSET) {            /* if newer header */
  430.         zoo_header->type = bytes[HTYPE_I];
  431.         zoo_header->acmt_pos = to_long(&bytes[ACMTPOS_I]);
  432.         zoo_header->acmt_len = to_int(&bytes[ACMTLEN_I]);
  433.         zoo_header->vdata        = bytes[HVDATA_I];
  434.     }
  435. }
  436.  
  437. /***********************
  438. zooh_to_b() converts a zoo_header structure to an array of BYTE.
  439. */
  440. void zooh_to_b (bytes, zoo_header)
  441. struct zoo_header *zoo_header;
  442. BYTE bytes[];
  443. {
  444.    int i;
  445.    for (i = 0; i < SIZ_TEXT; i++)                     /* copy text */
  446.       bytes[TEXT_I + i] = zoo_header->text[i];
  447.    splitlong (&bytes[ZTAG_I], zoo_header->zoo_tag);
  448.    splitlong (&bytes[ZST_I], zoo_header->zoo_start);
  449.    splitlong (&bytes[ZSTM_I], zoo_header->zoo_minus);
  450.    bytes[MAJV_I] =   zoo_header->major_ver;           /* copy versions */ 
  451.    bytes[MINV_I] =   zoo_header->minor_ver;
  452.     bytes[HTYPE_I] =    zoo_header->type;                        /* header type */
  453.     if (zoo_header->type > 0) {
  454.         splitlong (&bytes[ACMTPOS_I], zoo_header->acmt_pos);    /* comment posn */
  455.         splitint (&bytes[ACMTLEN_I], zoo_header->acmt_len);    /* comment len */
  456.         bytes[HVDATA_I] = zoo_header->vdata;                    /* version data */
  457.     }
  458. } /* zooh_to_b() */
  459.  
  460. /************************
  461. dir_to_b() converts a directory entry structure to an array of BYTE.
  462. */
  463. int dir_to_b (bytes, direntry)
  464. struct direntry *direntry;
  465. BYTE bytes[];
  466. {
  467.    int i;
  468.    int cursize;
  469.    int fixsize;
  470.     int totalsize;
  471.    splitlong(&bytes[DTAG_I], direntry->zoo_tag);
  472.    bytes[DTYP_I] = direntry->type ;
  473.    bytes[PKM_I] = direntry->packing_method ;
  474.    splitlong(&bytes[NXT_I], direntry->next);
  475.    splitlong(&bytes[OFS_I], direntry->offset);
  476.    splitint(&bytes[DAT_I], direntry->date);
  477.    splitint(&bytes[TIM_I], direntry->time);
  478.    splitint(&bytes[CRC_I], direntry->file_crc);
  479.    splitlong(&bytes[ORGS_I], direntry->org_size);
  480.    splitlong(&bytes[SIZNOW_I], direntry->size_now);
  481.    bytes[DMAJ_I] = direntry->major_ver;
  482.    bytes[DMIN_I] = direntry->minor_ver;
  483.    bytes[DEL_I] = direntry->deleted;
  484.    bytes[STRUC_I] = direntry->struc;
  485.    splitlong(&bytes[CMT_I], direntry->comment);
  486.    splitint(&bytes[CMTSIZ_I], direntry->cmt_size);
  487.    for (i = 0; i < FNM_SIZ; i++)
  488.       bytes[FNAME_I + i] = direntry->fname[i];
  489.    bytes[TZ_I] = NO_TZ;       /* assume unknown */
  490.    bytes[NAMLEN_I] = 0;
  491.    bytes[DIRLEN_I] = 0;
  492.  
  493.    cursize = SIZ_DIR;         /* to count size of directory */
  494.    fixsize = SIZ_DIR;         /* size of fixed part */
  495.    assert (direntry->type <= 2);
  496.    if (direntry->type == 2) { /* handle stuff relevant to type 2 */
  497.       cursize = SIZ_DIRL;
  498.       fixsize = SIZ_DIRL;
  499.       bytes[TZ_I] = direntry->tz;
  500.       assert(direntry->namlen < 256 && direntry->namlen >= 0);
  501.         cursize += 2;        /* space for namlen and dirlen */
  502.       if (direntry->namlen != 0) {
  503.          bytes[NAMLEN_I] = direntry->namlen;
  504.          for (i = 0; i < direntry->namlen; i++)
  505.             bytes[LFNAME_I+i] = direntry->lfname[i];
  506.          cursize += direntry->namlen;
  507.       }
  508.       assert(direntry->dirlen < 256 && direntry->dirlen >= 0);
  509.       if (direntry->dirlen != 0) {
  510.          bytes[DIRLEN_I] = direntry->dirlen;
  511.          for (i = 0; i < direntry->dirlen; i++)
  512.             bytes[cursize+i] = direntry->dirname[i];
  513.          cursize += direntry->dirlen;
  514.       }
  515.         /* Can't store system id if no namlen & dirlen...BUG!...now fixed.
  516.             Fortunately, system_id was always 0 so far so it probably
  517.             got interpreted as namlen=0 and dirlen=0 (2 bytes) */
  518.       splitint(&bytes[cursize], direntry->system_id);
  519.         cursize += 2;
  520.         bytes[cursize] = direntry->fattr & 0xff;                              /* byte 0 */
  521.         splitint(&bytes[cursize+1], (int) (direntry->fattr >> 8));  /* 1 & 2 */
  522.         cursize += 3;
  523.         bytes[cursize] = (direntry->vflag & 0xff);            /* version flag */
  524.         splitint(&bytes[cursize+1], direntry->version_no);    /* version number */
  525.         cursize += 3;
  526.    }
  527.  
  528.    splitint(&bytes[VARDIRLEN_I], direntry->var_dir_len);
  529.    assert(cursize == 
  530.             ((bytes[DIRLEN_I] > 0 || bytes[NAMLEN_I] > 0) ? 2 : 0) +
  531.             fixsize + bytes[DIRLEN_I] + bytes[NAMLEN_I]
  532.          );
  533.  
  534.     /* total size of dir entry is size of fixed part + size of var. part */
  535.     totalsize = fixsize + direntry->var_dir_len;
  536.  
  537.    /* Do CRC assuming CRC field is zero, and stuff CRC into field. */
  538.    splitint(&bytes[DCRC_I], 0);           /* fill with zeroes */
  539.    crccode = 0;
  540.    /* avoid mixing pointers to signed and unsigned char */
  541.    addbfcrc((char *) bytes, totalsize);         /* update CRC */
  542.    splitint(&bytes[DCRC_I], crccode);
  543.  
  544.    /* return total length of directory entry */
  545.    return (totalsize);
  546.  
  547. } /* dir_to_b() */
  548. #endif /* FIZ */
  549.  
  550. /* b_to_dir() converts bytes to directory entry structure.  The CRC of the
  551. directory bytes, if any, is checked and a zero or nonzero value is returned
  552. in direntry->dir_crc according as the check is good or bad */
  553.  
  554. void b_to_dir(direntry, bytes)
  555. struct direntry *direntry;
  556. BYTE bytes[];
  557. {
  558.    int i;
  559.     int sysid_offs;            /* temp variable */
  560.    unsigned int savecrc;
  561.    direntry->zoo_tag = to_long(&bytes[DTAG_I]);
  562.    direntry->type = bytes[DTYP_I];
  563.    direntry->packing_method = bytes[PKM_I];
  564.    direntry->next = to_long(&bytes[NXT_I]);
  565.    direntry->offset = to_long(&bytes[OFS_I]);
  566.    direntry->date = to_int(&bytes[DAT_I]);
  567.    direntry->time = to_int(&bytes[TIM_I]);
  568.    direntry->file_crc = to_int(&bytes[CRC_I]);
  569.    direntry->org_size = to_long(&bytes[ORGS_I]);
  570.    direntry->size_now = to_long(&bytes[SIZNOW_I]);
  571.    direntry->major_ver = bytes[DMAJ_I];
  572.    direntry->minor_ver = bytes[DMIN_I];
  573.    direntry->deleted = bytes[DEL_I];
  574.    direntry->struc = bytes[STRUC_I];
  575.    direntry->comment = to_long(&bytes[CMT_I]);
  576.    direntry->cmt_size = to_int(&bytes[CMTSIZ_I]);
  577.     /* for now, versions not implemented */
  578.     direntry->vflag = 0;
  579.     direntry->version_no = 0;
  580.    for (i = 0; i < FNM_SIZ; i++)
  581.       direntry->fname[i] = bytes[FNAME_I + i];
  582.  
  583.    /* start by assuming variable part is zero bytes */
  584.    direntry->var_dir_len = direntry->dir_crc    = 0;
  585.    direntry->namlen      = direntry->dirlen     = 0;
  586.    direntry->lfname[0]   = direntry->dirname[0] = '\0';
  587.    direntry->tz = NO_TZ;               /* assume unknown */
  588.    direntry->system_id = SYSID_NIX;    /* default system_id if not present */
  589.     direntry->fattr = NO_FATTR;            /* assume none */
  590.  
  591.    assert (direntry->type <= 2);
  592.    if (direntry->type == 2) {
  593.       direntry->var_dir_len = to_int(&bytes[VARDIRLEN_I]);
  594.       assert(direntry->var_dir_len <= MAXDIRSIZE);
  595.       if (direntry->var_dir_len > MAXDIRSIZE)
  596.          direntry->var_dir_len = MAXDIRSIZE;
  597.       direntry->tz = bytes[TZ_I];   
  598.       if (direntry->var_dir_len > 0)
  599.          direntry->namlen = bytes[NAMLEN_I];
  600.       if (direntry->var_dir_len > 1)
  601.          direntry->dirlen = bytes[DIRLEN_I];
  602.       for (i = 0; i < direntry->namlen; i++)
  603.          direntry->lfname[i] = bytes[LFNAME_I + i];
  604.       for (i = 0; i < direntry->dirlen; i++)
  605.          direntry->dirname[i] = bytes[DIRNAME_I + direntry->namlen + i];
  606.         sysid_offs = DIRNAME_I + direntry->namlen + i;    /* offset of system id */
  607.         if (direntry->var_dir_len > direntry->namlen + direntry->dirlen + 2) {
  608.             direntry->system_id = to_int(&bytes[sysid_offs]);
  609.         }
  610.         if (direntry->var_dir_len > direntry->namlen + direntry->dirlen + 4) {
  611.             direntry->fattr = ((unsigned long) bytes[sysid_offs + 2]) |
  612.                                     ((unsigned long) bytes[sysid_offs + 3] << 8) |
  613.                                     ((unsigned long) bytes[sysid_offs + 4] << 16);
  614.         }
  615.         if (direntry->var_dir_len > direntry->namlen + direntry->dirlen + 7) {
  616.             direntry->vflag = bytes[sysid_offs + 5];
  617.             direntry->version_no = to_int(&bytes[sysid_offs + 6]);
  618.         }
  619.       /* do CRC calculation */
  620.       savecrc = (unsigned int) to_int(&bytes[DCRC_I]);
  621.       crccode = 0;
  622.       splitint(&bytes[DCRC_I], 0);
  623.       addbfcrc((char *) bytes, SIZ_DIRL + direntry->var_dir_len);
  624.       direntry->dir_crc = crccode - savecrc;
  625.    }
  626. }
  627.  
  628. #ifdef FILTER
  629. #define TWOBYTES    2    /* better than literal 2;  figure out why */
  630.  
  631. /* rdint() reads two bytes from standard input in archive order */
  632. int rdint (val)
  633. unsigned int *val;
  634. {
  635.     BYTE bytes[TWOBYTES];
  636.     if (zooread (STDIN, bytes, TWOBYTES) == TWOBYTES) {
  637.         *val = to_int(bytes);
  638.         return (0);
  639.     } else
  640.         return (1);
  641. }
  642.  
  643. /* wrint() writes an unsigned int to standard output in archive order */
  644. int wrint (val)
  645. unsigned int val;
  646. {
  647.     BYTE bytes[TWOBYTES];
  648.     splitint (bytes, val);
  649.     if (zoowrite (STDOUT, bytes, TWOBYTES) == TWOBYTES)
  650.         return (0);
  651.     else
  652.         return (1);
  653. }
  654. #endif /* FILTER */
  655.  
  656. #ifdef TRACE_IO
  657. /* dump contents of archive header */
  658. void show_h (zoo_header)
  659. struct zoo_header *zoo_header;
  660. {
  661.    int i;
  662.    printf ("Header text:\n");
  663.    for (i = 0; i < SIZ_TEXT;  i++) {      /* ASSUMES ASCII TEXT */
  664.       int c;
  665.       c = zoo_header->text[i];
  666.       if (c >= ' ' && c < 0x7f)
  667.          putchar (c);
  668.       else {
  669.          putchar ('^');
  670.          putchar (i & 0x40);
  671.       }
  672.    }
  673.    putchar('\n');
  674.    printf ("zoo_tag = [%8lx] zoo_start = [%8lx] zoo_minus = [%8lx]\n",
  675.             zoo_header->zoo_tag, zoo_header->zoo_start, 
  676.             zoo_header->zoo_minus);
  677.    printf ("major_ver.minor_ver = [%d.%d]\n",
  678.             zoo_header->major_ver, zoo_header->minor_ver);
  679.     if (zoo_header->zoo_start != FIXED_OFFSET) {
  680.         printf ("type = [%d] ", zoo_header->type);
  681.         printf ("acmt_pos = [%8lx] acmt_len = [%4x] vdata = [%2x]",
  682.                     zoo_header->acmt_pos, zoo_header->acmt_len, zoo_header->vdata);
  683.         printf ("\n");
  684.     }
  685.    printf ("---------\n");
  686. }
  687.  
  688. /* dump contents of directory entry */
  689. void show_dir (direntry)
  690. struct direntry *direntry;
  691. {
  692.    printf ("Directory entry for file [%s][%s]:\n",
  693.             direntry->fname, direntry->lfname);
  694.    printf ("tag = [%8lx] type = [%d] PM = [%d] Next = [%8lx] Offset = [%8lx]\n",
  695.             direntry->zoo_tag, (int) direntry->type, 
  696.             (int) direntry->packing_method, direntry->next, 
  697.             direntry->offset);
  698.    printf ("Orig size = [%ld] Size now = [%ld] dmaj_v.dmin_v = [%d.%d]\n",
  699.          direntry->org_size, direntry->size_now,
  700.          (int) direntry->major_ver, (int) direntry->minor_ver);
  701.    printf ("Struc = [%d] DEL = [%d] comment_offset = [%8lx] cmt_size = [%d]\n",
  702.          (int) direntry->struc, (int) direntry->deleted, direntry->comment,
  703.          direntry->cmt_size);
  704.    printf ("var_dir_len = [%d] TZ = [%d] dir_crc = [%4x]\n",
  705.             direntry->var_dir_len, (int) direntry->tz, direntry->dir_crc);
  706.    printf ("system_id = [%d]  dirlen = [%d]  namlen = [%d] fattr=[%24lx]\n", 
  707.         direntry->system_id, direntry->dirlen, direntry->namlen, direntry->fattr);
  708.     printf ("vflag = [%4x] version_no = [%4x]\n",
  709.                 direntry->vflag, direntry->version_no);
  710.    if (direntry->dirlen > 0)
  711.       printf ("dirname = [%s]\n", direntry->dirname);
  712.    printf ("---------\n");
  713. }
  714. #endif   /* TRACE_IO */
  715.