cmd/mailx/collect.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2006 The Regents of the University of California an*
*                                                                      *
* Redistribution and use in source and binary forms, with or           *
* without modification, are permitted provided that the following      *
* conditions are met:                                                  *
*                                                                      *
*    1. Redistributions of source code must retain the above           *
*       copyright notice, this list of conditions and the              *
*       following disclaimer.                                          *
*                                                                      *
*    2. Redistributions in binary form must reproduce the above        *
*       copyright notice, this list of conditions and the              *
*       following disclaimer in the documentation and/or other         *
*       materials provided with the distribution.                      *
*                                                                      *
*    3. Neither the name of The Regents of the University of California*
*       names of its contributors may be used to endorse or            *
*       promote products derived from this software without            *
*       specific prior written permission.                             *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND               *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,          *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF             *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE             *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS    *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,             *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED      *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        *
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    *
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,      *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY       *
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE              *
* POSSIBILITY OF SUCH DAMAGE.                                          *
*                                                                      *
* Redistribution and use in source and binary forms, with or without   *
* modification, are permitted provided that the following conditions   *
* are met:                                                             *
* 1. Redistributions of source code must retain the above copyright    *
*    notice, this list of conditions and the following disclaimer.     *
* 2. Redistributions in binary form must reproduce the above copyright *
*    notice, this list of conditions and the following disclaimer in   *
*    the documentation and/or other materials provided with the        *
*    distribution.                                                     *
* 3. Neither the name of the University nor the names of its           *
*    contributors may be used to endorse or promote products derived   *
*    from this software without specific prior written permission.     *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"    *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED    *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A      *
* PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS    *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF     *
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND  *
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT   *
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *
* SUCH DAMAGE.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Mail -- a mail program
 *
 * Collect input from standard input, handling ~ escapes.
 */

#include "mailx.h"

#define CODE_64     (1<<0)
#define CODE_QP     (1<<1)
#define CODE_TEXT   (1<<2)

#define PART_INIT   0
#define PART_MAIN   1
#define PART_DATA   2

/*
 * On interrupt, come here to save the partial message in ~/dead.letter.
 * Then jump out of the collection loop.
 */
/*ARGSUSED*/
static void
collint(int sig)
{
    /*
     * the control flow is subtle, because we can be called from ~q.
     */
    if (!state.collect.hadintr) {
        if (state.var.ignore) {
            puts("@");
            fflush(stdout);
            clearerr(stdin);
            return;
        }
        state.collect.hadintr = 1;
        longjmp(state.collect.work, sig);
    }
    rewind(state.collect.fp);
    if (state.var.save)
        savedeadletter(state.collect.fp);
    longjmp(state.collect.abort, sig);
}

/*ARGSUSED*/
static void
collhup(int sig)
{
    rewind(state.collect.fp);
    savedeadletter(state.collect.fp);
    /*
     * Let's pretend nobody else wants to clean up,
     * a true statement at this time.
     */
    exit(1);
}

/*
 * Print (continue) when continued after ^Z.
 */
/*ARGSUSED*/
static void
collstop(int sig)
{
    sig_t   old_action = signal(sig, SIG_DFL);

    kill(getpid(), sig);
    signal(sig, old_action);
    if (state.collect.working) {
        state.collect.working = 0;
        state.collect.hadintr = 0;
        longjmp(state.collect.work, sig);
    }
}

/*
 * Write a file, ex-like if f set.
 */
static int
exwrite(char* name, FILE* fp, int f)
{
    register FILE*  of;
    off_t       cc;
    off_t       lc;

    if (f)
        note(PROMPT, "\"%s\" ", name);
    if (isreg(name)) {
        if (!f)
            note(PROMPT, "\"%s\" ", name);
        note(0, "[File exists]");
        return -1;
    }
    if (!(of = fileopen(name, "Ew")))
        return -1;
    if (filecopy(NiL, fp, name, of, NiL, (off_t)0, &lc, &cc, 0)) {
        fileclose(of);
        return -1;
    }
    fileclose(of);
    note(0, "%ld/%ld", (long)lc, (long)cc);
    return 0;
}

