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