NetNews Usenet Archive 1992 #26/NN_1992_26.iso/spool/comp/os/vms/17876

Text File | 1992-11-12 | 7.8 KB | 349 lines

Path: sparky!uunet!stanford.edu!agate!ucbvax!mcimail.com!0005066432
From: [e-mail] ("Tansin A. Darcos & Company")
Newsgroups: comp.os.vms
Subject: UUENCODE and UUDECODE
Message-ID: <[e-mail]>
Date: 12 Nov 92 18:53:00 GMT
Sender: [e-mail]
Distribution: world
Organization: The Internet
Lines: 337

I have used the UUDECODE portion of these two to decode files I've gotten
in the mail, so I know that works; I've not had to use the ENCODE part,
so I don't know if it does, but here it is.

Paul Robinson.

---- Cut here -----
/*
 * uuencode [input]
 *
 * Encode a file so it can be mailed to a remote system.
 *
 * Instructions for use are really quite simple. Type
 * uuencode foo.exe >bar.txt
 *
 * bar.txt can then be read by uudecode to generate foo.exe by typing
 * uudecode bar.txt
 *
 * Compiles under Turbo C v2.0 NO PROBLEM..
 *
 * If you have a problem, contact me IMMEDIATELY..I want this to work.
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <io.h>
#include <sys/types.h>
#include <sys/stat.h>

void encode(FILE *, FILE *);
int fr(FILE *, char *, int);
void outdec(char *, FILE *);

/* ENC is the basic 1 character encoding function to make a char printing */
#define ENC(c) (char) (((c) & 077) + ' ')

void main(argc, argv)
char **argv;
{
        FILE *in;
        struct stat sbuf;
        int mode;

        /* optional 1st argument */
        if (argc > 1) {
                if ((in = fopen(argv[1], "r")) == NULL) {
                        perror(argv[1]);
                        exit(1);
                }
                argv++; argc--;
        } else
                in = stdin;

        if (setmode(fileno(in), (int) O_BINARY) == -1)
          {
           perror(argv[1]);
           exit(1);
          }

        if (argc != 1) {
                printf("Usage: uuencode [infile] >remotefile\n");
                exit(2);
        }

        /* figure out the input file mode */
        fstat(fileno(in), &sbuf);
        mode = sbuf.st_mode & 0777;
        printf("begin %o %s\n", mode, argv[0]);

        encode(in, stdout);

        printf("end\n");
        exit(0);
}

/*
 * copy from in to out, encoding as you go along.
 */
void encode(in, out)
FILE *in;
FILE *out;
{
        char buf[80];
        int i, n;

        for (;;) {
                /* 1 (up to) 45 character line */
                n = fr(in, buf, 45);
                putc(ENC(n), out);

                for (i=0; i<n; i += 3)
                        outdec(&buf[i], out);

                putc('\n', out);
                if (n <= 0)
                        break;
        }
}

/*
 * output one group of 3 bytes, pointed at by p, on file f.
 */
void outdec(p, f)
char *p;
FILE *f;
{
        int c1, c2, c3, c4;

        c1 = *p >> 2;
        c2 = (*p << 4) & 060 | (p[1] >> 4) & 017;
        c3 = (p[1] << 2) & 074 | (p[2] >> 6) & 03;
        c4 = p[2] & 077;
        putc(ENC(c1), f);
        putc(ENC(c2), f);
        putc(ENC(c3), f);
        putc(ENC(c4), f);
}

/* fr: like read but stdio */
int
fr(fd, buf, cnt)
FILE *fd;
char *buf;
int cnt;
{
        int c, i;

        for (i=0; i<cnt; i++) {
                c = getc(fd);
                if (c == EOF)
                        return(i);
                buf[i] = (char) c;
        }
        return (cnt);
}

--- Cut Here ---
Decode Follows
--- Cut Here ---
/*
 * uudecode input
 *
 * create the specified file, decoding as you go.
 * used with uuencode.
 */
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <fcntl.h>
#include <string.h>

#ifndef MSDOS
#include <pwd.h>
#endif

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

