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

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