# 2.11BSD#431 - /usr/src/usr.sbin/sendmail/src/headers.c

##### Functions

    addheader         X
    chompheader       X
    commaize          X
    crackaddr         X
    eatheader         X
    hvalue            X
    isatword          X
    isheader          X
    priencode         X
    putheader         X

       1: /*
       2: **  Sendmail
       3: **  Copyright (c) 1983  Eric P. Allman
       4: **  Berkeley, California
       5: **
       6: **  Copyright (c) 1983 Regents of the University of California.
       7: **  All rights reserved.  The Berkeley software License Agreement
       8: **  specifies the terms and conditions for redistribution.
       9: */
      10:
      11: #if !defined(lint) && !defined(NOSCCS)
      12: static char SccsId[] = "@(#)headers.c	5.7 (Berkeley) 9/21/85";
      13: #endif
      14:
      15: # include <errno.h>
      16: # include "sendmail.h"
      17:
      18: /*
      19: **  CHOMPHEADER -- process and save a header line.
      20: **
      21: **	Called by collect and by readcf to deal with header lines.
      22: **
      23: **	Parameters:
      24: **		line -- header as a text line.
      25: **		def -- if set, this is a default value.
      26: **
      27: **	Returns:
      28: **		flags for this header.
      29: **
      30: **	Side Effects:
      31: **		The header is saved on the header list.
      32: **		Contents of 'line' are destroyed.
      33: */
      34:
      35: chompheader(line, def)
      36:     char *line;
      37:     bool def;
      38: {
      39:     register char *p;
      40:     register HDR *h;
      41:     HDR **hp;
      42:     char *fname;
      43:     char *fvalue;
      44:     struct hdrinfo *hi;
      45:     bool cond = FALSE;
      46:     BITMAP mopts;
      47:     extern char *crackaddr();
      48:
      49: # ifdef DEBUG
      50:     if (tTd(31, 6))
      51:         printf("chompheader: %s\n", line);
      52: # endif DEBUG
      53:
      54:     /* strip off options */
      55:     clrbitmap(mopts);
      56:     p = line;
      57:     if (*p == '?')
      58:     {
      59:         /* have some */
      60:         register char *q = index(p + 1, *p);
      61:
      62:         if (q != NULL)
      63:         {
      64:             *q++ = '\0';
      65:             while (*++p != '\0')
      66:                 setbitn(*p, mopts);
      67:             p = q;
      68:         }
      69:         else
      70:             syserr("chompheader: syntax error, line \"%s\"", line);
      71:         cond = TRUE;
      72:     }
      73:
      74:     /* find canonical name */
      75:     fname = p;
      76:     p = index(p, ':');
      77:     if (p == NULL)
      78:     {
      79:         syserr("chompheader: syntax error, line \"%s\"", line);
      80:         return (0);
      81:     }
      82:     fvalue = &p[1];
      83:     while (isspace(*--p))
      84:         continue;
      85:     *++p = '\0';
      86:     makelower(fname);
      87:
      88:     /* strip field value on front */
      89:     if (*fvalue == ' ')
      90:         fvalue++;
      91:
      92:     /* see if it is a known type */
      93:     for (hi = HdrInfo; hi->hi_field != NULL; hi++)
      94:     {
      95:         if (strcmp(hi->hi_field, fname) == 0)
      96:             break;
      97:     }
      98:
      99:     /* see if this is a resent message */
     100:     if (!def && bitset(H_RESENT, hi->hi_flags))
     101:         CurEnv->e_flags |= EF_RESENT;
     102:
     103:     /* if this means "end of header" quit now */
     104:     if (bitset(H_EOH, hi->hi_flags))
     105:         return (hi->hi_flags);
     106:
     107:     /* drop explicit From: if same as what we would generate -- for MH */
     108:     p = "resent-from";
     109:     if (!bitset(EF_RESENT, CurEnv->e_flags))
     110:         p += 7;
     111:     if (!def && !QueueRun && strcmp(fname, p) == 0)
     112:     {
     113:         if (CurEnv->e_from.q_paddr != NULL &&
     114:             strcmp(fvalue, CurEnv->e_from.q_paddr) == 0)
     115:             return (hi->hi_flags);
     116:     }
     117:
     118:     /* delete default value for this header */
     119:     for (hp = &CurEnv->e_header; (h = *hp) != NULL; hp = &h->h_link)
     120:     {
     121:         if (strcmp(fname, h->h_field) == 0 &&
     122:             bitset(H_DEFAULT, h->h_flags) &&
     123:             !bitset(H_FORCE, h->h_flags))
     124:             h->h_value = NULL;
     125:     }
     126:
     127:     /* create a new node */
     128:     h = (HDR *) xalloc(sizeof *h);
     129:     h->h_field = newstr(fname);
     130:     h->h_value = NULL;
     131:     h->h_link = NULL;
     132:     bcopy((char *) mopts, (char *) h->h_mflags, sizeof mopts);
     133:     *hp = h;
     134:     h->h_flags = hi->hi_flags;
     135:     if (def)
     136:         h->h_flags |= H_DEFAULT;
     137:     if (cond)
     138:         h->h_flags |= H_CHECK;
     139:     if (h->h_value != NULL)
     140:         free((char *) h->h_value);
     141:     h->h_value = newstr(fvalue);
     142:
     143:     /* hack to see if this is a new format message */
     144:     if (!def && bitset(H_RCPT|H_FROM, h->h_flags) &&
     145:         (index(fvalue, ',') != NULL || index(fvalue, '(') != NULL ||
     146:          index(fvalue, '<') != NULL || index(fvalue, ';') != NULL))
     147:     {
     148:         CurEnv->e_flags &= ~EF_OLDSTYLE;
     149:     }
     150:
     151:     return (h->h_flags);
     152: }
     153: /*
     154: **  ADDHEADER -- add a header entry to the end of the queue.
     155: **
     156: **	This bypasses the special checking of chompheader.
     157: **
     158: **	Parameters:
     159: **		field -- the name of the header field.
     160: **		value -- the value of the field.  It must be lower-cased.
     161: **		e -- the envelope to add them to.
     162: **
     163: **	Returns:
     164: **		none.
     165: **
     166: **	Side Effects:
     167: **		adds the field on the list of headers for this envelope.
     168: */
     169:
     170: addheader(field, value, e)
     171:     char *field;
     172:     char *value;
     173:     ENVELOPE *e;
     174: {
     175:     register HDR *h;
     176:     register struct hdrinfo *hi;
     177:     HDR **hp;
     178:
     179:     /* find info struct */
     180:     for (hi = HdrInfo; hi->hi_field != NULL; hi++)
     181:     {
     182:         if (strcmp(field, hi->hi_field) == 0)
     183:             break;
     184:     }
     185:
     186:     /* find current place in list -- keep back pointer? */
     187:     for (hp = &e->e_header; (h = *hp) != NULL; hp = &h->h_link)
     188:     {
     189:         if (strcmp(field, h->h_field) == 0)
     190:             break;
     191:     }
     192:
     193:     /* allocate space for new header */
     194:     h = (HDR *) xalloc(sizeof *h);
     195:     h->h_field = field;
     196:     h->h_value = newstr(value);
     197:     h->h_link = *hp;
     198:     h->h_flags = hi->hi_flags | H_DEFAULT;
     199:     clrbitmap(h->h_mflags);
     200:     *hp = h;
     201: }
     202: /*
     203: **  HVALUE -- return value of a header.
     204: **
     205: **	Only "real" fields (i.e., ones that have not been supplied
     206: **	as a default) are used.
     207: **
     208: **	Parameters:
     209: **		field -- the field name.
     210: **
     211: **	Returns:
     212: **		pointer to the value part.
     213: **		NULL if not found.
     214: **
     215: **	Side Effects:
     216: **		none.
     217: */
     218:
     219: char *
     220: hvalue(field)
     221:     char *field;
     222: {
     223:     register HDR *h;
     224:
     225:     for (h = CurEnv->e_header; h != NULL; h = h->h_link)
     226:     {
     227:         if (!bitset(H_DEFAULT, h->h_flags) && strcmp(h->h_field, field) == 0)
     228:             return (h->h_value);
     229:     }
     230:     return (NULL);
     231: }
     232: /*
     233: **  ISHEADER -- predicate telling if argument is a header.
     234: **
     235: **	A line is a header if it has a single word followed by
     236: **	optional white space followed by a colon.
     237: **
     238: **	Parameters:
     239: **		s -- string to check for possible headerness.
     240: **
     241: **	Returns:
     242: **		TRUE if s is a header.
     243: **		FALSE otherwise.
     244: **
     245: **	Side Effects:
     246: **		none.
     247: */
     248:
     249: bool
     250: isheader(s)
     251:     register char *s;
     252: {
     253:     while (*s > ' ' && *s != ':' && *s != '\0')
     254:         s++;
     255:
     256:     /* following technically violates RFC822 */
     257:     while (isspace(*s))
     258:         s++;
     259:
     260:     return (*s == ':');
     261: }
     262: /*
     263: **  EATHEADER -- run through the stored header and extract info.
     264: **
     265: **	Parameters:
     266: **		e -- the envelope to process.
     267: **
     268: **	Returns:
     269: **		none.
     270: **
     271: **	Side Effects:
     272: **		Sets a bunch of global variables from information
     273: **			in the collected header.
     274: **		Aborts the message if the hop count is exceeded.
     275: */
     276:
     277: eatheader(e)
     278:     register ENVELOPE *e;
     279: {
     280:     register HDR *h;
     281:     register char *p;
     282:     int hopcnt = 0;
     283:
     284: #ifdef DEBUG
     285:     if (tTd(32, 1))
     286:         printf("----- collected header -----\n");
     287: #endif DEBUG
     288:     for (h = e->e_header; h != NULL; h = h->h_link)
     289:     {
     290: #ifdef DEBUG
     291:         extern char *capitalize();
     292:
     293:         if (tTd(32, 1))
     294:             printf("%s: %s\n", capitalize(h->h_field), h->h_value);
     295: #endif DEBUG
     296:         /* count the number of times it has been processed */
     297:         if (bitset(H_TRACE, h->h_flags))
     298:             hopcnt++;
     299:
     300:         /* send to this person if we so desire */
     301:         if (GrabTo && bitset(H_RCPT, h->h_flags) &&
     302:             !bitset(H_DEFAULT, h->h_flags) &&
     303:             (!bitset(EF_RESENT, CurEnv->e_flags) || bitset(H_RESENT, h->h_flags)))
     304:         {
     305:             sendtolist(h->h_value, (ADDRESS *) NULL, &CurEnv->e_sendqueue);
     306:         }
     307:
     308:         /* log the message-id */
     309: #ifdef LOG
     310:         if (!QueueRun && LogLevel > 8 && h->h_value != NULL &&
     311:             strcmp(h->h_field, "message-id") == 0)
     312:         {
     313:             char buf[MAXNAME];
     314:
     315:             p = h->h_value;
     316:             if (bitset(H_DEFAULT, h->h_flags))
     317:             {
     318:                 expand(p, buf, &buf[sizeof buf], e);
     319:                 p = buf;
     320:             }
     321:             syslog(LOG_INFO, "%s: message-id=%s", e->e_id, p);
     322:         }
     323: #endif LOG
     324:     }
     325: #ifdef DEBUG
     326:     if (tTd(32, 1))
     327:         printf("----------------------------\n");
     328: #endif DEBUG
     329:
     330:     /* store hop count */
     331:     if (hopcnt > e->e_hopcount)
     332:         e->e_hopcount = hopcnt;
     333:
     334:     /* message priority */
     335:     p = hvalue("precedence");
     336:     if (p != NULL)
     337:         e->e_class = priencode(p);
     338:     if (!QueueRun)
     339:         e->e_msgpriority = e->e_msgsize
     340:                  - e->e_class * WkClassFact
     341:                  + e->e_nrcpts * WkRecipFact;
     342:
     343:     /* return receipt to */
     344:     p = hvalue("return-receipt-to");
     345:     if (p != NULL)
     346:         e->e_receiptto = p;
     347:
     348:     /* errors to */
     349:     p = hvalue("errors-to");
     350:     if (p != NULL)
     351:         sendtolist(p, (ADDRESS *) NULL, &e->e_errorqueue);
     352:
     353:     /* from person */
     354:     if (OpMode == MD_ARPAFTP)
     355:     {
     356:         register struct hdrinfo *hi = HdrInfo;
     357:
     358:         for (p = NULL; p == NULL && hi->hi_field != NULL; hi++)
     359:         {
     360:             if (bitset(H_FROM, hi->hi_flags))
     361:                 p = hvalue(hi->hi_field);
     362:         }
     363:         if (p != NULL)
     364:             setsender(p);
     365:     }
     366:
     367:     /* full name of from person */
     368:     p = hvalue("full-name");
     369:     if (p != NULL)
     370:         define('x', p, e);
     371:
     372:     /* date message originated */
     373:     p = hvalue("posted-date");
     374:     if (p == NULL)
     375:         p = hvalue("date");
     376:     if (p != NULL)
     377:     {
     378:         define('a', p, e);
     379:         /* we don't have a good way to do canonical conversion ....
     380: 		define('d', newstr(arpatounix(p)), e);
     381: 		.... so we will ignore the problem for the time being */
     382:     }
     383:
     384:     /*
     385: 	**  Log collection information.
     386: 	*/
     387:
     388: # ifdef LOG
     389:     if (!QueueRun && LogLevel > 1)
     390:     {
     391:         syslog(LOG_INFO, "%s: from=%s, size=%ld, class=%d\n",
     392:                CurEnv->e_id, CurEnv->e_from.q_paddr, CurEnv->e_msgsize,
     393:                CurEnv->e_class);
     394:     }
     395: # endif LOG
     396: }
     397: /*
     398: **  PRIENCODE -- encode external priority names into internal values.
     399: **
     400: **	Parameters:
     401: **		p -- priority in ascii.
     402: **
     403: **	Returns:
     404: **		priority as a numeric level.
     405: **
     406: **	Side Effects:
     407: **		none.
     408: */
     409:
     410: priencode(p)
     411:     char *p;
     412: {
     413:     register int i;
     414:     extern bool sameword();
     415:
     416:     for (i = 0; i < NumPriorities; i++)
     417:     {
     418:         if (sameword(p, Priorities[i].pri_name))
     419:             return (Priorities[i].pri_val);
     420:     }
     421:
     422:     /* unknown priority */
     423:     return (0);
     424: }
     425: /*
     426: **  CRACKADDR -- parse an address and turn it into a macro
     427: **
     428: **	This doesn't actually parse the address -- it just extracts
     429: **	it and replaces it with "$g".  The parse is totally ad hoc
     430: **	and isn't even guaranteed to leave something syntactically
     431: **	identical to what it started with.  However, it does leave
     432: **	something semantically identical.
     433: **
     434: **	The process is kind of strange.  There are a number of
     435: **	interesting cases:
     436: **		1.  comment <address> comment	==> comment <$g> comment
     437: **		2.  address			==> address
     438: **		3.  address (comment)		==> $g (comment)
     439: **		4.  (comment) address		==> (comment) $g
     440: **	And then there are the hard cases....
     441: **		5.  add (comment) ress		==> $g (comment)
     442: **		6.  comment <address (comment)>	==> comment <$g (comment)>
     443: **		7.    .... etc ....
     444: **
     445: **	Parameters:
     446: **		addr -- the address to be cracked.
     447: **
     448: **	Returns:
     449: **		a pointer to the new version.
     450: **
     451: **	Side Effects:
     452: **		none.
     453: **
     454: **	Warning:
     455: **		The return value is saved in local storage and should
     456: **		be copied if it is to be reused.
     457: */
     458:
     459: char *
     460: crackaddr(addr)
     461:     register char *addr;
     462: {
     463:     register char *p;
     464:     register int i;
     465:     static char buf[MAXNAME];
     466:     char *rhs;
     467:     bool gotaddr;
     468:     register char *bp;
     469:
     470: # ifdef DEBUG
     471:     if (tTd(33, 1))
     472:         printf("crackaddr(%s)\n", addr);
     473: # endif DEBUG
     474:
     475:     (void) strcpy(buf, "");
     476:     rhs = NULL;
     477:
     478:     /* strip leading spaces */
     479:     while (*addr != '\0' && isspace(*addr))
     480:         addr++;
     481:
     482:     /*
     483: 	**  See if we have anything in angle brackets.  If so, that is
     484: 	**  the address part, and the rest is the comment.
     485: 	*/
     486:
     487:     p = index(addr, '<');
     488:     if (p != NULL)
     489:     {
     490:         /* copy the beginning of the addr field to the buffer */
     491:         *p = '\0';
     492:         (void) strcpy(buf, addr);
     493:         (void) strcat(buf, "<");
     494:         *p++ = '<';
     495:
     496:         /* skip spaces */
     497:         while (isspace(*p))
     498:             p++;
     499:
     500:         /* find the matching right angle bracket */
     501:         addr = p;
     502:         for (i = 0; *p != '\0'; p++)
     503:         {
     504:             switch (*p)
     505:             {
     506:               case '<':
     507:                 i++;
     508:                 break;
     509:
     510:               case '>':
     511:                 i--;
     512:                 break;
     513:             }
     514:             if (i < 0)
     515:                 break;
     516:         }
     517:
     518:         /* p now points to the closing quote (or a null byte) */
     519:         if (*p != '\0')
     520:         {
     521:             /* make rhs point to the extra stuff at the end */
     522:             rhs = p;
     523:             *p++ = '\0';
     524:         }
     525:     }
     526:
     527:     /*
     528: 	**  Now parse the real address part.  "addr" points to the (null
     529: 	**  terminated) version of what we are inerested in; rhs points
     530: 	**  to the extra stuff at the end of the line, if any.
     531: 	*/
     532:
     533:     p = addr;
     534:
     535:     /* now strip out comments */
     536:     bp = &buf[strlen(buf)];
     537:     gotaddr = FALSE;
     538:     for (; *p != '\0'; p++)
     539:     {
     540:         if (*p == '(')
     541:         {
     542:             /* copy to matching close paren */
     543:             *bp++ = *p++;
     544:             for (i = 0; *p != '\0'; p++)
     545:             {
     546:                 *bp++ = *p;
     547:                 switch (*p)
     548:                 {
     549:                   case '(':
     550:                     i++;
     551:                     break;
     552:
     553:                   case ')':
     554:                     i--;
     555:                     break;
     556:                 }
     557:                 if (i < 0)
     558:                     break;
     559:             }
     560:             continue;
     561:         }
     562:
     563:         /*
     564: 		**  If this is the first "real" character we have seen,
     565: 		**  then we put the "$g" in the buffer now.
     566: 		*/
     567:
     568:         if (isspace(*p))
     569:             *bp++ = *p;
     570:         else if (!gotaddr)
     571:         {
     572:             (void) strcpy(bp, "\001g");
     573:             bp += 2;
     574:             gotaddr = TRUE;
     575:         }
     576:     }
     577:
     578:     /* hack, hack.... strip trailing blanks */
     579:     do
     580:     {
     581:         *bp-- = '\0';
     582:     } while (isspace(*bp));
     583:     bp++;
     584:
     585:     /* put any right hand side back on */
     586:     if (rhs != NULL)
     587:     {
     588:         *rhs = '>';
     589:         (void) strcpy(bp, rhs);
     590:     }
     591:
     592: # ifdef DEBUG
     593:     if (tTd(33, 1))
     594:         printf("crackaddr=>`%s'\n", buf);
     595: # endif DEBUG
     596:
     597:     return (buf);
     598: }
     599: /*
     600: **  PUTHEADER -- put the header part of a message from the in-core copy
     601: **
     602: **	Parameters:
     603: **		fp -- file to put it on.
     604: **		m -- mailer to use.
     605: **		e -- envelope to use.
     606: **
     607: **	Returns:
     608: **		none.
     609: **
     610: **	Side Effects:
     611: **		none.
     612: */
     613:
     614: putheader(fp, m, e)
     615:     register FILE *fp;
     616:     register MAILER *m;
     617:     register ENVELOPE *e;
     618: {
     619:     char buf[BUFSIZ];
     620:     register HDR *h;
     621:     extern char *arpadate();
     622:     extern char *capitalize();
     623:     char obuf[MAXLINE];
     624:
     625:     for (h = e->e_header; h != NULL; h = h->h_link)
     626:     {
     627:         register char *p;
     628:         extern bool bitintersect();
     629:
     630:         if (bitset(H_CHECK|H_ACHECK, h->h_flags) &&
     631:             !bitintersect(h->h_mflags, m->m_flags))
     632:             continue;
     633:
     634:         /* handle Resent-... headers specially */
     635:         if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
     636:             continue;
     637:
     638:         p = h->h_value;
     639:         if (bitset(H_DEFAULT, h->h_flags))
     640:         {
     641:             /* macro expand value if generated internally */
     642:             expand(p, buf, &buf[sizeof buf], e);
     643:             p = buf;
     644:             if (p == NULL || *p == '\0')
     645:                 continue;
     646:         }
     647:
     648:         if (bitset(H_FROM|H_RCPT, h->h_flags))
     649:         {
     650:             /* address field */
     651:             bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
     652:
     653:             if (bitset(H_FROM, h->h_flags))
     654:                 oldstyle = FALSE;
     655:             commaize(h, p, fp, oldstyle, m);
     656:         }
     657:         else
     658:         {
     659:             /* vanilla header line */
     660:             register char *nlp;
     661:
     662:             (void) sprintf(obuf, "%s: ", capitalize(h->h_field));
     663:             while ((nlp = index(p, '\n')) != NULL)
     664:             {
     665:                 *nlp = '\0';
     666:                 (void) strcat(obuf, p);
     667:                 *nlp = '\n';
     668:                 putline(obuf, fp, m);
     669:                 p = ++nlp;
     670:                 obuf[0] = '\0';
     671:             }
     672:             (void) strcat(obuf, p);
     673:             putline(obuf, fp, m);
     674:         }
     675:     }
     676: }
     677: /*
     678: **  COMMAIZE -- output a header field, making a comma-translated list.
     679: **
     680: **	Parameters:
     681: **		h -- the header field to output.
     682: **		p -- the value to put in it.
     683: **		fp -- file to put it to.
     684: **		oldstyle -- TRUE if this is an old style header.
     685: **		m -- a pointer to the mailer descriptor.  If NULL,
     686: **			don't transform the name at all.
     687: **
     688: **	Returns:
     689: **		none.
     690: **
     691: **	Side Effects:
     692: **		outputs "p" to file "fp".
     693: */
     694:
     695: commaize(h, p, fp, oldstyle, m)
     696:     register HDR *h;
     697:     register char *p;
     698:     FILE *fp;
     699:     bool oldstyle;
     700:     register MAILER *m;
     701: {
     702:     register char *obp;
     703:     int opos;
     704:     bool firstone = TRUE;
     705:     char obuf[MAXLINE + 3];
     706:
     707:     /*
     708: 	**  Output the address list translated by the
     709: 	**  mailer and with commas.
     710: 	*/
     711:
     712: # ifdef DEBUG
     713:     if (tTd(14, 2))
     714:         printf("commaize(%s: %s)\n", h->h_field, p);
     715: # endif DEBUG
     716:
     717:     obp = obuf;
     718:     (void) sprintf(obp, "%s: ", capitalize(h->h_field));
     719:     opos = strlen(h->h_field) + 2;
     720:     obp += opos;
     721:
     722:     /*
     723: 	**  Run through the list of values.
     724: 	*/
     725:
     726:     while (*p != '\0')
     727:     {
     728:         register char *name;
     729:         char savechar;
     730:         extern char *remotename();
     731:         extern char *DelimChar;     /* defined in prescan */
     732:
     733:         /*
     734: 		**  Find the end of the name.  New style names
     735: 		**  end with a comma, old style names end with
     736: 		**  a space character.  However, spaces do not
     737: 		**  necessarily delimit an old-style name -- at
     738: 		**  signs mean keep going.
     739: 		*/
     740:
     741:         /* find end of name */
     742:         while (isspace(*p) || *p == ',')
     743:             p++;
     744:         name = p;
     745:         for (;;)
     746:         {
     747:             char *oldp;
     748:             char pvpbuf[PSBUFSIZE];
     749:             extern bool isatword();
     750:             extern char **prescan();
     751:
     752:             (void) prescan(p, oldstyle ? ' ' : ',', pvpbuf);
     753:             p = DelimChar;
     754:
     755:             /* look to see if we have an at sign */
     756:             oldp = p;
     757:             while (*p != '\0' && isspace(*p))
     758:                 p++;
     759:
     760:             if (*p != '@' && !isatword(p))
     761:             {
     762:                 p = oldp;
     763:                 break;
     764:             }
     765:             p += *p == '@' ? 1 : 2;
     766:             while (*p != '\0' && isspace(*p))
     767:                 p++;
     768:         }
     769:         /* at the end of one complete name */
     770:
     771:         /* strip off trailing white space */
     772:         while (p >= name && (isspace(*p) || *p == ',' || *p == '\0'))
     773:             p--;
     774:         if (++p == name)
     775:             continue;
     776:         savechar = *p;
     777:         *p = '\0';
     778:
     779:         /* translate the name to be relative */
     780:         name = remotename(name, m, bitset(H_FROM, h->h_flags), FALSE);
     781:         if (*name == '\0')
     782:         {
     783:             *p = savechar;
     784:             continue;
     785:         }
     786:
     787:         /* output the name with nice formatting */
     788:         opos += qstrlen(name);
     789:         if (!firstone)
     790:             opos += 2;
     791:         if (opos > 78 && !firstone)
     792:         {
     793:             (void) strcpy(obp, ",\n");
     794:             putline(obuf, fp, m);
     795:             obp = obuf;
     796:             (void) sprintf(obp, "        ");
     797:             opos = strlen(obp);
     798:             obp += opos;
     799:             opos += qstrlen(name);
     800:         }
     801:         else if (!firstone)
     802:         {
     803:             (void) sprintf(obp, ", ");
     804:             obp += 2;
     805:         }
     806:
     807:         /* strip off quote bits as we output */
     808:         while (*name != '\0' && obp < &obuf[MAXLINE])
     809:         {
     810:             if (bitset(0200, *name))
     811:                 *obp++ = '\\';
     812:             *obp++ = *name++ & ~0200;
     813:         }
     814:         firstone = FALSE;
     815:         *p = savechar;
     816:     }
     817:     (void) strcpy(obp, "\n");
     818:     putline(obuf, fp, m);
     819: }
     820: /*
     821: **  ISATWORD -- tell if the word we are pointing to is "at".
     822: **
     823: **	Parameters:
     824: **		p -- word to check.
     825: **
     826: **	Returns:
     827: **		TRUE -- if p is the word at.
     828: **		FALSE -- otherwise.
     829: **
     830: **	Side Effects:
     831: **		none.
     832: */
     833:
     834: bool
     835: isatword(p)
     836:     register char *p;
     837: {
     838:     extern char lower();
     839:
     840:     if (lower(p[0]) == 'a' && lower(p[1]) == 't' &&
     841:         p[2] != '\0' && isspace(p[2]))
     842:         return (TRUE);
     843:     return (FALSE);
     844: }

