/*
 * uudecode [input]
 *
 * Decode a file encoded with uuencode.  Will extract multiple encoded
 * modules from a single file.  Can deal with most mangled files, including
 * those that have been mangled by common BITNET problems.
 *
 */

/* Modified by Steffen P. Häuser (ELF-Version was from Andreas Kleinert)
 *
 * 18.02.98: - WarpOS (TM) version, compiled with StormC, as ELF sucks :)
 *
 * 07.02.98: - powerUP (TM) version, compiled with SAS/C for PPC
 *
 * 31.08.97: - reworked for SAS/C 6.58
 *           - better compiler settings
 *           - ANSI-fied
 *
 * 04.08.94: - first, internal version
 *
 *
 *
 * Original authors:
 *
 * Written by Mark Horton
 * Modified by ajr (Alan J Rosenthatl,flaps@utcsri.UUCP) to use checksums
 * Modified by fnf (Fred Fish,well!fnf) to use Keith Pyle's suggestion for
 * compatibility
 * Modified by bcn (Bryce Nesbitt,ucbvax!cogsci!bryce) to fix a misleading
 * error message on the Amiga port, to fix a bug that prevented decoding
 * certain files, to work even if trailing spaces have been removed from a
 * file, to check the filesize (if present), to add some error checking, to
 * loop for multiple decodes from a single file, and to handle common
 * BITNET mangling.  Kludged around a missing string function in Aztec
 * C. Changed "r" to "rb" and "w" to "wb" for Messy-dos machines
 * (Thanks to Andrew Wylie).
 */

#define __USE_SYSBASE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <ctype.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <exec/types.h>

#include <clib/exec_protos.h>

void decode(FILE *in, FILE *out, UBYTE *dest);

UBYTE version [] = "\0$VER: uudecode 1.0 (7.2.98)";

long main(long argc, char **argv)
{
 FILE *in, *out;
 LONG through_loop = 0; /* Dejavu indicator */
 LONG mode;             /* file's mode (from header) */
 LONG filesize;         /* theoretical file size (from header) */
 UBYTE dest[128];
 UBYTE buf[80];

    /* A filename can be specified to be uudecoded, or nothing can
    be specified, and the input will come from STDIN */

    switch (argc)
        {
        case 1:
        in=stdin;
        break;

        case 2:
        if ((in = fopen(argv[1], "r")) == NULL)
            {
            fprintf(stderr, "ERROR: can't find %s\n", argv[1]);
            fprintf(stderr, "USAGE: uudecode [infile]\n");
            exit(20);
            }
        break;

        default:
        fprintf(stderr, "USAGE: uudecode [infile]\n");
        exit(0);
        break;
        }

    /* Loop through file, searching for headers.  Decode anything with a
       header, complain if there where no headers. */

for (;;)
{
    /* search file for header line */
    for (;;)
        {
        if (fgets(buf, sizeof buf, in) == NULL)
            {
            if (!through_loop)
                {
                fprintf(stderr, "ERROR: no `begin' line!\n");
                exit(20);
                }
            else
                {
                exit(0);
                }
            }
        if (strncmp(buf, "begin ", 6) == 0)
            break;
        }
    sscanf(buf, "begin %o %s", &mode, dest);

    /* create output file */
    if ((out = fopen(dest, "w")) == NULL)
        {
        fprintf(stderr, "ERROR: can't open output file %s\n", dest);
        exit(20);
        }

    decode(in, out, dest);

    if (fgets(buf, sizeof buf, in) == NULL || strncmp(buf,"end",3))
        {              /* don't be overly picky about newline ^ */
        fprintf(stderr, "ERROR: no `end' line\n");
        exit(20);
        }

    if (!(fgets(buf,sizeof buf,in) == NULL || strncmp(buf,"size ",3)))
        {
        sscanf(buf, "size %ld", &filesize);
        if (ftell(out) != filesize)
            {
            fprintf(stderr, "ERROR: file should have been %ld bytes long but was %ld.\n", filesize, ftell(out));
            exit(20);
            }
        }
    through_loop = 1;
}   /* forever */

 exit(0);
}

#define SUMSIZE 64
#define DEC(c)  (((c) - ' ') & 077)    /* single character decode */

/*
 * Copy from in to out, decoding as you go.
 * If a return or newline is encountered too early in a line, it is
 * assumed that means that some editor has truncated trailing spaces.
 */
void decode(FILE *in, FILE *out, UBYTE *dest)
{
 extern errno;

 UBYTE *bp;
 LONG nosum=0;
 LONG j, n, checksum, line;
 UBYTE buf[256];

    for (line = 1; ; line++)    /* for each input line */
        {
        if (fgets(buf, sizeof buf, in) == NULL)
            {
            fprintf(stderr, "ERROR: input ended unexpectedly!\n");
            exit(20);
            }

        /* Pad end of lines in case some editor truncated trailing
           spaces */

        for (n=0;n<79;n++)  /* search for first \r, \n or \000 */
            {
            if (buf[n]=='\176')     /* If BITNET made a twiddle, */
                buf[n]='\136';     /* we make a caret           */
            if (buf[n]=='\r'||buf[n]=='\n'||buf[n]=='\000')
                break;
            }
        for (;n<79;n++)     /* when found, fill rest of line with space */
            {
            buf[n]=' ';
            }
        buf[79]=0;          /* terminate new string */

        checksum = 0;
        n = DEC(buf[0]);
        if (n <= 0)
            break;      /* 0 bytes on a line??  Must be the last line */

        bp = &buf[1];

        /* FOUR input characters go into each THREE output charcters */

        while (n >= 4)
            {
            j = DEC(bp[0]) << 2 | DEC(bp[1]) >> 4; putc(j, out); checksum += j;
            j = DEC(bp[1]) << 4 | DEC(bp[2]) >> 2; putc(j, out); checksum += j;
            j = DEC(bp[2]) << 6 | DEC(bp[3]);      putc(j, out); checksum += j;
            checksum = checksum % SUMSIZE;
            bp += 4;
            n -= 3;
            }

            j = DEC(bp[0]) << 2 | DEC(bp[1]) >> 4;
                checksum += j;
                if (n >= 1)
                    putc(j, out);
            j = DEC(bp[1]) << 4 | DEC(bp[2]) >> 2;
                checksum += j;
                if (n >= 2)
                    putc(j, out);
            j = DEC(bp[2]) << 6 | DEC(bp[3]);
                checksum += j;
                if (n >= 3)
                    putc(j, out);
            checksum = checksum % SUMSIZE;
            bp += 4;
            n -= 3;

         /* Error checking under UNIX??? You must be kidding... */
         /* Check if an error occured while writing to that last line */
        if (errno)
            {
            fprintf(stderr, "ERROR: error writing to %s\n",dest);
            exit(20);
            }

        /* The line has been decoded; now check that sum */

        nosum |= !isspace(*bp);
        if (nosum)                      /* Is there a checksum at all?? */
            {
            if (checksum != DEC(*bp))   /* Does that checksum match? */
                {
                fprintf(stderr, "ERROR: checksum mismatch decoding %s, line %d.\n",dest, line);
                }
            }   /* sum */
    }   /* line */
}   /* function */