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