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