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