git.marmaro.de Git - mmh/blob - uip/msh.c

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