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