Return to uurec.c CVS log

Up to [Research Unix] / researchv10no / cmd / netnews / src

Annotation of researchv10no/cmd/netnews/src/uurec.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * uurec - receive articles via /bin/mail.
                      3:  */
                      4: 
                      5: static char *SccsId = "@(#)uurec.c     2.3     3/3/83";
                      6: 
                      7: #include "defs.h"
                      8: 
                      9: #include <stdio.h>
                     10: #include <ctype.h>
                     11: 
                     12: /*
                     13:  * Process a news article which has been shipped via /bin/mail.
                     14:  */
                     15: 
                     16: #define FROM   01
                     17: #define NLIN   02
                     18: #define BLANK  03
                     19: #define OTHER  04
                     20: 
                     21: #define SKIPPING       010
                     22: #define READING                020
                     23: 
                     24: #define BFSZ 250
                     25: 
                     26: #define EOT    '\004'
                     27: 
                     28: #define A      01
                     29: #define B      02
                     30: 
                     31: #ifdef debug
                     32: # define RNEWS "cat"
                     33: #endif
                     34: extern char    *strcat(), *strcpy();
                     35: extern char    *frombreak();
                     36: extern FILE    *popen();
                     37: 
                     38: /* ARGSUSED */
                     39: main(argc, argv)
                     40: int argc;
                     41: char **argv;
                     42: {
                     43:        char buf[BFSZ], fbuf[BFSZ];
                     44:        register char *p;
                     45:        register FILE *pipe = stdout;
                     46:        register int mode, frmflg, pathcnt, format;
                     47: 
                     48:        mode = SKIPPING;
                     49:        frmflg = FALSE;
                     50:        while (fgets(buf, BFSZ, stdin) != NULL) {
                     51: #ifdef debug
                     52:                printf("%o\t%s", mode|type(buf), buf);
                     53: #endif
                     54:                switch (mode | type(buf)) {
                     55: 
                     56:                case FROM | SKIPPING:
                     57:                        if (frmflg)
                     58:                                p = frombreak(p, buf);
                     59:                        else
                     60:                                p = fbuf;
                     61:                        frmflg = TRUE;
                     62:                        break;
                     63: 
                     64:                case FROM | READING:
                     65:                        if (!frmflg) {
                     66:                                frmflg = TRUE;
                     67:                                p = fbuf;
                     68:                                pclose(pipe);
                     69:                        }
                     70:                        p = frombreak(p, buf);
                     71:                        break;
                     72: 
                     73:                case NLIN | SKIPPING:
                     74:                        if ((isupper(buf[1]) && index(buf, ':')) || !strncmp(buf, "From ", 5))
                     75:                                format = B;
                     76:                        else
                     77:                                format = A;
                     78: #ifdef debug
                     79:                        printf("format = %d\n", format);
                     80: #endif
                     81:                        mode = READING;
                     82: 
                     83:                case NLIN | READING:
                     84:                        if (frmflg) {
                     85:                                frmflg = FALSE;
                     86:                                --p;
                     87:                                while (p >= fbuf && *--p != '!')
                     88:                                        ;
                     89:                                *++p = '\0';
                     90:                                pathcnt = 0;
                     91:                                if ((pipe = popen(RNEWS, "w")) == NULL) {
                     92:                                        perror("uurec: popen failed");
                     93:                                        exit(1);
                     94:                                }
                     95:                        }
                     96:                        if (format == A) {
                     97:                                if (++pathcnt == 3)
                     98:                                        fputs(fbuf, pipe);
                     99:                                fputs(buf+1, pipe);
                    100:                        } else {
                    101:                                if (!pathcnt && (!strncmp(buf+1, "From: ", 6) || !strncmp(buf+1, "From ", 5))) {
                    102:                                        pathcnt++;
                    103:                                        fprintf(pipe, "From: %s", fbuf);
                    104:                                        sscanf(buf, "%s %s", fbuf, fbuf);
                    105:                                        fprintf(pipe, "%s\n", fbuf);
                    106:                                } else
                    107:                                        fputs(buf+1, pipe);
                    108:                        }
                    109:                        break;
                    110: 
                    111:                case OTHER | SKIPPING:
                    112:                        break;
                    113: 
                    114:                case OTHER | READING:
                    115:                        pclose(pipe);
                    116:                        mode = SKIPPING;
                    117:                }
                    118:        }
                    119:        if (pipe)
                    120:                pclose(pipe);
                    121:        exit(0);
                    122: }
                    123: 
                    124: type(p)
                    125: register char *p;
                    126: {
                    127:        while (*p == ' ' || *p == '?')
                    128:                ++p;
                    129: 
                    130:        if (*p == 'N')
                    131:                return (NLIN);
                    132: 
                    133:        if (strncmp(p, ">From", 5) == 0)
                    134:                return (FROM);
                    135: 
                    136:        if (strncmp(p, "From", 4) == 0)
                    137:                return (FROM);
                    138: 
                    139:        return(OTHER);
                    140: }
                    141: 
                    142: /*
                    143:  * Get the system name out of a from line.
                    144:  */
                    145: char *
                    146: frombreak(buf, fbuf)
                    147: register char *buf, *fbuf;
                    148: {
                    149:        register char *p;
                    150: 
                    151:        /* break the line into tokens. */
                    152:        p = fbuf;
                    153:        while (*++p != '\0')
                    154:                switch (*p) {
                    155:                case '\n':
                    156:                case '\t':
                    157:                case ' ':
                    158:                        *p = '\0';
                    159:                        break;
                    160:                case EOT:
                    161:                        goto garbled;
                    162:                default:;
                    163:                }
                    164:        *++p = EOT;
                    165:        *++p = '\0';
                    166: 
                    167:        for (p=fbuf; *p != EOT  || p[1] != '\0'; p += strlen(p)+1) {
                    168:                if (strcmp(p, "forwarded") == 0)
                    169:                        return(buf);
                    170:                if (strcmp(p, "remote") == 0) {
                    171:                        p += strlen(p)+1;
                    172:                        if (strcmp(p, "from") == 0) {
                    173:                                p += strlen(p)+1;
                    174:                                strcpy(buf, p);
                    175:                                strcat(buf, "!");
                    176:                                return(buf+strlen(buf));
                    177:                        }
                    178:                }
                    179:        }
                    180:     garbled:
                    181:        strcat(buf, "???!");
                    182:        return(buf+4);
                    183: }

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