Return to to822.c CVS log

Up to [Research Unix] / researchv8dc / cmd / upas / rfc822

Annotation of researchv8dc/cmd/upas/rfc822/to822.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <ctype.h>
                      3: #include "mail.h"
                      4: #include "header.h"
                      5: #include "string.h"
                      6: 
                      7: /* imports */
                      8: header hdrs[] = {
                      9:        HEADER("Date:"),
                     10:        HEADER("From:"),
                     11:        HEADER("To:"),
                     12:        HEADER("Received:"),
                     13:        HEADER("Message-Id:"),
                     14:        HEADER("Status:"),
                     15:        HEADER("")
                     16: };
                     17: #define datehdr hdrs[0]
                     18: #define fromhdr hdrs[1]
                     19: #define tohdr hdrs[2]
                     20: #define receivedhdr hdrs[3]
                     21: #define idhdr hdrs[4]
                     22: #define statushdr hdrs[5]
                     23: 
                     24: /* imported */
                     25: extern void getheader();
                     26: extern void printheaders();
                     27: extern void addheader();
                     28: extern char *fgets();
                     29: extern int getunix();
                     30: extern void initgetunix();
                     31: 
                     32: /* predeclared */
                     33: char *gets();
                     34: static char *convertdate();
                     35: extern char *convertaddr();
                     36: 
                     37: extern void
                     38: to822(fp, hostname)
                     39: FILE *fp;              /* file to output to */
                     40: char *hostname;                /* name of our host */
                     41: {
                     42:        char buf[FROMLINESIZE];
                     43:        char from[FROMLINESIZE];
                     44:        char date[DATESIZE];
                     45: 
                     46:        /* get UNIX from line */
                     47:        if (fgets(buf, sizeof buf, stdin) == NULL)
                     48:                exit(1);
                     49: 
                     50:        /* first line had better be a from */
                     51:        if (getunix(buf, from, date) == 0)
                     52:                exit(1);
                     53: 
                     54:        /* get any pre-existing RFC822 header lines */
                     55:        getheader();
                     56: 
                     57:        /* output new message */
                     58:        fprintf(fp, "%s %s.%s\n", fromhdr.name, convertaddr(from), hostname);
                     59:        fprintf(fp, "%s %s\n\n", datehdr.name, convertdate(date));
                     60:        printheaders(fp);
                     61:        while (gets(buf) != NULL)
                     62:                fprintf(fp, "%s\n", buf);
                     63: }
                     64: 
                     65: /* juggle date fields */
                     66: static char *
                     67: convertdate(date)
                     68: char *date;
                     69: {
                     70:        static char ndate[DATESIZE];
                     71:        char *field[6];
                     72:        char *sp;
                     73:        int i;
                     74: 
                     75:        sp = date;
                     76:        /* parse the date into fields */
                     77:        for (i = 0; i < 6; i++) {               
                     78:                while (isspace(*sp) || *sp == ',' || *sp == '-')
                     79:                        *sp++ = '\0';
                     80:                field[i] = sp;
                     81:                while (!isspace(*sp) && *sp != ',' && *sp != '-' && *sp != '\0')
                     82:                        sp++;
                     83:        }
                     84:        *sp = '\0';
                     85: 
                     86:        /* shuffle the fields into internet format */
                     87:        sprintf (ndate, "%s, %s %s %s %s %s", field[0], field[2], field[1],
                     88:                 field[4], field[5], field[3]);
                     89:        return ndate;
                     90: }
                     91: 
                     92: /*
                     93:  *     Convert from `bang' to `rfc822' format.
                     94:  */
                     95: extern char *
                     96: convertaddr(addr)
                     97: char *addr;
                     98: {
                     99:        static char buf[FROMLINESIZE];
                    100:        register int i=0;
                    101:        register char *sp;
                    102:        char *field[128];
                    103: 
                    104:        sp = field[i] = addr;
                    105:        while (*sp) {
                    106:                if (*sp == '!') {
                    107:                        *sp = '\0';
                    108:                        if (strcmp(field[i], "uucp") == 0) {
                    109:                                /* the token 'uucp' stops the parsing */
                    110:                                field[i] = ++sp;
                    111:                                break;
                    112:                        }
                    113:                        field[++i] = ++sp;
                    114:                } else
                    115:                        ++sp;
                    116:        }
                    117:        strcpy(buf, field[i--]);
                    118:        if (i >= 0) {
                    119:                strcat(buf, "@");
                    120:                strcat(buf, field[i--]);
                    121:        }
                    122:        while (i >= 0) {
                    123:                strcat(buf, ".");
                    124:                strcat(buf, field[i--]);
                    125:        }
                    126:                
                    127:        return buf;
                    128: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.