![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msh.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip|
Return to msh.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip |
1.1 ! root 1: /* msh.c - The MH shell (sigh) */ ! 2: ! 3: /* TODO: ! 4: Keep more status information in maildrop map ! 5: */ ! 6: ! 7: #include "../h/mh.h" ! 8: #include "../h/dropsbr.h" ! 9: #include "../h/formatsbr.h" ! 10: #include "../h/scansbr.h" ! 11: #include "../zotnet/tws.h" ! 12: #include <stdio.h> ! 13: #include "../zotnet/mts.h" ! 14: #include <ctype.h> ! 15: #include <sys/types.h> ! 16: #include <sys/stat.h> ! 17: #ifndef SYS5 ! 18: #include <sgtty.h> ! 19: #else SYS5 ! 20: #include <termio.h> ! 21: #include <sys/ioctl.h> ! 22: #endif SYS5 ! 23: #include <pwd.h> ! 24: #include <setjmp.h> ! 25: #include <signal.h> ! 26: #include "../h/mshsbr.h" ! 27: #include "../h/vmhsbr.h" ! 28: ! 29: ! 30: #define QUOTE '\\' /* sigh */ ! 31: ! 32: ! 33: /* */ ! 34: ! 35: static struct swit switches[] = { ! 36: #define IDSW 0 ! 37: "idstart number", -7, /* interface from bbc */ ! 38: #define FDSW 1 ! 39: "idstop number", -6, /* .. */ ! 40: #define QDSW 2 ! 41: "idquit number", -6, /* .. */ ! 42: #define NMSW 3 ! 43: "idname BBoard", -6, /* .. */ ! 44: ! 45: #define PRMPTSW 4 ! 46: "prompt string", 0, ! 47: ! 48: #define SCANSW 5 ! 49: "scan", 0, ! 50: #define NSCANSW 6 ! 51: "noscan", 0, ! 52: ! 53: #define READSW 7 ! 54: "vmhread fd", -7, ! 55: #define WRITESW 8 ! 56: "vmhwrite fd", -8, ! 57: ! 58: #define PREADSW 9 ! 59: "popread fd", -7, ! 60: #define PWRITSW 10 ! 61: "popwrite fd", -8, ! 62: ! 63: #define TCURSW 11 ! 64: "topcur", 0, ! 65: #define NTCURSW 12 ! 66: "notopcur", 0, ! 67: ! 68: #define HELPSW 13 ! 69: "help", 4, ! 70: ! 71: NULL, NULL ! 72: }; ! 73: ! 74: /* */ ! 75: /* FOLDER */ ! 76: char *fmsh = NULL; /* folder instead of file */ ! 77: int modified; /* command modified folder */ ! 78: struct msgs *mp; /* used a lot */ ! 79: static int nMsgs = 0; ! 80: struct Msg *Msgs = NULL; /* Msgs[0] not used */ ! 81: static FILE *fp; /* input file */ ! 82: static FILE *yp = NULL; /* temporary file */ ! 83: static int mode; /* mode of file */ ! 84: static int numfds = 0; /* number of files cached */ ! 85: static int maxfds = 0; /* number of files cached to be cached */ ! 86: static time_t mtime = (time_t) 0;/* mtime of file */ ! 87: ! 88: ! 89: /* VMH */ ! 90: #define ALARM ((unsigned int) 10) ! 91: #define ttyN(c) ttyNaux ((c), NULLCP) ! 92: ! 93: static int vmh = 0; ! 94: ! 95: static int vmhpid = OK; ! 96: static int vmhfd0; ! 97: static int vmhfd1; ! 98: static int vmhfd2; ! 99: ! 100: static int vmhtty = NOTOK; ! 101: ! 102: #define SCAN 1 ! 103: #define STATUS 2 ! 104: #define DISPLAY 3 ! 105: #define NWIN DISPLAY ! 106: ! 107: static int topcur = 0; ! 108: ! 109: static int numwins = 0; ! 110: static int windows[NWIN + 1]; ! 111: ! 112: static jmp_buf peerenv; ! 113: ! 114: void padios (), padvise (); ! 115: int alrmser (); ! 116: ! 117: ! 118: #ifdef BPOP ! 119: /* POP */ ! 120: ! 121: static int pmsh = 0; /* BPOP enabled */ ! 122: ! 123: extern char response[]; ! 124: #endif BPOP ! 125: ! 126: ! 127: /* PARENT */ ! 128: static int pfd = NOTOK; /* fd parent is reading from */ ! 129: static int ppid = 0; /* pid of parent */ ! 130: ! 131: ! 132: /* COMMAND */ ! 133: int interactive; /* running from a /dev/tty */ ! 134: int redirected; /* re-directing output */ ! 135: FILE *sp = NULL; /* original stdout */ ! 136: ! 137: char *cmd_name; /* command being run */ ! 138: ! 139: char myfilter[BUFSIZ]; /* path to mhl.forward */ ! 140: ! 141: static char *myprompt = "(%s) ";/* prompting string */ ! 142: ! 143: ! 144: /* BBOARDS */ ! 145: static int gap; /* gap in BBoard-ID:s */ ! 146: ! 147: static char *myname = NULL; /* BBoard name */ ! 148: ! 149: char *BBoard_ID = "BBoard-ID";/* BBoard-ID constant */ ! 150: ! 151: /* SIGNALS */ ! 152: int (*istat) (); /* original SIGINT */ ! 153: static int (*pstat) (); /* current SIGPIPE */ ! 154: int (*qstat) (); /* original SIGQUIT */ ! 155: #ifdef SIGTSTP ! 156: static int (*tstat) (); /* original SIGTSTP */ ! 157: #endif SIGTSTP ! 158: int interrupted; /* SIGINT detected */ ! 159: int broken_pipe; /* SIGPIPE detected */ ! 160: int told_to_quit; /* SIGQUIT detected */ ! 161: ! 162: #ifdef BSD42 ! 163: int should_intr; /* signal handler should interrupt call */ ! 164: jmp_buf sigenv; /* the environment pointer */ ! 165: #endif BSD42 ! 166: ! 167: int intrser (), pipeser (), quitser (); ! 168: ! 169: ! 170: #ifdef SYS5 ! 171: struct passwd *getpwnam (); ! 172: #endif SYS5 ! 173: ! 174: /* */ ! 175: ! 176: /* ARGSUSED */ ! 177: ! 178: main (argc, argv) ! 179: int argc; ! 180: char **argv; ! 181: { ! 182: int id = 0, ! 183: scansw = 0, ! 184: vmh1 = 0, ! 185: vmh2 = 0; ! 186: #ifdef BPOP ! 187: int pmsh1 = 0, ! 188: pmsh2 = 0; ! 189: #endif BPOP ! 190: char *cp, ! 191: *file = NULL, ! 192: *folder = NULL, ! 193: **ap, ! 194: **argp, ! 195: buf[80], ! 196: *arguments[MAXARGS]; ! 197: ! 198: invo_name = r1bindex (argv[0], '/'); ! 199: mts_init (invo_name); ! 200: if ((cp = m_find (invo_name)) != NULL) { ! 201: ap = brkstring (cp = getcpy (cp), " ", "\n"); ! 202: ap = copyip (ap, arguments); ! 203: } ! 204: else ! 205: ap = arguments; ! 206: (void) copyip (argv + 1, ap); ! 207: argp = arguments; ! 208: ! 209: /* */ ! 210: ! 211: while (cp = *argp++) { ! 212: if (*cp == '-') ! 213: switch (smatch (++cp, switches)) { ! 214: case AMBIGSW: ! 215: ambigsw (cp, switches); ! 216: done (1); ! 217: case UNKWNSW: ! 218: adios (NULLCP, "-%s unknown", cp); ! 219: case HELPSW: ! 220: (void) sprintf (buf, "%s [switches] file", invo_name); ! 221: help (buf, switches); ! 222: done (1); ! 223: ! 224: case IDSW: ! 225: if (!(cp = *argp++) || *cp == '-') ! 226: adios (NULLCP, "missing argument to %s", argp[-2]); ! 227: if ((id = atoi (cp)) < 1) ! 228: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 229: continue; ! 230: case FDSW: ! 231: if (!(cp = *argp++) || *cp == '-') ! 232: adios (NULLCP, "missing argument to %s", argp[-2]); ! 233: if ((pfd = atoi (cp)) <= 1) ! 234: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 235: continue; ! 236: case QDSW: ! 237: if (!(cp = *argp++) || *cp == '-') ! 238: adios (NULLCP, "missing argument to %s", argp[-2]); ! 239: if ((ppid = atoi (cp)) <= 1) ! 240: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 241: continue; ! 242: case NMSW: ! 243: if (!(myname = *argp++) || *myname == '-') ! 244: adios (NULLCP, "missing argument to %s", argp[-2]); ! 245: continue; ! 246: ! 247: case SCANSW: ! 248: scansw++; ! 249: continue; ! 250: case NSCANSW: ! 251: scansw = 0; ! 252: continue; ! 253: ! 254: case PRMPTSW: ! 255: if (!(myprompt = *argp++) || *myprompt == '-') ! 256: adios (NULLCP, "missing argument to %s", argp[-2]); ! 257: continue; ! 258: ! 259: case READSW: ! 260: if (!(cp = *argp++) || *cp == '-') ! 261: adios (NULLCP, "missing argument to %s", argp[-2]); ! 262: if ((vmh1 = atoi (cp)) < 1) ! 263: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 264: continue; ! 265: case WRITESW: ! 266: if (!(cp = *argp++) || *cp == '-') ! 267: adios (NULLCP, "missing argument to %s", argp[-2]); ! 268: if ((vmh2 = atoi (cp)) < 1) ! 269: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 270: continue; ! 271: ! 272: case PREADSW: ! 273: if (!(cp = *argp++) || *cp == '-') ! 274: adios (NULLCP, "missing argument to %s", argp[-2]); ! 275: #ifdef BPOP ! 276: if ((pmsh1 = atoi (cp)) < 1) ! 277: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 278: #endif BPOP ! 279: continue; ! 280: case PWRITSW: ! 281: if (!(cp = *argp++) || *cp == '-') ! 282: adios (NULLCP, "missing argument to %s", argp[-2]); ! 283: #ifdef BPOP ! 284: if ((pmsh2 = atoi (cp)) < 1) ! 285: adios (NULLCP, "bad argument %s %s", argp[-2], cp); ! 286: #endif BPOP ! 287: continue; ! 288: ! 289: case TCURSW: ! 290: topcur++; ! 291: continue; ! 292: case NTCURSW: ! 293: topcur = 0; ! 294: continue; ! 295: } ! 296: if (*cp == '+' || *cp == '@') { ! 297: if (folder) ! 298: adios (NULLCP, "only one folder at a time!"); ! 299: else ! 300: folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF); ! 301: } ! 302: else ! 303: if (file) ! 304: adios (NULLCP, "only one file at a time!"); ! 305: else ! 306: file = cp; ! 307: } ! 308: ! 309: /* */ ! 310: ! 311: if (!file && !folder) ! 312: file = "./msgbox"; ! 313: if (file && folder) ! 314: adios (NULLCP, "use a file or a folder, not both"); ! 315: (void) strcpy (myfilter, libpath (mhlforward)); ! 316: #ifdef FIOCLEX ! 317: if (pfd > 1) ! 318: (void) ioctl (pfd, FIOCLEX, NULLCP); ! 319: #endif FIOCLEX ! 320: ! 321: #ifdef BSD42 ! 322: should_intr = 0; ! 323: #endif BSD42 ! 324: setsigx (istat, SIGINT, intrser); ! 325: setsigx (qstat, SIGQUIT, quitser); ! 326: ! 327: (void) sc_width (); /* MAGIC... */ ! 328: ! 329: if (vmh = vmh1 && vmh2) { ! 330: (void) rcinit (vmh1, vmh2); ! 331: (void) pINI (); ! 332: (void) signal (SIGINT, SIG_IGN); ! 333: (void) signal (SIGQUIT, SIG_IGN); ! 334: #ifdef SIGTSTP ! 335: tstat = signal (SIGTSTP, SIG_IGN); ! 336: #endif SIGTSTP ! 337: } ! 338: ! 339: #ifdef BPOP ! 340: if (pmsh = pmsh1 && pmsh2) { ! 341: cp = getenv ("MHPOPDEBUG"); ! 342: if (pop_set (pmsh1, pmsh2, cp && *cp) == NOTOK) ! 343: padios (NULLCP, "%s", response); ! 344: if (folder) ! 345: file = folder, folder = NULL; ! 346: } ! 347: #endif BPOP ! 348: ! 349: if (folder) ! 350: fsetup (folder); ! 351: else ! 352: setup (file); ! 353: readids (id); ! 354: display_info (id > 0 ? scansw : 0); ! 355: ! 356: msh (id > 0 ? scansw : 0); ! 357: ! 358: m_reset (); ! 359: ! 360: done (0); ! 361: } ! 362: ! 363: /* */ ! 364: ! 365: static struct swit mshcmds[] = { ! 366: #define ALICMD 0 ! 367: "ali", 0, ! 368: #define EXPLCMD 1 ! 369: "burst", 0, ! 370: #define COMPCMD 2 ! 371: "comp", 0, ! 372: #define DISTCMD 3 ! 373: "dist", 0, ! 374: #define EXITCMD 4 ! 375: "exit", 0, ! 376: #define FOLDCMD 5 ! 377: "folder", 0, ! 378: #define FORWCMD 6 ! 379: "forw", 0, ! 380: #define HELPCMD 7 ! 381: "help", 0, ! 382: #define INCMD 8 ! 383: "inc", 0, ! 384: #define MARKCMD 9 ! 385: "mark", 0, ! 386: #define MAILCMD 10 ! 387: "mhmail", 0, ! 388: #define MSGKCMD 11 ! 389: "msgchk", 0, ! 390: #define NEXTCMD 12 ! 391: "next", 0, ! 392: #define PACKCMD 13 ! 393: "packf", 0, ! 394: #define PICKCMD 14 ! 395: "pick", 0, ! 396: #define PREVCMD 15 ! 397: "prev", 0, ! 398: #define QUITCMD 16 ! 399: "quit", 0, ! 400: #define FILECMD 17 ! 401: "refile", 0, ! 402: #define REPLCMD 18 ! 403: "repl", 0, ! 404: #define RMMCMD 19 ! 405: "rmm", 0, ! 406: #define SCANCMD 20 ! 407: "scan", 0, ! 408: #define SENDCMD 21 ! 409: "send", 0, ! 410: #define SHOWCMD 22 ! 411: "show", 0, ! 412: #define SORTCMD 23 ! 413: "sortm", 0, ! 414: #define WHATCMD 24 ! 415: "whatnow", 0, ! 416: #define WHOMCMD 25 ! 417: "whom", 0, ! 418: ! 419: NULL, NULL ! 420: }; ! 421: ! 422: /* */ ! 423: ! 424: static msh (scansw) ! 425: int scansw; ! 426: { ! 427: int i; ! 428: register char *cp, ! 429: **ap; ! 430: char prompt[BUFSIZ], ! 431: *vec[MAXARGS]; ! 432: struct Cmd typein; ! 433: register struct Cmd *cmdp; ! 434: ! 435: (void) sprintf (prompt, myprompt, invo_name); ! 436: cmdp = &typein; ! 437: ! 438: for (;;) { ! 439: if (yp) { ! 440: (void) fclose (yp); ! 441: yp = NULL; ! 442: } ! 443: if (vmh) { ! 444: if ((i = getcmds (mshcmds, cmdp, scansw)) == EOF) { ! 445: (void) rcdone (); ! 446: return; ! 447: } ! 448: } ! 449: else { ! 450: (void) check_folder (scansw); ! 451: if ((i = getargs (prompt, mshcmds, cmdp)) == EOF) { ! 452: (void) putchar ('\n'); ! 453: return; ! 454: } ! 455: } ! 456: cmd_name = mshcmds[i].sw; ! 457: ! 458: switch (i) { ! 459: case QUITCMD: ! 460: quit (); ! 461: return; ! 462: ! 463: case EXITCMD: ! 464: case EXPLCMD: ! 465: case FOLDCMD: ! 466: case FORWCMD: /* sigh */ ! 467: case MARKCMD: ! 468: case NEXTCMD: ! 469: case PACKCMD: ! 470: case PICKCMD: ! 471: case PREVCMD: ! 472: case RMMCMD: ! 473: case SHOWCMD: ! 474: case SCANCMD: ! 475: case SORTCMD: ! 476: if ((cp = m_find (cmd_name)) != NULL) { ! 477: ap = brkstring (cp = getcpy (cp), " ", "\n"); ! 478: ap = copyip (ap, vec); ! 479: } ! 480: else ! 481: ap = vec; ! 482: break; ! 483: ! 484: default: ! 485: cp = NULL; ! 486: ap = vec; ! 487: break; ! 488: } ! 489: (void) copyip (cmdp -> args + 1, ap); ! 490: ! 491: m_init (); ! 492: ! 493: if (!vmh && init_io (cmdp, vmh) == NOTOK) { ! 494: if (cp != NULL) ! 495: free (cp); ! 496: continue; ! 497: } ! 498: modified = 0; ! 499: redirected = vmh || cmdp -> direction != STDIO; ! 500: ! 501: switch (i) { ! 502: case ALICMD: ! 503: case COMPCMD: ! 504: case INCMD: ! 505: case MAILCMD: ! 506: case MSGKCMD: ! 507: case SENDCMD: ! 508: case WHATCMD: ! 509: case WHOMCMD: ! 510: if (!vmh || ttyN (cmdp) != NOTOK) ! 511: forkcmd (vec, cmd_name); ! 512: break; ! 513: ! 514: case DISTCMD: ! 515: if (!vmh || ttyN (cmdp) != NOTOK) ! 516: distcmd (vec); ! 517: break; ! 518: ! 519: case EXPLCMD: ! 520: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 521: explcmd (vec); ! 522: break; ! 523: ! 524: case FILECMD: ! 525: if (!vmh ! 526: || (filehak (vec) == OK ? ttyN (cmdp) ! 527: : winN (cmdp, DISPLAY, 1)) != NOTOK) ! 528: filecmd (vec); ! 529: break; ! 530: ! 531: case FOLDCMD: ! 532: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 533: foldcmd (vec); ! 534: break; ! 535: ! 536: case FORWCMD: ! 537: if (!vmh || ttyN (cmdp) != NOTOK) ! 538: forwcmd (vec); ! 539: break; ! 540: ! 541: case HELPCMD: ! 542: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 543: helpcmd (vec); ! 544: break; ! 545: ! 546: case EXITCMD: ! 547: case MARKCMD: ! 548: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 549: markcmd (vec); ! 550: break; ! 551: ! 552: case NEXTCMD: ! 553: case PREVCMD: ! 554: case SHOWCMD: ! 555: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 556: showcmd (vec); ! 557: break; ! 558: ! 559: case PACKCMD: ! 560: if (!vmh ! 561: || (packhak (vec) == OK ? ttyN (cmdp) ! 562: : winN (cmdp, DISPLAY, 1)) != NOTOK) ! 563: packcmd (vec); ! 564: break; ! 565: ! 566: case PICKCMD: ! 567: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 568: pickcmd (vec); ! 569: break; ! 570: ! 571: case REPLCMD: ! 572: if (!vmh || ttyN (cmdp) != NOTOK) ! 573: replcmd (vec); ! 574: break; ! 575: ! 576: case RMMCMD: ! 577: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 578: rmmcmd (vec); ! 579: break; ! 580: ! 581: case SCANCMD: ! 582: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 583: scancmd (vec); ! 584: break; ! 585: ! 586: case SORTCMD: ! 587: if (!vmh || winN (cmdp, DISPLAY, 1) != NOTOK) ! 588: sortcmd (vec); ! 589: break; ! 590: ! 591: default: ! 592: padios (NULLCP, "no dispatch for %s", cmd_name); ! 593: } ! 594: ! 595: if (vmh) { ! 596: if (vmhtty != NOTOK) ! 597: (void) ttyR (cmdp); ! 598: if (vmhpid > OK) ! 599: (void) winR (cmdp); ! 600: } ! 601: else ! 602: fin_io (cmdp, vmh); ! 603: if (cp != NULL) ! 604: free (cp); ! 605: if (i == EXITCMD) { ! 606: quit (); ! 607: return; ! 608: } ! 609: } ! 610: } ! 611: ! 612: /* */ ! 613: ! 614: fsetup (folder) ! 615: char *folder; ! 616: { ! 617: register int msgnum; ! 618: char *maildir; ! 619: struct stat st; ! 620: ! 621: maildir = m_maildir (folder); ! 622: if (chdir (maildir) == NOTOK) ! 623: padios (maildir, "unable to change directory to"); ! 624: if (!(mp = m_gmsg (folder))) ! 625: padios (NULLCP, "unable to read folder %s", folder); ! 626: if (mp -> hghmsg == 0) ! 627: padios (NULLCP, "no messages in %s", folder); ! 628: ! 629: mode = m_gmprot (); ! 630: mtime = stat (mp -> foldpath, &st) != NOTOK ? st.st_mtime : 0; ! 631: ! 632: m_gMsgs (mp -> hghmsg); ! 633: ! 634: for (msgnum = mp -> lowmsg; msgnum <= mp -> hghmsg; msgnum++) { ! 635: Msgs[msgnum].m_bboard_id = 0; ! 636: Msgs[msgnum].m_top = NOTOK; ! 637: Msgs[msgnum].m_start = Msgs[msgnum].m_stop = 0L; ! 638: Msgs[msgnum].m_scanl = NULL; ! 639: } ! 640: ! 641: m_init (); ! 642: ! 643: fmsh = getcpy (folder); ! 644: ! 645: #ifndef BSD42 ! 646: maxfds = _NFILE / 2; ! 647: #else BSD42 ! 648: maxfds = getdtablesize () / 2; ! 649: #endif BSD42 ! 650: if ((maxfds -= 2) < 1) ! 651: maxfds = 1; ! 652: } ! 653: ! 654: /* */ ! 655: ! 656: setup (file) ! 657: char *file; ! 658: { ! 659: int i, ! 660: msgp; ! 661: #ifdef BPOP ! 662: char tmpfil[BUFSIZ]; ! 663: #endif BPOP ! 664: struct stat st; ! 665: ! 666: #ifdef BPOP ! 667: if (pmsh) { ! 668: (void) strcpy (tmpfil, m_tmpfil (invo_name)); ! 669: if ((fp = fopen (tmpfil, "w+")) == NULL) ! 670: padios (tmpfil, "unable to create"); ! 671: (void) unlink (tmpfil); ! 672: } ! 673: else ! 674: #endif BPOP ! 675: if ((fp = fopen (file, "r")) == NULL) ! 676: padios (file, "unable to read"); ! 677: #ifdef FIOCLEX ! 678: (void) ioctl (fileno (fp), FIOCLEX, NULLCP); ! 679: #endif FIOCLEX ! 680: if (fstat (fileno (fp), &st) != NOTOK) { ! 681: mode = (int) (st.st_mode & 0777), mtime = st.st_mtime; ! 682: msgp = read_map (file, (long) st.st_size); ! 683: } ! 684: else { ! 685: mode = m_gmprot (), mtime = 0; ! 686: msgp = 0; ! 687: } ! 688: ! 689: if ((msgp = read_file (msgp ? Msgs[msgp].m_stop : 0L, msgp + 1)) < 1) ! 690: padios (NULLCP, "no messages in %s", myname ? myname : file); ! 691: ! 692: mp = (struct msgs *) calloc ((unsigned) 1, MSIZE (mp, 1, msgp + 1)); ! 693: if (mp == NULL) ! 694: padios (NULLCP, "unable to allocate folder storage"); ! 695: ! 696: mp -> hghmsg = msgp; ! 697: mp -> nummsg = msgp; ! 698: mp -> lowmsg = 1; ! 699: mp -> curmsg = 0; ! 700: ! 701: mp -> foldpath = getcpy (myname ? myname : file); ! 702: mp -> msgflags = NULL; ! 703: #ifdef BPOP ! 704: if (pmsh) ! 705: mp -> msgflags |= READONLY; ! 706: else { ! 707: #endif BPOP ! 708: (void) stat (file, &st); ! 709: if (st.st_uid != getuid () || access (file, 02) == NOTOK) ! 710: mp -> msgflags |= READONLY; ! 711: #ifdef BPOP ! 712: } ! 713: #endif BPOP ! 714: mp -> lowoff = 1; ! 715: mp -> hghoff = mp -> hghmsg + 1; ! 716: ! 717: #ifdef MTR ! 718: mp -> msgstats = (short *) ! 719: calloc ((unsigned) 1, MSIZEX (mp, mp -> lowmsg, mp -> hghmsg)); ! 720: if (mp -> msgstats == NULL) ! 721: padios (NULLCP, "unable to allocate messages storage"); ! 722: mp -> msgstats = (mp -> msgbase = mp -> msgstats) - mp -> lowoff; ! 723: if (mp -> msgstats < 0) ! 724: padios (NULLCP, "setup() botch -- you lose big"); ! 725: #endif MTR ! 726: #ifdef BPOP ! 727: if (pmsh) { ! 728: for (i = mp -> lowmsg; i <= mp -> hghmsg; i++) { ! 729: Msgs[i].m_top = i; ! 730: mp -> msgstats[i] = EXISTS | VIRTUAL; ! 731: } ! 732: } ! 733: else ! 734: #endif BPOP ! 735: for (i = mp -> lowmsg; i <= mp -> hghmsg; i++) ! 736: mp -> msgstats[i] = EXISTS; ! 737: m_init (); ! 738: ! 739: mp -> msgattrs[0] = getcpy ("unseen"); ! 740: mp -> msgattrs[1] = NULL; ! 741: ! 742: m_unknown (fp); /* the MAGIC invocation */ ! 743: if (fmsh) { ! 744: free (fmsh); ! 745: fmsh = NULL; ! 746: } ! 747: } ! 748: ! 749: /* */ ! 750: ! 751: static int read_map (file, size) ! 752: char *file; ! 753: long size; ! 754: { ! 755: register int i, ! 756: msgp; ! 757: register struct drop *dp, ! 758: *mp; ! 759: struct drop *rp; ! 760: ! 761: #ifdef BPOP ! 762: if (pmsh) ! 763: return read_pop (); ! 764: #endif BPOP ! 765: ! 766: if ((i = map_read (file, size, &rp, 1)) == 0) ! 767: return 0; ! 768: ! 769: m_gMsgs (i); ! 770: ! 771: msgp = 1; ! 772: for (dp = rp; i-- > 0; msgp++, dp++) { ! 773: mp = &Msgs[msgp].m_drop; ! 774: mp -> d_id = dp -> d_id; ! 775: mp -> d_size = dp -> d_size; ! 776: mp -> d_start = dp -> d_start; ! 777: mp -> d_stop = dp -> d_stop; ! 778: Msgs[msgp].m_scanl = NULL; ! 779: } ! 780: free ((char *) rp); ! 781: ! 782: return (msgp - 1); ! 783: } ! 784: ! 785: /* */ ! 786: ! 787: static int read_file (pos, msgp) ! 788: register long pos; ! 789: register int msgp; ! 790: { ! 791: register int i; ! 792: register struct drop *dp, ! 793: *mp; ! 794: struct drop *rp; ! 795: ! 796: #ifdef BPOP ! 797: if (pmsh) ! 798: return (msgp - 1); ! 799: #endif BPOP ! 800: ! 801: if ((i = mbx_read (fp, pos, &rp, 1)) <= 0) ! 802: return (msgp - 1); ! 803: ! 804: m_gMsgs ((msgp - 1) + i); ! 805: ! 806: for (dp = rp; i-- > 0; msgp++, dp++) { ! 807: mp = &Msgs[msgp].m_drop; ! 808: mp -> d_id = 0; ! 809: mp -> d_size = dp -> d_size; ! 810: mp -> d_start = dp -> d_start; ! 811: mp -> d_stop = dp -> d_stop; ! 812: Msgs[msgp].m_scanl = NULL; ! 813: } ! 814: free ((char *) rp); ! 815: ! 816: return (msgp - 1); ! 817: } ! 818: ! 819: /* */ ! 820: ! 821: #ifdef BPOP ! 822: static int read_pop () { ! 823: int nmsgs, ! 824: nbytes; ! 825: ! 826: if (pop_stat (&nmsgs, &nbytes) == NOTOK) ! 827: padios (NULLCP, "%s", response); ! 828: ! 829: m_gMsgs (nmsgs); ! 830: ! 831: return nmsgs; ! 832: } ! 833: ! 834: ! 835: static int pop_action (s) ! 836: register char *s; ! 837: { ! 838: fprintf (yp, "%s\n", s); ! 839: } ! 840: #endif BPOP ! 841: ! 842: /* */ ! 843: ! 844: static m_gMsgs (n) ! 845: int n; ! 846: { ! 847: if (Msgs == NULL) { ! 848: nMsgs = n + MAXFOLDER / 2; ! 849: Msgs = (struct Msg *) calloc ((unsigned) (nMsgs + 2), sizeof *Msgs); ! 850: if (Msgs == NULL) ! 851: padios (NULLCP, "unable to allocate Msgs structure"); ! 852: return; ! 853: } ! 854: ! 855: if (nMsgs >= n) ! 856: return; ! 857: ! 858: nMsgs = n + MAXFOLDER / 2; ! 859: Msgs = (struct Msg *) realloc ((char *) Msgs, ! 860: (unsigned) (nMsgs + 2) * sizeof *Msgs); ! 861: if (Msgs == NULL) ! 862: padios (NULLCP, "unable to reallocate Msgs structure"); ! 863: } ! 864: ! 865: /* */ ! 866: ! 867: FILE *msh_ready (msgnum, full) ! 868: register int msgnum; ! 869: int full; ! 870: { ! 871: register int msgp; ! 872: int fd; ! 873: long pos1, ! 874: pos2; ! 875: char *cp, ! 876: tmpfil[BUFSIZ]; ! 877: ! 878: if (yp) { ! 879: (void) fclose (yp); ! 880: yp = NULL; ! 881: } ! 882: ! 883: if (fmsh) { ! 884: if ((fd = Msgs[msgnum].m_top) == NOTOK) { ! 885: if (numfds >= maxfds) ! 886: for (msgp = mp -> lowmsg; msgp <= mp -> hghmsg; msgp++) ! 887: if (Msgs[msgp].m_top != NOTOK) { ! 888: (void) close (Msgs[msgp].m_top); ! 889: Msgs[msgp].m_top = NOTOK; ! 890: numfds--; ! 891: break; ! 892: } ! 893: ! 894: if ((fd = open (cp = m_name (msgnum), 0)) == NOTOK) ! 895: padios (cp, "unable to open message"); ! 896: Msgs[msgnum].m_top = fd; ! 897: numfds++; ! 898: } ! 899: ! 900: if ((fd = dup (fd)) == NOTOK) ! 901: padios ("cached message", "unable to dup"); ! 902: if ((yp = fdopen (fd, "r")) == NULL) ! 903: padios (NULLCP, "unable to fdopen cached message"); ! 904: (void) fseek (yp, 0L, 0); ! 905: return yp; ! 906: } ! 907: ! 908: #ifdef BPOP ! 909: if (pmsh && (mp -> msgstats[msgnum] & VIRTUAL)) { ! 910: if (Msgs[msgnum].m_top == 0) ! 911: padios (NULLCP, "msh_ready (%d, %d) botch", msgnum, full); ! 912: if (!full) { ! 913: (void) strcpy (tmpfil, m_tmpfil (invo_name)); ! 914: if ((yp = fopen (tmpfil, "w+")) == NULL) ! 915: padios (tmpfil, "unable to create"); ! 916: (void) unlink (tmpfil); ! 917: ! 918: if (pop_top (Msgs[msgnum].m_top, 4, pop_action) == NOTOK) ! 919: padios (NULLCP, "%s", response); ! 920: ! 921: m_eomsbr ((int (*)()) 0); /* XXX */ ! 922: msg_style = MS_DEFAULT; /* .. */ ! 923: (void) fseek (yp, 0L, 0); ! 924: return yp; ! 925: } ! 926: ! 927: (void) fseek (fp, 0L, 2); ! 928: (void) fwrite (mmdlm1, 1, strlen (mmdlm1), fp); ! 929: if (fflush (fp)) ! 930: padios ("temporary file", "write error on"); ! 931: (void) fseek (fp, 0L, 2); ! 932: pos1 = ftell (fp); ! 933: ! 934: yp = fp; ! 935: if (pop_retr (Msgs[msgnum].m_top, pop_action) == NOTOK) ! 936: padios (NULLCP, "%s", response); ! 937: yp = NULL; ! 938: ! 939: (void) fseek (fp, 0L, 2); ! 940: pos2 = ftell (fp); ! 941: (void) fwrite (mmdlm2, 1, strlen (mmdlm2), fp); ! 942: if (fflush (fp)) ! 943: padios ("temporary file", "write error on"); ! 944: ! 945: Msgs[msgnum].m_start = pos1; ! 946: Msgs[msgnum].m_stop = pos2; ! 947: ! 948: mp -> msgstats[msgnum] &= ~VIRTUAL; ! 949: } ! 950: #endif BPOP ! 951: ! 952: m_eomsbr ((int (*)()) 0); /* XXX */ ! 953: (void) fseek (fp, Msgs[msgnum].m_start, 0); ! 954: return fp; ! 955: } ! 956: ! 957: /* */ ! 958: ! 959: static int check_folder (scansw) ! 960: int scansw; ! 961: { ! 962: int flags, ! 963: i, ! 964: low, ! 965: hgh, ! 966: msgp; ! 967: struct stat st; ! 968: ! 969: #ifdef BPOP ! 970: if (pmsh) ! 971: return 0; ! 972: #endif BPOP ! 973: ! 974: if (fmsh) { ! 975: if (stat (mp -> foldpath, &st) == NOTOK) ! 976: padios (mp -> foldpath, "unable to stat"); ! 977: if (mtime == st.st_mtime) ! 978: return 0; ! 979: mtime = st.st_mtime; ! 980: ! 981: low = mp -> hghmsg + 1; ! 982: m_fmsg (mp); ! 983: ! 984: if (!(mp = m_gmsg (fmsh))) ! 985: padios (NULLCP, "unable to re-read folder %s", fmsh); ! 986: ! 987: hgh = mp -> hghmsg; ! 988: ! 989: for (msgp = mp -> lowmsg; msgp <= mp -> hghmsg; msgp++) { ! 990: if (Msgs[msgp].m_top != NOTOK) { ! 991: (void) close (Msgs[msgp].m_top); ! 992: Msgs[msgp].m_top = NOTOK; ! 993: numfds--; ! 994: } ! 995: if (Msgs[msgp].m_scanl) { ! 996: free (Msgs[msgp].m_scanl); ! 997: Msgs[msgp].m_scanl = NULL; ! 998: } ! 999: } ! 1000: ! 1001: m_init (); ! 1002: ! 1003: if (modified || low > hgh) ! 1004: return 1; ! 1005: goto check_vmh; ! 1006: } ! 1007: if (fstat (fileno (fp), &st) == NOTOK) ! 1008: padios (mp -> foldpath, "unable to fstat"); ! 1009: if (mtime == st.st_mtime) ! 1010: return 0; ! 1011: mode = (int) (st.st_mode & 0777); ! 1012: mtime = st.st_mtime; ! 1013: ! 1014: if ((msgp = read_file (Msgs[mp -> hghmsg].m_stop, mp -> hghmsg + 1)) < 1) ! 1015: padios (NULLCP, "no messages in %s", mp -> foldpath); /* XXX */ ! 1016: if (msgp >= MAXFOLDER) ! 1017: padios (NULLCP, "more than %d messages in %s", MAXFOLDER, ! 1018: mp -> foldpath); ! 1019: if (msgp <= mp -> hghmsg) ! 1020: return 0; /* XXX */ ! 1021: ! 1022: if ((mp = m_remsg (mp, 0, msgp)) == NULL) ! 1023: padios (NULLCP, "unable to allocate folder storage"); ! 1024: ! 1025: low = mp -> hghmsg + 1, hgh = msgp; ! 1026: flags = scansw ? m_seqflag (mp, "unseen") : 0; ! 1027: for (i = mp -> hghmsg + 1; i <= msgp; i++) { ! 1028: mp -> msgstats[i] = EXISTS | flags; ! 1029: mp -> nummsg++; ! 1030: } ! 1031: mp -> hghmsg = msgp; ! 1032: m_init (); ! 1033: ! 1034: check_vmh: ; ! 1035: if (vmh) ! 1036: return 1; ! 1037: ! 1038: advise (NULLCP, "new messages have arrived!\007"); ! 1039: if (scansw) ! 1040: scanrange (low, hgh); ! 1041: ! 1042: return 1; ! 1043: } ! 1044: ! 1045: /* */ ! 1046: ! 1047: static scanrange (low, hgh) ! 1048: int low, ! 1049: hgh; ! 1050: { ! 1051: char buffer[BUFSIZ]; ! 1052: ! 1053: (void) sprintf (buffer, "%d-%d", low, hgh); ! 1054: scanstring (buffer); ! 1055: } ! 1056: ! 1057: ! 1058: static scanstring (arg) ! 1059: char *arg; ! 1060: { ! 1061: char *cp, ! 1062: **ap, ! 1063: *vec[MAXARGS]; ! 1064: ! 1065: if ((cp = m_find (cmd_name = "scan")) != NULL) { ! 1066: ap = brkstring (cp = getcpy (cp), " ", "\n"); ! 1067: ap = copyip (ap, vec); ! 1068: } ! 1069: else ! 1070: ap = vec; ! 1071: *ap++ = arg; ! 1072: *ap = NULL; ! 1073: m_init (); ! 1074: scancmd (vec); ! 1075: if (cp != NULL) ! 1076: free (cp); ! 1077: } ! 1078: ! 1079: /* */ ! 1080: ! 1081: readids (id) ! 1082: int id; ! 1083: { ! 1084: register int cur, ! 1085: flags, ! 1086: i, ! 1087: msgnum; ! 1088: ! 1089: if (mp -> curmsg == 0) ! 1090: m_setcur (mp, mp -> lowmsg); ! 1091: if (id <= 0 || (flags = m_seqflag (mp, "unseen")) == 0) ! 1092: return; ! 1093: ! 1094: for (msgnum = mp -> hghmsg; msgnum >= mp -> lowmsg; msgnum--) ! 1095: mp -> msgstats[msgnum] |= flags; ! 1096: ! 1097: if (id != 1) { ! 1098: cur = mp -> curmsg; ! 1099: ! 1100: for (msgnum = mp -> hghmsg; msgnum >= mp -> lowmsg; msgnum--) ! 1101: if ((i = readid (msgnum)) > 0 && i < id) { ! 1102: cur = msgnum + 1; ! 1103: mp -> msgstats[msgnum] &= ~flags; ! 1104: break; ! 1105: } ! 1106: for (i = mp -> lowmsg; i < msgnum; i++) ! 1107: mp -> msgstats[i] &= ~flags; ! 1108: ! 1109: if (cur > mp -> hghmsg) ! 1110: cur = mp -> hghmsg; ! 1111: ! 1112: m_setcur (mp, cur); ! 1113: } ! 1114: ! 1115: if ((gap = 1 < id && id < (i = readid (mp -> lowmsg)) ? id : 0) && !vmh) ! 1116: advise (NULLCP, "gap in ID:s, last seen %d, lowest present %d\n", ! 1117: id - 1, i); ! 1118: } ! 1119: ! 1120: /* */ ! 1121: ! 1122: int readid (msgnum) ! 1123: int msgnum; ! 1124: { ! 1125: int i, ! 1126: state; ! 1127: #ifdef BPOP ! 1128: int arg1, ! 1129: arg2, ! 1130: arg3; ! 1131: #endif BPOP ! 1132: char *bp, ! 1133: buf[BUFSIZ], ! 1134: name[NAMESZ]; ! 1135: register FILE *zp; ! 1136: ! 1137: if (Msgs[msgnum].m_bboard_id) ! 1138: return Msgs[msgnum].m_bboard_id; ! 1139: #ifdef BPOP ! 1140: if (pmsh) { ! 1141: if (Msgs[msgnum].m_top == 0) ! 1142: padios (NULLCP, "readid (%d) botch", msgnum); ! 1143: if (pop_list (Msgs[msgnum].m_top, (int *) 0, &arg1, &arg2, &arg3) == OK ! 1144: && arg3 > 0) ! 1145: return (Msgs[msgnum].m_bboard_id = arg3); ! 1146: } ! 1147: #endif BPOP ! 1148: ! 1149: zp = msh_ready (msgnum, 0); ! 1150: for (state = FLD;;) ! 1151: switch (state = m_getfld (state, name, buf, sizeof buf, zp)) { ! 1152: case FLD: ! 1153: case FLDEOF: ! 1154: case FLDPLUS: ! 1155: if (uleq (name, BBoard_ID)) { ! 1156: bp = getcpy (buf); ! 1157: while (state == FLDPLUS) { ! 1158: state = m_getfld (state, name, buf, sizeof buf, zp); ! 1159: bp = add (buf, bp); ! 1160: } ! 1161: i = atoi (bp); ! 1162: free (bp); ! 1163: if (i > 0) ! 1164: return (Msgs[msgnum].m_bboard_id = i); ! 1165: else ! 1166: continue; ! 1167: } ! 1168: while (state == FLDPLUS) ! 1169: state = m_getfld (state, name, buf, sizeof buf, zp); ! 1170: if (state != FLDEOF) ! 1171: continue; ! 1172: ! 1173: default: ! 1174: return 0; ! 1175: } ! 1176: } ! 1177: ! 1178: /* */ ! 1179: ! 1180: display_info (scansw) ! 1181: int scansw; ! 1182: { ! 1183: int flags, ! 1184: sd; ! 1185: ! 1186: interactive = isatty (fileno (stdout)); ! 1187: if (sp == NULL) { ! 1188: if ((sd = dup (fileno (stdout))) == NOTOK) ! 1189: padios ("standard output", "unable to dup"); ! 1190: #ifndef BSD42 /* XXX */ ! 1191: #ifdef FIOCLEX ! 1192: (void) ioctl (sd, FIOCLEX, NULL); ! 1193: #endif FIOCLEX ! 1194: #endif not BSD42 ! 1195: if ((sp = fdopen (sd, "w")) == NULL) ! 1196: padios ("standard output", "unable to fdopen"); ! 1197: } ! 1198: ! 1199: (void) putenv ("mhfolder", mp -> foldpath); ! 1200: if (vmh) ! 1201: return; ! 1202: ! 1203: if (myname) { ! 1204: printf ("Reading "); ! 1205: if (SOprintf ("%s", myname)) ! 1206: printf ("%s", myname); ! 1207: printf (", currently at message %d of %d\n", ! 1208: mp -> curmsg, mp -> hghmsg); ! 1209: } ! 1210: else { ! 1211: printf ("Reading "); ! 1212: if (fmsh) ! 1213: printf ("+%s", fmsh); ! 1214: else ! 1215: printf ("%s", mp -> foldpath); ! 1216: printf (", currently at message %d of %d\n", ! 1217: mp -> curmsg, mp -> hghmsg); ! 1218: } ! 1219: ! 1220: if ((flags = m_seqflag (mp, "unseen")) ! 1221: && scansw ! 1222: && (mp -> msgstats[mp -> hghmsg] & flags)) ! 1223: scanstring ("unseen"); ! 1224: } ! 1225: ! 1226: /* */ ! 1227: ! 1228: static write_ids () { ! 1229: int i = 0, ! 1230: flags, ! 1231: msgnum; ! 1232: char buffer[80]; ! 1233: ! 1234: if (pfd <= 1) ! 1235: return; ! 1236: ! 1237: if (flags = m_seqflag (mp, "unseen")) ! 1238: for (msgnum = mp -> hghmsg; msgnum >= mp -> lowmsg; msgnum--) ! 1239: if (!(mp -> msgstats[msgnum] & flags)) { ! 1240: if (Msgs[msgnum].m_bboard_id == 0) ! 1241: (void) readid (msgnum); ! 1242: if ((i = Msgs[msgnum].m_bboard_id) > 0) ! 1243: break; ! 1244: } ! 1245: ! 1246: (void) sprintf (buffer, "%d %d\n", i, Msgs[mp -> hghmsg].m_bboard_id); ! 1247: (void) write (pfd, buffer, sizeof buffer); ! 1248: (void) close (pfd); ! 1249: pfd = NOTOK; ! 1250: } ! 1251: ! 1252: /* */ ! 1253: ! 1254: static quit () { ! 1255: int i, ! 1256: md, ! 1257: msgnum; ! 1258: char *cp, ! 1259: tmpfil[BUFSIZ], ! 1260: map1[BUFSIZ], ! 1261: map2[BUFSIZ]; ! 1262: struct stat st; ! 1263: FILE *dp; ! 1264: ! 1265: if (!(mp -> msgflags & MODIFIED) || mp -> msgflags & READONLY || fmsh) { ! 1266: if (vmh) ! 1267: (void) rc2peer (RC_FIN, 0, NULLCP); ! 1268: return; ! 1269: } ! 1270: ! 1271: if (vmh) ! 1272: (void) ttyNaux (NULLCMD, "FAST"); ! 1273: cp = NULL; ! 1274: if ((dp = lkfopen (mp -> foldpath, "r")) == NULL) { ! 1275: advise (mp -> foldpath, "unable to lock"); ! 1276: if (vmh) { ! 1277: (void) ttyR (NULLCMD); ! 1278: (void) pFIN (); ! 1279: } ! 1280: return; ! 1281: } ! 1282: if (fstat (fileno (dp), &st) == NOTOK) { ! 1283: advise (mp -> foldpath, "unable to stat"); ! 1284: goto release; ! 1285: } ! 1286: if (mtime != st.st_mtime) { ! 1287: advise (NULLCP, "new messages have arrived, no update"); ! 1288: goto release; ! 1289: } ! 1290: mode = (int) (st.st_mode & 0777); ! 1291: ! 1292: if (mp -> nummsg == 0) { ! 1293: cp = concat ("Zero file \"", mp -> foldpath, "\"? ", NULLCP); ! 1294: if (getanswer (cp)) { ! 1295: if ((i = creat (mp -> foldpath, mode)) != NOTOK) ! 1296: (void) close (i); ! 1297: else ! 1298: advise (mp -> foldpath, "error zero'ing"); ! 1299: (void) unlink (map_name (mp -> foldpath));/* XXX */ ! 1300: } ! 1301: goto release; ! 1302: } ! 1303: ! 1304: cp = concat ("Update file \"", mp -> foldpath, "\"? ", NULLCP); ! 1305: if (!getanswer (cp)) ! 1306: goto release; ! 1307: (void) strcpy (tmpfil, m_backup (mp -> foldpath)); ! 1308: if ((md = mbx_open (tmpfil, st.st_uid, st.st_gid, mode)) == NOTOK) { ! 1309: advise (tmpfil, "unable to open"); ! 1310: goto release; ! 1311: } ! 1312: ! 1313: for (msgnum = mp -> lowmsg; msgnum <= mp -> hghmsg; msgnum++) ! 1314: if (mp -> msgstats[msgnum] & EXISTS ! 1315: && pack (tmpfil, md, msgnum) == NOTOK) { ! 1316: (void) mbx_close (tmpfil, md); ! 1317: (void) unlink (tmpfil); ! 1318: (void) unlink (map_name (tmpfil)); ! 1319: goto release; ! 1320: } ! 1321: (void) mbx_close (tmpfil, md); ! 1322: ! 1323: if (rename (tmpfil, mp -> foldpath) == NOTOK) ! 1324: admonish (mp -> foldpath, "unable to rename %s to", tmpfil); ! 1325: else { ! 1326: (void) strcpy (map1, map_name (tmpfil)); ! 1327: (void) strcpy (map2, map_name (mp -> foldpath)); ! 1328: ! 1329: if (rename (map1, map2) == NOTOK) { ! 1330: admonish (map2, "unable to rename %s to", map1); ! 1331: (void) unlink (map1); ! 1332: (void) unlink (map2); ! 1333: } ! 1334: } ! 1335: ! 1336: release: ; ! 1337: if (cp) ! 1338: free (cp); ! 1339: (void) lkfclose (dp, mp -> foldpath); ! 1340: if (vmh) { ! 1341: (void) ttyR (NULLCMD); ! 1342: (void) pFIN (); ! 1343: } ! 1344: } ! 1345: ! 1346: /* */ ! 1347: ! 1348: static int getargs (prompt, sw, cmdp) ! 1349: char *prompt; ! 1350: struct swit *sw; ! 1351: struct Cmd *cmdp; ! 1352: { ! 1353: int i; ! 1354: char *cp; ! 1355: static char buffer[BUFSIZ]; ! 1356: ! 1357: told_to_quit = 0; ! 1358: for (;;) { ! 1359: interrupted = 0; ! 1360: #ifdef BSD42 ! 1361: switch (setjmp (sigenv)) { ! 1362: case OK: ! 1363: should_intr = 1; ! 1364: break; ! 1365: ! 1366: default: ! 1367: should_intr = 0; ! 1368: if (interrupted && !told_to_quit) { ! 1369: (void) putchar ('\n'); ! 1370: continue; ! 1371: } ! 1372: if (ppid > 0) ! 1373: (void) kill (ppid, SIGEMT); ! 1374: return EOF; ! 1375: } ! 1376: #endif BSD42 ! 1377: if (interactive) { ! 1378: printf ("%s", prompt); ! 1379: (void) fflush (stdout); ! 1380: } ! 1381: for (cp = buffer; (i = getchar ()) != '\n';) { ! 1382: #ifndef BSD42 ! 1383: if (interrupted && !told_to_quit) { ! 1384: buffer[0] = NULL; ! 1385: (void) putchar ('\n'); ! 1386: break; ! 1387: } ! 1388: if (told_to_quit || i == EOF) { ! 1389: if (ppid > 0) ! 1390: (void) kill (ppid, SIGEMT); ! 1391: return EOF; ! 1392: } ! 1393: #else BSD42 ! 1394: if (i == EOF) ! 1395: longjmp (sigenv, DONE); ! 1396: #endif BSD42 ! 1397: if (cp < &buffer[sizeof buffer - 2]) ! 1398: *cp++ = i; ! 1399: } ! 1400: *cp = NULL; ! 1401: ! 1402: if (buffer[0] == NULL) ! 1403: continue; ! 1404: if (buffer[0] == '?') { ! 1405: printf ("commands:\n"); ! 1406: printsw (ALL, sw, ""); ! 1407: printf ("type CTRL-D or use ``quit'' to leave %s\n", ! 1408: invo_name); ! 1409: continue; ! 1410: } ! 1411: ! 1412: if (parse (buffer, cmdp) == NOTOK) ! 1413: continue; ! 1414: ! 1415: switch (i = smatch (cmdp -> args[0], sw)) { ! 1416: case AMBIGSW: ! 1417: ambigsw (cmdp -> args[0], sw); ! 1418: continue; ! 1419: case UNKWNSW: ! 1420: printf ("say what: ``%s'' -- type ? (or help) for help\n", ! 1421: cmdp -> args[0]); ! 1422: continue; ! 1423: default: ! 1424: #ifdef BSD42 ! 1425: should_intr = 0; ! 1426: #endif BSD42 ! 1427: return i; ! 1428: } ! 1429: } ! 1430: } ! 1431: ! 1432: /* */ ! 1433: ! 1434: static int getcmds (sw, cmdp, scansw) ! 1435: struct swit *sw; ! 1436: struct Cmd *cmdp; ! 1437: int scansw; ! 1438: { ! 1439: int i; ! 1440: struct record rcs, ! 1441: *rc = &rcs; ! 1442: ! 1443: initrc (rc); ! 1444: ! 1445: for (;;) ! 1446: switch (peer2rc (rc)) { ! 1447: case RC_QRY: ! 1448: (void) pQRY (rc -> rc_data, scansw); ! 1449: break; ! 1450: ! 1451: case RC_CMD: ! 1452: if ((i = pCMD (rc -> rc_data, sw, cmdp)) != NOTOK) ! 1453: return i; ! 1454: break; ! 1455: ! 1456: case RC_FIN: ! 1457: if (ppid > 0) ! 1458: (void) kill (ppid, SIGEMT); ! 1459: return EOF; ! 1460: ! 1461: case RC_XXX: ! 1462: padios (NULLCP, "%s", rc -> rc_data); ! 1463: ! 1464: default: ! 1465: (void) fmt2peer (RC_ERR, "pLOOP protocol screw-up"); ! 1466: done (1); ! 1467: } ! 1468: } ! 1469: ! 1470: /* */ ! 1471: ! 1472: static int parse (buffer, cmdp) ! 1473: char *buffer; ! 1474: struct Cmd *cmdp; ! 1475: { ! 1476: int argp = 0; ! 1477: char c, ! 1478: *cp, ! 1479: *pp; ! 1480: ! 1481: cmdp -> line[0] = NULL; ! 1482: pp = cmdp -> args[argp++] = cmdp -> line; ! 1483: cmdp -> redirect = NULL; ! 1484: cmdp -> direction = STDIO; ! 1485: cmdp -> stream = NULL; ! 1486: ! 1487: for (cp = buffer; c = *cp; cp++) ! 1488: if (!isspace (c)) ! 1489: break; ! 1490: if (c == NULL) { ! 1491: if (vmh) ! 1492: (void) fmt2peer (RC_EOF, "null command"); ! 1493: return NOTOK; ! 1494: } ! 1495: ! 1496: while (c = *cp++) { ! 1497: if (isspace (c)) { ! 1498: while (isspace (c)) ! 1499: c = *cp++; ! 1500: if (c == NULL) ! 1501: break; ! 1502: *pp++ = NULL; ! 1503: cmdp -> args[argp++] = pp; ! 1504: *pp = NULL; ! 1505: } ! 1506: ! 1507: switch (c) { ! 1508: case '"': ! 1509: for (;;) { ! 1510: switch (c = *cp++) { ! 1511: case NULL: ! 1512: padvise (NULLCP, "unmatched \""); ! 1513: return NOTOK; ! 1514: case '"': ! 1515: break; ! 1516: case QUOTE: ! 1517: if ((c = *cp++) == NULL) ! 1518: goto no_quoting; ! 1519: default: ! 1520: *pp++ = c; ! 1521: continue; ! 1522: } ! 1523: break; ! 1524: } ! 1525: continue; ! 1526: ! 1527: case QUOTE: ! 1528: if ((c = *cp++) == NULL) { ! 1529: no_quoting: ; ! 1530: padvise (NULLCP, "the newline character can not be quoted"); ! 1531: return NOTOK; ! 1532: } ! 1533: ! 1534: default: ; ! 1535: *pp++ = c; ! 1536: continue; ! 1537: ! 1538: case '>': ! 1539: case '|': ! 1540: if (pp == cmdp -> line) { ! 1541: padvise (NULLCP, "invalid null command"); ! 1542: return NOTOK; ! 1543: } ! 1544: if (*cmdp -> args[argp - 1] == NULL) ! 1545: argp--; ! 1546: cmdp -> direction = c == '>' ? CRTIO : PIPIO; ! 1547: if (cmdp -> direction == CRTIO && (c = *cp) == '>') { ! 1548: cmdp -> direction = APPIO; ! 1549: cp++; ! 1550: } ! 1551: cmdp -> redirect = pp + 1;/* sigh */ ! 1552: for (; c = *cp; cp++) ! 1553: if (!isspace (c)) ! 1554: break; ! 1555: if (c == NULL) { ! 1556: padvise (NULLCP, cmdp -> direction != PIPIO ! 1557: ? "missing name for redirect" ! 1558: : "invalid null command"); ! 1559: return NOTOK; ! 1560: } ! 1561: (void) strcpy (cmdp -> redirect, cp); ! 1562: if (cmdp -> direction != PIPIO) { ! 1563: for (; *cp; cp++) ! 1564: if (isspace (*cp)) { ! 1565: padvise (NULLCP, "bad name for redirect"); ! 1566: return NOTOK; ! 1567: } ! 1568: if (expand (cmdp -> redirect) == NOTOK) ! 1569: return NOTOK; ! 1570: } ! 1571: break; ! 1572: } ! 1573: break; ! 1574: } ! 1575: ! 1576: *pp++ = NULL; ! 1577: cmdp -> args[argp] = NULL; ! 1578: ! 1579: return OK; ! 1580: } ! 1581: ! 1582: /* */ ! 1583: ! 1584: int expand (redirect) ! 1585: char *redirect; ! 1586: { ! 1587: char *cp, ! 1588: *pp; ! 1589: char path[BUFSIZ]; ! 1590: struct passwd *pw; ! 1591: ! 1592: if (*redirect != '~') ! 1593: return OK; ! 1594: ! 1595: if (cp = index (pp = redirect + 1, '/')) ! 1596: *cp++ = NULL; ! 1597: if (*pp == NULL) ! 1598: pp = mypath; ! 1599: else ! 1600: if (pw = getpwnam (pp)) ! 1601: pp = pw -> pw_dir; ! 1602: else { ! 1603: padvise (NULLCP, "unknown user: %s", pp); ! 1604: return NOTOK; ! 1605: } ! 1606: ! 1607: (void) sprintf (path, "%s/%s", pp, cp ? cp : ""); ! 1608: (void) strcpy (redirect, path); ! 1609: return OK; ! 1610: } ! 1611: ! 1612: /* */ ! 1613: ! 1614: static int init_io (cmdp, vio) ! 1615: register struct Cmd *cmdp; ! 1616: int vio; ! 1617: { ! 1618: int io, ! 1619: result; ! 1620: ! 1621: io = vmh; ! 1622: ! 1623: vmh = vio; ! 1624: result = initaux_io (cmdp); ! 1625: vmh = io; ! 1626: ! 1627: return result; ! 1628: } ! 1629: ! 1630: ! 1631: static int initaux_io (cmdp) ! 1632: register struct Cmd *cmdp; ! 1633: { ! 1634: char *mode; ! 1635: ! 1636: switch (cmdp -> direction) { ! 1637: case STDIO: ! 1638: return OK; ! 1639: ! 1640: case CRTIO: ! 1641: case APPIO: ! 1642: mode = cmdp -> direction == CRTIO ? "write" : "append"; ! 1643: if ((cmdp -> stream = fopen (cmdp -> redirect, mode)) == NULL) { ! 1644: padvise (cmdp -> redirect, "unable to %s ", mode); ! 1645: cmdp -> direction = STDIO; ! 1646: return NOTOK; ! 1647: } ! 1648: break; ! 1649: ! 1650: case PIPIO: ! 1651: if ((cmdp -> stream = popen (cmdp -> redirect, "w")) == NULL) { ! 1652: padvise (cmdp -> redirect, "unable to pipe"); ! 1653: cmdp -> direction = STDIO; ! 1654: return NOTOK; ! 1655: } ! 1656: (void) signal (SIGPIPE, pipeser); ! 1657: broken_pipe = 0; ! 1658: break; ! 1659: ! 1660: default: ! 1661: padios (NULLCP, "unknown redirection for command"); ! 1662: } ! 1663: ! 1664: (void) fflush (stdout); ! 1665: if (dup2 (fileno (cmdp -> stream), fileno (stdout)) == NOTOK) ! 1666: padios ("standard output", "unable to dup2"); ! 1667: clearerr (stdout); ! 1668: ! 1669: return OK; ! 1670: } ! 1671: ! 1672: /* */ ! 1673: ! 1674: static fin_io (cmdp, vio) ! 1675: register struct Cmd *cmdp; ! 1676: int vio; ! 1677: { ! 1678: int io; ! 1679: ! 1680: io = vmh; ! 1681: ! 1682: vmh = vio; ! 1683: finaux_io (cmdp); ! 1684: vmh = io; ! 1685: } ! 1686: ! 1687: ! 1688: static int finaux_io (cmdp) ! 1689: register struct Cmd *cmdp; ! 1690: { ! 1691: switch (cmdp -> direction) { ! 1692: case STDIO: ! 1693: return; ! 1694: ! 1695: case CRTIO: ! 1696: case APPIO: ! 1697: (void) fflush (stdout); ! 1698: (void) close (fileno (stdout)); ! 1699: if (ferror (stdout)) ! 1700: padvise (NULLCP, "problems writing %s", cmdp -> redirect); ! 1701: (void) fclose (cmdp -> stream); ! 1702: break; ! 1703: ! 1704: case PIPIO: ! 1705: (void) fflush (stdout); ! 1706: (void) close (fileno (stdout)); ! 1707: (void) pclose (cmdp -> stream); ! 1708: (void) signal (SIGPIPE, SIG_DFL); ! 1709: break; ! 1710: ! 1711: default: ! 1712: padios (NULLCP, "unknown redirection for command"); ! 1713: } ! 1714: ! 1715: if (dup2 (fileno (sp), fileno (stdout)) == NOTOK) ! 1716: padios ("standard output", "unable to dup2"); ! 1717: clearerr (stdout); ! 1718: ! 1719: cmdp -> direction = STDIO; ! 1720: } ! 1721: ! 1722: /* */ ! 1723: ! 1724: static m_init () { ! 1725: int msgnum; ! 1726: ! 1727: for (msgnum = mp -> lowmsg; msgnum <= mp -> hghmsg; msgnum++) ! 1728: mp -> msgstats[msgnum] &= ~SELECTED; ! 1729: mp -> lowsel = mp -> hghsel = mp -> numsel = 0; ! 1730: } ! 1731: ! 1732: ! 1733: m_reset () { ! 1734: write_ids (); ! 1735: m_fmsg (mp); ! 1736: myname = NULL; ! 1737: #ifdef BPOP ! 1738: if (pmsh) { ! 1739: (void) pop_done (); ! 1740: pmsh = 0; ! 1741: } ! 1742: #endif BPOP ! 1743: } ! 1744: ! 1745: /* */ ! 1746: ! 1747: void m_setcur (mp, msgnum) ! 1748: register struct msgs *mp; ! 1749: register int msgnum; ! 1750: { ! 1751: if (mp -> curmsg == msgnum) ! 1752: return; ! 1753: ! 1754: if (mp -> curmsg && Msgs[mp -> curmsg].m_scanl) { ! 1755: free (Msgs[mp -> curmsg].m_scanl); ! 1756: Msgs[mp -> curmsg].m_scanl = NULL; ! 1757: } ! 1758: if (Msgs[msgnum].m_scanl) { ! 1759: free (Msgs[msgnum].m_scanl); ! 1760: Msgs[msgnum].m_scanl = NULL; ! 1761: } ! 1762: ! 1763: mp -> curmsg = msgnum; ! 1764: } ! 1765: ! 1766: /* */ ! 1767: ! 1768: /* ARGSUSED */ ! 1769: ! 1770: static int intrser (i) ! 1771: int i; ! 1772: { ! 1773: #ifndef BSD42 ! 1774: (void) signal (SIGINT, intrser); ! 1775: #endif not BSD42 ! 1776: ! 1777: discard (stdout); ! 1778: ! 1779: interrupted++; ! 1780: #ifdef BSD42 ! 1781: if (should_intr) ! 1782: longjmp (sigenv, NOTOK); ! 1783: #endif BSD42 ! 1784: } ! 1785: ! 1786: ! 1787: /* ARGSUSED */ ! 1788: ! 1789: static int pipeser (i) ! 1790: int i; ! 1791: { ! 1792: #ifndef BSD42 ! 1793: (void) signal (SIGPIPE, pipeser); ! 1794: #endif not BSD42 ! 1795: ! 1796: if (broken_pipe++ == 0) ! 1797: fprintf (stderr, "broken pipe\n"); ! 1798: told_to_quit++; ! 1799: interrupted++; ! 1800: #ifdef BSD42 ! 1801: if (should_intr) ! 1802: longjmp (sigenv, NOTOK); ! 1803: #endif BSD42 ! 1804: } ! 1805: ! 1806: ! 1807: /* ARGSUSED */ ! 1808: ! 1809: static int quitser (i) ! 1810: int i; ! 1811: { ! 1812: #ifndef BSD42 ! 1813: (void) signal (SIGQUIT, quitser); ! 1814: #endif BSD42 ! 1815: ! 1816: told_to_quit++; ! 1817: interrupted++; ! 1818: #ifdef BSD42 ! 1819: if (should_intr) ! 1820: longjmp (sigenv, NOTOK); ! 1821: #endif BSD42 ! 1822: } ! 1823: ! 1824: /* */ ! 1825: ! 1826: static int pINI () { ! 1827: int i, ! 1828: vrsn; ! 1829: char *bp; ! 1830: struct record rcs, ! 1831: *rc = &rcs; ! 1832: ! 1833: initrc (rc); ! 1834: ! 1835: switch (peer2rc (rc)) { ! 1836: case RC_INI: ! 1837: bp = rc -> rc_data; ! 1838: while (isspace (*bp)) ! 1839: bp++; ! 1840: if (sscanf (bp, "%d", &vrsn) != 1) { ! 1841: bad_init: ; ! 1842: (void) fmt2peer (RC_ERR, "bad init \"%s\"", rc -> rc_data); ! 1843: done (1); ! 1844: } ! 1845: if (vrsn != RC_VRSN) { ! 1846: (void) fmt2peer (RC_ERR, "version %d unsupported", vrsn); ! 1847: done (1); ! 1848: } ! 1849: ! 1850: while (*bp && !isspace (*bp)) ! 1851: bp++; ! 1852: while (isspace (*bp)) ! 1853: bp++; ! 1854: if (sscanf (bp, "%d", &numwins) != 1 || numwins <= 0) ! 1855: goto bad_init; ! 1856: if (numwins > NWIN) ! 1857: numwins = NWIN; ! 1858: ! 1859: for (i = 1; i <= numwins; i++) { ! 1860: while (*bp && !isspace (*bp)) ! 1861: bp++; ! 1862: while (isspace (*bp)) ! 1863: bp++; ! 1864: if (sscanf (bp, "%d", &windows[i]) != 1 || windows[i] <= 0) ! 1865: goto bad_init; ! 1866: } ! 1867: (void) rc2peer (RC_ACK, 0, NULLCP); ! 1868: return OK; ! 1869: ! 1870: case RC_XXX: ! 1871: padios (NULLCP, "%s", rc -> rc_data); ! 1872: ! 1873: default: ! 1874: (void) fmt2peer (RC_ERR, "pINI protocol screw-up"); ! 1875: done (1); /* NOTREACHED */ ! 1876: } ! 1877: } ! 1878: ! 1879: /* */ ! 1880: ! 1881: /* ARGSUSED */ ! 1882: ! 1883: static int pQRY (str, scansw) ! 1884: char *str; ! 1885: int scansw; ! 1886: { ! 1887: if (pQRY1 (scansw) == NOTOK || pQRY2 () == NOTOK) ! 1888: return NOTOK; ! 1889: ! 1890: (void) rc2peer (RC_EOF, 0, NULLCP); ! 1891: return OK; ! 1892: } ! 1893: ! 1894: /* */ ! 1895: ! 1896: static int pQRY1 (scansw) ! 1897: int scansw; ! 1898: { ! 1899: int oldhgh; ! 1900: static int lastlow = 0, ! 1901: lastcur = 0, ! 1902: lasthgh = 0, ! 1903: lastnum = 0; ! 1904: ! 1905: oldhgh = mp -> hghmsg; ! 1906: if (check_folder (scansw) && oldhgh < mp -> hghmsg) { ! 1907: switch (winX (STATUS)) { ! 1908: case NOTOK: ! 1909: return NOTOK; ! 1910: ! 1911: case OK: ! 1912: printf ("new messages have arrived!"); ! 1913: (void) fflush (stdout); ! 1914: (void) fflush (stderr); ! 1915: _exit (0); /* NOTREACHED */ ! 1916: ! 1917: default: ! 1918: lastlow = lastcur = lasthgh = lastnum = 0; ! 1919: break; ! 1920: } ! 1921: ! 1922: switch (winX (DISPLAY)) { ! 1923: case NOTOK: ! 1924: return NOTOK; ! 1925: ! 1926: case OK: ! 1927: scanrange (oldhgh + 1, mp -> hghmsg); ! 1928: (void) fflush (stdout); ! 1929: (void) fflush (stderr); ! 1930: _exit (0); /* NOTREACHED */ ! 1931: ! 1932: default: ! 1933: break; ! 1934: } ! 1935: return OK; ! 1936: } ! 1937: ! 1938: if (gap) ! 1939: switch (winX (STATUS)) { ! 1940: case NOTOK: ! 1941: return NOTOK; ! 1942: ! 1943: case OK: ! 1944: printf ("%s: gap in ID:s, last seen %d, lowest present %d\n", ! 1945: myname ? myname : fmsh ? fmsh : mp -> foldpath, gap - 1, ! 1946: readid (mp -> lowmsg)); ! 1947: (void) fflush (stdout); ! 1948: (void) fflush (stderr); ! 1949: _exit (0); /* NOTREACHED */ ! 1950: ! 1951: default: ! 1952: gap = 0; ! 1953: return OK; ! 1954: } ! 1955: ! 1956: if (mp -> lowmsg != lastlow ! 1957: || mp -> curmsg != lastcur ! 1958: || mp -> hghmsg != lasthgh ! 1959: || mp -> nummsg != lastnum) ! 1960: switch (winX (STATUS)) { ! 1961: case NOTOK: ! 1962: return NOTOK; ! 1963: ! 1964: case OK: ! 1965: foldcmd (NULLVP); ! 1966: (void) fflush (stdout); ! 1967: (void) fflush (stderr); ! 1968: _exit (0); /* NOTREACHED */ ! 1969: ! 1970: default: ! 1971: lastlow = mp -> lowmsg; ! 1972: lastcur = mp -> curmsg; ! 1973: lasthgh = mp -> hghmsg; ! 1974: lastnum = mp -> nummsg; ! 1975: return OK; ! 1976: } ! 1977: ! 1978: return OK; ! 1979: } ! 1980: ! 1981: /* */ ! 1982: ! 1983: static int pQRY2 () { ! 1984: int i, ! 1985: j, ! 1986: k, ! 1987: msgnum, ! 1988: n; ! 1989: static int cur = 0, ! 1990: num = 0, ! 1991: lo = 0, ! 1992: hi = 0; ! 1993: ! 1994: if (mp -> nummsg == 0 && mp -> nummsg != num) ! 1995: switch (winX (SCAN)) { ! 1996: case NOTOK: ! 1997: return NOTOK; ! 1998: ! 1999: case OK: ! 2000: printf ("empty!"); ! 2001: (void) fflush (stdout); ! 2002: (void) fflush (stderr); ! 2003: _exit (0); /* NOTREACHED */ ! 2004: ! 2005: default: ! 2006: num = mp -> nummsg; ! 2007: return OK; ! 2008: } ! 2009: num = mp -> nummsg; ! 2010: ! 2011: i = 0; ! 2012: j = (k = windows[SCAN]) / 2; ! 2013: for (msgnum = mp -> curmsg; msgnum <= mp -> hghmsg; msgnum++) ! 2014: if (mp -> msgstats[msgnum] & EXISTS) ! 2015: i++; ! 2016: if (i-- > 0) ! 2017: if (topcur) ! 2018: k = i >= k ? 1 : k - i; ! 2019: else ! 2020: k -= i > j ? j : i; ! 2021: ! 2022: i = j = 0; ! 2023: n = 1; ! 2024: for (msgnum = mp -> curmsg; msgnum >= mp -> lowmsg; msgnum--) ! 2025: if (mp -> msgstats[msgnum] & EXISTS) { ! 2026: i = msgnum; ! 2027: if (j == 0) ! 2028: j = msgnum; ! 2029: if (n++ >= k) ! 2030: break; ! 2031: } ! 2032: for (msgnum = mp -> curmsg + 1; msgnum <= mp -> hghmsg; msgnum++) ! 2033: if (mp -> msgstats[msgnum] & EXISTS) { ! 2034: if (i == 0) ! 2035: i = msgnum; ! 2036: j = msgnum; ! 2037: if (n++ >= windows[SCAN]) ! 2038: break; ! 2039: } ! 2040: if (!topcur ! 2041: && lo > 0 ! 2042: && hi > 0 ! 2043: && mp -> msgstats[lo] & EXISTS ! 2044: && mp -> msgstats[hi] & EXISTS ! 2045: && (lo < mp -> curmsg ! 2046: || (lo == mp -> curmsg && lo == mp -> lowmsg)) ! 2047: && (mp -> curmsg < hi ! 2048: || (hi == mp -> curmsg && hi == mp -> hghmsg)) ! 2049: && hi - lo == j - i) ! 2050: i = lo, j = hi; ! 2051: ! 2052: if (mp -> curmsg != cur || modified) ! 2053: switch (winN (NULLCMD, SCAN, 0)) { ! 2054: case NOTOK: ! 2055: return NOTOK; ! 2056: ! 2057: case OK: ! 2058: return OK; ! 2059: ! 2060: default: ! 2061: scanrange (lo = i, hi = j); ! 2062: cur = mp -> curmsg; ! 2063: (void) winR (NULLCMD); ! 2064: return OK; ! 2065: } ! 2066: ! 2067: return OK; ! 2068: } ! 2069: ! 2070: /* */ ! 2071: ! 2072: static int pCMD (str, sw, cmdp) ! 2073: char *str; ! 2074: struct swit *sw; ! 2075: struct Cmd *cmdp; ! 2076: { ! 2077: int i; ! 2078: ! 2079: if (*str == '?') ! 2080: switch (winX (DISPLAY)) { ! 2081: case NOTOK: ! 2082: return NOTOK; ! 2083: ! 2084: case OK: ! 2085: printf ("commands:\n"); ! 2086: printsw (ALL, sw, ""); ! 2087: printf ("type ``quit'' to leave %s\n", invo_name); ! 2088: (void) fflush (stdout); ! 2089: (void) fflush (stderr); ! 2090: _exit (0); /* NOTREACHED */ ! 2091: ! 2092: default: ! 2093: (void) rc2peer (RC_EOF, 0, NULLCP); ! 2094: return NOTOK; ! 2095: } ! 2096: ! 2097: if (parse (str, cmdp) == NOTOK) ! 2098: return NOTOK; ! 2099: ! 2100: switch (i = smatch (cmdp -> args[0], sw)) { ! 2101: case AMBIGSW: ! 2102: switch (winX (DISPLAY)) { ! 2103: case NOTOK: ! 2104: return NOTOK; ! 2105: ! 2106: case OK: ! 2107: ambigsw (cmdp -> args[0], sw); ! 2108: (void) fflush (stdout); ! 2109: (void) fflush (stderr); ! 2110: _exit (0); /* NOTREACHED */ ! 2111: ! 2112: default: ! 2113: (void) rc2peer (RC_EOF, 0, NULLCP); ! 2114: return NOTOK; ! 2115: } ! 2116: ! 2117: case UNKWNSW: ! 2118: (void) fmt2peer (RC_ERR, ! 2119: "say what: ``%s'' -- type ? (or help) for help", ! 2120: cmdp -> args[0]); ! 2121: return NOTOK; ! 2122: ! 2123: default: ! 2124: return i; ! 2125: } ! 2126: } ! 2127: ! 2128: /* */ ! 2129: ! 2130: static int pFIN () { ! 2131: int status; ! 2132: ! 2133: switch (setjmp (peerenv)) { ! 2134: case OK: ! 2135: (void) signal (SIGALRM, alrmser); ! 2136: (void) alarm (ALARM); ! 2137: ! 2138: status = peerwait (); ! 2139: ! 2140: (void) alarm (0); ! 2141: return status; ! 2142: ! 2143: default: ! 2144: return NOTOK; ! 2145: } ! 2146: } ! 2147: ! 2148: ! 2149: static int peerwait () { ! 2150: struct record rcs, ! 2151: *rc = &rcs; ! 2152: ! 2153: initrc (rc); ! 2154: ! 2155: switch (peer2rc (rc)) { ! 2156: case RC_QRY: ! 2157: case RC_CMD: ! 2158: (void) rc2peer (RC_FIN, 0, NULLCP); ! 2159: return OK; ! 2160: ! 2161: case RC_XXX: ! 2162: advise (NULLCP, "%s", rc -> rc_data); ! 2163: return NOTOK; ! 2164: ! 2165: default: ! 2166: (void) fmt2peer (RC_FIN, "pLOOP protocol screw-up"); ! 2167: return NOTOK; ! 2168: } ! 2169: } ! 2170: ! 2171: ! 2172: /* ARGSUSED */ ! 2173: ! 2174: static int alrmser (i) ! 2175: int i; ! 2176: { ! 2177: longjmp (peerenv, DONE); ! 2178: } ! 2179: ! 2180: /* */ ! 2181: ! 2182: static int ttyNaux (cmdp, s) ! 2183: register struct Cmd *cmdp; ! 2184: char *s; ! 2185: { ! 2186: struct record rcs, ! 2187: *rc = &rcs; ! 2188: ! 2189: initrc (rc); ! 2190: ! 2191: if (cmdp && init_io (cmdp, vmh) == NOTOK) ! 2192: return NOTOK; ! 2193: ! 2194: if (!fmsh) ! 2195: (void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */ ! 2196: ! 2197: vmhtty = NOTOK; ! 2198: switch (rc2rc (RC_TTY, s ? strlen (s) : 0, s, rc)) { ! 2199: case RC_ACK: ! 2200: vmhtty = OK; /* fall */ ! 2201: case RC_ERR: ! 2202: break; ! 2203: ! 2204: case RC_XXX: ! 2205: padios (NULLCP, "%s", rc -> rc_data);/* NOTREACHED */ ! 2206: ! 2207: default: ! 2208: (void) fmt2peer (RC_ERR, "pTTY protocol screw-up"); ! 2209: done (1); /* NOTREACHED */ ! 2210: } ! 2211: ! 2212: #ifdef SIGTSTP ! 2213: (void) signal (SIGTSTP, tstat); ! 2214: #endif SIGTSTP ! 2215: return vmhtty; ! 2216: } ! 2217: ! 2218: /* */ ! 2219: ! 2220: static int ttyR (cmdp) ! 2221: register struct Cmd *cmdp; ! 2222: { ! 2223: struct record rcs, ! 2224: *rc = &rcs; ! 2225: ! 2226: #ifdef SIGTSTP ! 2227: (void) signal (SIGTSTP, SIG_IGN); ! 2228: #endif SIGTSTP ! 2229: ! 2230: if (vmhtty != OK) ! 2231: return NOTOK; ! 2232: ! 2233: initrc (rc); ! 2234: ! 2235: if (cmdp) ! 2236: fin_io (cmdp, 0); ! 2237: ! 2238: vmhtty = NOTOK; ! 2239: switch (rc2rc (RC_EOF, 0, NULLCP, rc)) { ! 2240: case RC_ACK: ! 2241: (void) rc2peer (RC_EOF, 0, NULLCP); ! 2242: return OK; ! 2243: ! 2244: case RC_XXX: ! 2245: padios (NULLCP, "%s", rc -> rc_data);/* NOTREACHED */ ! 2246: ! 2247: default: ! 2248: (void) fmt2peer (RC_ERR, "pTTY protocol screw-up"); ! 2249: done (1); /* NOTREACHED */ ! 2250: } ! 2251: } ! 2252: ! 2253: /* */ ! 2254: ! 2255: static int winN (cmdp, n, eof) ! 2256: register struct Cmd *cmdp; ! 2257: int n, ! 2258: eof; ! 2259: { ! 2260: int i, ! 2261: pd[2]; ! 2262: char buffer[BUFSIZ]; ! 2263: struct record rcs, ! 2264: *rc = &rcs; ! 2265: ! 2266: if (vmhpid == NOTOK) ! 2267: return OK; ! 2268: ! 2269: initrc (rc); ! 2270: ! 2271: if (!fmsh) ! 2272: (void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */ ! 2273: ! 2274: vmhpid = OK; ! 2275: ! 2276: (void) sprintf (buffer, "%d", n); ! 2277: switch (str2rc (RC_WIN, buffer, rc)) { ! 2278: case RC_ACK: ! 2279: break; ! 2280: ! 2281: case RC_ERR: ! 2282: return NOTOK; ! 2283: ! 2284: case RC_XXX: ! 2285: padios (NULLCP, "%s", rc -> rc_data); ! 2286: ! 2287: default: ! 2288: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2289: done (1); ! 2290: } ! 2291: ! 2292: if (pipe (pd) == NOTOK) { ! 2293: (void) err2peer (RC_ERR, "pipe", "unable to"); ! 2294: return NOTOK; ! 2295: } ! 2296: ! 2297: switch (vmhpid = fork ()) { ! 2298: case NOTOK: ! 2299: (void) err2peer (RC_ERR, "fork", "unable to"); ! 2300: (void) close (pd[0]); ! 2301: (void) close (pd[1]); ! 2302: return NOTOK; ! 2303: ! 2304: case OK: ! 2305: (void) close (pd[1]); ! 2306: (void) signal (SIGPIPE, SIG_IGN); ! 2307: while ((i = read (pd[0], buffer, sizeof buffer)) > 0) ! 2308: switch (rc2rc (RC_DATA, i, buffer, rc)) { ! 2309: case RC_ACK: ! 2310: break; ! 2311: ! 2312: case RC_ERR: ! 2313: _exit (1); ! 2314: ! 2315: case RC_XXX: ! 2316: advise (NULLCP, "%s", rc -> rc_data); ! 2317: _exit (2); ! 2318: ! 2319: default: ! 2320: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2321: _exit (2); ! 2322: } ! 2323: if (i == OK) ! 2324: switch (rc2rc (RC_EOF, 0, NULLCP, rc)) { ! 2325: case RC_ACK: ! 2326: if (eof) ! 2327: (void) rc2peer (RC_EOF, 0, NULLCP); ! 2328: i = 0; ! 2329: break; ! 2330: ! 2331: case RC_XXX: ! 2332: advise (NULLCP, "%s", rc -> rc_data); ! 2333: i = 2; ! 2334: break; ! 2335: ! 2336: default: ! 2337: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2338: i = 2; ! 2339: break; ! 2340: } ! 2341: if (i == NOTOK) ! 2342: (void) err2peer (RC_ERR, "pipe", "error reading from"); ! 2343: (void) close (pd[0]); ! 2344: _exit (i != NOTOK ? i : 1); ! 2345: ! 2346: default: ! 2347: if ((vmhfd0 = dup (fileno (stdin))) == NOTOK) ! 2348: padios ("standard input", "unable to dup"); ! 2349: if ((vmhfd1 = dup (fileno (stdout))) == NOTOK) ! 2350: padios ("standard output", "unable to dup"); ! 2351: if ((vmhfd2 = dup (fileno (stderr))) == NOTOK) ! 2352: padios ("diagnostic output", "unable to dup"); ! 2353: ! 2354: (void) close (0); ! 2355: if ((i = open ("/dev/null", 0)) != NOTOK && i != fileno (stdin)) { ! 2356: (void) dup2 (i, fileno (stdin)); ! 2357: (void) close (i); ! 2358: } ! 2359: ! 2360: (void) fflush (stdout); ! 2361: if (dup2 (pd[1], fileno (stdout)) == NOTOK) ! 2362: padios ("standard output", "unable to dup2"); ! 2363: clearerr (stdout); ! 2364: ! 2365: (void) fflush (stderr); ! 2366: if (dup2 (pd[1], fileno (stderr)) == NOTOK) ! 2367: padios ("diagnostic output", "unable to dup2"); ! 2368: clearerr (stderr); ! 2369: ! 2370: if (cmdp && init_io (cmdp, 0) == NOTOK) ! 2371: return NOTOK; ! 2372: pstat = signal (SIGPIPE, pipeser); ! 2373: broken_pipe = 1; ! 2374: ! 2375: (void) close (pd[0]); ! 2376: (void) close (pd[1]); ! 2377: ! 2378: return vmhpid; ! 2379: } ! 2380: } ! 2381: ! 2382: /* */ ! 2383: ! 2384: static int winR (cmdp) ! 2385: register struct Cmd *cmdp; ! 2386: { ! 2387: int status; ! 2388: ! 2389: if (vmhpid <= OK) ! 2390: return NOTOK; ! 2391: ! 2392: if (cmdp) ! 2393: fin_io (cmdp, 0); ! 2394: ! 2395: if (dup2 (vmhfd0, fileno (stdin)) == NOTOK) ! 2396: padios ("standard input", "unable to dup2"); ! 2397: clearerr (stdin); ! 2398: (void) close (vmhfd0); ! 2399: ! 2400: (void) fflush (stdout); ! 2401: if (dup2 (vmhfd1, fileno (stdout)) == NOTOK) ! 2402: padios ("standard output", "unable to dup2"); ! 2403: clearerr (stdout); ! 2404: (void) close (vmhfd1); ! 2405: ! 2406: (void) fflush (stderr); ! 2407: if (dup2 (vmhfd2, fileno (stderr)) == NOTOK) ! 2408: padios ("diagnostic output", "unable to dup2"); ! 2409: clearerr (stderr); ! 2410: (void) close (vmhfd2); ! 2411: ! 2412: (void) signal (SIGPIPE, pstat); ! 2413: ! 2414: if ((status = pidwait (vmhpid, OK)) == 2) ! 2415: done (1); ! 2416: ! 2417: vmhpid = OK; ! 2418: return (status == 0 ? OK : NOTOK); ! 2419: } ! 2420: ! 2421: /* */ ! 2422: ! 2423: static int winX (n) ! 2424: int n; ! 2425: { ! 2426: int i, ! 2427: pid, ! 2428: pd[2]; ! 2429: char buffer[BUFSIZ]; ! 2430: struct record rcs, ! 2431: *rc = &rcs; ! 2432: ! 2433: initrc (rc); ! 2434: ! 2435: if (!fmsh) ! 2436: (void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */ ! 2437: ! 2438: (void) sprintf (buffer, "%d", n); ! 2439: switch (str2rc (RC_WIN, buffer, rc)) { ! 2440: case RC_ACK: ! 2441: break; ! 2442: ! 2443: case RC_ERR: ! 2444: return NOTOK; ! 2445: ! 2446: case RC_XXX: ! 2447: padios (NULLCP, "%s", rc -> rc_data); ! 2448: ! 2449: default: ! 2450: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2451: done (1); ! 2452: } ! 2453: ! 2454: if (pipe (pd) == NOTOK) { ! 2455: (void) err2peer (RC_ERR, "pipe", "unable to"); ! 2456: return NOTOK; ! 2457: } ! 2458: ! 2459: switch (pid = fork ()) { ! 2460: case NOTOK: ! 2461: (void) err2peer (RC_ERR, "fork", "unable to"); ! 2462: (void) close (pd[0]); ! 2463: (void) close (pd[1]); ! 2464: return NOTOK; ! 2465: ! 2466: case OK: ! 2467: (void) close (fileno (stdin)); ! 2468: if ((i = open ("/dev/null", 0)) != NOTOK && i != fileno (stdin)) { ! 2469: (void) dup2 (i, fileno (stdin)); ! 2470: (void) close (i); ! 2471: } ! 2472: (void) dup2 (pd[1], fileno (stdout)); ! 2473: (void) dup2 (pd[1], fileno (stderr)); ! 2474: (void) close (pd[0]); ! 2475: (void) close (pd[1]); ! 2476: vmhpid = NOTOK; ! 2477: return OK; ! 2478: ! 2479: default: ! 2480: (void) close (pd[1]); ! 2481: while ((i = read (pd[0], buffer, sizeof buffer)) > 0) ! 2482: switch (rc2rc (RC_DATA, i, buffer, rc)) { ! 2483: case RC_ACK: ! 2484: break; ! 2485: ! 2486: case RC_ERR: ! 2487: (void) close (pd[0]); ! 2488: (void) pidwait (pid, OK); ! 2489: return NOTOK; ! 2490: ! 2491: case RC_XXX: ! 2492: padios (NULLCP, "%s", rc -> rc_data); ! 2493: ! 2494: default: ! 2495: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2496: done (1); ! 2497: } ! 2498: if (i == OK) ! 2499: switch (rc2rc (RC_EOF, 0, NULLCP, rc)) { ! 2500: case RC_ACK: ! 2501: break; ! 2502: ! 2503: case RC_XXX: ! 2504: padios (NULLCP, "%s", rc -> rc_data); ! 2505: ! 2506: default: ! 2507: (void) fmt2peer (RC_ERR, "pWIN protocol screw-up"); ! 2508: done (1); ! 2509: } ! 2510: if (i == NOTOK) ! 2511: (void) err2peer (RC_ERR, "pipe", "error reading from"); ! 2512: ! 2513: (void) close (pd[0]); ! 2514: (void) pidwait (pid, OK); ! 2515: return (i != NOTOK ? pid : NOTOK); ! 2516: } ! 2517: } ! 2518: ! 2519: /* */ ! 2520: ! 2521: /* VARARGS2 */ ! 2522: ! 2523: void padios (what, fmt, a, b, c, d, e, f) ! 2524: char *what, ! 2525: *fmt, ! 2526: *a, ! 2527: *b, ! 2528: *c, ! 2529: *d, ! 2530: *e, ! 2531: *f; ! 2532: { ! 2533: if (vmh) { ! 2534: (void) err2peer (RC_FIN, what, fmt, a, b, c, d, e, f); ! 2535: (void) rcdone (); ! 2536: } ! 2537: else ! 2538: advise (what, fmt, a, b, c, d, e, f); ! 2539: ! 2540: done (1); ! 2541: } ! 2542: ! 2543: ! 2544: /* VARARGS2 */ ! 2545: ! 2546: void padvise (what, fmt, a, b, c, d, e, f) ! 2547: char *what, ! 2548: *fmt, ! 2549: *a, ! 2550: *b, ! 2551: *c, ! 2552: *d, ! 2553: *e, ! 2554: *f; ! 2555: { ! 2556: if (vmh) ! 2557: (void) err2peer (RC_ERR, what, fmt, a, b, c, d, e, f); ! 2558: else ! 2559: advise (what, fmt, a, b, c, d, e, f); ! 2560: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.