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