home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / dostools / uudoall / uudoall.c next >
Text File  |  1993-04-01  |  8KB  |  333 lines
  1. /*uudoall.c cleans up split files checks checksums and writes by h**2 7/4/91
  2.  *  (c) 1991 by Howard Helman
  3.  */
  4.  
  5.  
  6.  
  7. /*
  8.   uudoall.c can usually handle the split files with all the intervening mail
  9.   crap.
  10.   Automatically checks for checksums on lines and automatically checks for
  11.   a `size' line at the end and verifies the size.  It also computes the sum
  12.   value for the decoded file. I could not find any convention on people using
  13.   sum so the program just computes it and prints it.
  14.  
  15.   Compile by defining DOS for msdos use or UNIX for use elsewhere.
  16.  */
  17.  
  18.  
  19. /* the program is called by :
  20.     uudoall [opts] -ddir infile [...]
  21.  where opts are:
  22.         -s+        do size check
  23.         -s-        inhibit size check
  24.         -c+        do line by line checksum
  25.         -c-        inhibit checksum
  26.         -ddir    place output files in the named directory
  27.         infile    the file to process (all parts should be concatenated.)
  28.         [...]    options and file names may be repeated.
  29.                 The last option setting is in effect when a file is
  30.                 processed.
  31.  If the program cannot open the output file, it prompts the user
  32.  for a new file name or `enter' to stop.
  33.  The trimming of trailing blanks is handled properly.  This program
  34.  has been in use continually and has only had one problem: a user
  35.  signature started in col 1 and had a `M' and over sixty characters in the
  36.  line.  This is what the program searches for to find the next part of the
  37.  encoded file.
  38. */
  39.  
  40. /*
  41.   This program is donated to the public domain provided that the source
  42.   is distributed in total and my authorship of the program is credited.
  43.  
  44.         Howard Helman
  45.         Box 340
  46.         Manhattan Beach
  47.         CA 90266
  48. */
  49.  
  50. /* v1.1, 3 Oct 91   Toad Hall Tweak
  51.  * - Slight tweaks to reduce Turbo C v2.0 warnings.
  52.  * - Threw in some prototypes.
  53.  * - Reformatted to K&R standards (via good old Mister Mangler,
  54.  *   AKA indent).
  55.  * David Kirschbaum
  56.  * Toad Hall
  57.  * kirsch@usasoc.soc.mil
  58.  */
  59.  
  60. #ifdef __TURBOC__
  61. #define DOS 1
  62. #endif
  63.  
  64. #ifdef DOS
  65. #include <stdlib.h>
  66. #include <alloc.h>
  67. #define ReaD "rt"
  68. #define WritE "wb"
  69. #define SlasH "\\"
  70. #endif
  71. #ifdef UNIX
  72. #define ReaD "r"
  73. #define WritE "w"
  74. #define SlasH "/"
  75. #endif
  76. #include <stdio.h>
  77. #include <string.h>
  78. #include <ctype.h>
  79.  
  80. #define Bsize 80
  81. #define SUMSIZE 64
  82. #define DEC(c)  (((x_x=(c))>=' ')?((x_x-' ')&077):(0))    /* single char decode */
  83. #define match(x) matcher(buf,x)
  84.  
  85. static int dosize = 1, docheck = 1;
  86. static char x_x, dir[80];
  87. static long nbytes;
  88. static unsigned int sum1;
  89.  
  90. #ifdef DOS
  91. static void *vbi;
  92. static unsigned bn;
  93. #endif
  94.  
  95. #ifdef __TURBOC__
  96. /* v1.1 I like prototypes */
  97. int matcher(char *a, char *b);
  98. int hget(char *buf, int bs, FILE *in);
  99. void decode(FILE *in, FILE *out, char *dest);
  100. void doopts(char *s);
  101. void decodeit(FILE *in, char buf[Bsize]);
  102.  
  103. #endif
  104. enum States {
  105.     BeginSearch, InBody, GapOrEnd, LookEnd, PutTwo, PutEnd,
  106.     Mfind
  107. } state = BeginSearch;
  108.  
  109. int matcher(a, b)
  110. char *a, *b;
  111. {
  112.     while (*b && *a == *b)
  113.         a++, b++;
  114.     return (!*b);
  115. }
  116.  
  117. int hget(buf, bs, in)
  118. char *buf;
  119. int bs;
  120. FILE *in;
  121. {
  122.     static char s1[Bsize], s2[Bsize];
  123.  
  124.     if (state == PutEnd) {
  125.         strcpy(buf, "end");
  126.         state = BeginSearch;
  127.         return 1;
  128.     }
  129.     if (state == PutTwo) {
  130.         strcpy(buf, s2);
  131.         state = PutEnd;
  132.         return 1;
  133.     }
  134.     while (fgets(buf, bs, in)) {
  135.         switch (state) {
  136.         case BeginSearch:
  137.             if (match("begin "))
  138.                 state = InBody;
  139.             return 1;
  140.         case InBody:
  141.             if (*buf == 'M')
  142.                 return 1;
  143.             else if (*buf == '`') {
  144.                 state = BeginSearch;
  145.                 return 1;
  146.             } else {
  147.                 strcpy(s1, buf);
  148.                 state = GapOrEnd;
  149.             }
  150.             break;
  151.         case GapOrEnd:
  152.             if (match("end")) {
  153.                 strcpy(buf, s1);
  154.                 state = PutEnd;
  155.                 return 1;
  156.             } else {
  157.                 strcpy(s2, buf);
  158.                 state = LookEnd;
  159.             }
  160.             break;
  161.         case LookEnd:
  162.             if (match("end")) {
  163.                 strcpy(buf, s1);
  164.                 state = PutTwo;
  165.                 return 1;
  166.             } else
  167.                 state = Mfind;
  168.             break;
  169.         case Mfind:
  170.             if (*buf == 'M' && strlen(buf) > 60) {
  171.                 state = InBody;
  172.                 return 1;
  173.             }
  174.             break;
  175.         }
  176.     }
  177.     return 0;
  178. }
  179.  
  180. void decode(in, out, dest)
  181. FILE *in, *out;
  182. char *dest;
  183. {
  184.     int j, n, checksum, altsum;
  185.     char buf[Bsize], *bp, hold[Bsize / 4 * 3], *jp;
  186.     unsigned pcline = 0, line = 0;
  187.  
  188.     sum1 = 0;
  189.     nbytes = 0;
  190.     while (memset(buf, 0, Bsize), hget(buf, Bsize, in)
  191.       &&(n = DEC(*buf)) > 0) {
  192.         line++;
  193.         altsum = checksum = 0;
  194.         bp = buf + 1;
  195.         for (jp = hold, j = n; j > 0; j -= 3, bp += 4) {
  196.             *jp = (DEC(bp[0]) << 2) | (DEC(bp[1]) >> 4);
  197.             checksum += *jp++;
  198.             *jp = (DEC(bp[1]) << 4) | (DEC(bp[2]) >> 2);
  199.             checksum += *jp++;
  200.             *jp = (DEC(bp[2]) << 6) | (DEC(bp[3]));
  201.             checksum += *jp++;
  202.             altsum += bp[0] + bp[1] + bp[2] + bp[3];
  203.         }
  204.         for (j = 0, jp = hold; j < n; j++, jp++)
  205.             sum1 = ((sum1 >> 1) + ((sum1 & 1) ? 0x8000 : 0)
  206.                 + (*jp & 0xff)) & 0xffff;
  207.         nbytes += n;
  208.         if (fwrite(hold, 1, n, out) != n) {
  209.             fprintf(stderr, "ERROR: error writing to %s\n", dest);
  210.             exit(1);
  211.         }
  212.         if (!isspace(*bp) && docheck)
  213.             if ((checksum & (SUMSIZE - 1)) != DEC(*bp)
  214.               && (altsum & 077) != (DEC(*bp) & 077)) {
  215.                 if (!pcline)
  216.                     pcline = line;
  217.             } else if (pcline) {
  218.                 fprintf(stderr,
  219.                         "ERROR:Bad Checksum lines %u-%u\n", pcline, line);
  220.                 pcline = 0;
  221.             }
  222.     }
  223.     if (pcline)
  224.         fprintf(stderr, "ERROR:Bad Checksum lines %u-%u\n", pcline, line);
  225.     if (feof(in) ||ferror(in)) {
  226.         fprintf(stderr, "ERROR: Input ended unexpectedly!\n");
  227.         exit(1);
  228.     }
  229. }
  230.  
  231. void decodeit(in, buf)
  232. FILE *in;
  233. char buf[Bsize];
  234. {
  235.     int mode;
  236.     long filesize, tsize;
  237.     FILE *out;
  238.     char fname[128], dest[128];
  239.  
  240.     sscanf(buf, "begin %o %s", &mode, dest);
  241.     while (strcpy(fname, dir) && strcat(fname, dest)
  242.       && !(out = fopen(fname, WritE))) {
  243.         fprintf(stderr, "ERROR: Can't open output file %s\nTry new one:",
  244.                 fname);
  245.         gets(dest);
  246.         if (!*dest)
  247.             exit(1);
  248.     }
  249. #ifdef DOS
  250.     setvbuf(out, (char *) vbi + bn * 512, _IOFBF, bn * 512);
  251. #endif
  252.     fprintf(stderr, "Creating %s\n", fname);
  253.     decode(in, out, dest);
  254.     if (!hget(buf, Bsize, in) ||!match("end")) {
  255.         fprintf(stderr, "ERROR: no `end' line\n");
  256.         exit(1);
  257.     }
  258.     tsize = ftell(out);
  259.     if (dosize && hget(buf, Bsize, in) &&match("size ")) {
  260.         sscanf(buf, "size %ld", &filesize);
  261.         if (tsize != filesize) {
  262.             fprintf(stderr,
  263.             "ERROR: file should have been %ld bytes long but was %ld.\n",
  264.                     filesize, tsize);
  265.             exit(1);
  266.         }
  267.     } else if (dosize)
  268.         fprintf(stderr, "Size check not done\n");
  269.     if (tsize != nbytes) {
  270.         fprintf(stderr, "Size Error:file=%ld data=%ld\n", tsize, nbytes);
  271.         exit(1);
  272.     }
  273.     fprintf(stderr, "sums: %u %ld %ld\n", sum1, (nbytes + 1023) / 1024,
  274.             nbytes);
  275.     fclose(out);
  276. }
  277.  
  278. void doopts(s)
  279. char *s;
  280. {
  281.     if (s[1] == 's')
  282.         dosize = s[2] != '-';
  283.     else if (s[1] == 'c')
  284.         docheck = s[2] != '-';
  285.     else if (s[1] == 'd') {
  286.         strcpy(dir, s + 2);
  287.         if (*dir)
  288.             strcat(dir, SlasH);
  289.     } else {
  290.         fprintf(stderr, "Illegal flag %s\n", s);
  291.         exit(1);
  292.     }
  293. }
  294.  
  295. int main(argc, argv)
  296. int argc;
  297. char **argv;
  298. {
  299.     FILE *in;
  300.     int nf = 0, i;
  301.     char buf[80];
  302.  
  303.     *dir = 0;
  304.     if (argc < 2) {
  305.         fprintf(stderr,
  306.     "USAGE: uudoall [opts] -ddir infile [...] where opts are -s+|- -c+|-\n");
  307.         exit(1);
  308.     }
  309. #ifdef DOS
  310.     bn = coreleft() / 1024 - 2;
  311.     vbi = malloc(512 * 2 * bn);
  312. #endif
  313.     for (i = 1; i < argc; i++) {
  314.         if (argv[i][0] == '-')
  315.             doopts(argv[i]);
  316.         else if (!(in = fopen(argv[i], ReaD)))
  317.             fprintf(stderr, "ERROR: can't find %s\n", argv[i]);
  318.         else {
  319. #ifdef DOS
  320.             setvbuf(in, vbi, _IOFBF, bn * 512);
  321. #endif
  322.             while (hget(buf, Bsize, in)) {
  323.                 if (match("begin ")) {
  324.                     nf++;
  325.                     decodeit(in, buf);
  326.                 }
  327.             }
  328.             fclose(in);
  329.         }
  330.     }
  331.     return !nf;
  332. }
  333.