/*
 * Edit the message on state.collect.fp.
 * On return, make the edit file the new temp file.
 */
static void
editmessage(struct header* hp, int c)
{
    sig_t   sigint;
    FILE*   fp;

    sigint = signal(SIGINT, SIG_IGN);
    if (fp = run_editor(state.collect.fp, (off_t)-1, hp, c, 0)) {
        fseek(fp, (off_t)0, SEEK_END);
        fileclose(state.collect.fp);
        state.collect.fp = fp;
    }
    signal(SIGINT, sigint);
}

/*
 * Pipe the message through the command.
 * Old message is on stdin of command;
 * New message collected from stdout.
 * Sh -c must return 0 to accept the new message.
 */
static void
pipemessage(FILE* fp, char* cmd)
{
    FILE *nf;
    sig_t sigint = signal(SIGINT, SIG_IGN);

    if (!(nf = fileopen(state.tmp.edit, "Ew+")))
        goto out;
    remove(state.tmp.edit);
    /*
     * stdin = current message.
     * stdout = new message.
     */
    if (run_command(state.var.shell, 0, fileno(fp), fileno(nf), "-c", cmd, NiL) < 0) {
        fileclose(nf);
        goto out;
    }
    if (!filesize(nf)) {
        note(0, "No bytes from \"%s\" !?", cmd);
        fileclose(nf);
        goto out;
    }
    /*
     * Take new files.
     */
    fseek(nf, (off_t)0, SEEK_END);
    state.collect.fp = nf;
    fileclose(fp);
 out:
    signal(SIGINT, sigint);
}

/*
 * Return the name of the dead.letter file.
 */
static char*
deadletter(void)
{
    register char*  s;

    if ((s = expand(state.var.dead, 1)) && *s != '/') {
        sfprintf(state.path.temp, "~/%s", s);
        s = expand(struse(state.path.temp), 1);
    }
    return s;
}

/*
 * Interpolate the named messages into the current
 * message, preceding each line with a tab.
 * Return a count of the number of characters now in
 * the message, or -1 if an error is encountered writing
 * the message temporary.  The flag argument is 'm' if we
 * should shift over and 'f' if not.
 */
static int
interpolate(char* ms, FILE* fp, int f, int followup)
{
    register struct msg*    mp;
    register struct msg*    ip;
    Dt_t**          ignore;
    char*           prefix;
    unsigned long       flags;

    if (getmsglist(ms, 0) < 0)
        return 0;
    if (!state.msg.list->m_index) {
        if (!(state.msg.list->m_index = first(0, MMNORM))) {
            note(0, "No appropriate messages");
            return 0;
        }
        (state.msg.list + 1)->m_index = 0;
    }
    flags = 0;
    if (f == 'f' || f == 'F') {
        if (f == 'f')
            flags |= GINTERPOLATE|GMIME;
        prefix = 0;
    }
    else if (!(prefix = state.var.indentprefix))
        prefix = "\t";
    ignore = isupper(f) ? (Dt_t**)0 : &state.ignore;
    if (!followup)
        printf("Interpolating:");
    for (ip = state.msg.list; ip->m_index; ip++) {
        mp = state.msg.list + ip->m_index - 1;
        touchmsg(mp);
        if (followup)
            flags |= GREFERENCES;
        else
            printf(" %d", ip->m_index);
        if (copy(mp, fp, ignore, prefix, flags) < 0) {
            note(SYSTEM, "%s", state.tmp.mail);
            return -1;
        }
    }
    if (!followup)
        printf("\n");
    return 0;
}

/*
 * Generate multipart boundary.
 */