void decode(FILE *, FILE *);
void outdec(char *, FILE *, int);
char *index(char *, char);
int fr(FILE *, char *, int);

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

void main(argc, argv)
char **argv;
{
        FILE *in, *out;
        struct stat sbuf;
        int mode;
        char dest[128];
        char buf[80];

        /* optional input arg */
        if (argc > 1) {
                if ((in = fopen(argv[1], "r")) == NULL) {
                        perror(argv[1]);
                        exit(1);
                }
                argv++; argc--;
        } else
                in = stdin;

        if (argc != 1) {
                printf("Usage: uudecode [infile]\n");
                exit(2);
        }

        /* search for header line */
        for (;;) {
                if (fgets(buf, sizeof buf, in) == NULL) {
                        fprintf(stderr, "No begin line\n");
                        exit(3);
                }
                if (strncmp(buf, "begin ", 6) == 0)
                        break;
        }
        sscanf(buf, "begin %o %s", &mode, dest);

#ifndef MSDOS
        /* handle ~user/file format */
        if (dest[0] == '~') {
                char *sl;
                struct passwd *getpwnam();
                char *index();
                struct passwd *user;
                char dnbuf[100];

                sl = index(dest, '/');
                if (sl == NULL) {
                        fprintf(stderr, "Illegal ~user\n");
                        exit(3);
                }
                *sl++ = 0;
                user = getpwnam(dest+1);
                if (user == NULL) {
                        fprintf(stderr, "No such user as %s\n", dest);
                        exit(4);
                }
                strcpy(dnbuf, user->pw_dir);
                strcat(dnbuf, "/");
                strcat(dnbuf, sl);
                strcpy(dest, dnbuf);
        }
#endif

        /* create output file */
        out = fopen(dest, "w");
        if (out == NULL) {
                perror(dest);
                exit(4);
        }
        setmode(fileno(out), (int) O_BINARY);
        chmod(dest, mode);

        decode(in, out);

        if (fgets(buf, sizeof buf, in) == NULL || strcmp(buf, "end\n")) {
                fprintf(stderr, "No end line\n");
                exit(5);
        }
        exit(0);
}

/*
 * copy from in to out, decoding as you go along.
 */
void decode(in, out)
FILE *in;
FILE *out;
{
        char buf[80];
        char *bp;
        int n;

        for (;;) {
                /* for each input line */
                if (fgets(buf, sizeof buf, in) == NULL) {
                        printf("Short file\n");
                        exit(10);
                }
                n = DEC(buf[0]);
                if (n <= 0)
                        break;

                bp = &buf[1];
                while (n > 0) {
                        outdec(bp, out, n);
                        bp += 4;
                        n -= 3;
                }
        }
}

/*
 * output a group of 3 bytes (4 input characters).
 * the input chars are pointed to by p, they are to
 * be output to file f.  n is used to tell us not to
 * output all of them at the end of the file.
 */
void outdec(p, f, n)
char *p;
FILE *f;
{
        int c1, c2, c3;

        c1 = DEC(*p) << 2 | DEC(p[1]) >> 4;
        c2 = DEC(p[1]) << 4 | DEC(p[2]) >> 2;
        c3 = DEC(p[2]) << 6 | DEC(p[3]);
        if (n >= 1)
                putc((char) c1, f);
        if (n >= 2)
                putc((char) c2, f);
        if (n >= 3)
                putc((char) c3, f);
}


/* fr: like read but stdio */
int
fr(fd, buf, cnt)
FILE *fd;
char *buf;
int cnt;
{
        int c, i;

        for (i=0; i<cnt; i++) {
                c = getc(fd);
                if (c == EOF)
                        return(i);
                buf[i] = (char) c;
        }
        return (cnt);
}

/*
 * Return the ptr in sp at which the character c appears;
 * NULL if not found
 */

char *
index(sp, c)
register char *sp, c;
{
        do {
                if (*sp == c)
                        return(sp);
        } while (*sp++);
        return(NULL);
}

---cut here---
Paul Robinson -- [e-mail]