![[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] / 43BSD / usr.lib / sendmail / src|
Return to headers.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src |
1.1 ! root 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: #ifndef lint ! 12: static char SccsId[] = "@(#)headers.c 5.7 (Berkeley) 9/21/85"; ! 13: #endif not lint ! 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.