Return to header.c CVS log

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

Annotation of researchv8dc/cmd/upas/rfc822/header.c, revision 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: /* imported */
        !             8: extern char *malloc();
        !             9: extern char *strcpy();
        !            10: extern char *strchr();
        !            11: extern int strncmp();
        !            12: extern char *fgets();
        !            13: 
        !            14: /* predeclared */
        !            15: extern void addheader();
        !            16: static char *newstring();
        !            17: 
        !            18: /*
        !            19:  *     Input header from standard input.  Actually two extra lines are also
        !            20:  *     read, but this isn't a problem.  Save some header lines in the header
        !            21:  *     array.
        !            22:  */
        !            23: extern void
        !            24: getheader()
        !            25: {
        !            26:        char buf[2*FROMLINESIZE];
        !            27:        char line[2*FROMLINESIZE];
        !            28:        header *hp;
        !            29:  
        !            30:        if (fgets(buf, sizeof buf, stdin) == NULL)
        !            31:                buf[0] = '\0';
        !            32:        while (buf[0] != '\n' && buf[0] != '\0') {
        !            33:                /* gather a multiple line header field */
        !            34:                line[0] = '\0';
        !            35:                do {
        !            36:                        (void)strcat(line, buf);
        !            37:                        if (fgets(buf, sizeof buf, stdin) == NULL)
        !            38:                                buf[0] = '\0';
        !            39:                } while (buf[0] == ' ' || buf[0] == '\t');
        !            40: 
        !            41:                /* header lines must contain `:' */
        !            42:                if (strchr(line, ':') == NULL) {
        !            43:                        addheader(line);
        !            44:                        break;
        !            45:                }
        !            46: 
        !            47:                /* look for `important' headers */
        !            48:                for (hp = hdrs; *(hp->name) != '\0'; hp++) {
        !            49:                        if (STRCMP(line, hp) == 0) {
        !            50:                                hp->line = newstring(line+(hp->size));
        !            51:                                break;
        !            52:                        };
        !            53:                }
        !            54:                if (*(hp->name) == '\0')
        !            55:                        addheader(line);
        !            56:        }
        !            57:        /* at this point, buf contains the first line of the body */
        !            58:        addheader(buf);
        !            59: }
        !            60: 
        !            61: static char*
        !            62: newstring(line)
        !            63: char *line;
        !            64: {
        !            65:        char *rv;
        !            66: 
        !            67:        rv = malloc(strlen(line)+1);
        !            68:        if (rv == NULL) {
        !            69:                perror("reading header");
        !            70:                exit(1);
        !            71:        }
        !            72:        return strcpy(rv, line);
        !            73: }
        !            74: 
        !            75: /*
        !            76:  *     Keep a list of header lines to output.
        !            77:  */
        !            78: typedef struct quux{
        !            79:        struct quux *next;
        !            80:        char line[1];
        !            81: } hlist;
        !            82: static hlist dummy = { &dummy, '\0' };
        !            83: static hlist *list = &dummy;
        !            84: 
        !            85: /*
        !            86:  *     Add to list of header lines.
        !            87:  */
        !            88: extern void
        !            89: addheader(line)
        !            90: char *line;
        !            91: {
        !            92:        hlist *thing;
        !            93: 
        !            94:        thing = (hlist *)malloc(strlen(line) + sizeof(hlist));
        !            95:        if (thing == NULL) {
        !            96:                perror("reading header");
        !            97:                exit(1);
        !            98:        }
        !            99:        strcpy(thing->line, line);
        !           100:        thing->next = list->next;
        !           101:        list->next = thing;
        !           102:        list = thing;
        !           103: }
        !           104: 
        !           105: /*
        !           106:  *     Print list of headers.
        !           107:  */
        !           108: extern void
        !           109: printheaders(fp)
        !           110: FILE *fp;
        !           111: {
        !           112:        hlist *thing;
        !           113: 
        !           114:        for(thing = list->next->next; thing != &dummy; thing = thing->next)
        !           115:                fprintf(fp, "%s", thing->line);
        !           116: }

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