void
boundary(void)
{
    if (!state.part.out.multi) {
        state.part.out.multi = 1;
        state.part.out.boundlen = sfsprintf(state.part.out.boundary, sizeof(state.part.out.boundary), "=_=_=_=_=%s==%04X==%08X==", state.var.user, getpid(), time(NiL));
    }
}

/*
 * Ouput multipart header.
 */
static void
part(FILE* fp, char* name, char* type, int code)
{
    char*   s;

    if (name && (s = strrchr(name, '/')))
        name = s + 1;
    boundary();
    fprintf(fp, "\n--%s\n", state.part.out.boundary);
    if (!type)
        type = (code & CODE_64) ? "application/octet-stream" : "text/plain";
    fprintf(fp, "Content-Type: %s", type);
    if (!mimecmp("text", type, NiL))
        fprintf(fp, "; charset=us-ascii");
    if (name)
        fprintf(fp, "; name=\"%s\"", name);
    fprintf(fp, "\nContent-Transfer-Encoding: %s\n", (code & CODE_64) ? "base64" : (code & CODE_QP) ? "quoted-printable" : "7bit");
    if (name)
        fprintf(fp, "Content-Disposition: attachment; filename=\"%s\"\n", name);
    fprintf(fp, "\n");
}

/*
 * Collect input from standard input, handling ~ escapes.
 */
