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