From ncr-sd!hp-sdd!hplabs!ucbvax!VENUS.YCC.YALE.EDU!LEICHTER Sat Dec 26 00:44:39 PST 1987


	Could some kind soul point me towards an UUENCODER/UUDECODER for VMS ?
	Or even send me one (maybe for Christmas) ? I am fed up with having to
	transfer every file to a cp/m micro and back to UUDECODE it; its
	particularly bad since i think the UUDECODER i am using under cp/m has
	a bug.

The following came of the net from SOMEWHERE, I'm not sure where.  No
guarantees....
							-- Jerry
-----------------------UUENCODE.C--------------------------------
#ifndef lint
static char sccsid[] = "@(#)uuencode.c    5.1 (Berkeley) 7/2/83";
#endif

/*
 * uuencode [input] output
 *
 * Encode a file so it can be mailed to a remote system.
 */
#ifndef vms
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#else /* vms */
#include stdio
#include types
#include stat
#endif /* vms */

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

main(argc, argv)
char **argv;
{
    FILE *in;
#ifdef vms
    FILE *out;
#endif
    struct stat sbuf;
    int mode;

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

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

#ifdef vms    /* write to output file */
    if ((out = fopen(argv[1], "w")) == NULL) {
        perror(argv[1]);
        exit(1);
    }
#else
    out = stdout;
#endif /* vms */

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

    encode(in, out);

    fprintf(out, "end\n");
    exit(0);
}

/*
 * copy from in to out, encoding as you go along.
 */
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.
 */
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] = c;
    }
    return (cnt);
}
-----------------------UUDECODE.C--------------------------------
#ifndef lint
static char sccsid[] = "@(#)uudecode.c    5.1 (Berkeley) 7/2/83";
#endif

/*
 * uudecode [input]
 *
 * create the specified file, decoding as you go.
 * used with uuencode.
 */
#ifndef vms
#include <stdio.h>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>
#else /* vms */
#include stdio
#include types
#include stat
#endif /* vms */

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

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 vms
    /* 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 /* ifndef vms */

    /* create output file */
    out = fopen(dest, "w");
    if (out == NULL) {
        perror(dest);
        exit(4);
    }
    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.
 */
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.
 */
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(c1, f);
    if (n >= 2)
        putc(c2, f);
    if (n >= 3)
        putc(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] = c;
    }
    return (cnt);
}

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

#define    NULL    0

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