]> diplodocus.org Git - nmh/blob - uip/msh.c
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Quiet lock warning.
[nmh] / uip / msh.c
1
2 /*
3 * msh.c -- The nmh shell
4 *
5 * $Id$
6 *
7 * This code is Copyright (c) 2002, by the authors of nmh. See the
8 * COPYRIGHT file in the root directory of the nmh distribution for
9 * complete copyright information.
10 */
11
12 /*
13 * TODO:
14 * Keep more status information in maildrop map
15 */
16
17 #include <h/mh.h>
18 #include <fcntl.h>
19 #include <h/signals.h>
20 #include <h/dropsbr.h>
21 #include <h/fmt_scan.h>
22 #include <h/scansbr.h>
23 #include <h/tws.h>
24 #include <h/mts.h>
25
26 #ifdef HAVE_TERMIOS_H
27 # include <termios.h>
28 #else
29 # ifdef HAVE_TERMIO_H
30 # include <termio.h>
31 # else
32 # include <sgtty.h>
33 # endif
34 #endif
35
36 #include <pwd.h>
37 #include <setjmp.h>
38 #include <signal.h>
39 #include <h/msh.h>
40 #include <h/vmhsbr.h>
41
42 #define QUOTE '\\' /* sigh */
43
44 static struct swit switches[] = {
45 #define IDSW 0
46 { "idstart number", -7 }, /* interface from bbc */
47 #define FDSW 1
48 { "idstop number", -6 }, /* .. */
49 #define QDSW 2
50 { "idquit number", -6 }, /* .. */
51 #define NMSW 3
52 { "idname BBoard", -6 }, /* .. */
53 #define PRMPTSW 4
54 { "prompt string", 0 },
55 #define SCANSW 5
56 { "scan", 0 },
57 #define NSCANSW 6
58 { "noscan", 0 },
59 #define READSW 7
60 { "vmhread fd", -7 },
61 #define WRITESW 8
62 { "vmhwrite fd", -8 },
63 #define PREADSW 9
64 { "popread fd", -7 },
65 #define PWRITSW 10
66 { "popwrite fd", -8 },
67 #define TCURSW 11
68 { "topcur", 0 },
69 #define NTCURSW 12
70 { "notopcur", 0 },
71 #define VERSIONSW 13
72 { "version", 0 },
73 #define HELPSW 14
74 { "help", 0 },
75 { NULL, 0 }
76 };
77
78 static int mbx_style = MMDF_FORMAT;
79
80 /*
81 * FOLDER
82 */
83 char*fmsh = NULL; /* folder instead of file */
84 int modified; /* command modified folder */
85 struct msgs *mp; /* used a lot */
86 static int nMsgs = 0;
87 struct Msg *Msgs = NULL; /* Msgs[0] not used */
88 static FILE *fp; /* input file */
89 static FILE *yp = NULL; /* temporary file */
90 static int mode; /* mode of file */
91 static int numfds = 0; /* number of files cached */
92 static int maxfds = 0; /* number of files cached to be cached */
93 static time_t mtime = (time_t) 0; /* mtime of file */
94
95 /*
96 * VMH
97 */
98 #define ALARM ((unsigned int) 10)
99 #define ttyN(c) ttyNaux ((c), NULL)
100
101 static int vmh = 0;
102
103 static int vmhpid = OK;
104 static int vmhfd0;
105 static int vmhfd1;
106 static int vmhfd2;
107
108 static int vmhtty = NOTOK;
109
110 #define SCAN 1
111 #define STATUS 2
112 #define DISPLAY 3
113 #define NWIN DISPLAY
114
115 static int topcur = 0;
116
117 static int numwins = 0;
118 static int windows[NWIN + 1];
119
120 static jmp_buf peerenv;
121
122 #ifdef BPOP
123 int pmsh = 0; /* BPOP enabled */
124 extern char response[];
125 #endif /* BPOP */
126
127 /*
128 * PARENT
129 */
130 static int pfd = NOTOK; /* fd parent is reading from */
131 static int ppid = 0; /* pid of parent */
132
133 /*
134 * COMMAND
135 */
136 int interactive; /* running from a /dev/tty */
137 int redirected; /* re-directing output */
138 FILE *sp = NULL; /* original stdout */
139
140 char *cmd_name; /* command being run */
141 char myfilter[BUFSIZ]; /* path to mhl.forward */
142
143 static char *myprompt = "(%s) ";/* prompting string */
144
145 /*
146 * BBOARDS
147 */
148 static int gap; /* gap in BBoard-ID:s */
149 static char *myname = NULL; /* BBoard name */
150 char *BBoard_ID = "BBoard-ID"; /* BBoard-ID constant */
151
152 /*
153 * SIGNALS
154 */
155 SIGNAL_HANDLER istat; /* original SIGINT */
156 static SIGNAL_HANDLER pstat; /* current SIGPIPE */
157 SIGNAL_HANDLER qstat; /* original SIGQUIT */
158
159 #ifdef SIGTSTP
160 SIGNAL_HANDLER tstat; /* original SIGTSTP */
161 #endif
162
163 int interrupted; /* SIGINT detected */
164 int broken_pipe; /* SIGPIPE detected */
165 int told_to_quit; /* SIGQUIT detected */
166
167 #ifdef BSD42
168 int should_intr; /* signal handler should interrupt call */
169 jmp_buf sigenv; /* the environment pointer */
170 #endif
171
172 /*
173 * prototypes
174 */
175 int SOprintf (char *, ...); /* from termsbr.c */
176 int sc_width (void); /* from termsbr.c */
177 void fsetup (char *);
178 void setup (char *);
179 FILE *msh_ready (int, int);
180 void readids (int);
181 int readid (int);
182 void display_info (int);
183 int expand (char *);
184 void m_reset (void);
185 void seq_setcur (struct msgs *, int);
186 void padios (char *, char *, ...);
187 void padvise (char *, char *, ...);
188
189
190 /*
191 * static prototypes
192 */
193 static void msh (int);
194 static int read_map (char *, long);
195 static int read_file (long, int);
196
197 #ifdef BPOP
198 # ifdef NNTP
199 static int pop_statmsg (char *);
200 # endif /* NNTP */
201 static int read_pop (void);
202 static int pop_action (char *);
203 #endif /* BPOP */
204
205 static void m_gMsgs (int);
206 FILE *msh_ready (int, int);
207 static int check_folder (int);
208 static void scanrange (int, int);
209 static void scanstring (char *);
210 static void write_ids (void);
211 static void quit (void);
212 static int getargs (char *, struct swit *, struct Cmd *);
213 static int getcmds (struct swit *, struct Cmd *, int);
214 static int parse (char *, struct Cmd *);
215 static int init_io (struct Cmd *, int);
216 static int initaux_io (struct Cmd *);
217 static void fin_io (struct Cmd *, int);
218 static void finaux_io (struct Cmd *);
219 static void m_init (void);
220 static RETSIGTYPE intrser (int);
221 static RETSIGTYPE pipeser (int);
222 static RETSIGTYPE quitser (int);
223 static RETSIGTYPE alrmser (int);
224 static int pINI (void);
225 static int pQRY (char *, int);
226 static int pQRY1 (int);
227 static int pQRY2 (void);
228 static int pCMD (char *, struct swit *, struct Cmd *);
229 static int pFIN (void);
230 static int peerwait (void);
231 static int ttyNaux (struct Cmd *, char *);
232 static int ttyR (struct Cmd *);
233 static int winN (struct Cmd *, int, int);
234 static int winR (struct Cmd *);
235 static int winX (int);
236
237
238 int
239 main (int argc, char **argv)
240 {
241 int id = 0, scansw = 0, vmh1 = 0, vmh2 = 0;
242 char *cp, *file = NULL, *folder = NULL;
243 char **argp, **arguments, buf[BUFSIZ];
244 #ifdef BPOP
245 int pmsh1 = 0, pmsh2 = 0;
246 #endif
247
248 #ifdef LOCALE
249 setlocale(LC_ALL, "");
250 #endif
251 invo_name = r1bindex (argv[0], '/');
252
253 /* read user profile/context */
254 context_read();
255
256 mts_init (invo_name);
257 arguments = getarguments (invo_name, argc,argv, 1);
258 argp = arguments;
259
260 while ((cp = *argp++)) {
261 if (*cp == '-')
262 switch (smatch (++cp, switches)) {
263 case AMBIGSW:
264 ambigsw (cp, switches);
265 done (1);
266 case UNKWNSW:
267 adios (NULL, "-%s unknown", cp);
268
269 case HELPSW:
270 snprintf (buf, sizeof(buf), "%s [switches] file", invo_name);
271 print_help (buf, switches, 1);
272 done (1);
273 case VERSIONSW:
274 print_version(invo_name);
275 done (1);
276
277 case IDSW:
278 if (!(cp = *argp++) || *cp == '-')
279 adios (NULL, "missing argument to %s", argp[-2]);
280 if ((id = atoi (cp)) < 1)
281 adios (NULL, "bad argument %s %s", argp[-2], cp);
282 continue;
283 case FDSW:
284 if (!(cp = *argp++) || *cp == '-')
285 adios (NULL, "missing argument to %s", argp[-2]);
286 if ((pfd = atoi (cp)) <= 1)
287 adios (NULL, "bad argument %s %s", argp[-2], cp);
288 continue;
289 case QDSW:
290 if (!(cp = *argp++) || *cp == '-')
291 adios (NULL, "missing argument to %s", argp[-2]);
292 if ((ppid = atoi (cp)) <= 1)
293 adios (NULL, "bad argument %s %s", argp[-2], cp);
294 continue;
295 case NMSW:
296 if (!(myname = *argp++) || *myname == '-')
297 adios (NULL, "missing argument to %s", argp[-2]);
298 continue;
299
300 case SCANSW:
301 scansw++;
302 continue;
303 case NSCANSW:
304 scansw = 0;
305 continue;
306
307 case PRMPTSW:
308 if (!(myprompt = *argp++) || *myprompt == '-')
309 adios (NULL, "missing argument to %s", argp[-2]);
310 continue;
311
312 case READSW:
313 if (!(cp = *argp++) || *cp == '-')
314 adios (NULL, "missing argument to %s", argp[-2]);
315 if ((vmh1 = atoi (cp)) < 1)
316 adios (NULL, "bad argument %s %s", argp[-2], cp);
317 continue;
318 case WRITESW:
319 if (!(cp = *argp++) || *cp == '-')
320 adios (NULL, "missing argument to %s", argp[-2]);
321 if ((vmh2 = atoi (cp)) < 1)
322 adios (NULL, "bad argument %s %s", argp[-2], cp);
323 continue;
324
325 case PREADSW:
326 if (!(cp = *argp++) || *cp == '-')
327 adios (NULL, "missing argument to %s", argp[-2]);
328 #ifdef BPOP
329 if ((pmsh1 = atoi (cp)) < 1)
330 adios (NULL, "bad argument %s %s", argp[-2], cp);
331 #endif /* BPOP */
332 continue;
333 case PWRITSW:
334 if (!(cp = *argp++) || *cp == '-')
335 adios (NULL, "missing argument to %s", argp[-2]);
336 #ifdef BPOP
337 if ((pmsh2 = atoi (cp)) < 1)
338 adios (NULL, "bad argument %s %s", argp[-2], cp);
339 #endif /* BPOP */
340 continue;
341
342 case TCURSW:
343 topcur++;
344 continue;
345 case NTCURSW:
346 topcur = 0;
347 continue;
348 }
349 if (*cp == '+' || *cp == '@') {
350 if (folder)
351 adios (NULL, "only one folder at a time!");
352 else
353 folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
354 }
355 else
356 if (file)
357 adios (NULL, "only one file at a time!");
358 else
359 file = cp;
360 }
361
362 if (!file && !folder)
363 file = "./msgbox";
364 if (file && folder)
365 adios (NULL, "use a file or a folder, not both");
366 strncpy (myfilter, etcpath (mhlforward), sizeof(myfilter));
367 #ifdef FIOCLEX
368 if (pfd > 1)
369 ioctl (pfd, FIOCLEX, NULL);
370 #endif /* FIOCLEX */
371
372 #ifdef BSD42
373 should_intr = 0;
374 #endif /* BSD42 */
375 istat = SIGNAL2 (SIGINT, intrser);
376 qstat = SIGNAL2 (SIGQUIT, quitser);
377
378 sc_width (); /* MAGIC... */
379
380 if ((vmh = vmh1 && vmh2)) {
381 rcinit (vmh1, vmh2);
382 pINI ();
383 SIGNAL (SIGINT, SIG_IGN);
384 SIGNAL (SIGQUIT, SIG_IGN);
385 #ifdef SIGTSTP
386 tstat = SIGNAL (SIGTSTP, SIG_IGN);
387 #endif /* SIGTSTP */
388 }
389
390 #ifdef BPOP
391 if (pmsh = pmsh1 && pmsh2) {
392 cp = getenv ("MHPOPDEBUG");
393 #ifdef NNTP
394 if (pop_set (pmsh1, pmsh2, cp && *cp, myname) == NOTOK)
395 #else /* NNTP */
396 if (pop_set (pmsh1, pmsh2, cp && *cp) == NOTOK)
397 #endif /* NNTP */
398 padios (NULL, "%s", response);
399 if (folder)
400 file = folder, folder = NULL;
401 }
402 #endif /* BPOP */
403
404 if (folder)
405 fsetup (folder);
406 else
407 setup (file);
408 readids (id);
409 display_info (id > 0 ? scansw : 0);
410
411 msh (id > 0 ? scansw : 0);
412
413 m_reset ();
414
415 return done (0);
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 strncpy (tmpfil, m_tmpfil (invo_name), sizeof(tmpfil));
735 if ((fp = fopen (tmpfil, "w+")) == NULL)
736 padios (tmpfil, "unable to create");
737 unlink (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 *) realloc ((char *) Msgs, (size_t) (nmsgs + 2) * sizeof *Msgs);
945 if (Msgs == NULL)
946 padios (NULL, "unable to reallocate Msgs structure");
947 memset((char *) (Msgs + nMsgs + 2), 0, (size_t) ((nmsgs - nMsgs) * sizeof *Msgs));
948
949 nMsgs = nmsgs;
950 }
951
952
953 FILE *
954 msh_ready (int msgnum, int full)
955 {
956 register int msgp;
957 int fd;
958 char *cp;
959 #ifdef BPOP
960 char tmpfil[BUFSIZ];
961 long pos1, pos2;
962 #endif
963
964 if (yp) {
965 fclose (yp);
966 yp = NULL;
967 }
968
969 if (fmsh) {
970 if ((fd = Msgs[msgnum].m_top) == NOTOK) {
971 if (numfds >= maxfds)
972 for (msgp = mp->lowmsg; msgp <= mp->hghmsg; msgp++)
973 if (Msgs[msgp].m_top != NOTOK) {
974 close (Msgs[msgp].m_top);
975 Msgs[msgp].m_top = NOTOK;
976 numfds--;
977 break;
978 }
979
980 if ((fd = open (cp = m_name (msgnum), O_RDONLY)) == NOTOK)
981 padios (cp, "unable to open message");
982 Msgs[msgnum].m_top = fd;
983 numfds++;
984 }
985
986 if ((fd = dup (fd)) == NOTOK)
987 padios ("cached message", "unable to dup");
988 if ((yp = fdopen (fd, "r")) == NULL)
989 padios (NULL, "unable to fdopen cached message");
990 fseek (yp, 0L, SEEK_SET);
991 return yp;
992 }
993
994 #ifdef BPOP
995 if (pmsh && is_virtual (mp, msgnum)) {
996 if (Msgs[msgnum].m_top == 0)
997 padios (NULL, "msh_ready (%d, %d) botch", msgnum, full);
998 if (!full) {
999 strncpy (tmpfil, m_tmpfil (invo_name), sizeof(tmpfil));
1000 if ((yp = fopen (tmpfil, "w+")) == NULL)
1001 padios (tmpfil, "unable to create");
1002 unlink (tmpfil);
1003
1004 if (pop_top (Msgs[msgnum].m_top, 4, pop_action) == NOTOK)
1005 padios (NULL, "%s", response);
1006
1007 m_eomsbr ((int (*)()) 0); /* XXX */
1008 msg_style = MS_DEFAULT; /* .. */
1009 fseek (yp, 0L, SEEK_SET);
1010 return yp;
1011 }
1012
1013 fseek (fp, 0L, SEEK_END);
1014 fwrite (mmdlm1, 1, strlen (mmdlm1), fp);
1015 if (fflush (fp))
1016 padios ("temporary file", "write error on");
1017 fseek (fp, 0L, SEEK_END);
1018 pos1 = ftell (fp);
1019
1020 yp = fp;
1021 if (pop_retr (Msgs[msgnum].m_top, pop_action) == NOTOK)
1022 padios (NULL, "%s", response);
1023 yp = NULL;
1024
1025 fseek (fp, 0L, SEEK_END);
1026 pos2 = ftell (fp);
1027 fwrite (mmdlm2, 1, strlen (mmdlm2), fp);
1028 if (fflush (fp))
1029 padios ("temporary file", "write error on");
1030
1031 Msgs[msgnum].m_start = pos1;
1032 Msgs[msgnum].m_stop = pos2;
1033
1034 unset_virtual (mp, msgnum);
1035 }
1036 #endif /* BPOP */
1037
1038 m_eomsbr ((int (*)()) 0); /* XXX */
1039 fseek (fp, Msgs[msgnum].m_start, SEEK_SET);
1040 return fp;
1041 }
1042
1043
1044 static int
1045 check_folder (int scansw)
1046 {
1047 int seqnum, i, low, hgh, 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 folder_free (mp); /* free folder/message structure */
1064
1065 if (!(mp = folder_read (fmsh)))
1066 padios (NULL, "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 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 (NULL, "no messages in %s", mp->foldpath); /* XXX */
1097 if (msgp >= MAXFOLDER)
1098 padios (NULL, "more than %d messages in %s", MAXFOLDER,
1099 mp->foldpath);
1100 if (msgp <= mp->hghmsg)
1101 return 0; /* XXX */
1102
1103 if (!(mp = folder_realloc (mp, mp->lowoff, msgp)))
1104 padios (NULL, "unable to allocate folder storage");
1105
1106 low = mp->hghmsg + 1, hgh = msgp;
1107 seqnum = scansw ? seq_getnum (mp, "unseen") : -1;
1108 for (i = mp->hghmsg + 1; i <= msgp; i++) {
1109 set_exists(mp, i);
1110 if (seqnum != -1)
1111 add_sequence(mp, seqnum, i);
1112 mp->nummsg++;
1113 }
1114 mp->hghmsg = msgp;
1115 m_init ();
1116
1117 check_vmh: ;
1118 if (vmh)
1119 return 1;
1120
1121 advise (NULL, "new messages have arrived!\007");
1122 if (scansw)
1123 scanrange (low, hgh);
1124
1125 return 1;
1126 }
1127
1128
1129 static void
1130 scanrange (int low, int hgh)
1131 {
1132 char buffer[BUFSIZ];
1133
1134 snprintf (buffer, sizeof(buffer), "%d-%d", low, hgh);
1135 scanstring (buffer);
1136 }
1137
1138
1139 static void
1140 scanstring (char *arg)
1141 {
1142 char *cp, **ap, *vec[MAXARGS];
1143
1144 /*
1145 * This should be replace with a call to getarguments()
1146 */
1147 if ((cp = context_find (cmd_name = "scan"))) {
1148 cp = getcpy (cp);
1149 ap = brkstring (cp, " ", "\n");
1150 ap = copyip (ap, vec, MAXARGS);
1151 } else {
1152 ap = vec;
1153 }
1154 *ap++ = arg;
1155 *ap = NULL;
1156 m_init ();
1157 scancmd (vec);
1158 if (cp != NULL)
1159 free (cp);
1160 }
1161
1162
1163 void
1164 readids (int id)
1165 {
1166 register int cur, seqnum, i, msgnum;
1167
1168 if (mp->curmsg == 0)
1169 seq_setcur (mp, mp->lowmsg);
1170 if (id <= 0 || (seqnum = seq_getnum (mp, "unseen")) == -1)
1171 return;
1172
1173 for (msgnum = mp->hghmsg; msgnum >= mp->lowmsg; msgnum--)
1174 add_sequence(mp, seqnum, msgnum);
1175
1176 if (id != 1) {
1177 cur = mp->curmsg;
1178
1179 for (msgnum = mp->hghmsg; msgnum >= mp->lowmsg; msgnum--)
1180 if (does_exist(mp, msgnum)) /* FIX */
1181 if ((i = readid (msgnum)) > 0 && i < id) {
1182 cur = msgnum + 1;
1183 clear_sequence(mp, seqnum, msgnum);
1184 break;
1185 }
1186 for (i = mp->lowmsg; i < msgnum; i++)
1187 clear_sequence(mp, seqnum, i);
1188
1189 if (cur > mp->hghmsg)
1190 cur = mp->hghmsg;
1191
1192 seq_setcur (mp, cur);
1193 }
1194
1195 if ((gap = 1 < id && id < (i = readid (mp->lowmsg)) ? id : 0) && !vmh)
1196 advise (NULL, "gap in ID:s, last seen %d, lowest present %d\n",
1197 id - 1, i);
1198 }
1199
1200
1201 int
1202 readid (int msgnum)
1203 {
1204 int i, state;
1205 char *bp, buf[BUFSIZ], name[NAMESZ];
1206 register FILE *zp;
1207 #ifdef BPOP
1208 int arg1, arg2, arg3;
1209 #endif
1210
1211 if (Msgs[msgnum].m_bboard_id)
1212 return Msgs[msgnum].m_bboard_id;
1213 #ifdef BPOP
1214 if (pmsh) {
1215 if (Msgs[msgnum].m_top == 0)
1216 padios (NULL, "readid (%d) botch", msgnum);
1217 if (pop_list (Msgs[msgnum].m_top, (int *) 0, &arg1, &arg2, &arg3) == OK
1218 && arg3 > 0)
1219 return (Msgs[msgnum].m_bboard_id = arg3);
1220 }
1221 #endif /* BPOP */
1222
1223 zp = msh_ready (msgnum, 0);
1224 for (state = FLD;;)
1225 switch (state = m_getfld (state, name, buf, sizeof(buf), zp)) {
1226 case FLD:
1227 case FLDEOF:
1228 case FLDPLUS:
1229 if (!strcasecmp (name, BBoard_ID)) {
1230 bp = getcpy (buf);
1231 while (state == FLDPLUS) {
1232 state = m_getfld (state, name, buf, sizeof(buf), zp);
1233 bp = add (buf, bp);
1234 }
1235 i = atoi (bp);
1236 free (bp);
1237 if (i > 0)
1238 return (Msgs[msgnum].m_bboard_id = i);
1239 else
1240 continue;
1241 }
1242 while (state == FLDPLUS)
1243 state = m_getfld (state, name, buf, sizeof(buf), zp);
1244 if (state != FLDEOF)
1245 continue;
1246
1247 default:
1248 return 0;
1249 }
1250 }
1251
1252
1253 void
1254 display_info (int scansw)
1255 {
1256 int seqnum, sd;
1257
1258 interactive = isatty (fileno (stdout));
1259 if (sp == NULL) {
1260 if ((sd = dup (fileno (stdout))) == NOTOK)
1261 padios ("standard output", "unable to dup");
1262 #ifndef BSD42 /* XXX */
1263 #ifdef FIOCLEX
1264 ioctl (sd, FIOCLEX, NULL);
1265 #endif /* FIOCLEX */
1266 #endif /* not BSD42 */
1267 if ((sp = fdopen (sd, "w")) == NULL)
1268 padios ("standard output", "unable to fdopen");
1269 }
1270
1271 m_putenv ("mhfolder", mp->foldpath);
1272 if (vmh)
1273 return;
1274
1275 if (myname) {
1276 printf ("Reading ");
1277 if (SOprintf ("%s", myname))
1278 printf ("%s", myname);
1279 printf (", currently at message %d of %d\n",
1280 mp->curmsg, mp->hghmsg);
1281 }
1282 else {
1283 printf ("Reading ");
1284 if (fmsh)
1285 printf ("+%s", fmsh);
1286 else
1287 printf ("%s", mp->foldpath);
1288 printf (", currently at message %d of %d\n",
1289 mp->curmsg, mp->hghmsg);
1290 }
1291
1292 if (((seqnum = seq_getnum (mp, "unseen")) != -1)
1293 && scansw
1294 && in_sequence(mp, seqnum, mp->hghmsg))
1295 scanstring ("unseen");
1296 }
1297
1298
1299 static void
1300 write_ids (void)
1301 {
1302 int i = 0, seqnum, msgnum;
1303 char buffer[80];
1304
1305 if (pfd <= 1)
1306 return;
1307
1308 if ((seqnum = seq_getnum (mp, "unseen")) != -1)
1309 for (msgnum = mp->hghmsg; msgnum >= mp->lowmsg; msgnum--)
1310 if (!in_sequence(mp, seqnum, msgnum)) {
1311 if (Msgs[msgnum].m_bboard_id == 0)
1312 readid (msgnum);
1313 if ((i = Msgs[msgnum].m_bboard_id) > 0)
1314 break;
1315 }
1316
1317 snprintf (buffer, sizeof(buffer), "%d %d\n", i, Msgs[mp->hghmsg].m_bboard_id);
1318 write (pfd, buffer, sizeof(buffer));
1319 close (pfd);
1320 pfd = NOTOK;
1321 }
1322
1323
1324 static void
1325 quit (void)
1326 {
1327 int i, md, msgnum;
1328 char *cp, tmpfil[BUFSIZ];
1329 char map1[BUFSIZ], map2[BUFSIZ];
1330 struct stat st;
1331 FILE *dp;
1332
1333 if (!(mp->msgflags & MODIFIED) || is_readonly(mp) || fmsh) {
1334 if (vmh)
1335 rc2peer (RC_FIN, 0, NULL);
1336 return;
1337 }
1338
1339 if (vmh)
1340 ttyNaux (NULLCMD, "FAST");
1341 cp = NULL;
1342 if ((dp = lkfopen (mp->foldpath, "r")) == NULL) {
1343 advise (mp->foldpath, "unable to lock");
1344 if (vmh) {
1345 ttyR (NULLCMD);
1346 pFIN ();
1347 }
1348 return;
1349 }
1350 if (fstat (fileno (dp), &st) == NOTOK) {
1351 advise (mp->foldpath, "unable to stat");
1352 goto release;
1353 }
1354 if (mtime != st.st_mtime) {
1355 advise (NULL, "new messages have arrived, no update");
1356 goto release;
1357 }
1358 mode = (int) (st.st_mode & 0777);
1359
1360 if (mp->nummsg == 0) {
1361 cp = concat ("Zero file \"", mp->foldpath, "\"? ", NULL);
1362 if (getanswer (cp)) {
1363 if ((i = creat (mp->foldpath, mode)) != NOTOK)
1364 close (i);
1365 else
1366 advise (mp->foldpath, "error zero'ing");
1367 unlink (map_name (mp->foldpath));/* XXX */
1368 }
1369 goto release;
1370 }
1371
1372 cp = concat ("Update file \"", mp->foldpath, "\"? ", NULL);
1373 if (!getanswer (cp))
1374 goto release;
1375 strncpy (tmpfil, m_backup (mp->foldpath), sizeof(tmpfil));
1376 if ((md = mbx_open (tmpfil, mbx_style, st.st_uid, st.st_gid, mode)) == NOTOK) {
1377 advise (tmpfil, "unable to open");
1378 goto release;
1379 }
1380
1381 for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++)
1382 if (does_exist(mp, msgnum) && pack (tmpfil, md, msgnum) == NOTOK) {
1383 mbx_close (tmpfil, md);
1384 unlink (tmpfil);
1385 unlink (map_name (tmpfil));
1386 goto release;
1387 }
1388 mbx_close (tmpfil, md);
1389
1390 if (rename (tmpfil, mp->foldpath) == NOTOK)
1391 admonish (mp->foldpath, "unable to rename %s to", tmpfil);
1392 else {
1393 strncpy (map1, map_name (tmpfil), sizeof(map1));
1394 strncpy (map2, map_name (mp->foldpath), sizeof(map2));
1395
1396 if (rename (map1, map2) == NOTOK) {
1397 admonish (map2, "unable to rename %s to", map1);
1398 unlink (map1);
1399 unlink (map2);
1400 }
1401 }
1402
1403 release: ;
1404 if (cp)
1405 free (cp);
1406 lkfclose (dp, mp->foldpath);
1407 if (vmh) {
1408 ttyR (NULLCMD);
1409 pFIN ();
1410 }
1411 }
1412
1413
1414 static int
1415 getargs (char *prompt, struct swit *sw, struct Cmd *cmdp)
1416 {
1417 int i;
1418 char *cp;
1419 static char buffer[BUFSIZ];
1420
1421 told_to_quit = 0;
1422 for (;;) {
1423 interrupted = 0;
1424 #ifdef BSD42
1425 switch (setjmp (sigenv)) {
1426 case OK:
1427 should_intr = 1;
1428 break;
1429
1430 default:
1431 should_intr = 0;
1432 if (interrupted && !told_to_quit) {
1433 putchar ('\n');
1434 continue;
1435 }
1436 if (ppid > 0)
1437 #ifdef SIGEMT
1438 kill (ppid, SIGEMT);
1439 #else
1440 kill (ppid, SIGTERM);
1441 #endif
1442 return EOF;
1443 }
1444 #endif /* BSD42 */
1445 if (interactive) {
1446 printf ("%s", prompt);
1447 fflush (stdout);
1448 }
1449 for (cp = buffer; (i = getchar ()) != '\n';) {
1450 #ifndef BSD42
1451 if (interrupted && !told_to_quit) {
1452 buffer[0] = '\0';
1453 putchar ('\n');
1454 break;
1455 }
1456 if (told_to_quit || i == EOF) {
1457 if (ppid > 0)
1458 #ifdef SIGEMT
1459 kill (ppid, SIGEMT);
1460 #else
1461 kill (ppid, SIGTERM);
1462 #endif
1463 return EOF;
1464 }
1465 #else /* BSD42 */
1466 if (i == EOF)
1467 longjmp (sigenv, DONE);
1468 #endif /* BSD42 */
1469 if (cp < &buffer[sizeof buffer - 2])
1470 *cp++ = i;
1471 }
1472 *cp = 0;
1473
1474 if (buffer[0] == 0)
1475 continue;
1476 if (buffer[0] == '?') {
1477 printf ("commands:\n");
1478 print_sw (ALL, sw, "");
1479 printf ("type CTRL-D or use ``quit'' to leave %s\n",
1480 invo_name);
1481 continue;
1482 }
1483
1484 if (parse (buffer, cmdp) == NOTOK)
1485 continue;
1486
1487 switch (i = smatch (cmdp->args[0], sw)) {
1488 case AMBIGSW:
1489 ambigsw (cmdp->args[0], sw);
1490 continue;
1491 case UNKWNSW:
1492 printf ("say what: ``%s'' -- type ? (or help) for help\n",
1493 cmdp->args[0]);
1494 continue;
1495 default:
1496 #ifdef BSD42
1497 should_intr = 0;
1498 #endif /* BSD42 */
1499 return i;
1500 }
1501 }
1502 }
1503
1504
1505 static int
1506 getcmds (struct swit *sw, struct Cmd *cmdp, int scansw)
1507 {
1508 int i;
1509 struct record rcs, *rc;
1510
1511 rc = &rcs;
1512 initrc (rc);
1513
1514 for (;;)
1515 switch (peer2rc (rc)) {
1516 case RC_QRY:
1517 pQRY (rc->rc_data, scansw);
1518 break;
1519
1520 case RC_CMD:
1521 if ((i = pCMD (rc->rc_data, sw, cmdp)) != NOTOK)
1522 return i;
1523 break;
1524
1525 case RC_FIN:
1526 if (ppid > 0)
1527 #ifdef SIGEMT
1528 kill (ppid, SIGEMT);
1529 #else
1530 kill (ppid, SIGTERM);
1531 #endif
1532 return EOF;
1533
1534 case RC_XXX:
1535 padios (NULL, "%s", rc->rc_data);
1536
1537 default:
1538 fmt2peer (RC_ERR, "pLOOP protocol screw-up");
1539 done (1);
1540 }
1541 }
1542
1543
1544 static int
1545 parse (char *buffer, struct Cmd *cmdp)
1546 {
1547 int argp = 0;
1548 char c, *cp, *pp;
1549
1550 cmdp->line[0] = 0;
1551 pp = cmdp->args[argp++] = cmdp->line;
1552 cmdp->redirect = NULL;
1553 cmdp->direction = STDIO;
1554 cmdp->stream = NULL;
1555
1556 for (cp = buffer; (c = *cp); cp++) {
1557 if (!isspace (c))
1558 break;
1559 }
1560 if (c == '\0') {
1561 if (vmh)
1562 fmt2peer (RC_EOF, "null command");
1563 return NOTOK;
1564 }
1565
1566 while ((c = *cp++)) {
1567 if (isspace (c)) {
1568 while (isspace (c))
1569 c = *cp++;
1570 if (c == 0)
1571 break;
1572 *pp++ = 0;
1573 cmdp->args[argp++] = pp;
1574 *pp = 0;
1575 }
1576
1577 switch (c) {
1578 case '"':
1579 for (;;) {
1580 switch (c = *cp++) {
1581 case 0:
1582 padvise (NULL, "unmatched \"");
1583 return NOTOK;
1584 case '"':
1585 break;
1586 case QUOTE:
1587 if ((c = *cp++) == 0)
1588 goto no_quoting;
1589 default:
1590 *pp++ = c;
1591 continue;
1592 }
1593 break;
1594 }
1595 continue;
1596
1597 case QUOTE:
1598 if ((c = *cp++) == 0) {
1599 no_quoting: ;
1600 padvise (NULL, "the newline character can not be quoted");
1601 return NOTOK;
1602 }
1603
1604 default: ;
1605 *pp++ = c;
1606 continue;
1607
1608 case '>':
1609 case '|':
1610 if (pp == cmdp->line) {
1611 padvise (NULL, "invalid null command");
1612 return NOTOK;
1613 }
1614 if (*cmdp->args[argp - 1] == 0)
1615 argp--;
1616 cmdp->direction = c == '>' ? CRTIO : PIPIO;
1617 if (cmdp->direction == CRTIO && (c = *cp) == '>') {
1618 cmdp->direction = APPIO;
1619 cp++;
1620 }
1621 cmdp->redirect = pp + 1;/* sigh */
1622 for (; (c = *cp); cp++)
1623 if (!isspace (c))
1624 break;
1625 if (c == 0) {
1626 padvise (NULL, cmdp->direction != PIPIO
1627 ? "missing name for redirect"
1628 : "invalid null command");
1629 return NOTOK;
1630 }
1631 strcpy (cmdp->redirect, cp);
1632 if (cmdp->direction != PIPIO) {
1633 for (; *cp; cp++)
1634 if (isspace (*cp)) {
1635 padvise (NULL, "bad name for redirect");
1636 return NOTOK;
1637 }
1638 if (expand (cmdp->redirect) == NOTOK)
1639 return NOTOK;
1640 }
1641 break;
1642 }
1643 break;
1644 }
1645
1646 *pp++ = 0;
1647 cmdp->args[argp] = NULL;
1648
1649 return OK;
1650 }
1651
1652
1653 int
1654 expand (char *redirect)
1655 {
1656 char *cp, *pp;
1657 char path[BUFSIZ];
1658 struct passwd *pw;
1659
1660 if (*redirect != '~')
1661 return OK;
1662
1663 if ((cp = strchr(pp = redirect + 1, '/')))
1664 *cp++ = 0;
1665 if (*pp == 0)
1666 pp = mypath;
1667 else
1668 if ((pw = getpwnam (pp)))
1669 pp = pw->pw_dir;
1670 else {
1671 padvise (NULL, "unknown user: %s", pp);
1672 return NOTOK;
1673 }
1674
1675 snprintf (path, sizeof(path), "%s/%s", pp, cp ? cp : "");
1676 strcpy (redirect, path);
1677 return OK;
1678 }
1679
1680
1681 static int
1682 init_io (struct Cmd *cmdp, int vio)
1683 {
1684 int io, result;
1685
1686 io = vmh;
1687
1688 vmh = vio;
1689 result = initaux_io (cmdp);
1690 vmh = io;
1691
1692 return result;
1693 }
1694
1695
1696 static int
1697 initaux_io (struct Cmd *cmdp)
1698 {
1699 char *mode;
1700
1701 switch (cmdp->direction) {
1702 case STDIO:
1703 return OK;
1704
1705 case CRTIO:
1706 case APPIO:
1707 mode = cmdp->direction == CRTIO ? "write" : "append";
1708 if ((cmdp->stream = fopen (cmdp->redirect, mode)) == NULL) {
1709 padvise (cmdp->redirect, "unable to %s ", mode);
1710 cmdp->direction = STDIO;
1711 return NOTOK;
1712 }
1713 break;
1714
1715 case PIPIO:
1716 if ((cmdp->stream = popen (cmdp->redirect, "w")) == NULL) {
1717 padvise (cmdp->redirect, "unable to pipe");
1718 cmdp->direction = STDIO;
1719 return NOTOK;
1720 }
1721 SIGNAL (SIGPIPE, pipeser);
1722 broken_pipe = 0;
1723 break;
1724
1725 default:
1726 padios (NULL, "unknown redirection for command");
1727 }
1728
1729 fflush (stdout);
1730 if (dup2 (fileno (cmdp->stream), fileno (stdout)) == NOTOK)
1731 padios ("standard output", "unable to dup2");
1732 clearerr (stdout);
1733
1734 return OK;
1735 }
1736
1737
1738 static void
1739 fin_io (struct Cmd *cmdp, int vio)
1740 {
1741 int io;
1742
1743 io = vmh;
1744 vmh = vio;
1745 finaux_io (cmdp);
1746 vmh = io;
1747 }
1748
1749
1750 static void
1751 finaux_io (struct Cmd *cmdp)
1752 {
1753 switch (cmdp->direction) {
1754 case STDIO:
1755 return;
1756
1757 case CRTIO:
1758 case APPIO:
1759 fflush (stdout);
1760 close (fileno (stdout));
1761 if (ferror (stdout))
1762 padvise (NULL, "problems writing %s", cmdp->redirect);
1763 fclose (cmdp->stream);
1764 break;
1765
1766 case PIPIO:
1767 fflush (stdout);
1768 close (fileno (stdout));
1769 pclose (cmdp->stream);
1770 SIGNAL (SIGPIPE, SIG_DFL);
1771 break;
1772
1773 default:
1774 padios (NULL, "unknown redirection for command");
1775 }
1776
1777 if (dup2 (fileno (sp), fileno (stdout)) == NOTOK)
1778 padios ("standard output", "unable to dup2");
1779 clearerr (stdout);
1780
1781 cmdp->direction = STDIO;
1782 }
1783
1784
1785 static void
1786 m_init (void)
1787 {
1788 int msgnum;
1789
1790 for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++)
1791 unset_selected (mp, msgnum);
1792 mp->lowsel = mp->hghsel = mp->numsel = 0;
1793 }
1794
1795
1796 void
1797 m_reset (void)
1798 {
1799 write_ids ();
1800 folder_free (mp); /* free folder/message structure */
1801 myname = NULL;
1802 #ifdef BPOP
1803 if (pmsh) {
1804 pop_done ();
1805 pmsh = 0;
1806 }
1807 #endif /* BPOP */
1808 }
1809
1810
1811 void
1812 seq_setcur (struct msgs *mp, int msgnum)
1813 {
1814 if (mp->curmsg == msgnum)
1815 return;
1816
1817 if (mp->curmsg && Msgs[mp->curmsg].m_scanl) {
1818 free (Msgs[mp->curmsg].m_scanl);
1819 Msgs[mp->curmsg].m_scanl = NULL;
1820 }
1821 if (Msgs[msgnum].m_scanl) {
1822 free (Msgs[msgnum].m_scanl);
1823 Msgs[msgnum].m_scanl = NULL;
1824 }
1825
1826 mp->curmsg = msgnum;
1827 }
1828
1829
1830
1831 static RETSIGTYPE
1832 intrser (int i)
1833 {
1834 #ifndef RELIABLE_SIGNALS
1835 SIGNAL (SIGINT, intrser);
1836 #endif
1837
1838 discard (stdout);
1839 interrupted++;
1840
1841 #ifdef BSD42
1842 if (should_intr)
1843 longjmp (sigenv, NOTOK);
1844 #endif
1845 }
1846
1847
1848 static RETSIGTYPE
1849 pipeser (int i)
1850 {
1851 #ifndef RELIABLE_SIGNALS
1852 SIGNAL (SIGPIPE, pipeser);
1853 #endif
1854
1855 if (broken_pipe++ == 0)
1856 fprintf (stderr, "broken pipe\n");
1857 told_to_quit++;
1858 interrupted++;
1859
1860 #ifdef BSD42
1861 if (should_intr)
1862 longjmp (sigenv, NOTOK);
1863 #endif
1864 }
1865
1866
1867 static RETSIGTYPE
1868 quitser (int i)
1869 {
1870 #ifndef RELIABLE_SIGNALS
1871 SIGNAL (SIGQUIT, quitser);
1872 #endif
1873
1874 told_to_quit++;
1875 interrupted++;
1876
1877 #ifdef BSD42
1878 if (should_intr)
1879 longjmp (sigenv, NOTOK);
1880 #endif
1881 }
1882
1883
1884 static RETSIGTYPE
1885 alrmser (int i)
1886 {
1887 longjmp (peerenv, DONE);
1888 }
1889
1890
1891 static int
1892 pINI (void)
1893 {
1894 int i, vrsn;
1895 char *bp;
1896 struct record rcs, *rc;
1897
1898 rc = &rcs;
1899 initrc (rc);
1900
1901 switch (peer2rc (rc)) {
1902 case RC_INI:
1903 bp = rc->rc_data;
1904 while (isspace (*bp))
1905 bp++;
1906 if (sscanf (bp, "%d", &vrsn) != 1) {
1907 bad_init: ;
1908 fmt2peer (RC_ERR, "bad init \"%s\"", rc->rc_data);
1909 done (1);
1910 }
1911 if (vrsn != RC_VRSN) {
1912 fmt2peer (RC_ERR, "version %d unsupported", vrsn);
1913 done (1);
1914 }
1915
1916 while (*bp && !isspace (*bp))
1917 bp++;
1918 while (isspace (*bp))
1919 bp++;
1920 if (sscanf (bp, "%d", &numwins) != 1 || numwins <= 0)
1921 goto bad_init;
1922 if (numwins > NWIN)
1923 numwins = NWIN;
1924
1925 for (i = 1; i <= numwins; i++) {
1926 while (*bp && !isspace (*bp))
1927 bp++;
1928 while (isspace (*bp))
1929 bp++;
1930 if (sscanf (bp, "%d", &windows[i]) != 1 || windows[i] <= 0)
1931 goto bad_init;
1932 }
1933 rc2peer (RC_ACK, 0, NULL);
1934 return OK;
1935
1936 case RC_XXX:
1937 padios (NULL, "%s", rc->rc_data);
1938
1939 default:
1940 fmt2peer (RC_ERR, "pINI protocol screw-up");
1941 done (1); /* NOTREACHED */
1942 }
1943
1944 return 1; /* dead code to satisfy the compiler */
1945 }
1946
1947
1948 static int
1949 pQRY (char *str, int scansw)
1950 {
1951 if (pQRY1 (scansw) == NOTOK || pQRY2 () == NOTOK)
1952 return NOTOK;
1953
1954 rc2peer (RC_EOF, 0, NULL);
1955 return OK;
1956 }
1957
1958
1959 static int
1960 pQRY1 (int scansw)
1961 {
1962 int oldhgh;
1963 static int lastlow = 0,
1964 lastcur = 0,
1965 lasthgh = 0,
1966 lastnum = 0;
1967
1968 oldhgh = mp->hghmsg;
1969 if (check_folder (scansw) && oldhgh < mp->hghmsg) {
1970 switch (winX (STATUS)) {
1971 case NOTOK:
1972 return NOTOK;
1973
1974 case OK:
1975 printf ("new messages have arrived!");
1976 fflush (stdout);
1977 fflush (stderr);
1978 _exit (0); /* NOTREACHED */
1979
1980 default:
1981 lastlow = lastcur = lasthgh = lastnum = 0;
1982 break;
1983 }
1984
1985 switch (winX (DISPLAY)) {
1986 case NOTOK:
1987 return NOTOK;
1988
1989 case OK:
1990 scanrange (oldhgh + 1, mp->hghmsg);
1991 fflush (stdout);
1992 fflush (stderr);
1993 _exit (0); /* NOTREACHED */
1994
1995 default:
1996 break;
1997 }
1998 return OK;
1999 }
2000
2001 if (gap)
2002 switch (winX (STATUS)) {
2003 case NOTOK:
2004 return NOTOK;
2005
2006 case OK:
2007 printf ("%s: gap in ID:s, last seen %d, lowest present %d\n",
2008 myname ? myname : fmsh ? fmsh : mp->foldpath, gap - 1,
2009 readid (mp->lowmsg));
2010 fflush (stdout);
2011 fflush (stderr);
2012 _exit (0); /* NOTREACHED */
2013
2014 default:
2015 gap = 0;
2016 return OK;
2017 }
2018
2019 if (mp->lowmsg != lastlow
2020 || mp->curmsg != lastcur
2021 || mp->hghmsg != lasthgh
2022 || mp->nummsg != lastnum)
2023 switch (winX (STATUS)) {
2024 case NOTOK:
2025 return NOTOK;
2026
2027 case OK:
2028 foldcmd (NULL);
2029 fflush (stdout);
2030 fflush (stderr);
2031 _exit (0); /* NOTREACHED */
2032
2033 default:
2034 lastlow = mp->lowmsg;
2035 lastcur = mp->curmsg;
2036 lasthgh = mp->hghmsg;
2037 lastnum = mp->nummsg;
2038 return OK;
2039 }
2040
2041 return OK;
2042 }
2043
2044
2045 static int
2046 pQRY2 (void)
2047 {
2048 int i, j, k, msgnum, n;
2049 static int cur = 0,
2050 num = 0,
2051 lo = 0,
2052 hi = 0;
2053
2054 if (mp->nummsg == 0 && mp->nummsg != num)
2055 switch (winX (SCAN)) {
2056 case NOTOK:
2057 return NOTOK;
2058
2059 case OK:
2060 printf ("empty!");
2061 fflush (stdout);
2062 fflush (stderr);
2063 _exit (0); /* NOTREACHED */
2064
2065 default:
2066 num = mp->nummsg;
2067 return OK;
2068 }
2069 num = mp->nummsg;
2070
2071 i = 0;
2072 j = (k = windows[SCAN]) / 2;
2073 for (msgnum = mp->curmsg; msgnum <= mp->hghmsg; msgnum++)
2074 if (does_exist (mp, msgnum))
2075 i++;
2076 if (i-- > 0) {
2077 if (topcur)
2078 k = i >= k ? 1 : k - i;
2079 else
2080 k -= i > j ? j : i;
2081 }
2082
2083 i = j = 0;
2084 n = 1;
2085 for (msgnum = mp->curmsg; msgnum >= mp->lowmsg; msgnum--)
2086 if (does_exist (mp, msgnum)) {
2087 i = msgnum;
2088 if (j == 0)
2089 j = msgnum;
2090 if (n++ >= k)
2091 break;
2092 }
2093 for (msgnum = mp->curmsg + 1; msgnum <= mp->hghmsg; msgnum++)
2094 if (does_exist (mp, msgnum)) {
2095 if (i == 0)
2096 i = msgnum;
2097 j = msgnum;
2098 if (n++ >= windows[SCAN])
2099 break;
2100 }
2101 if (!topcur
2102 && lo > 0
2103 && hi > 0
2104 && does_exist (mp, lo)
2105 && does_exist (mp, hi)
2106 && (lo < mp->curmsg
2107 || (lo == mp->curmsg && lo == mp->lowmsg))
2108 && (mp->curmsg < hi
2109 || (hi == mp->curmsg && hi == mp->hghmsg))
2110 && hi - lo == j - i)
2111 i = lo, j = hi;
2112
2113 if (mp->curmsg != cur || modified)
2114 switch (winN (NULLCMD, SCAN, 0)) {
2115 case NOTOK:
2116 return NOTOK;
2117
2118 case OK:
2119 return OK;
2120
2121 default:
2122 scanrange (lo = i, hi = j);
2123 cur = mp->curmsg;
2124 winR (NULLCMD);
2125 return OK;
2126 }
2127
2128 return OK;
2129 }
2130
2131
2132 static int
2133 pCMD (char *str, struct swit *sw, struct Cmd *cmdp)
2134 {
2135 int i;
2136
2137 if (*str == '?')
2138 switch (winX (DISPLAY)) {
2139 case NOTOK:
2140 return NOTOK;
2141
2142 case OK:
2143 printf ("commands:\n");
2144 print_sw (ALL, sw, "");
2145 printf ("type ``quit'' to leave %s\n", invo_name);
2146 fflush (stdout);
2147 fflush (stderr);
2148 _exit (0); /* NOTREACHED */
2149
2150 default:
2151 rc2peer (RC_EOF, 0, NULL);
2152 return NOTOK;
2153 }
2154
2155 if (parse (str, cmdp) == NOTOK)
2156 return NOTOK;
2157
2158 switch (i = smatch (cmdp->args[0], sw)) {
2159 case AMBIGSW:
2160 switch (winX (DISPLAY)) {
2161 case NOTOK:
2162 return NOTOK;
2163
2164 case OK:
2165 ambigsw (cmdp->args[0], sw);
2166 fflush (stdout);
2167 fflush (stderr);
2168 _exit (0); /* NOTREACHED */
2169
2170 default:
2171 rc2peer (RC_EOF, 0, NULL);
2172 return NOTOK;
2173 }
2174
2175 case UNKWNSW:
2176 fmt2peer (RC_ERR,
2177 "say what: ``%s'' -- type ? (or help) for help",
2178 cmdp->args[0]);
2179 return NOTOK;
2180
2181 default:
2182 return i;
2183 }
2184 }
2185
2186
2187 static int
2188 pFIN (void)
2189 {
2190 int status;
2191
2192 switch (setjmp (peerenv)) {
2193 case OK:
2194 SIGNAL (SIGALRM, alrmser);
2195 alarm (ALARM);
2196
2197 status = peerwait ();
2198
2199 alarm (0);
2200 return status;
2201
2202 default:
2203 return NOTOK;
2204 }
2205 }
2206
2207
2208 static int
2209 peerwait (void)
2210 {
2211 struct record rcs, *rc;
2212
2213 rc = &rcs;
2214 initrc (rc);
2215
2216 switch (peer2rc (rc)) {
2217 case RC_QRY:
2218 case RC_CMD:
2219 rc2peer (RC_FIN, 0, NULL);
2220 return OK;
2221
2222 case RC_XXX:
2223 advise (NULL, "%s", rc->rc_data);
2224 return NOTOK;
2225
2226 default:
2227 fmt2peer (RC_FIN, "pLOOP protocol screw-up");
2228 return NOTOK;
2229 }
2230 }
2231
2232
2233 static int
2234 ttyNaux (struct Cmd *cmdp, char *s)
2235 {
2236 struct record rcs, *rc;
2237
2238 rc = &rcs;
2239 initrc (rc);
2240
2241 if (cmdp && init_io (cmdp, vmh) == NOTOK)
2242 return NOTOK;
2243
2244 /* XXX: fseek() too tricky for our own good */
2245 if (!fmsh)
2246 fseek (fp, 0L, SEEK_SET);
2247
2248 vmhtty = NOTOK;
2249 switch (rc2rc (RC_TTY, s ? strlen (s) : 0, s, rc)) {
2250 case RC_ACK:
2251 vmhtty = OK; /* fall */
2252 case RC_ERR:
2253 break;
2254
2255 case RC_XXX:
2256 padios (NULL, "%s", rc->rc_data);/* NOTREACHED */
2257
2258 default:
2259 fmt2peer (RC_ERR, "pTTY protocol screw-up");
2260 done (1); /* NOTREACHED */
2261 }
2262
2263 #ifdef SIGTSTP
2264 SIGNAL (SIGTSTP, tstat);
2265 #endif
2266 return vmhtty;
2267 }
2268
2269
2270 static int
2271 ttyR (struct Cmd *cmdp)
2272 {
2273 struct record rcs, *rc;
2274
2275 rc = &rcs;
2276
2277 #ifdef SIGTSTP
2278 SIGNAL (SIGTSTP, SIG_IGN);
2279 #endif
2280
2281 if (vmhtty != OK)
2282 return NOTOK;
2283
2284 initrc (rc);
2285
2286 if (cmdp)
2287 fin_io (cmdp, 0);
2288
2289 vmhtty = NOTOK;
2290 switch (rc2rc (RC_EOF, 0, NULL, rc)) {
2291 case RC_ACK:
2292 rc2peer (RC_EOF, 0, NULL);
2293 return OK;
2294
2295 case RC_XXX:
2296 padios (NULL, "%s", rc->rc_data);/* NOTREACHED */
2297
2298 default:
2299 fmt2peer (RC_ERR, "pTTY protocol screw-up");
2300 done (1); /* NOTREACHED */
2301 }
2302
2303 return 1; /* dead code to satisfy compiler */
2304 }
2305
2306
2307 static int
2308 winN (struct Cmd *cmdp, int n, int eof)
2309 {
2310 int i, pd[2];
2311 char buffer[BUFSIZ];
2312 struct record rcs, *rc;
2313
2314 rc = &rcs;
2315 if (vmhpid == NOTOK)
2316 return OK;
2317
2318 initrc (rc);
2319
2320 /* XXX: fseek() too tricky for our own good */
2321 if (!fmsh)
2322 fseek (fp, 0L, SEEK_SET);
2323
2324 vmhpid = OK;
2325
2326 snprintf (buffer, sizeof(buffer), "%d", n);
2327 switch (str2rc (RC_WIN, buffer, rc)) {
2328 case RC_ACK:
2329 break;
2330
2331 case RC_ERR:
2332 return NOTOK;
2333
2334 case RC_XXX:
2335 padios (NULL, "%s", rc->rc_data);
2336
2337 default:
2338 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2339 done (1);
2340 }
2341
2342 if (pipe (pd) == NOTOK) {
2343 err2peer (RC_ERR, "pipe", "unable to");
2344 return NOTOK;
2345 }
2346
2347 switch (vmhpid = fork()) {
2348 case NOTOK:
2349 err2peer (RC_ERR, "fork", "unable to");
2350 close (pd[0]);
2351 close (pd[1]);
2352 return NOTOK;
2353
2354 case OK:
2355 close (pd[1]);
2356 SIGNAL (SIGPIPE, SIG_IGN);
2357 while ((i = read (pd[0], buffer, sizeof buffer)) > 0)
2358 switch (rc2rc (RC_DATA, i, buffer, rc)) {
2359 case RC_ACK:
2360 break;
2361
2362 case RC_ERR:
2363 _exit (1);
2364
2365 case RC_XXX:
2366 advise (NULL, "%s", rc->rc_data);
2367 _exit (2);
2368
2369 default:
2370 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2371 _exit (2);
2372 }
2373 if (i == OK)
2374 switch (rc2rc (RC_EOF, 0, NULL, rc)) {
2375 case RC_ACK:
2376 if (eof)
2377 rc2peer (RC_EOF, 0, NULL);
2378 i = 0;
2379 break;
2380
2381 case RC_XXX:
2382 advise (NULL, "%s", rc->rc_data);
2383 i = 2;
2384 break;
2385
2386 default:
2387 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2388 i = 2;
2389 break;
2390 }
2391 if (i == NOTOK)
2392 err2peer (RC_ERR, "pipe", "error reading from");
2393 close (pd[0]);
2394 _exit (i != NOTOK ? i : 1);
2395
2396 default:
2397 if ((vmhfd0 = dup (fileno (stdin))) == NOTOK)
2398 padios ("standard input", "unable to dup");
2399 if ((vmhfd1 = dup (fileno (stdout))) == NOTOK)
2400 padios ("standard output", "unable to dup");
2401 if ((vmhfd2 = dup (fileno (stderr))) == NOTOK)
2402 padios ("diagnostic output", "unable to dup");
2403
2404 close (0);
2405 if ((i = open ("/dev/null", O_RDONLY)) != NOTOK && i != fileno (stdin)) {
2406 dup2 (i, fileno (stdin));
2407 close (i);
2408 }
2409
2410 fflush (stdout);
2411 if (dup2 (pd[1], fileno (stdout)) == NOTOK)
2412 padios ("standard output", "unable to dup2");
2413 clearerr (stdout);
2414
2415 fflush (stderr);
2416 if (dup2 (pd[1], fileno (stderr)) == NOTOK)
2417 padios ("diagnostic output", "unable to dup2");
2418 clearerr (stderr);
2419
2420 if (cmdp && init_io (cmdp, 0) == NOTOK)
2421 return NOTOK;
2422 pstat = SIGNAL (SIGPIPE, pipeser);
2423 broken_pipe = 1;
2424
2425 close (pd[0]);
2426 close (pd[1]);
2427
2428 return vmhpid;
2429 }
2430 }
2431
2432
2433 static int
2434 winR (struct Cmd *cmdp)
2435 {
2436 int status;
2437
2438 if (vmhpid <= OK)
2439 return NOTOK;
2440
2441 if (cmdp)
2442 fin_io (cmdp, 0);
2443
2444 if (dup2 (vmhfd0, fileno (stdin)) == NOTOK)
2445 padios ("standard input", "unable to dup2");
2446 clearerr (stdin);
2447 close (vmhfd0);
2448
2449 fflush (stdout);
2450 if (dup2 (vmhfd1, fileno (stdout)) == NOTOK)
2451 padios ("standard output", "unable to dup2");
2452 clearerr (stdout);
2453 close (vmhfd1);
2454
2455 fflush (stderr);
2456 if (dup2 (vmhfd2, fileno (stderr)) == NOTOK)
2457 padios ("diagnostic output", "unable to dup2");
2458 clearerr (stderr);
2459 close (vmhfd2);
2460
2461 SIGNAL (SIGPIPE, pstat);
2462
2463 if ((status = pidwait (vmhpid, OK)) == 2)
2464 done (1);
2465
2466 vmhpid = OK;
2467 return (status == 0 ? OK : NOTOK);
2468 }
2469
2470
2471 static int
2472 winX (int n)
2473 {
2474 int i, pid, pd[2];
2475 char buffer[BUFSIZ];
2476 struct record rcs, *rc;
2477
2478 rc = &rcs;
2479 initrc (rc);
2480
2481 /* XXX: fseek() too tricky for our own good */
2482 if (!fmsh)
2483 fseek (fp, 0L, SEEK_SET);
2484
2485 snprintf (buffer, sizeof(buffer), "%d", n);
2486 switch (str2rc (RC_WIN, buffer, rc)) {
2487 case RC_ACK:
2488 break;
2489
2490 case RC_ERR:
2491 return NOTOK;
2492
2493 case RC_XXX:
2494 padios (NULL, "%s", rc->rc_data);
2495
2496 default:
2497 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2498 done (1);
2499 }
2500
2501 if (pipe (pd) == NOTOK) {
2502 err2peer (RC_ERR, "pipe", "unable to");
2503 return NOTOK;
2504 }
2505
2506 switch (pid = fork ()) {
2507 case NOTOK:
2508 err2peer (RC_ERR, "fork", "unable to");
2509 close (pd[0]);
2510 close (pd[1]);
2511 return NOTOK;
2512
2513 case OK:
2514 close (fileno (stdin));
2515 if ((i = open ("/dev/null", O_RDONLY)) != NOTOK && i != fileno (stdin)) {
2516 dup2 (i, fileno (stdin));
2517 close (i);
2518 }
2519 dup2 (pd[1], fileno (stdout));
2520 dup2 (pd[1], fileno (stderr));
2521 close (pd[0]);
2522 close (pd[1]);
2523 vmhpid = NOTOK;
2524 return OK;
2525
2526 default:
2527 close (pd[1]);
2528 while ((i = read (pd[0], buffer, sizeof buffer)) > 0)
2529 switch (rc2rc (RC_DATA, i, buffer, rc)) {
2530 case RC_ACK:
2531 break;
2532
2533 case RC_ERR:
2534 close (pd[0]);
2535 pidwait (pid, OK);
2536 return NOTOK;
2537
2538 case RC_XXX:
2539 padios (NULL, "%s", rc->rc_data);
2540
2541 default:
2542 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2543 done (1);
2544 }
2545 if (i == OK)
2546 switch (rc2rc (RC_EOF, 0, NULL, rc)) {
2547 case RC_ACK:
2548 break;
2549
2550 case RC_XXX:
2551 padios (NULL, "%s", rc->rc_data);
2552
2553 default:
2554 fmt2peer (RC_ERR, "pWIN protocol screw-up");
2555 done (1);
2556 }
2557 if (i == NOTOK)
2558 err2peer (RC_ERR, "pipe", "error reading from");
2559
2560 close (pd[0]);
2561 pidwait (pid, OK);
2562 return (i != NOTOK ? pid : NOTOK);
2563 }
2564 }
2565
2566
2567 void
2568 padios (char *what, char *fmt, ...)
2569 {
2570 va_list ap;
2571
2572 va_start(ap, fmt);
2573 if (vmh) {
2574 verr2peer (RC_FIN, what, fmt, ap);
2575 rcdone ();
2576 } else {
2577 advertise (what, NULL, fmt, ap);
2578 }
2579 va_end(ap);
2580
2581 done (1);
2582 }
2583
2584
2585 void
2586 padvise (char *what, char *fmt, ...)
2587 {
2588 va_list ap;
2589
2590 va_start(ap, fmt);
2591 if (vmh) {
2592 verr2peer (RC_ERR, what, fmt, ap);
2593 } else {
2594 advertise (what, NULL, fmt, ap);
2595 }
2596 va_end(ap);
2597 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git