Return to to822.c CVS log

Up to [Research Unix] / researchv10no / cmd / nupas / smtp

Annotation of researchv10no/cmd/nupas/smtp/to822.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <ctype.h>
        !             3: #include <regexp.h>
        !             4: #include "mail.h"
        !             5: #include "string.h"
        !             6: #include "header.h"
        !             7: #include "aux.h"
        !             8: #include "addrformat.h"
        !             9: 
        !            10: /* imports */
        !            11: header hdrs[] = {
        !            12:        HEADER("Date:"),
        !            13:        HEADER("From:"),
        !            14:        HEADER("To:"),
        !            15:        HEADER("")
        !            16: };
        !            17: #define datehdr hdrs[0]
        !            18: #define fromhdr hdrs[1]
        !            19: #define tohdr hdrs[2]
        !            20: 
        !            21: /* imported */
        !            22: extern int getheader();
        !            23: extern int printheaders();
        !            24: extern void printbodies();
        !            25: extern char *fgets();
        !            26: extern string *getaddr();
        !            27: extern int cistrncmp();
        !            28: extern void exit();
        !            29: extern int debug;
        !            30: 
        !            31: /* predeclared */
        !            32: static char *convertdate();
        !            33: extern char *convertaddr();
        !            34: static int indomain();
        !            35: 
        !            36: /* exported */
        !            37: int extrafrom = 0;
        !            38: 
        !            39: extern int
        !            40: to822(fputsp, in, out, sender, domain, rcvr)
        !            41:        int (*fputsp)();
        !            42:        FILE *in, *out;         /* file to output to */
        !            43:        char *sender;           /* name of sender (already in 822 format) */
        !            44:        char *domain;
        !            45:        char *rcvr;
        !            46: {
        !            47:        string *buf=s_new();
        !            48:        string *from=s_new();
        !            49:        string *date=s_new();
        !            50:        string *remfrom=s_new();
        !            51:        string *faddr;
        !            52:        static regexp *pp=NULL;
        !            53:        int originalfrom=0;
        !            54:        regsubexp subexp[10];
        !            55:        char xbuf[4096];
        !            56:        int n;
        !            57:        char *cp;
        !            58: 
        !            59:        /* get UNIX from line */
        !            60:        if(fgets(xbuf, sizeof xbuf, in)==NULL) {
        !            61:                fprintf(stderr, "to822: empty file.\n");
        !            62:                return -1;
        !            63:        }
        !            64: 
        !            65:        /* first line had better be a from */
        !            66:        if (pp==NULL)
        !            67:                pp = regcomp(REMFROMRE);
        !            68:        if (regexec(pp, xbuf, subexp, 10)) {
        !            69:                append_match(subexp, from, REMSENDERMATCH);
        !            70:                append_match(subexp, date, REMDATEMATCH);
        !            71:                append_match(subexp, remfrom, REMSYSMATCH);
        !            72:        } else {
        !            73:                fprintf(stderr, "to822: From_ line missing or malformed.\n");
        !            74:                return -1;
        !            75:        }
        !            76: 
        !            77:        /* get any pre-existing RFC822 header lines */
        !            78:        if(getheader(fgets, in)<0){
        !            79:                fprintf(stderr, "to822: error reading input.\n");
        !            80:                return -1;
        !            81:        }
        !            82: 
        !            83:        /*
        !            84:         *  Output new message.  If there is an original From: line with
        !            85:         *  an address in the requested domain, leave it alone.  Otherwise
        !            86:         *  generate a From: line and turn any existing one into
        !            87:         *  Original-From:
        !            88:         */
        !            89:        if (fromhdr.line != NULL) {
        !            90:                faddr = getaddr(HCONTENT(fromhdr));
        !            91:                if(domain!=NULL && !indomain(s_to_c(faddr), domain)){
        !            92:                        sprintf(xbuf, "%s %s\n", fromhdr.name, sender);
        !            93:                        (*fputsp)(xbuf, out);
        !            94:                        originalfrom = 1;
        !            95:                }
        !            96:        } else {
        !            97:                sprintf(xbuf, "%s %s\n", fromhdr.name, sender);
        !            98:                (*fputsp)(xbuf, out);
        !            99:        }
        !           100:        if (datehdr.line == NULL){
        !           101:                sprintf(xbuf, "%s %s\n", datehdr.name, convertdate((s_to_c(date))));
        !           102:                (*fputsp)(xbuf, out);
        !           103:        }
        !           104:        if (tohdr.line == NULL && rcvr != NULL){
        !           105:                sprintf(xbuf, "%s %s\n", tohdr.name, rcvr);
        !           106:                (*fputsp)(xbuf, out);
        !           107:        }
        !           108:                
        !           109:        printheaders(fputsp, out, originalfrom);
        !           110:        (*fputsp)("\n", out);
        !           111:        printbodies(fputsp, out);
        !           112:        n = 0;
        !           113:        while (fgets(xbuf, sizeof(xbuf), in)!=NULL) {
        !           114:                (*fputsp)(xbuf, out);
        !           115:                n += strlen(xbuf)+1;
        !           116:                if (n>1024) {
        !           117:                        if (debug)
        !           118:                                fprintf(stderr, ".");
        !           119:                        n -= 1024;
        !           120:                        setalarm(5 * 60, "sending mail data");
        !           121:                }
        !           122:        }
        !           123:        s_free(from);
        !           124:        s_free(date);
        !           125: 
        !           126:        if(ferror(in))
        !           127:                return -1;
        !           128: 
        !           129:        return 0;
        !           130: }
        !           131: 
        !           132: /* juggle date fields
        !           133:        Unix ctime: Mon Oct 19 19:47:25 EDT 1987
        !           134:        822 standard: [Mon, ] 19 Oct 87 19:47:25 EDT
        !           135:                (sometimes the , is omitted; sometimes (Mon) at end)
        !           136:  */
        !           137: static char *
        !           138: convertdate(date)
        !           139: char *date;
        !           140: {
        !           141:        static string *ndate=NULL;
        !           142:        char *field[6];
        !           143:        char *sp;
        !           144:        int i;
        !           145: 
        !           146:        sp = date;
        !           147:        /* parse the date into fields */
        !           148:        for (i = 0; i < 6; i++) {               
        !           149:                while (isspace(*sp) || *sp == ',' || *sp == '-')
        !           150:                        *sp++ = '\0';
        !           151:                field[i] = sp;
        !           152:                while (!isspace(*sp) && *sp != ',' && *sp != '-' && *sp != '\0')
        !           153:                        sp++;
        !           154:        }
        !           155:        *sp = '\0';
        !           156:        if (strlen(field[5])==4)
        !           157:                field[5] += 2;
        !           158: 
        !           159:        /* shuffle the fields into internet format */
        !           160:        if (ndate==NULL)
        !           161:                ndate = s_new();
        !           162:        s_restart(ndate);
        !           163:        s_append(ndate, field[0]);
        !           164:        s_append(ndate, ", ");
        !           165:        s_append(ndate, field[2]);
        !           166:        s_append(ndate, " ");
        !           167:        s_append(ndate, field[1]);
        !           168:        s_append(ndate, " ");
        !           169:        s_append(ndate, field[5]);
        !           170:        s_append(ndate, " ");
        !           171:        s_append(ndate, field[3]);
        !           172:        s_append(ndate, " ");
        !           173:        s_append(ndate, field[4]);
        !           174:        return s_to_c(ndate);
        !           175: }
        !           176: 
        !           177: /*
        !           178:  *  return true if addr belongs to domain
        !           179:  */
        !           180: static int
        !           181: indomain(addr, domain)
        !           182:        char *addr;
        !           183:        char *domain;
        !           184: {
        !           185:        int n, m;
        !           186:        int punct;
        !           187: 
        !           188:        n = strlen(domain);
        !           189:        m = strlen(addr);
        !           190:        if(m<n)
        !           191:                return 0;
        !           192:        punct = *(addr+m-n);
        !           193:        if(punct!='@' && punct!='.')
        !           194:                return 0;
        !           195:        return(cistrncmp(addr+m-n+1, domain+1, n-1)==0);
        !           196: }

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