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