home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / unix / unpit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-03  |  9.1 KB  |  421 lines
  1. /*
  2.  
  3.         unpit - Macintosh PackIt file unpacker
  4.  
  5.         Version 2, for PackIt II
  6.  
  7. This program will unpack a Macintosh PackIt file into separate files.  The
  8. data fork of a PackIt file contains both the data and resource forks of the
  9. packed files.  The program will unpack each Mac file into separate .data,
  10. .rsrc., and .info files that can be downloaded to a Mac using macput.
  11.  
  12. The program syntax is much like macput/macget:
  13.  
  14.     unpit [-rdu] packit-file.data
  15.  
  16. The  -r and -d flags will cause only the resource and data forks to be
  17. written.  The -u flag will cause only the data fork to be written and
  18. to have carriage return characters changed to Unix newline characters.
  19.  
  20. Some of the program is borrowed from the macput.c/macget.c programs.
  21.  
  22.     Author: Allan G. Weber, (Weber%Brand@USC-ECL)        
  23.     Date:   September 30, 1985
  24.     Revised: January 24, 1986 - added CRC checking
  25.          March 25, 1986 - support compressed mode of PackIt II,
  26.                   check for illegal Unix file names
  27.  
  28. */
  29.  
  30. /* There is some confusion as to what to do with the "inited" flag in the
  31.    finder info bytes that are in the header of each file in the packit file.
  32.    If this flag bit is copied to the .info file, it seems to confuse
  33.    MacTerminal into placing the file icons in the upper left corner of the
  34.    window on top of each other.  Setting this bit to zero in the .info file
  35.    seems to fix that problem but may cause others.  I haven't been able to
  36.    find any .info files that have this flag set so making it zero may be OK.
  37.    Anyway, MacTerminal seems to set the flag when it create the file on the
  38.    Mac.  The "#define INITED_BUG" can be used to try both settings.  */
  39.  
  40. /*
  41. Format of a Packit file:
  42.  
  43. Repeat the following sequence for each file in the Packit file:
  44.  
  45.     4 byte identifier ("PMag" = not compressed, "Pma4" = compressed)
  46.     variable length compression data (if compressed file)
  47.     92 byte header (see struct pit_header below) *
  48.     2 bytes CRC number *
  49.     data fork (length from header) *
  50.     resource fork (length from header) *
  51.     2 bytes CRC number *
  52.  
  53. Last file is followed by the 4 byte Ascii string, "Pend", and then the EOF.
  54.  
  55. * these are in compressed form if compression is on for the file
  56.  
  57. */
  58.  
  59. #define DEBUG
  60.  
  61. #include <stdio.h>
  62.  
  63. typedef char byte;
  64. typedef short word;
  65.  
  66. struct pit_header {    /* Packit file header (92 bytes)
  67.     byte nlen;    /* number of characters in packed file name */
  68.     byte name[63];    /* name of packed file */
  69.     byte type[4];    /* file type */
  70.     byte auth[4];    /* file creator */
  71.     word flags;    /* file flags (?) */
  72.     word lock;    /* unknown */
  73.     long dlen;    /* number of bytes in data fork */
  74.     long rlen;    /* number of bytes in resource fork */
  75.     long ctim;    /* file creation time */
  76.     long mtim;    /* file modified time */
  77. };
  78.  
  79. #define HDRBYTES  92
  80. #define INFOBYTES 128
  81.  
  82. #define BYTEMASK 0xff
  83.  
  84. #define H_NAMELEN 63
  85.  
  86. #define H_NLENOFF 0
  87. #define H_NAMEOFF 1
  88. #define H_TYPEOFF 64
  89. #define H_AUTHOFF 68
  90. #define    H_LOCKOFF 70
  91. #define H_FLAGOFF 72
  92. #define H_DLENOFF 76
  93. #define H_RLENOFF 80
  94. #define H_CTIMOFF 84
  95. #define H_MTIMOFF 88
  96.  
  97. #define I_NAMELEN 69    /* H_NAMELEN + strlen(".info") + 1 */
  98.  
  99. /* The following are copied out of macput.c/macget.c */
  100. #define I_NLENOFF 1
  101. #define I_NAMEOFF 2
  102. /* 65 <-> 80 is the FInfo structure */
  103. #define I_TYPEOFF 65
  104. #define I_AUTHOFF 69
  105. #define I_FLAGOFF 73
  106. #define I_LOCKOFF 81
  107. #define I_DLENOFF 83
  108. #define I_RLENOFF 87
  109. #define I_CTIMOFF 91
  110. #define I_MTIMOFF 95
  111.  
  112. #define INITED_BUG
  113. #define INITED_OFF    I_FLAGOFF    /* offset to byte with Inited flag */
  114. #define INITED_MASK    (~1)        /* mask to '&' with byte to reset it */
  115.  
  116. #define TEXT 0
  117. #define DATA 1
  118. #define RSRC 2
  119. #define FULL 3
  120.  
  121. struct node {
  122.     int flag, byte;
  123.     struct node *one, *zero;
  124. } nodelist[512], *nodeptr, *read_tree();    /* 512 should be big enough */
  125.  
  126. char f_info[I_NAMELEN];
  127. char f_data[I_NAMELEN];
  128. char f_rsrc[I_NAMELEN];
  129.  
  130. char hdr[HDRBYTES];
  131. char info[INFOBYTES];
  132. char text[H_NAMELEN+1];
  133.  
  134. int mode, txtmode;
  135. int datalen, rsrclen;
  136. int decode, bit;
  137.  
  138. char usage[] = "usage: unpit [-rdu] filename\n";
  139.  
  140. main(ac, av)
  141. int ac;
  142. char **av;
  143. {
  144.     char temp[4], *name;
  145.     int crc, data_crc;
  146.  
  147.     mode = FULL;
  148.     name = "";
  149.     ac--; av++;
  150.     while (ac) {
  151.         if (av[0][0] == '-') {
  152.             switch (av[0][1]) {
  153.             case 'r':
  154.                 mode = RSRC;
  155.                 break;
  156.             case 'd':
  157.                 mode = DATA;
  158.                 break;
  159.             case 'u':
  160.                 mode = TEXT;
  161.                 break;
  162.             case '\0':
  163.                 name = av[0];
  164.                 break;
  165.             default:
  166.                 fprintf(stderr, usage);
  167.                 exit(1);
  168.             }
  169.         }
  170.         else {
  171.             name = av[0];
  172.         }
  173.         ac--; av++;
  174.     }
  175.  
  176.     if (strlen(name) == 0) {
  177.         fprintf(stderr, usage);
  178.         exit(1);
  179.     }
  180.     else {
  181.         if (freopen(name,"r",stdin) == NULL) {
  182.             fprintf(stderr,"Can't open input file \"%s\"\n",name);
  183.             exit(1);
  184.         }
  185.     }
  186.  
  187.     while (1) {
  188.         fread(temp, 1, 4, stdin);
  189.         if (strncmp(temp, "PMag", 4) == 0 ||
  190.             strncmp(temp, "PMa4", 4) == 0) {
  191.             if (temp[3] == '4') {
  192.                 nodeptr = nodelist;
  193.                 read_tree();
  194.                 decode = 1;
  195.             }
  196.             else
  197.                 decode = 0;
  198.             data_crc = read_hdr();
  199.             crc = getcrc();
  200.             if (crc != data_crc) {
  201.                 fprintf(stderr, "File header CRC mismatch\n");
  202.                 exit(1);
  203.             }
  204.             txtmode = (mode == TEXT);
  205.             data_crc = write_file(f_data, datalen, 0);
  206.             txtmode = 0;
  207.             data_crc = write_file(f_rsrc, rsrclen, data_crc);
  208.             crc = getcrc();
  209.             if (crc != data_crc) {
  210.                 fprintf(stderr,
  211.                     "File data/rsrc CRC mismatch\n");
  212.                 exit(1);
  213.             }
  214.             decode = 0;
  215.             bit = 0;    /* flush unused bits */
  216.         }
  217.         else if (strncmp(temp, "PEnd", 4) == 0)
  218.             break;
  219.         else {
  220.             fprintf(stderr, "Unrecognized Packit format\n");
  221.             exit(1);
  222.         }
  223.     }
  224. }
  225.  
  226. /* This routine recursively reads the compression decoding data.
  227.    It appears to be Huffman compression. */
  228. struct node *read_tree()
  229. {
  230.     struct node *np;
  231.     np = nodeptr++;
  232.     if (getbit() == 1) {
  233.         np->flag = 1;
  234.         np->byte = getbyte();
  235.     }
  236.     else {
  237.         np->flag = 0;
  238.         np->zero = read_tree();
  239.         np->one  = read_tree();
  240.     }
  241.     return(np);
  242. }
  243.  
  244. read_hdr()
  245. {
  246.     long get4();
  247.     register int i, n, crc;
  248.     FILE *fp;
  249.     char *np;
  250.  
  251.     for (n = 0; n < INFOBYTES; n++)
  252.         info[n] = '\0';
  253.     for (n = 0; n < HDRBYTES; n++)
  254.         hdr[n] = getbyte();
  255.     crc = 0;
  256.     for (n = 0; n < HDRBYTES; n++) {
  257.         crc = crc ^ ((int)hdr[n] << 8);
  258.         for (i = 0; i < 8; i++)
  259.             if (crc & 0x8000)
  260.                 crc = (crc << 1) ^ 0x1021;
  261.             else
  262.                 crc <<= 1;
  263.     }
  264.  
  265.     n = hdr[H_NLENOFF] & BYTEMASK;
  266.     if (n > H_NAMELEN)
  267.         n = H_NAMELEN;
  268.     info[I_NLENOFF] = n;
  269.     copy(info + I_NAMEOFF, hdr + H_NAMEOFF, n);
  270.     strncpy(text, hdr + H_NAMEOFF, n);
  271.     text[n] = '\0';
  272.     datalen = get4(hdr + H_DLENOFF);
  273.     rsrclen = get4(hdr + H_RLENOFF);
  274. #ifdef DEBUG
  275.     printf("name=\"%s\", type=%4.4s, author=%4.4s, data=%ld, rsrc=%ld\n",
  276.     text, hdr + H_TYPEOFF, hdr + H_AUTHOFF, datalen, rsrclen);
  277. #endif
  278.     /* check for illegal Unix characters in file name */
  279.     for (np = text; *np; np++)
  280.         if (*np <= ' ' || *np == '/' || *np > '~')
  281.             *np = '_';
  282.  
  283.     if (mode == FULL) {
  284.         sprintf(f_info, "%s.info", text);
  285.         sprintf(f_data, "%s.data", text);
  286.         sprintf(f_rsrc, "%s.rsrc", text);
  287.  
  288.         copy(info + I_TYPEOFF, hdr + H_TYPEOFF, 4);
  289.         copy(info + I_AUTHOFF, hdr + H_AUTHOFF, 4);
  290.         copy(info + I_FLAGOFF, hdr + H_FLAGOFF, 2);
  291. #ifdef INITED_BUG
  292.         info[INITED_OFF] &= INITED_MASK;    /* reset init bit */
  293. #endif
  294.         copy(info + I_LOCKOFF, hdr + H_LOCKOFF, 2);
  295.         copy(info + I_DLENOFF, hdr + H_DLENOFF, 4);
  296.         copy(info + I_RLENOFF, hdr + H_RLENOFF, 4);
  297.         copy(info + I_CTIMOFF, hdr + H_CTIMOFF, 4);
  298.         copy(info + I_MTIMOFF, hdr + H_MTIMOFF, 4);
  299.  
  300.         fp = fopen(f_info, "w");
  301.         if (fp == NULL) {
  302.             perror(f_info);
  303.             exit(1);
  304.         }
  305.         fwrite(info, 1, INFOBYTES, fp);
  306.         fclose(fp);
  307.     }
  308.     else if (mode == RSRC) {
  309.             sprintf(f_data, "/dev/null");
  310.             sprintf(f_rsrc, "%s.rsrc", text);
  311.     }
  312.     else {
  313.             sprintf(f_data, "%s", text);
  314.             sprintf(f_rsrc, "/dev/null");
  315.     }
  316.     return(crc & 0xffff);
  317. }
  318.  
  319. write_file(fname, bytes, crc)
  320. char *fname;
  321. long bytes;
  322. register int crc;
  323. {
  324.     register int b, i;
  325.     FILE *outf;
  326.  
  327.     outf = fopen(fname, "w");
  328.     if (outf == NULL) {
  329.         perror(fname);
  330.         exit(1);
  331.     }
  332.     while (bytes-- > 0) {
  333.         b = getbyte();
  334.         crc = crc ^ (b << 8);
  335.         for (i = 0; i < 8; i++)
  336.             if (crc & 0x8000)
  337.                 crc = (crc << 1) ^ 0x1021;
  338.             else
  339.                 crc <<= 1;
  340.         if (txtmode && (b & BYTEMASK) == '\r')
  341.             b = '\n';
  342.         putc(b, outf);
  343.     }
  344.     fclose(outf);
  345.     return(crc & 0xffff);
  346. }
  347.  
  348. long
  349. get4(bp)
  350. char *bp;
  351. {
  352.     register int i;
  353.     long value = 0;
  354.  
  355.     for (i = 0; i < 4; i++) {
  356.         value <<= 8;
  357.         value |= (*bp & BYTEMASK);
  358.         bp++;
  359.     }
  360.     return(value);
  361. }
  362.  
  363. getcrc()
  364. {
  365.     int value;
  366.     value = getbyte() & BYTEMASK;
  367.     return( value << 8 | (getbyte() & BYTEMASK) );
  368. }
  369.  
  370. copy(p1, p2, n)
  371. char *p1, *p2;
  372. int n;
  373. {
  374.     while (n-- > 0)
  375.         *p1++ = *p2++;
  376. }
  377.  
  378.  
  379. /* This routine returns the next bit in the input stream (MSB first) */
  380. getbit()
  381. {
  382.     static char b;
  383.     if (bit == 0) {
  384.         b = getchar() & 0xff;
  385.         bit = 8;
  386.     }
  387.     bit--;
  388.     return((b >> bit) & 1);
  389. }
  390.  
  391. /* This routine returns the next 8 bits.  If decoding is on, it finds the
  392. byte in the decoding tree based on the bits from the input stream.  If
  393. decoding is not on, it either gets it directly from the input stream or
  394. puts it together from 8 calls to getbit(), depending on whether or not we
  395. are currently on a byte boundary
  396. */
  397. getbyte()
  398. {
  399.     register struct node *np;
  400.     register int i, b;
  401.     if (decode) {
  402.         np = nodelist;
  403.         while (np->flag == 0)
  404.             np = (getbit()) ? np->one : np->zero;
  405.         b = np->byte;
  406.     }
  407.     else {
  408.         if (bit == 0)    /* on byte boundary? */
  409.             b = getc(stdin) & 0xff;
  410.         else {        /* no, put a byte together */
  411.             b = 0;
  412.             for (i = 8; i > 0; i--) {
  413.                 b = (b << 1) + getbit();
  414.             }
  415.         }
  416.     }
  417.     return(b);
  418. }
  419.  
  420.  
  421.