]> diplodocus.org Git - nmh/blob - uip/mshcmds.c
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix stupid accidental dependence on a bash quirk in previous
[nmh] / uip / mshcmds.c
1
2 /*
3 * mshcmds.c -- command handlers in msh
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 #include <h/mh.h>
13 #include <h/signals.h>
14 #include <h/dropsbr.h>
15 #include <h/fmt_scan.h>
16 #include <h/scansbr.h>
17 #include <h/tws.h>
18 #include <h/mts.h>
19 #include <errno.h>
20 #include <setjmp.h>
21 #include <signal.h>
22 #include <h/msh.h>
23 #include <h/picksbr.h>
24
25
26 static char delim3[] = "-------"; /* from burst.c */
27
28 static int mhlnum;
29 static FILE *mhlfp;
30
31 #if defined(NNTP) && defined(MPOP)
32 # undef MPOP
33 #endif
34
35 #ifdef MPOP
36 # ifdef BPOP
37 extern int pmsh;
38 extern char response[];
39 # endif
40 #endif /* MPOP */
41
42 /*
43 * Type for a compare function for qsort. This keeps
44 * the compiler happy.
45 */
46 typedef int (*qsort_comp) (const void *, const void *);
47
48 /*
49 * prototypes
50 */
51 void clear_screen (void); /* from termsbr.c */
52 int SOprintf (char *, ...); /* from termsbr.c */
53 int sc_width (void); /* from termsbr.c */
54
55 /*
56 * static prototypes
57 */
58 static int burst (struct Msg *, int, int, int, int);
59 static void forw (char *, char *, int, char **);
60 static void rmm (void);
61 static void show (int);
62 static int eom_action (int);
63 static FILE *mhl_action (char *);
64 static int ask (int);
65 static int is_nontext (int);
66 static int get_fields (char *, char *, int, struct Msg *);
67 static int msgsort (struct Msg *, struct Msg *);
68 static int subsort (struct Msg *, struct Msg *);
69 static char *sosmash (char *, char *);
70 static int process (int, char *, int, char **);
71 static void copy_message (int, FILE *);
72 static void copy_digest (int, FILE *);
73
74 /* from mhlsbr.c */
75 int mhlsbr (int, char **, FILE *(*)());
76
77 void
78 forkcmd (char **args, char *pgm)
79 {
80 int child_id;
81 char *vec[MAXARGS];
82
83 vec[0] = r1bindex (pgm, '/');
84 copyip (args, vec + 1, MAXARGS - 1);
85
86 if (fmsh) {
87 context_del (pfolder);
88 context_replace (pfolder, fmsh);/* update current folder */
89 seq_save (mp);
90 context_save (); /* save the context file */
91 }
92 fflush (stdout);
93 switch (child_id = fork ()) {
94 case NOTOK:
95 advise ("fork", "unable to");
96 return;
97
98 case OK:
99 closefds (3);
100 SIGNAL (SIGINT, istat);
101 SIGNAL (SIGQUIT, qstat);
102
103 execvp (pgm, vec);
104 fprintf (stderr, "unable to exec ");
105 perror (cmd_name);
106 _exit (1);
107
108 default:
109 pidXwait (child_id, NULL);
110 break;
111 }
112 if (fmsh) { /* assume the worst case */
113 mp->msgflags |= MODIFIED;
114 modified++;
115 }
116 }
117
118
119 static struct swit distswit[] = {
120 #define DIANSW 0
121 { "annotate", 0 },
122 #define DINANSW 1
123 { "noannotate", 0 },
124 #define DIDFSW 2
125 { "draftfolder +folder", 0 },
126 #define DIDMSW 3
127 { "draftmessage msg", 0 },
128 #define DINDFSW 4
129 { "nodraftfolder", 0 },
130 #define DIEDTSW 5
131 { "editor editor", 0 },
132 #define DINEDSW 6
133 { "noedit", 0 },
134 #define DIFRMSW 7
135 { "form formfile", 0 },
136 #define DIINSW 8
137 { "inplace", 0 },
138 #define DININSW 9
139 { "noinplace", 0 },
140 #define DIWHTSW 10
141 { "whatnowproc program", 0 },
142 #define DINWTSW 11
143 { "nowhatnowproc", 0 },
144 #define DIHELP 12
145 { "help", 0 },
146 { NULL, 0 }
147 };
148
149
150 void
151 distcmd (char **args)
152 {
153 int vecp = 1;
154 char *cp, *msg = NULL;
155 char buf[BUFSIZ], *vec[MAXARGS];
156
157 if (fmsh) {
158 forkcmd (args, cmd_name);
159 return;
160 }
161
162 while ((cp = *args++)) {
163 if (*cp == '-')
164 switch (smatch (++cp, distswit)) {
165 case AMBIGSW:
166 ambigsw (cp, distswit);
167 return;
168 case UNKWNSW:
169 fprintf (stderr, "-%s unknown\n", cp);
170 return;
171 case DIHELP:
172 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
173 print_help (buf, distswit, 1);
174 return;
175
176 case DIANSW: /* not implemented */
177 case DINANSW:
178 case DIINSW:
179 case DININSW:
180 continue;
181
182 case DINDFSW:
183 case DINEDSW:
184 case DINWTSW:
185 vec[vecp++] = --cp;
186 continue;
187
188 case DIEDTSW:
189 case DIFRMSW:
190 case DIDFSW:
191 case DIDMSW:
192 case DIWHTSW:
193 vec[vecp++] = --cp;
194 if (!(cp = *args++) || *cp == '-') {
195 advise (NULL, "missing argument to %s", args[-2]);
196 return;
197 }
198 vec[vecp++] = cp;
199 continue;
200 }
201 if (*cp == '+' || *cp == '@') {
202 advise (NULL, "sorry, no folders allowed!");
203 return;
204 }
205 else
206 if (msg) {
207 advise (NULL, "only one message at a time!");
208 return;
209 }
210 else
211 msg = cp;
212 }
213
214 vec[0] = cmd_name;
215 vec[vecp++] = "-file";
216 vec[vecp] = NULL;
217 if (!msg)
218 msg = "cur";
219 if (!m_convert (mp, msg))
220 return;
221 seq_setprev (mp);
222
223 if (mp->numsel > 1) {
224 advise (NULL, "only one message at a time!");
225 return;
226 }
227 process (mp->hghsel, cmd_name, vecp, vec);
228 seq_setcur (mp, mp->hghsel);
229 }
230
231
232 static struct swit explswit[] = {
233 #define EXINSW 0
234 { "inplace", 0 },
235 #define EXNINSW 1
236 { "noinplace", 0 },
237 #define EXQISW 2
238 { "quiet", 0 },
239 #define EXNQISW 3
240 { "noquiet", 0 },
241 #define EXVBSW 4
242 { "verbose", 0 },
243 #define EXNVBSW 5
244 { "noverbose", 0 },
245 #define EXHELP 6
246 { "help", 0 },
247 { NULL, 0 }
248 };
249
250
251 void
252 explcmd (char **args)
253 {
254 int inplace = 0, quietsw = 0, verbosw = 0;
255 int msgp = 0, hi, msgnum;
256 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
257 struct Msg *smsgs;
258
259 if (fmsh) {
260 forkcmd (args, cmd_name);
261 return;
262 }
263
264 while ((cp = *args++)) {
265 if (*cp == '-')
266 switch (smatch (++cp, explswit)) {
267 case AMBIGSW:
268 ambigsw (cp, explswit);
269 return;
270 case UNKWNSW:
271 fprintf (stderr, "-%s unknown\n", cp);
272 return;
273 case EXHELP:
274 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
275 print_help (buf, explswit, 1);
276 return;
277
278 case EXINSW:
279 inplace++;
280 continue;
281 case EXNINSW:
282 inplace = 0;
283 continue;
284 case EXQISW:
285 quietsw++;
286 continue;
287 case EXNQISW:
288 quietsw = 0;
289 continue;
290 case EXVBSW:
291 verbosw++;
292 continue;
293 case EXNVBSW:
294 verbosw = 0;
295 continue;
296 }
297 if (*cp == '+' || *cp == '@') {
298 advise (NULL, "sorry, no folders allowed!");
299 return;
300 }
301 else
302 msgs[msgp++] = cp;
303 }
304
305 if (!msgp)
306 msgs[msgp++] = "cur";
307 for (msgnum = 0; msgnum < msgp; msgnum++)
308 if (!m_convert (mp, msgs[msgnum]))
309 return;
310 seq_setprev (mp);
311
312 smsgs = (struct Msg *)
313 calloc ((size_t) (MAXFOLDER + 2), sizeof *smsgs);
314 if (smsgs == NULL)
315 adios (NULL, "unable to allocate folder storage");
316
317 hi = mp->hghmsg + 1;
318 interrupted = 0;
319 for (msgnum = mp->lowsel;
320 msgnum <= mp->hghsel && !interrupted;
321 msgnum++)
322 if (is_selected (mp, msgnum))
323 if (burst (smsgs, msgnum, inplace, quietsw, verbosw) != OK)
324 break;
325
326 free ((char *) smsgs);
327
328 if (inplace)
329 seq_setcur (mp, mp->lowsel);
330 else
331 if (hi <= mp->hghmsg)
332 seq_setcur (mp, hi);
333
334 mp->msgflags |= MODIFIED;
335 modified++;
336 }
337
338
339 static int
340 burst (struct Msg *smsgs, int msgnum, int inplace, int quietsw, int verbosw)
341 {
342 int i, j, ld3, wasdlm, msgp;
343 long pos;
344 char c, buffer[BUFSIZ];
345 register FILE *zp;
346
347 ld3 = strlen (delim3);
348
349 if (Msgs[msgnum].m_scanl) {
350 free (Msgs[msgnum].m_scanl);
351 Msgs[msgnum].m_scanl = NULL;
352 }
353
354 pos = ftell (zp = msh_ready (msgnum, 1));
355 for (msgp = 0; msgp <= MAXFOLDER;) {
356 while (fgets (buffer, sizeof buffer, zp) != NULL
357 && buffer[0] == '\n'
358 && pos < Msgs[msgnum].m_stop)
359 pos += (long) strlen (buffer);
360 if (feof (zp) || pos >= Msgs[msgnum].m_stop)
361 break;
362 fseek (zp, pos, SEEK_SET);
363 smsgs[msgp].m_start = pos;
364
365 for (c = 0;
366 pos < Msgs[msgnum].m_stop
367 && fgets (buffer, sizeof buffer, zp) != NULL;
368 c = buffer[0])
369 if (strncmp (buffer, delim3, ld3) == 0
370 && (msgp == 1 || c == '\n')
371 && peekc (zp) == '\n')
372 break;
373 else
374 pos += (long) strlen (buffer);
375
376 wasdlm = strncmp (buffer, delim3, ld3) == 0;
377 if (smsgs[msgp].m_start != pos)
378 smsgs[msgp++].m_stop = (c == '\n' && wasdlm) ? pos - 1 : pos;
379 if (feof (zp) || pos >= Msgs[msgnum].m_stop) {
380 if (wasdlm)
381 smsgs[msgp - 1].m_stop -= ((long) strlen (buffer) + 1);
382 break;
383 }
384 pos += (long) strlen (buffer);
385 }
386
387 switch (msgp--) { /* toss "End of XXX Digest" */
388 case 0:
389 adios (NULL, "burst() botch -- you lose big");
390
391 case 1:
392 if (!quietsw)
393 printf ("message %d not in digest format\n", msgnum);
394 return OK;
395
396 default:
397 if (verbosw)
398 printf ("%d message%s exploded from digest %d\n",
399 msgp, msgp != 1 ? "s" : "", msgnum);
400 break;
401 }
402
403 if ((i = msgp + mp->hghmsg) > MAXFOLDER) {
404 advise (NULL, "more than %d messages", MAXFOLDER);
405 return NOTOK;
406 }
407 if (!(mp = folder_realloc (mp, mp->lowoff, i)))
408 adios (NULL, "unable to allocate folder storage");
409
410 j = mp->hghmsg;
411 mp->hghmsg += msgp;
412 mp->nummsg += msgp;
413 if (mp->hghsel > msgnum)
414 mp->hghsel += msgp;
415
416 if (inplace)
417 for (i = mp->hghmsg; j > msgnum; i--, j--) {
418 if (verbosw)
419 printf ("message %d becomes message %d\n", j, i);
420
421 Msgs[i].m_bboard_id = Msgs[j].m_bboard_id;
422 Msgs[i].m_top = Msgs[j].m_top;
423 Msgs[i].m_start = Msgs[j].m_start;
424 Msgs[i].m_stop = Msgs[j].m_stop;
425 Msgs[i].m_scanl = NULL;
426 if (Msgs[j].m_scanl) {
427 free (Msgs[j].m_scanl);
428 Msgs[j].m_scanl = NULL;
429 }
430 copy_msg_flags (mp, i, j);
431 }
432
433 if (Msgs[msgnum].m_bboard_id == 0)
434 readid (msgnum);
435
436 unset_selected (mp, msgnum);
437 i = inplace ? msgnum + msgp : mp->hghmsg;
438 for (j = msgp; j >= (inplace ? 0 : 1); i--, j--) {
439 if (verbosw && i != msgnum)
440 printf ("message %d of digest %d becomes message %d\n",
441 j, msgnum, i);
442
443 Msgs[i].m_bboard_id = Msgs[msgnum].m_bboard_id;
444 Msgs[i].m_top = Msgs[j].m_top;
445 Msgs[i].m_start = smsgs[j].m_start;
446 Msgs[i].m_stop = smsgs[j].m_stop;
447 Msgs[i].m_scanl = NULL;
448 copy_msg_flags (mp, i, msgnum);
449 }
450
451 return OK;
452 }
453
454
455 static struct swit fileswit[] = {
456 #define FIDRFT 0
457 { "draft", 0 },
458 #define FILINK 1
459 { "link", 0 },
460 #define FINLINK 2
461 { "nolink", 0 },
462 #define FIPRES 3
463 { "preserve", 0 },
464 #define FINPRES 4
465 { "nopreserve", 0 },
466 #define FISRC 5
467 { "src +folder", 0 },
468 #define FIFILE 6
469 { "file file", 0 },
470 #define FIPROC 7
471 { "rmmproc program", 0 },
472 #define FINPRC 8
473 { "normmproc", 0 },
474 #define FIHELP 9
475 { "help", 0 },
476 { NULL, 0 }
477 };
478
479
480 void
481 filecmd (char **args)
482 {
483 int linksw = 0, msgp = 0;
484 int vecp = 1, i, msgnum;
485 char *cp, buf[BUFSIZ];
486 char *msgs[MAXARGS], *vec[MAXARGS];
487
488 if (fmsh) {
489 forkcmd (args, cmd_name);
490 return;
491 }
492
493 while ((cp = *args++)) {
494 if (*cp == '-')
495 switch (i = smatch (++cp, fileswit)) {
496 case AMBIGSW:
497 ambigsw (cp, fileswit);
498 return;
499 case UNKWNSW:
500 fprintf (stderr, "-%s unknown\n", cp);
501 return;
502 case FIHELP:
503 snprintf (buf, sizeof(buf), "%s +folder... [msgs] [switches]", cmd_name);
504 print_help (buf, fileswit, 1);
505 return;
506
507 case FILINK:
508 linksw++;
509 continue;
510 case FINLINK:
511 linksw = 0;
512 continue;
513
514 case FIPRES:
515 case FINPRES:
516 continue;
517
518 case FISRC:
519 case FIDRFT:
520 case FIFILE:
521 case FIPROC:
522 case FINPRC:
523 advise (NULL, "sorry, -%s not allowed!", fileswit[i].sw);
524 return;
525 }
526 if (*cp == '+' || *cp == '@')
527 vec[vecp++] = cp;
528 else
529 msgs[msgp++] = cp;
530 }
531
532 vec[0] = cmd_name;
533 vec[vecp++] = "-file";
534 vec[vecp] = NULL;
535 if (!msgp)
536 msgs[msgp++] = "cur";
537 for (msgnum = 0; msgnum < msgp; msgnum++)
538 if (!m_convert (mp, msgs[msgnum]))
539 return;
540 seq_setprev (mp);
541
542 interrupted = 0;
543 for (msgnum = mp->lowsel;
544 msgnum <= mp->hghsel && !interrupted;
545 msgnum++)
546 if (is_selected (mp, msgnum))
547 if (process (msgnum, fileproc, vecp, vec)) {
548 unset_selected (mp, msgnum);
549 mp->numsel--;
550 }
551
552 if (mp->numsel != mp->nummsg || linksw)
553 seq_setcur (mp, mp->hghsel);
554 if (!linksw)
555 rmm ();
556 }
557
558
559 int
560 filehak (char **args)
561 {
562 int result, vecp = 0;
563 char *cp, *cwd, *vec[MAXARGS];
564
565 while ((cp = *args++)) {
566 if (*cp == '-')
567 switch (smatch (++cp, fileswit)) {
568 case AMBIGSW:
569 case UNKWNSW:
570 case FIHELP:
571 return NOTOK;
572
573 case FILINK:
574 case FINLINK:
575 case FIPRES:
576 case FINPRES:
577 continue;
578
579 case FISRC:
580 case FIDRFT:
581 case FIFILE:
582 return NOTOK;
583 }
584 if (*cp == '+' || *cp == '@')
585 vec[vecp++] = cp;
586 }
587 vec[vecp] = NULL;
588
589 result = NOTOK;
590 cwd = NULL;
591 for (vecp = 0; (cp = vec[vecp]) && result == NOTOK; vecp++) {
592 if (cwd == NULL)
593 cwd = getcpy (pwd ());
594 chdir (m_maildir (""));
595 cp = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
596 if (access (m_maildir (cp), F_OK) == NOTOK)
597 result = OK;
598 free (cp);
599 }
600 if (cwd)
601 chdir (cwd);
602
603 return result;
604 }
605
606
607 static struct swit foldswit[] = {
608 #define FLALSW 0
609 { "all", 0 },
610 #define FLFASW 1
611 { "fast", 0 },
612 #define FLNFASW 2
613 { "nofast", 0 },
614 #define FLHDSW 3
615 { "header", 0 },
616 #define FLNHDSW 4
617 { "noheader", 0 },
618 #define FLPKSW 5
619 { "pack", 0 },
620 #define FLNPKSW 6
621 { "nopack", 0 },
622 #define FLRCSW 7
623 { "recurse", 0 },
624 #define FLNRCSW 8
625 { "norecurse", 0 },
626 #define FLTLSW 9
627 { "total", 0 },
628 #define FLNTLSW 10
629 { "nototal", 0 },
630 #define FLPRSW 11
631 { "print", 0 },
632 #define FLPUSW 12
633 { "push", 0 },
634 #define FLPOSW 13
635 { "pop", 0 },
636 #define FLLISW 14
637 { "list", 0 },
638 #define FLHELP 15
639 { "help", 0 },
640 { NULL, 0 }
641 };
642
643
644 void
645 foldcmd (char **args)
646 {
647 int fastsw = 0, headersw = 0, packsw = 0;
648 int hole, msgnum;
649 char *cp, *folder = NULL, *msg = NULL;
650 char buf[BUFSIZ], **vec = args;
651
652 if (args == NULL)
653 goto fast;
654
655 while ((cp = *args++)) {
656 if (*cp == '-')
657 switch (smatch (++cp, foldswit)) {
658 case AMBIGSW:
659 ambigsw (cp, foldswit);
660 return;
661 case UNKWNSW:
662 fprintf (stderr, "-%s unknown\n", cp);
663 return;
664 case FLHELP:
665 snprintf (buf, sizeof(buf), "%s [+folder] [msg] [switches]", cmd_name);
666 print_help (buf, foldswit, 1);
667 return;
668
669 case FLALSW: /* not implemented */
670 case FLRCSW:
671 case FLNRCSW:
672 case FLTLSW:
673 case FLNTLSW:
674 case FLPRSW:
675 case FLPUSW:
676 case FLPOSW:
677 case FLLISW:
678 continue;
679
680 case FLFASW:
681 fastsw++;
682 continue;
683 case FLNFASW:
684 fastsw = 0;
685 continue;
686 case FLHDSW:
687 headersw++;
688 continue;
689 case FLNHDSW:
690 headersw = 0;
691 continue;
692 case FLPKSW:
693 packsw++;
694 continue;
695 case FLNPKSW:
696 packsw = 0;
697 continue;
698 }
699 if (*cp == '+' || *cp == '@') {
700 if (folder) {
701 advise (NULL, "only one folder at a time!\n");
702 return;
703 }
704 else
705 folder = fmsh ? path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF)
706 : cp + 1;
707 }
708 else
709 if (msg) {
710 advise (NULL, "only one message at a time!\n");
711 return;
712 }
713 else
714 msg = cp;
715 }
716
717 if (folder) {
718 if (*folder == 0) {
719 advise (NULL, "null folder names are not permitted");
720 return;
721 }
722 if (fmsh) {
723 if (access (m_maildir (folder), R_OK) == NOTOK) {
724 advise (folder, "unable to read");
725 return;
726 }
727 }
728 else {
729 strncpy (buf, folder, sizeof(buf));
730 if (expand (buf) == NOTOK)
731 return;
732 folder = buf;
733 if (access (folder, R_OK) == NOTOK) {
734 advise (folder, "unable to read");
735 return;
736 }
737 }
738 m_reset ();
739
740 if (fmsh)
741 fsetup (folder);
742 else
743 setup (folder);
744 readids (0);
745 display_info (0);
746 }
747
748 if (msg) {
749 if (!m_convert (mp, msg))
750 return;
751 seq_setprev (mp);
752
753 if (mp->numsel > 1) {
754 advise (NULL, "only one message at a time!");
755 return;
756 }
757 seq_setcur (mp, mp->hghsel);
758 }
759
760 if (packsw) {
761 if (fmsh) {
762 forkcmd (vec, cmd_name);
763 return;
764 }
765
766 if (mp->lowoff > 1 && !(mp = folder_realloc (mp, 1, mp->hghmsg)))
767 adios (NULL, "unable to allocate folder storage");
768
769 for (msgnum = mp->lowmsg, hole = 1; msgnum <= mp->hghmsg; msgnum++)
770 if (does_exist (mp, msgnum)) {
771 if (msgnum != hole) {
772 Msgs[hole].m_bboard_id = Msgs[msgnum].m_bboard_id;
773 Msgs[hole].m_top = Msgs[msgnum].m_top;
774 Msgs[hole].m_start = Msgs[msgnum].m_start;
775 Msgs[hole].m_stop = Msgs[msgnum].m_stop;
776 Msgs[hole].m_scanl = NULL;
777 if (Msgs[msgnum].m_scanl) {
778 free (Msgs[msgnum].m_scanl);
779 Msgs[msgnum].m_scanl = NULL;
780 }
781 copy_msg_flags (mp, hole, msgnum);
782 if (mp->curmsg == msgnum)
783 seq_setcur (mp, hole);
784 }
785 hole++;
786 }
787 if (mp->nummsg > 0) {
788 mp->lowmsg = 1;
789 mp->hghmsg = hole - 1;
790 }
791 mp->msgflags |= MODIFIED;
792 modified++;
793 }
794
795 fast: ;
796 if (fastsw)
797 printf ("%s\n", fmsh ? fmsh : mp->foldpath);
798 else {
799 if (headersw)
800 printf ("\t\tFolder %*s# of messages (%*srange%*s); cur%*smsg\n",
801 DMAXFOLDER, "", DMAXFOLDER - 2, "", DMAXFOLDER - 2, "",
802 DMAXFOLDER - 2, "");
803 printf (args ? "%22s " : "%s ", fmsh ? fmsh : mp->foldpath);
804
805 /* check for empty folder */
806 if (mp->nummsg == 0) {
807 printf ("has no messages%*s",
808 mp->msgflags & OTHERS ? DMAXFOLDER * 2 + 4 : 0, "");
809 } else {
810 printf ("has %*d message%s (%*d-%*d)",
811 DMAXFOLDER, mp->nummsg, mp->nummsg != 1 ? "s" : "",
812 DMAXFOLDER, mp->lowmsg, DMAXFOLDER, mp->hghmsg);
813 if (mp->curmsg >= mp->lowmsg
814 && mp->curmsg <= mp->hghmsg)
815 printf ("; cur=%*d", DMAXFOLDER, mp->curmsg);
816 }
817 printf (".\n");
818 }
819 }
820
821
822 static struct swit forwswit[] = {
823 #define FOANSW 0
824 { "annotate", 0 },
825 #define FONANSW 1
826 { "noannotate", 0 },
827 #define FODFSW 2
828 { "draftfolder +folder", 0 },
829 #define FODMSW 3
830 { "draftmessage msg", 0 },
831 #define FONDFSW 4
832 { "nodraftfolder", 0 },
833 #define FOEDTSW 5
834 { "editor editor", 0 },
835 #define FONEDSW 6
836 { "noedit", 0 },
837 #define FOFTRSW 7
838 { "filter filterfile", 0 },
839 #define FOFRMSW 8
840 { "form formfile", 0 },
841 #define FOFTSW 9
842 { "format", 5 },
843 #define FONFTSW 10
844 { "noformat", 7 },
845 #define FOINSW 11
846 { "inplace", 0 },
847 #define FONINSW 12
848 { "noinplace", 0 },
849 #define FOMISW 13
850 { "mime", 0 },
851 #define FONMISW 14
852 { "nomime", 0 },
853 #define FOWHTSW 15
854 { "whatnowproc program", 0 },
855 #define FONWTSW 16
856 { "nowhatnow", 0 },
857 #define FOHELP 17
858 { "help", 0 },
859 { NULL, 0 }
860 };
861
862
863 void
864 forwcmd (char **args)
865 {
866 int msgp = 0, vecp = 1, msgnum;
867 char *cp, *filter = NULL, buf[BUFSIZ];
868 char *msgs[MAXARGS], *vec[MAXARGS];
869
870 if (fmsh) {
871 forkcmd (args, cmd_name);
872 return;
873 }
874
875 while ((cp = *args++)) {
876 if (*cp == '-')
877 switch (smatch (++cp, forwswit)) {
878 case AMBIGSW:
879 ambigsw (cp, forwswit);
880 return;
881 case UNKWNSW:
882 fprintf (stderr, "-%s unknown\n", cp);
883 return;
884 case FOHELP:
885 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
886 print_help (buf, forwswit, 1);
887 return;
888
889 case FOANSW: /* not implemented */
890 case FONANSW:
891 case FOINSW:
892 case FONINSW:
893 case FOMISW:
894 case FONMISW:
895 continue;
896
897 case FONDFSW:
898 case FONEDSW:
899 case FONWTSW:
900 vec[vecp++] = --cp;
901 continue;
902
903 case FOEDTSW:
904 case FOFRMSW:
905 case FODFSW:
906 case FODMSW:
907 case FOWHTSW:
908 vec[vecp++] = --cp;
909 if (!(cp = *args++) || *cp == '-') {
910 advise (NULL, "missing argument to %s", args[-2]);
911 return;
912 }
913 vec[vecp++] = cp;
914 continue;
915 case FOFTRSW:
916 if (!(filter = *args++) || *filter == '-') {
917 advise (NULL, "missing argument to %s", args[-2]);
918 return;
919 }
920 continue;
921 case FOFTSW:
922 if (access (filter = myfilter, R_OK) == NOTOK) {
923 advise (filter, "unable to read default filter file");
924 return;
925 }
926 continue;
927 case FONFTSW:
928 filter = NULL;
929 continue;
930 }
931 if (*cp == '+' || *cp == '@') {
932 advise (NULL, "sorry, no folders allowed!");
933 return;
934 }
935 else
936 msgs[msgp++] = cp;
937 }
938
939 /* foil search of .mh_profile */
940 snprintf (buf, sizeof(buf), "%sXXXXXX", invo_name);
941 /*
942 Mkstemp work postponed until later -Doug
943 #ifdef HAVE_MKSTEMP
944 vec[0] = (char *)mkstemp (buf);
945 #else
946 */
947 vec[0] = (char *)mktemp (buf);
948 /*
949 #endif
950 */
951 vec[vecp++] = "-file";
952 vec[vecp] = NULL;
953 if (!msgp)
954 msgs[msgp++] = "cur";
955 for (msgnum = 0; msgnum < msgp; msgnum++)
956 if (!m_convert (mp, msgs[msgnum]))
957 return;
958 seq_setprev (mp);
959
960 if (filter) {
961 strncpy (buf, filter, sizeof(buf));
962 if (expand (buf) == NOTOK)
963 return;
964 if (access (filter = getcpy (etcpath (buf)), R_OK) == NOTOK) {
965 advise (filter, "unable to read");
966 free (filter);
967 return;
968 }
969 }
970 forw (cmd_name, filter, vecp, vec);
971 seq_setcur (mp, mp->hghsel);
972 if (filter)
973 free (filter);
974 }
975
976
977 static void
978 forw (char *proc, char *filter, int vecp, char **vec)
979 {
980 int i, child_id, msgnum, msgcnt;
981 char tmpfil[80], *args[MAXARGS];
982 FILE *out;
983
984 strncpy (tmpfil, m_tmpfil (invo_name), sizeof(tmpfil));
985 interrupted = 0;
986 if (filter)
987 switch (child_id = fork ()) {
988 case NOTOK:
989 advise ("fork", "unable to");
990 return;
991
992 case OK: /* "trust me" */
993 if (freopen (tmpfil, "w", stdout) == NULL) {
994 fprintf (stderr, "unable to create ");
995 perror (tmpfil);
996 _exit (1);
997 }
998 args[0] = r1bindex (mhlproc, '/');
999 i = 1;
1000 args[i++] = "-forwall";
1001 args[i++] = "-form";
1002 args[i++] = filter;
1003 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1004 if (is_selected (mp, msgnum))
1005 args[i++] = getcpy (m_name (msgnum));
1006 args[i] = NULL;
1007 mhlsbr (i, args, mhl_action);
1008 m_eomsbr ((int (*) ()) 0);
1009 fclose (stdout);
1010 _exit (0);
1011
1012 default:
1013 if (pidXwait (child_id, NULL))
1014 interrupted++;
1015 break;
1016 }
1017 else {
1018 if ((out = fopen (tmpfil, "w")) == NULL) {
1019 advise (tmpfil, "unable to create temporary file");
1020 return;
1021 }
1022
1023 msgcnt = 1;
1024 for (msgnum = mp->lowsel;
1025 msgnum <= mp->hghsel && !interrupted;
1026 msgnum++)
1027 if (is_selected (mp, msgnum)) {
1028 fprintf (out, "\n\n-------");
1029 if (msgnum == mp->lowsel)
1030 fprintf (out, " Forwarded Message%s",
1031 mp->numsel > 1 ? "s" : "");
1032 else
1033 fprintf (out, " Message %d", msgcnt);
1034 fprintf (out, "\n\n");
1035 copy_digest (msgnum, out);
1036 msgcnt++;
1037 }
1038
1039 fprintf (out, "\n\n------- End of Forwarded Message%s\n",
1040 mp->numsel > 1 ? "s" : "");
1041 fclose (out);
1042 }
1043
1044 fflush (stdout);
1045 if (!interrupted)
1046 switch (child_id = fork ()) {
1047 case NOTOK:
1048 advise ("fork", "unable to");
1049 break;
1050
1051 case OK:
1052 closefds (3);
1053 SIGNAL (SIGINT, istat);
1054 SIGNAL (SIGQUIT, qstat);
1055
1056 vec[vecp++] = tmpfil;
1057 vec[vecp] = NULL;
1058
1059 execvp (proc, vec);
1060 fprintf (stderr, "unable to exec ");
1061 perror (proc);
1062 _exit (1);
1063
1064 default:
1065 pidXwait (child_id, NULL);
1066 break;
1067 }
1068
1069 unlink (tmpfil);
1070 }
1071
1072
1073 static char *hlpmsg[] = {
1074 "The %s program emulates many of the commands found in the nmh",
1075 "system. Instead of operating on nmh folders, commands to %s concern",
1076 "a single file.",
1077 "",
1078 "To see the list of commands available, just type a ``?'' followed by",
1079 "the RETURN key. To find out what switches each command takes, type",
1080 "the name of the command followed by ``-help''. To leave %s, use the",
1081 "``quit'' command.",
1082 "",
1083 "Although a lot of nmh commands are found in %s, not all are fully",
1084 "implemented. %s will always recognize all legal switches for a",
1085 "given command though, and will let you know when you ask for an",
1086 "option that it is unable to perform.",
1087 "",
1088 "Running %s is fun, but using nmh from your shell is far superior.",
1089 "After you have familiarized yourself with the nmh style by using %s,",
1090 "you should try using nmh from the shell. You can still use %s for",
1091 "message files that aren't in nmh format, such as BBoard files.",
1092 NULL
1093 };
1094
1095
1096 void
1097 helpcmd (char **args)
1098 {
1099 int i;
1100
1101 for (i = 0; hlpmsg[i]; i++) {
1102 printf (hlpmsg[i], invo_name);
1103 putchar ('\n');
1104 }
1105 }
1106
1107
1108 static struct swit markswit[] = {
1109 #define MADDSW 0
1110 { "add", 0 },
1111 #define MDELSW 1
1112 { "delete", 0 },
1113 #define MLSTSW 2
1114 { "list", 0 },
1115 #define MSEQSW 3
1116 { "sequence name", 0 },
1117 #define MPUBSW 4
1118 { "public", 0 },
1119 #define MNPUBSW 5
1120 { "nopublic", 0 },
1121 #define MZERSW 6
1122 { "zero", 0 },
1123 #define MNZERSW 7
1124 { "nozero", 0 },
1125 #define MHELP 8
1126 { "help", 0 },
1127 #define MDBUGSW 9
1128 { "debug", -5 },
1129 { NULL, 0 }
1130 };
1131
1132
1133 void
1134 markcmd (char **args)
1135 {
1136 int addsw = 0, deletesw = 0, debugsw = 0;
1137 int listsw = 0, zerosw = 0, seqp = 0;
1138 int msgp = 0, msgnum;
1139 char *cp, buf[BUFSIZ];
1140 char *seqs[NUMATTRS + 1], *msgs[MAXARGS];
1141
1142 while ((cp = *args++)) {
1143 if (*cp == '-') {
1144 switch (smatch (++cp, markswit)) {
1145 case AMBIGSW:
1146 ambigsw (cp, markswit);
1147 return;
1148 case UNKWNSW:
1149 fprintf (stderr, "-%s unknown\n", cp);
1150 return;
1151 case MHELP:
1152 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1153 print_help (buf, markswit, 1);
1154 return;
1155
1156 case MADDSW:
1157 addsw++;
1158 deletesw = listsw = 0;
1159 continue;
1160 case MDELSW:
1161 deletesw++;
1162 addsw = listsw = 0;
1163 continue;
1164 case MLSTSW:
1165 listsw++;
1166 addsw = deletesw = 0;
1167 continue;
1168
1169 case MSEQSW:
1170 if (!(cp = *args++) || *cp == '-') {
1171 advise (NULL, "missing argument to %s", args[-2]);
1172 return;
1173 }
1174 if (seqp < NUMATTRS)
1175 seqs[seqp++] = cp;
1176 else {
1177 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1178 return;
1179 }
1180 continue;
1181
1182 case MPUBSW: /* not implemented */
1183 case MNPUBSW:
1184 continue;
1185
1186 case MDBUGSW:
1187 debugsw++;
1188 continue;
1189
1190 case MZERSW:
1191 zerosw++;
1192 continue;
1193 case MNZERSW:
1194 zerosw = 0;
1195 continue;
1196 }
1197 }
1198 if (*cp == '+' || *cp == '@') {
1199 advise (NULL, "sorry, no folders allowed!");
1200 return;
1201 } else {
1202 msgs[msgp++] = cp;
1203 }
1204 }
1205
1206 if (!addsw && !deletesw && !listsw) {
1207 if (seqp)
1208 addsw++;
1209 else
1210 if (debugsw)
1211 listsw++;
1212 else {
1213 seqs[seqp++] = "unseen";
1214 deletesw++;
1215 zerosw = 0;
1216 if (!msgp)
1217 msgs[msgp++] = "all";
1218 }
1219 }
1220
1221 if (!msgp)
1222 msgs[msgp++] = listsw ? "all" :"cur";
1223 for (msgnum = 0; msgnum < msgp; msgnum++)
1224 if (!m_convert (mp, msgs[msgnum]))
1225 return;
1226
1227 if (debugsw) {
1228 printf ("invo_name=%s mypath=%s defpath=%s\n",
1229 invo_name, mypath, defpath);
1230 printf ("ctxpath=%s context flags=%s\n",
1231 ctxpath, snprintb (buf, sizeof(buf), (unsigned) ctxflags, DBITS));
1232 printf ("foldpath=%s flags=%s\n",
1233 mp->foldpath,
1234 snprintb (buf, sizeof(buf), (unsigned) mp->msgflags, FBITS));
1235 printf ("hghmsg=%d lowmsg=%d nummsg=%d curmsg=%d\n",
1236 mp->hghmsg, mp->lowmsg, mp->nummsg, mp->curmsg);
1237 printf ("lowsel=%d hghsel=%d numsel=%d\n",
1238 mp->lowsel, mp->hghsel, mp->numsel);
1239 printf ("lowoff=%d hghoff=%d\n", mp->lowoff, mp->hghoff);
1240 }
1241
1242 if (seqp == 0 && (addsw || deletesw)) {
1243 advise (NULL, "-%s requires at least one -sequence argument",
1244 addsw ? "add" : "delete");
1245 return;
1246 }
1247 seqs[seqp] = NULL;
1248
1249 if (addsw) {
1250 for (seqp = 0; seqs[seqp]; seqp++)
1251 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1252 return;
1253 }
1254
1255 if (deletesw) {
1256 for (seqp = 0; seqs[seqp]; seqp++)
1257 if (!seq_delsel (mp, seqs[seqp], 0, zerosw))
1258 return;
1259 }
1260
1261 /* Listing messages in sequences */
1262 if (listsw) {
1263 if (seqp) {
1264 /* list the given sequences */
1265 for (seqp = 0; seqs[seqp]; seqp++)
1266 seq_print (mp, seqs[seqp]);
1267 } else {
1268 /* else list them all */
1269 seq_printall (mp);
1270 }
1271
1272 interrupted = 0;
1273 if (debugsw)
1274 for (msgnum = mp->lowsel;
1275 msgnum <= mp->hghsel && !interrupted;
1276 msgnum++)
1277 if (is_selected (mp, msgnum)) {
1278 printf ("%*d: id=%d top=%d start=%ld stop=%ld %s\n",
1279 DMAXFOLDER,
1280 msgnum,
1281 Msgs[msgnum].m_bboard_id,
1282 Msgs[msgnum].m_top,
1283 (long) Msgs[msgnum].m_start,
1284 (long) Msgs[msgnum].m_stop,
1285 snprintb (buf, sizeof(buf),
1286 (unsigned) mp->msgstats[msgnum - mp->lowoff],
1287 seq_bits (mp)));
1288 if (Msgs[msgnum].m_scanl)
1289 printf ("%s", Msgs[msgnum].m_scanl);
1290 }
1291 }
1292 }
1293
1294
1295 static struct swit mhnswit[] = {
1296 #define MHNAUTOSW 0
1297 { "auto", 0 },
1298 #define MHNNAUTOSW 1
1299 { "noauto", 0 },
1300 #define MHNDEBUGSW 2
1301 { "debug", -5 },
1302 #define MHNEBCDICSW 3
1303 { "ebcdicsafe", 0 },
1304 #define MHNNEBCDICSW 4
1305 { "noebcdicsafe", 0 },
1306 #define MHNFORMSW 5
1307 { "form formfile", 4 },
1308 #define MHNHEADSW 6
1309 { "headers", 0 },
1310 #define MHNNHEADSW 7
1311 { "noheaders", 0 },
1312 #define MHNLISTSW 8
1313 { "list", 0 },
1314 #define MHNNLISTSW 9
1315 { "nolist", 0 },
1316 #define MHNPARTSW 10
1317 { "part number", 0 },
1318 #define MHNSIZESW 11
1319 { "realsize", 0 },
1320 #define MHNNSIZESW 12
1321 { "norealsize", 0 },
1322 #define MHNRFC934SW 13
1323 { "rfc934mode", 0 },
1324 #define MHNNRFC934SW 14
1325 { "norfc934mode", 0 },
1326 #define MHNSERIALSW 15
1327 { "serialonly", 0 },
1328 #define MHNNSERIALSW 16
1329 { "noserialonly", 0 },
1330 #define MHNSHOWSW 17
1331 { "show", 0 },
1332 #define MHNNSHOWSW 18
1333 { "noshow", 0 },
1334 #define MHNSTORESW 19
1335 { "store", 0 },
1336 #define MHNNSTORESW 20
1337 { "nostore", 0 },
1338 #define MHNTYPESW 21
1339 { "type content", 0 },
1340 #define MHNVERBSW 22
1341 { "verbose", 0 },
1342 #define MHNNVERBSW 23
1343 { "noverbose", 0 },
1344 #define MHNHELPSW 24
1345 { "help", 0 },
1346 #define MHNPROGSW 25
1347 { "moreproc program", -4 },
1348 #define MHNNPROGSW 26
1349 { "nomoreproc", -3 },
1350 #define MHNLENSW 27
1351 { "length lines", -4 },
1352 #define MHNWIDSW 28
1353 { "width columns", -4 },
1354 { NULL, 0 }
1355 };
1356
1357
1358 void
1359 mhncmd (char **args)
1360 {
1361 int msgp = 0, vecp = 1;
1362 int msgnum;
1363 char *cp, buf[BUFSIZ];
1364 char *msgs[MAXARGS], *vec[MAXARGS];
1365
1366 if (fmsh) {
1367 forkcmd (args, cmd_name);
1368 return;
1369 }
1370 while ((cp = *args++)) {
1371 if (*cp == '-') {
1372 switch (smatch (++cp, mhnswit)) {
1373 case AMBIGSW:
1374 ambigsw (cp, mhnswit);
1375 return;
1376 case UNKWNSW:
1377 fprintf (stderr, "-%s unknown\n", cp);
1378 return;
1379 case MHNHELPSW:
1380 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1381 print_help (buf, mhnswit, 1);
1382 return;
1383
1384 case MHNAUTOSW:
1385 case MHNNAUTOSW:
1386 case MHNDEBUGSW:
1387 case MHNEBCDICSW:
1388 case MHNNEBCDICSW:
1389 case MHNHEADSW:
1390 case MHNNHEADSW:
1391 case MHNLISTSW:
1392 case MHNNLISTSW:
1393 case MHNSIZESW:
1394 case MHNNSIZESW:
1395 case MHNRFC934SW:
1396 case MHNNRFC934SW:
1397 case MHNSERIALSW:
1398 case MHNNSERIALSW:
1399 case MHNSHOWSW:
1400 case MHNNSHOWSW:
1401 case MHNSTORESW:
1402 case MHNNSTORESW:
1403 case MHNVERBSW:
1404 case MHNNVERBSW:
1405 case MHNNPROGSW:
1406 vec[vecp++] = --cp;
1407 continue;
1408
1409 case MHNFORMSW:
1410 case MHNPARTSW:
1411 case MHNTYPESW:
1412 case MHNPROGSW:
1413 case MHNLENSW:
1414 case MHNWIDSW:
1415 vec[vecp++] = --cp;
1416 if (!(cp = *args++) || *cp == '-') {
1417 advise (NULL, "missing argument to %s", args[-2]);
1418 return;
1419 }
1420 vec[vecp++] = cp;
1421 continue;
1422 }
1423 }
1424 if (*cp == '+' || *cp == '@') {
1425 advise (NULL, "sorry, no folders allowed!");
1426 return;
1427 } else {
1428 msgs[msgp++] = cp;
1429 }
1430 }
1431
1432 vec[0] = cmd_name;
1433 vec[vecp++] = "-file";
1434 vec[vecp] = NULL;
1435 if (!msgp)
1436 msgs[msgp++] = "cur";
1437 for (msgnum = 0; msgnum < msgp; msgnum++)
1438 if (!m_convert (mp, msgs[msgnum]))
1439 return;
1440 seq_setprev (mp);
1441
1442 interrupted = 0;
1443 for (msgnum = mp->lowsel;
1444 msgnum <= mp->hghsel && !interrupted;
1445 msgnum++)
1446 if (is_selected (mp, msgnum))
1447 if (process (msgnum, cmd_name, vecp, vec)) {
1448 unset_selected (mp, msgnum);
1449 mp->numsel--;
1450 }
1451
1452 seq_setcur (mp, mp->hghsel);
1453 }
1454
1455
1456 static struct swit packswit[] = {
1457 #define PAFISW 0
1458 { "file name", 0 },
1459 #define PAHELP 1
1460 { "help", 0 },
1461 { NULL, 0 }
1462 };
1463
1464 static int mbx_style = MMDF_FORMAT;
1465
1466 void
1467 packcmd (char **args)
1468 {
1469 int msgp = 0, md, msgnum;
1470 char *cp, *file = NULL;
1471 char buf[BUFSIZ], *msgs[MAXARGS];
1472 struct stat st;
1473
1474 if (fmsh) {
1475 forkcmd (args, cmd_name);
1476 return;
1477 }
1478
1479 while ((cp = *args++)) {
1480 if (*cp == '-')
1481 switch (smatch (++cp, packswit)) {
1482 case AMBIGSW:
1483 ambigsw (cp, packswit);
1484 return;
1485 case UNKWNSW:
1486 fprintf (stderr, "-%s unknown\n", cp);
1487 return;
1488 case PAHELP:
1489 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1490 print_help (buf, packswit, 1);
1491 return;
1492
1493 case PAFISW:
1494 if (!(file = *args++) || *file == '-') {
1495 advise (NULL, "missing argument to %s", args[-2]);
1496 return;
1497 }
1498 continue;
1499 }
1500 if (*cp == '+' || *cp == '@') {
1501 advise (NULL, "sorry, no folders allowed!");
1502 return;
1503 }
1504 else
1505 msgs[msgp++] = cp;
1506 }
1507
1508 if (!file)
1509 file = "./msgbox";
1510 file = path (file, TFILE);
1511 if (stat (file, &st) == NOTOK) {
1512 if (errno != ENOENT) {
1513 advise (file, "error on file");
1514 goto done_pack;
1515 }
1516 md = getanswer (cp = concat ("Create file \"", file, "\"? ", NULL));
1517 free (cp);
1518 if (!md)
1519 goto done_pack;
1520 }
1521
1522 if (!msgp)
1523 msgs[msgp++] = "all";
1524 for (msgnum = 0; msgnum < msgp; msgnum++)
1525 if (!m_convert (mp, msgs[msgnum]))
1526 goto done_pack;
1527 seq_setprev (mp);
1528
1529 if ((md = mbx_open (file, mbx_style, getuid (), getgid (), m_gmprot ())) == NOTOK) {
1530 advise (file, "unable to open");
1531 goto done_pack;
1532 }
1533 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1534 if (is_selected (mp, msgnum))
1535 if (pack (file, md, msgnum) == NOTOK)
1536 break;
1537 mbx_close (file, md);
1538
1539 if (mp->hghsel != mp->curmsg)
1540 seq_setcur (mp, mp->lowsel);
1541
1542 done_pack: ;
1543 free (file);
1544 }
1545
1546
1547 int
1548 pack (char *mailbox, int md, int msgnum)
1549 {
1550 register FILE *zp;
1551
1552 if (Msgs[msgnum].m_bboard_id == 0)
1553 readid (msgnum);
1554
1555 zp = msh_ready (msgnum, 1);
1556 return mbx_write (mailbox, md, zp, Msgs[msgnum].m_bboard_id,
1557 0L, ftell (zp), Msgs[msgnum].m_stop, 1, 1);
1558 }
1559
1560
1561 int
1562 packhak (char **args)
1563 {
1564 int result;
1565 char *cp, *file = NULL;
1566
1567 while ((cp = *args++)) {
1568 if (*cp == '-')
1569 switch (smatch (++cp, packswit)) {
1570 case AMBIGSW:
1571 case UNKWNSW:
1572 case PAHELP:
1573 return NOTOK;
1574
1575 case PAFISW:
1576 if (!(file = *args++) || *file == '-')
1577 return NOTOK;
1578 continue;
1579 }
1580 if (*cp == '+' || *cp == '@')
1581 return NOTOK;
1582 }
1583
1584 file = path (file ? file : "./msgbox", TFILE);
1585 result = access (file, F_OK) == NOTOK ? OK : NOTOK;
1586 free (file);
1587
1588 return result;
1589 }
1590
1591
1592 static struct swit pickswit[] = {
1593 #define PIANSW 0
1594 { "and", 0 },
1595 #define PIORSW 1
1596 { "or", 0 },
1597 #define PINTSW 2
1598 { "not", 0 },
1599 #define PILBSW 3
1600 { "lbrace", 0 },
1601 #define PIRBSW 4
1602 { "rbrace", 0 },
1603 #define PICCSW 5
1604 { "cc pattern", 0 },
1605 #define PIDASW 6
1606 { "date pattern", 0 },
1607 #define PIFRSW 7
1608 { "from pattern", 0 },
1609 #define PISESW 8
1610 { "search pattern", 0 },
1611 #define PISUSW 9
1612 { "subject pattern", 0 },
1613 #define PITOSW 10
1614 { "to pattern", 0 },
1615 #define PIOTSW 11
1616 { "-othercomponent pattern", 15 },
1617 #define PIAFSW 12
1618 { "after date", 0 },
1619 #define PIBFSW 13
1620 { "before date", 0 },
1621 #define PIDFSW 14
1622 { "datefield field", 5 },
1623 #define PISQSW 15
1624 { "sequence name", 0 },
1625 #define PIPUSW 16
1626 { "public", 0 },
1627 #define PINPUSW 17
1628 { "nopublic", 0 },
1629 #define PIZRSW 18
1630 { "zero", 0 },
1631 #define PINZRSW 19
1632 { "nozero", 0 },
1633 #define PILISW 20
1634 { "list", 0 },
1635 #define PINLISW 21
1636 { "nolist", 0 },
1637 #define PIHELP 22
1638 { "help", 0 },
1639 { NULL, 0 }
1640 };
1641
1642
1643 void
1644 pickcmd (char **args)
1645 {
1646 int zerosw = 1, msgp = 0, seqp = 0;
1647 int vecp = 0, hi, lo, msgnum;
1648 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1649 char *seqs[NUMATTRS], *vec[MAXARGS];
1650 register FILE *zp;
1651
1652 while ((cp = *args++)) {
1653 if (*cp == '-') {
1654 if (*++cp == '-') {
1655 vec[vecp++] = --cp;
1656 goto pattern;
1657 }
1658 switch (smatch (cp, pickswit)) {
1659 case AMBIGSW:
1660 ambigsw (cp, pickswit);
1661 return;
1662 case UNKWNSW:
1663 fprintf (stderr, "-%s unknown\n", cp);
1664 return;
1665 case PIHELP:
1666 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1667 print_help (buf, pickswit, 1);
1668 return;
1669
1670 case PICCSW:
1671 case PIDASW:
1672 case PIFRSW:
1673 case PISUSW:
1674 case PITOSW:
1675 case PIDFSW:
1676 case PIAFSW:
1677 case PIBFSW:
1678 case PISESW:
1679 vec[vecp++] = --cp;
1680 pattern: ;
1681 if (!(cp = *args++)) {/* allow -xyz arguments */
1682 advise (NULL, "missing argument to %s", args[-2]);
1683 return;
1684 }
1685 vec[vecp++] = cp;
1686 continue;
1687 case PIOTSW:
1688 advise (NULL, "internal error!");
1689 return;
1690 case PIANSW:
1691 case PIORSW:
1692 case PINTSW:
1693 case PILBSW:
1694 case PIRBSW:
1695 vec[vecp++] = --cp;
1696 continue;
1697
1698 case PISQSW:
1699 if (!(cp = *args++) || *cp == '-') {
1700 advise (NULL, "missing argument to %s", args[-2]);
1701 return;
1702 }
1703 if (seqp < NUMATTRS)
1704 seqs[seqp++] = cp;
1705 else {
1706 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1707 return;
1708 }
1709 continue;
1710 case PIZRSW:
1711 zerosw++;
1712 continue;
1713 case PINZRSW:
1714 zerosw = 0;
1715 continue;
1716
1717 case PIPUSW: /* not implemented */
1718 case PINPUSW:
1719 case PILISW:
1720 case PINLISW:
1721 continue;
1722 }
1723 }
1724 if (*cp == '+' || *cp == '@') {
1725 advise (NULL, "sorry, no folders allowed!");
1726 return;
1727 }
1728 else
1729 msgs[msgp++] = cp;
1730 }
1731 vec[vecp] = NULL;
1732
1733 if (!msgp)
1734 msgs[msgp++] = "all";
1735 for (msgnum = 0; msgnum < msgp; msgnum++)
1736 if (!m_convert (mp, msgs[msgnum]))
1737 return;
1738 seq_setprev (mp);
1739
1740 interrupted = 0;
1741 if (!pcompile (vec, NULL))
1742 return;
1743
1744 lo = mp->lowsel;
1745 hi = mp->hghsel;
1746
1747 for (msgnum = mp->lowsel;
1748 msgnum <= mp->hghsel && !interrupted;
1749 msgnum++)
1750 if (is_selected (mp, msgnum)) {
1751 zp = msh_ready (msgnum, 1);
1752 if (pmatches (zp, msgnum, fmsh ? 0L : Msgs[msgnum].m_start,
1753 fmsh ? 0L : Msgs[msgnum].m_stop)) {
1754 if (msgnum < lo)
1755 lo = msgnum;
1756 if (msgnum > hi)
1757 hi = msgnum;
1758 }
1759 else {
1760 unset_selected (mp, msgnum);
1761 mp->numsel--;
1762 }
1763 }
1764
1765 if (interrupted)
1766 return;
1767
1768 mp->lowsel = lo;
1769 mp->hghsel = hi;
1770
1771 if (mp->numsel <= 0) {
1772 advise (NULL, "no messages match specification");
1773 return;
1774 }
1775
1776 seqs[seqp] = NULL;
1777 for (seqp = 0; seqs[seqp]; seqp++)
1778 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1779 return;
1780
1781 printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
1782 }
1783
1784
1785 static struct swit replswit[] = {
1786 #define REANSW 0
1787 { "annotate", 0 },
1788 #define RENANSW 1
1789 { "noannotate", 0 },
1790 #define RECCSW 2
1791 { "cc type", 0 },
1792 #define RENCCSW 3
1793 { "nocc type", 0 },
1794 #define REDFSW 4
1795 { "draftfolder +folder", 0 },
1796 #define REDMSW 5
1797 { "draftmessage msg", 0 },
1798 #define RENDFSW 6
1799 { "nodraftfolder", 0 },
1800 #define REEDTSW 7
1801 { "editor editor", 0 },
1802 #define RENEDSW 8
1803 { "noedit", 0 },
1804 #define REFCCSW 9
1805 { "fcc +folder", 0 },
1806 #define REFLTSW 10
1807 { "filter filterfile", 0 },
1808 #define REFRMSW 11
1809 { "form formfile", 0 },
1810 #define REINSW 12
1811 { "inplace", 0 },
1812 #define RENINSW 13
1813 { "noinplace", 0 },
1814 #define REQUSW 14
1815 { "query", 0 },
1816 #define RENQUSW 15
1817 { "noquery", 0 },
1818 #define REWHTSW 16
1819 { "whatnowproc program", 0 },
1820 #define RENWTSW 17
1821 { "nowhatnow", 0 },
1822 #define REWIDSW 19
1823 { "width columns", 0 },
1824 #define REHELP 20
1825 { "help", 0 },
1826 { NULL, 0 }
1827 };
1828
1829
1830 void
1831 replcmd (char **args)
1832 {
1833 int vecp = 1;
1834 char *cp, *msg = NULL;
1835 char buf[BUFSIZ], *vec[MAXARGS];
1836
1837 if (fmsh) {
1838 forkcmd (args, cmd_name);
1839 return;
1840 }
1841
1842 while ((cp = *args++)) {
1843 if (*cp == '-')
1844 switch (smatch (++cp, replswit)) {
1845 case AMBIGSW:
1846 ambigsw (cp, replswit);
1847 return;
1848 case UNKWNSW:
1849 fprintf (stderr, "-%s unknown\n", cp);
1850 return;
1851 case REHELP:
1852 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1853 print_help (buf, replswit, 1);
1854 return;
1855
1856 case REANSW: /* not implemented */
1857 case RENANSW:
1858 case REINSW:
1859 case RENINSW:
1860 continue;
1861
1862 case REQUSW:
1863 case RENQUSW:
1864 case RENDFSW:
1865 case RENEDSW:
1866 case RENWTSW:
1867 vec[vecp++] = --cp;
1868 continue;
1869
1870 case RECCSW:
1871 case RENCCSW:
1872 case REEDTSW:
1873 case REFCCSW:
1874 case REFLTSW:
1875 case REFRMSW:
1876 case REWIDSW:
1877 case REDFSW:
1878 case REDMSW:
1879 case REWHTSW:
1880 vec[vecp++] = --cp;
1881 if (!(cp = *args++) || *cp == '-') {
1882 advise (NULL, "missing argument to %s", args[-2]);
1883 return;
1884 }
1885 vec[vecp++] = cp;
1886 continue;
1887 }
1888 if (*cp == '+' || *cp == '@') {
1889 advise (NULL, "sorry, no folders allowed!");
1890 return;
1891 }
1892 else
1893 if (msg) {
1894 advise (NULL, "only one message at a time!");
1895 return;
1896 }
1897 else
1898 msg = cp;
1899 }
1900
1901 vec[0] = cmd_name;
1902 vec[vecp++] = "-file";
1903 vec[vecp] = NULL;
1904 if (!msg)
1905 msg = "cur";
1906 if (!m_convert (mp, msg))
1907 return;
1908 seq_setprev (mp);
1909
1910 if (mp->numsel > 1) {
1911 advise (NULL, "only one message at a time!");
1912 return;
1913 }
1914 process (mp->hghsel, cmd_name, vecp, vec);
1915 seq_setcur (mp, mp->hghsel);
1916 }
1917
1918
1919 static struct swit rmmswit[] = {
1920 #define RMHELP 0
1921 { "help", 0 },
1922 { NULL, 0 }
1923 };
1924
1925
1926 void
1927 rmmcmd (char **args)
1928 {
1929 int msgp = 0, msgnum;
1930 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1931
1932 while ((cp = *args++)) {
1933 if (*cp == '-')
1934 switch (smatch (++cp, rmmswit)) {
1935 case AMBIGSW:
1936 ambigsw (cp, rmmswit);
1937 return;
1938 case UNKWNSW:
1939 fprintf (stderr, "-%s unknown\n", cp);
1940 return;
1941 case RMHELP:
1942 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1943 print_help (buf, rmmswit, 1);
1944 return;
1945 }
1946 if (*cp == '+' || *cp == '@') {
1947 advise (NULL, "sorry, no folders allowed!");
1948 return;
1949 }
1950 else
1951 msgs[msgp++] = cp;
1952 }
1953
1954 if (!msgp)
1955 msgs[msgp++] = "cur";
1956 for (msgnum = 0; msgnum < msgp; msgnum++)
1957 if (!m_convert (mp, msgs[msgnum]))
1958 return;
1959 seq_setprev (mp);
1960
1961 rmm ();
1962 }
1963
1964
1965 static void
1966 rmm (void)
1967 {
1968 register int msgnum, vecp;
1969 register char *cp;
1970 char buffer[BUFSIZ], *vec[MAXARGS];
1971
1972 if (fmsh) {
1973 if (rmmproc) {
1974 if (mp->numsel > MAXARGS - 1) {
1975 advise (NULL, "more than %d messages for %s exec",
1976 MAXARGS - 1, rmmproc);
1977 return;
1978 }
1979 vecp = 0;
1980 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1981 if (is_selected (mp, msgnum))
1982 vec[vecp++] = getcpy (m_name (msgnum));
1983 vec[vecp] = NULL;
1984 forkcmd (vec, rmmproc);
1985 for (vecp = 0; vec[vecp]; vecp++)
1986 free (vec[vecp]);
1987 }
1988 else
1989 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1990 if (is_selected (mp, msgnum)) {
1991 strncpy (buffer, m_backup (cp = m_name (msgnum)), sizeof(buffer));
1992 if (rename (cp, buffer) == NOTOK)
1993 admonish (buffer, "unable to rename %s to", cp);
1994 }
1995 }
1996
1997 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1998 if (is_selected (mp, msgnum)) {
1999 set_deleted (mp, msgnum);
2000 unset_exists (mp, msgnum);
2001 #ifdef MPOP
2002 #ifdef BPOP
2003 if (pmsh && pop_dele (msgnum) != OK)
2004 fprintf (stderr, "%s", response);
2005 #endif
2006 #endif /* MPOP */
2007 }
2008
2009 if ((mp->nummsg -= mp->numsel) <= 0) {
2010 if (fmsh)
2011 admonish (NULL, "no messages remaining in +%s", fmsh);
2012 else
2013 admonish (NULL, "no messages remaining in %s", mp->foldpath);
2014 mp->lowmsg = mp->hghmsg = mp->nummsg = 0;
2015 }
2016 if (mp->lowsel == mp->lowmsg) {
2017 for (msgnum = mp->lowmsg + 1; msgnum <= mp->hghmsg; msgnum++)
2018 if (does_exist (mp, msgnum))
2019 break;
2020 mp->lowmsg = msgnum;
2021 }
2022 if (mp->hghsel == mp->hghmsg) {
2023 for (msgnum = mp->hghmsg - 1; msgnum >= mp->lowmsg; msgnum--)
2024 if (does_exist (mp, msgnum))
2025 break;
2026 mp->hghmsg = msgnum;
2027 }
2028
2029 mp->msgflags |= MODIFIED;
2030 modified++;
2031 }
2032
2033
2034 static struct swit scanswit[] = {
2035 #define SCCLR 0
2036 { "clear", 0 },
2037 #define SCNCLR 1
2038 { "noclear", 0 },
2039 #define SCFORM 2
2040 { "form formatfile", 0 },
2041 #define SCFMT 3
2042 { "format string", 5 },
2043 #define SCHEAD 4
2044 { "header", 0 },
2045 #define SCNHEAD 5
2046 { "noheader", 0 },
2047 #define SCWID 6
2048 { "width columns", 0 },
2049 #define SCHELP 7
2050 { "help", 0 },
2051 { NULL, 0 }
2052 };
2053
2054
2055 void
2056 scancmd (char **args)
2057 {
2058 #define equiv(a,b) (a ? b && !strcmp (a, b) : !b)
2059
2060 int clearsw = 0, headersw = 0, width = 0, msgp = 0;
2061 int msgnum, optim, state;
2062 char *cp, *form = NULL, *format = NULL;
2063 char buf[BUFSIZ], *nfs, *msgs[MAXARGS];
2064 register FILE *zp;
2065 #ifdef MPOP
2066 #ifdef BPOP
2067 static int p_optim = 0;
2068 #endif
2069 #endif /* MPOP */
2070 static int s_optim = 0;
2071 static char *s_form = NULL, *s_format = NULL;
2072
2073 while ((cp = *args++)) {
2074 if (*cp == '-')
2075 switch (smatch (++cp, scanswit)) {
2076 case AMBIGSW:
2077 ambigsw (cp, scanswit);
2078 return;
2079 case UNKWNSW:
2080 fprintf (stderr, "-%s unknown\n", cp);
2081 return;
2082 case SCHELP:
2083 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2084 print_help (buf, scanswit, 1);
2085 return;
2086
2087 case SCCLR:
2088 clearsw++;
2089 continue;
2090 case SCNCLR:
2091 clearsw = 0;
2092 continue;
2093 case SCHEAD:
2094 headersw++;
2095 continue;
2096 case SCNHEAD:
2097 headersw = 0;
2098 continue;
2099 case SCFORM:
2100 if (!(form = *args++) || *form == '-') {
2101 advise (NULL, "missing argument to %s", args[-2]);
2102 return;
2103 }
2104 format = NULL;
2105 continue;
2106 case SCFMT:
2107 if (!(format = *args++) || *format == '-') {
2108 advise (NULL, "missing argument to %s", args[-2]);
2109 return;
2110 }
2111 form = NULL;
2112 continue;
2113 case SCWID:
2114 if (!(cp = *args++) || *cp == '-') {
2115 advise (NULL, "missing argument to %s", args[-2]);
2116 return;
2117 }
2118 width = atoi (cp);
2119 continue;
2120 }
2121 if (*cp == '+' || *cp == '@') {
2122 advise (NULL, "sorry, no folders allowed!");
2123 return;
2124 }
2125 else
2126 msgs[msgp++] = cp;
2127 }
2128
2129 if (!msgp)
2130 msgs[msgp++] = "all";
2131 for (msgnum = 0; msgnum < msgp; msgnum++)
2132 if (!m_convert (mp, msgs[msgnum]))
2133 return;
2134 seq_setprev (mp);
2135
2136 /* Get new format string */
2137 nfs = new_fs (form, format, FORMAT);
2138
2139 /* force scansbr to (re)compile format */
2140 if (scanl) {
2141 free (scanl);
2142 scanl = NULL;
2143 }
2144
2145 if (s_optim == 0) {
2146 s_optim = optim = 1;
2147 s_form = form ? getcpy (form) : NULL;
2148 s_format = format ? getcpy (format) : NULL;
2149
2150 #ifdef MPOP
2151 #ifdef BPOP
2152 if (pmsh) {
2153 int i;
2154 char *dp, *ep, *fp;
2155
2156 if (width == 0)
2157 width = sc_width ();
2158
2159 for (dp = nfs, i = 0; *dp; dp++, i++)
2160 if (*dp == '\\' || *dp == '"' || *dp == '\n')
2161 i++;
2162 i++;
2163 if ((ep = malloc ((unsigned) i)) == NULL)
2164 adios (NULL, "out of memory");
2165 for (dp = nfs, fp = ep; *dp; dp++) {
2166 if (*dp == '\n') {
2167 *fp++ = '\\', *fp++ = 'n';
2168 continue;
2169 }
2170 if (*dp == '"' || *dp == '\\')
2171 *fp++ = '\\';
2172 *fp++ = *dp;
2173 }
2174 *fp = NULL;
2175
2176 if (pop_command ("XTND SCAN %d \"%s\"", width, ep) == OK)
2177 p_optim = 1;
2178
2179 free (ep);
2180 }
2181 #endif
2182 #endif /* MPOP */
2183 }
2184 else
2185 optim = equiv (s_form, form) && equiv (s_format, format);
2186
2187 #ifdef MPOP
2188 #ifdef BPOP
2189 if (p_optim && optim) {
2190 for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++)
2191 if (!is_selected(mp, msgnum) || Msgs[msgnum].m_scanl)
2192 break;
2193 if (msgnum > mp->hghmsg && pop_command ("LIST") == OK) {
2194 fprintf (stderr, "Stand-by...");
2195 fflush (stderr);
2196
2197 for (;;) {
2198 int size;
2199
2200 switch (pop_multiline ()) {
2201 case NOTOK:
2202 fprintf (stderr, "%s", response);
2203 /* and fall... */
2204 case DONE:
2205 fprintf (stderr,"\n");
2206 break;
2207
2208 case OK:
2209 if (sscanf (response, "%d %d", &msgnum, &size) == 2
2210 && mp->lowmsg <= msgnum
2211 && msgnum <= mp->hghmsg
2212 && (cp = strchr(response, '#'))
2213 && *++cp)
2214 Msgs[msgnum].m_scanl = concat (cp, "\n", NULL);
2215 continue;
2216 }
2217 break;
2218 }
2219 }
2220 }
2221 #endif
2222 #endif /* MPOP */
2223
2224 interrupted = 0;
2225 for (msgnum = mp->lowsel;
2226 msgnum <= mp->hghsel && !interrupted;
2227 msgnum++)
2228 if (is_selected (mp, msgnum)) {
2229 if (optim && Msgs[msgnum].m_scanl)
2230 printf ("%s", Msgs[msgnum].m_scanl);
2231 else {
2232 #ifdef MPOP
2233 #ifdef BPOP
2234 if (p_optim
2235 && optim
2236 && is_virtual (mp, msgnum)
2237 && pop_command ("LIST %d", msgnum) == OK
2238 && (cp = strchr(response, '#'))
2239 && *++cp) {
2240 Msgs[msgnum].m_scanl = concat (cp, "\n", NULL);
2241 printf ("%s", Msgs[msgnum].m_scanl);
2242 continue;
2243 }
2244 #endif
2245 #endif /* MPOP */
2246
2247 zp = msh_ready (msgnum, 0);
2248 switch (state = scan (zp, msgnum, 0, nfs, width,
2249 msgnum == mp->curmsg,
2250 is_unseen (mp, msgnum),
2251 headersw ? (fmsh ? fmsh : mp->foldpath) : NULL,
2252 fmsh ? 0L : (long) (Msgs[msgnum].m_stop - Msgs[msgnum].m_start),
2253 1)) {
2254 case SCNMSG:
2255 case SCNENC:
2256 case SCNERR:
2257 if (optim)
2258 Msgs[msgnum].m_scanl = getcpy (scanl);
2259 break;
2260
2261 default:
2262 advise (NULL, "scan() botch (%d)", state);
2263 return;
2264
2265 case SCNEOF:
2266 printf ("%*d empty\n", DMAXFOLDER, msgnum);
2267 break;
2268 }
2269 }
2270 headersw = 0;
2271 }
2272
2273 if (clearsw)
2274 clear_screen ();
2275 }
2276
2277
2278 static struct swit showswit[] = {
2279 #define SHDRAFT 0
2280 { "draft", 5 },
2281 #define SHFORM 1
2282 { "form formfile", 4 },
2283 #define SHPROG 2
2284 { "moreproc program", 4 },
2285 #define SHNPROG 3
2286 { "nomoreproc", 3 },
2287 #define SHLEN 4
2288 { "length lines", 4 },
2289 #define SHWID 5
2290 { "width columns", 4 },
2291 #define SHSHOW 6
2292 { "showproc program", 4 },
2293 #define SHNSHOW 7
2294 { "noshowproc", 3 },
2295 #define SHHEAD 8
2296 { "header", 4 },
2297 #define SHNHEAD 9
2298 { "noheader", 3 },
2299 #define SHHELP 10
2300 { "help", 0 },
2301 { NULL, 0 }
2302 };
2303
2304
2305 void
2306 showcmd (char **args)
2307 {
2308 int headersw = 1, nshow = 0, msgp = 0, vecp = 1;
2309 int mhl = 0, seqnum = -1, mode = 0, i, msgnum;
2310 char *cp, *proc = showproc, buf[BUFSIZ];
2311 char *msgs[MAXARGS], *vec[MAXARGS];
2312
2313 if (!strcasecmp (cmd_name, "next"))
2314 mode = 1;
2315 else
2316 if (!strcasecmp (cmd_name, "prev"))
2317 mode = -1;
2318 while ((cp = *args++)) {
2319 if (*cp == '-')
2320 switch (i = smatch (++cp, showswit)) {
2321 case AMBIGSW:
2322 ambigsw (cp, showswit);
2323 return;
2324 case UNKWNSW:
2325 case SHNPROG:
2326 vec[vecp++] = --cp;
2327 continue;
2328 case SHHELP:
2329 snprintf (buf, sizeof(buf), "%s %s[switches] [switches for showproc]",
2330 cmd_name, mode ? NULL : "[msgs] ");
2331 print_help (buf, showswit, 1);
2332 return;
2333
2334 case SHFORM:
2335 case SHPROG:
2336 case SHLEN:
2337 case SHWID:
2338 vec[vecp++] = --cp;
2339 if (!(cp = *args++) || *cp == '-') {
2340 advise (NULL, "missing argument to %s", args[-2]);
2341 return;
2342 }
2343 vec[vecp++] = cp;
2344 continue;
2345 case SHHEAD:
2346 headersw++;
2347 continue;
2348 case SHNHEAD:
2349 headersw = 0;
2350 continue;
2351 case SHSHOW:
2352 if (!(proc = *args++) || *proc == '-') {
2353 advise (NULL, "missing argument to %s", args[-2]);
2354 return;
2355 }
2356 nshow = 0;
2357 continue;
2358 case SHNSHOW:
2359 nshow++;
2360 continue;
2361
2362 case SHDRAFT:
2363 advise (NULL, "sorry, -%s not allowed!", showswit[i].sw);
2364 return;
2365 }
2366 if (*cp == '+' || *cp == '@') {
2367 advise (NULL, "sorry, no folders allowed!");
2368 return;
2369 }
2370 else
2371 if (mode) {
2372 fprintf (stderr,
2373 "usage: %s [switches] [switches for showproc]\n",
2374 cmd_name);
2375 return;
2376 }
2377 else
2378 msgs[msgp++] = cp;
2379 }
2380 vec[vecp] = NULL;
2381
2382 if (!msgp)
2383 msgs[msgp++] = mode > 0 ? "next" : mode < 0 ? "prev" : "cur";
2384 for (msgnum = 0; msgnum < msgp; msgnum++)
2385 if (!m_convert (mp, msgs[msgnum]))
2386 return;
2387 seq_setprev (mp);
2388
2389 if (!nshow && !getenv ("NOMHNPROC"))
2390 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2391 if (is_selected (mp, msgnum) && is_nontext (msgnum)) {
2392 proc = showmimeproc;
2393 vec[vecp++] = "-file";
2394 vec[vecp] = NULL;
2395 goto finish;
2396 }
2397
2398 if (nshow)
2399 proc = catproc;
2400 else
2401 if (strcmp (showproc, "mhl") == 0) {
2402 proc = mhlproc;
2403 mhl++;
2404 }
2405
2406 finish: ;
2407 seqnum = seq_getnum (mp, "unseen");
2408 vec[0] = r1bindex (proc, '/');
2409 if (mhl) {
2410 msgp = vecp;
2411 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2412 if (is_selected (mp, msgnum)) {
2413 vec[vecp++] = getcpy (m_name (msgnum));
2414 if (seqnum != -1)
2415 seq_delmsg (mp, "unseen", msgnum);
2416 }
2417 vec[vecp] = NULL;
2418 if (mp->numsel == 1 && headersw)
2419 show (mp->lowsel);
2420 mhlsbr (vecp, vec, mhl_action);
2421 m_eomsbr ((int (*)()) 0);
2422 while (msgp < vecp)
2423 free (vec[msgp++]);
2424 } else {
2425 interrupted = 0;
2426 for (msgnum = mp->lowsel;
2427 msgnum <= mp->hghsel && !interrupted;
2428 msgnum++)
2429 if (is_selected (mp, msgnum)) {
2430 switch (ask (msgnum)) {
2431 case NOTOK: /* QUIT */
2432 break;
2433
2434 case OK: /* INTR */
2435 continue;
2436
2437 default:
2438 if (mp->numsel == 1 && headersw)
2439 show (msgnum);
2440 if (nshow)
2441 copy_message (msgnum, stdout);
2442 else
2443 process (msgnum, proc, vecp, vec);
2444
2445 if (seqnum != -1)
2446 seq_delmsg (mp, "unseen", msgnum);
2447 continue;
2448 }
2449 break;
2450 }
2451 }
2452
2453 seq_setcur (mp, mp->hghsel);
2454 }
2455
2456
2457 static void
2458 show (int msgnum)
2459 {
2460 if (Msgs[msgnum].m_bboard_id == 0)
2461 readid (msgnum);
2462
2463 printf ("(Message %d", msgnum);
2464 if (Msgs[msgnum].m_bboard_id > 0)
2465 printf (", %s: %d", BBoard_ID, Msgs[msgnum].m_bboard_id);
2466 printf (")\n");
2467 }
2468
2469
2470
2471 static int
2472 eom_action (int c)
2473 {
2474 return (ftell (mhlfp) >= Msgs[mhlnum].m_stop);
2475 }
2476
2477
2478 static FILE *
2479 mhl_action (char *name)
2480 {
2481 int msgnum;
2482
2483 if ((msgnum = m_atoi (name)) < mp->lowmsg
2484 || msgnum > mp->hghmsg
2485 || !does_exist (mp, msgnum))
2486 return NULL;
2487 mhlnum = msgnum;
2488
2489 mhlfp = msh_ready (msgnum, 1);
2490 if (!fmsh)
2491 m_eomsbr (eom_action);
2492
2493 return mhlfp;
2494 }
2495
2496
2497
2498 static int
2499 ask (int msgnum)
2500 {
2501 char buf[BUFSIZ];
2502
2503 if (mp->numsel == 1 || !interactive || redirected)
2504 return DONE;
2505
2506 if (SOprintf ("Press <return> to list \"%d\"...", msgnum)) {
2507 if (mp->lowsel != msgnum)
2508 printf ("\n\n\n");
2509 printf ("Press <return> to list \"%d\"...", msgnum);
2510 }
2511 fflush (stdout);
2512 buf[0] = 0;
2513
2514 #ifndef BSD42
2515 read (fileno (stdout), buf, sizeof buf);
2516 #else /* BSD42 */
2517 switch (setjmp (sigenv)) {
2518 case OK:
2519 should_intr = 1;
2520 read (fileno (stdout), buf, sizeof buf);/* fall... */
2521
2522 default:
2523 should_intr = 0;
2524 break;
2525 }
2526 #endif /* BSD42 */
2527
2528 if (strchr(buf, '\n') == NULL)
2529 putchar ('\n');
2530
2531 if (told_to_quit) {
2532 told_to_quit = interrupted = 0;
2533 return NOTOK;
2534 }
2535 if (interrupted) {
2536 interrupted = 0;
2537 return OK;
2538 }
2539
2540 return DONE;
2541 }
2542
2543
2544 #include <h/mime.h>
2545
2546 static int
2547 is_nontext (int msgnum)
2548 {
2549 int result, state;
2550 char *bp, *cp, *dp;
2551 char buf[BUFSIZ], name[NAMESZ];
2552 FILE *fp;
2553
2554 if (Msgs[msgnum].m_flags & MHNCHK)
2555 return (Msgs[msgnum].m_flags & MHNYES);
2556 Msgs[msgnum].m_flags |= MHNCHK;
2557
2558 fp = msh_ready (msgnum, 1);
2559
2560 for (state = FLD;;)
2561 switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
2562 case FLD:
2563 case FLDPLUS:
2564 case FLDEOF:
2565 /*
2566 * Check Content-Type field
2567 */
2568 if (!strcasecmp (name, TYPE_FIELD)) {
2569 int passno;
2570 char c;
2571
2572 cp = add (buf, NULL);
2573 while (state == FLDPLUS) {
2574 state = m_getfld (state, name, buf, sizeof buf, fp);
2575 cp = add (buf, cp);
2576 }
2577 bp = cp;
2578 passno = 1;
2579
2580 again:
2581 for (; isspace (*bp); bp++)
2582 continue;
2583 if (*bp == '(') {
2584 int i;
2585
2586 for (bp++, i = 0;;) {
2587 switch (*bp++) {
2588 case '\0':
2589 invalid:
2590 result = 0;
2591 goto out;
2592 case '\\':
2593 if (*bp++ == '\0')
2594 goto invalid;
2595 continue;
2596 case '(':
2597 i++;
2598 /* and fall... */
2599 default:
2600 continue;
2601 case ')':
2602 if (--i < 0)
2603 break;
2604 continue;
2605 }
2606 break;
2607 }
2608 }
2609 if (passno == 2) {
2610 if (*bp != '/')
2611 goto invalid;
2612 bp++;
2613 passno = 3;
2614 goto again;
2615 }
2616 for (dp = bp; istoken (*dp); dp++)
2617 continue;
2618 c = *dp;
2619 *dp = '\0';
2620 if (!*bp)
2621 goto invalid;
2622 if (passno > 1) {
2623 if ((result = (strcasecmp (bp, "plain") != 0)))
2624 goto out;
2625 *dp = c;
2626 for (dp++; isspace (*dp); dp++)
2627 continue;
2628 if (*dp) {
2629 if ((result = !uprf (dp, "charset")))
2630 goto out;
2631 dp += sizeof "charset" - 1;
2632 while (isspace (*dp))
2633 dp++;
2634 if (*dp++ != '=')
2635 goto invalid;
2636 while (isspace (*dp))
2637 dp++;
2638 if (*dp == '"') {
2639 if ((bp = strchr(++dp, '"')))
2640 *bp = '\0';
2641 } else {
2642 for (bp = dp; *bp; bp++)
2643 if (isspace (*bp)) {
2644 *bp = '\0';
2645 break;
2646 }
2647 }
2648 } else {
2649 /* Default character set */
2650 dp = "US-ASCII";
2651 }
2652 /* Check the character set */
2653 result = !check_charset (dp, strlen (dp));
2654 } else {
2655 if (!(result = (strcasecmp (bp, "text") != 0))) {
2656 *dp = c;
2657 bp = dp;
2658 passno = 2;
2659 goto again;
2660 }
2661 }
2662 out:
2663 free (cp);
2664 if (result) {
2665 Msgs[msgnum].m_flags |= MHNYES;
2666 return result;
2667 }
2668 break;
2669 }
2670
2671 /*
2672 * Check Content-Transfer-Encoding field
2673 */
2674 if (!strcasecmp (name, ENCODING_FIELD)) {
2675 cp = add (buf, NULL);
2676 while (state == FLDPLUS) {
2677 state = m_getfld (state, name, buf, sizeof buf, fp);
2678 cp = add (buf, cp);
2679 }
2680 for (bp = cp; isspace (*bp); bp++)
2681 continue;
2682 for (dp = bp; istoken (*dp); dp++)
2683 continue;
2684 *dp = '\0';
2685 result = (strcasecmp (bp, "7bit")
2686 && strcasecmp (bp, "8bit")
2687 && strcasecmp (bp, "binary"));
2688
2689 free (cp);
2690 if (result) {
2691 Msgs[msgnum].m_flags |= MHNYES;
2692 return result;
2693 }
2694 break;
2695 }
2696
2697 /*
2698 * Just skip the rest of this header
2699 * field and go to next one.
2700 */
2701 while (state == FLDPLUS)
2702 state = m_getfld (state, name, buf, sizeof(buf), fp);
2703 break;
2704
2705 /*
2706 * We've passed the message header,
2707 * so message is just text.
2708 */
2709 default:
2710 return 0;
2711 }
2712 }
2713
2714
2715 static struct swit sortswit[] = {
2716 #define SODATE 0
2717 { "datefield field", 0 },
2718 #define SOSUBJ 1
2719 { "textfield field", 0 },
2720 #define SONSUBJ 2
2721 { "notextfield", 0 },
2722 #define SOLIMT 3
2723 { "limit days", 0 },
2724 #define SONLIMT 4
2725 { "nolimit", 0 },
2726 #define SOVERB 5
2727 { "verbose", 0 },
2728 #define SONVERB 6
2729 { "noverbose", 0 },
2730 #define SOHELP 7
2731 { "help", 0 },
2732 { NULL, 0 }
2733 };
2734
2735
2736 void
2737 sortcmd (char **args)
2738 {
2739 int msgp = 0, msgnum;
2740 char *cp, *datesw = NULL, *subjsw = NULL;
2741 char buf[BUFSIZ], *msgs[MAXARGS];
2742 struct tws tb;
2743
2744 if (fmsh) {
2745 forkcmd (args, cmd_name);
2746 return;
2747 }
2748
2749 while ((cp = *args++)) {
2750 if (*cp == '-')
2751 switch (smatch (++cp, sortswit)) {
2752 case AMBIGSW:
2753 ambigsw (cp, sortswit);
2754 return;
2755 case UNKWNSW:
2756 fprintf (stderr, "-%s unknown\n", cp);
2757 return;
2758 case SOHELP:
2759 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2760 print_help (buf, sortswit, 1);
2761 return;
2762
2763 case SODATE:
2764 if (datesw) {
2765 advise (NULL, "only one date field at a time!");
2766 return;
2767 }
2768 if (!(datesw = *args++) || *datesw == '-') {
2769 advise (NULL, "missing argument to %s", args[-2]);
2770 return;
2771 }
2772 continue;
2773
2774 case SOSUBJ:
2775 if (subjsw) {
2776 advise (NULL, "only one text field at a time!");
2777 return;
2778 }
2779 if (!(subjsw = *args++) || *subjsw == '-') {
2780 advise (NULL, "missing argument to %s", args[-2]);
2781 return;
2782 }
2783 continue;
2784 case SONSUBJ:
2785 subjsw = (char *)0;
2786 continue;
2787
2788 case SOLIMT: /* too hard */
2789 if (!(cp = *args++) || *cp == '-') {
2790 advise (NULL, "missing argument to %s", args[-2]);
2791 return;
2792 }
2793 case SONLIMT:
2794 case SOVERB: /* not implemented */
2795 case SONVERB:
2796 continue;
2797 }
2798 if (*cp == '+' || *cp == '@') {
2799 advise (NULL, "sorry, no folders allowed!");
2800 return;
2801 }
2802 else
2803 msgs[msgp++] = cp;
2804 }
2805
2806 if (!msgp)
2807 msgs[msgp++] = "all";
2808 if (!datesw)
2809 datesw = "Date";
2810 for (msgnum = 0; msgnum < msgp; msgnum++)
2811 if (!m_convert (mp, msgs[msgnum]))
2812 return;
2813 seq_setprev (mp);
2814
2815 twscopy (&tb, dlocaltimenow ());
2816
2817 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2818 if (Msgs[msgnum].m_scanl) {
2819 free (Msgs[msgnum].m_scanl);
2820 Msgs[msgnum].m_scanl = NULL;
2821 }
2822 if (is_selected (mp, msgnum)) {
2823 if (get_fields (datesw, subjsw, msgnum, &Msgs[msgnum]))
2824 twscopy (&Msgs[msgnum].m_tb,
2825 msgnum != mp->lowsel ? &Msgs[msgnum - 1].m_tb : &tb);
2826 }
2827 else /* m_scaln is already NULL */
2828 twscopy (&Msgs[msgnum].m_tb, &tb);
2829 Msgs[msgnum].m_stats = mp->msgstats[msgnum - mp->lowoff];
2830 if (mp->curmsg == msgnum)
2831 Msgs[msgnum].m_stats |= CUR;
2832 }
2833
2834 qsort ((char *) &Msgs[mp->lowsel], mp->hghsel - mp->lowsel + 1,
2835 sizeof(struct Msg), (qsort_comp) (subjsw ? subsort : msgsort));
2836
2837 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2838 if (subjsw && Msgs[msgnum].m_scanl) {
2839 free (Msgs[msgnum].m_scanl); /* from subjsort */
2840 Msgs[msgnum].m_scanl = NULL;
2841 }
2842 mp->msgstats[msgnum - mp->lowoff] = Msgs[msgnum].m_stats & ~CUR;
2843 if (Msgs[msgnum].m_stats & CUR)
2844 seq_setcur (mp, msgnum);
2845 }
2846
2847 mp->msgflags |= MODIFIED;
2848 modified++;
2849 }
2850
2851
2852 /*
2853 * get_fields - parse message, and get date and subject if needed.
2854 * We'll use the msgp->m_tb tws struct for the date, and overload
2855 * the msgp->m_scanl field with our subject string.
2856 */
2857 static int
2858 get_fields (char *datesw, char *subjsw, int msgnum, struct Msg *msgp)
2859 {
2860 int state, gotdate = 0;
2861 char *bp, buf[BUFSIZ], name[NAMESZ];
2862 struct tws *tw = (struct tws *) 0;
2863 register FILE *zp;
2864
2865 zp = msh_ready (msgnum, 0);
2866 for (state = FLD;;) {
2867 switch (state = m_getfld (state, name, buf, sizeof buf, zp)) {
2868 case FLD:
2869 case FLDEOF:
2870 case FLDPLUS:
2871 if (!strcasecmp (name, datesw)) {
2872 bp = getcpy (buf);
2873 while (state == FLDPLUS) {
2874 state = m_getfld (state, name, buf, sizeof buf, zp);
2875 bp = add (buf, bp);
2876 }
2877 if ((tw = dparsetime (bp)) == NULL)
2878 admonish (NULL,
2879 "unable to parse %s field in message %d",
2880 datesw, msgnum);
2881 else
2882 twscopy (&(msgp->m_tb), tw);
2883 free (bp);
2884 if (!subjsw) /* not using this, or already done */
2885 break; /* all done! */
2886 gotdate++;
2887 }
2888 else if (subjsw && !strcasecmp(name, subjsw)) {
2889 bp = getcpy (buf);
2890 while (state == FLDPLUS) {
2891 state = m_getfld (state, name, buf, sizeof buf, zp);
2892 bp = add (buf, bp);
2893 }
2894 msgp->m_scanl = sosmash(subjsw, bp);
2895 if (gotdate)
2896 break; /* date done so we're done */
2897 else
2898 subjsw = (char *)0;/* subject done, need date */
2899 } else {
2900 while (state == FLDPLUS) /* flush this one */
2901 state = m_getfld (state, name, buf, sizeof buf, zp);
2902 }
2903 continue;
2904
2905 case BODY:
2906 case BODYEOF:
2907 case FILEEOF:
2908 break;
2909
2910 case LENERR:
2911 case FMTERR:
2912 admonish (NULL, "format error in message %d", msgnum);
2913 if (msgp->m_scanl) { /* this might need free'd */
2914 free (msgp->m_scanl); /* probably can't use subj anyway */
2915 msgp->m_scanl = NULL;
2916 }
2917 return NOTOK;
2918
2919 default:
2920 adios (NULL, "internal error -- you lose");
2921 }
2922 break;
2923 }
2924 if (tw)
2925 return OK; /* not an error if subj not found */
2926
2927 admonish (NULL, "no %s field in message %d", datesw, msgnum);
2928 return NOTOK; /* NOTOK means use some other date */
2929 }
2930
2931
2932 /*
2933 * sort routines
2934 */
2935
2936 static int
2937 msgsort (struct Msg *a, struct Msg *b)
2938 {
2939 return twsort (&a->m_tb, &b->m_tb);
2940 }
2941
2942
2943 static int
2944 subsort (struct Msg *a, struct Msg *b)
2945 {
2946 register int i;
2947
2948 if (a->m_scanl && b->m_scanl)
2949 if ((i = strcmp (a->m_scanl, b->m_scanl)))
2950 return (i);
2951
2952 return twsort (&a->m_tb, &b->m_tb);
2953 }
2954
2955
2956 /*
2957 * try to make the subject "canonical": delete leading "re:", everything
2958 * but letters & smash letters to lower case.
2959 */
2960 static char *
2961 sosmash (char *subj, char *s)
2962 {
2963 register char *cp, *dp, c;
2964
2965 if (s) {
2966 cp = s;
2967 dp = s; /* dst pointer */
2968 if (!strcasecmp (subj, "subject"))
2969 while ((c = *cp)) {
2970 if (! isspace(c)) {
2971 if(uprf(cp, "re:"))
2972 cp += 2;
2973 else {
2974 if (isalnum(c))
2975 *dp++ = isupper(c) ? tolower(c) : c;
2976 break;
2977 }
2978 }
2979 cp++;
2980 }
2981 while ((c = *cp++)) {
2982 if (isalnum(c))
2983 *dp++ = isupper(c) ? tolower(c) : c;
2984
2985 }
2986 *dp = '\0';
2987 }
2988 return s;
2989 }
2990
2991
2992 static int
2993 process (int msgnum, char *proc, int vecp, char **vec)
2994 {
2995 int child_id, status;
2996 char tmpfil[80];
2997 FILE *out;
2998
2999 if (fmsh) {
3000 strncpy (tmpfil, m_name (msgnum), sizeof(tmpfil));
3001 context_del (pfolder);
3002 context_replace (pfolder, fmsh);/* update current folder */
3003 seq_save (mp);
3004 context_save (); /* save the context file */
3005 goto ready;
3006 }
3007
3008 strncpy (tmpfil, m_scratch ("", invo_name), sizeof(tmpfil));
3009 if ((out = fopen (tmpfil, "w")) == NULL) {
3010 int olderr;
3011 char newfil[80];
3012
3013 olderr = errno;
3014 strncpy (newfil, m_tmpfil (invo_name), sizeof(newfil));
3015 if ((out = fopen (newfil, "w")) == NULL) {
3016 errno = olderr;
3017 advise (tmpfil, "unable to create temporary file");
3018 return NOTOK;
3019 } else {
3020 strncpy (tmpfil, newfil, sizeof(tmpfil));
3021 }
3022 }
3023 copy_message (msgnum, out);
3024 fclose (out);
3025
3026 ready: ;
3027 fflush (stdout);
3028 switch (child_id = fork ()) {
3029 case NOTOK:
3030 advise ("fork", "unable to");
3031 status = NOTOK;
3032 break;
3033
3034 case OK:
3035 closefds (3);
3036 SIGNAL (SIGINT, istat);
3037 SIGNAL (SIGQUIT, qstat);
3038
3039 vec[vecp++] = tmpfil;
3040 vec[vecp] = NULL;
3041
3042 execvp (proc, vec);
3043 fprintf (stderr, "unable to exec ");
3044 perror (proc);
3045 _exit (1);
3046
3047 default:
3048 status = pidXwait (child_id, NULL);
3049 break;
3050 }
3051
3052 if (!fmsh)
3053 unlink (tmpfil);
3054 return status;
3055 }
3056
3057
3058 static void
3059 copy_message (int msgnum, FILE *out)
3060 {
3061 long pos;
3062 static char buffer[BUFSIZ];
3063 register FILE *zp;
3064
3065 zp = msh_ready (msgnum, 1);
3066 if (fmsh) {
3067 while (fgets (buffer, sizeof buffer, zp) != NULL) {
3068 fputs (buffer, out);
3069 if (interrupted && out == stdout)
3070 break;
3071 }
3072 }
3073 else {
3074 pos = ftell (zp);
3075 while (fgets (buffer, sizeof buffer, zp) != NULL
3076 && pos < Msgs[msgnum].m_stop) {
3077 fputs (buffer, out);
3078 pos += (long) strlen (buffer);
3079 if (interrupted && out == stdout)
3080 break;
3081 }
3082 }
3083 }
3084
3085
3086 static void
3087 copy_digest (int msgnum, FILE *out)
3088 {
3089 char c;
3090 long pos;
3091 static char buffer[BUFSIZ];
3092 register FILE *zp;
3093
3094 c = '\n';
3095 zp = msh_ready (msgnum, 1);
3096 if (!fmsh)
3097 pos = ftell (zp);
3098 while (fgets (buffer, sizeof buffer, zp) != NULL
3099 && !fmsh && pos < Msgs[msgnum].m_stop) {
3100 if (c == '\n' && *buffer == '-')
3101 fputc (' ', out);
3102 fputs (buffer, out);
3103 c = buffer[strlen (buffer) - 1];
3104 if (!fmsh)
3105 pos += (long) strlen (buffer);
3106 if (interrupted && out == stdout)
3107 break;
3108 }
3109 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git