Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2640

Internet Message Format | 1991-01-31 | 33.5 KB

From: [e-mail] (Martin Junius)
Newsgroups: alt.sources
Subject: FIDOGATE Part 5/6
Message-ID: <mj.665055349@suntex>
Date: 28 Jan 91 09:35:49 GMT

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 05 of a multipart archive
# ============= funpack.c ==============
if test -f 'funpack.c' -a X"$1" != X"-c"; then
    echo 'x - skipping funpack.c (File already exists)'
else
echo 'x - extracting funpack.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'funpack.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: funpack.c,v 2.12 91/01/26 13:27:37 mj Exp $
X *
X * Unpack fido mail packets
X *
X * $Log:    funpack.c,v $
X * Revision 2.12  91/01/26  13:27:37  mj
X * Changed generation of `Path' header to include FIDO address of gateway.
X *
X * Revision 2.11  90/12/09  17:34:26  mj
X * Recognize `To:' header at start of message.
X *
X * Revision 2.10  90/12/02  21:22:02  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 2.9  90/11/23  20:41:10  mj
X * Changed locally generated message ids to <[e-mail]>,
X * corrected line breaking in ffgets().
X *
X * Revision 2.8  90/11/20  21:08:44  mj
X * Added support for ^AINTL kludge.
X *
X * Revision 2.7  90/11/05  20:50:14  mj
X * Changed my signature in all program headers.
X *
X * Revision 2.6  90/11/04  14:14:48  mj
X * A small change in line wrapping: no more line wrapping at punctuation
X * characters.
X *
X * Revision 2.5  90/11/01  14:33:56  mj
X * Convert FIDO ^AMSGID and ^AREPLY kludges to RFC822 Message-ID and
X * References headers.
X *
X * Revision 2.4  90/10/29  21:19:37  mj
X * Ignore case when checking for name alias.
X *
X * Revision 2.3  90/09/16  17:35:49  mj
X * Also look for "UUCPFROM:" in first lines of message body.
X *
X * Revision 2.2  90/09/09  10:54:37  mj
X * Fixed a bug in handling of `ReplyTo:' in FIDO message body. Spaces
X * in such an address are now striped off.
X *
X * Revision 2.1  90/09/08  18:46:32  mj
X * Changed some code for getting real names out of FIDO from and to header
X * fields. (Ignore things after "%" or "Of")
X * Now we look for RFC822 like header lines at the beginning of the
X * message body and use them for the `From:' and `To:' field.
X *
X * Revision 2.0  90/09/03  17:54:23  mj
X * Rewrote much of the code inside this module.
X * There are now hooks, where support for most of
X * the FIDO ^A kludges (e.g. ^AMSGID) can be installed.
X * Function stripbad() from nodelist.c moved to
X * funpack.c
X *
X * Revision 1.7  90/08/12  11:56:54  mj
X * Some changes. (what?)
X *
X * Revision 1.6  90/07/23  12:58:26  mj
X * The FIDO `^AFMPT x' kludge is now recognized by funpack and
X * inserted as the point address in the `From: ...' line.
X *
X * Revision 1.5  90/07/15  10:26:11  mj
X * Messages for mail: M.xxxx.TO is not used any more. frecv now
X * looks for `To: ...' line is mail file M.xxxx.
X * Messages for news: Address from origin line is only substituted
X * in header `From: ...' line, all others are left unchanged.
X *
X * Revision 1.4  90/07/01  15:20:18  mj
X * Fixed some bugs in funpack caused by the removal of alloca().
X * No more core dumps, but heaven knows, why it works now. Strange.
X *
X * Revision 1.3  90/07/01  13:45:50  mj
X * Removed all calls to alloca(). All unsave malloc()'s without
X * checking the returned pointer are now done via xmalloc().
X * Fixed a malloc() error in rmail.
X *
X * Revision 1.2  90/06/28  22:04:19  mj
X * Much rework of the sources, no more hsu.h and other clean up.
X * rmail improved, now handles special XENIX quirks.
X *
X * Revision 1.1  90/06/21  21:09:19  mj
X * Everything seems to work, so this delta was made.
X *
X * Revision 1.0  90/06/19  18:32:29  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
/*
X * Fido mail packets in SPOOL/in are processed and splitted into
X * single messages for either news
X *     N.xxxx
X * or mail
X *     M.xxxx
X * in directory SPOOL/unpacked.
X *
X */
X
#include "fidogate.h"
X
X
X
#define PROGRAMNAME "funpack $Revision: 2.12 $"
X
X
X
#define SEPARATORS " ,;\015\012\011"
#define WHITESPACE " \015\012\011"
X
X
X
extern time_t time();
extern char *tzname[];
extern int getopt();
extern int optind;
extern char *optarg;
extern void exit(), perror();
extern time_t dateconv();
extern void swab();
X
X
int verbose = INIT_VERBOSE;
int acceptprivate = FALSE;
int trashprivate = FALSE;
X
/* Our net/node information */
Node this;
X
X
/*
X * For recognizing `^AINTL', `^AFMPT x', `^AMSGID ...' and `^AREPLY ...'
X */
#define SAVEBUFSIZ 256
X
static int  msgbody_fmpt = 0;
static char msgbody_msgid[SAVEBUFSIZ];
static char msgbody_reply[SAVEBUFSIZ];
static char msgbody_intl[SAVEBUFSIZ];
X
X
/*
X * For grabbing addresses from RFC822 header lines at start of message
X */
X
static char *msgbody_rfc_from;
static char *msgbody_rfc_to;
X
X
X
/*
X * check_origin() --- Analyse ` * Origin: ...' line in FIDO message
X *                    body and parse address in ()s into Node structure
X *
X * Origin line is checked for the rightmost occurence of
X * ([text] z:n/n.p). If origin line get splitted across
X * two lines you're out of luck.
X */
X
check_origin(buffer, node, text)
char *buffer;
Node *node;
char *text;
{
char *left, *right;
char *buf;
X
X    if(!strncmp(" * Origin:", buffer, 10)) {
X        debug(3, "Checking origin line for FIDO address");
X        buf   = strsave(buffer);
X        right = strrchr(buf, ')');
X        if(!right) {
X            free(buf);
X            return(FALSE);
X        }
X        left  = strrchr(buf, '(');
X        if(!left) {
X            free(buf);
X            return(FALSE);
X        }
X        *right = 0;
X        *left++ = 0;
X        /*
X         * Copy info text for Organization: header
X         */
X        strcpy(text, buf + strlen(" * Origin: "));
X        /*
X         * Parse node info
X         */
X        if(parsefnetaddress(left, node)) {
X            /* Not a valid FIDO address */
X            debug(3, "Could not parse %s", left);
X            node->zone = node->net = node->node = node->point = -1;
X            free(buf);
X            return(FALSE);
X        }
X        else {
X            /* Valid FIDO address */
X            debug(3, "Parsed %s to %s", left, ascnode(*node));
X        }
X        free(buf);
X        return(TRUE);
X    }
X    return(FALSE);
}
X
X
X
/*
X * check_ctrl_a() --- Check for various ^A kludges
X */
X
check_ctrl_a(buffer)
char *buffer;
{
register char *p;
X
X    /*
X     * Look for `^AINTL ...'
X     */
X    if(!strncmp(buffer, "^AINTL", 6)) {
X        buffer += 6;
X        while(*buffer==':' || *buffer==' ')
X            buffer++;
X        strcpy(msgbody_intl, buffer);
X    }
X
X    /*
X     * Look for `^AFMPT x'
X     */
X    if(!strncmp(buffer, "^AFMPT", 6)) {
X        for(p=buffer+6; *p && !isdigit(*p); p++);
X        if(*p)
X            msgbody_fmpt = atoi(p);
X    }
X
X    /*
X     * Look for `^AMSGID ...'
X     */
X    if(!strncmp(buffer, "^AMSGID: ", 9))
X        strcpy(msgbody_msgid, buffer+9);
X
X    /*
X     * Look for `^AREPLY ...'
X     */
X    if(!strncmp(buffer, "^AREPLY: ", 9))
X        strcpy(msgbody_reply, buffer+9);
X
}
X
X
X
/*
X * check_rfc_header() --- Check for RFC822 like header lines at
X *                        the beginning of the FIDO message body
X */
X
int check_rfc_header(buffer)
char *buffer;
{
X    if(!strncmp(buffer, "From: ", 6)) {
X        msgbody_rfc_from = strsaveline(buffer + 6);
/*        compress_spaces(msgbody_rfc_from); */
X        return(1);
X    }
X    if(!strncmp(buffer, "Reply-To: ", 10)) {
X        msgbody_rfc_from = strsaveline(buffer + 10);
X        compress_spaces(msgbody_rfc_from);
X        return(1);
X    }
X    if(!strncmp(buffer, "UUCPFROM:", 9)) {
X        msgbody_rfc_from = strsaveline(buffer + 9);
/*        compress_spaces(msgbody_rfc_from); */
X        return(1);
X    }
X    if(!strncmp(buffer, "To: ", 4)) {
X        msgbody_rfc_to = strsaveline(buffer + 4);
X        return(1);
X    }
X    return(0);
}
X
X
X
/*
X * compress_spaces()  ---  Strip spaces out of string
X */
X
compress_spaces(string)
char *string;
{
char *p;
X
X    for(p=string; *p; p++)
X        if(*p != ' ')
X            *string++ = *p;
X    *string = 0;
}
X
X
X
/*
X * Generate RFC822 message-id from FIDO ^AMSGID/REPLY kludge
X */
X
int generate_msgid(fp, header, msgid)
FILE *fp;
char *header, *msgid;
{
char *system;
char *id;
Node idnode;
long idnumber, xtol();
X
X    /*
X     * Seperate system string
X     */
X    for(system=msgid; *msgid && !isspace(*msgid); msgid++);
X    if(!*msgid)
X        return(-1);
X    *msgid++ = 0;
X    /*
X     * Seperate id string
X     */
X    for(; *msgid && isspace(*msgid); msgid++);
X    if(!*msgid)
X        return(-1);
X    for(id=msgid; *msgid && isxdigit(*msgid); msgid++);
X    *msgid = 0;
X
X    /*
X     * Try to interprete system as FIDO node
X     */
X    if(!parsefnetaddress(system, &idnode))
X        system = internode(idnode);
X    else
X        stripbad(system);
X    /*
X     * Convert hex id to decimal
X     */
X    idnumber = xtol(id);
X
X    /*
X     * Output RFC822 style message id
X     */
X    fprintf(fp, "%s <%lu@%s>\n", header, idnumber, system);
X
X    return(0);
}
X
X
X
/*
X * Replacement for fgets(3S) to understand cr's generated by Fido
X * and 'soft' cr's generated by SEAdog.
X * ie. 0 is got from file.
X */
X
static char *
ffgets(buffer, maxlen, fp)
char *buffer;
int maxlen;
FILE *fp;
{
X    register int c, ch, index;
X    register char *cp;
X    static char wordsave[BUFSIZ];
X
X    /* TRUE if last line was origin line without valid node */
X    static int last_line_was_origin = FALSE;
X
X    /* TRUE if last character caused line wrap */
X    static int last_char_wrapped = FALSE;
X    Node node;
X
X    /* There might be wrapped word lying around */
X    if (*wordsave) {
X        strcpy(buffer, wordsave);
X        strsclean(buffer);
X        debug(20, "Picked up word '%s'", buffer);
X        *wordsave = 0;
X    }
X    else
X        *buffer = 0;
X
X    cp = buffer + strlen(buffer);
X
X    while (--maxlen > 0 && (c = getc(fp)) != EOF && c) {
X        /* Hard carriage return */
X
X        if (c == '\r')
X            c = '\n';
X        else if (c == '\n' || c == 0x8d) {
X            /* Forget about these ! */
X            continue;
X        }
X        else if(c < ' ') {
X            /*
X             * Substitute control chars with '^X'
X             */
X            if(c != '\t') {
X                *cp++ = '^';
X                c = c + '@';
X            }
X        }
X        else if(c & 0x80) {
X            /*
X             * Convert IBM umlaut chars and others above 0x80
X             */
X            switch(c) {
X                case 132:
X                    *cp++ = 'a';    c = 'e';    break;
X                case 148:
X                    *cp++ = 'o';    c = 'e';    break;
X                case 129:
X                    *cp++ = 'u';    c = 'e';    break;
X                case 142:
X                    *cp++ = 'A';    c = 'e';    break;
X                case 153:
X                    *cp++ = 'O';    c = 'e';    break;
X                case 154:
X                    *cp++ = 'U';    c = 'e';    break;
X                case 225:  case 158:
X                    *cp++ = 's';    c = 's';    break;
X                default:
X                    c = '*';                    break;
X            }
X        }
X
X        /*
X         * If last character caused line wrap, and we now got another linefeed,
X         * skip this linefeed to avoid unneeded empty lines.
X         */
X        if (last_char_wrapped) {
X            if (c == '\n') {
X                last_char_wrapped = FALSE;
X                continue;
X            }
X
X            if (isspace(c) && strempty(buffer))
X                continue;
X        }
X
X        *cp++ = c;
X
X        if (c == '\n')
X            break;
X
X        *cp = 0;
X
X        /*
X         * Try to wrap if line is too long and it is not a seen-by, origin or
X         * path line.
X         */
X        if (strlen(buffer) >= MAX_LINELEN &&
X            strncmp(" * Origin:", buffer, 10) &&
X            strncmp("SEEN-BY:", buffer, 8) &&
X            strncmp("^A", buffer, 2) &&
X            strncmp("FSC-Control:", buffer, 12)) {        /* - 1 for \n */
X            last_char_wrapped = TRUE;
X
X            /* Search for place to cut */
X            for (index = strlen(buffer) - 1; index >= 0; index--) {
X                c = buffer[index];
X                if (index <= MAX_LINELEN / 3) {
X                    /* Too long, cut. */
X                    *cp++ = c = '\n';
X                    goto collected;
X                }
X
X                if (isspace(c)) {
X                    /* Wrap here! */
X                    cp = buffer + index + 1;    /* Punctuation left on this
X                                                 * line */
X                    strcpy(wordsave, cp);
X                    debug(20, "saving word '%s'", wordsave);
X                    *cp++ = c = '\n';
X                    goto collected;
X                }
X            }
X        }
X
X        last_char_wrapped = FALSE;
X    }
X
X  collected:
X
X    /* if we got nul, put it back if occurred in the middle of line */
X    if (!c && cp != buffer)
X        (void) ungetc(0, fp);
X
X    *cp = 0;                    /* Cut it here */
X
X
X  out:
X    return ((!c || c == EOF) && cp == buffer) ? (char *) 0 : buffer;
}
X
X
X
static Packet header;
X
read_header(fp)
FILE *fp;
{
X    header.orig_node = read_int(fp);
X    header.dest_node = read_int(fp);
X    header.year      = read_int(fp);
X    header.month     = read_int(fp);
X    header.day       = read_int(fp);
X    header.hour      = read_int(fp);
X    header.minute    = read_int(fp);
X    header.second    = read_int(fp);
X    header.rate      = read_int(fp);
X    header.ver       = read_int(fp);
X    header.orig_net  = read_int(fp);
X    header.dest_net  = read_int(fp);
X    header.product   = getc(fp);
X    header.x1        = getc(fp);
X    fread(header.pwd_kludge, 8, 1, fp);
X    header.orig_zone = read_int(fp);
X    if (header.orig_zone == 0)
X        header.orig_zone = MY_ZONE;
X    header.dest_zone = read_int(fp);
X    if (header.dest_zone == 0)
X        header.dest_zone = MY_ZONE;
X    fread(header.B_fill2, 16, 1, fp);
X    fread((char *) &header.B_fill3, 4, 1, fp);
X    return(ferror(fp) || feof(fp));
}
X
X
X
/*
X * Read 16-bit integer in 80x86 format, i.e. low byte first,
X * then high byte. Machine independent function.
X */
X
int read_int(fp)
FILE *fp;
{
register int c;
register int val;
X
X    if((c = getc(fp)) == EOF) {
X        log("$Can't read file (EOF)");
X        return(0);
X    }
X    val  = c;
X    if((c = getc(fp)) == EOF) {
X        log("$Can't read file (EOF)");
X        return(0);
X    }
X    val |= c << 8;
X    return(val);
}
X
X
X
/* Read null-terminated string from file. Ensure that buffer is also
X   null-terminated. Remove possible \n:s from end, they are generated by
X   some buggy mailers. */
X
void
get_string(buffer, fp, nbytes)
char *buffer;
FILE *fp;
int nbytes;
{
X    register int n;
X    char *p;
X
X    debug(8, "get string start %ld", ftell(fp));
X
X    for (n = 0, *buffer = 0; n < nbytes; n++)
X        if ((buffer[n] = getc(fp)) == 0)
X            break;
X        else
X            debug(8, "<%d %c>", buffer[n], buffer[n]);
X
X    /* If still more chars in buffer, skip them until null char found */
X    if (n >= nbytes) {
X        debug(8, "Skipping rest");
X        while (getc(fp)) ;
X    }
X
X    buffer[nbytes] = 0;
X
X    /* Remove \n from end if its there, its a bug */
X    if (p = strchr(buffer, '\n'))
X        *p = 0;
X
X    debug(8, "Getstring at %ld %s", ftell(fp), buffer);
}
X
#define NGFLAG_ACCEPT_PRIVATE 0
#define NGFLAG_COMMAND 1
#define NGFLAG_TRASH_PRIVATE 2
X
static char distribution[64];
static char *ngflags[] =
{"accept-private", "command", "trash-private", ""};
X
/* Like strtok but returns empty string instead of null if no more thigns
X   found */
X
char *
estrtok(s, sep)
char *s, *sep;
{
X    char *p;
X
X    if (p = strtok(s, sep))
X        return p;
X    return "";
}
X
char *
get_ng(config, echo, distrib)
FILE *config;
char *echo, *distrib;
{
static char conv[BUFLEN];
char *gr, *flag;
X
X    debug(2, "Checking echolist '%s'", echo);
X
/*    section(SECT_AREA_NG, config); /**/
X    trashprivate = FALSE;
X    acceptprivate = FALSE;
X    while (getcl(conv, BUFLEN, config)) {
X        debug(3, "Config line '%s'", conv);
X
X        gr = estrtok(conv, SEPARATORS);
X        if (!strcmp(gr, echo)) {
X            /* Matched, take distribution and return newsgroup */
X
X            gr = estrtok(NULL, SEPARATORS);
X            strcpy(distrib, estrtok(NULL, SEPARATORS));
X            while (flag = strtok(NULL, SEPARATORS))
X                switch (listscan(ngflags, flag)) {
X                    case NGFLAG_ACCEPT_PRIVATE:
X                        acceptprivate = TRUE;
X                        break;
X
X                    case NGFLAG_TRASH_PRIVATE:
X                        trashprivate = TRUE;
X                        break;
X
X                    case -1:
X                    default:
X                        log("Bad flag '%s' for newsgroup %s", flag, gr);
X                        break;
X                }
X
X            debug(3, "Match, return newsgroup '%s', distribution %s",
X                  gr, distrib);
X            return gr;
X        }
X    }
X    log("No newsgroup for '%s' found, return junk, distribution local", echo);
X    strcpy(distrib, "local");
X    return "junk";
}
X
/* Check if message is news-message (currenlty: if first line begins
X   with AREA:). If area is found, we'll return name for that area,
X   otherwise NULL. */
X
char *
news_msg(fp)
FILE *fp;
{
X    FILE *config;
X    long offset = ftell(fp);
X    char *cp;
X    static char area[64];
X
X    if (ffgets(area, 64, fp) && !strncmp(area, "AREA:", 5)) {
X        /* this is echomail-message */
X        area[strlen(area) - 1] = 0;
X
X        /* strip possible spaces */
X        for (cp = area + 5; *cp && isspace(*cp); cp++) ;
X
X        if ((config = pfopen(LIBDIR, "Areas", "r")) == NULL) {
X            log("$Unable to open areas file");
X            exit(1);
X        }
X
X        strcpy(cp, get_ng(config, cp, distribution));
X        fclose(config);
X
X        /* return converted area-name */
X        return cp;
X    }
X    else {
X        /* this is not echomail message, seek back */
X        (void) fseek(fp, offset, 0);
X        return (char *) 0;
X    }
X    /* NOTREACHED */
}
X
X
X
/*
X * Return date of message in UNIX format (secs after the epoche)
X *
X * Understood formats: see getdate.y
X */
X
time_t lgetdate(packet)
FILE *packet;
{
char buffer[20];
int c;
time_t timevar;
int n;
X
X    /* read date from packet */
X    for (n = 0; n < 20; n++)
X        if ((buffer[n] = getc(packet)) == 0)
X            break;
X
X    /*
X     * Some message-packers do mistakes! Date should be 20 bytes but they start
X     * name directly after null terminating 18-char date used in some systems.
X     * Check if following char is null or not, and if not, put it back there as
X     * it probably is first char in recipent name. This seems to be problem in
X     * OMMM, but I'm not sure yet.
X     *
X     * Wed Nov 16 21:11:34 1988 Seems that the bug is in fsc001, as I constantly
X     * keep receiving messages which 19 byte date?
X     */
X
#ifdef FSC_IS_REALLY_CORRECT
X    for (n++; n < 20; n++)
X        if (c = getc(packet)) {
X            ungetc(c, packet);
X        }
#endif
X
X    buffer[19] = 0;
X    debug(8, "Getdate %s at %ld", buffer, ftell(packet));
X
X    /* try to get date */
X    timevar = getdate(buffer, NULL);
X    return timevar;
}
X
X
X
/* Search alias name which matches with fidonet name, return NULL
X   if no alias specified. */
X
char *
get_alias(name)
char *name;
{
X    char buffer[BUFSIZ];
X    char *cp;
X    FILE *fp;
X    static char unixname[BUFSIZ], fidoname[BUFSIZ];
X
X    if (fp = fopen(ALIAS, "r")) {
X        while (fgets(buffer, BUFSIZ, fp)) {
X            buffer[strlen(buffer) - 1] = 0;
X            if (*buffer != '#') {
X                if ((cp = strchr(buffer, ' ')) ?
X                    cp : (cp = strchr(buffer, '\t'))) {
X                    *cp = 0;    /* Break unixname out */
X                    strcpy(unixname, buffer);    /* And save it */
X                    debug(8, "Unix name %s", unixname);
X                }
X                else {
X                    /* No space or tab found, probably bad line */
X                    debug(1, "Bad alias line %s", buffer);
X                    continue;
X                }
X
X                /* Search for name start, there may be space between */
X                cp++;
X                while (*cp && isspace(*cp))
X                    cp++;
X                if (!*cp) {
X                    debug(1, "Bad alias line %s", buffer);
X                    continue;
X                }
X
X                strcpy(fidoname, cp);    /* Save fidonet name */
X                debug(8, "Fidoname %s", fidoname);
X
X                if (!stricmp(fidoname, name)) {
X                    fclose(fp);
X
X                    /* There may be node specs after name, null them out */
X                    if (cp = strchr(unixname, ','))
X                        *cp = 0;
X
X                    debug(8, "Fidoname %s matched with %s, return %s",
X                          fidoname, name, unixname);
X                    return unixname;
X                }
X            }
X        }
X    }
X
X    fclose(fp);
X    return NULL;
}
X
X
X
/*
X * Strip bad chars from FIDO names, i.e. chars not allowed in
X * RFC822 `atoms'. One execption is ' ' (space), which is converted
X * to '_' later on.
X */
X
stripbad(name)
char *name;
{
char *d;
X
X    for(d=name; *d; d++)
X        if( !iscntrl(*d) && !strchr("()<>@,;:\\\"[]", *d) )
X            *name++ = *d;
X    *name = 0;
}
X
X
X
/*
X * Capitalize string
X */
X
char *strcap(s)
char *s;
{
X    if(!s || !*s)
X        return(s);
X    if(islower(*s))
X        *s = toupper(*s);
X    for(s++; *s; s++)
X        if(isupper(*s))
X            *s = tolower(*s);
X    return(s);
}
X
X
X
/*
X * Convert name in FIDO from or to field to real name
X * for use in () in RFC822 header. Everything after
X * `%' or `Of' is thrown away. The result is capitalized.
X */
X
realname_convert(name, realname)
char *name;
char *realname;
{
char *p, *string;
int cat_flag = 0;
X
X    string = strsave(name);
X    *realname = 0;
X    for(p=strtok(string, " \t"); p; p=strtok(NULL, " \t")) {
X        if(!strcmp(p, "%") || !strcmp(p, "of") || !strcmp(p, "Of") ||
X           !strcmp(p, "-")                                                )
X            break;
X        strcap(p);
X        if(cat_flag)
X            strcat(realname, " ");
X        strcat(realname, p);
X        cat_flag = 1;
X    }
X    free(string);
}
X
X
X
/* Unpack packet and all files in it. Packet's header will be stripped
X   off. For each message check if it is news-msg (First line begins
X   with AREA:). If it is, send it to news-sender sfnews, otherwise
X   send it to rmail. Address is given in to-field, or if it wont
X   fit to it, in the first line of message. In later case to-field
X   must be "Usenet". */
X
void
unpack(packet, packetnode)
FILE *packet;
Node packetnode;
{
/*
X * Variables for header info
X */
Node msg_orignode, msg_destnode;        /* Origin/destination address */
int msg_attributes;                        /* Attributes of message (priv. etc.) */
time_t msg_date;                        /* Date of message */
char msg_to[36];                        /* To name */
char msg_from[36];                        /* From name */
char msg_subject[72];                    /* Subject */
/*
X * Variables for info from FIDO kludges
X */
Node origin_node;                        /* Address in origin line */
char origin_text[128];                    /* Organization taken from * Origin */
X
int lines;                                /* Lines in message body */
X
char *area;                                /* Area / newsgroup (NULL = mail) */
char *p;
int count, messagetype;
char realto[40], realfrom[40];
char searchto[36];
char buffer[BUFSIZ];
int c;
Node *entry, mynode;
Node node;
char hostname[10];
long msgid;                                /* Msg id from sequence file */
char out_name[128];                        /* Name for output msg */
char mail_to[128];                        /* Addressee of mail */
FILE *outtmp, *out;
int rfc_header_flag;
X
X
#ifdef NODELIST_SUPPORT
X    /* get node-entry fo packet-sender */
X    if (node_entry(packetnode) == NULL) {
X        log("Unknown packet sender: %s", ascnode(packetnode));
X        return;
X    }
#endif
X
X    mynode.zone = MY_ZONE;
X    mynode.net = MY_NET;
X    mynode.node = MY_NODE;
X    mynode.point = MY_POINT;
X    strcpy(mynode.name, MY_NAME);
X
#ifdef NODELIST_SUPPORT
X    if ((entry = node_entry(mynode)) == NULL) {
X        log("Unable to find this net/node from nodelist");
X        return;
X    }
#else
X    entry = &mynode;
#endif
X
X    /* get our uucp-nodename */
X    if (gethostname(hostname, 10) == -1) {
X        log("Unable to get hostname");
X        return;
X    }
X
X    while ((messagetype = read_int(packet)) == MSGTYPE) {
X        /*
X         * Clear stuff set by parsing message body
X         */
X        origin_node.zone = -1;
X        origin_text[0] = 0;
X        msgbody_fmpt = 0;
X        msgbody_msgid[0] = 0;
X        msgbody_reply[0] = 0;
X        msgbody_intl[0]  = 0;
X        if(msgbody_rfc_from) {
X            free(msgbody_rfc_from);
X            msgbody_rfc_from = NULL;
X        }
X        if(msgbody_rfc_to) {
X            free(msgbody_rfc_to);
X            msgbody_rfc_to = NULL;
X        }
X        lines = 1;
X
X        /*
X         * Initialize some stuff
X         */
X        msg_orignode.zone  = packetnode.zone;
X        msg_orignode.point = packetnode.point;
X        msg_destnode.zone  = packetnode.zone;
X        msg_destnode.point = packetnode.point;
X
X        /*
X         * Read FIDO message header and save information
X         */
X        /***** Origin/destination node *****/
X        msg_orignode.node = read_int(packet);
X        msg_destnode.node = read_int(packet);
X        /***** Origin/destination net *****/
X        msg_orignode.net = read_int(packet);
X        msg_destnode.net = read_int(packet);
X        debug(2, "Origin:      %s", ascnode(msg_orignode));
X        debug(2, "Destination: %s", ascnode(msg_destnode));
X        /***** Message attributes *****/
X        msg_attributes = read_int(packet);
X        /***** Cost (thrown away) *****/
X        read_int(packet);
X        /***** Date *****/
X        msg_date = lgetdate(packet);
X        /***** To name *****/
X        get_string(msg_to, packet, 35);
X        debug(2, "To:      %s", msg_to);
X        /***** From name *****/
X        get_string(msg_from, packet, 35);
X        debug(2, "From:    %s", msg_from);
X        /***** Subject *****/
X        get_string(msg_subject, packet, 71);
X        /* Remove trailing blanks */
X        for(count = strlen(msg_subject) - 1;
X            count >= 0 && isspace(msg_subject[count]);
X            count--                                    )
X            msg_subject[count] = 0;
X        if (!*msg_subject)
X            strcpy(msg_subject, "(no subject)");
X        debug(2, "Subject: %s", msg_subject);
X
X        /*
X         * Check that message is addressed to this node
X         */
X        if(!samenode(msg_destnode, mynode)) {
X            log("Msg from %s to %s at %s: wrong node address",
X                msg_from, msg_to, ascnode(msg_destnode));
X            goto error;
X        }
X
X        /*
X         * Strip bad chars from header fields
X         */
X        stripbad(msg_from);
X        stripbad(msg_to);
X        strcpy(searchto, msg_to);
X        /*
X         * Convert to real names for use in ()
X         */
X        realname_convert(msg_from, realfrom);
X        realname_convert(msg_to, realto);
X        /*
X         * Convert spaces to `_'
X         */
X        for(p=msg_from; *p; p++)
X            *p = *p==' ' ? '_' : *p;
X        for(p=msg_to; *p; p++)
X            *p = *p==' ' ? '_' : *p;
X
X        /*
X         * Get next message-id
X         */
X        msgid = sequencer(IDSEQUENCE);
X
X        /*
X         * Check for mail or news.
X         * Read first line from FIDO message body. If it starts with
X         * `AREA:...' then it is news, else it is mail. area is newsgroup
X         * name or NULL for mail.
X         */
X        if ((area = news_msg(packet)) &&
X            (acceptprivate || !(msg_attributes & ATTR_PRIVATE)))
X        {
X            /*
X             * This is a news article.
X             */
X            debug(1, "Message is news-article");
X            sprintf(out_name, "%s/unpacked/N.%ld", SPOOL, msgid);
X        }
X        else {
X            /*
X             * This is personal mail
X             */
X            debug(1, "Message is for mail");
X            sprintf(out_name, "%s/unpacked/M.%ld", SPOOL, msgid);
X
X            if (area) {
X                debug(1, "Private message for area %s", area);
X                if (trashprivate)
X                    goto error;
X            }
X
X            debug(8, "Searching alias for %s", searchto);
X            if (p = get_alias(searchto)) {
X                (void) strcpy(buffer, p);
X                debug(8, "Got alias %s", buffer);
X            }
X            else {
X                if (area) {
X                    log("Skipping private echo for %s", msg_to);
X                    goto error;        /* If private echo message, skip */
X                }
X                (void) strcpy(buffer, msg_to);
X                debug(8, "No alias, using %s", buffer);
X            }
X
X            for(p=buffer; *p; p++)
X                *p = isupper(*p) ? tolower(*p) : *p;
X
X            strcpy(mail_to, buffer);
X            log("Sending mail from %s at %s to %s", msg_from,
X                ascnode(msg_orignode), buffer );
X
X            area = NULL;
X        }
X
X        /*
X         * Create files
X         */
X        outtmp = tmpfile();
X        if(!outtmp) {
X            log("$Can't create temp file");
X            goto error;
X        }
X        out = fopen(out_name, "w");
X        if(!out) {
X            log("$Can't create output file %s", out_name);
X            fclose(outtmp);
X            goto error;
X        }
X
X        /*
X         * Read entire FIDO message body and write it
X         * to temporary file for later use. (Must read
X         * message body first `cause we need some information
X         * from it.)
X         * Some special treatment for origin line and ^A
X         * kludges is done.
X         */
X        rfc_header_flag = 1;
X        while(ffgets(buffer, BUFSIZ, packet)) {
X            if(!strncmp(buffer, "^A", 2)) {
X                check_ctrl_a(buffer);
X                continue;
X            }
X            else if(rfc_header_flag) {
X                rfc_header_flag = check_rfc_header(buffer);
X            }
X            if(!strncmp(" * Origin:", buffer, 10)) {
X                check_origin(buffer, &origin_node, origin_text);
X            }
X            lines++;
X            fputs(buffer, outtmp);
X        }
X
X        /*
X         * Construct real from address, using information from
X         * header, origin line and ^A kludges.
X         */
X        if (origin_node.zone != -1) {
X            debug(1, "Using address from ` * Origin: ...'");
X            msg_orignode = origin_node;
X        }
X        else {
X            debug(1, "Using address in message header");
X        }
X        if(*msgbody_intl) {
X            p = strtok(msgbody_intl, " \n");        /* Destination */
X            p = strtok(NULL        , " \n");        /* Source */
X            if(p)
X                if(!parsefnetaddress(p, &node)) {
X                    debug(1, "Using address from ^AINTL");
X                    msg_orignode = node;
X                }
X        }
X        if(msgbody_fmpt) {
X            debug(1, "Point address %d", msgbody_fmpt);
X            msg_orignode.point = msgbody_fmpt;
X        }
X        debug(1, "New from address %s", ascnode(msg_orignode));
X
X        /*
X         * Output `From user ...' for mail
X         */
X        if(!area) {
X            fprintf(out, "From %s %s remote from %s\n",
X                        msg_from,
X                        date("%a %h %d %T 19%y", (long *) 0),
X                        internode(packetnode)                    );
X        }
X
X        /*
X         * Output RFC822 header for mail/news
X         */
X        if(area)
X            fprintf(out, "Path: %s!%s!%s\n",
X                         internode(this), internode(msg_orignode), msg_from);
X        else {
X            fprintf(out, "Received: by %s (%s/%s)\n",
X                    internode(*entry), PROGRAMNAME, entry->name);
X            fprintf(out, "\tid AA%05d; %s\n",
X                    getpid(), date("%a, %d %h %y %T %o (%z)", (long *) 0));
X        }
X        fprintf(out, "Date: %s\n", date("%a, %d %h %y %T %o", &msg_date));
X        if(msgbody_rfc_from) {
X            if(strchr(msgbody_rfc_from, '('))
X                fprintf(out, "From: %s\n", msgbody_rfc_from);
X            else
X                fprintf(out, "From: %s (%s)\n", msgbody_rfc_from, realfrom);
X        }
X        else
X            fprintf(out, "From: %s@%s (%s)\n", msg_from, internode(msg_orignode),
X                    realfrom);
X        fprintf(out, "Subject: %s\n", msg_subject);
X        if(!*msgbody_msgid ||
X           generate_msgid(out, "Message-ID:", msgbody_msgid) )
X            fprintf(out, "Message-ID: <funpack%lu@%s>\n", msgid, internode(*entry));
X        if(*msgbody_reply)
X            generate_msgid(out, "References:", msgbody_reply);
X
X        if (area) {
X            /*
X             * News special
X             */
X            fprintf(out, "Newsgroups: %s\n", area);
X            if(*distribution)
X                fprintf(out, "Distribution: %s\n", distribution);
X            /***** This is a *USER DEFINED* header, not in RFC822 !!! *****/
X            fprintf(out, "Comment-To: %s@%s (%s)\n", msg_to,
X                    internode(msg_destnode), realto);
X        }
X        else {
X            /*
X             * Mail special
X             */
X            if(msgbody_rfc_to) {
X                if(strchr(msgbody_rfc_to, '('))
X                    fprintf(out, "To: %s\n", msgbody_rfc_to);
X                else
X                    fprintf(out, "To: %s (%s)\n", msgbody_rfc_to, realto);
X            }
X            else
X                fprintf(out, "To: %s\n", mail_to);
X        }
X        /*
X         * Some more headers ...
X         */
X        if(*origin_text)
X            fprintf(out, "Organization: %s\n", origin_text);
X        fprintf(out, "Lines: %d\n", lines);
X
X        /*
X         * Append message body in temporary file to message
X         */
X        fprintf(out, "\n");
X
X        rewind(outtmp);
X        while(fgets(buffer, BUFSIZ, outtmp))
X            fputs(buffer, out);
X
X        /*
X         * Dome with this message.
X         */
X        fclose(outtmp);
X        fclose(out);
X        debug(1, "Done with message");
X        continue;
X
X        /*
X         * In case of error skip text of message
X         */
error:
X        while((c = getc(packet)) && c != EOF);
X    }
X
X    if (messagetype != MSGTYPE && messagetype != EOF && messagetype != 0)
X        log("Strange ending: %d", messagetype);
X
X    debug(1, "Done with packet");
}
X
X
X
main(argc, argv)
int argc;
char *argv[];
{
struct dirent *dir;
DIR *dp;
int c;
FILE *packet;
char files[BUFLEN];
Node node;
bool nocheck = FALSE;
char *error, *p;
Node packetnode;
X
X    node.zone = -1;
X    while ((c = getopt(argc, argv, "if:vV:")) != EOF)
X        switch (c) {
X            case 'i':
X                nocheck = TRUE;
X                break;
X            case 'v':
X                verbose++;
X                break;
X            case 'V':
X                verbose = atoi(optarg);
X                break;
X            case 'f':
X                if (parsefnetaddress(optarg, &node))
X                    exit(1);
X                break;
X            default:
X                fprintf(stderr, "%s\n\n", PROGRAMNAME);
X                fprintf(stderr, "usage: funpack [-iv] [-V verbose_level] [-f Z:N/F.P]\n\n");
X                exit(EX_USAGE);
X                break;
X        }
X
X    this.zone  = MY_ZONE;
X    this.net   = MY_NET;
X    this.node  = MY_NODE;
X    this.point = MY_POINT;
X    strcpy(this.name, MY_NAME);
X
X    /* create name for unpacking */
X    if (node.zone == -1)
X        (void) strcpy(files, "");
X    else {
X        sprintipacketname(files, node);
X        /* Cut sequence number off */
X        if (p = strrchr(files, "."))
X            *p = 0;
X    }
X
X    debug(2, "Unpacking packets beginning with %s", files);
X
X    /* try to update nodelist-index */
#ifdef NODELIST_SUPPORT
X    if (error = update_index()) {
X        if (*error == '$')
X            log("$Cannot update nodelist-index: %s", error + 1);
X        else
X            log("Cannot update nodelist-index: %s", error);
X        exit(EX_OSERR);
X    }
#endif
X    if (chdir(sprintfs("%s/in", SPOOL)) == -1) {
X        log("$Cannot chdir to %s/in", SPOOL);
X        exit(EX_OSERR);
X    };
X    if (dp = opendir(".")) {
X        while (dir = readdir(dp))
X            if (!strncmp(dir->d_name, files, strlen(files)) && *dir->d_name != '.') {
X
X                /* this packet is right */
X                debug(1, "Unpacking %s", dir->d_name);
X
X                /* open packet */
X                if (packet = fopen(dir->d_name, "r")) {
X                    if (read_header(packet)) {
X                        if (feof(packet))
X                            log("Missing packet header");
X                        else
X                            log("$Error reading header");
X                    }
X                    else {
X                        packetnode.zone  = header.orig_zone;
X                        packetnode.net   = header.orig_net;
X                        packetnode.node  = header.orig_node;
X                        packetnode.point = 0;
X                        debug(1, "Packet from %s", ascnode(packetnode));
X                        debug(1, "Time %02d:%02d:%02d %d.%d.%d",
X                                header.hour, header.minute, header.second,
X                                header.day, header.month+1, header.year   );
X                        debug(1, "Max baud rate %d, version %d, product %d, x %d",
X                                header.rate, header.ver, header.product, header.x1);
X                        debug(1, "Pwd \"%s\"", header.pwd_kludge);
X                    }
X
X                    if (nocheck || ((header.dest_zone == MY_ZONE ||
X                                     header.dest_zone == 0) &&
X                                    header.dest_node == MY_NODE &&
X                                    header.dest_net == MY_NET))
X                        unpack(packet, packetnode);
X                    else
X                        log("Packet is to %d:%d/%d",
X                            header.dest_zone,
X                            header.dest_net,
X                            header.dest_node);
X                    (void) fclose(packet);
X
X                    if (unlink(dir->d_name))
X                        log("$Could not unlink packet %s", dir->d_name);
X                }
X                else
X                    log("$Unable open packet %s", dir->d_name);
X            }
X        (void) closedir(dp);
X    }
X    else {
X        log("$Unable to open spool directory");
X        exit(EX_OSERR);
X    }
X    exit(EX_OK);
X    /* NOTREACHED */
}
SHAR_EOF
chmod 0644 funpack.c ||
echo 'restore of funpack.c failed'
Wc_c="`wc -c < 'funpack.c'`"
test 32138 -eq "$Wc_c" ||
    echo 'funpack.c: original size 32138, current size' "$Wc_c"
fi
true || echo 'restore of nodelist.c failed'
echo End of part 5, continue with part 6
exit 0

--
 _____ _____
|     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
| | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
|_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931