![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mhlsbr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip|
Return to mhlsbr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / uip |
1.1 root 1: /* mhlsbr.c - implement the "nifty" message lister */
2:
3: #include "../h/mh.h"
4: #include "../h/addrsbr.h"
5: #include "../h/formatsbr.h"
6: #include "../zotnet/tws.h"
7: #include <ctype.h>
8: #include <setjmp.h>
9: #include <signal.h>
10: #include <stdio.h>
11: #include <sys/types.h>
12: #include <sys/stat.h>
13:
14:
15: /* MAJOR BUG:
16: for a component containing addresses, ADDRFMT, if COMPRESS is also
17: set, then addresses get split wrong (not at the spaces between commas).
18: To fix this correctly, putstr() should know about "atomic" strings that
19: must NOT be broken across lines. That's too difficult for right now
20: (it turns out that there are a number of degernate cases), so in
21: oneline(), instead of
22:
23: (*onelp == '\n' && !onelp[1])
24:
25: being a terminating condition,
26:
27: (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT)))
28:
29: is used instead. This cuts the line prematurely, and gives us a much
30: better chance of getting things right.
31: */
32:
33:
34: #define ONECOMP 0
35: #define TWOCOMP 1
36: #define BODYCOMP 2
37:
38: #define adios mhladios
39:
40: #define QUOTE '\\'
41:
42: /* */
43:
44: static struct swit mhlswitches[] = {
45: #define BELLSW 0
46: "bell", 0,
47: #define NBELLSW 1
48: "nobell", 0,
49:
50: #define CLRSW 2
51: "clear", 0,
52: #define NCLRSW 3
53: "noclear", 0,
54:
55: #define FOLDSW 4
56: "folder +folder", 0,
57: #define FORMSW 5
58: "form formfile", 0,
59:
60: #define PROGSW 6
61: "moreproc program", 0,
62: #define NPROGSW 7
63: "nomoreproc", 0,
64:
65: #define LENSW 8
66: "length lines", 0,
67: #define WIDSW 9
68: "width columns", 0,
69:
70: #define HELPSW 10
71: "help", 4,
72:
73: #define FORW1SW 11
74: "forward", -7, /* interface from forw */
75: #define FORW2SW 12
76: "forwall", -7, /* .. */
77:
78: #define DASHSW 13
79: "dashmunging", 4,
80: #define NDASHSW 14
81: "nodashmunging", 6,
82:
83: #define DGSTSW 15
84: "digest list", -6,
85:
86: NULL, NULL
87: };
88:
89: /* */
90:
91: struct mcomp {
92: char *c_name; /* component name */
93: char *c_text; /* component text */
94: char *c_ovtxt; /* text overflow indicator */
95: char *c_nfs; /* iff FORMAT */
96: struct format *c_fmt; /* .. */
97:
98: int c_offset; /* left margin indentation */
99: int c_ovoff; /* overflow indentation */
100: int c_width; /* width of field */
101: int c_cwidth; /* width of component */
102: int c_length; /* length in lines */
103:
104: short c_flags;
105: #define NOCOMPONENT 0x0001 /* don't show component name */
106: #define UPPERCASE 0x0002 /* display in all upper case */
107: #define CENTER 0x0004 /* center line */
108: #define CLEARTEXT 0x0008 /* cleartext */
109: #define EXTRA 0x0010 /* an "extra" component */
110: #define HDROUTPUT 0x0020 /* already output */
111: #define CLEARSCR 0x0040 /* clear screen */
112: #define LEFTADJUST 0x0080 /* left justify multiple lines */
113: #define COMPRESS 0x0100 /* compress text */
114: #define ADDRFMT 0x0200 /* contains addresses */
115: #define BELL 0x0400 /* sound bell at EOP */
116: #define DATEFMT 0x0800 /* contains dates */
117: #define FORMAT 0x1000 /* parse address/date */
118: #define INIT 0x2000
119: #define LBITS "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT"
120: #define GFLAGS (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS)
121:
122: struct mcomp *c_next;
123: };
124:
125: static struct mcomp *msghd = NULL;
126: static struct mcomp *msgtl = NULL;
127: static struct mcomp *fmthd = NULL;
128: static struct mcomp *fmttl = NULL;
129:
130: static struct mcomp global = {
131: NULL, NULL, "", NULL, NULL, 0, -1, 80, -1, 40, BELL, NULL
132: };
133: static struct mcomp holder =
134: {
135: NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, NULL
136: };
137:
138:
139: static struct pair {
140: char *p_name;
141: short p_flags;
142: } pairs[] = {
143: "Date", DATEFMT,
144: "From", ADDRFMT,
145: "Sender", ADDRFMT,
146: "Reply-To", ADDRFMT,
147: "To", ADDRFMT,
148: "cc", ADDRFMT,
149: "Bcc", ADDRFMT,
150: "Resent-Date", DATEFMT,
151: "Resent-From", ADDRFMT,
152: "Resent-Sender", ADDRFMT,
153: "Resent-Reply-To", ADDRFMT,
154: "Resent-To", ADDRFMT,
155: "Resent-cc", ADDRFMT,
156: "Resent-Bcc", ADDRFMT,
157:
158: NULL
159: };
160:
161: static struct triple {
162: char *t_name;
163: short t_on;
164: short t_off;
165: } triples[] = {
166: "nocomponent", NOCOMPONENT, 0,
167: "uppercase", UPPERCASE, 0,
168: "nouppercase", 0, UPPERCASE,
169: "center", CENTER, 0,
170: "nocenter", 0, CENTER,
171: "clearscreen", CLEARSCR, 0,
172: "noclearscreen", 0, CLEARSCR,
173: "noclear", 0, CLEARSCR,
174: "leftadjust", LEFTADJUST, 0,
175: "noleftadjust", 0, LEFTADJUST,
176: "compress", COMPRESS, 0,
177: "nocompress", 0, COMPRESS,
178: "addrfield", ADDRFMT, DATEFMT,
179: "bell", BELL, 0,
180: "nobell", 0, BELL,
181: "datefield", DATEFMT, ADDRFMT,
182:
183: NULL
184: };
185:
186: /* */
187:
188: static int bellflg = 0;
189: static int clearflg = 0;
190: static int forwflg = 0;
191: static int forwall = 0;
192: static int dashflg = 1;
193:
194: static char *digest = NULL;
195:
196: static int exitstat = 0;
197: static int mhldebug = 0;
198:
199: #define PITTY (-1)
200: #define NOTTY 0
201: #define ISTTY 1
202: static int ontty = NOTTY;
203:
204: static int row;
205: static int column;
206:
207: static int lm;
208: static int llim;
209: static int ovoff;
210: static int term;
211: static int wid;
212:
213:
214: static char *ovtxt;
215:
216: static char *onelp;
217:
218:
219: static char *parptr;
220: static char *ignores[MAXARGS];
221:
222:
223: static jmp_buf env;
224: static jmp_buf mhlenv;
225:
226:
227: static char delim3[] = /* from forw.c */
228: "\n------------------------------------------------------------\n\n";
229: static char delim4[] = "\n------------------------------\n\n";
230:
231:
232: static FP (*mhl_action) () = (FP (*) ()) 0;
233:
234: void clear_screen(), mhldone();
235:
236: static int evalvar(), ptoi(), ptos(), mcomp_flags();
237: static char *parse(), *mcomp_add(), *oneline();
238: static void mhl_format(), process(), mhlfile(), mcomp_format(),
239: free_queue(), putcomp(), putstr(), putch(), mhladios(),
240: m_popen();
241: static struct mcomp *add_queue();
242: static SIGDECL intrser(), pipeser(), quitser();
243:
244:
245: /* */
246:
247: /* ARGSUSED */
248:
249: mhl(argc, argv)
250: int argc;
251: char *argv[];
252: {
253: int length = 0,
254: nomore = 0,
255: width = 0,
256: vecp = 0,
257: i;
258: register char *cp,
259: *folder = NULL,
260: *form = NULL,
261: **ap,
262: **argp;
263: char buf[80],
264: *arguments[MAXARGS],
265: *files[MAXARGS];
266:
267: invo_name = r1bindex (argv[0], '/');
268: if ((cp = getenv ("MHLDEBUG")) && *cp)
269: mhldebug++;
270: if ((cp = m_find (invo_name)) != NULL) {
271: ap = brkstring (getcpy (cp), " ", "\n");
272: ap = copyip (ap, arguments);
273: }
274: else
275: ap = arguments;
276: (void) copyip (argv + 1, ap);
277: argp = arguments;
278:
279: /* */
280:
281: vecp = 0;
282: while (cp = *argp++) {
283: if (*cp == '-')
284: switch (smatch (++cp, mhlswitches)) {
285: case AMBIGSW:
286: ambigsw (cp, mhlswitches);
287: mhldone (1);
288: case UNKWNSW:
289: adios (NULLCP, "-%s unknown\n", cp);
290: case HELPSW:
291: (void) sprintf (buf, "%s [switches] [files ...]",
292: invo_name);
293: help (buf, mhlswitches);
294: mhldone (1);
295:
296: case BELLSW:
297: bellflg = 1;
298: continue;
299: case NBELLSW:
300: bellflg = -1;
301: continue;
302:
303: case CLRSW:
304: clearflg = 1;
305: continue;
306: case NCLRSW:
307: clearflg = -1;
308: continue;
309:
310: case FOLDSW:
311: if (!(folder = *argp++) || *folder == '-')
312: adios (NULLCP, "missing argument to %s", argp[-2]);
313: continue;
314: case FORMSW:
315: if (!(form = *argp++) || *form == '-')
316: adios (NULLCP, "missing argument to %s", argp[-2]);
317: continue;
318:
319: case PROGSW:
320: if (!(moreproc = *argp++) || *moreproc == '-')
321: adios (NULLCP, "missing argument to %s", argp[-2]);
322: continue;
323: case NPROGSW:
324: nomore++;
325: continue;
326:
327: case LENSW:
328: if (!(cp = *argp++) || *cp == '-')
329: adios (NULLCP, "missing argument to %s", argp[-2]);
330: if ((length = atoi (cp)) < 1)
331: adios (NULLCP, "bad argument %s %s", argp[-2], cp);
332: continue;
333: case WIDSW:
334: if (!(cp = *argp++) || *cp == '-')
335: adios (NULLCP, "missing argument to %s", argp[-2]);
336: if ((width = atoi (cp)) < 1)
337: adios (NULLCP, "bad argument %s %s", argp[-2], cp);
338: continue;
339:
340: case DGSTSW:
341: if (!(digest = *argp++) || *digest == '-')
342: adios (NULLCP, "missing argument to %s", argp[-2]);
343: case FORW2SW:
344: forwall++; /* fall */
345: case FORW1SW:
346: forwflg++;
347: clearflg = -1;/* XXX */
348: continue;
349:
350: case DASHSW:
351: dashflg++;
352: continue;
353: case NDASHSW:
354: dashflg = 0;
355: continue;
356: }
357: files[vecp++] = cp;
358: }
359:
360: /* */
361:
362: if (!folder)
363: folder = getenv ("mhfolder");
364:
365: if (isatty (fileno (stdout)))
366: if (!nomore && moreproc && *moreproc) {
367: if (mhl_action) {
368: setsig (SIGINT, SIG_IGN);
369: setsig (SIGQUIT, quitser);
370: }
371: m_popen (moreproc);
372: ontty = PITTY;
373: }
374: else {
375: setsig (SIGINT, SIG_IGN);
376: setsig (SIGQUIT, quitser);
377: ontty = ISTTY;
378: }
379: else
380: ontty = NOTTY;
381:
382: mhl_format (form ? form : mhlformat, length, width);
383:
384: if (vecp == 0)
385: process (folder, NULLCP, 1, vecp = 1);
386: else
387: for (i = 0; i < vecp; i++)
388: process (folder, files[i], i + 1, vecp);
389:
390: if (forwall) {
391: if (digest) {
392: printf ("%s", delim4);
393: (void) sprintf (buf, "End of %s Digest\n", digest);
394: i = strlen (buf);
395: for (cp = buf + i; i > 1; i--)
396: *cp++ = '*';
397: *cp++ = '\n';
398: *cp = NULL;
399: printf ("%s", buf);
400: }
401: else
402: printf ("\n------- End of Forwarded Message%s\n\n",
403: vecp > 1 ? "s" : "");
404: }
405:
406: if (clearflg > 0 && ontty == NOTTY)
407: clear_screen ();
408:
409: if (ontty == PITTY)
410: m_pclose ();
411:
412: return exitstat;
413: }
414:
415: /* */
416:
417: static void
418: mhl_format(file, length, width)
419: register char *file;
420: int length, width;
421: {
422: int i;
423: register char *bp,
424: *cp,
425: **ip;
426: char *ap,
427: buffer[BUFSIZ],
428: name[NAMESZ];
429: register struct mcomp *c1;
430: struct stat st;
431: register FILE *fp;
432: static dev_t dev = 0;
433: static ino_t ino = 0;
434: static time_t mtime = 0;
435:
436: if (fmthd != NULL)
437: if (stat (libpath (file), &st) != NOTOK
438: && mtime == st.st_mtime
439: && dev == st.st_dev
440: && ino == st.st_ino)
441: goto out;
442: else
443: free_queue (&fmthd, &fmttl);
444:
445: if ((fp = fopen (libpath (file), "r")) == NULL)
446: adios (file, "unable to open format file");
447:
448: if (fstat (fileno (fp), &st) != NOTOK)
449: mtime = st.st_mtime, dev = st.st_dev, ino = st.st_ino;
450:
451: global.c_ovtxt = global.c_nfs = NULL;
452: global.c_fmt = NULL;
453: global.c_offset = 0;
454: global.c_ovoff = -1;
455: if ((i = sc_width ()) > 5)
456: global.c_width = i;
457: global.c_cwidth = -1;
458: if ((i = sc_length ()) > 5)
459: global.c_length = i - 1;
460: global.c_flags = BELL; /* BELL is default */
461: *(ip = ignores) = NULL;
462:
463: while (vfgets (fp, &ap) == OK) {
464: bp = ap;
465: if (*bp == ';')
466: continue;
467:
468: if (cp = index (bp, '\n'))
469: *cp = NULL;
470:
471: if (*bp == ':') {
472: c1 = add_queue (&fmthd, &fmttl, NULLCP, bp + 1, CLEARTEXT);
473: continue;
474: }
475:
476: parptr = bp;
477: (void) strcpy (name, parse ());
478: switch (*parptr) {
479: case '\0':
480: case ',':
481: case '=':
482: if (uleq (name, "ignores")) {
483: ip = copyip (brkstring (getcpy (++parptr), ",", NULLCP), ip);
484: continue;
485: }
486: parptr = bp;
487: while (*parptr) {
488: if (evalvar (&global))
489: adios (NULLCP, "format file syntax error: %s", bp);
490: if (*parptr)
491: parptr++;
492: }
493: continue;
494:
495: case ':':
496: c1 = add_queue (&fmthd, &fmttl, name, NULLCP, INIT);
497: while (*parptr == ':' || *parptr == ',') {
498: parptr++;
499: if (evalvar (c1))
500: adios (NULLCP, "format file syntax error: %s", bp);
501: }
502: if (!c1 -> c_nfs && global.c_nfs)
503: if (c1 -> c_flags & DATEFMT) {
504: if (global.c_flags & DATEFMT)
505: c1 -> c_nfs = getcpy (global.c_nfs);
506: }
507: else
508: if (c1 -> c_flags & ADDRFMT) {
509: if (global.c_flags & ADDRFMT)
510: c1 -> c_nfs = getcpy (global.c_nfs);
511: }
512: continue;
513:
514: default:
515: adios (NULLCP, "format file syntax error: %s", bp);
516: }
517: }
518: (void) fclose (fp);
519:
520: if (mhldebug)
521: for (c1 = fmthd; c1; c1 = c1 -> c_next) {
522: fprintf (stderr, "c1: name=\"%s\" text=\"%s\" ovtxt=\"%s\"\n",
523: c1 -> c_name, c1 -> c_text, c1 -> c_ovtxt);
524: fprintf (stderr, "\tnfs=0x%x fmt=0x%x\n",
525: c1 -> c_nfs, c1 -> c_fmt);
526: fprintf (stderr, "\toffset=%d ovoff=%d width=%d cwidth=%d length=%d\n",
527: c1 -> c_offset, c1 -> c_ovoff, c1 -> c_width,
528: c1 -> c_cwidth, c1 -> c_length);
529: fprintf (stderr, "\tflags=%s\n",
530: sprintb (buffer, (unsigned) c1 -> c_flags, LBITS));
531: }
532:
533: out: ;
534: if (clearflg == 1)
535: global.c_flags |= CLEARSCR;
536: else
537: if (clearflg == -1)
538: global.c_flags &= ~CLEARSCR;
539:
540: switch (bellflg) { /* command line may override format file */
541: case 1:
542: global.c_flags |= BELL;
543: break;
544: case -1:
545: global.c_flags &= ~BELL;
546: break;
547: }
548:
549: if (length)
550: global.c_length = length;
551: if (width)
552: global.c_width = width;
553: if (global.c_length < 5)
554: global.c_length = 10000;
555: if (global.c_width < 5)
556: global.c_width = 10000;
557: }
558:
559: /* */
560:
561: static int
562: evalvar(c1)
563: register struct mcomp *c1;
564: {
565: char *cp,
566: name[NAMESZ];
567: register struct triple *ap;
568:
569: if (!*parptr)
570: return 0;
571: (void) strcpy (name, parse ());
572:
573: if (uleq (name, "component")) {
574: if (ptos (name, &c1 -> c_text))
575: return 1;
576: c1 -> c_flags &= ~NOCOMPONENT;
577: return 0;
578: }
579: if (uleq (name, "overflowtext"))
580: return ptos (name, &c1 -> c_ovtxt);
581: if (uleq (name, "formatfield")) {
582: if (ptos (name, &cp))
583: return 1;
584: c1 -> c_nfs = getcpy (new_fs (NULLCP, NULLCP, cp));
585: c1 -> c_flags |= FORMAT;
586: return 0;
587: }
588:
589: if (uleq (name, "offset"))
590: return ptoi (name, &c1 -> c_offset);
591: if (uleq (name, "overflowoffset"))
592: return ptoi (name, &c1 -> c_ovoff);
593: if (uleq (name, "width"))
594: return ptoi (name, &c1 -> c_width);
595: if (uleq (name, "compwidth"))
596: return ptoi (name, &c1 -> c_cwidth);
597: if (uleq (name, "length"))
598: return ptoi (name, &c1 -> c_length);
599:
600: for (ap = triples; ap -> t_name; ap++)
601: if (uleq (ap -> t_name, name)) {
602: c1 -> c_flags |= ap -> t_on;
603: c1 -> c_flags &= ~ap -> t_off;
604: return 0;
605: }
606:
607: return 1;
608: }
609:
610: /* */
611:
612: static int
613: ptoi(name, i)
614: register char *name;
615: register int *i;
616: {
617: char *cp;
618:
619: if (*parptr++ != '=' || !*(cp = parse ())) {
620: advise (NULLCP, "missing argument to variable %s", name);
621: return 1;
622: }
623:
624: *i = atoi (cp);
625: return 0;
626: }
627:
628:
629: static int
630: ptos(name, s)
631: register char *name, **s;
632: {
633: char c,
634: *cp;
635:
636: if (*parptr++ != '=') {
637: advise (NULLCP, "missing argument to variable %s", name);
638: return 1;
639: }
640:
641: if (*parptr != '"')
642: for (cp = parptr;
643: *parptr && *parptr != ':' && *parptr != ',';
644: parptr++)
645: continue;
646: else
647: for (cp = ++parptr; *parptr && *parptr != '"'; parptr++)
648: if (*parptr == QUOTE)
649: if (!*++parptr)
650: parptr--;
651: c = *parptr;
652: *parptr = NULL;
653: *s = getcpy (cp);
654: if ((*parptr = c) == '"')
655: parptr++;
656: return 0;
657: }
658:
659: /* */
660:
661: static char *
662: parse()
663: {
664: int c;
665: register char *cp;
666: static char result[NAMESZ];
667:
668: for (cp = result; c = *parptr; parptr++)
669: if (isalnum (c)
670: || c == '.'
671: || c == '-'
672: || c == '_'
673: || c =='['
674: || c == ']')
675: *cp++ = c;
676: else
677: break;
678: *cp = NULL;
679:
680: return result;
681: }
682:
683: /* */
684:
685: static void
686: process(folder, fname, ofilen, ofilec)
687: register char *folder, *fname;
688: int ofilen, ofilec;
689: {
690: register char *cp;
691: register struct mcomp *c1;
692: register FILE *fp;
693:
694: switch (setjmp (env)) {
695: case OK:
696: if (fname) {
697: fp = mhl_action ? (*mhl_action) (fname) : fopen (fname, "r");
698: if (fp == NULL) {
699: advise (fname, "unable to open");
700: exitstat++;
701: return;
702: }
703: }
704: else {
705: fname = "(stdin)";
706: fp = stdin;
707: }
708: cp = folder ? concat (folder, ":", fname, NULLCP) : getcpy (fname);
709: if (ontty != PITTY)
710: (void) signal (SIGINT, intrser);
711: mhlfile (fp, cp, ofilen, ofilec);/* fall */
712:
713: default:
714: if (ontty != PITTY)
715: (void) signal (SIGINT, SIG_IGN);
716: if (mhl_action == NULL && fp != stdin)
717: (void) fclose (fp);
718: free (cp);
719: if (holder.c_text) {
720: free (holder.c_text);
721: holder.c_text = NULL;
722: }
723: free_queue (&msghd, &msgtl);
724: for (c1 = fmthd; c1; c1 = c1 -> c_next)
725: c1 -> c_flags &= ~HDROUTPUT;
726: break;
727: }
728: }
729:
730: /* */
731:
732: static void
733: mhlfile(fp, mname, ofilen, ofilec)
734: register FILE *fp;
735: register char *mname;
736: int ofilen, ofilec;
737: {
738: int state;
739: register struct mcomp *c1,
740: *c2;
741: register char **ip;
742: char name[NAMESZ],
743: buf[BUFSIZ];
744:
745: if (forwall) {
746: if (digest)
747: printf ("%s", ofilen == 1 ? delim3 : delim4);
748: else {
749: printf ("\n-------");
750: if (ofilen == 1)
751: printf (" Forwarded Message%s", ofilec > 1 ? "s" : "");
752: else
753: printf (" Message %d", ofilen);
754: printf ("\n\n");
755: }
756: }
757: else
758: switch (ontty) {
759: case PITTY:
760: if (ofilec > 1) {
761: if (ofilen > 1) {
762: if ((global.c_flags & CLEARSCR))
763: clear_screen ();
764: else
765: printf ("\n\n\n");
766: }
767: printf (">>> %s\n\n", mname);
768: }
769: break;
770:
771: case ISTTY:
772: (void) strcpy (buf, "\n");
773: if (ofilec > 1) {
774: if (SOprintf ("Press <return> to list \"%s\"...", mname)) {
775: if (ofilen > 1)
776: printf ("\n\n\n");
777: printf ("Press <return> to list \"%s\"...", mname);
778: }
779: (void) fflush (stdout);
780: buf[0] = NULL;
781: (void) read (fileno (stdout), buf, sizeof buf);
782: }
783: if (index (buf, '\n')) {
784: if ((global.c_flags & CLEARSCR))
785: clear_screen ();
786: }
787: else
788: printf ("\n");
789: break;
790:
791: default:
792: if (ofilec > 1) {
793: if (ofilen > 1) {
794: printf ("\n\n\n");
795: if (clearflg > 0)
796: clear_screen ();
797: }
798: printf (">>> %s\n\n", mname);
799: }
800: break;
801: }
802:
803: /* */
804:
805: for (state = FLD;;)
806: switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
807: case FLD:
808: case FLDPLUS:
809: for (ip = ignores; *ip; ip++)
810: if (uleq (name, *ip)) {
811: while (state == FLDPLUS)
812: state = m_getfld (state, name, buf, sizeof buf, fp);
813: break;
814: }
815: if (*ip)
816: continue;
817:
818: for (c1 = msghd; c1; c1 = c1 -> c_next)
819: if (uleq (name, c1 -> c_name)) {
820: c1 -> c_text =
821: mcomp_add (c1 -> c_flags, buf, c1 -> c_text);
822: break;
823: }
824: if (c1 == NULL)
825: c1 = add_queue (&msghd, &msgtl, name, buf, 0);
826: while (state == FLDPLUS) {
827: state = m_getfld (state, name, buf, sizeof buf, fp);
828: c1 -> c_text = add (buf, c1 -> c_text);
829: }
830:
831: for (c2 = fmthd; c2; c2 = c2 -> c_next)
832: if (uleq (c2 -> c_name, c1 -> c_name))
833: break;
834: if (c2 == NULL)
835: c1 -> c_flags |= EXTRA;
836: continue;
837:
838: case BODY:
839: case FILEEOF:
840: row = column = 0;
841: for (c1 = fmthd; c1; c1 = c1 -> c_next) {
842: if (c1 -> c_flags & CLEARTEXT) {
843: putcomp (c1, c1, ONECOMP);
844: continue;
845: }
846: if (uleq (c1 -> c_name, "messagename")) {
847: holder.c_text = concat ("(Message ", mname, ")\n",
848: NULLCP);
849: putcomp (c1, &holder, ONECOMP);
850: free (holder.c_text);
851: holder.c_text = NULL;
852: continue;
853: }
854: if (uleq (c1 -> c_name, "extras")) {
855: for (c2 = msghd; c2; c2 = c2 -> c_next)
856: if (c2 -> c_flags & EXTRA)
857: putcomp (c1, c2, TWOCOMP);
858: continue;
859: }
860: if (uleq (c1 -> c_name, "body")) {
861: if ((holder.c_text = malloc (sizeof buf)) == NULL)
862: adios (NULLCP, "unable to allocate buffer memory");
863: (void) strcpy (holder.c_text, buf);
864: while (state == BODY) {
865: putcomp (c1, &holder, BODYCOMP);
866: state = m_getfld (state, name, holder.c_text,
867: sizeof buf, fp);
868: }
869: free (holder.c_text);
870: holder.c_text = NULL;
871: continue;
872: }
873: for (c2 = msghd; c2; c2 = c2 -> c_next)
874: if (uleq (c2 -> c_name, c1 -> c_name)) {
875: putcomp (c1, c2, ONECOMP);
876: break;
877: }
878: }
879: return;
880:
881: case LENERR:
882: case FMTERR:
883: advise (NULLCP, "format error in message %s", mname);
884: exitstat++;
885: return;
886:
887: default:
888: adios (NULLCP, "getfld() returned %d", state);
889: }
890: }
891:
892: /* */
893:
894: static int
895: mcomp_flags(name)
896: register char *name;
897: {
898: register struct pair *ap;
899:
900: for (ap = pairs; ap -> p_name; ap++)
901: if (uleq (ap -> p_name, name))
902: return (ap -> p_flags);
903:
904: return NULL;
905: }
906:
907:
908: static char *
909: mcomp_add(flags, s1, s2)
910: short flags;
911: register char *s1, *s2;
912: {
913: register char *dp;
914:
915: if (!(flags & ADDRFMT))
916: return add (s1, s2);
917:
918: if (s2 && *(dp = s2 + strlen (s2) - 1) == '\n')
919: *dp = NULL;
920:
921: return add (s1, add (",\n", s2));
922: }
923:
924: /* */
925:
926: struct pqpair {
927: char *pq_text;
928: char *pq_error;
929: struct pqpair *pq_next;
930: };
931:
932:
933: static void
934: mcomp_format(c1, c2)
935: register struct mcomp *c1, *c2;
936: {
937: int dat[4];
938: register char *ap,
939: *cp;
940: char buffer[BUFSIZ],
941: error[BUFSIZ];
942: register struct comp *cptr;
943: register struct pqpair *p,
944: *q;
945: struct pqpair pq;
946: register struct mailname *mp;
947:
948: ap = c2 -> c_text;
949: c2 -> c_text = NULL;
950: dat[0] = dat[1] = dat[2] = 0;
951: dat[3] = sizeof buffer - 1;
952: (void) fmt_compile (c1 -> c_nfs, &c1 -> c_fmt);
953:
954: if (c1 -> c_flags & DATEFMT) {
955: FINDCOMP (cptr, "text");
956: if (cptr)
957: cptr -> c_text = ap;
958:
959: (void) fmtscan (c1 -> c_fmt, buffer, sizeof buffer - 1, dat);
960: /* Don't need to append a newline, dctime() already did */
961: c2 -> c_text = getcpy (buffer);
962:
963: free (ap);
964: return;
965: }
966:
967: (q = &pq) -> pq_next = NULL;
968: while (cp = getname (ap)) {
969: if ((p = (struct pqpair *) calloc ((unsigned) 1, sizeof *p)) == NULL)
970: adios (NULLCP, "unable to allocate pqpair memory");
971:
972: if ((mp = getm (cp, NULLCP, 0, AD_NAME, error)) == NULL) {
973: p -> pq_text = getcpy (cp);
974: p -> pq_error = getcpy (error);
975: }
976: else {
977: p -> pq_text = getcpy (mp -> m_text);
978: mnfree (mp);
979: }
980: q = (q -> pq_next = p);
981: }
982:
983: for (p = pq.pq_next; p; p = q) {
984: FINDCOMP (cptr, "text");
985: if (cptr)
986: cptr -> c_text = p -> pq_text;
987: FINDCOMP (cptr, "error");
988: if (cptr)
989: cptr -> c_text = p -> pq_error;
990:
991: (void) fmtscan (c1 -> c_fmt, buffer, sizeof buffer - 1, dat);
992: if (*buffer) {
993: if (c2 -> c_text)
994: c2 -> c_text = add (",\n", c2 -> c_text);
995: if (*(cp = buffer + strlen (buffer) - 1) == '\n')
996: *cp = NULL;
997: c2 -> c_text = add (buffer, c2 -> c_text);
998: }
999:
1000: free (p -> pq_text);
1001: if (p -> pq_error)
1002: free (p -> pq_error);
1003: q = p -> pq_next;
1004: free ((char *) p);
1005: }
1006:
1007: c2 -> c_text = add ("\n", c2 -> c_text);
1008: free (ap);
1009: }
1010:
1011: /* */
1012:
1013: static struct mcomp *
1014: add_queue(head, tail, name, text, flags)
1015: register struct mcomp **head, **tail;
1016: register char *name, *text;
1017: int flags;
1018: {
1019: register struct mcomp *c1;
1020:
1021: if ((c1 = (struct mcomp *) calloc ((unsigned) 1, sizeof *c1)) == NULL)
1022: adios (NULLCP, "unable to allocate comp memory");
1023:
1024: c1 -> c_flags = flags & ~INIT;
1025: if (c1 -> c_name = name ? getcpy (name) : NULL)
1026: c1 -> c_flags |= mcomp_flags (c1 -> c_name);
1027: c1 -> c_text = text ? getcpy (text) : NULL;
1028: if (flags & INIT) {
1029: if (global.c_ovtxt)
1030: c1 -> c_ovtxt = getcpy (global.c_ovtxt);
1031: c1 -> c_offset = global.c_offset;
1032: c1 -> c_ovoff = global. c_ovoff;
1033: c1 -> c_width = c1 -> c_length = 0;
1034: c1 -> c_cwidth = global.c_cwidth;
1035: c1 -> c_flags |= global.c_flags & GFLAGS;
1036: }
1037: if (*head == NULL)
1038: *head = c1;
1039: if (*tail != NULL)
1040: (*tail) -> c_next = c1;
1041: *tail = c1;
1042:
1043: return c1;
1044: }
1045:
1046:
1047: static void
1048: free_queue(head, tail)
1049: register struct mcomp **head, **tail;
1050: {
1051: register struct mcomp *c1,
1052: *c2;
1053:
1054: for (c1 = *head; c1; c1 = c2) {
1055: c2 = c1 -> c_next;
1056: if (c1 -> c_name)
1057: free (c1 -> c_name);
1058: if (c1 -> c_text)
1059: free (c1 -> c_text);
1060: if (c1 -> c_ovtxt)
1061: free (c1 -> c_ovtxt);
1062: if (c1 -> c_nfs)
1063: free (c1 -> c_nfs);
1064: if (c1 -> c_fmt)
1065: free ((char *) c1 -> c_fmt);
1066: free ((char *) c1);
1067: }
1068:
1069: *head = *tail = NULL;
1070: }
1071:
1072: /* */
1073:
1074: static void
1075: putcomp(c1, c2, flag)
1076: register struct mcomp *c1, *c2;
1077: int flag;
1078: {
1079: int count,
1080: cchdr;
1081: register char *cp;
1082: static int lastterm = '\n'; /* initial state */
1083:
1084: cchdr = 0;
1085: lm = 0;
1086: llim = c1 -> c_length ? c1 -> c_length : -1;
1087: wid = c1 -> c_width ? c1 -> c_width : global.c_width;
1088: ovoff = (c1 -> c_ovoff >= 0 ? c1 -> c_ovoff : global.c_ovoff)
1089: + c1 -> c_offset;
1090: if ((ovtxt = c1 -> c_ovtxt ? c1 -> c_ovtxt : global.c_ovtxt) == NULL)
1091: ovtxt = "";
1092: if (wid < ovoff + strlen (ovtxt) + 5)
1093: adios (NULLCP, "component: %s width(%d) too small for overflow(%d)",
1094: c1 -> c_name, wid, ovoff + strlen (ovtxt) + 5);
1095: onelp = NULL;
1096:
1097: if (c1 -> c_flags & CLEARTEXT) {
1098: putstr (c1 -> c_text);
1099: putstr ("\n");
1100: return;
1101: }
1102:
1103: if (c1 -> c_nfs && (c1 -> c_flags & (ADDRFMT | DATEFMT)))
1104: mcomp_format (c1, c2);
1105:
1106: if (c1 -> c_flags & CENTER) {
1107: count = (c1 -> c_width ? c1 -> c_width : global.c_width)
1108: - c1 -> c_offset - strlen (c2 -> c_text);
1109: if (!(c1 -> c_flags & HDROUTPUT) && !(c1 -> c_flags & NOCOMPONENT))
1110: count -= strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) + 2;
1111: lm = c1 -> c_offset + (count / 2);
1112: }
1113: else
1114: if (c1 -> c_offset)
1115: lm = c1 -> c_offset;
1116:
1117: if (!(c1 -> c_flags & HDROUTPUT) && !(c1 -> c_flags & NOCOMPONENT)) {
1118: if (c1 -> c_flags & UPPERCASE) /* uppercase component also */
1119: for (cp = (c1 -> c_text ? c1 -> c_text : c1 -> c_name); *cp; cp++)
1120: if (islower (*cp))
1121: *cp = toupper (*cp);
1122: if (flag != BODYCOMP || lastterm == '\n')
1123: putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
1124: if (flag != BODYCOMP) {
1125: putstr (": ");
1126: c1 -> c_flags |= HDROUTPUT;
1127: }
1128:
1129: cchdr++;
1130: if ((count = c1 -> c_cwidth -
1131: strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) - 2) > 0)
1132: while (count--)
1133: putstr (" ");
1134: }
1135:
1136: if (flag == TWOCOMP
1137: && !(c2 -> c_flags & HDROUTPUT)
1138: && !(c2 -> c_flags & NOCOMPONENT)) {
1139: if (c1 -> c_flags & UPPERCASE)
1140: for (cp = c2 -> c_name; *cp; cp++)
1141: if (islower (*cp))
1142: *cp = toupper (*cp);
1143: putstr (c2 -> c_name);
1144: putstr (": ");
1145: c2 -> c_flags |= HDROUTPUT;
1146: }
1147: if (c1 -> c_flags & UPPERCASE)
1148: for (cp = c2 -> c_text; *cp; cp++)
1149: if (islower (*cp))
1150: *cp = toupper (*cp);
1151:
1152: count = 0;
1153: if (cchdr)
1154: count = (c1 -> c_cwidth >= 0) ? c1 -> c_cwidth
1155: : strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) + 2;
1156: count += c1 -> c_offset;
1157:
1158: putstr (oneline (c2 -> c_text, c1 -> c_flags));
1159: if (term == '\n')
1160: putstr ("\n");
1161: lastterm = term;
1162: while (cp = oneline (c2 -> c_text, c1 -> c_flags)) {
1163: if (flag == BODYCOMP
1164: && lastterm == '\n'
1165: && !(c1 -> c_flags & HDROUTPUT)
1166: && !(c1 -> c_flags & NOCOMPONENT))
1167: putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
1168: if (*cp) {
1169: lm = count;
1170: putstr (cp);
1171: }
1172: if (term == '\n')
1173: putstr ("\n");
1174: lastterm = term;
1175: }
1176: }
1177:
1178: /* */
1179:
1180: static char *
1181: oneline(stuff, flags)
1182: register char *stuff;
1183: short flags;
1184: {
1185: int spc;
1186: register char *cp,
1187: *ret;
1188:
1189: if (onelp == NULL)
1190: onelp = stuff;
1191: if (*onelp == NULL)
1192: return (onelp = NULL);
1193:
1194: ret = onelp;
1195: term = 0;
1196: if (flags & COMPRESS) {
1197: for (spc = 1, cp = ret; *onelp; onelp++)
1198: if (isspace (*onelp)) {
1199: if (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT))) {
1200: term = '\n';
1201: *onelp++ = NULL;
1202: break;
1203: }
1204: else
1205: if (!spc) {
1206: *cp++ = ' ';
1207: spc++;
1208: }
1209: }
1210: else {
1211: *cp++ = *onelp;
1212: spc = 0;
1213: }
1214:
1215: *cp = NULL;
1216: }
1217: else {
1218: while (*onelp && *onelp != '\n')
1219: onelp++;
1220: if (*onelp == '\n') {
1221: term = '\n';
1222: *onelp++ = NULL;
1223: }
1224: if (flags & LEFTADJUST)
1225: while (*ret == ' ' || *ret == '\t')
1226: ret++;
1227: }
1228:
1229: return ret;
1230: }
1231:
1232: /* */
1233:
1234: static void
1235: putstr(string)
1236: register char *string;
1237: {
1238: if (!column && lm > 0)
1239: while (lm > 0)
1240: if (lm >= 8) {
1241: putch ('\t');
1242: lm -= 8;
1243: }
1244: else {
1245: putch (' ');
1246: lm--;
1247: }
1248: lm = 0;
1249: while (*string)
1250: putch (*string++);
1251: }
1252:
1253: /* */
1254:
1255: static void
1256: putch(ch)
1257: register char ch;
1258: {
1259: char buf[BUFSIZ];
1260:
1261: if (llim == 0)
1262: return;
1263:
1264: switch (ch) {
1265: case '\n':
1266: if (llim > 0)
1267: llim--;
1268: column = 0;
1269: row++;
1270: if (ontty != ISTTY || row != global.c_length)
1271: break;
1272: if (global.c_flags & BELL)
1273: (void) putchar ('\007');
1274: (void) fflush (stdout);
1275: buf[0] = NULL;
1276: (void) read (fileno (stdout), buf, sizeof buf);
1277: if (index (buf, '\n')) {
1278: if (global.c_flags & CLEARSCR)
1279: clear_screen ();
1280: row = 0;
1281: }
1282: else {
1283: (void) putchar ('\n');
1284: row = global.c_length / 3;
1285: }
1286: return;
1287:
1288: case '\t':
1289: column |= 07;
1290: column++;
1291: break;
1292:
1293: case '\b':
1294: column--;
1295: break;
1296:
1297: case '\r':
1298: column = 0;
1299: break;
1300:
1301: default:
1302: if (column == 0 && forwflg && dashflg && ch == '-')
1303: (void) putchar ('-'), putchar (' ');
1304: if (ch >= ' ')
1305: column++;
1306: break;
1307: }
1308:
1309: if (column >= wid) {
1310: putch ('\n');
1311: if (ovoff > 0)
1312: lm = ovoff;
1313: putstr (ovtxt ? ovtxt : "");
1314: putch (ch);
1315: return;
1316: }
1317:
1318: (void) putchar (ch);
1319: }
1320:
1321: /* */
1322:
1323: /* ARGSUSED */
1324:
1325: static SIGDECL
1326: intrser(i)
1327: int i;
1328: {
1329: #ifndef BSD42
1330: (void) signal (SIGINT, intrser);
1331: #endif BSD42
1332:
1333: discard (stdout);
1334: (void) putchar ('\n');
1335:
1336: longjmp (env, DONE);
1337: }
1338:
1339:
1340: /* ARGSUSED */
1341:
1342: static SIGDECL
1343: pipeser(i)
1344: int i;
1345: {
1346: #ifndef BSD42
1347: (void) signal (SIGPIPE, pipeser);
1348: #endif BSD42
1349:
1350: mhldone (NOTOK);
1351: }
1352:
1353:
1354: /* ARGSUSED */
1355:
1356: static SIGDECL
1357: quitser(i)
1358: int i;
1359: {
1360: #ifndef BSD42
1361: (void) signal (SIGQUIT, quitser);
1362: #endif BSD42
1363:
1364: (void) putchar ('\n');
1365: (void) fflush (stdout);
1366:
1367: mhldone (NOTOK);
1368: }
1369:
1370: /* */
1371:
1372: #undef adios
1373:
1374: mhlsbr(argc, argv, action)
1375: int argc;
1376: register char **argv;
1377: register FP (*action)();
1378: {
1379: SIGDECL (*istat)(), (*pstat)(), (*qstat)();
1380: register char *cp;
1381: register struct mcomp *c1;
1382:
1383: switch (setjmp (mhlenv)) {
1384: case OK:
1385: cp = invo_name;
1386: bellflg = clearflg = forwflg = forwall = exitstat = 0;
1387: digest = NULL;
1388: ontty = NOTTY;
1389: mhl_action = action;
1390: if ((istat = signal (SIGINT, SIG_IGN)) != SIG_DFL)
1391: (void) signal (SIGINT, istat);
1392: if ((qstat = signal (SIGQUIT, SIG_IGN)) != SIG_DFL)
1393: (void) signal (SIGQUIT, qstat);
1394: pstat = signal (SIGPIPE, pipeser);
1395: (void) mhl (argc, argv); /* fall */
1396:
1397: default:
1398: (void) signal (SIGINT, istat);
1399: (void) signal (SIGQUIT, qstat);
1400: (void) signal (SIGPIPE, SIG_IGN);/* XXX */
1401: if (ontty == PITTY)
1402: m_pclose ();
1403: (void) signal (SIGPIPE, pstat);
1404: invo_name = cp;
1405: if (holder.c_text) {
1406: free (holder.c_text);
1407: holder.c_text = NULL;
1408: }
1409: free_queue (&msghd, &msgtl);
1410: for (c1 = fmthd; c1; c1 = c1 -> c_next)
1411: c1 -> c_flags &= ~HDROUTPUT;
1412: return exitstat;
1413: }
1414: }
1415:
1416: /* */
1417:
1418: /* VARARGS2 */
1419:
1420: static void
1421: mhladios(what, fmt, a, b, c, d, e, f)
1422: char *what, *fmt, *a, *b, *c, *d, *e, *f;
1423: {
1424: advise (what, fmt, a, b, c, d, e, f);
1425: mhldone (1);
1426: }
1427:
1428:
1429: void
1430: mhldone(status)
1431: int status;
1432: {
1433: exitstat = status;
1434: if (mhl_action)
1435: longjmp (mhlenv, DONE);
1436: else
1437: done(exitstat); /* call real done() */
1438: }
1439:
1440: /* */
1441:
1442: static int m_pid = NOTOK;
1443: static int sd = NOTOK;
1444:
1445:
1446: static void
1447: m_popen(name)
1448: char *name;
1449: {
1450: int pd[2];
1451:
1452: if (mhl_action && (sd = dup (fileno (stdout))) == NOTOK)
1453: adios ("standard output", "unable to dup()");
1454:
1455: if (pipe (pd) == NOTOK)
1456: adios ("pipe", "unable to");
1457:
1458: switch (m_pid = vfork ()) {
1459: case NOTOK:
1460: adios ("fork", "unable to");
1461:
1462: case OK:
1463: (void) signal (SIGINT, SIG_DFL);
1464: (void) signal (SIGQUIT, SIG_DFL);
1465:
1466: (void) close (pd[1]);
1467: if (pd[0] != fileno (stdin)) {
1468: (void) dup2 (pd[0], fileno (stdin));
1469: (void) close (pd[0]);
1470: }
1471: execlp (name, r1bindex (name, '/'), NULLCP);
1472: fprintf (stderr, "unable to exec ");
1473: perror (name);
1474: _exit (-1);
1475:
1476: default:
1477: (void) close (pd[0]);
1478: if (pd[1] != fileno (stdout)) {
1479: (void) dup2 (pd[1], fileno (stdout));
1480: (void) close (pd[1]);
1481: }
1482: }
1483: }
1484:
1485:
1486: m_pclose()
1487: {
1488: if (m_pid == NOTOK)
1489: return;
1490:
1491: if (sd != NOTOK) {
1492: (void) fflush (stdout);
1493: if (dup2 (sd, fileno (stdout)) == NOTOK)
1494: adios ("standard output", "unable to dup2()");
1495:
1496: clearerr (stdout);
1497: (void) close (sd);
1498: sd = NOTOK;
1499: }
1500: else
1501: (void) fclose (stdout);
1502:
1503: (void) pidwait (m_pid, OK);
1504: m_pid = NOTOK;
1505: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.