git.marmaro.de Git - mmh/blob - uip/mhlsbr.c

   1 /*
   2 ** mhlsbr.c -- main routines for nmh message lister
   3 **
   4 ** This code is Copyright (c) 2002, by the authors of nmh.  See the
   5 ** COPYRIGHT file in the root directory of the nmh distribution for
   6 ** complete copyright information.
   7 */
   8
   9 #include <h/mh.h>
  10 #include <h/signals.h>
  11 #include <h/addrsbr.h>
  12 #include <h/fmt_scan.h>
  13 #include <h/tws.h>
  14 #include <h/utils.h>
  15 #include <setjmp.h>
  16 #include <signal.h>
  17
  18 /*
  19 ** MAJOR BUG:
  20 ** for a component containing addresses, ADDRFMT, if COMPRESS is also
  21 ** set, then addresses get split wrong (not at the spaces between commas).
  22 ** To fix this correctly, putstr() should know about "atomic" strings that
  23 ** must NOT be broken across lines.  That's too difficult for right now
  24 ** (it turns out that there are a number of degernate cases), so in
  25 ** oneline(), instead of
  26 **
  27 **       (*onelp == '\n' && !onelp[1])
  28 **
  29 ** being a terminating condition,
  30 **
  31 **       (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT)))
  32 **
  33 ** is used instead.  This cuts the line prematurely, and gives us a much
  34 ** better chance of getting things right.
  35 */
  36
  37 #define ONECOMP  0
  38 #define TWOCOMP  1
  39 #define BODYCOMP 2
  40
  41 #define QUOTE  '\\'
  42
  43 static struct swit mhlswitches[] = {
  44 #define BELLSW  0
  45         { "bell", 0 },
  46 #define NBELLSW  1
  47         { "nobell", 0 },
  48 #define CLRSW  2
  49         { "clear", 0 },
  50 #define NCLRSW  3
  51         { "noclear", 0 },
  52 #define FACESW  4
  53         { "faceproc program", 0 },
  54 #define NFACESW  5
  55         { "nofaceproc", 0 },
  56 #define FOLDSW  6
  57         { "folder +folder", 0 },
  58 #define FORMSW  7
  59         { "form formfile", 0 },
  60 #define PROGSW  8
  61         { "moreproc program", 0 },
  62 #define NPROGSW  9
  63         { "nomoreproc", 0 },
  64 #define LENSW  10
  65         { "length lines", 0 },
  66 #define WIDTHSW  11
  67         { "width columns", 0 },
  68 #define SLEEPSW  12
  69         { "sleep seconds",  0 },
  70 #define BITSTUFFSW  13
  71         { "dashstuffing", -12 },  /* interface from forw */
  72 #define NBITSTUFFSW   14
  73         { "nodashstuffing", -14 },  /* interface from forw */
  74 #define VERSIONSW  15
  75         { "version", 0 },
  76 #define HELPSW  16
  77         { "help", 0 },
  78 #define FORW1SW  17
  79         { "forward", -7 },  /* interface from forw */
  80 #define FORW2SW  18
  81         { "forwall", -7 },  /* interface from forw */
  82 #define DGSTSW  19
  83         { "digest list", -6 },
  84 #define VOLUMSW  20
  85         { "volume number", -6 },
  86 #define ISSUESW  21
  87         { "issue number", -5 },
  88 #define NBODYSW  22
  89         { "nobody", -6 },
  90         { NULL, 0 }
  91 };
  92
  93 #define NOCOMPONENT 0x000001  /* don't show component name   */
  94 #define UPPERCASE   0x000002  /* display in all upper case   */
  95 #define CENTER      0x000004  /* center line                 */
  96 #define CLEARTEXT   0x000008  /* cleartext                   */
  97 #define EXTRA       0x000010  /* an "extra" component        */
  98 #define HDROUTPUT   0x000020  /* already output              */
  99 #define CLEARSCR    0x000040  /* clear screen                */
 100 #define LEFTADJUST  0x000080  /* left justify multiple lines */
 101 #define COMPRESS    0x000100  /* compress text               */
 102 #define ADDRFMT     0x000200  /* contains addresses          */
 103 #define BELL        0x000400  /* sound bell at EOP           */
 104 #define DATEFMT     0x000800  /* contains dates              */
 105 #define FORMAT      0x001000  /* parse address/date/RFC-2047 field */
 106 #define INIT        0x002000  /* initialize component        */
 107 #define FACEFMT     0x004000  /* contains face               */
 108 #define FACEDFLT    0x008000  /* default for face            */
 109 #define SPLIT       0x010000  /* split headers (don't concatenate) */
 110 #define NONEWLINE   0x020000  /* don't write trailing newline */
 111 #define LBITS       "\020\01NOCOMPONENT\02UPPERCASE\03CENTER\04CLEARTEXT\05EXTRA\06HDROUTPUT\07CLEARSCR\010LEFTADJUST\011COMPRESS\012ADDRFMT\013BELL\014DATEFMT\015FORMAT\016INIT\017FACEFMT\020FACEDFLT\021SPLIT\022NONEWLINE"
 112 #define GFLAGS      (NOCOMPONENT | UPPERCASE | CENTER | LEFTADJUST | COMPRESS | SPLIT)
 113
 114 struct mcomp {
 115         char *c_name;  /* component name */
 116         char *c_text;  /* component text */
 117         char *c_ovtxt; /* text overflow indicator */
 118         char *c_nfs;   /* iff FORMAT */
 119         struct format *c_fmt;  /*  .. */
 120         char *c_face;  /* face designator */
 121         int c_offset;  /* left margin indentation */
 122         int c_ovoff;   /* overflow indentation */
 123         int c_width;   /* width of field */
 124         int c_cwidth;  /* width of component */
 125         int c_length;  /* length in lines */
 126         long c_flags;
 127         struct mcomp *c_next;
 128 };
 129
 130 static struct mcomp *msghd = NULL;
 131 static struct mcomp *msgtl = NULL;
 132 static struct mcomp *fmthd = NULL;
 133 static struct mcomp *fmttl = NULL;
 134
 135 static struct mcomp global = {
 136         NULL, NULL, "", NULL, NULL, 0, -1, 80, -1, 40, BELL, 0
 137 };
 138
 139 static struct mcomp holder = {
 140         NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NOCOMPONENT, 0
 141 };
 142
 143 struct pair {
 144         char *p_name;
 145         long p_flags;
 146 };
 147
 148 static struct pair pairs[] = {
 149         { "Date", DATEFMT },
 150         { "From", ADDRFMT|FACEDFLT },
 151         { "Sender", ADDRFMT },
 152         { "Reply-To", ADDRFMT },
 153         { "To", ADDRFMT },
 154         { "cc", ADDRFMT },
 155         { "Bcc", ADDRFMT },
 156         { "Resent-Date", DATEFMT },
 157         { "Resent-From", ADDRFMT },
 158         { "Resent-Sender", ADDRFMT },
 159         { "Resent-Reply-To", ADDRFMT },
 160         { "Resent-To", ADDRFMT },
 161         { "Resent-cc", ADDRFMT },
 162         { "Resent-Bcc", ADDRFMT },
 163         { "Face", FACEFMT },
 164         { NULL, 0 }
 165 };
 166
 167 struct triple {
 168         char *t_name;
 169         long t_on;
 170         long t_off;
 171 };
 172
 173 static struct triple triples[] = {
 174         { "nocomponent",  NOCOMPONENT, 0 },
 175         { "uppercase", UPPERCASE, 0 },
 176         { "nouppercase", 0, UPPERCASE },
 177         { "center", CENTER, 0 },
 178         { "nocenter", 0, CENTER },
 179         { "clearscreen", CLEARSCR, 0 },
 180         { "noclearscreen", 0, CLEARSCR },
 181         { "noclear", 0, CLEARSCR },
 182         { "leftadjust", LEFTADJUST, 0 },
 183         { "noleftadjust", 0, LEFTADJUST },
 184         { "compress", COMPRESS, 0 },
 185         { "nocompress", 0, COMPRESS },
 186         { "split", SPLIT, 0 },
 187         { "nosplit", 0, SPLIT },
 188         { "addrfield", ADDRFMT, DATEFMT },
 189         { "bell", BELL, 0 },
 190         { "nobell", 0, BELL },
 191         { "datefield", DATEFMT, ADDRFMT },
 192         { "newline", 0, NONEWLINE },
 193         { "nonewline", NONEWLINE, 0 },
 194         { NULL, 0, 0 }
 195 };
 196
 197
 198 static int bellflg   = 0;
 199 static int clearflg  = 0;
 200 static int dashstuff = 0;
 201 static int dobody    = 1;
 202 static int forwflg   = 0;
 203 static int forwall   = 0;
 204
 205 static int sleepsw = NOTOK;
 206
 207 static char *digest = NULL;
 208 static int volume = 0;
 209 static int issue = 0;
 210
 211 static int exitstat = 0;
 212 static int mhldebug = 0;
 213
 214 #define PITTY  (-1)
 215 #define NOTTY  0
 216 #define ISTTY  1
 217 static int ontty = NOTTY;
 218
 219 static int row;
 220 static int column;
 221
 222 static int lm;
 223 static int llim;
 224 static int ovoff;
 225 static int term;
 226 static int wid;
 227
 228 static char *ovtxt;
 229
 230 static unsigned char *onelp;
 231
 232 static char *parptr;
 233
 234 static int num_ignores = 0;
 235 static char *ignores[MAXARGS];
 236
 237 static  jmp_buf env;
 238 static  jmp_buf mhlenv;
 239
 240 static char delim3[] = /* from forw.c */
 241         "\n----------------------------------------------------------------------\n\n";
 242 static char delim4[] = "\n------------------------------\n\n";
 243
 244 static FILE *(*mhl_action) () = (FILE *(*) ()) 0;
 245
 246
 247 /*
 248 ** Redefine a couple of functions.
 249 ** These are undefined later in the code.
 250 */
 251 #define adios mhladios
 252 #define done  mhldone
 253
 254 /*
 255 ** prototypes
 256 */
 257 static void mhl_format(char *, int, int);
 258 static int evalvar(struct mcomp *);
 259 static int ptoi(char *, int *);
 260 static int ptos(char *, char **);
 261 static char *parse(void);
 262 static void process(char *, char *, int, int);
 263 static void mhlfile(FILE *, char *, int, int);
 264 static int mcomp_flags(char *);
 265 static char *mcomp_add(long, char *, char *);
 266 static void mcomp_format(struct mcomp *, struct mcomp *);
 267 static struct mcomp *add_queue(struct mcomp **, struct mcomp **,
 268                 char *, char *, int);
 269 static void free_queue(struct mcomp **, struct mcomp **);
 270 static void putcomp(struct mcomp *, struct mcomp *, int);
 271 static char *oneline(char *, long);
 272 static void putstr(char *);
 273 static void putch(char);
 274 static RETSIGTYPE intrser(int);
 275 static RETSIGTYPE pipeser(int);
 276 static RETSIGTYPE quitser(int);
 277 static void face_format(struct mcomp *);
 278 static int doface(struct mcomp *);
 279 static void mhladios(char *, char *, ...);
 280 static void mhldone(int);
 281 static void m_popen(char *);
 282
 283 int mhl(int, char **);
 284 int mhlsbr(int, char **, FILE *(*)());
 285 void m_pclose(void);
 286
 287 void clear_screen(void);  /* from termsbr.c */
 288 int SOprintf(char *, ...);  /* from termsbr.c */
 289 int sc_width(void);  /* from termsbr.c */
 290 int sc_length(void);  /* from termsbr.c */
 291 int sc_hardcopy(void);  /* from termsbr.c */
 292
 293
 294 int
 295 mhl(int argc, char **argv)
 296 {
 297         int length = 0, nomore = 0;
 298         int i, width = 0, vecp = 0;
 299         char *cp, *folder = NULL, *form = NULL;
 300         char buf[BUFSIZ], *files[MAXARGS];
 301         char **argp, **arguments;
 302
 303         invo_name = r1bindex(argv[0], '/');
 304
 305         /* read user profile/context */
 306         context_read();
 307
 308         arguments = getarguments(invo_name, argc, argv, 1);
 309         argp = arguments;
 310
 311         if ((cp = getenv("MHLDEBUG")) && *cp)
 312                 mhldebug++;
 313
 314         if ((cp = getenv("FACEPROC")))
 315                 faceproc = cp;
 316
 317         while ((cp = *argp++)) {
 318                 if (*cp == '-') {
 319                         switch (smatch(++cp, mhlswitches)) {
 320                                 case AMBIGSW:
 321                                         ambigsw(cp, mhlswitches);
 322                                         done(1);
 323                                 case UNKWNSW:
 324                                         adios(NULL, "-%s unknown\n", cp);
 325
 326                                 case HELPSW:
 327                                         snprintf(buf, sizeof(buf), "%s [switches] [files ...]", invo_name);
 328                                         print_help(buf, mhlswitches, 1);
 329                                         done(1);
 330                                 case VERSIONSW:
 331                                         print_version(invo_name);
 332                                         done(1);
 333
 334                                 case BELLSW:
 335                                         bellflg = 1;
 336                                         continue;
 337                                 case NBELLSW:
 338                                         bellflg = -1;
 339                                         continue;
 340
 341                                 case CLRSW:
 342                                         clearflg = 1;
 343                                         continue;
 344                                 case NCLRSW:
 345                                         clearflg = -1;
 346                                         continue;
 347
 348                                 case FOLDSW:
 349                                         if (!(folder = *argp++) ||
 350                                                         *folder == '-')
 351                                                 adios(NULL, "missing argument to %s", argp[-2]);
 352                                         continue;
 353                                 case FORMSW:
 354                                         if (!(form = *argp++) || *form == '-')
 355                                                 adios(NULL, "missing argument to %s", argp[-2]);
 356                                         continue;
 357
 358                                 case FACESW:
 359                                         if (!(faceproc = *argp++) || *faceproc == '-')
 360                                                 adios(NULL, "missing argument to %s", argp[-2]);
 361                                         continue;
 362                                 case NFACESW:
 363                                         faceproc = NULL;
 364                                         continue;
 365                                 case SLEEPSW:
 366                                         if (!(cp = *argp++) || *cp == '-')
 367                                                 adios(NULL, "missing argument to %s", argp[-2]);
 368                                         sleepsw = atoi(cp);  /* ZERO ok! */
 369                                         continue;
 370
 371                                 case PROGSW:
 372                                         if (!(moreproc = *argp++) || *moreproc == '-')
 373                                                 adios(NULL, "missing argument to %s", argp[-2]);
 374                                         continue;
 375                                 case NPROGSW:
 376                                         nomore++;
 377                                         continue;
 378
 379                                 case LENSW:
 380                                         if (!(cp = *argp++) || *cp == '-')
 381                                                 adios(NULL, "missing argument to %s", argp[-2]);
 382                                         if ((length = atoi(cp)) < 1)
 383                                                 adios(NULL, "bad argument %s %s", argp[-2], cp);
 384                                         continue;
 385                                 case WIDTHSW:
 386                                         if (!(cp = *argp++) || *cp == '-')
 387                                                 adios(NULL, "missing argument to %s", argp[-2]);
 388                                         if ((width = atoi(cp)) < 1)
 389                                                 adios(NULL, "bad argument %s %s", argp[-2], cp);
 390                                         continue;
 391
 392                                 case DGSTSW:
 393                                         if (!(digest = *argp++) ||
 394                                                         *digest == '-')
 395                                                 adios(NULL, "missing argument to %s", argp[-2]);
 396                                         continue;
 397                                 case ISSUESW:
 398                                         if (!(cp = *argp++) || *cp == '-')
 399                                                 adios(NULL, "missing argument to %s", argp[-2]);
 400                                         if ((issue = atoi(cp)) < 1)
 401                                                 adios(NULL, "bad argument %s %s", argp[-2], cp);
 402                                         continue;
 403                                 case VOLUMSW:
 404                                         if (!(cp = *argp++) || *cp == '-')
 405                                                 adios(NULL, "missing argument to %s", argp[-2]);
 406                                         if ((volume = atoi(cp)) < 1)
 407                                                 adios(NULL, "bad argument %s %s", argp[-2], cp);
 408                                         continue;
 409
 410                                 case FORW2SW:
 411                                         forwall++;  /* fall */
 412                                 case FORW1SW:
 413                                         forwflg++;
 414                                         clearflg = -1;/* XXX */
 415                                         continue;
 416
 417                                 case BITSTUFFSW:
 418                                         dashstuff = 1;  /* trinary logic */
 419                                         continue;
 420                                 case NBITSTUFFSW:
 421                                         dashstuff = -1;  /* trinary logic */
 422                                         continue;
 423
 424                                 case NBODYSW:
 425                                         dobody = 0;
 426                                         continue;
 427                         }
 428                 }
 429                 files[vecp++] = cp;
 430         }
 431
 432         if (!folder)
 433                 folder = getenv("mhfolder");
 434
 435         if (isatty(fileno(stdout))) {
 436                 if (!nomore && !sc_hardcopy() && moreproc && *moreproc != '\0') {
 437                         if (mhl_action) {
 438                                 SIGNAL(SIGINT, SIG_IGN);
 439                                 SIGNAL2(SIGQUIT, quitser);
 440                         }
 441                         SIGNAL2(SIGPIPE, pipeser);
 442                         m_popen(moreproc);
 443                         ontty = PITTY;
 444                 } else {
 445                         SIGNAL(SIGINT, SIG_IGN);
 446                         SIGNAL2(SIGQUIT, quitser);
 447                         ontty = ISTTY;
 448                 }
 449         } else {
 450                 ontty = NOTTY;
 451         }
 452
 453         mhl_format(form ? form : mhlformat, length, width);
 454
 455         if (vecp == 0) {
 456                 process(folder, NULL, 1, vecp = 1);
 457         } else {
 458                 for (i = 0; i < vecp; i++)
 459                         process(folder, files[i], i + 1, vecp);
 460         }
 461
 462         if (forwall) {
 463                 if (digest) {
 464                         printf("%s", delim4);
 465                         if (volume == 0) {
 466                                 snprintf(buf, sizeof(buf),
 467                                         "End of %s Digest\n", digest);
 468                         } else {
 469                                 snprintf(buf, sizeof(buf), "End of %s Digest [Volume %d Issue %d]\n", digest, volume, issue);
 470                         }
 471                         i = strlen(buf);
 472                         for (cp = buf + i; i > 1; i--)
 473                                 *cp++ = '*';
 474                         *cp++ = '\n';
 475                         *cp = 0;
 476                         printf("%s", buf);
 477                 } else
 478                         printf("\n------- End of Forwarded Message%s\n\n",
 479                                 vecp > 1 ? "s" : "");
 480         }
 481
 482         fflush(stdout);
 483         if (ferror(stdout)) {
 484                 adios("output", "error writing");
 485         }
 486
 487         if (clearflg > 0 && ontty == NOTTY)
 488                 clear_screen();
 489
 490         if (ontty == PITTY)
 491                 m_pclose();
 492
 493         return exitstat;
 494 }
 495
 496
 497 static void
 498 mhl_format(char *file, int length, int width)
 499 {
 500         int i;
 501         char *bp, *cp, **ip;
 502         char *ap, buffer[BUFSIZ], name[NAMESZ];
 503         struct mcomp *c1;
 504         struct stat st;
 505         FILE *fp;
 506         static dev_t dev = 0;
 507         static ino_t ino = 0;
 508         static time_t mtime = 0;
 509
 510         if (fmthd != NULL) {
 511                 if (stat(etcpath(file), &st) != NOTOK
 512                         && mtime == st.st_mtime
 513                         && dev == st.st_dev
 514                         && ino == st.st_ino)
 515                         goto out;
 516                 else
 517                         free_queue(&fmthd, &fmttl);
 518         }
 519
 520         if ((fp = fopen(etcpath(file), "r")) == NULL)
 521                 adios(file, "unable to open format file");
 522
 523         if (fstat(fileno(fp), &st) != NOTOK) {
 524                 mtime = st.st_mtime;
 525                 dev = st.st_dev;
 526                 ino = st.st_ino;
 527         }
 528
 529         global.c_ovtxt = global.c_nfs = NULL;
 530         global.c_fmt = NULL;
 531         global.c_offset = 0;
 532         global.c_ovoff = -1;
 533         if ((i = sc_width()) > 5)
 534                 global.c_width = i;
 535         global.c_cwidth = -1;
 536         if ((i = sc_length()) > 5)
 537                 global.c_length = i - 1;
 538         global.c_flags = BELL;  /* BELL is default */
 539         *(ip = ignores) = NULL;
 540
 541         while (vfgets(fp, &ap) == OK) {
 542                 bp = ap;
 543                 if (*bp == ';')
 544                         continue;
 545
 546                 if ((cp = strchr(bp, '\n')))
 547                         *cp = 0;
 548
 549                 if (*bp == ':') {
 550                         c1 = add_queue(&fmthd, &fmttl, NULL, bp + 1,
 551                                         CLEARTEXT);
 552                         continue;
 553                 }
 554
 555                 parptr = bp;
 556                 strncpy(name, parse(), sizeof(name));
 557                 switch(*parptr) {
 558                         case '\0':
 559                         case ',':
 560                         case '=':
 561                                 /*
 562                                 ** Split this list of fields to ignore,
 563                                 ** and copy it to the end of the current
 564                                 ** "ignores" list.
 565                                 */
 566                                 if (!mh_strcasecmp(name, "ignores")) {
 567                                         char **tmparray, **p;
 568                                         int n = 0;
 569
 570                                         /* split the fields */
 571                                         tmparray = brkstring(getcpy(++parptr),
 572                                                         ",", NULL);
 573
 574                                         /* count number of fields split */
 575                                         p = tmparray;
 576                                         while (*p++)
 577                                                 n++;
 578
 579                                         /*
 580                                         ** copy pointers to split fields
 581                                         ** to ignores array
 582                                         */
 583                                         ip = copyip(tmparray, ip,
 584                                                         MAXARGS - num_ignores);
 585                                         num_ignores += n;
 586                                         continue;
 587                                 }
 588                                 parptr = bp;
 589                                 while (*parptr) {
 590                                         if (evalvar(&global))
 591                                                 adios(NULL, "format file syntax error: %s", bp);
 592                                         if (*parptr)
 593                                                 parptr++;
 594                                 }
 595                                 continue;
 596
 597                         case ':':
 598                                 c1 = add_queue(&fmthd, &fmttl, name, NULL,
 599                                                 INIT);
 600                                 while (*parptr == ':' || *parptr == ',') {
 601                                         parptr++;
 602                                         if (evalvar(c1))
 603                                                 adios(NULL, "format file syntax error: %s", bp);
 604                                 }
 605                                 if (!c1->c_nfs && global.c_nfs) {
 606                                         if (c1->c_flags & DATEFMT) {
 607                                                 if (global.c_flags & DATEFMT)
 608                                                         c1->c_nfs = getcpy(global.c_nfs);
 609                                         }
 610                                         else
 611                                                 if (c1->c_flags & ADDRFMT) {
 612                                                         if (global.c_flags & ADDRFMT)
 613                                                                 c1->c_nfs = getcpy(global.c_nfs);
 614                                                 }
 615                                 }
 616                                 continue;
 617
 618                         default:
 619                                 adios(NULL, "format file syntax error: %s",
 620                                                 bp);
 621                 }
 622         }
 623         fclose(fp);
 624
 625         if (mhldebug) {
 626                 for (c1 = fmthd; c1; c1 = c1->c_next) {
 627                         fprintf(stderr, "c1: name=\"%s\" text=\"%s\" ovtxt=\"%s\"\n", c1->c_name, c1->c_text, c1->c_ovtxt);
 628                         fprintf(stderr, "\tnfs=0x%x fmt=0x%x\n", (unsigned int)(unsigned long) c1->c_nfs, (unsigned int)(unsigned long) c1->c_fmt);
 629                         fprintf(stderr, "\toffset=%d ovoff=%d width=%d cwidth=%d length=%d\n", c1->c_offset, c1->c_ovoff, c1->c_width, c1->c_cwidth, c1->c_length);
 630                         fprintf (stderr, "\tflags=%s\n", snprintb(buffer, sizeof(buffer), (unsigned) c1->c_flags, LBITS));
 631                 }
 632         }
 633
 634 out:
 635         if (clearflg == 1) {
 636                 global.c_flags |= CLEARSCR;
 637         } else {
 638                 if (clearflg == -1)
 639                         global.c_flags &= ~CLEARSCR;
 640         }
 641
 642         switch (bellflg) {  /* command line may override format file */
 643                 case 1:
 644                         global.c_flags |= BELL;
 645                         break;
 646                 case -1:
 647                         global.c_flags &= ~BELL;
 648                         break;
 649         }
 650
 651         if (length)
 652                 global.c_length = length;
 653         if (width)
 654                 global.c_width = width;
 655         if (global.c_length < 5)
 656                 global.c_length = 10000;
 657         if (global.c_width < 5)
 658                 global.c_width = 10000;
 659 }
 660
 661
 662 static int
 663 evalvar(struct mcomp *c1)
 664 {
 665         char *cp, name[NAMESZ];
 666         struct triple *ap;
 667
 668         if (!*parptr)
 669                 return 0;
 670         strncpy(name, parse(), sizeof(name));
 671
 672         if (!mh_strcasecmp(name, "component")) {
 673                 if (ptos(name, &c1->c_text))
 674                         return 1;
 675                 c1->c_flags &= ~NOCOMPONENT;
 676                 return 0;
 677         }
 678
 679         if (!mh_strcasecmp(name, "overflowtext"))
 680                 return ptos(name, &c1->c_ovtxt);
 681
 682         if (!mh_strcasecmp(name, "formatfield")) {
 683                 char *nfs;
 684
 685                 if (ptos(name, &cp))
 686                         return 1;
 687                 nfs = new_fs(NULL, NULL, cp);
 688                 c1->c_nfs = getcpy(nfs);
 689                 c1->c_flags |= FORMAT;
 690                 return 0;
 691         }
 692
 693         if (!mh_strcasecmp(name, "decode")) {
 694                 char *nfs;
 695
 696                 nfs = new_fs(NULL, NULL, "%(decode{text})");
 697                 c1->c_nfs = getcpy(nfs);
 698                 c1->c_flags |= FORMAT;
 699                 return 0;
 700         }
 701
 702         if (!mh_strcasecmp(name, "offset"))
 703                 return ptoi(name, &c1->c_offset);
 704         if (!mh_strcasecmp(name, "overflowoffset"))
 705                 return ptoi(name, &c1->c_ovoff);
 706         if (!mh_strcasecmp(name, "width"))
 707                 return ptoi(name, &c1->c_width);
 708         if (!mh_strcasecmp(name, "compwidth"))
 709                 return ptoi(name, &c1->c_cwidth);
 710         if (!mh_strcasecmp(name, "length"))
 711                 return ptoi(name, &c1->c_length);
 712         if (!mh_strcasecmp(name, "nodashstuffing"))
 713                 return (dashstuff = -1);
 714
 715         for (ap = triples; ap->t_name; ap++)
 716                 if (!mh_strcasecmp(ap->t_name, name)) {
 717                         c1->c_flags |= ap->t_on;
 718                         c1->c_flags &= ~ap->t_off;
 719                         return 0;
 720                 }
 721
 722         return 1;
 723 }
 724
 725
 726 static int
 727 ptoi(char *name, int *i)
 728 {
 729         char *cp;
 730
 731         if (*parptr++ != '=' || !*(cp = parse())) {
 732                 advise(NULL, "missing argument to variable %s", name);
 733                 return 1;
 734         }
 735
 736         *i = atoi(cp);
 737         return 0;
 738 }
 739
 740
 741 static int
 742 ptos(char *name, char **s)
 743 {
 744         char c, *cp;
 745
 746         if (*parptr++ != '=') {
 747                 advise(NULL, "missing argument to variable %s", name);
 748                 return 1;
 749         }
 750
 751         if (*parptr != '"') {
 752                 for (cp = parptr; *parptr && *parptr != ':' && *parptr != ',';
 753                                 parptr++)
 754                         continue;
 755         } else {
 756                 for (cp = ++parptr; *parptr && *parptr != '"'; parptr++)
 757                         if (*parptr == QUOTE)
 758                                 if (!*++parptr)
 759                                         parptr--;
 760         }
 761         c = *parptr;
 762         *parptr = 0;
 763         *s = getcpy(cp);
 764         if ((*parptr = c) == '"')
 765                 parptr++;
 766         return 0;
 767 }
 768
 769
 770 static char *
 771 parse(void)
 772 {
 773         int c;
 774         char *cp;
 775         static char result[NAMESZ];
 776
 777         for (cp = result; *parptr && (cp - result < NAMESZ); parptr++) {
 778                 c = *parptr;
 779                 if (isalnum(c)
 780                                 || c == '.'
 781                                 || c == '-'
 782                                 || c == '_'
 783                                 || c == '['
 784                                 || c == ']')
 785                         *cp++ = c;
 786                 else
 787                         break;
 788         }
 789         *cp = '\0';
 790
 791         return result;
 792 }
 793
 794
 795 static void
 796 process(char *folder, char *fname, int ofilen, int ofilec)
 797 {
 798         char *cp = NULL;
 799         FILE *fp = NULL;
 800         struct mcomp *c1;
 801
 802         switch (setjmp(env)) {
 803                 case OK:
 804                         if (fname) {
 805                                 fp = mhl_action ? (*mhl_action) (fname) :
 806                                                 fopen(fname, "r");
 807                                 if (fp == NULL) {
 808                                         advise(fname, "unable to open");
 809                                         exitstat++;
 810                                         return;
 811                                 }
 812                         } else {
 813                                 fname = "(stdin)";
 814                                 fp = stdin;
 815                         }
 816                         cp = folder ? concat(folder, ":", fname, NULL) :
 817                                         getcpy(fname);
 818                         if (ontty != PITTY)
 819                                 SIGNAL(SIGINT, intrser);
 820                         mhlfile(fp, cp, ofilen, ofilec);  /* FALL THROUGH! */
 821
 822                 default:
 823                         if (ontty != PITTY)
 824                                 SIGNAL(SIGINT, SIG_IGN);
 825                         if (mhl_action == NULL && fp != stdin)
 826                                 fclose(fp);
 827                         free(cp);
 828                         if (holder.c_text) {
 829                                 free(holder.c_text);
 830                                 holder.c_text = NULL;
 831                         }
 832                         free_queue(&msghd, &msgtl);
 833                         for (c1 = fmthd; c1; c1 = c1->c_next)
 834                                 c1->c_flags &= ~HDROUTPUT;
 835                         break;
 836         }
 837 }
 838
 839
 840 static void
 841 mhlfile(FILE *fp, char *mname, int ofilen, int ofilec)
 842 {
 843         int state;
 844         struct mcomp *c1, *c2, *c3;
 845         char **ip, name[NAMESZ], buf[BUFSIZ];
 846
 847         if (forwall) {
 848                 if (digest)
 849                         printf("%s", ofilen == 1 ? delim3 : delim4);
 850                 else {
 851                         printf("\n-------");
 852                         if (ofilen == 1)
 853                                 printf(" Forwarded Message%s",
 854                                                 ofilec > 1 ? "s" : "");
 855                         else
 856                                 printf(" Message %d", ofilen);
 857                         printf("\n\n");
 858                 }
 859         } else {
 860                 switch (ontty) {
 861                         case PITTY:
 862                                 if (ofilec > 1) {
 863                                         if (ofilen > 1) {
 864                                                 if ((global.c_flags & CLEARSCR))
 865                                                         clear_screen();
 866                                                 else
 867                                                         printf("\n\n\n");
 868                                         }
 869                                         printf(">>> %s\n\n", mname);
 870                                 }
 871                                 break;
 872
 873                         case ISTTY:
 874                                 strncpy(buf, "\n", sizeof(buf));
 875                                 if (ofilec > 1) {
 876                                         if (SOprintf("Press <return> to list \"%s\"...", mname)) {
 877                                                 if (ofilen > 1)
 878                                                         printf("\n\n\n");
 879                                                 printf("Press <return> to list \"%s\"...", mname);
 880                                         }
 881                                         fflush(stdout);
 882                                         buf[0] = 0;
 883                                         read(fileno(stdout), buf, sizeof(buf));
 884                                 }
 885                                 if (strchr(buf, '\n')) {
 886                                         if ((global.c_flags & CLEARSCR))
 887                                                 clear_screen();
 888                                 }
 889                                 else
 890                                         printf("\n");
 891                                 break;
 892
 893                         default:
 894                                 if (ofilec > 1) {
 895                                         if (ofilen > 1) {
 896                                                 printf("\n\n\n");
 897                                                 if (clearflg > 0)
 898                                                         clear_screen();
 899                                         }
 900                                         printf(">>> %s\n\n", mname);
 901                                 }
 902                                 break;
 903                 }
 904         }
 905
 906         for (state = FLD;;) {
 907                 switch (state = m_getfld(state, name, buf, sizeof(buf), fp)) {
 908                         case FLD:
 909                         case FLDPLUS:
 910                                 for (ip = ignores; *ip; ip++)
 911                                         if (!mh_strcasecmp(name, *ip)) {
 912                                                 while (state == FLDPLUS)
 913                                                         state = m_getfld(state, name, buf, sizeof(buf), fp);
 914                                                 break;
 915                                         }
 916                                 if (*ip)
 917                                         continue;
 918
 919                                 for (c2 = fmthd; c2; c2 = c2->c_next)
 920                                         if (!mh_strcasecmp(c2->c_name, name))
 921                                                 break;
 922                                 c1 = NULL;
 923                                 if (!((c3 = c2 ? c2 : &global)->c_flags & SPLIT))
 924                                         for (c1 = msghd; c1; c1 = c1->c_next)
 925                                                 if (!mh_strcasecmp(c1->c_name, c3->c_name)) {
 926                                                         c1->c_text = mcomp_add (c1->c_flags, buf, c1->c_text);
 927                                                         break;
 928                                                 }
 929                                 if (c1 == NULL)
 930                                         c1 = add_queue(&msghd, &msgtl, name, buf, 0);
 931                                 while (state == FLDPLUS) {
 932                                         state = m_getfld(state, name, buf, sizeof(buf), fp);
 933                                         c1->c_text = add(buf, c1->c_text);
 934                                 }
 935                                 if (c2 == NULL)
 936                                         c1->c_flags |= EXTRA;
 937                                 continue;
 938
 939                         case BODY:
 940                         case FILEEOF:
 941                                 row = column = 0;
 942                                 for (c1 = fmthd; c1; c1 = c1->c_next) {
 943                                         if (c1->c_flags & CLEARTEXT) {
 944                                                 putcomp(c1, c1, ONECOMP);
 945                                                 continue;
 946                                         }
 947                                         if (!mh_strcasecmp(c1->c_name, "messagename")) {
 948                                                 holder.c_text = concat("(Message ", mname, ")\n",
 949                                                                                         NULL);
 950                                                 putcomp(c1, &holder, ONECOMP);
 951                                                 free(holder.c_text);
 952                                                 holder.c_text = NULL;
 953                                                 continue;
 954                                         }
 955                                         if (!mh_strcasecmp(c1->c_name, "extras")) {
 956                                                 for (c2 = msghd; c2; c2 = c2->c_next)
 957                                                         if (c2->c_flags & EXTRA)
 958                                                                 putcomp(c1, c2, TWOCOMP);
 959                                                 continue;
 960                                         }
 961                                         if (dobody && !mh_strcasecmp(c1->c_name, "body")) {
 962                                                 holder.c_text = mh_xmalloc(sizeof(buf));
 963                                                 strncpy(holder.c_text, buf, sizeof(buf));
 964                                                 while (state == BODY) {
 965                                                         putcomp(c1, &holder, BODYCOMP);
 966                                                         state = m_getfld(state, name, holder.c_text, sizeof(buf), fp);
 967                                                 }
 968                                                 free(holder.c_text);
 969                                                 holder.c_text = NULL;
 970                                                 continue;
 971                                         }
 972                                         for (c2 = msghd; c2; c2 = c2->c_next)
 973                                                 if (!mh_strcasecmp(c2->c_name, c1->c_name)) {
 974                                                         putcomp(c1, c2, ONECOMP);
 975                                                         if (!(c1->c_flags & SPLIT))
 976                                                                 break;
 977                                                 }
 978                                         if (faceproc && c2 == NULL && (c1->c_flags & FACEFMT))
 979                                                 for (c2 = msghd; c2; c2 = c2->c_next)
 980                                                         if (c2->c_flags & FACEDFLT) {
 981                                                                 if (c2->c_face == NULL)
 982                                                                         face_format(c2);
 983                                                                 if ((holder.c_text = c2->c_face)) {
 984                                                                         putcomp(c1, &holder, ONECOMP);
 985                                                                         holder.c_text = NULL;
 986                                                                 }
 987                                                                 break;
 988                                                         }
 989                                 }
 990                                 return;
 991
 992                         case LENERR:
 993                         case FMTERR:
 994                                 advise(NULL, "format error in message %s",
 995                                                 mname);
 996                                 exitstat++;
 997                                 return;
 998
 999                         default:
1000                                 adios(NULL, "getfld() returned %d", state);
1001                 }
1002         }
1003 }
1004
1005
1006 static int
1007 mcomp_flags(char *name)
1008 {
1009         struct pair *ap;
1010
1011         for (ap = pairs; ap->p_name; ap++)
1012                 if (!mh_strcasecmp(ap->p_name, name))
1013                         return (ap->p_flags);
1014
1015         return 0;
1016 }
1017
1018
1019 static char *
1020 mcomp_add(long flags, char *s1, char *s2)
1021 {
1022         char *dp;
1023
1024         if (!(flags & ADDRFMT))
1025                 return add(s1, s2);
1026
1027         if (s2 && *(dp = s2 + strlen(s2) - 1) == '\n')
1028                 *dp = 0;
1029
1030         return add(s1, add(",\n", s2));
1031 }
1032
1033
1034 struct pqpair {
1035         char *pq_text;
1036         char *pq_error;
1037         struct pqpair *pq_next;
1038 };
1039
1040
1041 static void
1042 mcomp_format(struct mcomp *c1, struct mcomp *c2)
1043 {
1044         int dat[5];
1045         char *ap, *cp;
1046         char buffer[BUFSIZ], error[BUFSIZ];
1047         struct comp *cptr;
1048         struct pqpair *p, *q;
1049         struct pqpair pq;
1050         struct mailname *mp;
1051
1052         ap = c2->c_text;
1053         c2->c_text = NULL;
1054         dat[0] = 0;
1055         dat[1] = 0;
1056         dat[2] = 0;
1057         dat[3] = sizeof(buffer) - 1;
1058         dat[4] = 0;
1059         fmt_compile(c1->c_nfs, &c1->c_fmt);
1060
1061         if (!(c1->c_flags & ADDRFMT)) {
1062                 FINDCOMP(cptr, "text");
1063                 if (cptr)
1064                         cptr->c_text = ap;
1065                 if ((cp = strrchr(ap, '\n')))  /* drop ending newline */
1066                         if (!cp[1])
1067                                 *cp = 0;
1068
1069                 fmt_scan(c1->c_fmt, buffer, sizeof(buffer) - 1, dat);
1070                 /* Don't need to append a newline, dctime() already did */
1071                 c2->c_text = getcpy(buffer);
1072
1073                 free(ap);
1074                 return;
1075         }
1076
1077         (q = &pq)->pq_next = NULL;
1078         while ((cp = getname(ap))) {
1079                 if ((p = (struct pqpair *)
1080                                 calloc((size_t) 1, sizeof(*p))) == NULL)
1081                         adios(NULL, "unable to allocate pqpair memory");
1082
1083                 if ((mp = getm(cp, NULL, 0, AD_NAME, error)) == NULL) {
1084                         p->pq_text = getcpy(cp);
1085                         p->pq_error = getcpy(error);
1086                 } else {
1087                         if ((c1->c_flags & FACEDFLT) && c2->c_face == NULL) {
1088                                 char   *h, *o;
1089                                 if ((h = mp->m_host) == NULL)
1090                                         h = LocalName();
1091                                 if ((o = OfficialName(h)))
1092                                         h = o;
1093                                 c2->c_face = concat("address ", h, " ",
1094                                                 mp->m_mbox, NULL);
1095                         }
1096                         p->pq_text = getcpy(mp->m_text);
1097                         mnfree(mp);
1098                 }
1099                 q = (q->pq_next = p);
1100         }
1101
1102         for (p = pq.pq_next; p; p = q) {
1103                 FINDCOMP(cptr, "text");
1104                 if (cptr)
1105                         cptr->c_text = p->pq_text;
1106                 FINDCOMP(cptr, "error");
1107                 if (cptr)
1108                         cptr->c_text = p->pq_error;
1109
1110                 fmt_scan(c1->c_fmt, buffer, sizeof(buffer) - 1, dat);
1111                 if (*buffer) {
1112                         if (c2->c_text)
1113                                 c2->c_text = add(",\n", c2->c_text);
1114                         if (*(cp = buffer + strlen(buffer) - 1) == '\n')
1115                                 *cp = 0;
1116                         c2->c_text = add(buffer, c2->c_text);
1117                 }
1118
1119                 free(p->pq_text);
1120                 if (p->pq_error)
1121                         free(p->pq_error);
1122                 q = p->pq_next;
1123                 free((char *) p);
1124         }
1125
1126         c2->c_text = add("\n", c2->c_text);
1127         free (ap);
1128 }
1129
1130
1131 static struct mcomp *
1132 add_queue(struct mcomp **head, struct mcomp **tail, char *name,
1133                 char *text, int flags)
1134 {
1135         struct mcomp *c1;
1136
1137         if ((c1 = (struct mcomp *) calloc((size_t) 1, sizeof(*c1))) == NULL)
1138                 adios(NULL, "unable to allocate comp memory");
1139
1140         c1->c_flags = flags & ~INIT;
1141         if ((c1->c_name = name ? getcpy(name) : NULL))
1142                 c1->c_flags |= mcomp_flags(c1->c_name);
1143         c1->c_text = text ? getcpy(text) : NULL;
1144         if (flags & INIT) {
1145                 if (global.c_ovtxt)
1146                         c1->c_ovtxt = getcpy(global.c_ovtxt);
1147                 c1->c_offset = global.c_offset;
1148                 c1->c_ovoff = global. c_ovoff;
1149                 c1->c_width = c1->c_length = 0;
1150                 c1->c_cwidth = global.c_cwidth;
1151                 c1->c_flags |= global.c_flags & GFLAGS;
1152         }
1153         if (*head == NULL)
1154                 *head = c1;
1155         if (*tail != NULL)
1156                 (*tail)->c_next = c1;
1157         *tail = c1;
1158
1159         return c1;
1160 }
1161
1162
1163 static void
1164 free_queue(struct mcomp **head, struct mcomp **tail)
1165 {
1166         struct mcomp *c1, *c2;
1167
1168         for (c1 = *head; c1; c1 = c2) {
1169                 c2 = c1->c_next;
1170                 if (c1->c_name)
1171                         free(c1->c_name);
1172                 if (c1->c_text)
1173                         free(c1->c_text);
1174                 if (c1->c_ovtxt)
1175                         free(c1->c_ovtxt);
1176                 if (c1->c_nfs)
1177                         free(c1->c_nfs);
1178                 if (c1->c_fmt)
1179                         free((char *) c1->c_fmt);
1180                 if (c1->c_face)
1181                         free(c1->c_face);
1182                 free((char *) c1);
1183         }
1184
1185         *head = *tail = NULL;
1186 }
1187
1188
1189 static void
1190 putcomp(struct mcomp *c1, struct mcomp *c2, int flag)
1191 {
1192         int count, cchdr;
1193         unsigned char *cp;
1194
1195         cchdr = 0;
1196         lm = 0;
1197         llim = c1->c_length ? c1->c_length : -1;
1198         wid = c1->c_width ? c1->c_width : global.c_width;
1199         ovoff = (c1->c_ovoff >= 0 ? c1->c_ovoff : global.c_ovoff)
1200                         + c1->c_offset;
1201         if ((ovtxt = c1->c_ovtxt ? c1->c_ovtxt : global.c_ovtxt) == NULL)
1202                 ovtxt = "";
1203         if (wid < ovoff + strlen(ovtxt) + 5)
1204                 adios(NULL, "component: %s width(%d) too small for overflow(%d)", c1->c_name, wid, ovoff + strlen(ovtxt) + 5);
1205         onelp = NULL;
1206
1207         if (c1->c_flags & CLEARTEXT) {
1208                 putstr(c1->c_text);
1209                 putstr("\n");
1210                 return;
1211         }
1212
1213         if (c1->c_flags & FACEFMT)
1214                 switch (doface(c2)) {
1215                         case NOTOK:  /* error */
1216                         case OK:  /* async faceproc */
1217                                 return;
1218
1219                         default:  /* sync faceproc */
1220                                 break;
1221                 }
1222
1223         if (c1->c_nfs && (c1->c_flags & (ADDRFMT | DATEFMT | FORMAT)))
1224                 mcomp_format(c1, c2);
1225
1226         if (c1->c_flags & CENTER) {
1227                 count = (c1->c_width ? c1->c_width : global.c_width)
1228                                 - c1->c_offset - strlen(c2->c_text);
1229                 if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT))
1230                         count -= strlen(c1->c_text ? c1->c_text : c1->c_name)
1231                                         + 2;
1232                 lm = c1->c_offset + (count / 2);
1233         } else {
1234                 if (c1->c_offset)
1235                         lm = c1->c_offset;
1236         }
1237
1238         if (!(c1->c_flags & HDROUTPUT) && !(c1->c_flags & NOCOMPONENT)) {
1239                 if (c1->c_flags & UPPERCASE)  /* uppercase component also */
1240                         for (cp = (c1->c_text ? c1->c_text : c1->c_name); *cp; cp++)
1241                                 if (islower(*cp))
1242                                         *cp = toupper(*cp);
1243                 putstr(c1->c_text ? c1->c_text : c1->c_name);
1244                 if (flag != BODYCOMP) {
1245                         putstr(": ");
1246                         if (!(c1->c_flags & SPLIT))
1247                                 c1->c_flags |= HDROUTPUT;
1248
1249                 cchdr++;
1250                 if ((count = c1->c_cwidth -
1251                         strlen(c1->c_text ? c1->c_text : c1->c_name) - 2) > 0)
1252                         while (count--)
1253                                 putstr(" ");
1254                 } else
1255                         c1->c_flags |= HDROUTPUT;  /* for BODYCOMP */
1256         }
1257
1258         if (flag == TWOCOMP && !(c2->c_flags & HDROUTPUT)
1259                 && !(c2->c_flags & NOCOMPONENT)) {
1260                 if (c1->c_flags & UPPERCASE)
1261                         for (cp = c2->c_name; *cp; cp++)
1262                                 if (islower(*cp))
1263                                         *cp = toupper(*cp);
1264                 putstr(c2->c_name);
1265                 putstr(": ");
1266                 if (!(c1->c_flags & SPLIT))
1267                         c2->c_flags |= HDROUTPUT;
1268
1269                 cchdr++;
1270                 if ((count = c1->c_cwidth - strlen(c2->c_name) - 2) > 0)
1271                         while (count--)
1272                                 putstr(" ");
1273         }
1274         if (c1->c_flags & UPPERCASE)
1275                 for (cp = c2->c_text; *cp; cp++)
1276                         if (islower(*cp))
1277                                 *cp = toupper(*cp);
1278
1279         count = 0;
1280         if (cchdr) {
1281                 if (flag == TWOCOMP)
1282                         count = (c1->c_cwidth >= 0) ?
1283                                         c1->c_cwidth : strlen(c2->c_name) + 2;
1284                 else
1285                         count = (c1->c_cwidth >= 0) ?
1286                                         c1->c_cwidth : strlen(c1->c_text ?
1287                                         c1->c_text : c1->c_name) + 2;
1288         }
1289         count += c1->c_offset;
1290
1291         if ((cp = oneline(c2->c_text, c1->c_flags)))
1292            putstr(cp);
1293         if (term == '\n')
1294                 putstr("\n");
1295         while ((cp = oneline(c2->c_text, c1->c_flags))) {
1296                 lm = count;
1297                 if (flag == BODYCOMP && !(c1->c_flags & NOCOMPONENT))
1298                         putstr(c1->c_text ? c1->c_text : c1->c_name);
1299                 if (*cp)
1300                         putstr(cp);
1301                 if (term == '\n')
1302                         putstr("\n");
1303         }
1304         if (flag == BODYCOMP && term == '\n')
1305                 c1->c_flags &= ~HDROUTPUT;  /* Buffer ended on a newline */
1306 }
1307
1308
1309 static char *
1310 oneline(char *stuff, long flags)
1311 {
1312         int spc;
1313         char *cp, *ret;
1314
1315         if (onelp == NULL)
1316                 onelp = stuff;
1317         if (*onelp == 0)
1318                 return (onelp = NULL);
1319
1320         ret = onelp;
1321         term = 0;
1322         if (flags & COMPRESS) {
1323                 for (spc = 1, cp = ret; *onelp; onelp++)
1324                         if (isspace(*onelp)) {
1325                                 if (*onelp == '\n' &&
1326                                                 (!onelp[1] ||
1327                                                 (flags & ADDRFMT))) {
1328                                         term = '\n';
1329                                         *onelp++ = 0;
1330                                         break;
1331                                 } else if (!spc) {
1332                                         *cp++ = ' ';
1333                                         spc++;
1334                                 }
1335                         } else {
1336                                 *cp++ = *onelp;
1337                                 spc = 0;
1338                         }
1339
1340                 *cp = 0;
1341         } else {
1342                 while (*onelp && *onelp != '\n')
1343                         onelp++;
1344                 if (*onelp == '\n') {
1345                         term = '\n';
1346                         *onelp++ = 0;
1347                 }
1348                 if (flags & LEFTADJUST)
1349                         while (*ret == ' ' || *ret == '\t')
1350                                 ret++;
1351         }
1352         if (*onelp == 0 && term == '\n' && (flags & NONEWLINE))
1353                 term = 0;
1354
1355         return ret;
1356 }
1357
1358
1359 static void
1360 putstr(char *string)
1361 {
1362         if (!column && lm > 0) {
1363                 while (lm > 0)
1364                         if (lm >= 8) {
1365                                 putch('\t');
1366                                 lm -= 8;
1367                         } else {
1368                                 putch(' ');
1369                                 lm--;
1370                         }
1371         }
1372         lm = 0;
1373         while (*string)
1374                 putch(*string++);
1375 }
1376
1377
1378 static void
1379 putch(char ch)
1380 {
1381         char buf[BUFSIZ];
1382
1383         if (llim == 0)
1384                 return;
1385
1386         switch (ch) {
1387                 case '\n':
1388                         if (llim > 0)
1389                                 llim--;
1390                         column = 0;
1391                         row++;
1392                         if (ontty != ISTTY || row != global.c_length)
1393                                 break;
1394                         if (global.c_flags & BELL)
1395                                 putchar('\007');
1396                         fflush(stdout);
1397                         buf[0] = 0;
1398                         read(fileno(stdout), buf, sizeof(buf));
1399                         if (strchr(buf, '\n')) {
1400                                 if (global.c_flags & CLEARSCR)
1401                                         clear_screen();
1402                                 row = 0;
1403                         } else {
1404                                 putchar('\n');
1405                                 row = global.c_length / 3;
1406                         }
1407                         return;
1408
1409                 case '\t':
1410                         column |= 07;
1411                         column++;
1412                         break;
1413
1414                 case '\b':
1415                         column--;
1416                         break;
1417
1418                 case '\r':
1419                         column = 0;
1420                         break;
1421
1422                 default:
1423                         /*
1424                         ** If we are forwarding this message, and the first
1425                         ** column contains a dash, then add a dash and a space.
1426                         */
1427                         if (column == 0 && forwflg && (dashstuff >= 0) && ch == '-') {
1428                                 putchar('-');
1429                                 putchar(' ');
1430                         }
1431                         if (ch >= ' ')
1432                                 column++;
1433                         break;
1434         }
1435
1436         if (column >= wid) {
1437                 putch('\n');
1438                 if (ovoff > 0)
1439                         lm = ovoff;
1440                 putstr(ovtxt ? ovtxt : "");
1441                 putch(ch);
1442                 return;
1443         }
1444
1445         putchar(ch);
1446 }
1447
1448
1449 static RETSIGTYPE
1450 intrser(int i)
1451 {
1452 #ifndef RELIABLE_SIGNALS
1453         SIGNAL(SIGINT, intrser);
1454 #endif
1455
1456         discard(stdout);
1457         putchar('\n');
1458         longjmp(env, DONE);
1459 }
1460
1461
1462 static RETSIGTYPE
1463 pipeser(int i)
1464 {
1465 #ifndef RELIABLE_SIGNALS
1466         SIGNAL(SIGPIPE, pipeser);
1467 #endif
1468
1469         done(NOTOK);
1470 }
1471
1472
1473 static RETSIGTYPE
1474 quitser(int i)
1475 {
1476 #ifndef RELIABLE_SIGNALS
1477         SIGNAL(SIGQUIT, quitser);
1478 #endif
1479
1480         putchar('\n');
1481         fflush(stdout);
1482         done(NOTOK);
1483 }
1484
1485
1486 static void
1487 face_format(struct mcomp *c1)
1488 {
1489         char *cp;
1490         struct mailname *mp;
1491
1492         if ((cp = c1->c_text) == NULL)
1493                 return;
1494
1495         if ((cp = getname(cp))) {
1496                 if ((mp = getm(cp, NULL, 0, AD_NAME, NULL))) {
1497                         char *h, *o;
1498                         if ((h = mp->m_host) == NULL)
1499                                 h = LocalName();
1500                         if ((o = OfficialName(h)))
1501                                 h = o;
1502                         c1->c_face = concat("address ", h, " ", mp->m_mbox,
1503                                         NULL);
1504                 }
1505
1506                 while ((cp = getname(cp)))
1507                         continue;
1508         }
1509 }
1510
1511
1512 /*
1513 ** faceproc is two elements defining the image agent's location:
1514 **     Internet host
1515 **     UDP port
1516 */
1517
1518 #include <sys/socket.h>
1519 #include <netinet/in.h>
1520 #include <netdb.h>
1521
1522 #ifdef HAVE_ARPA_INET_H
1523 # include <arpa/inet.h>
1524 #endif
1525
1526 static int
1527 doface(struct mcomp *c1)
1528 {
1529         int result, sd;
1530         static int inited = OK;
1531         static struct sockaddr_storage ss;
1532         static socklen_t socklen;
1533         static int socktype;
1534         static int protocol;
1535
1536         if (inited == OK) {
1537                 char *cp;
1538                 char **ap = brkstring(cp = getcpy(faceproc), " ", "\n");
1539                 struct addrinfo hints, *res;
1540
1541                 if (ap[0] == NULL || ap[1] == NULL) {
1542 bad_faceproc: ;
1543                         free(cp);
1544                         return (inited = NOTOK);
1545                 }
1546
1547                 memset(&hints, 0, sizeof(hints));
1548 #ifdef AI_ADDRCONFIG
1549                 hints.ai_flags = AI_ADDRCONFIG;
1550 #endif
1551                 hints.ai_family = PF_UNSPEC;
1552                 hints.ai_socktype = SOCK_DGRAM;
1553
1554                 if (getaddrinfo(ap[0], ap[1], &hints, &res) != 0)
1555                         goto bad_faceproc;
1556
1557                 memcpy(&ss, res->ai_addr, res->ai_addrlen);
1558                 socklen = res->ai_addrlen;
1559                 socktype = res->ai_socktype;
1560                 protocol = res->ai_protocol;
1561                 freeaddrinfo(res);
1562
1563                 inited = DONE;
1564         }
1565         if (inited == NOTOK)
1566                 return NOTOK;
1567
1568         if ((sd = socket(ss.ss_family, socktype, protocol)) == NOTOK)
1569                 return NOTOK;
1570
1571         result = sendto(sd, c1->c_text, strlen(c1->c_text), 0,
1572                         (struct sockaddr *) &ss, socklen);
1573
1574         close(sd);
1575
1576         return (result != NOTOK ? OK : NOTOK);
1577 }
1578
1579 /*
1580 ** COMMENTED OUT
1581 ** This version doesn't use sockets
1582 */
1583 #if 0
1584
1585 static int
1586 doface(struct mcomp *c1)
1587 {
1588         int i, len, vecp;
1589         pid_t child_id;
1590         int result, pdi[2], pdo[2];
1591         char *bp, *cp;
1592         char buffer[BUFSIZ], *vec[10];
1593
1594         if (pipe(pdi) == NOTOK)
1595                 return NOTOK;
1596         if (pipe(pdo) == NOTOK) {
1597                 close(pdi[0]);
1598                 close(pdi[1]);
1599                 return NOTOK;
1600         }
1601
1602         for (i = 0; (child_id = vfork()) == NOTOK && i < 5; i++)
1603                 sleep(5);
1604
1605         switch (child_id) {
1606                 case NOTOK:
1607                         /* oops... fork error */
1608                         return NOTOK;
1609
1610                 case OK:
1611                         /* child process */
1612                         SIGNAL(SIGINT, SIG_IGN);
1613                         SIGNAL(SIGQUIT, SIG_IGN);
1614                         if (pdi[0] != fileno(stdin)) {
1615                                 dup2(pdi[0], fileno(stdin));
1616                                 close(pdi[0]);
1617                         }
1618                         close(pdi[1]);
1619                         close(pdo[0]);
1620                         if (pdo[1] != fileno(stdout)) {
1621                                 dup2(pdo[1], fileno(stdout));
1622                                 close(pdo[1]);
1623                         }
1624                         vecp = 0;
1625                         vec[vecp++] = r1bindex(faceproc, '/');
1626                         vec[vecp++] = "-e";
1627                         if (sleepsw != NOTOK) {
1628                                 vec[vecp++] = "-s";
1629                                 snprintf(buffer, sizeof(buffer), "%d",
1630                                                 sleepsw);
1631                                 vec[vecp++] = buffer;
1632                         }
1633                         vec[vecp] = NULL;
1634                         execvp(faceproc, vec);
1635                         fprintf(stderr, "unable to exec ");
1636                         perror(faceproc);
1637                         _exit(-1);  /* NOTREACHED */
1638
1639                 default:
1640                         /* parent process */
1641                         close(pdi[0]);
1642                         i = strlen(c1->c_text);
1643                         if (write(pdi[1], c1->c_text, i) != i)
1644                                 adios("pipe", "error writing to");
1645                         free(c1->c_text), c1->c_text = NULL;
1646                         close(pdi[1]);
1647
1648                         close(pdo[1]);
1649                         cp = NULL, len = 0;
1650                         result = DONE;
1651                         while ((i=read(pdo[0], buffer, strlen(buffer))) > 0) {
1652                                 if (cp) {
1653                                         int j;
1654                                         char *dp;
1655                                         dp = mh_xrealloc(cp, (unsigned) (j = len + i));
1656                                         memcpy(dp + len, buffer, i);
1657                                         cp = dp, len = j;
1658                                 } else {
1659                                         cp = mh_xmalloc((unsigned) i);
1660                                         memcpy(cp, buffer, i);
1661                                         len = i;
1662                                 }
1663                                 if (result == DONE)
1664                                         for (bp = buffer + i - 1; bp >= buffer; bp--)
1665                                                 if (!isascii(*bp) ||
1666                                                                 iscntrl(*bp)) {
1667                                                         result = OK;
1668                                                         break;
1669                                                 }
1670                         }
1671                         close(pdo[0]);
1672
1673 /* no waiting for child... */
1674
1675                         if (result == OK) {  /* binary */
1676                                 if (write(1, cp, len) != len)
1677                                         adios("writing", "error");
1678                                 free(cp);
1679                         }
1680                         else  /* empty */
1681                                 if ((c1->c_text = cp) == NULL)
1682                                         result = OK;
1683                         break;
1684         }
1685
1686         return result;
1687 }
1688 #endif /* COMMENTED OUT */
1689
1690
1691 int
1692 mhlsbr(int argc, char **argv, FILE *(*action)())
1693 {
1694         SIGNAL_HANDLER istat = NULL, pstat = NULL, qstat = NULL;
1695         char *cp = NULL;
1696         struct mcomp *c1;
1697
1698         switch (setjmp(mhlenv)) {
1699                 case OK:
1700                         cp = invo_name;
1701                         sleepsw = 0;  /* XXX */
1702                         bellflg = clearflg = forwflg = forwall = exitstat = 0;
1703                         digest = NULL;
1704                         ontty = NOTTY;
1705                         mhl_action = action;
1706
1707                         /*
1708                         ** If signal is at default action, then start ignoring
1709                         ** it, else let it set to its current action.
1710                         */
1711                         if ((istat = SIGNAL(SIGINT, SIG_IGN)) != SIG_DFL)
1712                                 SIGNAL(SIGINT, istat);
1713                         if ((qstat = SIGNAL(SIGQUIT, SIG_IGN)) != SIG_DFL)
1714                                 SIGNAL(SIGQUIT, qstat);
1715                         pstat = SIGNAL(SIGPIPE, pipeser);
1716                         mhl(argc, argv);  /* FALL THROUGH! */
1717
1718                 default:
1719                         SIGNAL(SIGINT, istat);
1720                         SIGNAL(SIGQUIT, qstat);
1721                         SIGNAL(SIGPIPE, SIG_IGN);  /*
1722                                         ** should probably change to block
1723                                         ** instead
1724                                         */
1725                         if (ontty == PITTY)
1726                                 m_pclose();
1727                         SIGNAL(SIGPIPE, pstat);
1728                         invo_name = cp;
1729                         if (holder.c_text) {
1730                                 free(holder.c_text);
1731                                 holder.c_text = NULL;
1732                         }
1733                         free_queue(&msghd, &msgtl);
1734                         for (c1 = fmthd; c1; c1 = c1->c_next)
1735                                 c1->c_flags &= ~HDROUTPUT;
1736                         return exitstat;
1737         }
1738 }
1739
1740 #undef adios
1741 #undef done
1742
1743 static void
1744 mhladios(char *what, char *fmt, ...)
1745 {
1746         va_list ap;
1747
1748         va_start(ap, fmt);
1749         advertise(what, NULL, fmt, ap);
1750         va_end(ap);
1751         mhldone(1);
1752 }
1753
1754
1755 static void
1756 mhldone(int status)
1757 {
1758         exitstat = status;
1759         if (mhl_action)
1760                 longjmp(mhlenv, DONE);
1761         else
1762                 done(exitstat);
1763 }
1764
1765
1766 static int m_pid = NOTOK;
1767 static int sd = NOTOK;
1768
1769 static void
1770 m_popen(char *name)
1771 {
1772         int pd[2];
1773
1774         if (mhl_action && (sd = dup(fileno(stdout))) == NOTOK)
1775                 adios("standard output", "unable to dup()");
1776
1777         if (pipe(pd) == NOTOK)
1778                 adios("pipe", "unable to");
1779
1780         switch (m_pid = vfork()) {
1781                 case NOTOK:
1782                         adios("fork", "unable to");
1783
1784                 case OK:
1785                         SIGNAL(SIGINT, SIG_DFL);
1786                         SIGNAL(SIGQUIT, SIG_DFL);
1787
1788                         close(pd[1]);
1789                         if (pd[0] != fileno(stdin)) {
1790                                 dup2(pd[0], fileno(stdin));
1791                                 close(pd[0]);
1792                         }
1793                         execlp(name, r1bindex(name, '/'), NULL);
1794                         fprintf(stderr, "unable to exec ");
1795                         perror(name);
1796                         _exit(-1);
1797
1798                 default:
1799                         close(pd[0]);
1800                         if (pd[1] != fileno(stdout)) {
1801                                 dup2(pd[1], fileno(stdout));
1802                                 close(pd[1]);
1803                         }
1804         }
1805 }
1806
1807
1808 void
1809 m_pclose(void)
1810 {
1811         if (m_pid == NOTOK)
1812                 return;
1813
1814         if (sd != NOTOK) {
1815                 fflush(stdout);
1816                 if (dup2(sd, fileno(stdout)) == NOTOK)
1817                         adios("standard output", "unable to dup2()");
1818
1819                 clearerr(stdout);
1820                 close(sd);
1821                 sd = NOTOK;
1822         }
1823         else
1824                 fclose(stdout);
1825
1826         pidwait(m_pid, OK);
1827         m_pid = NOTOK;
1828 }