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