# 2.11BSD#431 - /usr/src/local/mp/header.c

##### Functions

    get_header        X
    get_mult_hdr      X
    hdr_equal         X
    parse_headers     X
    reset_headers     X
    show_headers      X
    show_mult_hdr     X

       1:
       2: /*  @(#)header.c 1.5 92/02/17
       3:  *
       4:  *  Copyright (c) Steve Holden and Rich Burridge.
       5:  *                All rights reserved.
       6:  *
       7:  *  Permission is given to distribute these sources, as long as the
       8:  *  copyright messages are not removed, and no monies are exchanged.
       9:  *
      10:  *  No responsibility is taken for any errors inherent either
      11:  *  to the comments or the code of this program, but if reported
      12:  *  to me then an attempt will be made to fix them.
      13:  */
      14:
      15: #include "mp.h"
      16: #include "extern.h"
      17:
      18:
      19: /*  If input line is header of type 'hdr', get the contents of the header
      20:  *  into 'dest' (dynamically allocated).
      21:  */
      22:
      23: void
      24: get_header(hdr, dest)
      25: char *hdr ;
      26: char **dest ;
      27: {
      28:   if (hdr_equal(hdr))
      29:     {
      30:       *dest = malloc((unsigned) (strlen(nextline) - strlen(hdr) + 1)) ;
      31:       STRCPY(*dest, nextline + strlen(hdr)) ;
      32:     }
      33: }
      34:
      35:
      36: /*  If input line is header of type 'hdr', get header into dest. The header
      37:  *  may have multiple lines. This skips input to next line.
      38:  */
      39:
      40: void
      41: get_mult_hdr(hdr, dest)
      42: char *hdr ;
      43: char *dest[] ;
      44: {
      45:   int i = 0 ;
      46:
      47:   if (hdr_equal(hdr))
      48:     {
      49:       get_header(hdr, dest) ;
      50:       i++ ;
      51:       readline() ;
      52:       while (i < MAXCONT && !emptyline(nextline) && isspace(nextline[0]))
      53:         {
      54:           dest[i] = malloc((unsigned) (strlen(nextline) + 1)) ;
      55:           STRCPY(dest[i], nextline) ;
      56:           i++ ;
      57:           readline() ;
      58:         }
      59:       dest[i] = NULL ;
      60:     }
      61: }
      62:
      63:
      64: /*  Compare the first word of the current line (converted to lower-case,
      65:  *  with the given header definition. Determine if they are equal.
      66:  */
      67:
      68: int
      69: hdr_equal(val)
      70: char val[MAXLINE] ;
      71: {
      72:   register char *nptr = nextline ;
      73:   register char *wptr = val ;
      74:   register int n, w ;
      75:
      76:   do
      77:     {
      78:       n = *nptr++ ;
      79:       w = *wptr++ ;
      80:       if (isupper(n)) n = tolower(n) ;
      81:       if (isupper(w)) w = tolower(w) ;
      82:       if (n != w && w != '\0') return(0) ;
      83:     }
      84:   while (n != '\0' && w != '\0') ;
      85:   return(1) ;
      86: }
      87:
      88:
      89: /*  Parse_headers is a function which reads and parses the message headers,
      90:  *  extracting the bits which are of interest.
      91:  *
      92:  *  The document is on standard input; the document is read up to the end of
      93:  *  the header; the next line is read ahead into 'nextline'.
      94:  *
      95:  *  Parameter:
      96:  *  digest  indicates if parsing is of digest headers instead of message
      97:  *          headers
      98:  *
      99:  *  Implicit Input:
     100:  *  nextline  contains the next line from standard input
     101:  *
     102:  *  Side-effects:
     103:  *  The function fills in the global header variables with headers found.
     104:  *  The global variable doc_type is set to the document type
     105:  *  The global variable nextline is set
     106:  *  The document is read up to the line following the headers
     107:  */
     108:
     109:
     110: void
     111: parse_headers(digest)
     112: int digest ;            /* Parsing digest headers */
     113: {
     114:   char *colon ;         /* Pointer to colon in line */
     115:   char *c ;             /* General character pointer */
     116:   char tmpstr[MAXLINE] ;
     117:
     118: /*  If not processing digest headers, determine if this article is an
     119:  *  ordinary text file.
     120:  */
     121:
     122:   if (!digest)
     123:     {
     124:       if (!hdr_equal(FROM_HDR))         /* UNIX From_ header? */
     125:         {
     126:           colon = strchr(nextline, ':') ;
     127:           if (colon == NULL)        /* No colon => not a header line */
     128:             {
     129:               doc_type = DO_TEXT ;
     130:               return ;
     131:             }
     132:           c = nextline ;
     133:           while (c < colon && (!isspace(*c))) c++ ;
     134:           if (c != colon)      /* Whitespace in header name => not header */
     135:             {
     136:               doc_type = DO_TEXT ;
     137:               return ;
     138:             }
     139:         }
     140:     }
     141:
     142:   doc_type = DO_MAIL ;    /* Default to mail document */
     143:
     144: /* Parse headers */
     145:
     146:   while (TRUE)
     147:     {
     148:       if (emptyline(nextline)) break ;    /* End of headers */
     149:
     150:       if (!digest)
     151:         {
     152:           get_header(FROM_HDR,      &from_) ;
     153:           get_header(APP_FROMHDR,   &apparently_from) ;
     154:           get_header(APP_TOHDR,     &apparently_to) ;
     155:           get_header(NEWSGROUPSHDR, &newsgroups) ;
     156:           get_header(NEWSGROUPHDR,  &newsgroups) ;
     157:           get_header(REPLYHDR,      &reply_to) ;
     158:
     159:           get_mult_hdr(TOHDR,       to) ;
     160:           if (emptyline(nextline)) break ;
     161:
     162:           get_mult_hdr(CCHDR,       cc) ;
     163:           if (emptyline(nextline)) break ;
     164:
     165:           if (doc_type != DO_NEWS && hdr_equal(NEWSGROUPSHDR))
     166:             doc_type = DO_NEWS ;
     167:           if (doc_type != DO_NEWS && hdr_equal(NEWSGROUPHDR))
     168:             doc_type = DO_NEWS ;
     169:         }
     170:       get_header(FROMHDR, &from) ;
     171:       get_header(SUBJECTHDR, &subject) ;
     172:       get_header(DATEHDR, &date) ;
     173:
     174:       if (content)
     175:         {
     176:           get_header(CONTENT_LEN, &content_len) ;
     177:           if (hdr_equal(CONTENT_LEN))
     178:             {
     179:               SSCANF(nextline, "%s %d", tmpstr, &mlen) ;
     180:
     181: /*  The Content-Length: doesn't seem to include the initial blank line
     182:  *  between the mail header and the message body, or the blank line after
     183:  *  the message body and before the start of the next "From " header, so add
     184:  *  in two for those.
     185:  */
     186:               mlen += 2 ;
     187:             }
     188:         }
     189:
     190:       if (!hdr_equal(TOHDR) && !hdr_equal(CCHDR))
     191:         {
     192:           while (!end_of_file && !end_of_line)
     193:             readline() ;                       /* Skip rest of long lines */
     194:           readline() ;
     195:         }
     196:     }
     197: }
     198:
     199:
     200: void
     201: reset_headers()          /* Reset header values for next message. */
     202: {
     203:   int i ;
     204:
     205:   if (from != NULL) free(from) ;
     206:   if (from_ != NULL) free(from_) ;
     207:   if (apparently_from != NULL) free(apparently_from) ;
     208:   if (apparently_to != NULL) free(apparently_to) ;
     209:   if (content_len != NULL)   free(content_len) ;
     210:   if (date != NULL) free(date) ;
     211:   if (newsgroups != NULL) free(newsgroups) ;
     212:   if (reply_to != NULL) free(reply_to) ;
     213:
     214:   from = from_ = apparently_from = apparently_to = NULL ;
     215:   date = newsgroups = reply_to = subject = NULL ;
     216:
     217:   for (i = 0; i < MAXCONT+1; i++)
     218:     {
     219:       if (to[i] != NULL) free(to[i]) ;
     220:       if (cc[i] != NULL) free(cc[i]) ;
     221:       to[i] = cc[i] = NULL ;
     222:     }
     223: }
     224:
     225:
     226: /*  Show_headers outputs the headers in PostScript. Different headers are
     227:  *  output depending 'digest'.
     228:  */
     229:
     230: void
     231: show_headers(digest)
     232: int digest ;
     233: {
     234:   if (digest)
     235:     {
     236:       if (from)       mixedshow(FROMHDR,    from) ;
     237:       if (subject)    mixedshow(SUBJECTHDR, subject) ;
     238:       if (date)       mixedshow(DATEHDR,    date) ;
     239:     }
     240:   else
     241:     {
     242:       if (from_)           boldshow(FROM_HDR,       from_) ;
     243:       if (from)            mixedshow(FROMHDR,       from) ;
     244:       if (apparently_from) mixedshow(APP_FROMHDR,   apparently_from) ;
     245:       if (to[0])           show_mult_hdr(TOHDR,     to) ;
     246:       if (apparently_to)   mixedshow(APP_TOHDR,     apparently_to) ;
     247:       if (cc[0])           show_mult_hdr(CCHDR,     cc) ;
     248:       if (reply_to)        mixedshow(REPLYHDR,      reply_to) ;
     249:       if (newsgroups)      mixedshow(NEWSGROUPSHDR, newsgroups) ;
     250:       if (subject)         mixedshow(SUBJECTHDR,    subject) ;
     251:       if (date)            mixedshow(DATEHDR,       date) ;
     252:     }
     253:   FPUTS("sf ", stdout) ;
     254: }
     255:
     256:
     257: void
     258: show_mult_hdr(hdr, val)
     259: char *hdr ;              /* Name of header */
     260: char *val[] ;            /* Value of header */
     261: {
     262:   mixedshow(hdr, *val) ;
     263:   val++ ;
     264:   while (*val) romanshow(*val++) ;
     265: }

#### Defined functions

get_header defined in line 23; used 11 times

- in line 49, 152-157(6), 170-176(4)

get_mult_hdr defined in line 40; used 2 times

- in line 159-162(2)

hdr_equal defined in line 68; used 8 times

- in line 28, 47, 124, 165-167(2), 177, 190(2)

parse_headers defined in line 110; never used
reset_headers defined in line 200; never used
show_headers defined in line 230; never used
show_mult_hdr defined in line 257; used 2 times

- in line 245-247(2)

Last modified: 1992-02-17 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1424 |