![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bbc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip|
Return to bbc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip |
1.1 ! root 1: /* bbc.c - ZOTnet BBoard checker */ ! 2: ! 3: #include "../h/mh.h" ! 4: #include "../zotnet/bboards.h" ! 5: #include <stdio.h> ! 6: #ifdef BPOP ! 7: #include "../zotnet/mts.h" ! 8: #endif BPOP ! 9: #include <errno.h> ! 10: #include <signal.h> ! 11: #ifndef sigmask ! 12: #define sigmask(s) (1 << ((s) - 1)) ! 13: #endif not sigmask ! 14: #include <sys/types.h> ! 15: #include <sys/stat.h> ! 16: #ifdef SIGTSTP ! 17: #include <sys/wait.h> ! 18: #include <sys/time.h> ! 19: #include <sys/resource.h> ! 20: #endif SIGTSTP ! 21: ! 22: ! 23: #define RCFILE ".bbrc" ! 24: ! 25: #define NBB 100 ! 26: ! 27: /* */ ! 28: ! 29: static struct swit switches[] = { ! 30: #define TOPICSW 0 ! 31: "topics", 6, ! 32: #define CHECKSW 1 ! 33: "check", 5, ! 34: #define READSW 2 ! 35: "read", 4, ! 36: ! 37: #define QUIETSW 3 ! 38: "quiet", 4, ! 39: #define VERBOSW 4 ! 40: "verbose", 4, ! 41: ! 42: #define ARCHSW 5 ! 43: "archive", 4, ! 44: #define NOARCH 6 ! 45: "noarchive", 3, ! 46: ! 47: #define PROTSW 7 ! 48: "protocol", 4, ! 49: #define NPROTSW 8 ! 50: "noprotocol", 3, ! 51: ! 52: #define PROGSW 9 ! 53: "mshproc program", 4, ! 54: ! 55: #define RCSW 10 ! 56: "rcfile rcfile", 4, ! 57: #define NRCSW 11 ! 58: "norcfile", 3, ! 59: ! 60: #define FILESW 12 ! 61: "file BBoardsfile", 4, ! 62: #define USERSW 13 ! 63: "user BBoardsuser", 4, ! 64: ! 65: #define HOSTSW 14 ! 66: "host host", ! 67: #ifndef BPOP ! 68: -4, ! 69: #else BPOP ! 70: 4, ! 71: #endif BPOP ! 72: #define RPOPSW 15 ! 73: "rpop", ! 74: #ifndef RPOP ! 75: -4, ! 76: #else RPOP ! 77: 4, ! 78: #endif RPOP ! 79: #define NRPOPSW 16 ! 80: "norpop", ! 81: #ifndef RPOP ! 82: -6, ! 83: #else RPOP ! 84: 6, ! 85: #endif RPOP ! 86: ! 87: #define HELPSW 17 ! 88: "help", 4, ! 89: ! 90: NULL, NULL ! 91: }; ! 92: ! 93: struct bbcount { ! 94: char *key; ! 95: int count; ! 96: struct bbcount *left; ! 97: struct bbcount *right; ! 98: }; ! 99: ! 100: /* */ ! 101: ! 102: extern int errno; ! 103: ! 104: static int changed = 0; ! 105: static int quitting = 0; ! 106: ! 107: static int archivesw = 0; ! 108: static int checksw = 0; ! 109: static int protsw = 1; ! 110: static int quietsw = 0; ! 111: static int readsw = 0; ! 112: static int topicsw = 0; ! 113: static int verbosw = 0; ! 114: ! 115: static int didpop = OK; ! 116: static int rpop = 1; ! 117: static char *user = BBOARDS; ! 118: static char *host = NULL; ! 119: #ifdef BPOP ! 120: extern char response[]; ! 121: ! 122: char *getusr(), **getip(); ! 123: #endif BPOP ! 124: ! 125: SIGDECL sigser(); ! 126: int action(); ! 127: #ifdef SIGTSTP ! 128: int tstpid; ! 129: static SIGDECL tstpser(); ! 130: #endif SIGTSTP ! 131: ! 132: static char *rcfile; ! 133: ! 134: ! 135: static struct bbcount *bbc = NULL; ! 136: static struct bboard *bbl = NULL; ! 137: ! 138: struct bbcount *add_count (), *seek_count (); ! 139: struct bboard *getbbaux (), *getbbvis (); ! 140: ! 141: /* */ ! 142: ! 143: /* ARGSUSED */ ! 144: ! 145: main(argc, argv) ! 146: int argc; ! 147: char **argv; ! 148: { ! 149: int bbp = 0, ! 150: vecp = 1; ! 151: char *cp, ! 152: *rc, ! 153: **ap, ! 154: **argp, ! 155: buffer[80], ! 156: *arguments[MAXARGS], ! 157: *bbs[NBB + 1], ! 158: *vec[MAXARGS]; ! 159: ! 160: invo_name = r1bindex (argv[0], '/'); ! 161: #ifdef BPOP ! 162: mts_init (invo_name); ! 163: if (popbbhost && *popbbhost) ! 164: host = popbbhost; ! 165: if (popbbuser && *popbbuser) ! 166: user = popbbuser, rpop = 0; ! 167: #endif BPOP ! 168: if ((cp = m_find (invo_name)) != NULL) { ! 169: ap = brkstring (cp = getcpy (cp), " ", "\n"); ! 170: ap = copyip (ap, arguments); ! 171: } ! 172: else ! 173: ap = arguments; ! 174: (void) copyip (argv + 1, ap); ! 175: argp = arguments; ! 176: ! 177: (void) setbbent (SB_STAY); ! 178: ! 179: /* */ ! 180: ! 181: while (cp = *argp++) { ! 182: if (*cp == '-') ! 183: switch (smatch (++cp, switches)) { ! 184: case AMBIGSW: ! 185: ambigsw (cp, switches); ! 186: done (1); ! 187: case UNKWNSW: ! 188: vec[vecp++] = --cp; ! 189: continue; ! 190: case HELPSW: ! 191: (void) sprintf (buffer, ! 192: "%s [bboards ...] [switches] [switches for mshproc]", ! 193: invo_name); ! 194: help (buffer, switches); ! 195: done (1); ! 196: ! 197: case TOPICSW: ! 198: topicsw++; ! 199: checksw = readsw = 0; ! 200: continue; ! 201: case CHECKSW: ! 202: checksw++; ! 203: readsw = topicsw = 0; ! 204: continue; ! 205: case READSW: ! 206: readsw++; ! 207: checksw = topicsw = 0; ! 208: continue; ! 209: ! 210: case ARCHSW: ! 211: archivesw++; ! 212: continue; ! 213: case NOARCH: ! 214: archivesw = 0; ! 215: continue; ! 216: ! 217: case PROTSW: ! 218: protsw++; ! 219: continue; ! 220: case NPROTSW: ! 221: protsw = 0; ! 222: continue; ! 223: ! 224: case QUIETSW: ! 225: quietsw++; ! 226: verbosw = 0; ! 227: continue; ! 228: case VERBOSW: ! 229: verbosw++; ! 230: quietsw = 0; ! 231: continue; ! 232: ! 233: case PROGSW: ! 234: if (!(mshproc = *argp++) || *mshproc == '-') ! 235: adios (NULLCP, "missing argument to %s", argp[-2]); ! 236: continue; ! 237: ! 238: case RCSW: ! 239: if (!(rc = *argp++) || *rc == '-') ! 240: adios (NULLCP, "missing argument to %s", argp[-2]); ! 241: continue; ! 242: case NRCSW: ! 243: rc = NULL; ! 244: continue; ! 245: ! 246: case FILESW: ! 247: if (!(cp = *argp++) || *cp == '-') ! 248: adios (NULLCP, "missing argument to %s", argp[-2]); ! 249: if (!setbbinfo (user, cp, 1)) ! 250: adios (NULLCP, "setbbinfo(%s, %s, 1) failed -- %s", ! 251: user, cp, getbberr ()); ! 252: continue; ! 253: case USERSW: ! 254: if (!(user = *argp++) || *user == '-') ! 255: adios (NULLCP, "missing argument to %s", argp[-2]); ! 256: continue; ! 257: ! 258: case HOSTSW: ! 259: if (!(host = *argp++) || *host == '-') ! 260: adios (NULLCP, "missing argument to %s", argp[-2]); ! 261: didpop = NOTOK; ! 262: continue; ! 263: case RPOPSW: ! 264: rpop++; ! 265: continue; ! 266: case NRPOPSW: ! 267: rpop = 0; ! 268: continue; ! 269: } ! 270: if (bbp < NBB) ! 271: bbs[bbp++] = cp; ! 272: else ! 273: adios (NULLCP, "too many bboards, starting with %s", cp); ! 274: } ! 275: bbs[bbp] = NULL; ! 276: ! 277: /* */ ! 278: ! 279: #ifdef BPOP ! 280: if (!*host) ! 281: host = NULL, didpop = OK; ! 282: if (!host || !rpop) ! 283: (void) setuid (getuid ()); ! 284: #endif BPOP ! 285: ! 286: if (!m_find ("path")) ! 287: free (path ("./", TFOLDER)); ! 288: ! 289: rcinit (rc); ! 290: ! 291: for (bbp = 0; cp = bbs[bbp]; bbp++) ! 292: add_bb (cp, NOTOK); ! 293: ! 294: if (topicsw) ! 295: topics (); ! 296: else { ! 297: default_bboards (); ! 298: if (checksw) ! 299: check (); ! 300: else ! 301: process (vecp, vec); ! 302: } ! 303: ! 304: #ifdef BPOP ! 305: if (didpop != OK && pop_quit () == NOTOK) ! 306: adios (NULLCP, "%s", response); ! 307: #endif BPOP ! 308: ! 309: done (0); ! 310: } ! 311: ! 312: /* */ ! 313: ! 314: topics() ! 315: { ! 316: register char *cp, ! 317: **ap; ! 318: register struct bboard *bb; ! 319: ! 320: printf ("%16s %s %s\n", "BBoard", "Items", ! 321: verbosw ? "Interesting Facts" : "Last Update"); ! 322: printf ("%16s %s %s\n", "------", "-----", ! 323: verbosw ? "-----------------" : "-----------"); ! 324: ! 325: for (bb = bbl ? bbl : getbbvis (); ! 326: bb; ! 327: bb = bbl ? bb -> bb_link : getbbvis ()) { ! 328: printf ("%16s %5d %s\n", ! 329: bb -> bb_name, bb -> bb_maxima, bb -> bb_date); ! 330: if (verbosw) { ! 331: if (*bb -> bb_aka) { ! 332: cp = NULL; ! 333: for (ap = bb -> bb_aka; *ap; ap++) ! 334: cp = add (*ap, cp ? add (", ", cp) : cp); ! 335: printv ("AKA", cp); ! 336: free (cp); ! 337: } ! 338: ! 339: printv ("Leaders", *bb -> bb_leader); ! 340: for (ap = bb -> bb_leader + 1; *ap; ap++) ! 341: printv (NULLCP, *ap); ! 342: printv ("File", bb -> bb_file); ! 343: printv ("Archive", bb -> bb_archive); ! 344: printv ("Info", bb -> bb_info); ! 345: printv ("Map", bb -> bb_map); ! 346: printv ("Password", bb -> bb_passwd); ! 347: if (strcmp (bb -> bb_name, bb -> bb_addr)) ! 348: printv ("Address", bb -> bb_addr); ! 349: if (strcmp (*bb -> bb_leader, bb -> bb_request)) ! 350: printv ("Request", bb -> bb_request); ! 351: if (*bb -> bb_relay) ! 352: printv ("Relay", bb -> bb_relay); ! 353: if (*bb -> bb_dist) { ! 354: changed = 0; ! 355: (void) getbbdist (bb, action); ! 356: if (!changed) ! 357: printv ("Dist", ""); ! 358: if (cp = getbberr ()) ! 359: printv ("Error", cp); ! 360: } ! 361: printb (bb -> bb_flags); ! 362: } ! 363: } ! 364: } ! 365: ! 366: /* */ ! 367: ! 368: printv(key, value) ! 369: register char *key, *value; ! 370: { ! 371: char buffer[BUFSIZ]; ! 372: ! 373: if (key) ! 374: (void) sprintf (buffer, "%s: ", key); ! 375: else ! 376: buffer[0] = '\0'; ! 377: printf ("%*s%-*s", 25, "", 10, buffer); ! 378: if (value && *value) ! 379: printf ("%s", value); ! 380: (void) putchar ('\n'); ! 381: } ! 382: ! 383: action(local, domain) ! 384: register char *local, *domain; ! 385: { ! 386: char buffer[BUFSIZ]; ! 387: ! 388: (void) sprintf (buffer, "%s@%s", local, domain); ! 389: printv (changed++ ? NULL : "Dist", buffer); ! 390: return 0; ! 391: } ! 392: ! 393: ! 394: printb(flags) ! 395: unsigned int flags; ! 396: { ! 397: char buffer[BUFSIZ]; ! 398: ! 399: printv ("Flags", sprintb (buffer, flags, BBITS)); ! 400: } ! 401: ! 402: /* */ ! 403: ! 404: check() ! 405: { ! 406: #define grammar(a,b,c) (a == 1 ? b : c) ! 407: #define plural(d) grammar(d, "", "s") ! 408: ! 409: int diff; ! 410: register struct bboard *bb; ! 411: ! 412: for (bb = bbl; bb; bb = bb -> bb_link) { ! 413: diff = bb -> bb_maxima - bb -> bb_count; ! 414: if (quietsw) { ! 415: if (diff > 0) ! 416: printf ("%s -- %d item%s unseen\n", ! 417: bb -> bb_name, diff, plural (diff)); ! 418: } ! 419: else ! 420: if (bb -> bb_maxima == 0) ! 421: printf ("%s -- empty\n", bb -> bb_name); ! 422: else ! 423: if (bb -> bb_count == 0) ! 424: printf ("%s -- %d item%sseen)\n", ! 425: bb -> bb_name, bb -> bb_maxima, ! 426: grammar (bb -> bb_maxima, " (un", "s (none ")); ! 427: else ! 428: if (diff <= 0) ! 429: printf ("%s -- %d item%s (all seen)\n", ! 430: bb -> bb_name, bb -> bb_maxima, ! 431: plural (bb -> bb_maxima)); ! 432: else ! 433: printf ("%s -- %d item%s unseen\n", ! 434: bb -> bb_name, diff, plural (diff)); ! 435: } ! 436: } ! 437: ! 438: /* */ ! 439: ! 440: process(vecp, vec) ! 441: int vecp; ! 442: char *vec[]; ! 443: { ! 444: int diff; ! 445: #ifdef SIGTSTP ! 446: SIGDECL (*tstat)(); ! 447: #endif SIGTSTP ! 448: register struct bboard *bb; ! 449: ! 450: vec[0] = r1bindex (mshproc, '/'); ! 451: #ifdef SIGTSTP ! 452: tstat = signal (SIGTSTP, tstpser); ! 453: #endif SIGTSTP ! 454: ! 455: for (bb = bbl; bb && !quitting; bb = bb -> bb_link) { ! 456: diff = bb -> bb_maxima - bb -> bb_count; ! 457: if (bb -> bb_maxima == 0) { ! 458: if (!quietsw) ! 459: printf ("%s -- empty\n", bb -> bb_name); ! 460: continue; ! 461: } ! 462: else ! 463: if (verbosw || archivesw || diff > 0) ! 464: bbread (bb, vecp, vec); ! 465: else ! 466: if (!quietsw) ! 467: printf ("%s -- %d item%s (all seen)\n", ! 468: bb -> bb_name, bb -> bb_maxima, ! 469: plural (bb -> bb_maxima)); ! 470: ! 471: }; ! 472: ! 473: #ifdef SIGTSTP ! 474: (void) signal (SIGTSTP, tstat); ! 475: #endif SIGTSTP ! 476: rcend (); ! 477: } ! 478: ! 479: /* */ ! 480: ! 481: #ifdef BPOP ! 482: /* ARGSUSED */ ! 483: ! 484: static int ! 485: xtnd1(s) ! 486: char *s; ! 487: { ! 488: return OK; ! 489: } ! 490: #endif BPOP ! 491: ! 492: /* */ ! 493: ! 494: bbread(bb, vecp, vec) ! 495: register struct bboard *bb; ! 496: int vecp; ! 497: char *vec[]; ! 498: { ! 499: int child_id, ! 500: pd[2]; ! 501: char buf1[BUFSIZ], ! 502: buf2[BUFSIZ], ! 503: buf3[BUFSIZ]; ! 504: #ifdef BPOP ! 505: int nmsgs, ! 506: nbytes; ! 507: char buf4[BUFSIZ], ! 508: buf5[BUFSIZ]; ! 509: #endif BPOP ! 510: struct stat st; ! 511: ! 512: #ifdef BPOP ! 513: if (bb -> bb_flags & BB_REMOTE) { ! 514: if (pop_xtnd (xtnd1, "%s %s", archivesw ? "archive" : "bboards", ! 515: bb -> bb_name) == NOTOK) { ! 516: advise (NULLCP, "%s", response); ! 517: return; ! 518: } ! 519: if (pop_stat (&nmsgs, &nbytes) == NOTOK) ! 520: adios (NULLCP, "%s", response); ! 521: if (nmsgs == 0) ! 522: return; ! 523: if (pop_fd (buf4, buf5) == NOTOK) ! 524: adios (NULLCP, "%s", response); ! 525: } ! 526: else ! 527: #endif BPOP ! 528: if (stat (archivesw ? bb -> bb_archive : bb -> bb_file, &st) != NOTOK ! 529: && st.st_size == 0) ! 530: return; ! 531: ! 532: if (protsw) { ! 533: if (pipe (pd) == NOTOK) ! 534: adios ("pipe", "unable to"); ! 535: (void) sprintf (buf3, "%d", getpid ()); ! 536: } ! 537: ! 538: switch (child_id = fork ()) { ! 539: case NOTOK: ! 540: adios ("fork", "unable to"); ! 541: ! 542: case OK: ! 543: if (protsw) { ! 544: (void) close (pd[0]); ! 545: (void) sprintf (buf1, "%d", bb -> bb_count + 1); ! 546: (void) sprintf (buf2, "%d", pd[1]); ! 547: vec[vecp++] = "-idname"; ! 548: vec[vecp++] = bb -> bb_name; ! 549: vec[vecp++] = "-idstart"; ! 550: vec[vecp++] = buf1; ! 551: vec[vecp++] = "-idstop"; ! 552: vec[vecp++] = buf2; ! 553: vec[vecp++] = "-idquit"; ! 554: vec[vecp++] = buf3; ! 555: } ! 556: #ifdef BPOP ! 557: if (bb -> bb_flags & BB_REMOTE) { ! 558: vec[vecp++] = "-popread"; ! 559: vec[vecp++] = buf4; ! 560: vec[vecp++] = "-popwrite"; ! 561: vec[vecp++] = buf5; ! 562: } ! 563: #endif BPOP ! 564: vec[vecp++] = archivesw ? bb -> bb_archive : bb -> bb_file; ! 565: vec[vecp] = NULL; ! 566: execvp (mshproc, vec); ! 567: fprintf (stderr, "unable to exec "); ! 568: perror (mshproc); ! 569: _exit (-1); ! 570: ! 571: default: ! 572: #ifdef SIGTSTP ! 573: tstpid = child_id; ! 574: #endif SIGTSTP ! 575: if (protsw) { ! 576: (void) close (pd[1]); ! 577: pgmread (pd[0], child_id, bb); ! 578: } ! 579: else ! 580: (void) pidXwait (child_id, mshproc); ! 581: } ! 582: } ! 583: ! 584: /* */ ! 585: ! 586: pgmread(pd, child_id, bb) ! 587: int pd, child_id; ! 588: register struct bboard *bb; ! 589: { ! 590: int i, ! 591: j, ! 592: n; ! 593: SIGDECL (*estat)(), (*hstat)(), (*istat)(), (*qstat)(), (*tstat)(); ! 594: char buffer[BUFSIZ]; ! 595: struct bbcount *selected; ! 596: ! 597: estat = signal (SIGEMT, sigser); ! 598: hstat = signal (SIGHUP, SIG_IGN); ! 599: istat = signal (SIGINT, SIG_IGN); ! 600: qstat = signal (SIGQUIT, SIG_IGN); ! 601: tstat = signal (SIGTERM, sigser); ! 602: ! 603: while ((n = read (pd, buffer, sizeof buffer)) == NOTOK && errno == EINTR) ! 604: continue; ! 605: (void) close (pd); ! 606: (void) pidXwait (child_id, mshproc); ! 607: ! 608: (void) signal (SIGEMT, estat); ! 609: (void) signal (SIGHUP, hstat); ! 610: (void) signal (SIGINT, istat); ! 611: (void) signal (SIGQUIT, qstat); ! 612: (void) signal (SIGTERM, tstat); ! 613: ! 614: if (n <= 0) ! 615: return; ! 616: if (sscanf (buffer, "%d %d", &i, &j) != 2 || i <= 0 || j <= 0) ! 617: return; ! 618: ! 619: if ((selected = seek_count (bbc, bb -> bb_name)) == NULL) { ! 620: bbc = add_count (bbc, bb -> bb_name, i); ! 621: changed++; ! 622: } ! 623: else ! 624: if (archivesw) { ! 625: if (i > selected -> count) { ! 626: selected -> count = i; ! 627: changed++; ! 628: } ! 629: } ! 630: else { ! 631: if (bb -> bb_maxima > j && i >= j)/* bbl... */ ! 632: i = bb -> bb_maxima; ! 633: if (i != selected -> count) { ! 634: selected -> count = i; ! 635: changed++; ! 636: } ! 637: } ! 638: } ! 639: ! 640: ! 641: /* ARGSUSED */ ! 642: ! 643: SIGDECL ! 644: sigser(i) ! 645: int i; ! 646: { ! 647: #ifndef BSD42 ! 648: (void) signal (i, sigser); ! 649: #endif not BSD42 ! 650: quitting++; ! 651: } ! 652: ! 653: /* */ ! 654: ! 655: rcinit(rc) ! 656: register char *rc; ! 657: { ! 658: int state; ! 659: register char *cp; ! 660: char key[NAMESZ], ! 661: value[BUFSIZ]; ! 662: register FILE *bbrc; ! 663: ! 664: if ((cp = rc ? rc : getenv ("MHBBRC")) && *cp) { ! 665: rcfile = path (cp, TFILE); ! 666: if (*cp != '/') ! 667: (void) putenv ("MHBBRC", rcfile); ! 668: } ! 669: else ! 670: rcfile = concat (mypath, "/", RCFILE, NULLCP); ! 671: ! 672: if ((bbrc = fopen (rcfile, "r")) == NULL) ! 673: if (cp && *cp) ! 674: adios (rcfile, "unable to read"); ! 675: else ! 676: return; ! 677: ! 678: for (state = FLD;;) { ! 679: switch (state = m_getfld (state, key, value, sizeof value, bbrc)) { ! 680: case FLD: ! 681: case FLDEOF: ! 682: make_lower (key, key); ! 683: bbc = add_count (bbc, key, atoi (value)); ! 684: if (state == FLDEOF) ! 685: break; ! 686: continue; ! 687: ! 688: default: ! 689: admonish (NULLCP, "bad format: %s", rcfile); ! 690: case FILEEOF: ! 691: break; ! 692: } ! 693: ! 694: break; ! 695: } ! 696: ! 697: if (ferror (bbrc)) ! 698: admonish (rcfile, "error reading"); ! 699: (void) fclose (bbrc); ! 700: } ! 701: ! 702: /* */ ! 703: ! 704: rcend() ! 705: { ! 706: SIGDECL (*hstat)(), (*istat)(), (*qstat)(), (*tstat)(); ! 707: register FILE *bbrc; ! 708: ! 709: if (!changed) ! 710: return; ! 711: ! 712: hstat = signal (SIGHUP, SIG_IGN); ! 713: istat = signal (SIGINT, SIG_IGN); ! 714: qstat = signal (SIGQUIT, SIG_IGN); ! 715: tstat = signal (SIGTERM, SIG_IGN); ! 716: ! 717: if ((bbrc = fopen (rcfile, "w")) == NULL) ! 718: adios (rcfile, "unable to write"); ! 719: rcput (bbrc, bbc); ! 720: ! 721: if (ferror (bbrc)) ! 722: adios (rcfile, "error writing"); ! 723: (void) fclose (bbrc); ! 724: ! 725: (void) signal (SIGHUP, hstat); ! 726: (void) signal (SIGINT, istat); ! 727: (void) signal (SIGQUIT, qstat); ! 728: (void) signal (SIGTERM, tstat); ! 729: ! 730: changed = 0; ! 731: } ! 732: ! 733: rcput(bbrc, p) ! 734: register FILE *bbrc; ! 735: register struct bbcount *p; ! 736: { ! 737: if (p == NULL) ! 738: return; ! 739: ! 740: fprintf (bbrc, "%s: %d\n", p -> key, p -> count); ! 741: rcput (bbrc, p -> left); ! 742: rcput (bbrc, p -> right); ! 743: } ! 744: ! 745: /* */ ! 746: ! 747: #ifdef SIGTSTP ! 748: static SIGDECL ! 749: tstpser(sig) ! 750: int sig; ! 751: { ! 752: int pid; ! 753: union wait w; ! 754: ! 755: rcend (); ! 756: ! 757: while ((pid = wait3 (&w, WUNTRACED, (struct rusage *) 0)) != NOTOK ! 758: && pid != tstpid) ! 759: continue; ! 760: ! 761: (void) signal (SIGTSTP, SIG_DFL); ! 762: #ifdef BSD42 ! 763: (void) sigsetmask (sigblock (0) & ~sigmask (SIGTSTP)); ! 764: #endif BSD42 ! 765: ! 766: (void) kill (getpid (), sig); ! 767: ! 768: #ifdef BSD42 ! 769: (void) sigblock (sigmask (SIGTSTP)); ! 770: #endif BSD42 ! 771: (void) signal (SIGTSTP, tstpser); ! 772: } ! 773: #endif SIGTSTP ! 774: ! 775: /* */ ! 776: ! 777: struct bbcount * ! 778: add_count(p, w, i) ! 779: register struct bbcount *p; ! 780: register char *w; ! 781: int i; ! 782: { ! 783: int cond; ! 784: ! 785: if (p == NULL) { ! 786: p = (struct bbcount *) malloc (sizeof *p); ! 787: if (p == NULL) ! 788: adios (NULLCP,"insufficient memory"); ! 789: p -> key = getcpy (w); ! 790: p -> count = i; ! 791: p -> left = p -> right = NULL; ! 792: } ! 793: else ! 794: if ((cond = strcmp (w, p -> key)) < 0) ! 795: p -> left = add_count (p -> left, w, i); ! 796: else ! 797: if (cond > 0) ! 798: p -> right = add_count (p -> right, w, i); ! 799: ! 800: return p; ! 801: } ! 802: ! 803: struct bbcount * ! 804: seek_count(p, w) ! 805: register struct bbcount *p; ! 806: register char *w; ! 807: { ! 808: int cond; ! 809: ! 810: if (p == NULL || (cond = strcmp (w, p -> key)) == 0) ! 811: return p; ! 812: else ! 813: return seek_count (cond < 0 ? p -> left : p -> right, w); ! 814: } ! 815: ! 816: /* */ ! 817: ! 818: default_bboards() ! 819: { ! 820: register char *cp, ! 821: **ap; ! 822: ! 823: if (bbl != NULL) ! 824: return; ! 825: ! 826: if (!archivesw && ((cp = m_find ("bboards")) != NULL)) { ! 827: #ifndef BPOP ! 828: for (ap = brkstring (cp = getcpy (cp), " ", "\n"); *ap; ap++) ! 829: #else BPOP ! 830: for (ap = getip (cp); *ap; ap++) ! 831: #endif BPOP ! 832: add_bb (*ap, OK); ! 833: #ifndef BPOP ! 834: free (cp); ! 835: #endif not BPOP ! 836: } ! 837: else ! 838: add_bb ("system", NOTOK); ! 839: ! 840: if (bbl == NULL) ! 841: done (1); ! 842: } ! 843: ! 844: /* */ ! 845: ! 846: add_bb(s, hush) ! 847: register char *s; ! 848: int hush; ! 849: { ! 850: register struct bboard *bb; ! 851: static struct bboard *tail = NULL; ! 852: ! 853: make_lower (s, s); ! 854: if ((bb = getbbaux (s)) == NULL) ! 855: if (hush == OK) ! 856: return; ! 857: else ! 858: adios (NULLCP, "no such bboard as '%s'", s); ! 859: ! 860: if (tail != NULL) ! 861: tail -> bb_link = bb; ! 862: if (bbl == NULL) ! 863: bbl = bb; ! 864: tail = bb; ! 865: } ! 866: ! 867: /* */ ! 868: ! 869: #ifdef BPOP ! 870: static struct bboard *Bhead = NULL; ! 871: static struct bboard *Btail = NULL; ! 872: ! 873: static int ! 874: xtnd2(s) ! 875: char *s; ! 876: { ! 877: int maxima; ! 878: char name[BUFSIZ]; ! 879: register struct bboard *bb; ! 880: ! 881: if (sscanf (s, "%s %d", name, &maxima) != 2) ! 882: adios (NULLCP, "XTND2 botch: %s", s); ! 883: ! 884: if ((bb = (struct bboard *) calloc (1, sizeof *bb)) == NULL) ! 885: adios (NULLCP, "insufficient memory"); ! 886: bb -> bb_name = getcpy (name); ! 887: if ((bb -> bb_aka = (char **) calloc (1, sizeof *bb -> bb_aka)) == NULL) ! 888: adios (NULLCP, "insufficient memory"); ! 889: *bb -> bb_aka = NULL; ! 890: bb -> bb_file = bb -> bb_archive = bb -> bb_info = bb -> bb_map = ""; ! 891: bb -> bb_passwd = ""; ! 892: if ((bb -> bb_leader = (char **) calloc (1, sizeof *bb -> bb_leader)) ! 893: == NULL) ! 894: adios (NULLCP, "insufficient memory"); ! 895: *bb -> bb_leader = NULL; ! 896: bb -> bb_addr = bb -> bb_request = bb -> bb_relay = ""; ! 897: if ((bb -> bb_dist = (char **) calloc (1, sizeof *bb -> bb_dist)) == NULL) ! 898: adios (NULLCP, "insufficient memory"); ! 899: *bb -> bb_dist = NULL; ! 900: bb -> bb_flags = BB_REMOTE; ! 901: bb -> bb_count = 0; ! 902: bb -> bb_maxima = maxima; ! 903: bb -> bb_date = ""; ! 904: bb -> bb_next = bb -> bb_link = bb -> bb_chain = NULL; ! 905: ! 906: if (Btail != NULL) ! 907: Btail -> bb_chain = bb; ! 908: if (Bhead == NULL) ! 909: Bhead = bb; ! 910: Btail = bb; ! 911: ! 912: return OK; ! 913: } ! 914: ! 915: /* */ ! 916: ! 917: static int ! 918: xtnd3(s) ! 919: char *s; ! 920: { ! 921: static int bbs = 0; ! 922: static struct bboard *bb; ! 923: ! 924: switch (bbs++) { ! 925: case 0: ! 926: for (bb = Bhead; bb; bb = bb -> bb_chain) ! 927: if (strcmp (bb -> bb_name, s) == 0) ! 928: break; ! 929: if (bb == NULL) ! 930: adios (NULLCP, "XTND3 botch"); ! 931: ! 932: free (bb -> bb_name); ! 933: bb -> bb_name = getcpy (s); ! 934: break; ! 935: case 1: ! 936: if (bb -> bb_aka) ! 937: free ((char *) bb -> bb_aka); ! 938: bb -> bb_aka = getip (s); ! 939: break; ! 940: case 2: ! 941: bb -> bb_file = getcpy (s); ! 942: break; ! 943: case 3: ! 944: bb -> bb_archive = getcpy (s); ! 945: break; ! 946: case 4: ! 947: bb -> bb_info = getcpy (s); ! 948: break; ! 949: case 5: ! 950: bb -> bb_map = getcpy (s); ! 951: break; ! 952: case 6: ! 953: bb -> bb_passwd = getcpy (s); ! 954: break; ! 955: case 7: ! 956: if (bb -> bb_leader) ! 957: free ((char *) bb -> bb_leader); ! 958: bb -> bb_leader = getip (s); ! 959: break; ! 960: case 8: ! 961: bb -> bb_addr = getcpy (s); ! 962: break; ! 963: case 9: ! 964: bb -> bb_request = getcpy (s); ! 965: break; ! 966: case 10: ! 967: bb -> bb_relay = getcpy (s); ! 968: break; ! 969: case 11: ! 970: if (bb -> bb_dist) ! 971: free ((char *) bb -> bb_dist); ! 972: bb -> bb_dist = getip (s); ! 973: break; ! 974: case 12: ! 975: bb -> bb_flags = bb -> bb_maxima = 0; ! 976: (void) sscanf (s, "%o %d", &bb -> bb_flags, &bb -> bb_maxima); ! 977: bb -> bb_flags |= BB_REMOTE; ! 978: break; ! 979: case 13: ! 980: bb -> bb_date = getcpy (s); ! 981: bbs = 0; ! 982: break; ! 983: } ! 984: ! 985: return OK; ! 986: } ! 987: ! 988: ! 989: static char ** ! 990: getip(s) ! 991: char *s; ! 992: { ! 993: register char **ap, ! 994: **p, ! 995: **q; ! 996: ! 997: for (p = ap = brkstring (getcpy (s), " ", "\n"); *p; p++) ! 998: continue; ! 999: ! 1000: q = (char **) calloc ((unsigned) (p - ap + 1), sizeof *q); ! 1001: if (q == NULL) ! 1002: adios (NULLCP, "insufficient memory"); ! 1003: ! 1004: for (p = ap, ap = q; *p; *q++ = *p++) ! 1005: continue; ! 1006: *q = NULL; ! 1007: ! 1008: return ap; ! 1009: } ! 1010: ! 1011: /* */ ! 1012: ! 1013: static struct bboard *rover = NULL; ! 1014: ! 1015: struct bboard * ! 1016: getbbpop() ! 1017: { ! 1018: int snoop; ! 1019: char *cp, ! 1020: *pass = NULL; ! 1021: register struct bboard *bb; ! 1022: ! 1023: if (didpop != NOTOK && ((bb = getbbent ()) || !host)) ! 1024: return bb; ! 1025: ! 1026: if (Bhead == NULL) { ! 1027: snoop = (cp = getenv ("MHPOPDEBUG")) && *cp; ! 1028: if (rpop) { ! 1029: if (user == NULL) ! 1030: user = getusr (); ! 1031: pass = getusr (); ! 1032: } ! 1033: else ! 1034: if (strcmp (user, popbbuser) == 0) ! 1035: pass = user; ! 1036: else ! 1037: ruserpass (host, &user, &pass); ! 1038: if (didpop != NOTOK) ! 1039: didpop = DONE; ! 1040: ! 1041: if (pop_init (host, user, pass, snoop, rpop) == NOTOK) ! 1042: adios (NULLCP, "%s", response); ! 1043: if (rpop) ! 1044: (void) setuid (getuid ()); ! 1045: if (pop_xtnd (xtnd2, "bboards") == NOTOK) ! 1046: adios (NULLCP, "%s", response); ! 1047: if (topicsw && verbosw) /* could optimize here */ ! 1048: for (bb = Bhead; bb; bb = bb -> bb_chain) ! 1049: if (pop_xtnd (xtnd3, "x-bboards %s", bb -> bb_name) == NOTOK) ! 1050: adios (NULLCP, "%s", response); ! 1051: rover = Bhead; ! 1052: } ! 1053: ! 1054: if (bb = rover) ! 1055: rover = rover -> bb_chain; ! 1056: return bb; ! 1057: } ! 1058: ! 1059: #define getbbent getbbpop ! 1060: #endif BPOP ! 1061: ! 1062: /* */ ! 1063: ! 1064: struct bboard * ! 1065: getbbaux(s) ! 1066: register char *s; ! 1067: { ! 1068: #ifdef BPOP ! 1069: int nlatch = host ? 1 : 0; ! 1070: #endif BPOP ! 1071: register char **ap; ! 1072: register struct bbcount *selected; ! 1073: register struct bboard *bb; ! 1074: static struct bboard *head = NULL, ! 1075: *tail = NULL; ! 1076: ! 1077: for (bb = head; bb; bb = bb -> bb_next) { ! 1078: if (strcmp (bb -> bb_name, s) == 0) ! 1079: return bb; ! 1080: for (ap = bb -> bb_aka; *ap; ap++) ! 1081: if (strcmp (*ap, s) == 0) ! 1082: return bb; ! 1083: } ! 1084: ! 1085: #ifdef BPOP ! 1086: one_more_time: ; ! 1087: #endif BPOP ! 1088: while (bb = getbbent ()) { ! 1089: if ((selected = seek_count (bbc, bb -> bb_name)) != NULL) ! 1090: bb -> bb_count = selected -> count; ! 1091: ! 1092: #ifdef BPOP ! 1093: if (!(bb -> bb_flags & BB_REMOTE)) ! 1094: #endif BPOP ! 1095: if ((bb = getbbcpy (bb)) == NULL) ! 1096: adios (NULLCP, "insufficient memory"); ! 1097: if (tail != NULL) ! 1098: tail -> bb_next = bb; ! 1099: if (head == NULL) ! 1100: head = bb; ! 1101: tail = bb; ! 1102: ! 1103: if (strcmp (bb -> bb_name, s) == 0) ! 1104: return bb; ! 1105: for (ap = bb -> bb_aka; *ap; ap++) ! 1106: if (strcmp (*ap, s) == 0) ! 1107: return bb; ! 1108: } ! 1109: ! 1110: #ifdef BPOP ! 1111: if (nlatch && pop_xtnd (xtnd2, "bboards %s", s) != NOTOK) { ! 1112: rover = Bhead; ! 1113: nlatch = 0; ! 1114: goto one_more_time; ! 1115: } ! 1116: #endif BPOP ! 1117: ! 1118: return NULL; ! 1119: } ! 1120: ! 1121: struct bboard * ! 1122: getbbvis() ! 1123: { ! 1124: register struct bboard *bb; ! 1125: ! 1126: while (bb = getbbent ()) ! 1127: if (!(bb -> bb_flags & BB_INVIS) ! 1128: && (access (bb -> bb_file, 04) != NOTOK || errno != EACCES)) ! 1129: break; ! 1130: ! 1131: return bb; ! 1132: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.