FILE*
collect(struct header* hp, unsigned long flags)
{
    register char*  s;
    register int    n;
    int     ask;
    int     c;
    int     eofcount;
    int     escape;
    int     headers;
    int     code;
    int     sig;
    int     g;
    long        cc;
    long        lc;
    long        tc;
    char*       t;
    char*       e;
    FILE*       fp;
    char*       av[2];
    struct parse    pp;

    ask = 0;
    state.collect.fp = 0;
    state.part.out.multi = 0;
    headers = 0;
    /*
     * Start catching signals from here, but we'll still die on interrupts
     * until we're in the main loop.
     */
#ifdef SIGTSTP
    state.collect.sigtstp = signal(SIGTSTP, collstop);
#endif
#ifdef SIGTTOU
    state.collect.sigttou = signal(SIGTTOU, collstop);
#endif
#ifdef SIGTTIN
    state.collect.sigttin = signal(SIGTTIN, collstop);
#endif
    if ((sig = setjmp(state.collect.abort)) || (sig = setjmp(state.collect.work))) {
        resume(sig);
        rm(state.tmp.mail);
        goto err;
    }
    if ((state.collect.sigint = signal(SIGINT, SIG_IGN)) != SIG_IGN)
        signal(SIGINT, collint);
    if ((state.collect.sighup = signal(SIGHUP, SIG_IGN)) != SIG_IGN)
        signal(SIGHUP, collhup);
    state.noreset++;
    if (!(state.collect.fp = fileopen(state.tmp.mail, "Ew+")))
        goto err;
    remove(state.tmp.mail);

    pp.fp = stdin;
    if ((flags & INTERPOLATE) && interpolate("", state.collect.fp, 'm', 1) < 0)
        goto err;
    if ((flags & INTERPOLATE) && state.var.interactive) {
        rewind(state.collect.fp);
        editmessage(hp, 'v');
        note(0, "(continue)");
    }
    else {
        g = GEDIT|GNL;
        if (state.var.sendheaders) {
            headers = 1;
            flags |= HEADERS;
            g &= ~GNL;
        }
        else if (state.var.interactive && !hp->h_subject && (state.askheaders & GSUB)) {
            ask |= GSUB;
            g &= ~GNL;
        }
        if (flags & HEADERS) {
            if (flags & (FOLLOWUP|INTERPOLATE))
                g |= GREFERENCES;
            headout(stdout, hp, g);
            fflush(stdout);
        }
        if (headers)
            headset(&pp, NiL, pp.fp, hp, NiL, g|GDISPLAY);
    }
    escape = state.var.escape ? *state.var.escape : 0;
    eofcount = 0;
    state.collect.hadintr = 0;
    if (sig = setjmp(state.collect.work)) {
        /*
         * Come here for printing the after-signal message.
         * Duplicate messages won't be printed because
         * the write is aborted if we get a SIGTTOU.
         */
        resume(sig);
 cont:
        if (state.collect.hadintr)
            note(0, "\n(Interrupt -- one more to kill letter)");
        else
            note(0, "(continue)");
    }
    else if (ask)
        grabedit(hp, ask);
    for (;;) {
        state.collect.working = 1;
        if (headers) {
            if (headget(&pp))
                continue;
            headers = 0;
        }
        c = readline(pp.fp, pp.buf, sizeof(pp.buf));
        state.collect.working = 0;
        if (c < 0) {
            if (state.var.interactive &&
                state.var.ignoreeof && ++eofcount < 32) {
                note(0, "Use \".\" to terminate letter");
                continue;
            }
            break;
        }
        eofcount = 0;
        state.collect.hadintr = 0;
        if (pp.buf[0] == '.' && pp.buf[1] == 0 &&
            state.var.interactive &&
            (state.var.dot || state.var.ignoreeof))
            break;
        if (pp.buf[0] != escape || !state.var.interactive) {
            if (putline(state.collect.fp, pp.buf) < 0)
                goto err;
            continue;
        }
        c = pp.buf[1];
        switch (c) {
        case '!':
            /*
             * Shell escape, send the balance of the
             * line to sh -c.
             */
            shell(&pp.buf[2]);
            break;
        case '.':
            /*
             * Simulate end of file on input.
             */
            goto out;
        case ':':
        case '_':
            /*
             * Escape to command mode, but be nice!
             */
            execute(&pp.buf[2], 1);
            goto cont;
        case '?':
            pp.buf[1] = *state.var.escape;
            av[0] = &pp.buf[1];
            av[1] = 0;
            help(av);
            break;
        case 'A':
        case 'a':
            /*
             * Sign letter.
             */
            s = c == 'a' ? state.var.sign : state.var.Sign;
            if (s)
                goto outstr;
            if (state.var.signature && (fp = fileopen(state.var.signature, "EXr"))) {
                filecopy(state.var.signature, fp, state.var.signature, state.collect.fp, stdout, (off_t)0, NiL, NiL, 0);
                fileclose(fp);
            }
            goto cont;
        case 'b':
            /*
             * Add stuff to blind carbon copies list.
             */
            extract(hp, GBCC|GMETOO, &pp.buf[2]);
            break;
        case 'c':
            /*
             * Add to the CC list.
             */
            extract(hp, GCC|GMETOO, &pp.buf[2]);
            break;
        case 'd':
            strncopy(pp.buf + 2, deadletter(), sizeof(pp.buf) - 2);
            /* fall into . . . */
        case 'g':
        case 'r':
        case '<':
            /*
             * Invoke a file:
             * Search for the file name,
             * then open it and copy the contents
             * to state.collect.fp.
             */
            for (s = &pp.buf[2]; isspace(*s); s++);
            if (!*s || !(s = expand(s, 1))) {
                note(0, "Read what file !?");
                break;
            }
            if (c == 'g') {
                if (!(fp = fileopen(s, "ERr")))
                    break;
                code = 0;
                if (mime(1)) {
                    t = mimetype(state.part.mime, fp, s, &state.openstat);
                    if (!mimecmp("text", t, NiL))
                        code |= CODE_TEXT;
                }
                else
                    t = 0;
                cc = tc = 0;
                while ((lc = getc(fp)) != EOF) {
                    tc++;
                    if ((iscntrl(lc) || !isprint(lc)) && !isspace(lc))
                        cc++;
                }
                code |= cc ? ((cc < tc / 80) ? CODE_QP : CODE_64) : CODE_TEXT;
                part(state.collect.fp, s, t, code);
                if (!(code & (CODE_64|CODE_QP)))
                    rewind(fp);
                else {
                    fileclose(fp);
                    if (t) {
                        if (e = mimeview(state.part.mime, "compose", state.tmp.mail, t, NiL)) {
                            sfprintf(state.path.temp, "%s<%s", e, s);
                            if (state.part.disc.flags & MIME_PIPE) {
                                sfprintf(state.path.temp, "|");
                                t = 0;
                            }
                            else {
                                sfprintf(state.path.temp, ";");
                                t = state.tmp.mail;
                            }
                        }
                        else
                            t = s;
                    }
                    else
                        t = s;
                    sfprintf(state.path.temp, "uuencode -h -x %s", (code & CODE_QP) ? "quoted-printable " : "base64 ");
                    if (t)
                        shquote(state.path.temp, t);
                    sfputc(state.path.temp, ' ');
                    shquote(state.path.temp, s);
                    if (t == state.tmp.mail)
                    {
                        sfprintf(state.path.temp, "; rm -f ");
                        shquote(state.path.temp, t);
                    }
                    if (!(fp = pipeopen(struse(state.path.temp), "r")))
                        break;
                }
            }
            else if (!(fp = iscmd(s) ? pipeopen(s + 1, "r") : fileopen(s, "ERr")))
                break;
            note(PROMPT, "\"%s\" ", s);
            lc = 0;
            cc = 0;
            while (readline(fp, pp.buf, LINESIZE) >= 0) {
                lc++;
                if ((n = putline(state.collect.fp, pp.buf)) < 0) {
                    fileclose(fp);
                    goto err;
                }
                cc += n;
            }
            fileclose(fp);
            if (c == 'g')
                fprintf(state.collect.fp, "--%s--\n\n", state.part.out.boundary);
            note(0, "%d/%d", lc, cc);
            break;
        case 'e':
        case 'v':
            /*
             * Edit the current message.
             * 'e' means to use EDITOR
             * 'v' means to use VISUAL
             */
            rewind(state.collect.fp);
            editmessage(hp, c);
            goto cont;
        case 'f':
        case 'F':
        case 'm':
        case 'M':
            /*
             * Interpolate the named messages, if we
             * are in receiving mail mode.  Does the
             * standard list processing garbage.
             * If ~f is given, we don't shift over.
             */
            if (interpolate(pp.buf + 2, state.collect.fp, c, 0) < 0)
                goto err;
            goto cont;
        case 'h':
            /*
             * Grab the standard headers.
             */
            grabedit(hp, GSTD);
            goto cont;
        case 'i':
            /*
             * Insert variable value.
             */
            for (s = pp.buf + 2; isspace(*s); s++);
            s = varget(s);
            if (s) {
        outstr:
                putline(state.collect.fp, s);
                if (state.var.interactive)
                    putline(stdout, s);
            }
            goto cont;
        case 'p':
            /*
             * Print out the current state of the
             * message without altering anything.
             */
            rewind(state.collect.fp);
            fp = stdout;
            if (sig = setjmp(state.jump.sigpipe))
                resume(sig);
            else {
                if (!state.more.discipline && state.var.interactive && (lc = state.var.crt)) {
                    lc -= 5;
                    while ((c = getc(state.collect.fp)) != EOF)
                        if (c == '\n' && --lc <= 0) {
                            if (!(fp = pipeopen(state.var.pager, "Jw")))
                                fp = stdout;
                            break;
                        }
                    rewind(state.collect.fp);
                }
                fprintf(fp, "-------\nMessage contains:\n");
                headout(fp, hp, GEDIT|GNL);
                filecopy(NiL, state.collect.fp, NiL, fp, NiL, (off_t)0, NiL, NiL, 0);
            }
            fileclose(fp);
            goto cont;
        case 's':
            /*
             * Set the Subject list.
             */
            s = &pp.buf[2];
            while (isspace(*s))
                s++;
            if (hp->h_subject = savestr(s))
                hp->h_flags |= GSUB;
            break;
        case 't':
            /*
             * Add to the To list.
             */
            extract(hp, GTO|GMETOO, &pp.buf[2]);
            break;
        case 'w':
            /*
             * Write the message on a file.
             */
            s = &pp.buf[2];
            while (*s == ' ' || *s == '\t')
                s++;
            if (*s == 0) {
                note(0, "Write what file !?");
                break;
            }
            if (!(s = expand(s, 1)))
                break;
            rewind(state.collect.fp);
            exwrite(s, state.collect.fp, 1);
            break;
        case 'x':
            state.var.save = 0;
            /*FALLTHROUGH*/
        case 'q':
            /*
             * Force a quit of sending mail.
             * Act like an interrupt happened.
             */
            state.collect.hadintr++;
            collint(SIGINT);
            exit(1);
        case '|':
            /*
             * Pipe message through command.
             * Collect output as new message.
             */
            rewind(state.collect.fp);
            pipemessage(state.collect.fp, &pp.buf[2]);
            goto cont;
        default:
            /*
             * On double escape, just send the single one.
             * Otherwise, it's an error.
             */
            if (c == escape) {
                if (putline(state.collect.fp, &pp.buf[1]) < 0)
                    goto err;
                else
                    break;
            }
            if (isprint(c))
                note(0, "\"%c%c\": unknown escape command", escape, c);
            else
                note(0, "\"%c\\%03o\": unknown escape command", escape, c);
            break;
        }
    }
    goto out;
 err:
    if (state.collect.fp) {
        fileclose(state.collect.fp);
        state.collect.fp = 0;
    }
 out:
    if (state.collect.fp) {
        rewind(state.collect.fp);
        if (state.part.out.multi) {
            /*
             * Copy to a temp file adding the mime boundaries.
             */
            if (fp = fileopen(state.tmp.edit, "EMw+")) {
                fprintf(fp, "This is a multipart message in MIME format.\n");
                n = PART_INIT;
                while (s = fgets(state.path.path, sizeof(state.path.path), state.collect.fp)) {
                    if (s[0] == '-' && s[1] == '-' && !strncmp(s + 2, state.part.out.boundary, state.part.out.boundlen)) {
                        if (n == PART_INIT)
                            putc('\n', fp);
                        t = s + state.part.out.boundlen + 2;
                        if (*t == '\n' || *t == '\r' && *(t + 1) == '\n')
                            n = PART_DATA;
                        else if (*t++ == '-' && *t++ == '-' && (*t == '\n' || *t == '\r' && *(t + 1) == '\n')) {
                            n = PART_INIT;
                            continue;
                        }
                    }
                    else if (n == PART_INIT) {
                        if (*s == '\n' || *s == '\r' && *(s + 1) == '\n')
                            continue;
                        n = PART_MAIN;
                        part(fp, NiL, NiL, 0);
                    }
                    fputs(s, fp);
                }
                fprintf(fp, "\n--%s--\n\n", state.part.out.boundary);
                fileclose(state.collect.fp);
                remove(state.tmp.edit);
                state.collect.fp = fp;
                rewind(state.collect.fp);
            }
        }
    }
    state.noreset--;
#ifdef SIGTSTP
    signal(SIGTSTP, state.collect.sigtstp);
#endif
#ifdef SIGTTOU
    signal(SIGTTOU, state.collect.sigttou);
#endif
#ifdef SIGTTIN
    signal(SIGTTIN, state.collect.sigttin);
#endif
    signal(SIGINT, state.collect.sigint);
    signal(SIGHUP, state.collect.sighup);
    return state.collect.fp;
}

/*
 * Save fp in ${DEAD}.
 */
void
savedeadletter(FILE* fp)
{
    FILE*   dp;
    char*   s;

    if (filesize(fp) && (s = deadletter()) && (dp = fileopen(s, "Ma"))) {
        filecopy(NiL, fp, s, dp, NiL, (off_t)0, NiL, NiL, 0);
        fileclose(dp);
        rewind(fp);
    }
}