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