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

commaize defined in line 695; used 2 times
crackaddr defined in line 459; used 3 times
hvalue defined in line 219; used 12 times
isatword defined in line 834; used 2 times
isheader defined in line 249; used 2 times
priencode defined in line 410; used 1 times

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: 3030
Valid CSS Valid XHTML 1.0 Strict