home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / com / utils / trn / src / unship.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-22  |  12.2 KB  |  408 lines
  1. /* unship.c -- for unpacking ship files via trn */
  2. /* Based on ship.c -- Not copyrighted 1991 Mark Adler. */
  3. /* Modified by Wayne Davison, but still not copyrighted. */
  4.  
  5. #include "EXTERN.h"
  6. #include "common.h"
  7. #include "respond.h"
  8. #include "decode.h"
  9.  
  10. typedef unsigned long ulg;    /* 32-bit unsigned integer */
  11.  
  12. /* Function prototypes */
  13.  
  14. static void decode_line ANSI((unsigned char *));
  15. static void err ANSI((int));
  16.  
  17. /* Globals for ship() */
  18. ulg ccnt;        /* count of bytes read or written */
  19. ulg crc;        /* CRC register */
  20. ulg buf4;        /* four byte buffer */
  21. int bcnt;        /* buffer count */
  22.  
  23. unsigned int decb;    /* bit buffer for decode */
  24. unsigned int decn;    /* number of bits in decb */
  25.  
  26. bool fast;        /* true for arithmetic coding, else base 85 */
  27. bool overwrite = 1;    /* should we overwrite existing files? */
  28.  
  29. /* Errors */
  30. #define SE_FORM 1
  31. #define SE_CONT 2
  32. #define SE_CRC 3
  33. #define SE_OVER 4
  34. #define SE_FULL 5
  35. char *errors[] = {
  36.   /* 1 */ "Invalid ship format.",
  37.   /* 2 */ "This piece is out of sequence.",
  38.   /* 3 */ "CRC check failed.",
  39.   /* 4 */ "File already exists.",
  40.   /* 5 */ "Error writing file.",
  41. };
  42.  
  43. /* Set of 86 characters used for the base 85 digits (last one not used), and
  44.    the 86 character arithmetic coding.    Selected to be part of both the ASCII
  45.    printable characters, and the common EBCDIC printable characters whose
  46.    ASCII translations are universal. */
  47. unsigned char safe[] = {
  48.     '{','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',
  49.     '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?','@',
  50.     'A','B','C','D','E','F','G','H','I','J','K','L','M',
  51.     'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_',
  52.     'a','b','c','d','e','f','g','h','i','j','k','l','m',
  53.     'n','o','p','q','r','s','t','u','v','w','x','y','z','}'};
  54.  
  55. #define LOWSZ (sizeof(safe)-64)        /* low set size for fast coding */
  56.  
  57. /* Special replacement pairs--if first of each pair is received, it is
  58.    treated like the second member of the pair.    You're probably
  59.    wondering why.  The first pair is for compatibility with an
  60.    earlier version of ship that used ! for the base 85 zero digit.
  61.    However, there exist ASCII-EBCDIC translation tables that don't
  62.    know about exclamation marks.  The second set has mysterious
  63.    historical origins that are best left unspoken ... */
  64. unsigned char aliases[] = {'!','{','|','+',0};
  65.  
  66. /* Inverse of safe[], filled in by unship_init() */
  67. unsigned char invsafe[256];
  68.  
  69. /* Table of CRC-32's of all single byte values (made by makecrc.c) */
  70. ulg crctab[] = {
  71.   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  72.   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  73.   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  74.   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  75.   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  76.   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  77.   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  78.   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  79.   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  80.   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  81.   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  82.   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  83.   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  84.   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  85.   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  86.   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  87.   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  88.   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  89.   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  90.   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  91.   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  92.   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  93.   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  94.   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  95.   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  96.   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  97.   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  98.   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  99.   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  100.   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  101.   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  102.   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  103.   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  104.   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  105.   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  106.   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  107.   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  108.   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  109.   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  110.   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  111.   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  112.   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  113.   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  114.   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  115.   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  116.   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  117.   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  118.   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  119.   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  120.   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  121.   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  122.   0x2d02ef8dL
  123. };
  124.  
  125. /* Macro to update the CRC shift register one byte at a time */
  126. #define CRC(c,b) (crctab[((int)(c)^(int)(b))&0xff]^((c)>>8))
  127.  
  128. /* cputc(d,x)--like putc(d,f), but delays four bytes and computes a CRC.
  129.    x is a cfile *, and d is expected to be an ulg. */
  130. #define cputf(fp) (int)(crc=CRC(crc,buf4),putc((int)buf4&0xff,fp),ccnt++)
  131. #define cputc(d,fp) (bcnt!=4?bcnt++:cputf(fp),buf4=(buf4>>8)+((ulg)(d)<<24))
  132.  
  133. /* Build invsafe[], the inverse of safe[]. */
  134. void
  135. unship_init()
  136. {
  137.   int i;
  138.  
  139.   for (i = 0; i < 256; i++)
  140.     invsafe[i] = 127;
  141.   for (i = 0; i < sizeof(safe); i++)
  142.     invsafe[safe[i]] = (char)i;
  143.   for (i = 0; aliases[i]; i += 2)
  144.     invsafe[aliases[i]] = invsafe[aliases[i + 1]];
  145. }
  146.  
  147. int
  148. unship(in)
  149. FILE *in;
  150. {
  151.   int b;        /* state of line loop */
  152.   char l[LBUFLEN];    /* line buffer on input */
  153.   int counter; /** OS2-patch **/
  154.   char *p;        /* modifies line buffer */
  155.   char *q;        /* scans continuation line */
  156.  
  157.   /* Loop on the latest article's lines */
  158.   b = 2;                /* not in body yet */
  159.   while (1)                /* return on end of last file */
  160.   {
  161.     /* Get next line from file */
  162.     if (fgets(l, LBUFLEN, in) == Nullch)
  163.       break;
  164.  
  165. /*** OS2: AAAAAAAAHHHHHHHHHHHH, ..... another problem with \r (^M)... **/
  166.  
  167.     for (counter = 0; counter <= strlen(l); counter++)
  168.         if ((l[counter] == '\r') &&
  169.             (l[counter+1] == '\n')) {
  170.             for (; l[counter] != '\0'; counter++)
  171.                 l[counter] = l[counter+1];
  172.         }
  173.  
  174.     /* Strip control characters and leading blank space, if any */
  175.     for (q = l; *q && *q <= ' ' && *q != '\n'; q++)
  176.       ;
  177.     for (p = l; *q; q++)
  178.       if (*q >= ' ' || *q == '\n')
  179.     *p++ = *q;
  180.     *p = 0;
  181.  
  182.     /* Based on current state, end or start on terminator.  States are:
  183.      b == 0:  at start of body or body terminator line
  184.      b == 1:  in middle of body line
  185.      b == 2:  at start of non-body line
  186.      b == 3:  in middle of non-body line
  187.      b == 4:  at information line
  188.     */
  189.     switch (b)
  190.     {
  191.     case 0:
  192.       if ((!fast && strEQ(l, "$\n")) ||
  193.       (fast && strEQ(l, "$ f\n")))
  194.       {
  195.     b = 4;
  196.     break;
  197.       }
  198.       /* fall through to case 1 */
  199.     case 1:
  200.       decode_line((unsigned char *)l);
  201.       b = l[strlen(l) - 1] != '\n';
  202.       break;
  203.     case 2:
  204.       if (strEQ(l, "$\n") || strEQ(l, "$ f\n"))
  205.       {
  206.     fast = l[1] == ' ';
  207.     b = 4;
  208.     break;
  209.       }
  210.       /* fall through to case 3 */
  211.     case 3:
  212.       b = l[strlen(l)-1] == '\n' ? 2 : 3;
  213.       break;
  214.     case 4:
  215.       /* Possible information lines are ship, more, cont, and end */
  216.       if (l[b = strlen(l) - 1] != '\n')
  217.       {
  218.     err(SE_FORM);
  219.     decode_end();
  220.     return -1;
  221.       }
  222.       l[b] = 0;
  223.       if (strnEQ(l, "ship ", 5))
  224.       {
  225.     /* get name, open new output file */
  226.     if (decode_fp != Nullfp)
  227.       decode_end();            /* outputs an "incomplete" warning */
  228.     if (strEQ(l + 5, "-"))
  229.       strcpy(decode_fname, "unnamed");
  230.     else
  231.       strcpy(decode_fname, l + 5);
  232.     sprintf(decode_dest, "%s/%s", extractdest, decode_fname);
  233.     printf("Decoding: %s\n", decode_fname);
  234. #ifndef VMS    /* shouldn't have explicit version #, so VMS won't overwrite */
  235.     if (!overwrite && (decode_fp = fos2open(decode_dest, "r")) != Nullfp)
  236.     {
  237.       fclose(decode_fp);
  238.       decode_fp = Nullfp;
  239.       err(SE_OVER);
  240.       return -1;
  241.     }
  242. #endif /* !VMS */
  243.     if ((decode_fp = fos2open(decode_dest, FOPEN_WB)) == Nullfp)
  244.     {
  245.       err(SE_FULL);
  246.       return -1;
  247.     }
  248.     crc = 0xffffffffL;        /* preload CRC register */
  249.     buf4 = 0;            /* empty fifo (for output) */
  250.     bcnt = 0;            /* fifo is empty (output) */
  251.     b = decb = decn = 0;
  252.     ccnt = 0;
  253.       }
  254.       else if (strEQ(l, "more"))
  255.       {
  256.     /* check if currently writing */
  257.     if (decode_fp == Nullfp)
  258.     {
  259.       err(SE_FORM);
  260.       return -1;
  261.     }
  262.     b = 2;
  263.       }
  264.       else if (strnEQ(l, "cont ", 5))
  265.       {
  266.     /* check name and file offset */
  267.     if (decode_fp == Nullfp)
  268.     {
  269.       err(SE_CONT);
  270.       return -1;
  271.     }
  272.     for (q = l + 5; *q && *q != ' '; q++)
  273.       ;
  274.     if (*q == 0 || atol(l + 5) != ccnt + 4 + (decn != 0) ||
  275.         strNE(q + 1, decode_fname))
  276.     {
  277.       err(SE_CONT);
  278.       return -1;
  279.     }
  280.     b = 0;
  281.       }
  282.       else if (strcmp(l, "end") == 0)
  283.       {
  284.     /* check crc, close output file */
  285.     if (decode_fp == Nullfp)
  286.     {
  287.       err(SE_FORM);
  288.       return -1;
  289.     }
  290.     if (bcnt != 4 || buf4 != ~crc)
  291.       err(SE_CRC);
  292.     else
  293.       printf("CRC verified -- Done.\n");
  294.     if (ferror(decode_fp) || fclose(decode_fp))
  295.     {
  296.       err(SE_FULL);
  297.       decode_end();
  298.       return -1;
  299.     }
  300.     decode_fp = Nullfp;
  301.     b = 2;
  302.       }
  303.       else
  304.       {
  305.     for (q = l; *q && *q != ' '; q++)
  306.       ;
  307.     *q = 0;
  308.     printf("Ignoring unsupported ship keyword: '%s'\n", l);
  309.     b = 4;
  310.       }
  311.       break;
  312.     }
  313.   }
  314.   if (!(b & 2)) {
  315.     err(SE_FORM);
  316.     return -1;
  317.   }
  318.   if (decode_fp)
  319.     printf("(Continued)\n");
  320.   return 0;
  321. }
  322.  
  323. /* Decode s, a string of base 85 digits or, if fast is true, a string of safe
  324.    characters generated arithmetically, into its binary equivalent, writing
  325.    the result to decode_fp, using cputc(). */
  326. static void
  327. decode_line(s)
  328. unsigned char *s;    /* data to decode */
  329. {
  330.   int b;        /* state of line loop, next character */
  331.   int k;        /* counts bits or digits read */
  332.   /* powers of 85 table for decoding */
  333.   static ulg m[] = {1L,85L,85L*85L,85L*85L*85L,85L*85L*85L*85L};
  334.  
  335.   if (fast)
  336.   {
  337.     unsigned int d;    /* disperses bits */
  338.  
  339.     d = decb;
  340.     k = decn;
  341.     while ((b = *s++) != 0)
  342.       if ((b = invsafe[b]) < sizeof(safe))
  343.       {
  344.     if (b < LOWSZ)
  345.     {
  346.       d |= b << k;
  347.       k += 7;
  348.     }
  349.     else if ((b -= LOWSZ) < LOWSZ)
  350.     {
  351.       d |= (b + 0x40) << k;
  352.       k += 7;
  353.     }
  354.     else
  355.     {
  356.       d |= b << k;
  357.       k += 6;
  358.     }
  359.     if (k >= 8)
  360.     {
  361.       cputc(d, decode_fp);
  362.       d >>= 8;
  363.       k -= 8;
  364.     }
  365.       }
  366.     decb = d;
  367.     decn = k;
  368.   }
  369.   else
  370.   {
  371.     ulg d;        /* disperses bytes */
  372.  
  373.     d = k = 0;
  374.     while ((b = *s++) != 0)
  375.       if ((b = invsafe[b]) < 85)
  376.       {
  377.     d += m[k] * b;
  378.     if (++k == 5)
  379.     {
  380.       cputc(d, decode_fp);  d >>= 8;
  381.       cputc(d, decode_fp);  d >>= 8;
  382.       cputc(d, decode_fp);  d >>= 8;
  383.       cputc(d, decode_fp);
  384.       d = k = 0;
  385.     }
  386.       }
  387.     if (--k > 0)
  388.     {
  389.       while (--k)
  390.       {
  391.     cputc(d, decode_fp);
  392.     d >>= 8;
  393.       }
  394.       cputc(d, decode_fp);
  395.     }
  396.   }
  397. }
  398.  
  399. static void
  400. err(n)
  401. int n;            /* error number */
  402. {
  403.   if (n == SE_FULL)
  404.     perror("ship");
  405.   fputs(errors[n - 1], stdout);
  406.   putchar('\n') ; FLUSH;
  407. }
  408.