]> diplodocus.org Git - nmh/blob - uip/mshcmds.c
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
We're not using the .Bu macro anymore.
[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
871 if (fmsh) {
872 forkcmd (args, cmd_name);
873 return;
874 }
875
876 while ((cp = *args++)) {
877 if (*cp == '-')
878 switch (smatch (++cp, forwswit)) {
879 case AMBIGSW:
880 ambigsw (cp, forwswit);
881 return;
882 case UNKWNSW:
883 fprintf (stderr, "-%s unknown\n", cp);
884 return;
885 case FOHELP:
886 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
887 print_help (buf, forwswit, 1);
888 return;
889
890 case FOANSW: /* not implemented */
891 case FONANSW:
892 case FOINSW:
893 case FONINSW:
894 case FOMISW:
895 case FONMISW:
896 continue;
897
898 case FONDFSW:
899 case FONEDSW:
900 case FONWTSW:
901 vec[vecp++] = --cp;
902 continue;
903
904 case FOEDTSW:
905 case FOFRMSW:
906 case FODFSW:
907 case FODMSW:
908 case FOWHTSW:
909 vec[vecp++] = --cp;
910 if (!(cp = *args++) || *cp == '-') {
911 advise (NULL, "missing argument to %s", args[-2]);
912 return;
913 }
914 vec[vecp++] = cp;
915 continue;
916 case FOFTRSW:
917 if (!(filter = *args++) || *filter == '-') {
918 advise (NULL, "missing argument to %s", args[-2]);
919 return;
920 }
921 continue;
922 case FOFTSW:
923 if (access (filter = myfilter, R_OK) == NOTOK) {
924 advise (filter, "unable to read default filter file");
925 return;
926 }
927 continue;
928 case FONFTSW:
929 filter = NULL;
930 continue;
931 }
932 if (*cp == '+' || *cp == '@') {
933 advise (NULL, "sorry, no folders allowed!");
934 return;
935 }
936 else
937 msgs[msgp++] = cp;
938 }
939
940 /* foil search of .mh_profile */
941 snprintf (buf, sizeof(buf), "%sXXXXXX", invo_name);
942 /*
943 Mkstemp work postponed until later -Doug
944 #ifdef HAVE_MKSTEMP
945 vec[0] = (char *)mkstemp (buf);
946 #else
947 */
948 vec[0] = (char *)mktemp (buf);
949 /*
950 #endif
951 */
952 vec[vecp++] = "-file";
953 vec[vecp] = NULL;
954 if (!msgp)
955 msgs[msgp++] = "cur";
956 for (msgnum = 0; msgnum < msgp; msgnum++)
957 if (!m_convert (mp, msgs[msgnum]))
958 return;
959 seq_setprev (mp);
960
961 if (filter) {
962 strncpy (buf, filter, sizeof(buf));
963 if (expand (buf) == NOTOK)
964 return;
965 if (access (filter = getcpy (etcpath (buf)), R_OK) == NOTOK) {
966 advise (filter, "unable to read");
967 free (filter);
968 return;
969 }
970 }
971 forw (cmd_name, filter, vecp, vec);
972 seq_setcur (mp, mp->hghsel);
973 if (filter)
974 free (filter);
975 }
976
977
978 static void
979 forw (char *proc, char *filter, int vecp, char **vec)
980 {
981 int i, child_id, msgnum, msgcnt;
982 char tmpfil[80], *args[MAXARGS];
983 FILE *out;
984
985 strncpy (tmpfil, m_tmpfil (invo_name), sizeof(tmpfil));
986 interrupted = 0;
987 if (filter)
988 switch (child_id = fork ()) {
989 case NOTOK:
990 advise ("fork", "unable to");
991 return;
992
993 case OK: /* "trust me" */
994 if (freopen (tmpfil, "w", stdout) == NULL) {
995 fprintf (stderr, "unable to create ");
996 perror (tmpfil);
997 _exit (1);
998 }
999 args[0] = r1bindex (mhlproc, '/');
1000 i = 1;
1001 args[i++] = "-forwall";
1002 args[i++] = "-form";
1003 args[i++] = filter;
1004 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1005 if (is_selected (mp, msgnum))
1006 args[i++] = getcpy (m_name (msgnum));
1007 args[i] = NULL;
1008 mhlsbr (i, args, mhl_action);
1009 m_eomsbr ((int (*) ()) 0);
1010 fclose (stdout);
1011 _exit (0);
1012
1013 default:
1014 if (pidXwait (child_id, NULL))
1015 interrupted++;
1016 break;
1017 }
1018 else {
1019 if ((out = fopen (tmpfil, "w")) == NULL) {
1020 advise (tmpfil, "unable to create temporary file");
1021 return;
1022 }
1023
1024 msgcnt = 1;
1025 for (msgnum = mp->lowsel;
1026 msgnum <= mp->hghsel && !interrupted;
1027 msgnum++)
1028 if (is_selected (mp, msgnum)) {
1029 fprintf (out, "\n\n-------");
1030 if (msgnum == mp->lowsel)
1031 fprintf (out, " Forwarded Message%s",
1032 mp->numsel > 1 ? "s" : "");
1033 else
1034 fprintf (out, " Message %d", msgcnt);
1035 fprintf (out, "\n\n");
1036 copy_digest (msgnum, out);
1037 msgcnt++;
1038 }
1039
1040 fprintf (out, "\n\n------- End of Forwarded Message%s\n",
1041 mp->numsel > 1 ? "s" : "");
1042 fclose (out);
1043 }
1044
1045 fflush (stdout);
1046 if (!interrupted)
1047 switch (child_id = fork ()) {
1048 case NOTOK:
1049 advise ("fork", "unable to");
1050 break;
1051
1052 case OK:
1053 closefds (3);
1054 SIGNAL (SIGINT, istat);
1055 SIGNAL (SIGQUIT, qstat);
1056
1057 vec[vecp++] = tmpfil;
1058 vec[vecp] = NULL;
1059
1060 execvp (proc, vec);
1061 fprintf (stderr, "unable to exec ");
1062 perror (proc);
1063 _exit (1);
1064
1065 default:
1066 pidXwait (child_id, NULL);
1067 break;
1068 }
1069
1070 unlink (tmpfil);
1071 }
1072
1073
1074 static char *hlpmsg[] = {
1075 "The %s program emulates many of the commands found in the nmh",
1076 "system. Instead of operating on nmh folders, commands to %s concern",
1077 "a single file.",
1078 "",
1079 "To see the list of commands available, just type a ``?'' followed by",
1080 "the RETURN key. To find out what switches each command takes, type",
1081 "the name of the command followed by ``-help''. To leave %s, use the",
1082 "``quit'' command.",
1083 "",
1084 "Although a lot of nmh commands are found in %s, not all are fully",
1085 "implemented. %s will always recognize all legal switches for a",
1086 "given command though, and will let you know when you ask for an",
1087 "option that it is unable to perform.",
1088 "",
1089 "Running %s is fun, but using nmh from your shell is far superior.",
1090 "After you have familiarized yourself with the nmh style by using %s,",
1091 "you should try using nmh from the shell. You can still use %s for",
1092 "message files that aren't in nmh format, such as BBoard files.",
1093 NULL
1094 };
1095
1096
1097 void
1098 helpcmd (char **args)
1099 {
1100 int i;
1101
1102 for (i = 0; hlpmsg[i]; i++) {
1103 printf (hlpmsg[i], invo_name);
1104 putchar ('\n');
1105 }
1106 }
1107
1108
1109 static struct swit markswit[] = {
1110 #define MADDSW 0
1111 { "add", 0 },
1112 #define MDELSW 1
1113 { "delete", 0 },
1114 #define MLSTSW 2
1115 { "list", 0 },
1116 #define MSEQSW 3
1117 { "sequence name", 0 },
1118 #define MPUBSW 4
1119 { "public", 0 },
1120 #define MNPUBSW 5
1121 { "nopublic", 0 },
1122 #define MZERSW 6
1123 { "zero", 0 },
1124 #define MNZERSW 7
1125 { "nozero", 0 },
1126 #define MHELP 8
1127 { "help", 0 },
1128 #define MDBUGSW 9
1129 { "debug", -5 },
1130 { NULL, 0 }
1131 };
1132
1133
1134 void
1135 markcmd (char **args)
1136 {
1137 int addsw = 0, deletesw = 0, debugsw = 0;
1138 int listsw = 0, zerosw = 0, seqp = 0;
1139 int msgp = 0, msgnum;
1140 char *cp, buf[BUFSIZ];
1141 char *seqs[NUMATTRS + 1], *msgs[MAXARGS];
1142
1143 while ((cp = *args++)) {
1144 if (*cp == '-') {
1145 switch (smatch (++cp, markswit)) {
1146 case AMBIGSW:
1147 ambigsw (cp, markswit);
1148 return;
1149 case UNKWNSW:
1150 fprintf (stderr, "-%s unknown\n", cp);
1151 return;
1152 case MHELP:
1153 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1154 print_help (buf, markswit, 1);
1155 return;
1156
1157 case MADDSW:
1158 addsw++;
1159 deletesw = listsw = 0;
1160 continue;
1161 case MDELSW:
1162 deletesw++;
1163 addsw = listsw = 0;
1164 continue;
1165 case MLSTSW:
1166 listsw++;
1167 addsw = deletesw = 0;
1168 continue;
1169
1170 case MSEQSW:
1171 if (!(cp = *args++) || *cp == '-') {
1172 advise (NULL, "missing argument to %s", args[-2]);
1173 return;
1174 }
1175 if (seqp < NUMATTRS)
1176 seqs[seqp++] = cp;
1177 else {
1178 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1179 return;
1180 }
1181 continue;
1182
1183 case MPUBSW: /* not implemented */
1184 case MNPUBSW:
1185 continue;
1186
1187 case MDBUGSW:
1188 debugsw++;
1189 continue;
1190
1191 case MZERSW:
1192 zerosw++;
1193 continue;
1194 case MNZERSW:
1195 zerosw = 0;
1196 continue;
1197 }
1198 }
1199 if (*cp == '+' || *cp == '@') {
1200 advise (NULL, "sorry, no folders allowed!");
1201 return;
1202 } else {
1203 msgs[msgp++] = cp;
1204 }
1205 }
1206
1207 if (!addsw && !deletesw && !listsw) {
1208 if (seqp)
1209 addsw++;
1210 else
1211 if (debugsw)
1212 listsw++;
1213 else {
1214 seqs[seqp++] = "unseen";
1215 deletesw++;
1216 zerosw = 0;
1217 if (!msgp)
1218 msgs[msgp++] = "all";
1219 }
1220 }
1221
1222 if (!msgp)
1223 msgs[msgp++] = listsw ? "all" :"cur";
1224 for (msgnum = 0; msgnum < msgp; msgnum++)
1225 if (!m_convert (mp, msgs[msgnum]))
1226 return;
1227
1228 if (debugsw) {
1229 printf ("invo_name=%s mypath=%s defpath=%s\n",
1230 invo_name, mypath, defpath);
1231 printf ("ctxpath=%s context flags=%s\n",
1232 ctxpath, snprintb (buf, sizeof(buf), (unsigned) ctxflags, DBITS));
1233 printf ("foldpath=%s flags=%s\n",
1234 mp->foldpath,
1235 snprintb (buf, sizeof(buf), (unsigned) mp->msgflags, FBITS));
1236 printf ("hghmsg=%d lowmsg=%d nummsg=%d curmsg=%d\n",
1237 mp->hghmsg, mp->lowmsg, mp->nummsg, mp->curmsg);
1238 printf ("lowsel=%d hghsel=%d numsel=%d\n",
1239 mp->lowsel, mp->hghsel, mp->numsel);
1240 printf ("lowoff=%d hghoff=%d\n", mp->lowoff, mp->hghoff);
1241 }
1242
1243 if (seqp == 0 && (addsw || deletesw)) {
1244 advise (NULL, "-%s requires at least one -sequence argument",
1245 addsw ? "add" : "delete");
1246 return;
1247 }
1248 seqs[seqp] = NULL;
1249
1250 if (addsw) {
1251 for (seqp = 0; seqs[seqp]; seqp++)
1252 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1253 return;
1254 }
1255
1256 if (deletesw) {
1257 for (seqp = 0; seqs[seqp]; seqp++)
1258 if (!seq_delsel (mp, seqs[seqp], 0, zerosw))
1259 return;
1260 }
1261
1262 /* Listing messages in sequences */
1263 if (listsw) {
1264 if (seqp) {
1265 /* list the given sequences */
1266 for (seqp = 0; seqs[seqp]; seqp++)
1267 seq_print (mp, seqs[seqp]);
1268 } else {
1269 /* else list them all */
1270 seq_printall (mp);
1271 }
1272
1273 interrupted = 0;
1274 if (debugsw)
1275 for (msgnum = mp->lowsel;
1276 msgnum <= mp->hghsel && !interrupted;
1277 msgnum++)
1278 if (is_selected (mp, msgnum)) {
1279 printf ("%*d: id=%d top=%d start=%ld stop=%ld %s\n",
1280 DMAXFOLDER,
1281 msgnum,
1282 Msgs[msgnum].m_bboard_id,
1283 Msgs[msgnum].m_top,
1284 (long) Msgs[msgnum].m_start,
1285 (long) Msgs[msgnum].m_stop,
1286 snprintb (buf, sizeof(buf),
1287 (unsigned) mp->msgstats[msgnum - mp->lowoff],
1288 seq_bits (mp)));
1289 if (Msgs[msgnum].m_scanl)
1290 printf ("%s", Msgs[msgnum].m_scanl);
1291 }
1292 }
1293 }
1294
1295
1296 static struct swit mhnswit[] = {
1297 #define MHNAUTOSW 0
1298 { "auto", 0 },
1299 #define MHNNAUTOSW 1
1300 { "noauto", 0 },
1301 #define MHNDEBUGSW 2
1302 { "debug", -5 },
1303 #define MHNEBCDICSW 3
1304 { "ebcdicsafe", 0 },
1305 #define MHNNEBCDICSW 4
1306 { "noebcdicsafe", 0 },
1307 #define MHNFORMSW 5
1308 { "form formfile", 4 },
1309 #define MHNHEADSW 6
1310 { "headers", 0 },
1311 #define MHNNHEADSW 7
1312 { "noheaders", 0 },
1313 #define MHNLISTSW 8
1314 { "list", 0 },
1315 #define MHNNLISTSW 9
1316 { "nolist", 0 },
1317 #define MHNPARTSW 10
1318 { "part number", 0 },
1319 #define MHNSIZESW 11
1320 { "realsize", 0 },
1321 #define MHNNSIZESW 12
1322 { "norealsize", 0 },
1323 #define MHNRFC934SW 13
1324 { "rfc934mode", 0 },
1325 #define MHNNRFC934SW 14
1326 { "norfc934mode", 0 },
1327 #define MHNSERIALSW 15
1328 { "serialonly", 0 },
1329 #define MHNNSERIALSW 16
1330 { "noserialonly", 0 },
1331 #define MHNSHOWSW 17
1332 { "show", 0 },
1333 #define MHNNSHOWSW 18
1334 { "noshow", 0 },
1335 #define MHNSTORESW 19
1336 { "store", 0 },
1337 #define MHNNSTORESW 20
1338 { "nostore", 0 },
1339 #define MHNTYPESW 21
1340 { "type content", 0 },
1341 #define MHNVERBSW 22
1342 { "verbose", 0 },
1343 #define MHNNVERBSW 23
1344 { "noverbose", 0 },
1345 #define MHNHELPSW 24
1346 { "help", 0 },
1347 #define MHNPROGSW 25
1348 { "moreproc program", -4 },
1349 #define MHNNPROGSW 26
1350 { "nomoreproc", -3 },
1351 #define MHNLENSW 27
1352 { "length lines", -4 },
1353 #define MHNWIDSW 28
1354 { "width columns", -4 },
1355 { NULL, 0 }
1356 };
1357
1358
1359 void
1360 mhncmd (char **args)
1361 {
1362 int msgp = 0, vecp = 1;
1363 int msgnum;
1364 char *cp, buf[BUFSIZ];
1365 char *msgs[MAXARGS], *vec[MAXARGS];
1366
1367 if (fmsh) {
1368 forkcmd (args, cmd_name);
1369 return;
1370 }
1371 while ((cp = *args++)) {
1372 if (*cp == '-') {
1373 switch (smatch (++cp, mhnswit)) {
1374 case AMBIGSW:
1375 ambigsw (cp, mhnswit);
1376 return;
1377 case UNKWNSW:
1378 fprintf (stderr, "-%s unknown\n", cp);
1379 return;
1380 case MHNHELPSW:
1381 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1382 print_help (buf, mhnswit, 1);
1383 return;
1384
1385 case MHNAUTOSW:
1386 case MHNNAUTOSW:
1387 case MHNDEBUGSW:
1388 case MHNEBCDICSW:
1389 case MHNNEBCDICSW:
1390 case MHNHEADSW:
1391 case MHNNHEADSW:
1392 case MHNLISTSW:
1393 case MHNNLISTSW:
1394 case MHNSIZESW:
1395 case MHNNSIZESW:
1396 case MHNRFC934SW:
1397 case MHNNRFC934SW:
1398 case MHNSERIALSW:
1399 case MHNNSERIALSW:
1400 case MHNSHOWSW:
1401 case MHNNSHOWSW:
1402 case MHNSTORESW:
1403 case MHNNSTORESW:
1404 case MHNVERBSW:
1405 case MHNNVERBSW:
1406 case MHNNPROGSW:
1407 vec[vecp++] = --cp;
1408 continue;
1409
1410 case MHNFORMSW:
1411 case MHNPARTSW:
1412 case MHNTYPESW:
1413 case MHNPROGSW:
1414 case MHNLENSW:
1415 case MHNWIDSW:
1416 vec[vecp++] = --cp;
1417 if (!(cp = *args++) || *cp == '-') {
1418 advise (NULL, "missing argument to %s", args[-2]);
1419 return;
1420 }
1421 vec[vecp++] = cp;
1422 continue;
1423 }
1424 }
1425 if (*cp == '+' || *cp == '@') {
1426 advise (NULL, "sorry, no folders allowed!");
1427 return;
1428 } else {
1429 msgs[msgp++] = cp;
1430 }
1431 }
1432
1433 vec[0] = cmd_name;
1434 vec[vecp++] = "-file";
1435 vec[vecp] = NULL;
1436 if (!msgp)
1437 msgs[msgp++] = "cur";
1438 for (msgnum = 0; msgnum < msgp; msgnum++)
1439 if (!m_convert (mp, msgs[msgnum]))
1440 return;
1441 seq_setprev (mp);
1442
1443 interrupted = 0;
1444 for (msgnum = mp->lowsel;
1445 msgnum <= mp->hghsel && !interrupted;
1446 msgnum++)
1447 if (is_selected (mp, msgnum))
1448 if (process (msgnum, cmd_name, vecp, vec)) {
1449 unset_selected (mp, msgnum);
1450 mp->numsel--;
1451 }
1452
1453 seq_setcur (mp, mp->hghsel);
1454 }
1455
1456
1457 static struct swit packswit[] = {
1458 #define PAFISW 0
1459 { "file name", 0 },
1460 #define PAHELP 1
1461 { "help", 0 },
1462 { NULL, 0 }
1463 };
1464
1465 static int mbx_style = MMDF_FORMAT;
1466
1467 void
1468 packcmd (char **args)
1469 {
1470 int msgp = 0, md, msgnum;
1471 char *cp, *file = NULL;
1472 char buf[BUFSIZ], *msgs[MAXARGS];
1473 struct stat st;
1474
1475 if (fmsh) {
1476 forkcmd (args, cmd_name);
1477 return;
1478 }
1479
1480 while ((cp = *args++)) {
1481 if (*cp == '-')
1482 switch (smatch (++cp, packswit)) {
1483 case AMBIGSW:
1484 ambigsw (cp, packswit);
1485 return;
1486 case UNKWNSW:
1487 fprintf (stderr, "-%s unknown\n", cp);
1488 return;
1489 case PAHELP:
1490 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1491 print_help (buf, packswit, 1);
1492 return;
1493
1494 case PAFISW:
1495 if (!(file = *args++) || *file == '-') {
1496 advise (NULL, "missing argument to %s", args[-2]);
1497 return;
1498 }
1499 continue;
1500 }
1501 if (*cp == '+' || *cp == '@') {
1502 advise (NULL, "sorry, no folders allowed!");
1503 return;
1504 }
1505 else
1506 msgs[msgp++] = cp;
1507 }
1508
1509 if (!file)
1510 file = "./msgbox";
1511 file = path (file, TFILE);
1512 if (stat (file, &st) == NOTOK) {
1513 if (errno != ENOENT) {
1514 advise (file, "error on file");
1515 goto done_pack;
1516 }
1517 md = getanswer (cp = concat ("Create file \"", file, "\"? ", NULL));
1518 free (cp);
1519 if (!md)
1520 goto done_pack;
1521 }
1522
1523 if (!msgp)
1524 msgs[msgp++] = "all";
1525 for (msgnum = 0; msgnum < msgp; msgnum++)
1526 if (!m_convert (mp, msgs[msgnum]))
1527 goto done_pack;
1528 seq_setprev (mp);
1529
1530 if ((md = mbx_open (file, mbx_style, getuid (), getgid (), m_gmprot ())) == NOTOK) {
1531 advise (file, "unable to open");
1532 goto done_pack;
1533 }
1534 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1535 if (is_selected (mp, msgnum))
1536 if (pack (file, md, msgnum) == NOTOK)
1537 break;
1538 mbx_close (file, md);
1539
1540 if (mp->hghsel != mp->curmsg)
1541 seq_setcur (mp, mp->lowsel);
1542
1543 done_pack: ;
1544 free (file);
1545 }
1546
1547
1548 int
1549 pack (char *mailbox, int md, int msgnum)
1550 {
1551 register FILE *zp;
1552
1553 if (Msgs[msgnum].m_bboard_id == 0)
1554 readid (msgnum);
1555
1556 zp = msh_ready (msgnum, 1);
1557 return mbx_write (mailbox, md, zp, Msgs[msgnum].m_bboard_id,
1558 0L, ftell (zp), Msgs[msgnum].m_stop, 1, 1);
1559 }
1560
1561
1562 int
1563 packhak (char **args)
1564 {
1565 int result;
1566 char *cp, *file = NULL;
1567
1568 while ((cp = *args++)) {
1569 if (*cp == '-')
1570 switch (smatch (++cp, packswit)) {
1571 case AMBIGSW:
1572 case UNKWNSW:
1573 case PAHELP:
1574 return NOTOK;
1575
1576 case PAFISW:
1577 if (!(file = *args++) || *file == '-')
1578 return NOTOK;
1579 continue;
1580 }
1581 if (*cp == '+' || *cp == '@')
1582 return NOTOK;
1583 }
1584
1585 file = path (file ? file : "./msgbox", TFILE);
1586 result = access (file, F_OK) == NOTOK ? OK : NOTOK;
1587 free (file);
1588
1589 return result;
1590 }
1591
1592
1593 static struct swit pickswit[] = {
1594 #define PIANSW 0
1595 { "and", 0 },
1596 #define PIORSW 1
1597 { "or", 0 },
1598 #define PINTSW 2
1599 { "not", 0 },
1600 #define PILBSW 3
1601 { "lbrace", 0 },
1602 #define PIRBSW 4
1603 { "rbrace", 0 },
1604 #define PICCSW 5
1605 { "cc pattern", 0 },
1606 #define PIDASW 6
1607 { "date pattern", 0 },
1608 #define PIFRSW 7
1609 { "from pattern", 0 },
1610 #define PISESW 8
1611 { "search pattern", 0 },
1612 #define PISUSW 9
1613 { "subject pattern", 0 },
1614 #define PITOSW 10
1615 { "to pattern", 0 },
1616 #define PIOTSW 11
1617 { "-othercomponent pattern", 15 },
1618 #define PIAFSW 12
1619 { "after date", 0 },
1620 #define PIBFSW 13
1621 { "before date", 0 },
1622 #define PIDFSW 14
1623 { "datefield field", 5 },
1624 #define PISQSW 15
1625 { "sequence name", 0 },
1626 #define PIPUSW 16
1627 { "public", 0 },
1628 #define PINPUSW 17
1629 { "nopublic", 0 },
1630 #define PIZRSW 18
1631 { "zero", 0 },
1632 #define PINZRSW 19
1633 { "nozero", 0 },
1634 #define PILISW 20
1635 { "list", 0 },
1636 #define PINLISW 21
1637 { "nolist", 0 },
1638 #define PIHELP 22
1639 { "help", 0 },
1640 { NULL, 0 }
1641 };
1642
1643
1644 void
1645 pickcmd (char **args)
1646 {
1647 int zerosw = 1, msgp = 0, seqp = 0;
1648 int vecp = 0, hi, lo, msgnum;
1649 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1650 char *seqs[NUMATTRS], *vec[MAXARGS];
1651 register FILE *zp;
1652
1653 while ((cp = *args++)) {
1654 if (*cp == '-') {
1655 if (*++cp == '-') {
1656 vec[vecp++] = --cp;
1657 goto pattern;
1658 }
1659 switch (smatch (cp, pickswit)) {
1660 case AMBIGSW:
1661 ambigsw (cp, pickswit);
1662 return;
1663 case UNKWNSW:
1664 fprintf (stderr, "-%s unknown\n", cp);
1665 return;
1666 case PIHELP:
1667 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1668 print_help (buf, pickswit, 1);
1669 return;
1670
1671 case PICCSW:
1672 case PIDASW:
1673 case PIFRSW:
1674 case PISUSW:
1675 case PITOSW:
1676 case PIDFSW:
1677 case PIAFSW:
1678 case PIBFSW:
1679 case PISESW:
1680 vec[vecp++] = --cp;
1681 pattern: ;
1682 if (!(cp = *args++)) {/* allow -xyz arguments */
1683 advise (NULL, "missing argument to %s", args[-2]);
1684 return;
1685 }
1686 vec[vecp++] = cp;
1687 continue;
1688 case PIOTSW:
1689 advise (NULL, "internal error!");
1690 return;
1691 case PIANSW:
1692 case PIORSW:
1693 case PINTSW:
1694 case PILBSW:
1695 case PIRBSW:
1696 vec[vecp++] = --cp;
1697 continue;
1698
1699 case PISQSW:
1700 if (!(cp = *args++) || *cp == '-') {
1701 advise (NULL, "missing argument to %s", args[-2]);
1702 return;
1703 }
1704 if (seqp < NUMATTRS)
1705 seqs[seqp++] = cp;
1706 else {
1707 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1708 return;
1709 }
1710 continue;
1711 case PIZRSW:
1712 zerosw++;
1713 continue;
1714 case PINZRSW:
1715 zerosw = 0;
1716 continue;
1717
1718 case PIPUSW: /* not implemented */
1719 case PINPUSW:
1720 case PILISW:
1721 case PINLISW:
1722 continue;
1723 }
1724 }
1725 if (*cp == '+' || *cp == '@') {
1726 advise (NULL, "sorry, no folders allowed!");
1727 return;
1728 }
1729 else
1730 msgs[msgp++] = cp;
1731 }
1732 vec[vecp] = NULL;
1733
1734 if (!msgp)
1735 msgs[msgp++] = "all";
1736 for (msgnum = 0; msgnum < msgp; msgnum++)
1737 if (!m_convert (mp, msgs[msgnum]))
1738 return;
1739 seq_setprev (mp);
1740
1741 interrupted = 0;
1742 if (!pcompile (vec, NULL))
1743 return;
1744
1745 lo = mp->lowsel;
1746 hi = mp->hghsel;
1747
1748 for (msgnum = mp->lowsel;
1749 msgnum <= mp->hghsel && !interrupted;
1750 msgnum++)
1751 if (is_selected (mp, msgnum)) {
1752 zp = msh_ready (msgnum, 1);
1753 if (pmatches (zp, msgnum, fmsh ? 0L : Msgs[msgnum].m_start,
1754 fmsh ? 0L : Msgs[msgnum].m_stop)) {
1755 if (msgnum < lo)
1756 lo = msgnum;
1757 if (msgnum > hi)
1758 hi = msgnum;
1759 }
1760 else {
1761 unset_selected (mp, msgnum);
1762 mp->numsel--;
1763 }
1764 }
1765
1766 if (interrupted)
1767 return;
1768
1769 mp->lowsel = lo;
1770 mp->hghsel = hi;
1771
1772 if (mp->numsel <= 0) {
1773 advise (NULL, "no messages match specification");
1774 return;
1775 }
1776
1777 seqs[seqp] = NULL;
1778 for (seqp = 0; seqs[seqp]; seqp++)
1779 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1780 return;
1781
1782 printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
1783 }
1784
1785
1786 static struct swit replswit[] = {
1787 #define REANSW 0
1788 { "annotate", 0 },
1789 #define RENANSW 1
1790 { "noannotate", 0 },
1791 #define RECCSW 2
1792 { "cc type", 0 },
1793 #define RENCCSW 3
1794 { "nocc type", 0 },
1795 #define REDFSW 4
1796 { "draftfolder +folder", 0 },
1797 #define REDMSW 5
1798 { "draftmessage msg", 0 },
1799 #define RENDFSW 6
1800 { "nodraftfolder", 0 },
1801 #define REEDTSW 7
1802 { "editor editor", 0 },
1803 #define RENEDSW 8
1804 { "noedit", 0 },
1805 #define REFCCSW 9
1806 { "fcc +folder", 0 },
1807 #define REFLTSW 10
1808 { "filter filterfile", 0 },
1809 #define REFRMSW 11
1810 { "form formfile", 0 },
1811 #define REINSW 12
1812 { "inplace", 0 },
1813 #define RENINSW 13
1814 { "noinplace", 0 },
1815 #define REQUSW 14
1816 { "query", 0 },
1817 #define RENQUSW 15
1818 { "noquery", 0 },
1819 #define REWHTSW 16
1820 { "whatnowproc program", 0 },
1821 #define RENWTSW 17
1822 { "nowhatnow", 0 },
1823 #define REWIDSW 19
1824 { "width columns", 0 },
1825 #define REHELP 20
1826 { "help", 0 },
1827 { NULL, 0 }
1828 };
1829
1830
1831 void
1832 replcmd (char **args)
1833 {
1834 int vecp = 1;
1835 char *cp, *msg = NULL;
1836 char buf[BUFSIZ], *vec[MAXARGS];
1837
1838 if (fmsh) {
1839 forkcmd (args, cmd_name);
1840 return;
1841 }
1842
1843 while ((cp = *args++)) {
1844 if (*cp == '-')
1845 switch (smatch (++cp, replswit)) {
1846 case AMBIGSW:
1847 ambigsw (cp, replswit);
1848 return;
1849 case UNKWNSW:
1850 fprintf (stderr, "-%s unknown\n", cp);
1851 return;
1852 case REHELP:
1853 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1854 print_help (buf, replswit, 1);
1855 return;
1856
1857 case REANSW: /* not implemented */
1858 case RENANSW:
1859 case REINSW:
1860 case RENINSW:
1861 continue;
1862
1863 case REQUSW:
1864 case RENQUSW:
1865 case RENDFSW:
1866 case RENEDSW:
1867 case RENWTSW:
1868 vec[vecp++] = --cp;
1869 continue;
1870
1871 case RECCSW:
1872 case RENCCSW:
1873 case REEDTSW:
1874 case REFCCSW:
1875 case REFLTSW:
1876 case REFRMSW:
1877 case REWIDSW:
1878 case REDFSW:
1879 case REDMSW:
1880 case REWHTSW:
1881 vec[vecp++] = --cp;
1882 if (!(cp = *args++) || *cp == '-') {
1883 advise (NULL, "missing argument to %s", args[-2]);
1884 return;
1885 }
1886 vec[vecp++] = cp;
1887 continue;
1888 }
1889 if (*cp == '+' || *cp == '@') {
1890 advise (NULL, "sorry, no folders allowed!");
1891 return;
1892 }
1893 else
1894 if (msg) {
1895 advise (NULL, "only one message at a time!");
1896 return;
1897 }
1898 else
1899 msg = cp;
1900 }
1901
1902 vec[0] = cmd_name;
1903 vec[vecp++] = "-file";
1904 vec[vecp] = NULL;
1905 if (!msg)
1906 msg = "cur";
1907 if (!m_convert (mp, msg))
1908 return;
1909 seq_setprev (mp);
1910
1911 if (mp->numsel > 1) {
1912 advise (NULL, "only one message at a time!");
1913 return;
1914 }
1915 process (mp->hghsel, cmd_name, vecp, vec);
1916 seq_setcur (mp, mp->hghsel);
1917 }
1918
1919
1920 static struct swit rmmswit[] = {
1921 #define RMHELP 0
1922 { "help", 0 },
1923 { NULL, 0 }
1924 };
1925
1926
1927 void
1928 rmmcmd (char **args)
1929 {
1930 int msgp = 0, msgnum;
1931 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1932
1933 while ((cp = *args++)) {
1934 if (*cp == '-')
1935 switch (smatch (++cp, rmmswit)) {
1936 case AMBIGSW:
1937 ambigsw (cp, rmmswit);
1938 return;
1939 case UNKWNSW:
1940 fprintf (stderr, "-%s unknown\n", cp);
1941 return;
1942 case RMHELP:
1943 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1944 print_help (buf, rmmswit, 1);
1945 return;
1946 }
1947 if (*cp == '+' || *cp == '@') {
1948 advise (NULL, "sorry, no folders allowed!");
1949 return;
1950 }
1951 else
1952 msgs[msgp++] = cp;
1953 }
1954
1955 if (!msgp)
1956 msgs[msgp++] = "cur";
1957 for (msgnum = 0; msgnum < msgp; msgnum++)
1958 if (!m_convert (mp, msgs[msgnum]))
1959 return;
1960 seq_setprev (mp);
1961
1962 rmm ();
1963 }
1964
1965
1966 static void
1967 rmm (void)
1968 {
1969 register int msgnum, vecp;
1970 register char *cp;
1971 char buffer[BUFSIZ], *vec[MAXARGS];
1972
1973 if (fmsh) {
1974 if (rmmproc) {
1975 if (mp->numsel > MAXARGS - 1) {
1976 advise (NULL, "more than %d messages for %s exec",
1977 MAXARGS - 1, rmmproc);
1978 return;
1979 }
1980 vecp = 0;
1981 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1982 if (is_selected (mp, msgnum))
1983 vec[vecp++] = getcpy (m_name (msgnum));
1984 vec[vecp] = NULL;
1985 forkcmd (vec, rmmproc);
1986 for (vecp = 0; vec[vecp]; vecp++)
1987 free (vec[vecp]);
1988 }
1989 else
1990 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1991 if (is_selected (mp, msgnum)) {
1992 strncpy (buffer, m_backup (cp = m_name (msgnum)), sizeof(buffer));
1993 if (rename (cp, buffer) == NOTOK)
1994 admonish (buffer, "unable to rename %s to", cp);
1995 }
1996 }
1997
1998 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1999 if (is_selected (mp, msgnum)) {
2000 set_deleted (mp, msgnum);
2001 unset_exists (mp, msgnum);
2002 #ifdef MPOP
2003 #ifdef BPOP
2004 if (pmsh && pop_dele (msgnum) != OK)
2005 fprintf (stderr, "%s", response);
2006 #endif
2007 #endif /* MPOP */
2008 }
2009
2010 if ((mp->nummsg -= mp->numsel) <= 0) {
2011 if (fmsh)
2012 admonish (NULL, "no messages remaining in +%s", fmsh);
2013 else
2014 admonish (NULL, "no messages remaining in %s", mp->foldpath);
2015 mp->lowmsg = mp->hghmsg = mp->nummsg = 0;
2016 }
2017 if (mp->lowsel == mp->lowmsg) {
2018 for (msgnum = mp->lowmsg + 1; msgnum <= mp->hghmsg; msgnum++)
2019 if (does_exist (mp, msgnum))
2020 break;
2021 mp->lowmsg = msgnum;
2022 }
2023 if (mp->hghsel == mp->hghmsg) {
2024 for (msgnum = mp->hghmsg - 1; msgnum >= mp->lowmsg; msgnum--)
2025 if (does_exist (mp, msgnum))
2026 break;
2027 mp->hghmsg = msgnum;
2028 }
2029
2030 mp->msgflags |= MODIFIED;
2031 modified++;
2032 }
2033
2034
2035 static struct swit scanswit[] = {
2036 #define SCCLR 0
2037 { "clear", 0 },
2038 #define SCNCLR 1
2039 { "noclear", 0 },
2040 #define SCFORM 2
2041 { "form formatfile", 0 },
2042 #define SCFMT 3
2043 { "format string", 5 },
2044 #define SCHEAD 4
2045 { "header", 0 },
2046 #define SCNHEAD 5
2047 { "noheader", 0 },
2048 #define SCWID 6
2049 { "width columns", 0 },
2050 #define SCHELP 7
2051 { "help", 0 },
2052 { NULL, 0 }
2053 };
2054
2055
2056 void
2057 scancmd (char **args)
2058 {
2059 #define equiv(a,b) (a ? b && !strcmp (a, b) : !b)
2060
2061 int clearsw = 0, headersw = 0, width = 0, msgp = 0;
2062 int msgnum, optim, state;
2063 char *cp, *form = NULL, *format = NULL;
2064 char buf[BUFSIZ], *nfs, *msgs[MAXARGS];
2065 register FILE *zp;
2066 #ifdef MPOP
2067 #ifdef BPOP
2068 static int p_optim = 0;
2069 #endif
2070 #endif /* MPOP */
2071 static int s_optim = 0;
2072 static char *s_form = NULL, *s_format = NULL;
2073
2074 while ((cp = *args++)) {
2075 if (*cp == '-')
2076 switch (smatch (++cp, scanswit)) {
2077 case AMBIGSW:
2078 ambigsw (cp, scanswit);
2079 return;
2080 case UNKWNSW:
2081 fprintf (stderr, "-%s unknown\n", cp);
2082 return;
2083 case SCHELP:
2084 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2085 print_help (buf, scanswit, 1);
2086 return;
2087
2088 case SCCLR:
2089 clearsw++;
2090 continue;
2091 case SCNCLR:
2092 clearsw = 0;
2093 continue;
2094 case SCHEAD:
2095 headersw++;
2096 continue;
2097 case SCNHEAD:
2098 headersw = 0;
2099 continue;
2100 case SCFORM:
2101 if (!(form = *args++) || *form == '-') {
2102 advise (NULL, "missing argument to %s", args[-2]);
2103 return;
2104 }
2105 format = NULL;
2106 continue;
2107 case SCFMT:
2108 if (!(format = *args++) || *format == '-') {
2109 advise (NULL, "missing argument to %s", args[-2]);
2110 return;
2111 }
2112 form = NULL;
2113 continue;
2114 case SCWID:
2115 if (!(cp = *args++) || *cp == '-') {
2116 advise (NULL, "missing argument to %s", args[-2]);
2117 return;
2118 }
2119 width = atoi (cp);
2120 continue;
2121 }
2122 if (*cp == '+' || *cp == '@') {
2123 advise (NULL, "sorry, no folders allowed!");
2124 return;
2125 }
2126 else
2127 msgs[msgp++] = cp;
2128 }
2129
2130 if (!msgp)
2131 msgs[msgp++] = "all";
2132 for (msgnum = 0; msgnum < msgp; msgnum++)
2133 if (!m_convert (mp, msgs[msgnum]))
2134 return;
2135 seq_setprev (mp);
2136
2137 /* Get new format string */
2138 nfs = new_fs (form, format, FORMAT);
2139
2140 /* force scansbr to (re)compile format */
2141 if (scanl) {
2142 free (scanl);
2143 scanl = NULL;
2144 }
2145
2146 if (s_optim == 0) {
2147 s_optim = optim = 1;
2148 s_form = form ? getcpy (form) : NULL;
2149 s_format = format ? getcpy (format) : NULL;
2150
2151 #ifdef MPOP
2152 #ifdef BPOP
2153 if (pmsh) {
2154 int i;
2155 char *dp, *ep, *fp;
2156
2157 if (width == 0)
2158 width = sc_width ();
2159
2160 for (dp = nfs, i = 0; *dp; dp++, i++)
2161 if (*dp == '\\' || *dp == '"' || *dp == '\n')
2162 i++;
2163 i++;
2164 ep = mh_xmalloc ((unsigned) i);
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 (!mh_strcasecmp (cmd_name, "next"))
2314 mode = 1;
2315 else
2316 if (!mh_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 (!mh_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 = (mh_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 = (mh_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 (!mh_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 = (mh_strcasecmp (bp, "7bit")
2686 && mh_strcasecmp (bp, "8bit")
2687 && mh_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 (!mh_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 && !mh_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 (!mh_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