#### Defined functions

addheader defined in line 170; used 3 times

- in /usr/src/usr.sbin/sendmail/src/collect.c line 214
- in /usr/src/usr.sbin/sendmail/src/savemail.c line 401-405(2)

chompheader defined in line 35; used 3 times

- in /usr/src/usr.sbin/sendmail/src/collect.c line 129
- in /usr/src/usr.sbin/sendmail/src/queue.c line 710
- in /usr/src/usr.sbin/sendmail/src/readcf.c line 164

commaize defined in line 695; used 2 times

- in line 655
- in /usr/src/usr.sbin/sendmail/src/queue.c line 212

crackaddr defined in line 459; used 3 times

- in line 47
- in /usr/src/usr.sbin/sendmail/src/parseaddr.c line 1103, 1122

eatheader defined in line 277; used 3 times

- in /usr/src/usr.sbin/sendmail/src/collect.c line 193
- in /usr/src/usr.sbin/sendmail/src/queue.c line 629
- in /usr/src/usr.sbin/sendmail/src/savemail.c line 422

hvalue defined in line 219; used 12 times

- in line 335, 344-349(2), 361, 368-375(3)
- in /usr/src/usr.sbin/sendmail/src/collect.c line 43, 199-200(4)

isatword defined in line 834; used 2 times

- in line 749, 760

isheader defined in line 249; used 2 times

- in /usr/src/usr.sbin/sendmail/src/collect.c line 90, 107

priencode defined in line 410; used 1 times

- in line 337

putheader defined in line 614; used 8 times

- in /usr/src/usr.sbin/sendmail/src/envelope.c line 40, 54
- in /usr/src/usr.sbin/sendmail/src/main.c line 112, 151
- in /usr/src/usr.sbin/sendmail/src/savemail.c line 363, 393, 497, 506

#### Defined variables

SccsId defined in line 12; never used

Last modified: 1989-01-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2625 |