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