]> diplodocus.org Git - nmh/blob - uip/mshcmds.c
projects / nmh / blob
? search:


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