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