![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to names.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / ucbmail|
Return to names.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / ucbmail |
1.1 ! root 1: # ! 2: ! 3: /* ! 4: * Mail -- a mail program ! 5: * ! 6: * Handle name lists. ! 7: */ ! 8: ! 9: #include "rcv.h" ! 10: ! 11: /* ! 12: * Allocate a single element of a name list, ! 13: * initialize its name field to the passed ! 14: * name and return it. ! 15: */ ! 16: ! 17: struct name * ! 18: nalloc(str) ! 19: char str[]; ! 20: { ! 21: register struct name *np; ! 22: ! 23: np = (struct name *) salloc(sizeof *np); ! 24: np->n_flink = NIL; ! 25: np->n_blink = NIL; ! 26: np->n_type = -1; ! 27: np->n_name = savestr(str); ! 28: return(np); ! 29: } ! 30: ! 31: /* ! 32: * Find the tail of a list and return it. ! 33: */ ! 34: ! 35: struct name * ! 36: tailof(name) ! 37: struct name *name; ! 38: { ! 39: register struct name *np; ! 40: ! 41: np = name; ! 42: if (np == NIL) ! 43: return(NIL); ! 44: while (np->n_flink != NIL) ! 45: np = np->n_flink; ! 46: return(np); ! 47: } ! 48: ! 49: /* ! 50: * Extract a list of names from a line, ! 51: * and make a list of names from it. ! 52: * Return the list or NIL if none found. ! 53: */ ! 54: ! 55: struct name * ! 56: extract(line, ntype) ! 57: char line[]; ! 58: { ! 59: register char *cp; ! 60: register struct name *top, *np, *t; ! 61: char nbuf[BUFSIZ], abuf[BUFSIZ]; ! 62: ! 63: if (line == NOSTR || strlen(line) == 0) ! 64: return(NIL); ! 65: top = NIL; ! 66: np = NIL; ! 67: cp = line; ! 68: while ((cp = yankword(cp, nbuf)) != NOSTR) { ! 69: if (np != NIL && equal(nbuf, "at")) { ! 70: strcpy(abuf, nbuf); ! 71: if ((cp = yankword(cp, nbuf)) == NOSTR) { ! 72: strcpy(nbuf, abuf); ! 73: goto normal; ! 74: } ! 75: strcpy(abuf, np->n_name); ! 76: stradd(abuf, '@'); ! 77: strcat(abuf, nbuf); ! 78: np->n_name = savestr(abuf); ! 79: continue; ! 80: } ! 81: normal: ! 82: t = nalloc(nbuf); ! 83: t->n_type = ntype; ! 84: if (top == NIL) ! 85: top = t; ! 86: else ! 87: np->n_flink = t; ! 88: t->n_blink = np; ! 89: np = t; ! 90: } ! 91: return(top); ! 92: } ! 93: ! 94: /* ! 95: * Turn a list of names into a string of the same names. ! 96: */ ! 97: ! 98: char * ! 99: detract(np, ntype) ! 100: register struct name *np; ! 101: { ! 102: register int s; ! 103: register char *cp, *top; ! 104: register struct name *p; ! 105: register int comma; ! 106: ! 107: comma = ntype & GCOMMA; ! 108: if (np == NIL) ! 109: return(NOSTR); ! 110: ntype &= ~GCOMMA; ! 111: s = 0; ! 112: if (debug && comma) ! 113: fprintf(stderr, "detract asked to insert commas\n"); ! 114: for (p = np; p != NIL; p = p->n_flink) { ! 115: if (ntype && (p->n_type & GMASK) != ntype) ! 116: continue; ! 117: s += strlen(p->n_name) + 1; ! 118: if (comma) ! 119: s++; ! 120: } ! 121: if (s == 0) ! 122: return(NOSTR); ! 123: s += 2; ! 124: top = salloc(s); ! 125: cp = top; ! 126: for (p = np; p != NIL; p = p->n_flink) { ! 127: if (ntype && (p->n_type & GMASK) != ntype) ! 128: continue; ! 129: cp = copy(p->n_name, cp); ! 130: if (comma && p->n_flink != NIL) ! 131: *cp++ = ','; ! 132: *cp++ = ' '; ! 133: } ! 134: *--cp = 0; ! 135: if (comma && *--cp == ',') ! 136: *cp = 0; ! 137: return(top); ! 138: } ! 139: ! 140: /* ! 141: * Grab a single word (liberal word) ! 142: * Throw away things between ()'s. ! 143: */ ! 144: ! 145: char * ! 146: yankword(ap, wbuf) ! 147: char *ap, wbuf[]; ! 148: { ! 149: register char *cp, *cp2; ! 150: ! 151: do { ! 152: for (cp = ap; *cp && any(*cp, " \t,"); cp++) ! 153: ; ! 154: if (*cp == '(') { ! 155: while (*cp && *cp != ')') ! 156: cp++; ! 157: if (*cp) ! 158: cp++; ! 159: } ! 160: if (*cp == '\0') ! 161: return(NOSTR); ! 162: } while (any(*cp, " \t,(")); ! 163: for (cp2 = wbuf; *cp && !any(*cp, " \t,("); *cp2++ = *cp++) ! 164: ; ! 165: *cp2 = '\0'; ! 166: return(cp); ! 167: } ! 168: ! 169: /* ! 170: * Verify that all the users in the list of names are ! 171: * legitimate. Bitch about and delink those who aren't. ! 172: */ ! 173: ! 174: struct name * ! 175: verify(names) ! 176: struct name *names; ! 177: { ! 178: register struct name *np, *top, *t, *x; ! 179: register char *cp; ! 180: ! 181: #ifdef DELIVERMAIL ! 182: return(names); ! 183: #else ! 184: top = names; ! 185: np = names; ! 186: while (np != NIL) { ! 187: if (np->n_type & GDEL) { ! 188: np = np->n_flink; ! 189: continue; ! 190: } ! 191: for (cp = "!:@^"; *cp; cp++) ! 192: if (any(*cp, np->n_name)) ! 193: break; ! 194: if (*cp != 0) { ! 195: np = np->n_flink; ! 196: continue; ! 197: } ! 198: cp = np->n_name; ! 199: while (*cp == '\\') ! 200: cp++; ! 201: if (equal(cp, "msgs") || ! 202: getuserid(cp) != -1) { ! 203: np = np->n_flink; ! 204: continue; ! 205: } ! 206: fprintf(stderr, "Can't send to %s\n", np->n_name); ! 207: senderr++; ! 208: if (np == top) { ! 209: top = np->n_flink; ! 210: if (top != NIL) ! 211: top->n_blink = NIL; ! 212: np = top; ! 213: continue; ! 214: } ! 215: x = np->n_blink; ! 216: t = np->n_flink; ! 217: x->n_flink = t; ! 218: if (t != NIL) ! 219: t->n_blink = x; ! 220: np = t; ! 221: } ! 222: return(top); ! 223: #endif ! 224: } ! 225: ! 226: /* ! 227: * For each recipient in the passed name list with a / ! 228: * in the name, append the message to the end of the named file ! 229: * and remove him from the recipient list. ! 230: * ! 231: * Recipients whose name begins with | are piped through the given ! 232: * program and removed. ! 233: */ ! 234: ! 235: struct name * ! 236: outof(names, fo, hp) ! 237: struct name *names; ! 238: FILE *fo; ! 239: struct header *hp; ! 240: { ! 241: register int c; ! 242: register struct name *np, *top, *t, *x; ! 243: long now; ! 244: char *date, *fname, *shell, *ctime(); ! 245: FILE *fout, *fin; ! 246: int ispipe, s, pid; ! 247: extern char tempEdit[]; ! 248: ! 249: top = names; ! 250: np = names; ! 251: time(&now); ! 252: date = ctime(&now); ! 253: while (np != NIL) { ! 254: if (!any('/', np->n_name) && np->n_name[0] != '|') { ! 255: np = np->n_flink; ! 256: continue; ! 257: } ! 258: ispipe = np->n_name[0] == '|'; ! 259: if (ispipe) ! 260: fname = np->n_name+1; ! 261: else ! 262: fname = expand(np->n_name); ! 263: ! 264: /* ! 265: * See if we have copied the complete message out yet. ! 266: * If not, do so. ! 267: */ ! 268: ! 269: if (image < 0) { ! 270: if ((fout = fopen(tempEdit, "a")) == NULL) { ! 271: perror(tempEdit); ! 272: senderr++; ! 273: goto cant; ! 274: } ! 275: image = open(tempEdit, 2); ! 276: unlink(tempEdit); ! 277: if (image < 0) { ! 278: perror(tempEdit); ! 279: senderr++; ! 280: goto cant; ! 281: } ! 282: else { ! 283: rewind(fo); ! 284: fprintf(fout, "From %s %s", myname, date); ! 285: puthead(hp, fout, GTO|GSUBJECT|GCC|GNL); ! 286: while ((c = getc(fo)) != EOF) ! 287: putc(c, fout); ! 288: rewind(fo); ! 289: putc('\n', fout); ! 290: fflush(fout); ! 291: if (ferror(fout)) ! 292: perror(tempEdit); ! 293: fclose(fout); ! 294: } ! 295: } ! 296: ! 297: /* ! 298: * Now either copy "image" to the desired file ! 299: * or give it as the standard input to the desired ! 300: * program as appropriate. ! 301: */ ! 302: ! 303: if (ispipe) { ! 304: wait(&s); ! 305: switch (pid = fork()) { ! 306: case 0: ! 307: signal(SIGHUP, SIG_IGN); ! 308: signal(SIGINT, SIG_IGN); ! 309: signal(SIGQUIT, SIG_IGN); ! 310: close(0); ! 311: dup(image); ! 312: close(image); ! 313: if ((shell = value("SHELL")) == NOSTR) ! 314: shell = SHELL; ! 315: execl(shell, shell, "-c", fname, 0); ! 316: perror(shell); ! 317: exit(1); ! 318: break; ! 319: ! 320: case -1: ! 321: perror("fork"); ! 322: senderr++; ! 323: goto cant; ! 324: } ! 325: } ! 326: else { ! 327: if ((fout = fopen(fname, "a")) == NULL) { ! 328: perror(fname); ! 329: senderr++; ! 330: goto cant; ! 331: } ! 332: fin = Fdopen(image, "r"); ! 333: if (fin == NULL) { ! 334: fprintf(stderr, "Can't reopen image\n"); ! 335: fclose(fout); ! 336: senderr++; ! 337: goto cant; ! 338: } ! 339: rewind(fin); ! 340: while ((c = getc(fin)) != EOF) ! 341: putc(c, fout); ! 342: if (ferror(fout)) ! 343: senderr++, perror(fname); ! 344: fclose(fout); ! 345: fclose(fin); ! 346: } ! 347: ! 348: cant: ! 349: ! 350: /* ! 351: * In days of old we removed the entry from the ! 352: * the list; now for sake of header expansion ! 353: * we leave it in and mark it as deleted. ! 354: */ ! 355: ! 356: #ifdef CRAZYWOW ! 357: if (np == top) { ! 358: top = np->n_flink; ! 359: if (top != NIL) ! 360: top->n_blink = NIL; ! 361: np = top; ! 362: continue; ! 363: } ! 364: x = np->n_blink; ! 365: t = np->n_flink; ! 366: x->n_flink = t; ! 367: if (t != NIL) ! 368: t->n_blink = x; ! 369: np = t; ! 370: #endif ! 371: ! 372: np->n_type |= GDEL; ! 373: np = np->n_flink; ! 374: } ! 375: if (image >= 0) { ! 376: close(image); ! 377: image = -1; ! 378: } ! 379: return(top); ! 380: } ! 381: ! 382: /* ! 383: * Map all of the aliased users in the invoker's mailrc ! 384: * file and insert them into the list. ! 385: * Changed after all these months of service to recursively ! 386: * expand names (2/14/80). ! 387: */ ! 388: ! 389: struct name * ! 390: usermap(names) ! 391: struct name *names; ! 392: { ! 393: register struct name *new, *np, *cp; ! 394: struct name *getto; ! 395: struct grouphead *gh; ! 396: register int metoo; ! 397: ! 398: new = NIL; ! 399: np = names; ! 400: getto = NIL; ! 401: metoo = (value("metoo") != NOSTR); ! 402: while (np != NIL) { ! 403: if (np->n_name[0] == '\\') { ! 404: cp = np->n_flink; ! 405: new = put(new, np); ! 406: np = cp; ! 407: continue; ! 408: } ! 409: gh = findgroup(np->n_name); ! 410: cp = np->n_flink; ! 411: if (gh != NOGRP) ! 412: new = gexpand(new, gh, metoo, np->n_type); ! 413: else ! 414: new = put(new, np); ! 415: np = cp; ! 416: } ! 417: return(new); ! 418: } ! 419: ! 420: /* ! 421: * Recursively expand a group name. We limit the expansion to some ! 422: * fixed level to keep things from going haywire. ! 423: * Direct recursion is not expanded for convenience. ! 424: */ ! 425: ! 426: struct name * ! 427: gexpand(nlist, gh, metoo, ntype) ! 428: struct name *nlist; ! 429: struct grouphead *gh; ! 430: { ! 431: struct group *gp; ! 432: struct grouphead *ngh; ! 433: struct name *np; ! 434: static int depth; ! 435: char *cp; ! 436: ! 437: if (depth > MAXEXP) { ! 438: printf("Expanding alias to depth larger than %d\n", MAXEXP); ! 439: return(nlist); ! 440: } ! 441: depth++; ! 442: for (gp = gh->g_list; gp != NOGE; gp = gp->ge_link) { ! 443: cp = gp->ge_name; ! 444: if (*cp == '\\') ! 445: goto quote; ! 446: if (strcmp(cp, gh->g_name) == 0) ! 447: goto quote; ! 448: if ((ngh = findgroup(cp)) != NOGRP) { ! 449: nlist = gexpand(nlist, ngh, metoo, ntype); ! 450: continue; ! 451: } ! 452: quote: ! 453: np = nalloc(cp); ! 454: np->n_type = ntype; ! 455: /* ! 456: * At this point should allow to expand ! 457: * to self if only person in group ! 458: */ ! 459: if (gp == gh->g_list && gp->ge_link == NOGE) ! 460: goto skip; ! 461: if (!metoo && strcmp(cp, myname) == 0) ! 462: np->n_type |= GDEL; ! 463: skip: ! 464: nlist = put(nlist, np); ! 465: } ! 466: depth--; ! 467: return(nlist); ! 468: } ! 469: ! 470: ! 471: ! 472: /* ! 473: * Compute the length of the passed name list and ! 474: * return it. ! 475: */ ! 476: ! 477: lengthof(name) ! 478: struct name *name; ! 479: { ! 480: register struct name *np; ! 481: register int c; ! 482: ! 483: for (c = 0, np = name; np != NIL; c++, np = np->n_flink) ! 484: ; ! 485: return(c); ! 486: } ! 487: ! 488: /* ! 489: * Concatenate the two passed name lists, return the result. ! 490: */ ! 491: ! 492: struct name * ! 493: cat(n1, n2) ! 494: struct name *n1, *n2; ! 495: { ! 496: register struct name *tail; ! 497: ! 498: if (n1 == NIL) ! 499: return(n2); ! 500: if (n2 == NIL) ! 501: return(n1); ! 502: tail = tailof(n1); ! 503: tail->n_flink = n2; ! 504: n2->n_blink = tail; ! 505: return(n1); ! 506: } ! 507: ! 508: /* ! 509: * Unpack the name list onto a vector of strings. ! 510: * Return an error if the name list won't fit. ! 511: */ ! 512: ! 513: char ** ! 514: unpack(np) ! 515: struct name *np; ! 516: { ! 517: register char **ap, **top; ! 518: register struct name *n; ! 519: char *cp; ! 520: char hbuf[10]; ! 521: int t, extra, metoo; ! 522: ! 523: n = np; ! 524: if ((t = lengthof(n)) == 0) ! 525: panic("No names to unpack"); ! 526: ! 527: /* ! 528: * Compute the number of extra arguments we will need. ! 529: * We need at least two extra -- one for "mail" and one for ! 530: * the terminating 0 pointer. Additional spots may be needed ! 531: * to pass along -r and -f to the host mailer. ! 532: */ ! 533: ! 534: extra = 2; ! 535: if (rflag != NOSTR) ! 536: extra += 2; ! 537: #ifdef DELIVERMAIL ! 538: extra++; ! 539: metoo = value("metoo") != NOSTR; ! 540: if (metoo) ! 541: extra++; ! 542: #endif DELIVERMAIL ! 543: if (hflag) ! 544: extra += 2; ! 545: top = (char **) salloc((t + extra) * sizeof cp); ! 546: ap = top; ! 547: *ap++ = "send-mail"; ! 548: if (rflag != NOSTR) { ! 549: *ap++ = "-r"; ! 550: *ap++ = rflag; ! 551: } ! 552: #ifdef DELIVERMAIL ! 553: *ap++ = "-i"; ! 554: if (metoo) ! 555: *ap++ = "-m"; ! 556: #endif DELIVERMAIL ! 557: if (hflag) { ! 558: *ap++ = "-h"; ! 559: sprintf(hbuf, "%d", hflag); ! 560: *ap++ = savestr(hbuf); ! 561: } ! 562: while (n != NIL) { ! 563: if (n->n_type & GDEL) { ! 564: n = n->n_flink; ! 565: continue; ! 566: } ! 567: cp = n->n_name; ! 568: while (*cp == '\\') ! 569: cp++; ! 570: *ap++ = cp; ! 571: n = n->n_flink; ! 572: } ! 573: *ap = NOSTR; ! 574: return(top); ! 575: } ! 576: ! 577: /* ! 578: * See if the user named himself as a destination ! 579: * for outgoing mail. If so, set the global flag ! 580: * selfsent so that we avoid removing his mailbox. ! 581: */ ! 582: ! 583: mechk(names) ! 584: struct name *names; ! 585: { ! 586: register struct name *np; ! 587: ! 588: for (np = names; np != NIL; np = np->n_flink) ! 589: if ((np->n_type & GDEL) == 0 && equal(myname, np->n_name)) { ! 590: selfsent++; ! 591: return; ! 592: } ! 593: } ! 594: ! 595: /* ! 596: * Remove all of the duplicates from the passed name list by ! 597: * insertion sorting them, then checking for dups. ! 598: * Return the head of the new list. ! 599: */ ! 600: ! 601: struct name * ! 602: elide(names) ! 603: struct name *names; ! 604: { ! 605: register struct name *np, *t, *new; ! 606: struct name *x; ! 607: ! 608: if (names == NIL) ! 609: return(NIL); ! 610: new = names; ! 611: np = names; ! 612: np = np->n_flink; ! 613: if (np != NIL) ! 614: np->n_blink = NIL; ! 615: new->n_flink = NIL; ! 616: while (np != NIL) { ! 617: t = new; ! 618: while (nstrcmp(t->n_name, np->n_name) < 0) { ! 619: if (t->n_flink == NIL) ! 620: break; ! 621: t = t->n_flink; ! 622: } ! 623: ! 624: /* ! 625: * If we ran out of t's, put the new entry after ! 626: * the current value of t. ! 627: */ ! 628: ! 629: if (nstrcmp(t->n_name, np->n_name) < 0) { ! 630: t->n_flink = np; ! 631: np->n_blink = t; ! 632: t = np; ! 633: np = np->n_flink; ! 634: t->n_flink = NIL; ! 635: continue; ! 636: } ! 637: ! 638: /* ! 639: * Otherwise, put the new entry in front of the ! 640: * current t. If at the front of the list, ! 641: * the new guy becomes the new head of the list. ! 642: */ ! 643: ! 644: if (t == new) { ! 645: t = np; ! 646: np = np->n_flink; ! 647: t->n_flink = new; ! 648: new->n_blink = t; ! 649: t->n_blink = NIL; ! 650: new = t; ! 651: continue; ! 652: } ! 653: ! 654: /* ! 655: * The normal case -- we are inserting into the ! 656: * middle of the list. ! 657: */ ! 658: ! 659: x = np; ! 660: np = np->n_flink; ! 661: x->n_flink = t; ! 662: x->n_blink = t->n_blink; ! 663: t->n_blink->n_flink = x; ! 664: t->n_blink = x; ! 665: } ! 666: ! 667: /* ! 668: * Now the list headed up by new is sorted. ! 669: * Go through it and remove duplicates. ! 670: */ ! 671: ! 672: np = new; ! 673: while (np != NIL) { ! 674: t = np; ! 675: while (t->n_flink!=NIL && ! 676: icequal(np->n_name,t->n_flink->n_name)) ! 677: t = t->n_flink; ! 678: if (t == np || t == NIL) { ! 679: np = np->n_flink; ! 680: continue; ! 681: } ! 682: ! 683: /* ! 684: * Now t points to the last entry with the same name ! 685: * as np. Make np point beyond t. ! 686: */ ! 687: ! 688: np->n_flink = t->n_flink; ! 689: if (t->n_flink != NIL) ! 690: t->n_flink->n_blink = np; ! 691: np = np->n_flink; ! 692: } ! 693: return(new); ! 694: } ! 695: ! 696: /* ! 697: * Version of strcmp which ignores case differences. ! 698: */ ! 699: ! 700: nstrcmp(s1, s2) ! 701: register char *s1, *s2; ! 702: { ! 703: register int c1, c2; ! 704: ! 705: do { ! 706: c1 = *s1++; ! 707: c2 = *s2++; ! 708: } while (c1 && c1 == c2); ! 709: return(c1 - c2); ! 710: } ! 711: ! 712: /* ! 713: * Put another node onto a list of names and return ! 714: * the list. ! 715: */ ! 716: ! 717: struct name * ! 718: put(list, node) ! 719: struct name *list, *node; ! 720: { ! 721: node->n_flink = list; ! 722: node->n_blink = NIL; ! 723: if (list != NIL) ! 724: list->n_blink = node; ! 725: return(node); ! 726: } ! 727: ! 728: /* ! 729: * Determine the number of elements in ! 730: * a name list and return it. ! 731: */ ! 732: ! 733: count(np) ! 734: register struct name *np; ! 735: { ! 736: register int c = 0; ! 737: ! 738: while (np != NIL) { ! 739: c++; ! 740: np = np->n_flink; ! 741: } ! 742: return(c); ! 743: } ! 744: ! 745: /* ! 746: * Delete the given name from a namelist. ! 747: */ ! 748: ! 749: struct name * ! 750: delname(np, name) ! 751: register struct name *np; ! 752: char name[]; ! 753: { ! 754: register struct name *p; ! 755: ! 756: for (p = np; p != NIL; p = p->n_flink) ! 757: if (equal(p->n_name, name)) { ! 758: if (p->n_blink == NIL) { ! 759: if (p->n_flink != NIL) ! 760: p->n_flink->n_blink = NIL; ! 761: np = p->n_flink; ! 762: continue; ! 763: } ! 764: if (p->n_flink == NIL) { ! 765: if (p->n_blink != NIL) ! 766: p->n_blink->n_flink = NIL; ! 767: continue; ! 768: } ! 769: p->n_blink->n_flink = p->n_flink; ! 770: p->n_flink->n_blink = p->n_blink; ! 771: } ! 772: return(np); ! 773: } ! 774: ! 775: /* ! 776: * Call the given routine on each element of the name ! 777: * list, replacing said value if need be. ! 778: */ ! 779: ! 780: mapf(np, from) ! 781: register struct name *np; ! 782: char *from; ! 783: { ! 784: register struct name *p; ! 785: ! 786: for (p = np; p != NIL; p = p->n_flink) ! 787: p->n_name = netmap(p->n_name, from); ! 788: } ! 789: ! 790: /* ! 791: * Pretty print a name list ! 792: * Uncomment it if you need it. ! 793: */ ! 794: ! 795: prettyprint(name) ! 796: struct name *name; ! 797: { ! 798: register struct name *np; ! 799: ! 800: np = name; ! 801: while (np != NIL) { ! 802: fprintf(stderr, "%s(%d) ", np->n_name, np->n_type); ! 803: np = np->n_flink; ! 804: } ! 805: fprintf(stderr, "\n"); ! 806: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.