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