collect.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Collect input from standard input, handling ~ escapes.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE collect
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /* The following hookiness with global variables is so that on receipt of an
  43  * interrupt signal, the partial message can be salted away on *DEAD* */
  44
  45 static sighandler_type  _coll_saveint;    /* Previous SIGINT value */
  46 static sighandler_type  _coll_savehup;    /* Previous SIGHUP value */
  47 static sighandler_type  _coll_savetstp;   /* Previous SIGTSTP value */
  48 static sighandler_type  _coll_savettou;   /* Previous SIGTTOU value */
  49 static sighandler_type  _coll_savettin;   /* Previous SIGTTIN value */
  50 static FILE             *_coll_fp;        /* File for saving away */
  51 static int volatile     _coll_hadintr;    /* Have seen one SIGINT so far */
  52 static sigjmp_buf       _coll_jmp;        /* To get back to work */
  53 static int              _coll_jmp_p;      /* whether to long jump */
  54 static sigjmp_buf       _coll_abort;      /* To end collection with error */
  55 static sigjmp_buf       _coll_pipejmp;    /* On broken pipe */
  56
  57 /* Handle `~:', `~_' */
  58 static void       _execute_command(struct header *hp, char *linebuf,
  59                      size_t linesize);
  60
  61 /* If *interactive* is set and *doecho* is, too, also dump to *stdout* */
  62 static int        _include_file(char const *name, int *linecount,
  63                      int *charcount, bool_t doecho, bool_t indent);
  64
  65 static void       _collect_onpipe(int signo);
  66
  67 /* Execute cmd and insert its standard output into fp */
  68 static void       insertcommand(FILE *fp, char const *cmd);
  69
  70 /* ~p command */
  71 static void       print_collf(FILE *collf, struct header *hp);
  72
  73 /* Write a file, ex-like if f set */
  74 static int        exwrite(char const *name, FILE *fp, int f);
  75
  76 /* Parse off the message header from fp and store relevant fields in hp,
  77  * replace _coll_fp with a shiny new version without any header */
  78 static enum okay  makeheader(FILE *fp, struct header *hp, si8_t *checkaddr_err);
  79
  80 /* Edit the message being collected on fp.  On return, make the edit file the
  81  * new temp file */
  82 static void       mesedit(int c, struct header *hp);
  83
  84 /* Pipe the message through the command.  Old message is on stdin of command,
  85  * new message collected from stdout.  Shell must return 0 to accept new msg */
  86 static void       mespipe(char *cmd);
  87
  88 /* Interpolate the named messages into the current message, possibly doing
  89  * indent stuff.  The flag argument is one of the tilde escapes: [mMfFuU].
  90  * Return a count of the number of characters now in the message, or -1 if an
  91  * error is encountered writing the message temporary */
  92 static int        forward(char *ms, FILE *fp, int f);
  93
  94 /* Print (continue) when continued after ^Z */
  95 static void       collstop(int s);
  96
  97 /* On interrupt, come here to save the partial message in ~/dead.letter.
  98  * Then jump out of the collection loop */
  99 static void       _collint(int s);
 100
 101 static void       collhup(int s);
 102
 103 static int        putesc(char const *s, FILE *stream);
 104
 105 static void
 106 _execute_command(struct header *hp, char *linebuf, size_t linesize)
 107 {
 108    /* The problem arises if there are rfc822 message attachments and the
 109     * user uses `~:' to change the current file.  TODO Unfortunately we
 110     * TODO cannot simply keep a pointer to, or increment a reference count
 111     * TODO of the current `file' (mailbox that is) object, because the
 112     * TODO codebase doesn't deal with that at all; so, until some far
 113     * TODO later time, copy the name of the path, and warn the user if it
 114     * TODO changed; we COULD use the AC_TMPFILE attachment type, i.e.,
 115     * TODO copy the message attachments over to temporary files, but that
 116     * TODO would require more changes so that the user still can recognize
 117     * TODO in `~@' etc. that its a rfc822 message attachment; see below */
 118    char *mnbuf = NULL;
 119    size_t mnlen = 0 /* silence CC */;
 120    struct attachment *ap;
 121    NYD_ENTER;
 122
 123    /* If the above todo is worked, remove or outsource to attachments.c! */
 124    if ((ap = hp->h_attach) != NULL) do
 125       if (ap->a_msgno) {
 126          mnlen = strlen(mailname) +1;
 127          mnbuf = ac_alloc(mnlen);
 128          memcpy(mnbuf, mailname, mnlen);
 129          break;
 130       }
 131    while ((ap = ap->a_flink) != NULL);
 132
 133    pstate &= ~PS_HOOK_MASK;
 134    execute(linebuf, linesize);
 135
 136    if (mnbuf != NULL) {
 137       if (strncmp(mnbuf, mailname, mnlen))
 138          n_err(_("Mailbox changed: it is likely that existing "
 139             "rfc822 attachments became invalid!\n"));
 140       ac_free(mnbuf);
 141    }
 142    NYD_LEAVE;
 143 }
 144
 145 static int
 146 _include_file(char const *name, int *linecount, int *charcount,
 147    bool_t doecho, bool_t indent)
 148 {
 149    FILE *fbuf;
 150    char const *indb;
 151    int ret = -1;
 152    char *linebuf = NULL; /* TODO line pool */
 153    size_t linesize = 0, indl, linelen, cnt;
 154    NYD_ENTER;
 155
 156    if ((fbuf = Fopen(name, "r")) == NULL) {
 157       n_perr(name, 0);
 158       goto jleave;
 159    }
 160
 161    if (!indent)
 162       indb = NULL, indl = 0;
 163    else {
 164       if ((indb = ok_vlook(indentprefix)) == NULL)
 165          indb = INDENT_DEFAULT;
 166       indl = strlen(indb);
 167    }
 168
 169    *linecount = *charcount = 0;
 170    cnt = fsize(fbuf);
 171    while (fgetline(&linebuf, &linesize, &cnt, &linelen, fbuf, 0) != NULL) {
 172       if (indl > 0 && fwrite(indb, sizeof *indb, indl, _coll_fp) != indl)
 173          goto jleave;
 174       if (fwrite(linebuf, sizeof *linebuf, linelen, _coll_fp) != linelen)
 175          goto jleave;
 176       ++(*linecount);
 177       (*charcount) += linelen + indl;
 178       if ((options & OPT_INTERACTIVE) && doecho) {
 179          if (indl > 0)
 180             fwrite(indb, sizeof *indb, indl, stdout);
 181          fwrite(linebuf, sizeof *linebuf, linelen, stdout);
 182       }
 183    }
 184    if (fflush(_coll_fp))
 185       goto jleave;
 186    if ((options & OPT_INTERACTIVE) && doecho)
 187       fflush(stdout);
 188
 189    ret = 0;
 190 jleave:
 191    if (linebuf != NULL)
 192       free(linebuf);
 193    if (fbuf != NULL)
 194       Fclose(fbuf);
 195    NYD_LEAVE;
 196    return ret;
 197 }
 198
 199 static void
 200 _collect_onpipe(int signo)
 201 {
 202    NYD_X; /* Signal handler */
 203    UNUSED(signo);
 204    siglongjmp(_coll_pipejmp, 1);
 205 }
 206
 207 static void
 208 insertcommand(FILE *fp, char const *cmd)
 209 {
 210    FILE *ibuf = NULL;
 211    char const *cp;
 212    int c;
 213    NYD_ENTER;
 214
 215    cp = ok_vlook(SHELL);
 216    if (cp == NULL)
 217       cp = XSHELL;
 218
 219    if ((ibuf = Popen(cmd, "r", cp, NULL, 0)) != NULL) {
 220       while ((c = getc(ibuf)) != EOF) /* XXX bytewise, yuck! */
 221          putc(c, fp);
 222       Pclose(ibuf, TRU1);
 223    } else
 224       n_perr(cmd, 0);
 225    NYD_LEAVE;
 226 }
 227
 228 static void
 229 print_collf(FILE *cf, struct header *hp)
 230 {
 231    char *lbuf = NULL; /* TODO line pool */
 232    sighandler_type sigint;
 233    FILE * volatile obuf = stdout;
 234    struct attachment *ap;
 235    char const *cp;
 236    enum gfield gf;
 237    size_t linesize = 0, linelen, cnt, cnt2;
 238    NYD_ENTER;
 239
 240    fflush_rewind(cf);
 241    cnt = cnt2 = fsize(cf);
 242
 243    sigint = safe_signal(SIGINT, SIG_IGN);
 244
 245    if (IS_TTY_SESSION() && (cp = ok_vlook(crt)) != NULL) {
 246       size_t l, m;
 247
 248       m = 4;
 249       if (hp->h_to != NULL)
 250          ++m;
 251       if (hp->h_subject != NULL)
 252          ++m;
 253       if (hp->h_cc != NULL)
 254          ++m;
 255       if (hp->h_bcc != NULL)
 256          ++m;
 257       if (hp->h_attach != NULL)
 258          ++m;
 259       m += (hp->h_from != NULL || myaddrs(hp) != NULL);
 260       m += (hp->h_sender != NULL || ok_vlook(sender) != NULL);
 261       m += (hp->h_replyto != NULL || ok_vlook(replyto) != NULL);
 262       m += (hp->h_organization != NULL || ok_vlook(ORGANIZATION) != NULL);
 263
 264       l = (*cp == '\0') ? screensize() : atoi(cp);
 265       if (m > l)
 266          goto jpager;
 267       l -= m;
 268
 269       for (m = 0; fgetline(&lbuf, &linesize, &cnt2, NULL, cf, 0); ++m)
 270          ;
 271       rewind(cf);
 272       if (l < m) {
 273 jpager:
 274          cp = get_pager(NULL);
 275          if (sigsetjmp(_coll_pipejmp, 1))
 276             goto jendpipe;
 277          obuf = Popen(cp, "w", NULL, NULL, 1);
 278          if (obuf == NULL) {
 279             n_perr(cp, 0);
 280             obuf = stdout;
 281          } else
 282             safe_signal(SIGPIPE, &_collect_onpipe);
 283       }
 284    }
 285
 286    fprintf(obuf, _("-------\nMessage contains:\n"));
 287    gf = GIDENT | GTO | GSUBJECT | GCC | GBCC | GNL | GFILES | GCOMMA;
 288    puthead(hp, obuf, gf, SEND_TODISP, CONV_NONE, NULL, NULL);
 289    while (fgetline(&lbuf, &linesize, &cnt, &linelen, cf, 1))
 290       prout(lbuf, linelen, obuf);
 291    if (hp->h_attach != NULL) {
 292       fputs(_("-------\nAttachments:\n"), obuf);
 293       for (ap = hp->h_attach; ap != NULL; ap = ap->a_flink) {
 294          if (ap->a_msgno)
 295             fprintf(obuf, " - message %u\n", ap->a_msgno);
 296          else {
 297             /* TODO after MIME/send layer rewrite we *know*
 298              * TODO the details of the attachment here,
 299              * TODO so adjust this again, then */
 300             char const *cs, *csi = "-> ";
 301
 302             if ((cs = ap->a_charset) == NULL &&
 303                   (csi = "<- ", cs = ap->a_input_charset) == NULL)
 304                cs = charset_get_lc();
 305             if ((cp = ap->a_content_type) == NULL)
 306                cp = "?";
 307             else if (ascncasecmp(cp, "text/", 5))
 308                csi = "";
 309             fprintf(obuf, " - [%s, %s%s] %s\n", cp, csi, cs, ap->a_name);
 310          }
 311       }
 312    }
 313
 314 jendpipe:
 315    if (obuf != stdout) {
 316       safe_signal(SIGPIPE, SIG_IGN);
 317       Pclose(obuf, TRU1);
 318       safe_signal(SIGPIPE, dflpipe);
 319    }
 320    if (lbuf != NULL)
 321       free(lbuf);
 322    safe_signal(SIGINT, sigint);
 323    NYD_LEAVE;
 324 }
 325
 326 static int
 327 exwrite(char const *name, FILE *fp, int f)
 328 {
 329    FILE *of;
 330    int c, lc, rv = -1;
 331    long cc;
 332    NYD_ENTER;
 333
 334    if (f) {
 335       printf("\"%s\" ", name);
 336       fflush(stdout);
 337    }
 338    if ((of = Fopen(name, "a")) == NULL) {
 339       n_perr(NULL, 0);
 340       goto jleave;
 341    }
 342
 343    lc = 0;
 344    cc = 0;
 345    while ((c = getc(fp)) != EOF) {
 346       ++cc;
 347       if (c == '\n')
 348          ++lc;
 349       putc(c, of);
 350       if (ferror(of)) {
 351          n_perr(name, 0);
 352          Fclose(of);
 353          goto jleave;
 354       }
 355    }
 356    Fclose(of);
 357    printf(_("%d/%ld\n"), lc, cc);
 358    fflush(stdout);
 359    rv = 0;
 360 jleave:
 361    NYD_LEAVE;
 362    return rv;
 363 }
 364
 365 static enum okay
 366 makeheader(FILE *fp, struct header *hp, si8_t *checkaddr_err)
 367 {
 368    FILE *nf;
 369    int c;
 370    enum okay rv = STOP;
 371    NYD_ENTER;
 372
 373    if ((nf = Ftmp(NULL, "colhead", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==NULL) {
 374       n_perr(_("temporary mail edit file"), 0);
 375       goto jleave;
 376    }
 377
 378    extract_header(fp, hp, checkaddr_err);
 379
 380    while ((c = getc(fp)) != EOF) /* XXX bytewise, yuck! */
 381       putc(c, nf);
 382    if (fp != _coll_fp)
 383       Fclose(_coll_fp);
 384    Fclose(fp);
 385    _coll_fp = nf;
 386    if (check_from_and_sender(hp->h_from, hp->h_sender) == NULL)
 387       goto jleave;
 388    rv = OKAY;
 389 jleave:
 390    NYD_LEAVE;
 391    return rv;
 392 }
 393
 394 static void
 395 mesedit(int c, struct header *hp)
 396 {
 397    bool_t saved;
 398    sighandler_type sigint;
 399    FILE *nf;
 400    NYD_ENTER;
 401
 402    saved = ok_blook(add_file_recipients);
 403    ok_bset(add_file_recipients, TRU1);
 404
 405    sigint = safe_signal(SIGINT, SIG_IGN);
 406    nf = run_editor(_coll_fp, (off_t)-1, c, 0, hp, NULL, SEND_MBOX, sigint);
 407    if (nf != NULL) {
 408       if (hp) {
 409          rewind(nf);
 410          makeheader(nf, hp, NULL);
 411       } else {
 412          fseek(nf, 0L, SEEK_END);
 413          Fclose(_coll_fp);
 414          _coll_fp = nf;
 415       }
 416    }
 417    safe_signal(SIGINT, sigint);
 418
 419    ok_bset(add_file_recipients, saved);
 420    NYD_LEAVE;
 421 }
 422
 423 static void
 424 mespipe(char *cmd)
 425 {
 426    FILE *nf;
 427    sighandler_type sigint;
 428    char const *sh;
 429    NYD_ENTER;
 430
 431    sigint = safe_signal(SIGINT, SIG_IGN);
 432
 433    if ((nf = Ftmp(NULL, "colpipe", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==NULL) {
 434       n_perr(_("temporary mail edit file"), 0);
 435       goto jout;
 436    }
 437
 438    /* stdin = current message.  stdout = new message */
 439    if ((sh = ok_vlook(SHELL)) == NULL)
 440       sh = XSHELL;
 441    fflush(_coll_fp);
 442    if (run_command(sh, 0, fileno(_coll_fp), fileno(nf), "-c", cmd, NULL, NULL)
 443          < 0) {
 444       Fclose(nf);
 445       goto jout;
 446    }
 447
 448    if (fsize(nf) == 0) {
 449       n_err(_("No bytes from \"%s\" !?\n"), cmd);
 450       Fclose(nf);
 451       goto jout;
 452    }
 453
 454    /* Take new files */
 455    fseek(nf, 0L, SEEK_END);
 456    Fclose(_coll_fp);
 457    _coll_fp = nf;
 458 jout:
 459    safe_signal(SIGINT, sigint);
 460    NYD_LEAVE;
 461 }
 462
 463 static int
 464 forward(char *ms, FILE *fp, int f)
 465 {
 466    int *msgvec, rv = 0;
 467    struct ignoretab *ig;
 468    char const *tabst;
 469    enum sendaction action;
 470    NYD_ENTER;
 471
 472    msgvec = salloc((size_t)(msgCount + 1) * sizeof *msgvec);
 473    if (getmsglist(ms, msgvec, 0) < 0)
 474       goto jleave;
 475    if (*msgvec == 0) {
 476       *msgvec = first(0, MMNORM);
 477       if (*msgvec == 0) {
 478          n_err(_("No appropriate messages\n"));
 479          goto jleave;
 480       }
 481       msgvec[1] = 0;
 482    }
 483
 484    if (f == 'f' || f == 'F' || f == 'u')
 485       tabst = NULL;
 486    else if ((tabst = ok_vlook(indentprefix)) == NULL)
 487       tabst = INDENT_DEFAULT;
 488    if (f == 'u' || f == 'U')
 489       ig = allignore;
 490    else
 491       ig = upperchar(f) ? NULL : ignore;
 492    action = (upperchar(f) && f != 'U') ? SEND_QUOTE_ALL : SEND_QUOTE;
 493
 494    printf(_("Interpolating:"));
 495    for (; *msgvec != 0; ++msgvec) {
 496       struct message *mp = message + *msgvec - 1;
 497
 498       touch(mp);
 499       printf(" %d", *msgvec);
 500       fflush(stdout);
 501       if (sendmp(mp, fp, ig, tabst, action, NULL) < 0) {
 502          n_perr(_("temporary mail file"), 0);
 503          rv = -1;
 504          break;
 505       }
 506    }
 507    printf("\n");
 508 jleave:
 509    NYD_LEAVE;
 510    return rv;
 511 }
 512
 513 static void
 514 collstop(int s)
 515 {
 516    sighandler_type old_action;
 517    sigset_t nset;
 518    NYD_X; /* Signal handler */
 519
 520    old_action = safe_signal(s, SIG_DFL);
 521
 522    sigemptyset(&nset);
 523    sigaddset(&nset, s);
 524    sigprocmask(SIG_UNBLOCK, &nset, NULL);
 525    n_raise(s);
 526    sigprocmask(SIG_BLOCK, &nset, NULL);
 527
 528    safe_signal(s, old_action);
 529    if (_coll_jmp_p) {
 530       _coll_jmp_p = 0;
 531       _coll_hadintr = 0;
 532       siglongjmp(_coll_jmp, 1);
 533    }
 534 }
 535
 536 static void
 537 _collint(int s)
 538 {
 539    NYD_X; /* Signal handler */
 540
 541    /* the control flow is subtle, because we can be called from ~q */
 542    if (_coll_hadintr == 0) {
 543       if (ok_blook(ignore)) {
 544          puts("@");
 545          fflush(stdout);
 546          clearerr(stdin);
 547       } else
 548          _coll_hadintr = 1;
 549       siglongjmp(_coll_jmp, 1);
 550    }
 551    exit_status |= EXIT_SEND_ERROR;
 552    if (s != 0)
 553       savedeadletter(_coll_fp, 1);
 554    /* Aborting message, no need to fflush() .. */
 555    siglongjmp(_coll_abort, 1);
 556 }
 557
 558 static void
 559 collhup(int s)
 560 {
 561    NYD_X; /* Signal handler */
 562    UNUSED(s);
 563
 564    savedeadletter(_coll_fp, 1);
 565    /* Let's pretend nobody else wants to clean up, a true statement at
 566     * this time */
 567    exit(EXIT_ERR);
 568 }
 569
 570 static int
 571 putesc(char const *s, FILE *stream)
 572 {
 573    int n = 0, rv = -1;
 574    NYD_ENTER;
 575
 576    while (s[0] != '\0') {
 577       if (s[0] == '\\') {
 578          if (s[1] == 't') {
 579             if (putc('\t', stream) == EOF)
 580                goto jleave;
 581             ++n;
 582             s += 2;
 583             continue;
 584          }
 585          if (s[1] == 'n') {
 586             if (putc('\n', stream) == EOF)
 587                goto jleave;
 588             ++n;
 589             s += 2;
 590             continue;
 591          }
 592       }
 593       if (putc(s[0], stream) == EOF)
 594          goto jleave;
 595       ++n;
 596       ++s;
 597    }
 598    if (putc('\n', stream) == EOF)
 599       goto jleave;
 600    rv = ++n;
 601 jleave:
 602    NYD_LEAVE;
 603    return rv;
 604 }
 605
 606 FL FILE *
 607 collect(struct header *hp, int printheaders, struct message *mp,
 608    char *quotefile, int doprefix, si8_t *checkaddr_err)
 609 {
 610    struct ignoretab *quoteig;
 611    int lc, cc, c, t;
 612    int volatile escape, getfields;
 613    char *linebuf, *quote;
 614    char const *cp;
 615    size_t i, linesize; /* TODO line pool */
 616    long cnt;
 617    enum sendaction action;
 618    sigset_t oset, nset;
 619    sighandler_type savedtop;
 620    FILE * volatile sigfp;
 621    NYD_ENTER;
 622
 623    _coll_fp = NULL;
 624    sigfp = NULL;
 625    linesize = 0;
 626    linebuf = quote = NULL;
 627
 628    /* Start catching signals from here, but we're still die on interrupts
 629     * until we're in the main loop */
 630    sigemptyset(&nset);
 631    sigaddset(&nset, SIGINT);
 632    sigaddset(&nset, SIGHUP);
 633    sigprocmask(SIG_BLOCK, &nset, &oset);
 634    handlerpush(&_collint);
 635    if ((_coll_saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
 636       safe_signal(SIGINT, &_collint);
 637    if ((_coll_savehup = safe_signal(SIGHUP, SIG_IGN)) != SIG_IGN)
 638       safe_signal(SIGHUP, collhup);
 639    /* TODO We do a lot of redundant signal handling, especially
 640     * TODO with the command line editor(s); try to merge this */
 641    _coll_savetstp = safe_signal(SIGTSTP, collstop);
 642    _coll_savettou = safe_signal(SIGTTOU, collstop);
 643    _coll_savettin = safe_signal(SIGTTIN, collstop);
 644    if (sigsetjmp(_coll_abort, 1))
 645       goto jerr;
 646    if (sigsetjmp(_coll_jmp, 1))
 647       goto jerr;
 648    sigprocmask(SIG_SETMASK, &oset, (sigset_t*)NULL);
 649
 650    ++noreset;
 651    if ((_coll_fp = Ftmp(NULL, "collect", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
 652          NULL) {
 653       n_perr(_("temporary mail file"), 0);
 654       goto jerr;
 655    }
 656
 657    if ((cp = ok_vlook(NAIL_HEAD)) != NULL && putesc(cp, _coll_fp) < 0)
 658       goto jerr;
 659
 660    /* If we are going to prompt for a subject, refrain from printing a newline
 661     * after the headers (since some people mind) */
 662    getfields = 0;
 663    if (!(options & OPT_t_FLAG)) {
 664       t = GTO | GSUBJECT | GCC | GNL;
 665       if (ok_blook(fullnames))
 666          t |= GCOMMA;
 667
 668       if (options & OPT_INTERACTIVE) {
 669          if (hp->h_subject == NULL && (ok_blook(ask) || ok_blook(asksub)))
 670             t &= ~GNL, getfields |= GSUBJECT;
 671
 672          if (hp->h_to == NULL)
 673             t &= ~GNL, getfields |= GTO;
 674
 675          if (!ok_blook(bsdcompat) && !ok_blook(askatend)) {
 676             if (hp->h_bcc == NULL && ok_blook(askbcc))
 677                t &= ~GNL, getfields |= GBCC;
 678             if (hp->h_cc == NULL && ok_blook(askcc))
 679                t &= ~GNL, getfields |= GCC;
 680          }
 681       }
 682
 683       if (printheaders && !ok_blook(editalong)) {
 684          puthead(hp, stdout, t, SEND_TODISP, CONV_NONE, NULL, NULL);
 685          fflush(stdout);
 686       }
 687    }
 688
 689    /* Quote an original message */
 690    if (mp != NULL && (doprefix || (quote = ok_vlook(quote)) != NULL)) {
 691       quoteig = allignore;
 692       action = SEND_QUOTE;
 693       if (doprefix) {
 694          quoteig = fwdignore;
 695          if ((cp = ok_vlook(fwdheading)) == NULL)
 696             cp = "-------- Original Message --------";
 697          if (*cp != '\0' && fprintf(_coll_fp, "%s\n", cp) < 0)
 698             goto jerr;
 699       } else if (!strcmp(quote, "noheading")) {
 700          /*EMPTY*/;
 701       } else if (!strcmp(quote, "headers")) {
 702          quoteig = ignore;
 703       } else if (!strcmp(quote, "allheaders")) {
 704          quoteig = NULL;
 705          action = SEND_QUOTE_ALL;
 706       } else {
 707          cp = hfield1("from", mp);
 708          if (cp != NULL && (cnt = (long)strlen(cp)) > 0) {
 709             if (xmime_write(cp, cnt, _coll_fp, CONV_FROMHDR, TD_NONE) < 0)
 710                goto jerr;
 711             if (fprintf(_coll_fp, _(" wrote:\n\n")) < 0)
 712                goto jerr;
 713          }
 714       }
 715       if (fflush(_coll_fp))
 716          goto jerr;
 717       if (doprefix)
 718          cp = NULL;
 719       else if ((cp = ok_vlook(indentprefix)) == NULL)
 720          cp = INDENT_DEFAULT;
 721       if (sendmp(mp, _coll_fp, quoteig, cp, action, NULL) < 0)
 722          goto jerr;
 723    }
 724
 725    /* Print what we have sofar also on the terminal (if useful) */
 726    if ((options & OPT_INTERACTIVE) && !ok_blook(editalong)) {
 727       rewind(_coll_fp);
 728       while ((c = getc(_coll_fp)) != EOF) /* XXX bytewise, yuck! */
 729          putc(c, stdout);
 730       if (fseek(_coll_fp, 0, SEEK_END))
 731          goto jerr;
 732       /* Ensure this is clean xxx not really necessary? */
 733       fflush(stdout);
 734    }
 735
 736    escape = ((cp = ok_vlook(escape)) != NULL) ? *cp : ESCAPE;
 737    _coll_hadintr = 0;
 738
 739    if (!sigsetjmp(_coll_jmp, 1)) {
 740       if (getfields)
 741          grab_headers(hp, getfields, 1);
 742       if (quotefile != NULL) {
 743          if (_include_file(quotefile, &lc, &cc, TRU1, FAL0) != 0)
 744             goto jerr;
 745       }
 746       if ((options & OPT_INTERACTIVE) && ok_blook(editalong)) {
 747          rewind(_coll_fp);
 748          mesedit('e', hp);
 749          goto jcont;
 750       }
 751    } else {
 752       /* Come here for printing the after-signal message.  Duplicate messages
 753        * won't be printed because the write is aborted if we get a SIGTTOU */
 754       if (_coll_hadintr) {
 755          n_err(_("\n(Interrupt -- one more to kill letter)\n"));
 756       } else {
 757 jcont:
 758          printf(_("(continue)\n"));
 759          fflush(stdout);
 760       }
 761    }
 762
 763    /* No tilde escapes, interrupts not expected.  Simply copy STDIN */
 764    if (!(options & (OPT_INTERACTIVE | OPT_t_FLAG | OPT_TILDE_FLAG))) {
 765       linebuf = srealloc(linebuf, linesize = LINESIZE);
 766       while ((i = fread(linebuf, sizeof *linebuf, linesize, stdin)) > 0) {
 767          if (i != fwrite(linebuf, sizeof *linebuf, i, _coll_fp))
 768             goto jerr;
 769       }
 770       goto jout;
 771    }
 772
 773    /* The interactive collect loop.
 774     * All commands which come here are forbidden when sourcing! */
 775    assert(_coll_hadintr || !(pstate & PS_SOURCING));
 776    for (;;) {
 777       _coll_jmp_p = 1;
 778       cnt = readline_input("", FAL0, &linebuf, &linesize, NULL);
 779       _coll_jmp_p = 0;
 780
 781       if (cnt < 0) {
 782          assert(!(pstate & PS_SOURCING));
 783          if (options & OPT_t_FLAG) {
 784             fflush_rewind(_coll_fp);
 785             /* It is important to set PS_t_FLAG before extract_header() *and*
 786              * keep OPT_t_FLAG for the first parse of the message, too! */
 787             pstate |= PS_t_FLAG;
 788             if (makeheader(_coll_fp, hp, checkaddr_err) != OKAY)
 789                goto jerr;
 790             options &= ~OPT_t_FLAG;
 791             continue;
 792          } else if ((options & OPT_INTERACTIVE) && ok_blook(ignoreeof)) {
 793             printf(_("*ignoreeof* set, use \"~.\" to terminate letter\n"));
 794             continue;
 795          }
 796          break;
 797       }
 798
 799       _coll_hadintr = 0;
 800
 801       if (cnt == 0 || !(options & (OPT_INTERACTIVE | OPT_TILDE_FLAG))) {
 802 jputline:
 803          /* TODO calls putline(), which *always* appends LF;
 804           * TODO thus, STDIN with -t will ALWAYS end with LF,
 805           * TODO even if no trailing LF and QP encoding.
 806           * TODO when finally changed, update cc-test.sh */
 807          if (putline(_coll_fp, linebuf, cnt) < 0)
 808             goto jerr;
 809          continue;
 810       } else if (linebuf[0] == '.') {
 811          if (linebuf[1] == '\0' && (ok_blook(dot) || ok_blook(ignoreeof)))
 812             break;
 813       }
 814       if (linebuf[0] != escape)
 815          goto jputline;
 816
 817       if (!(options & OPT_t_FLAG))
 818          tty_addhist(linebuf, TRU1);
 819
 820       c = linebuf[1];
 821       switch (c) {
 822       default:
 823          /* On double escape, send a single one.  Otherwise, it's an error */
 824          if (c == escape) {
 825             if (putline(_coll_fp, linebuf + 1, cnt - 1) < 0)
 826                goto jerr;
 827             else
 828                break;
 829          }
 830          n_err(_("Unknown tilde escape: ~%c\n"), asciichar(c) ? c : '?');
 831          break;
 832       case '!':
 833          /* Shell escape, send the balance of line to sh -c */
 834          c_shell(linebuf + 2);
 835          break;
 836       case ':':
 837          /* FALLTHRU */
 838       case '_':
 839          /* Escape to command mode, but be nice! */
 840          _execute_command(hp, linebuf + 2, cnt - 2);
 841          goto jcont;
 842       case '.':
 843          /* Simulate end of file on input */
 844          goto jout;
 845       case 'x':
 846          /* Same as 'q', but no *DEAD* saving */
 847          /* FALLTHRU */
 848       case 'q':
 849          /* Force a quit, act like an interrupt had happened */
 850          ++_coll_hadintr;
 851          _collint((c == 'x') ? 0 : SIGINT);
 852          exit(EXIT_ERR);
 853          /*NOTREACHED*/
 854       case 'h':
 855          /* Grab a bunch of headers */
 856          do
 857             grab_headers(hp, GTO | GSUBJECT | GCC | GBCC,
 858                   (ok_blook(bsdcompat) && ok_blook(bsdorder)));
 859          while (hp->h_to == NULL);
 860          goto jcont;
 861       case 'H':
 862          /* Grab extra headers */
 863          do
 864             grab_headers(hp, GEXTRA, 0);
 865          while (check_from_and_sender(hp->h_from, hp->h_sender) == NULL);
 866          goto jcont;
 867       case 't':
 868          /* Add to the To list */
 869          hp->h_to = cat(hp->h_to,
 870                checkaddrs(lextract(linebuf + 2, GTO | GFULL), EACM_NORMAL,
 871                   NULL));
 872          break;
 873       case 's':
 874          /* Set the Subject list */
 875          cp = linebuf + 2;
 876          while (whitechar(*cp))
 877             ++cp;
 878          hp->h_subject = savestr(cp);
 879          break;
 880 #ifdef HAVE_DEBUG
 881       case 'S':
 882          c_sstats(NULL);
 883          break;
 884 #endif
 885       case '@':
 886          /* Edit the attachment list */
 887          if (linebuf[2] != '\0')
 888             append_attachments(&hp->h_attach, linebuf + 2);
 889          else
 890             edit_attachments(&hp->h_attach);
 891          break;
 892       case 'c':
 893          /* Add to the CC list */
 894          hp->h_cc = cat(hp->h_cc,
 895                checkaddrs(lextract(linebuf + 2, GCC | GFULL), EACM_NORMAL,
 896                NULL));
 897          break;
 898       case 'b':
 899          /* Add stuff to blind carbon copies list */
 900          hp->h_bcc = cat(hp->h_bcc,
 901                checkaddrs(lextract(linebuf + 2, GBCC | GFULL), EACM_NORMAL,
 902                   NULL));
 903          break;
 904       case 'd':
 905          strncpy(linebuf + 2, getdeadletter(), linesize - 2);
 906          linebuf[linesize - 1] = '\0';
 907          /*FALLTHRU*/
 908       case 'R':
 909       case 'r':
 910       case '<':
 911          /* Invoke a file: Search for the file name, then open it and copy the
 912           * contents to _coll_fp */
 913          cp = linebuf + 2;
 914          while (whitechar(*cp))
 915             ++cp;
 916          if (*cp == '\0') {
 917             n_err(_("Interpolate what file?\n"));
 918             break;
 919          }
 920          if (*cp == '!') {
 921             insertcommand(_coll_fp, cp + 1);
 922             break;
 923          }
 924          if ((cp = file_expand(cp)) == NULL)
 925             break;
 926          if (is_dir(cp)) {
 927             n_err(_("\"%s\": Directory\n"), cp);
 928             break;
 929          }
 930          printf(_("\"%s\" "), cp);
 931          fflush(stdout);
 932          if (_include_file(cp, &lc, &cc, FAL0, (c == 'R')) != 0)
 933             goto jerr;
 934          printf(_("%d/%d\n"), lc, cc);
 935          break;
 936       case 'i':
 937          /* Insert a variable into the file */
 938          cp = linebuf + 2;
 939          while (whitechar(*cp))
 940             ++cp;
 941          if ((cp = vok_vlook(cp)) == NULL || *cp == '\0')
 942             break;
 943          if (putesc(cp, _coll_fp) < 0)
 944             goto jerr;
 945          if ((options & OPT_INTERACTIVE) && putesc(cp, stdout) < 0)
 946             goto jerr;
 947          break;
 948       case 'a':
 949       case 'A':
 950          /* Insert the contents of a signature variable */
 951          cp = (c == 'a') ? ok_vlook(sign) : ok_vlook(Sign);
 952          if (cp != NULL && *cp != '\0') {
 953             if (putesc(cp, _coll_fp) < 0)
 954                goto jerr;
 955             if ((options & OPT_INTERACTIVE) && putesc(cp, stdout) < 0)
 956                goto jerr;
 957          }
 958          break;
 959       case 'w':
 960          /* Write the message on a file */
 961          cp = linebuf + 2;
 962          while (blankchar(*cp))
 963             ++cp;
 964          if (*cp == '\0' || (cp = file_expand(cp)) == NULL) {
 965             n_err(_("Write what file!?\n"));
 966             break;
 967          }
 968          rewind(_coll_fp);
 969          if (exwrite(cp, _coll_fp, 1) < 0)
 970             goto jerr;
 971          break;
 972       case 'm':
 973       case 'M':
 974       case 'f':
 975       case 'F':
 976       case 'u':
 977       case 'U':
 978          /* Interpolate the named messages, if we are in receiving mail mode.
 979           * Does the standard list processing garbage.  If ~f is given, we
 980           * don't shift over */
 981          if (forward(linebuf + 2, _coll_fp, c) < 0)
 982             goto jerr;
 983          goto jcont;
 984       case 'p':
 985          /* Print current state of the message without altering anything */
 986          print_collf(_coll_fp, hp);
 987          goto jcont;
 988       case '|':
 989          /* Pipe message through command. Collect output as new message */
 990          rewind(_coll_fp);
 991          mespipe(linebuf + 2);
 992          goto jcont;
 993       case 'v':
 994       case 'e':
 995          /* Edit the current message.  'e' -> use EDITOR, 'v' -> use VISUAL */
 996          rewind(_coll_fp);
 997          mesedit(c, ok_blook(editheaders) ? hp : NULL);
 998          goto jcont;
 999       case '?':
1000          /* Last the lengthy help string.  (Very ugly, but take care for
1001           * compiler supported string lengths :() */
1002          puts(_(
1003 "TILDE ESCAPES (to be placed after a newline) excerpt:\n"
1004 "~.            Commit and send message\n"
1005 "~: <command>  Execute a mail command\n"
1006 "~<! <command> Insert output of command\n"
1007 "~@ [<files>]  Edit attachment list\n"
1008 "~A            Insert *Sign* variable (`~a' inserts *sign*)\n"
1009 "~c <users>    Add users to Cc: list (`~b' for Bcc:)\n"
1010 "~d            Read in *DEAD* (dead.letter)\n"
1011 "~e            Edit message via *EDITOR*"
1012          ));
1013          puts(_(
1014 "~F <msglist>  Read in with headers, don't *indentprefix* lines\n"
1015 "~f <msglist>  Like ~F, but honour `ignore' / `retain' configuration\n"
1016 "~H            Edit From:, Reply-To: and Sender:\n"
1017 "~h            Prompt for Subject:, To:, Cc: and \"blind\" Bcc:\n"
1018 "~i <variable> Insert a value and a newline\n"
1019 "~M <msglist>  Read in with headers, *indentprefix* (`~m': `retain' etc.)\n"
1020 "~p            Print current message compose buffer\n"
1021 "~r <file>     Read in a file (`~R' *indentprefix* lines)"
1022          ));
1023          puts(_(
1024 "~s <subject>  Set Subject:\n"
1025 "~t <users>    Add users to To: list\n"
1026 "~u <msglist>  Read in message(s) without headers (`~U' indents lines)\n"
1027 "~v            Edit message via *VISUAL*\n"
1028 "~w <file>     Write message onto file\n"
1029 "~x            Abort composition, discard message (`~q' saves in *DEAD*)\n"
1030 "~| <command>  Pipe message through shell filter"
1031          ));
1032          break;
1033       }
1034    }
1035
1036 jout:
1037    /* Place signature? */
1038    if((cp = ok_vlook(signature)) != NULL && *cp != '\0'){
1039       if((quote = file_expand(cp)) == NULL){
1040          n_err(_("*signature* expands to invalid file: \"%s\"\n"), cp);
1041          goto jerr;
1042       }
1043       if((sigfp = Fopen(cp = quote, "r")) == NULL){
1044          n_err(_("Can't open *signature* \"%s\": %s\n"), cp, strerror(errno));
1045          goto jerr;
1046       }
1047
1048       if(linebuf == NULL)
1049          linebuf = smalloc(linesize = LINESIZE);
1050       c = '\0';
1051       while((i = fread(linebuf, sizeof *linebuf, linesize, UNVOLATILE(sigfp)))
1052             > 0){
1053          c = linebuf[i - 1];
1054          if(i != fwrite(linebuf, sizeof *linebuf, i, _coll_fp))
1055             goto jerr;
1056       }
1057
1058       /* C99 */{
1059          FILE *x = UNVOLATILE(sigfp);
1060          int e = errno, ise = ferror(x);
1061
1062          sigfp = NULL;
1063          Fclose(x);
1064
1065          if(ise){
1066             n_err(_("Errors while reading *signature* \"%s\": %s\n"),
1067                cp, strerror(e));
1068             goto jerr;
1069          }
1070       }
1071
1072       if(c != '\0' && c != '\n')
1073          putc('\n', _coll_fp);
1074    }
1075
1076    if(fflush(_coll_fp))
1077       goto jerr;
1078
1079    if ((cp = ok_vlook(NAIL_TAIL)) != NULL) {
1080       if (putesc(cp, _coll_fp) < 0)
1081          goto jerr;
1082       if ((options & OPT_INTERACTIVE) && putesc(cp, stdout) < 0)
1083          goto jerr;
1084    }
1085    rewind(_coll_fp);
1086
1087 jleave:
1088    if (linebuf != NULL)
1089       free(linebuf);
1090    handlerpop();
1091    --noreset;
1092    sigemptyset(&nset);
1093    sigaddset(&nset, SIGINT);
1094    sigaddset(&nset, SIGHUP);
1095    sigprocmask(SIG_BLOCK, &nset, NULL);
1096    safe_signal(SIGINT, _coll_saveint);
1097    safe_signal(SIGHUP, _coll_savehup);
1098    safe_signal(SIGTSTP, _coll_savetstp);
1099    safe_signal(SIGTTOU, _coll_savettou);
1100    safe_signal(SIGTTIN, _coll_savettin);
1101    sigprocmask(SIG_SETMASK, &oset, NULL);
1102    NYD_LEAVE;
1103    return _coll_fp;
1104
1105 jerr:
1106    if(sigfp != NULL)
1107       Fclose(UNVOLATILE(sigfp));
1108    if (_coll_fp != NULL) {
1109       Fclose(_coll_fp);
1110       _coll_fp = NULL;
1111    }
1112    goto jleave;
1113 }
1114
1115 FL void
1116 savedeadletter(FILE *fp, int fflush_rewind_first)
1117 {
1118    char const *cp;
1119    int c;
1120    FILE *dbuf;
1121    ul_i lines, bytes;
1122    NYD_ENTER;
1123
1124    if ((options & OPT_DEBUG) || !ok_blook(save))
1125       goto jleave;
1126
1127    if (fflush_rewind_first) {
1128       fflush(fp);
1129       rewind(fp);
1130    }
1131    if (fsize(fp) == 0)
1132       goto jleave;
1133
1134    cp = getdeadletter();
1135    c = umask(077);
1136    dbuf = Fopen(cp, "a");
1137    umask(c);
1138    if (dbuf == NULL)
1139       goto jleave;
1140
1141    really_rewind(fp);
1142
1143    printf("\"%s\" ", cp);
1144    for (lines = bytes = 0; (c = getc(fp)) != EOF; ++bytes) {
1145       putc(c, dbuf);
1146       if (c == '\n')
1147          ++lines;
1148    }
1149    printf("%lu/%lu\n", lines, bytes);
1150
1151    Fclose(dbuf);
1152    rewind(fp);
1153 jleave:
1154    NYD_LEAVE;
1155 }
1156
1157 /* s-it-mode */