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