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