]> diplodocus.org Git - nmh/blob - uip/mshcmds.c
projects / nmh / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Renamed ZSH.COMPLETION to COMPLETION-ZSH and added COMPLETION-TCSH.
[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 #ifdef HAVE_MKSTEMP
937 vec[0] = (char *)mkstemp (buf);
938 #else
939 vec[0] = (char *)mktemp (buf);
940 #endif
941 vec[vecp++] = "-file";
942 vec[vecp] = NULL;
943 if (!msgp)
944 msgs[msgp++] = "cur";
945 for (msgnum = 0; msgnum < msgp; msgnum++)
946 if (!m_convert (mp, msgs[msgnum]))
947 return;
948 seq_setprev (mp);
949
950 if (filter) {
951 strncpy (buf, filter, sizeof(buf));
952 if (expand (buf) == NOTOK)
953 return;
954 if (access (filter = getcpy (etcpath (buf)), R_OK) == NOTOK) {
955 advise (filter, "unable to read");
956 free (filter);
957 return;
958 }
959 }
960 forw (cmd_name, filter, vecp, vec);
961 seq_setcur (mp, mp->hghsel);
962 if (filter)
963 free (filter);
964 }
965
966
967 static void
968 forw (char *proc, char *filter, int vecp, char **vec)
969 {
970 int i, child_id, msgnum, msgcnt;
971 char tmpfil[80], *args[MAXARGS];
972 FILE *out;
973
974 strncpy (tmpfil, m_tmpfil (invo_name), sizeof(tmpfil));
975 interrupted = 0;
976 if (filter)
977 switch (child_id = fork ()) {
978 case NOTOK:
979 advise ("fork", "unable to");
980 return;
981
982 case OK: /* "trust me" */
983 if (freopen (tmpfil, "w", stdout) == NULL) {
984 fprintf (stderr, "unable to create ");
985 perror (tmpfil);
986 _exit (1);
987 }
988 args[0] = r1bindex (mhlproc, '/');
989 i = 1;
990 args[i++] = "-forwall";
991 args[i++] = "-form";
992 args[i++] = filter;
993 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
994 if (is_selected (mp, msgnum))
995 args[i++] = getcpy (m_name (msgnum));
996 args[i] = NULL;
997 mhlsbr (i, args, mhl_action);
998 m_eomsbr ((int (*) ()) 0);
999 fclose (stdout);
1000 _exit (0);
1001
1002 default:
1003 if (pidXwait (child_id, NULL))
1004 interrupted++;
1005 break;
1006 }
1007 else {
1008 if ((out = fopen (tmpfil, "w")) == NULL) {
1009 advise (tmpfil, "unable to create temporary file");
1010 return;
1011 }
1012
1013 msgcnt = 1;
1014 for (msgnum = mp->lowsel;
1015 msgnum <= mp->hghsel && !interrupted;
1016 msgnum++)
1017 if (is_selected (mp, msgnum)) {
1018 fprintf (out, "\n\n-------");
1019 if (msgnum == mp->lowsel)
1020 fprintf (out, " Forwarded Message%s",
1021 mp->numsel > 1 ? "s" : "");
1022 else
1023 fprintf (out, " Message %d", msgcnt);
1024 fprintf (out, "\n\n");
1025 copy_digest (msgnum, out);
1026 msgcnt++;
1027 }
1028
1029 fprintf (out, "\n\n------- End of Forwarded Message%s\n",
1030 mp->numsel > 1 ? "s" : "");
1031 fclose (out);
1032 }
1033
1034 fflush (stdout);
1035 if (!interrupted)
1036 switch (child_id = fork ()) {
1037 case NOTOK:
1038 advise ("fork", "unable to");
1039 break;
1040
1041 case OK:
1042 closefds (3);
1043 SIGNAL (SIGINT, istat);
1044 SIGNAL (SIGQUIT, qstat);
1045
1046 vec[vecp++] = tmpfil;
1047 vec[vecp] = NULL;
1048
1049 execvp (proc, vec);
1050 fprintf (stderr, "unable to exec ");
1051 perror (proc);
1052 _exit (1);
1053
1054 default:
1055 pidXwait (child_id, NULL);
1056 break;
1057 }
1058
1059 unlink (tmpfil);
1060 }
1061
1062
1063 static char *hlpmsg[] = {
1064 "The %s program emulates many of the commands found in the nmh",
1065 "system. Instead of operating on nmh folders, commands to %s concern",
1066 "a single file.",
1067 "",
1068 "To see the list of commands available, just type a ``?'' followed by",
1069 "the RETURN key. To find out what switches each command takes, type",
1070 "the name of the command followed by ``-help''. To leave %s, use the",
1071 "``quit'' command.",
1072 "",
1073 "Although a lot of nmh commands are found in %s, not all are fully",
1074 "implemented. %s will always recognize all legal switches for a",
1075 "given command though, and will let you know when you ask for an",
1076 "option that it is unable to perform.",
1077 "",
1078 "Running %s is fun, but using nmh from your shell is far superior.",
1079 "After you have familiarized yourself with the nmh style by using %s,",
1080 "you should try using nmh from the shell. You can still use %s for",
1081 "message files that aren't in nmh format, such as BBoard files.",
1082 NULL
1083 };
1084
1085
1086 void
1087 helpcmd (char **args)
1088 {
1089 int i;
1090
1091 for (i = 0; hlpmsg[i]; i++) {
1092 printf (hlpmsg[i], invo_name);
1093 putchar ('\n');
1094 }
1095 }
1096
1097
1098 static struct swit markswit[] = {
1099 #define MADDSW 0
1100 { "add", 0 },
1101 #define MDELSW 1
1102 { "delete", 0 },
1103 #define MLSTSW 2
1104 { "list", 0 },
1105 #define MSEQSW 3
1106 { "sequence name", 0 },
1107 #define MPUBSW 4
1108 { "public", 0 },
1109 #define MNPUBSW 5
1110 { "nopublic", 0 },
1111 #define MZERSW 6
1112 { "zero", 0 },
1113 #define MNZERSW 7
1114 { "nozero", 0 },
1115 #define MHELP 8
1116 { "help", 4 },
1117 #define MDBUGSW 9
1118 { "debug", -5 },
1119 { NULL, 0 }
1120 };
1121
1122
1123 void
1124 markcmd (char **args)
1125 {
1126 int addsw = 0, deletesw = 0, debugsw = 0;
1127 int listsw = 0, zerosw = 0, seqp = 0;
1128 int msgp = 0, msgnum;
1129 char *cp, buf[BUFSIZ];
1130 char *seqs[NUMATTRS + 1], *msgs[MAXARGS];
1131
1132 while ((cp = *args++)) {
1133 if (*cp == '-') {
1134 switch (smatch (++cp, markswit)) {
1135 case AMBIGSW:
1136 ambigsw (cp, markswit);
1137 return;
1138 case UNKWNSW:
1139 fprintf (stderr, "-%s unknown\n", cp);
1140 return;
1141 case MHELP:
1142 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1143 print_help (buf, markswit, 1);
1144 return;
1145
1146 case MADDSW:
1147 addsw++;
1148 deletesw = listsw = 0;
1149 continue;
1150 case MDELSW:
1151 deletesw++;
1152 addsw = listsw = 0;
1153 continue;
1154 case MLSTSW:
1155 listsw++;
1156 addsw = deletesw = 0;
1157 continue;
1158
1159 case MSEQSW:
1160 if (!(cp = *args++) || *cp == '-') {
1161 advise (NULL, "missing argument to %s", args[-2]);
1162 return;
1163 }
1164 if (seqp < NUMATTRS)
1165 seqs[seqp++] = cp;
1166 else {
1167 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1168 return;
1169 }
1170 continue;
1171
1172 case MPUBSW: /* not implemented */
1173 case MNPUBSW:
1174 continue;
1175
1176 case MDBUGSW:
1177 debugsw++;
1178 continue;
1179
1180 case MZERSW:
1181 zerosw++;
1182 continue;
1183 case MNZERSW:
1184 zerosw = 0;
1185 continue;
1186 }
1187 }
1188 if (*cp == '+' || *cp == '@') {
1189 advise (NULL, "sorry, no folders allowed!");
1190 return;
1191 } else {
1192 msgs[msgp++] = cp;
1193 }
1194 }
1195
1196 if (!addsw && !deletesw && !listsw) {
1197 if (seqp)
1198 addsw++;
1199 else
1200 if (debugsw)
1201 listsw++;
1202 else {
1203 seqs[seqp++] = "unseen";
1204 deletesw++;
1205 zerosw = 0;
1206 if (!msgp)
1207 msgs[msgp++] = "all";
1208 }
1209 }
1210
1211 if (!msgp)
1212 msgs[msgp++] = listsw ? "all" :"cur";
1213 for (msgnum = 0; msgnum < msgp; msgnum++)
1214 if (!m_convert (mp, msgs[msgnum]))
1215 return;
1216
1217 if (debugsw) {
1218 printf ("invo_name=%s mypath=%s defpath=%s\n",
1219 invo_name, mypath, defpath);
1220 printf ("ctxpath=%s context flags=%s\n",
1221 ctxpath, snprintb (buf, sizeof(buf), (unsigned) ctxflags, DBITS));
1222 printf ("foldpath=%s flags=%s\n",
1223 mp->foldpath,
1224 snprintb (buf, sizeof(buf), (unsigned) mp->msgflags, FBITS));
1225 printf ("hghmsg=%d lowmsg=%d nummsg=%d curmsg=%d\n",
1226 mp->hghmsg, mp->lowmsg, mp->nummsg, mp->curmsg);
1227 printf ("lowsel=%d hghsel=%d numsel=%d\n",
1228 mp->lowsel, mp->hghsel, mp->numsel);
1229 printf ("lowoff=%d hghoff=%d\n", mp->lowoff, mp->hghoff);
1230 }
1231
1232 if (seqp == 0 && (addsw || deletesw)) {
1233 advise (NULL, "-%s requires at least one -sequence argument",
1234 addsw ? "add" : "delete");
1235 return;
1236 }
1237 seqs[seqp] = NULL;
1238
1239 if (addsw) {
1240 for (seqp = 0; seqs[seqp]; seqp++)
1241 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1242 return;
1243 }
1244
1245 if (deletesw) {
1246 for (seqp = 0; seqs[seqp]; seqp++)
1247 if (!seq_delsel (mp, seqs[seqp], 0, zerosw))
1248 return;
1249 }
1250
1251 /* Listing messages in sequences */
1252 if (listsw) {
1253 if (seqp) {
1254 /* list the given sequences */
1255 for (seqp = 0; seqs[seqp]; seqp++)
1256 seq_print (mp, seqs[seqp]);
1257 } else {
1258 /* else list them all */
1259 seq_printall (mp);
1260 }
1261
1262 interrupted = 0;
1263 if (debugsw)
1264 for (msgnum = mp->lowsel;
1265 msgnum <= mp->hghsel && !interrupted;
1266 msgnum++)
1267 if (is_selected (mp, msgnum)) {
1268 printf ("%*d: id=%d top=%d start=%ld stop=%ld %s\n",
1269 DMAXFOLDER,
1270 msgnum,
1271 Msgs[msgnum].m_bboard_id,
1272 Msgs[msgnum].m_top,
1273 (long) Msgs[msgnum].m_start,
1274 (long) Msgs[msgnum].m_stop,
1275 snprintb (buf, sizeof(buf),
1276 (unsigned) mp->msgstats[msgnum - mp->lowoff],
1277 seq_bits (mp)));
1278 if (Msgs[msgnum].m_scanl)
1279 printf ("%s", Msgs[msgnum].m_scanl);
1280 }
1281 }
1282 }
1283
1284
1285 static struct swit mhnswit[] = {
1286 #define MHNAUTOSW 0
1287 { "auto", 0 },
1288 #define MHNNAUTOSW 1
1289 { "noauto", 0 },
1290 #define MHNDEBUGSW 2
1291 { "debug", -5 },
1292 #define MHNEBCDICSW 3
1293 { "ebcdicsafe", 0 },
1294 #define MHNNEBCDICSW 4
1295 { "noebcdicsafe", 0 },
1296 #define MHNFORMSW 5
1297 { "form formfile", 4 },
1298 #define MHNHEADSW 6
1299 { "headers", 0 },
1300 #define MHNNHEADSW 7
1301 { "noheaders", 0 },
1302 #define MHNLISTSW 8
1303 { "list", 0 },
1304 #define MHNNLISTSW 9
1305 { "nolist", 0 },
1306 #define MHNPARTSW 10
1307 { "part number", 0 },
1308 #define MHNSIZESW 11
1309 { "realsize", 0 },
1310 #define MHNNSIZESW 12
1311 { "norealsize", 0 },
1312 #define MHNRFC934SW 13
1313 { "rfc934mode", 0 },
1314 #define MHNNRFC934SW 14
1315 { "norfc934mode", 0 },
1316 #define MHNSERIALSW 15
1317 { "serialonly", 0 },
1318 #define MHNNSERIALSW 16
1319 { "noserialonly", 0 },
1320 #define MHNSHOWSW 17
1321 { "show", 0 },
1322 #define MHNNSHOWSW 18
1323 { "noshow", 0 },
1324 #define MHNSTORESW 19
1325 { "store", 0 },
1326 #define MHNNSTORESW 20
1327 { "nostore", 0 },
1328 #define MHNTYPESW 21
1329 { "type content", 0 },
1330 #define MHNVERBSW 22
1331 { "verbose", 0 },
1332 #define MHNNVERBSW 23
1333 { "noverbose", 0 },
1334 #define MHNHELPSW 24
1335 { "help", 4 },
1336 #define MHNPROGSW 25
1337 { "moreproc program", -4 },
1338 #define MHNNPROGSW 26
1339 { "nomoreproc", -3 },
1340 #define MHNLENSW 27
1341 { "length lines", -4 },
1342 #define MHNWIDSW 28
1343 { "width columns", -4 },
1344 { NULL, 0 }
1345 };
1346
1347
1348 void
1349 mhncmd (char **args)
1350 {
1351 int msgp = 0, vecp = 1;
1352 int msgnum;
1353 char *cp, buf[BUFSIZ];
1354 char *msgs[MAXARGS], *vec[MAXARGS];
1355
1356 if (fmsh) {
1357 forkcmd (args, cmd_name);
1358 return;
1359 }
1360 while ((cp = *args++)) {
1361 if (*cp == '-') {
1362 switch (smatch (++cp, mhnswit)) {
1363 case AMBIGSW:
1364 ambigsw (cp, mhnswit);
1365 return;
1366 case UNKWNSW:
1367 fprintf (stderr, "-%s unknown\n", cp);
1368 return;
1369 case MHNHELPSW:
1370 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1371 print_help (buf, mhnswit, 1);
1372 return;
1373
1374 case MHNAUTOSW:
1375 case MHNNAUTOSW:
1376 case MHNDEBUGSW:
1377 case MHNEBCDICSW:
1378 case MHNNEBCDICSW:
1379 case MHNHEADSW:
1380 case MHNNHEADSW:
1381 case MHNLISTSW:
1382 case MHNNLISTSW:
1383 case MHNSIZESW:
1384 case MHNNSIZESW:
1385 case MHNRFC934SW:
1386 case MHNNRFC934SW:
1387 case MHNSERIALSW:
1388 case MHNNSERIALSW:
1389 case MHNSHOWSW:
1390 case MHNNSHOWSW:
1391 case MHNSTORESW:
1392 case MHNNSTORESW:
1393 case MHNVERBSW:
1394 case MHNNVERBSW:
1395 case MHNNPROGSW:
1396 vec[vecp++] = --cp;
1397 continue;
1398
1399 case MHNFORMSW:
1400 case MHNPARTSW:
1401 case MHNTYPESW:
1402 case MHNPROGSW:
1403 case MHNLENSW:
1404 case MHNWIDSW:
1405 vec[vecp++] = --cp;
1406 if (!(cp = *args++) || *cp == '-') {
1407 advise (NULL, "missing argument to %s", args[-2]);
1408 return;
1409 }
1410 vec[vecp++] = cp;
1411 continue;
1412 }
1413 }
1414 if (*cp == '+' || *cp == '@') {
1415 advise (NULL, "sorry, no folders allowed!");
1416 return;
1417 } else {
1418 msgs[msgp++] = cp;
1419 }
1420 }
1421
1422 vec[0] = cmd_name;
1423 vec[vecp++] = "-file";
1424 vec[vecp] = NULL;
1425 if (!msgp)
1426 msgs[msgp++] = "cur";
1427 for (msgnum = 0; msgnum < msgp; msgnum++)
1428 if (!m_convert (mp, msgs[msgnum]))
1429 return;
1430 seq_setprev (mp);
1431
1432 interrupted = 0;
1433 for (msgnum = mp->lowsel;
1434 msgnum <= mp->hghsel && !interrupted;
1435 msgnum++)
1436 if (is_selected (mp, msgnum))
1437 if (process (msgnum, cmd_name, vecp, vec)) {
1438 unset_selected (mp, msgnum);
1439 mp->numsel--;
1440 }
1441
1442 seq_setcur (mp, mp->hghsel);
1443 }
1444
1445
1446 static struct swit packswit[] = {
1447 #define PAFISW 0
1448 { "file name", 0 },
1449 #define PAHELP 1
1450 { "help", 4 },
1451 { NULL, 0 }
1452 };
1453
1454 static mbx_style = MMDF_FORMAT;
1455
1456 void
1457 packcmd (char **args)
1458 {
1459 int msgp = 0, md, msgnum;
1460 char *cp, *file = NULL;
1461 char buf[BUFSIZ], *msgs[MAXARGS];
1462 struct stat st;
1463
1464 if (fmsh) {
1465 forkcmd (args, cmd_name);
1466 return;
1467 }
1468
1469 while ((cp = *args++)) {
1470 if (*cp == '-')
1471 switch (smatch (++cp, packswit)) {
1472 case AMBIGSW:
1473 ambigsw (cp, packswit);
1474 return;
1475 case UNKWNSW:
1476 fprintf (stderr, "-%s unknown\n", cp);
1477 return;
1478 case PAHELP:
1479 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1480 print_help (buf, packswit, 1);
1481 return;
1482
1483 case PAFISW:
1484 if (!(file = *args++) || *file == '-') {
1485 advise (NULL, "missing argument to %s", args[-2]);
1486 return;
1487 }
1488 continue;
1489 }
1490 if (*cp == '+' || *cp == '@') {
1491 advise (NULL, "sorry, no folders allowed!");
1492 return;
1493 }
1494 else
1495 msgs[msgp++] = cp;
1496 }
1497
1498 if (!file)
1499 file = "./msgbox";
1500 file = path (file, TFILE);
1501 if (stat (file, &st) == NOTOK) {
1502 if (errno != ENOENT) {
1503 advise (file, "error on file");
1504 goto done_pack;
1505 }
1506 md = getanswer (cp = concat ("Create file \"", file, "\"? ", NULL));
1507 free (cp);
1508 if (!md)
1509 goto done_pack;
1510 }
1511
1512 if (!msgp)
1513 msgs[msgp++] = "all";
1514 for (msgnum = 0; msgnum < msgp; msgnum++)
1515 if (!m_convert (mp, msgs[msgnum]))
1516 goto done_pack;
1517 seq_setprev (mp);
1518
1519 if ((md = mbx_open (file, mbx_style, getuid (), getgid (), m_gmprot ())) == NOTOK) {
1520 advise (file, "unable to open");
1521 goto done_pack;
1522 }
1523 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1524 if (is_selected (mp, msgnum))
1525 if (pack (file, md, msgnum) == NOTOK)
1526 break;
1527 mbx_close (file, md);
1528
1529 if (mp->hghsel != mp->curmsg)
1530 seq_setcur (mp, mp->lowsel);
1531
1532 done_pack: ;
1533 free (file);
1534 }
1535
1536
1537 int
1538 pack (char *mailbox, int md, int msgnum)
1539 {
1540 register FILE *zp;
1541
1542 if (Msgs[msgnum].m_bboard_id == 0)
1543 readid (msgnum);
1544
1545 zp = msh_ready (msgnum, 1);
1546 return mbx_write (mailbox, md, zp, Msgs[msgnum].m_bboard_id,
1547 0L, ftell (zp), Msgs[msgnum].m_stop, 1, 1);
1548 }
1549
1550
1551 int
1552 packhak (char **args)
1553 {
1554 int result;
1555 char *cp, *file = NULL;
1556
1557 while ((cp = *args++)) {
1558 if (*cp == '-')
1559 switch (smatch (++cp, packswit)) {
1560 case AMBIGSW:
1561 case UNKWNSW:
1562 case PAHELP:
1563 return NOTOK;
1564
1565 case PAFISW:
1566 if (!(file = *args++) || *file == '-')
1567 return NOTOK;
1568 continue;
1569 }
1570 if (*cp == '+' || *cp == '@')
1571 return NOTOK;
1572 }
1573
1574 file = path (file ? file : "./msgbox", TFILE);
1575 result = access (file, F_OK) == NOTOK ? OK : NOTOK;
1576 free (file);
1577
1578 return result;
1579 }
1580
1581
1582 static struct swit pickswit[] = {
1583 #define PIANSW 0
1584 { "and", 0 },
1585 #define PIORSW 1
1586 { "or", 0 },
1587 #define PINTSW 2
1588 { "not", 0 },
1589 #define PILBSW 3
1590 { "lbrace", 0 },
1591 #define PIRBSW 4
1592 { "rbrace", 0 },
1593 #define PICCSW 5
1594 { "cc pattern", 0 },
1595 #define PIDASW 6
1596 { "date pattern", 0 },
1597 #define PIFRSW 7
1598 { "from pattern", 0 },
1599 #define PISESW 8
1600 { "search pattern", 0 },
1601 #define PISUSW 9
1602 { "subject pattern", 0 },
1603 #define PITOSW 10
1604 { "to pattern", 0 },
1605 #define PIOTSW 11
1606 { "-othercomponent pattern", 15 },
1607 #define PIAFSW 12
1608 { "after date", 0 },
1609 #define PIBFSW 13
1610 { "before date", 0 },
1611 #define PIDFSW 14
1612 { "datefield field", 5 },
1613 #define PISQSW 15
1614 { "sequence name", 0 },
1615 #define PIPUSW 16
1616 { "public", 0 },
1617 #define PINPUSW 17
1618 { "nopublic", 0 },
1619 #define PIZRSW 18
1620 { "zero", 0 },
1621 #define PINZRSW 19
1622 { "nozero", 0 },
1623 #define PILISW 20
1624 { "list", 0 },
1625 #define PINLISW 21
1626 { "nolist", 0 },
1627 #define PIHELP 22
1628 { "help", 4 },
1629 { NULL, 0 }
1630 };
1631
1632
1633 void
1634 pickcmd (char **args)
1635 {
1636 int zerosw = 1, msgp = 0, seqp = 0;
1637 int vecp = 0, hi, lo, msgnum;
1638 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1639 char *seqs[NUMATTRS], *vec[MAXARGS];
1640 register FILE *zp;
1641
1642 while ((cp = *args++)) {
1643 if (*cp == '-') {
1644 if (*++cp == '-') {
1645 vec[vecp++] = --cp;
1646 goto pattern;
1647 }
1648 switch (smatch (cp, pickswit)) {
1649 case AMBIGSW:
1650 ambigsw (cp, pickswit);
1651 return;
1652 case UNKWNSW:
1653 fprintf (stderr, "-%s unknown\n", cp);
1654 return;
1655 case PIHELP:
1656 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1657 print_help (buf, pickswit, 1);
1658 return;
1659
1660 case PICCSW:
1661 case PIDASW:
1662 case PIFRSW:
1663 case PISUSW:
1664 case PITOSW:
1665 case PIDFSW:
1666 case PIAFSW:
1667 case PIBFSW:
1668 case PISESW:
1669 vec[vecp++] = --cp;
1670 pattern: ;
1671 if (!(cp = *args++)) {/* allow -xyz arguments */
1672 advise (NULL, "missing argument to %s", args[-2]);
1673 return;
1674 }
1675 vec[vecp++] = cp;
1676 continue;
1677 case PIOTSW:
1678 advise (NULL, "internal error!");
1679 return;
1680 case PIANSW:
1681 case PIORSW:
1682 case PINTSW:
1683 case PILBSW:
1684 case PIRBSW:
1685 vec[vecp++] = --cp;
1686 continue;
1687
1688 case PISQSW:
1689 if (!(cp = *args++) || *cp == '-') {
1690 advise (NULL, "missing argument to %s", args[-2]);
1691 return;
1692 }
1693 if (seqp < NUMATTRS)
1694 seqs[seqp++] = cp;
1695 else {
1696 advise (NULL, "only %d sequences allowed!", NUMATTRS);
1697 return;
1698 }
1699 continue;
1700 case PIZRSW:
1701 zerosw++;
1702 continue;
1703 case PINZRSW:
1704 zerosw = 0;
1705 continue;
1706
1707 case PIPUSW: /* not implemented */
1708 case PINPUSW:
1709 case PILISW:
1710 case PINLISW:
1711 continue;
1712 }
1713 }
1714 if (*cp == '+' || *cp == '@') {
1715 advise (NULL, "sorry, no folders allowed!");
1716 return;
1717 }
1718 else
1719 msgs[msgp++] = cp;
1720 }
1721 vec[vecp] = NULL;
1722
1723 if (!msgp)
1724 msgs[msgp++] = "all";
1725 for (msgnum = 0; msgnum < msgp; msgnum++)
1726 if (!m_convert (mp, msgs[msgnum]))
1727 return;
1728 seq_setprev (mp);
1729
1730 interrupted = 0;
1731 if (!pcompile (vec, NULL))
1732 return;
1733
1734 lo = mp->lowsel;
1735 hi = mp->hghsel;
1736
1737 for (msgnum = mp->lowsel;
1738 msgnum <= mp->hghsel && !interrupted;
1739 msgnum++)
1740 if (is_selected (mp, msgnum)) {
1741 zp = msh_ready (msgnum, 1);
1742 if (pmatches (zp, msgnum, fmsh ? 0L : Msgs[msgnum].m_start,
1743 fmsh ? 0L : Msgs[msgnum].m_stop)) {
1744 if (msgnum < lo)
1745 lo = msgnum;
1746 if (msgnum > hi)
1747 hi = msgnum;
1748 }
1749 else {
1750 unset_selected (mp, msgnum);
1751 mp->numsel--;
1752 }
1753 }
1754
1755 if (interrupted)
1756 return;
1757
1758 mp->lowsel = lo;
1759 mp->hghsel = hi;
1760
1761 if (mp->numsel <= 0) {
1762 advise (NULL, "no messages match specification");
1763 return;
1764 }
1765
1766 seqs[seqp] = NULL;
1767 for (seqp = 0; seqs[seqp]; seqp++)
1768 if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1769 return;
1770
1771 printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
1772 }
1773
1774
1775 static struct swit replswit[] = {
1776 #define REANSW 0
1777 { "annotate", 0 },
1778 #define RENANSW 1
1779 { "noannotate", 0 },
1780 #define RECCSW 2
1781 { "cc type", 0 },
1782 #define RENCCSW 3
1783 { "nocc type", 0 },
1784 #define REDFSW 4
1785 { "draftfolder +folder", 0 },
1786 #define REDMSW 5
1787 { "draftmessage msg", 0 },
1788 #define RENDFSW 6
1789 { "nodraftfolder", 0 },
1790 #define REEDTSW 7
1791 { "editor editor", 0 },
1792 #define RENEDSW 8
1793 { "noedit", 0 },
1794 #define REFCCSW 9
1795 { "fcc +folder", 0 },
1796 #define REFLTSW 10
1797 { "filter filterfile", 0 },
1798 #define REFRMSW 11
1799 { "form formfile", 0 },
1800 #define REINSW 12
1801 { "inplace", 0 },
1802 #define RENINSW 13
1803 { "noinplace", 0 },
1804 #define REQUSW 14
1805 { "query", 0 },
1806 #define RENQUSW 15
1807 { "noquery", 0 },
1808 #define REWHTSW 16
1809 { "whatnowproc program", 0 },
1810 #define RENWTSW 17
1811 { "nowhatnow", 0 },
1812 #define REWIDSW 19
1813 { "width columns", 0 },
1814 #define REHELP 20
1815 { "help", 4 },
1816 { NULL, 0 }
1817 };
1818
1819
1820 void
1821 replcmd (char **args)
1822 {
1823 int vecp = 1;
1824 char *cp, *msg = NULL;
1825 char buf[BUFSIZ], *vec[MAXARGS];
1826
1827 if (fmsh) {
1828 forkcmd (args, cmd_name);
1829 return;
1830 }
1831
1832 while ((cp = *args++)) {
1833 if (*cp == '-')
1834 switch (smatch (++cp, replswit)) {
1835 case AMBIGSW:
1836 ambigsw (cp, replswit);
1837 return;
1838 case UNKWNSW:
1839 fprintf (stderr, "-%s unknown\n", cp);
1840 return;
1841 case REHELP:
1842 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1843 print_help (buf, replswit, 1);
1844 return;
1845
1846 case REANSW: /* not implemented */
1847 case RENANSW:
1848 case REINSW:
1849 case RENINSW:
1850 continue;
1851
1852 case REQUSW:
1853 case RENQUSW:
1854 case RENDFSW:
1855 case RENEDSW:
1856 case RENWTSW:
1857 vec[vecp++] = --cp;
1858 continue;
1859
1860 case RECCSW:
1861 case RENCCSW:
1862 case REEDTSW:
1863 case REFCCSW:
1864 case REFLTSW:
1865 case REFRMSW:
1866 case REWIDSW:
1867 case REDFSW:
1868 case REDMSW:
1869 case REWHTSW:
1870 vec[vecp++] = --cp;
1871 if (!(cp = *args++) || *cp == '-') {
1872 advise (NULL, "missing argument to %s", args[-2]);
1873 return;
1874 }
1875 vec[vecp++] = cp;
1876 continue;
1877 }
1878 if (*cp == '+' || *cp == '@') {
1879 advise (NULL, "sorry, no folders allowed!");
1880 return;
1881 }
1882 else
1883 if (msg) {
1884 advise (NULL, "only one message at a time!");
1885 return;
1886 }
1887 else
1888 msg = cp;
1889 }
1890
1891 vec[0] = cmd_name;
1892 vec[vecp++] = "-file";
1893 vec[vecp] = NULL;
1894 if (!msg)
1895 msg = "cur";
1896 if (!m_convert (mp, msg))
1897 return;
1898 seq_setprev (mp);
1899
1900 if (mp->numsel > 1) {
1901 advise (NULL, "only one message at a time!");
1902 return;
1903 }
1904 process (mp->hghsel, cmd_name, vecp, vec);
1905 seq_setcur (mp, mp->hghsel);
1906 }
1907
1908
1909 static struct swit rmmswit[] = {
1910 #define RMHELP 0
1911 { "help", 4 },
1912 { NULL, 0 }
1913 };
1914
1915
1916 void
1917 rmmcmd (char **args)
1918 {
1919 int msgp = 0, msgnum;
1920 char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1921
1922 while ((cp = *args++)) {
1923 if (*cp == '-')
1924 switch (smatch (++cp, rmmswit)) {
1925 case AMBIGSW:
1926 ambigsw (cp, rmmswit);
1927 return;
1928 case UNKWNSW:
1929 fprintf (stderr, "-%s unknown\n", cp);
1930 return;
1931 case RMHELP:
1932 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1933 print_help (buf, rmmswit, 1);
1934 return;
1935 }
1936 if (*cp == '+' || *cp == '@') {
1937 advise (NULL, "sorry, no folders allowed!");
1938 return;
1939 }
1940 else
1941 msgs[msgp++] = cp;
1942 }
1943
1944 if (!msgp)
1945 msgs[msgp++] = "cur";
1946 for (msgnum = 0; msgnum < msgp; msgnum++)
1947 if (!m_convert (mp, msgs[msgnum]))
1948 return;
1949 seq_setprev (mp);
1950
1951 rmm ();
1952 }
1953
1954
1955 static void
1956 rmm (void)
1957 {
1958 register int msgnum, vecp;
1959 register char *cp;
1960 char buffer[BUFSIZ], *vec[MAXARGS];
1961
1962 if (fmsh) {
1963 if (rmmproc) {
1964 if (mp->numsel > MAXARGS - 1) {
1965 advise (NULL, "more than %d messages for %s exec",
1966 MAXARGS - 1, rmmproc);
1967 return;
1968 }
1969 vecp = 0;
1970 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1971 if (is_selected (mp, msgnum))
1972 vec[vecp++] = getcpy (m_name (msgnum));
1973 vec[vecp] = NULL;
1974 forkcmd (vec, rmmproc);
1975 for (vecp = 0; vec[vecp]; vecp++)
1976 free (vec[vecp]);
1977 }
1978 else
1979 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1980 if (is_selected (mp, msgnum)) {
1981 strncpy (buffer, m_backup (cp = m_name (msgnum)), sizeof(buffer));
1982 if (rename (cp, buffer) == NOTOK)
1983 admonish (buffer, "unable to rename %s to", cp);
1984 }
1985 }
1986
1987 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1988 if (is_selected (mp, msgnum)) {
1989 set_deleted (mp, msgnum);
1990 unset_exists (mp, msgnum);
1991 #ifdef MPOP
1992 #ifdef BPOP
1993 if (pmsh && pop_dele (msgnum) != OK)
1994 fprintf (stderr, "%s", response);
1995 #endif
1996 #endif /* MPOP */
1997 }
1998
1999 if ((mp->nummsg -= mp->numsel) <= 0) {
2000 if (fmsh)
2001 admonish (NULL, "no messages remaining in +%s", fmsh);
2002 else
2003 admonish (NULL, "no messages remaining in %s", mp->foldpath);
2004 mp->lowmsg = mp->hghmsg = mp->nummsg = 0;
2005 }
2006 if (mp->lowsel == mp->lowmsg) {
2007 for (msgnum = mp->lowmsg + 1; msgnum <= mp->hghmsg; msgnum++)
2008 if (does_exist (mp, msgnum))
2009 break;
2010 mp->lowmsg = msgnum;
2011 }
2012 if (mp->hghsel == mp->hghmsg) {
2013 for (msgnum = mp->hghmsg - 1; msgnum >= mp->lowmsg; msgnum--)
2014 if (does_exist (mp, msgnum))
2015 break;
2016 mp->hghmsg = msgnum;
2017 }
2018
2019 mp->msgflags |= MODIFIED;
2020 modified++;
2021 }
2022
2023
2024 static struct swit scanswit[] = {
2025 #define SCCLR 0
2026 { "clear", 0 },
2027 #define SCNCLR 1
2028 { "noclear", 0 },
2029 #define SCFORM 2
2030 { "form formatfile", 0 },
2031 #define SCFMT 3
2032 { "format string", 5 },
2033 #define SCHEAD 4
2034 { "header", 0 },
2035 #define SCNHEAD 5
2036 { "noheader", 0 },
2037 #define SCWID 6
2038 { "width columns", 0 },
2039 #define SCHELP 7
2040 { "help", 4 },
2041 { NULL, 0 }
2042 };
2043
2044
2045 void
2046 scancmd (char **args)
2047 {
2048 #define equiv(a,b) (a ? b && !strcmp (a, b) : !b)
2049
2050 int clearsw = 0, headersw = 0, width = 0, msgp = 0;
2051 int msgnum, optim, state;
2052 char *cp, *form = NULL, *format = NULL;
2053 char buf[BUFSIZ], *nfs, *msgs[MAXARGS];
2054 register FILE *zp;
2055 #ifdef MPOP
2056 #ifdef BPOP
2057 static int p_optim = 0;
2058 #endif
2059 #endif /* MPOP */
2060 static int s_optim = 0;
2061 static char *s_form = NULL, *s_format = NULL;
2062
2063 while ((cp = *args++)) {
2064 if (*cp == '-')
2065 switch (smatch (++cp, scanswit)) {
2066 case AMBIGSW:
2067 ambigsw (cp, scanswit);
2068 return;
2069 case UNKWNSW:
2070 fprintf (stderr, "-%s unknown\n", cp);
2071 return;
2072 case SCHELP:
2073 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2074 print_help (buf, scanswit, 1);
2075 return;
2076
2077 case SCCLR:
2078 clearsw++;
2079 continue;
2080 case SCNCLR:
2081 clearsw = 0;
2082 continue;
2083 case SCHEAD:
2084 headersw++;
2085 continue;
2086 case SCNHEAD:
2087 headersw = 0;
2088 continue;
2089 case SCFORM:
2090 if (!(form = *args++) || *form == '-') {
2091 advise (NULL, "missing argument to %s", args[-2]);
2092 return;
2093 }
2094 format = NULL;
2095 continue;
2096 case SCFMT:
2097 if (!(format = *args++) || *format == '-') {
2098 advise (NULL, "missing argument to %s", args[-2]);
2099 return;
2100 }
2101 form = NULL;
2102 continue;
2103 case SCWID:
2104 if (!(cp = *args++) || *cp == '-') {
2105 advise (NULL, "missing argument to %s", args[-2]);
2106 return;
2107 }
2108 width = atoi (cp);
2109 continue;
2110 }
2111 if (*cp == '+' || *cp == '@') {
2112 advise (NULL, "sorry, no folders allowed!");
2113 return;
2114 }
2115 else
2116 msgs[msgp++] = cp;
2117 }
2118
2119 if (!msgp)
2120 msgs[msgp++] = "all";
2121 for (msgnum = 0; msgnum < msgp; msgnum++)
2122 if (!m_convert (mp, msgs[msgnum]))
2123 return;
2124 seq_setprev (mp);
2125
2126 /* Get new format string */
2127 nfs = new_fs (form, format, FORMAT);
2128
2129 /* force scansbr to (re)compile format */
2130 if (scanl) {
2131 free (scanl);
2132 scanl = NULL;
2133 }
2134
2135 if (s_optim == 0) {
2136 s_optim = optim = 1;
2137 s_form = form ? getcpy (form) : NULL;
2138 s_format = format ? getcpy (format) : NULL;
2139
2140 #ifdef MPOP
2141 #ifdef BPOP
2142 if (pmsh) {
2143 int i;
2144 char *dp, *ep, *fp;
2145
2146 if (width == 0)
2147 width = sc_width ();
2148
2149 for (dp = nfs, i = 0; *dp; dp++, i++)
2150 if (*dp == '\\' || *dp == '"' || *dp == '\n')
2151 i++;
2152 i++;
2153 if ((ep = malloc ((unsigned) i)) == NULL)
2154 adios (NULL, "out of memory");
2155 for (dp = nfs, fp = ep; *dp; dp++) {
2156 if (*dp == '\n') {
2157 *fp++ = '\\', *fp++ = 'n';
2158 continue;
2159 }
2160 if (*dp == '"' || *dp == '\\')
2161 *fp++ = '\\';
2162 *fp++ = *dp;
2163 }
2164 *fp = NULL;
2165
2166 if (pop_command ("XTND SCAN %d \"%s\"", width, ep) == OK)
2167 p_optim = 1;
2168
2169 free (ep);
2170 }
2171 #endif
2172 #endif /* MPOP */
2173 }
2174 else
2175 optim = equiv (s_form, form) && equiv (s_format, format);
2176
2177 #ifdef MPOP
2178 #ifdef BPOP
2179 if (p_optim && optim) {
2180 for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++)
2181 if (!is_selected(mp, msgnum) || Msgs[msgnum].m_scanl)
2182 break;
2183 if (msgnum > mp->hghmsg && pop_command ("LIST") == OK) {
2184 fprintf (stderr, "Stand-by...");
2185 fflush (stderr);
2186
2187 for (;;) {
2188 int size;
2189
2190 switch (pop_multiline ()) {
2191 case NOTOK:
2192 fprintf (stderr, "%s", response);
2193 /* and fall... */
2194 case DONE:
2195 fprintf (stderr,"\n");
2196 break;
2197
2198 case OK:
2199 if (sscanf (response, "%d %d", &msgnum, &size) == 2
2200 && mp->lowmsg <= msgnum
2201 && msgnum <= mp->hghmsg
2202 && (cp = strchr(response, '#'))
2203 && *++cp)
2204 Msgs[msgnum].m_scanl = concat (cp, "\n", NULL);
2205 continue;
2206 }
2207 break;
2208 }
2209 }
2210 }
2211 #endif
2212 #endif /* MPOP */
2213
2214 interrupted = 0;
2215 for (msgnum = mp->lowsel;
2216 msgnum <= mp->hghsel && !interrupted;
2217 msgnum++)
2218 if (is_selected (mp, msgnum)) {
2219 if (optim && Msgs[msgnum].m_scanl)
2220 printf ("%s", Msgs[msgnum].m_scanl);
2221 else {
2222 #ifdef MPOP
2223 #ifdef BPOP
2224 if (p_optim
2225 && optim
2226 && is_virtual (mp, msgnum)
2227 && pop_command ("LIST %d", msgnum) == OK
2228 && (cp = strchr(response, '#'))
2229 && *++cp) {
2230 Msgs[msgnum].m_scanl = concat (cp, "\n", NULL);
2231 printf ("%s", Msgs[msgnum].m_scanl);
2232 continue;
2233 }
2234 #endif
2235 #endif /* MPOP */
2236
2237 zp = msh_ready (msgnum, 0);
2238 switch (state = scan (zp, msgnum, 0, nfs, width,
2239 msgnum == mp->curmsg,
2240 is_unseen (mp, msgnum),
2241 headersw ? (fmsh ? fmsh : mp->foldpath) : NULL,
2242 fmsh ? 0L : (long) (Msgs[msgnum].m_stop - Msgs[msgnum].m_start),
2243 1)) {
2244 case SCNMSG:
2245 case SCNENC:
2246 case SCNERR:
2247 if (optim)
2248 Msgs[msgnum].m_scanl = getcpy (scanl);
2249 break;
2250
2251 default:
2252 advise (NULL, "scan() botch (%d)", state);
2253 return;
2254
2255 case SCNEOF:
2256 printf ("%*d empty\n", DMAXFOLDER, msgnum);
2257 break;
2258 }
2259 }
2260 headersw = 0;
2261 }
2262
2263 if (clearsw)
2264 clear_screen ();
2265 }
2266
2267
2268 static struct swit showswit[] = {
2269 #define SHDRAFT 0
2270 { "draft", 5 },
2271 #define SHFORM 1
2272 { "form formfile", 4 },
2273 #define SHPROG 2
2274 { "moreproc program", 4 },
2275 #define SHNPROG 3
2276 { "nomoreproc", 3 },
2277 #define SHLEN 4
2278 { "length lines", 4 },
2279 #define SHWID 5
2280 { "width columns", 4 },
2281 #define SHSHOW 6
2282 { "showproc program", 4 },
2283 #define SHNSHOW 7
2284 { "noshowproc", 3 },
2285 #define SHHEAD 8
2286 { "header", 4 },
2287 #define SHNHEAD 9
2288 { "noheader", 3 },
2289 #define SHHELP 10
2290 { "help", 4 },
2291 { NULL, 0 }
2292 };
2293
2294
2295 void
2296 showcmd (char **args)
2297 {
2298 int headersw = 1, nshow = 0, msgp = 0, vecp = 1;
2299 int mhl = 0, seqnum = -1, mode = 0, i, msgnum;
2300 char *cp, *proc = showproc, buf[BUFSIZ];
2301 char *msgs[MAXARGS], *vec[MAXARGS];
2302
2303 if (!strcasecmp (cmd_name, "next"))
2304 mode = 1;
2305 else
2306 if (!strcasecmp (cmd_name, "prev"))
2307 mode = -1;
2308 while ((cp = *args++)) {
2309 if (*cp == '-')
2310 switch (i = smatch (++cp, showswit)) {
2311 case AMBIGSW:
2312 ambigsw (cp, showswit);
2313 return;
2314 case UNKWNSW:
2315 case SHNPROG:
2316 vec[vecp++] = --cp;
2317 continue;
2318 case SHHELP:
2319 snprintf (buf, sizeof(buf), "%s %s[switches] [switches for showproc]",
2320 cmd_name, mode ? NULL : "[msgs] ");
2321 print_help (buf, showswit, 1);
2322 return;
2323
2324 case SHFORM:
2325 case SHPROG:
2326 case SHLEN:
2327 case SHWID:
2328 vec[vecp++] = --cp;
2329 if (!(cp = *args++) || *cp == '-') {
2330 advise (NULL, "missing argument to %s", args[-2]);
2331 return;
2332 }
2333 vec[vecp++] = cp;
2334 continue;
2335 case SHHEAD:
2336 headersw++;
2337 continue;
2338 case SHNHEAD:
2339 headersw = 0;
2340 continue;
2341 case SHSHOW:
2342 if (!(proc = *args++) || *proc == '-') {
2343 advise (NULL, "missing argument to %s", args[-2]);
2344 return;
2345 }
2346 nshow = 0;
2347 continue;
2348 case SHNSHOW:
2349 nshow++;
2350 continue;
2351
2352 case SHDRAFT:
2353 advise (NULL, "sorry, -%s not allowed!", showswit[i].sw);
2354 return;
2355 }
2356 if (*cp == '+' || *cp == '@') {
2357 advise (NULL, "sorry, no folders allowed!");
2358 return;
2359 }
2360 else
2361 if (mode) {
2362 fprintf (stderr,
2363 "usage: %s [switches] [switches for showproc]\n",
2364 cmd_name);
2365 return;
2366 }
2367 else
2368 msgs[msgp++] = cp;
2369 }
2370 vec[vecp] = NULL;
2371
2372 if (!msgp)
2373 msgs[msgp++] = mode > 0 ? "next" : mode < 0 ? "prev" : "cur";
2374 for (msgnum = 0; msgnum < msgp; msgnum++)
2375 if (!m_convert (mp, msgs[msgnum]))
2376 return;
2377 seq_setprev (mp);
2378
2379 if (!nshow && !getenv ("NOMHNPROC"))
2380 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2381 if (is_selected (mp, msgnum) && is_nontext (msgnum)) {
2382 proc = showmimeproc;
2383 vec[vecp++] = "-show";
2384 vec[vecp++] = "-file";
2385 vec[vecp] = NULL;
2386 goto finish;
2387 }
2388
2389 if (nshow)
2390 proc = catproc;
2391 else
2392 if (strcmp (showproc, "mhl") == 0) {
2393 proc = mhlproc;
2394 mhl++;
2395 }
2396
2397 finish: ;
2398 seqnum = seq_getnum (mp, "unseen");
2399 vec[0] = r1bindex (proc, '/');
2400 if (mhl) {
2401 msgp = vecp;
2402 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2403 if (is_selected (mp, msgnum)) {
2404 vec[vecp++] = getcpy (m_name (msgnum));
2405 if (seqnum != -1)
2406 seq_delmsg (mp, "unseen", msgnum);
2407 }
2408 vec[vecp] = NULL;
2409 if (mp->numsel == 1 && headersw)
2410 show (mp->lowsel);
2411 mhlsbr (vecp, vec, mhl_action);
2412 m_eomsbr ((int (*)()) 0);
2413 while (msgp < vecp)
2414 free (vec[msgp++]);
2415 } else {
2416 interrupted = 0;
2417 for (msgnum = mp->lowsel;
2418 msgnum <= mp->hghsel && !interrupted;
2419 msgnum++)
2420 if (is_selected (mp, msgnum)) {
2421 switch (ask (msgnum)) {
2422 case NOTOK: /* QUIT */
2423 break;
2424
2425 case OK: /* INTR */
2426 continue;
2427
2428 default:
2429 if (mp->numsel == 1 && headersw)
2430 show (msgnum);
2431 if (nshow)
2432 copy_message (msgnum, stdout);
2433 else
2434 process (msgnum, proc, vecp, vec);
2435
2436 if (seqnum != -1)
2437 seq_delmsg (mp, "unseen", msgnum);
2438 continue;
2439 }
2440 break;
2441 }
2442 }
2443
2444 seq_setcur (mp, mp->hghsel);
2445 }
2446
2447
2448 static void
2449 show (int msgnum)
2450 {
2451 if (Msgs[msgnum].m_bboard_id == 0)
2452 readid (msgnum);
2453
2454 printf ("(Message %d", msgnum);
2455 if (Msgs[msgnum].m_bboard_id > 0)
2456 printf (", %s: %d", BBoard_ID, Msgs[msgnum].m_bboard_id);
2457 printf (")\n");
2458 }
2459
2460
2461
2462 static int
2463 eom_action (int c)
2464 {
2465 return (ftell (mhlfp) >= Msgs[mhlnum].m_stop);
2466 }
2467
2468
2469 static FILE *
2470 mhl_action (char *name)
2471 {
2472 int msgnum;
2473
2474 if ((msgnum = m_atoi (name)) < mp->lowmsg
2475 || msgnum > mp->hghmsg
2476 || !does_exist (mp, msgnum))
2477 return NULL;
2478 mhlnum = msgnum;
2479
2480 mhlfp = msh_ready (msgnum, 1);
2481 if (!fmsh)
2482 m_eomsbr (eom_action);
2483
2484 return mhlfp;
2485 }
2486
2487
2488
2489 static int
2490 ask (int msgnum)
2491 {
2492 char buf[BUFSIZ];
2493
2494 if (mp->numsel == 1 || !interactive || redirected)
2495 return DONE;
2496
2497 if (SOprintf ("Press <return> to list \"%d\"...", msgnum)) {
2498 if (mp->lowsel != msgnum)
2499 printf ("\n\n\n");
2500 printf ("Press <return> to list \"%d\"...", msgnum);
2501 }
2502 fflush (stdout);
2503 buf[0] = 0;
2504
2505 #ifndef BSD42
2506 read (fileno (stdout), buf, sizeof buf);
2507 #else /* BSD42 */
2508 switch (setjmp (sigenv)) {
2509 case OK:
2510 should_intr = 1;
2511 read (fileno (stdout), buf, sizeof buf);/* fall... */
2512
2513 default:
2514 should_intr = 0;
2515 break;
2516 }
2517 #endif /* BSD42 */
2518
2519 if (strchr(buf, '\n') == NULL)
2520 putchar ('\n');
2521
2522 if (told_to_quit) {
2523 told_to_quit = interrupted = 0;
2524 return NOTOK;
2525 }
2526 if (interrupted) {
2527 interrupted = 0;
2528 return OK;
2529 }
2530
2531 return DONE;
2532 }
2533
2534
2535 #include <h/mime.h>
2536
2537 static int
2538 is_nontext (int msgnum)
2539 {
2540 int result, state;
2541 char *bp, *cp, *dp;
2542 char buf[BUFSIZ], name[NAMESZ];
2543 FILE *fp;
2544
2545 if (Msgs[msgnum].m_flags & MHNCHK)
2546 return (Msgs[msgnum].m_flags & MHNYES);
2547 Msgs[msgnum].m_flags |= MHNCHK;
2548
2549 fp = msh_ready (msgnum, 1);
2550
2551 for (state = FLD;;)
2552 switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
2553 case FLD:
2554 case FLDPLUS:
2555 case FLDEOF:
2556 /*
2557 * Check Content-Type field
2558 */
2559 if (!strcasecmp (name, TYPE_FIELD)) {
2560 int passno;
2561 char c;
2562
2563 cp = add (buf, NULL);
2564 while (state == FLDPLUS) {
2565 state = m_getfld (state, name, buf, sizeof buf, fp);
2566 cp = add (buf, cp);
2567 }
2568 bp = cp;
2569 passno = 1;
2570
2571 again:
2572 for (; isspace (*bp); bp++)
2573 continue;
2574 if (*bp == '(') {
2575 int i;
2576
2577 for (bp++, i = 0;;) {
2578 switch (*bp++) {
2579 case '\0':
2580 invalid:
2581 result = 0;
2582 goto out;
2583 case '\\':
2584 if (*bp++ == '\0')
2585 goto invalid;
2586 continue;
2587 case '(':
2588 i++;
2589 /* and fall... */
2590 default:
2591 continue;
2592 case ')':
2593 if (--i < 0)
2594 break;
2595 continue;
2596 }
2597 break;
2598 }
2599 }
2600 if (passno == 2) {
2601 if (*bp != '/')
2602 goto invalid;
2603 bp++;
2604 passno = 3;
2605 goto again;
2606 }
2607 for (dp = bp; istoken (*dp); dp++)
2608 continue;
2609 c = *dp;
2610 *dp = '\0';
2611 if (!*bp)
2612 goto invalid;
2613 if (passno > 1) {
2614 if ((result = (strcasecmp (bp, "plain") != 0)))
2615 goto out;
2616 *dp = c;
2617 for (dp++; isspace (*dp); dp++)
2618 continue;
2619 if (*dp) {
2620 if ((result = !uprf (dp, "charset")))
2621 goto out;
2622 dp += sizeof "charset" - 1;
2623 while (isspace (*dp))
2624 dp++;
2625 if (*dp++ != '=')
2626 goto invalid;
2627 while (isspace (*dp))
2628 dp++;
2629 if (*dp == '"') {
2630 if ((bp = strchr(++dp, '"')))
2631 *bp = '\0';
2632 } else {
2633 for (bp = dp; *bp; bp++)
2634 if (isspace (*bp)) {
2635 *bp = '\0';
2636 break;
2637 }
2638 }
2639 } else {
2640 /* Default character set */
2641 dp = "US-ASCII";
2642 }
2643 /* Check the character set */
2644 result = !check_charset (dp, strlen (dp));
2645 } else {
2646 if (!(result = (strcasecmp (bp, "text") != 0))) {
2647 *dp = c;
2648 bp = dp;
2649 passno = 2;
2650 goto again;
2651 }
2652 }
2653 out:
2654 free (cp);
2655 if (result) {
2656 Msgs[msgnum].m_flags |= MHNYES;
2657 return result;
2658 }
2659 break;
2660 }
2661
2662 /*
2663 * Check Content-Transfer-Encoding field
2664 */
2665 if (!strcasecmp (name, ENCODING_FIELD)) {
2666 cp = add (buf, NULL);
2667 while (state == FLDPLUS) {
2668 state = m_getfld (state, name, buf, sizeof buf, fp);
2669 cp = add (buf, cp);
2670 }
2671 for (bp = cp; isspace (*bp); bp++)
2672 continue;
2673 for (dp = bp; istoken (*dp); dp++)
2674 continue;
2675 *dp = '\0';
2676 result = (strcasecmp (bp, "7bit")
2677 && strcasecmp (bp, "8bit")
2678 && strcasecmp (bp, "binary"));
2679
2680 free (cp);
2681 if (result) {
2682 Msgs[msgnum].m_flags |= MHNYES;
2683 return result;
2684 }
2685 break;
2686 }
2687
2688 /*
2689 * Just skip the rest of this header
2690 * field and go to next one.
2691 */
2692 while (state == FLDPLUS)
2693 state = m_getfld (state, name, buf, sizeof(buf), fp);
2694 break;
2695
2696 /*
2697 * We've passed the message header,
2698 * so message is just text.
2699 */
2700 default:
2701 return 0;
2702 }
2703 }
2704
2705
2706 static struct swit sortswit[] = {
2707 #define SODATE 0
2708 { "datefield field", 0 },
2709 #define SOSUBJ 1
2710 { "textfield field", 0 },
2711 #define SONSUBJ 2
2712 { "notextfield", 0 },
2713 #define SOLIMT 3
2714 { "limit days", 0 },
2715 #define SONLIMT 4
2716 { "nolimit", 0 },
2717 #define SOVERB 5
2718 { "verbose", 0 },
2719 #define SONVERB 6
2720 { "noverbose", 0 },
2721 #define SOHELP 7
2722 { "help", 4 },
2723 { NULL, 0 }
2724 };
2725
2726
2727 void
2728 sortcmd (char **args)
2729 {
2730 int msgp = 0, msgnum;
2731 char *cp, *datesw = NULL, *subjsw = NULL;
2732 char buf[BUFSIZ], *msgs[MAXARGS];
2733 struct tws tb;
2734
2735 if (fmsh) {
2736 forkcmd (args, cmd_name);
2737 return;
2738 }
2739
2740 while ((cp = *args++)) {
2741 if (*cp == '-')
2742 switch (smatch (++cp, sortswit)) {
2743 case AMBIGSW:
2744 ambigsw (cp, sortswit);
2745 return;
2746 case UNKWNSW:
2747 fprintf (stderr, "-%s unknown\n", cp);
2748 return;
2749 case SOHELP:
2750 snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2751 print_help (buf, sortswit, 1);
2752 return;
2753
2754 case SODATE:
2755 if (datesw) {
2756 advise (NULL, "only one date field at a time!");
2757 return;
2758 }
2759 if (!(datesw = *args++) || *datesw == '-') {
2760 advise (NULL, "missing argument to %s", args[-2]);
2761 return;
2762 }
2763 continue;
2764
2765 case SOSUBJ:
2766 if (subjsw) {
2767 advise (NULL, "only one text field at a time!");
2768 return;
2769 }
2770 if (!(subjsw = *args++) || *subjsw == '-') {
2771 advise (NULL, "missing argument to %s", args[-2]);
2772 return;
2773 }
2774 continue;
2775 case SONSUBJ:
2776 subjsw = (char *)0;
2777 continue;
2778
2779 case SOLIMT: /* too hard */
2780 if (!(cp = *args++) || *cp == '-') {
2781 advise (NULL, "missing argument to %s", args[-2]);
2782 return;
2783 }
2784 case SONLIMT:
2785 case SOVERB: /* not implemented */
2786 case SONVERB:
2787 continue;
2788 }
2789 if (*cp == '+' || *cp == '@') {
2790 advise (NULL, "sorry, no folders allowed!");
2791 return;
2792 }
2793 else
2794 msgs[msgp++] = cp;
2795 }
2796
2797 if (!msgp)
2798 msgs[msgp++] = "all";
2799 if (!datesw)
2800 datesw = "Date";
2801 for (msgnum = 0; msgnum < msgp; msgnum++)
2802 if (!m_convert (mp, msgs[msgnum]))
2803 return;
2804 seq_setprev (mp);
2805
2806 twscopy (&tb, dlocaltimenow ());
2807
2808 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2809 if (Msgs[msgnum].m_scanl) {
2810 free (Msgs[msgnum].m_scanl);
2811 Msgs[msgnum].m_scanl = NULL;
2812 }
2813 if (is_selected (mp, msgnum)) {
2814 if (get_fields (datesw, subjsw, msgnum, &Msgs[msgnum]))
2815 twscopy (&Msgs[msgnum].m_tb,
2816 msgnum != mp->lowsel ? &Msgs[msgnum - 1].m_tb : &tb);
2817 }
2818 else /* m_scaln is already NULL */
2819 twscopy (&Msgs[msgnum].m_tb, &tb);
2820 Msgs[msgnum].m_stats = mp->msgstats[msgnum - mp->lowoff];
2821 if (mp->curmsg == msgnum)
2822 Msgs[msgnum].m_stats |= CUR;
2823 }
2824
2825 qsort ((char *) &Msgs[mp->lowsel], mp->hghsel - mp->lowsel + 1,
2826 sizeof(struct Msg), (qsort_comp) (subjsw ? subsort : msgsort));
2827
2828 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2829 if (subjsw && Msgs[msgnum].m_scanl) {
2830 free (Msgs[msgnum].m_scanl); /* from subjsort */
2831 Msgs[msgnum].m_scanl = NULL;
2832 }
2833 mp->msgstats[msgnum - mp->lowoff] = Msgs[msgnum].m_stats & ~CUR;
2834 if (Msgs[msgnum].m_stats & CUR)
2835 seq_setcur (mp, msgnum);
2836 }
2837
2838 mp->msgflags |= MODIFIED;
2839 modified++;
2840 }
2841
2842
2843 /*
2844 * get_fields - parse message, and get date and subject if needed.
2845 * We'll use the msgp->m_tb tws struct for the date, and overload
2846 * the msgp->m_scanl field with our subject string.
2847 */
2848 static int
2849 get_fields (char *datesw, char *subjsw, int msgnum, struct Msg *msgp)
2850 {
2851 int state, gotdate = 0;
2852 char *bp, buf[BUFSIZ], name[NAMESZ];
2853 struct tws *tw = (struct tws *) 0;
2854 register FILE *zp;
2855
2856 zp = msh_ready (msgnum, 0);
2857 for (state = FLD;;) {
2858 switch (state = m_getfld (state, name, buf, sizeof buf, zp)) {
2859 case FLD:
2860 case FLDEOF:
2861 case FLDPLUS:
2862 if (!strcasecmp (name, datesw)) {
2863 bp = getcpy (buf);
2864 while (state == FLDPLUS) {
2865 state = m_getfld (state, name, buf, sizeof buf, zp);
2866 bp = add (buf, bp);
2867 }
2868 if ((tw = dparsetime (bp)) == NULL)
2869 admonish (NULL,
2870 "unable to parse %s field in message %d",
2871 datesw, msgnum);
2872 else
2873 twscopy (&(msgp->m_tb), tw);
2874 free (bp);
2875 if (!subjsw) /* not using this, or already done */
2876 break; /* all done! */
2877 gotdate++;
2878 }
2879 else if (subjsw && !strcasecmp(name, subjsw)) {
2880 bp = getcpy (buf);
2881 while (state == FLDPLUS) {
2882 state = m_getfld (state, name, buf, sizeof buf, zp);
2883 bp = add (buf, bp);
2884 }
2885 msgp->m_scanl = sosmash(subjsw, bp);
2886 if (gotdate)
2887 break; /* date done so we're done */
2888 else
2889 subjsw = (char *)0;/* subject done, need date */
2890 } else {
2891 while (state == FLDPLUS) /* flush this one */
2892 state = m_getfld (state, name, buf, sizeof buf, zp);
2893 }
2894 continue;
2895
2896 case BODY:
2897 case BODYEOF:
2898 case FILEEOF:
2899 break;
2900
2901 case LENERR:
2902 case FMTERR:
2903 admonish (NULL, "format error in message %d", msgnum);
2904 if (msgp->m_scanl) { /* this might need free'd */
2905 free (msgp->m_scanl); /* probably can't use subj anyway */
2906 msgp->m_scanl = NULL;
2907 }
2908 return NOTOK;
2909
2910 default:
2911 adios (NULL, "internal error -- you lose");
2912 }
2913 break;
2914 }
2915 if (tw)
2916 return OK; /* not an error if subj not found */
2917
2918 admonish (NULL, "no %s field in message %d", datesw, msgnum);
2919 return NOTOK; /* NOTOK means use some other date */
2920 }
2921
2922
2923 /*
2924 * sort routines
2925 */
2926
2927 static int
2928 msgsort (struct Msg *a, struct Msg *b)
2929 {
2930 return twsort (&a->m_tb, &b->m_tb);
2931 }
2932
2933
2934 static int
2935 subsort (struct Msg *a, struct Msg *b)
2936 {
2937 register int i;
2938
2939 if (a->m_scanl && b->m_scanl)
2940 if ((i = strcmp (a->m_scanl, b->m_scanl)))
2941 return (i);
2942
2943 return twsort (&a->m_tb, &b->m_tb);
2944 }
2945
2946
2947 /*
2948 * try to make the subject "canonical": delete leading "re:", everything
2949 * but letters & smash letters to lower case.
2950 */
2951 static char *
2952 sosmash (char *subj, char *s)
2953 {
2954 register char *cp, *dp, c;
2955
2956 if (s) {
2957 cp = s;
2958 dp = s; /* dst pointer */
2959 if (!strcasecmp (subj, "subject"))
2960 while ((c = *cp)) {
2961 if (! isspace(c)) {
2962 if(uprf(cp, "re:"))
2963 cp += 2;
2964 else {
2965 if (isalnum(c))
2966 *dp++ = isupper(c) ? tolower(c) : c;
2967 break;
2968 }
2969 }
2970 cp++;
2971 }
2972 while ((c = *cp++)) {
2973 if (isalnum(c))
2974 *dp++ = isupper(c) ? tolower(c) : c;
2975
2976 }
2977 *dp = '\0';
2978 }
2979 return s;
2980 }
2981
2982
2983 static int
2984 process (int msgnum, char *proc, int vecp, char **vec)
2985 {
2986 int child_id, status;
2987 char tmpfil[80];
2988 FILE *out;
2989
2990 if (fmsh) {
2991 strncpy (tmpfil, m_name (msgnum), sizeof(tmpfil));
2992 context_del (pfolder);
2993 context_replace (pfolder, fmsh);/* update current folder */
2994 seq_save (mp);
2995 context_save (); /* save the context file */
2996 goto ready;
2997 }
2998
2999 strncpy (tmpfil, m_scratch ("", invo_name), sizeof(tmpfil));
3000 if ((out = fopen (tmpfil, "w")) == NULL) {
3001 int olderr;
3002 extern int errno;
3003 char newfil[80];
3004
3005 olderr = errno;
3006 strncpy (newfil, m_tmpfil (invo_name), sizeof(newfil));
3007 if ((out = fopen (newfil, "w")) == NULL) {
3008 errno = olderr;
3009 advise (tmpfil, "unable to create temporary file");
3010 return NOTOK;
3011 } else {
3012 strncpy (tmpfil, newfil, sizeof(tmpfil));
3013 }
3014 }
3015 copy_message (msgnum, out);
3016 fclose (out);
3017
3018 ready: ;
3019 fflush (stdout);
3020 switch (child_id = fork ()) {
3021 case NOTOK:
3022 advise ("fork", "unable to");
3023 status = NOTOK;
3024 break;
3025
3026 case OK:
3027 closefds (3);
3028 SIGNAL (SIGINT, istat);
3029 SIGNAL (SIGQUIT, qstat);
3030
3031 vec[vecp++] = tmpfil;
3032 vec[vecp] = NULL;
3033
3034 execvp (proc, vec);
3035 fprintf (stderr, "unable to exec ");
3036 perror (proc);
3037 _exit (1);
3038
3039 default:
3040 status = pidXwait (child_id, NULL);
3041 break;
3042 }
3043
3044 if (!fmsh)
3045 unlink (tmpfil);
3046 return status;
3047 }
3048
3049
3050 static void
3051 copy_message (int msgnum, FILE *out)
3052 {
3053 long pos;
3054 static char buffer[BUFSIZ];
3055 register FILE *zp;
3056
3057 zp = msh_ready (msgnum, 1);
3058 if (fmsh) {
3059 while (fgets (buffer, sizeof buffer, zp) != NULL) {
3060 fputs (buffer, out);
3061 if (interrupted && out == stdout)
3062 break;
3063 }
3064 }
3065 else {
3066 pos = ftell (zp);
3067 while (fgets (buffer, sizeof buffer, zp) != NULL
3068 && pos < Msgs[msgnum].m_stop) {
3069 fputs (buffer, out);
3070 pos += (long) strlen (buffer);
3071 if (interrupted && out == stdout)
3072 break;
3073 }
3074 }
3075 }
3076
3077
3078 static void
3079 copy_digest (int msgnum, FILE *out)
3080 {
3081 char c;
3082 long pos;
3083 static char buffer[BUFSIZ];
3084 register FILE *zp;
3085
3086 c = '\n';
3087 zp = msh_ready (msgnum, 1);
3088 if (!fmsh)
3089 pos = ftell (zp);
3090 while (fgets (buffer, sizeof buffer, zp) != NULL
3091 && !fmsh && pos < Msgs[msgnum].m_stop) {
3092 if (c == '\n' && *buffer == '-')
3093 fputc (' ', out);
3094 fputs (buffer, out);
3095 c = buffer[strlen (buffer) - 1];
3096 if (!fmsh)
3097 pos += (long) strlen (buffer);
3098 if (interrupted && out == stdout)
3099 break;
3100 }
3101 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git