Use va_copy() to get a copy of va_list, instead of using original.

[nmh] / uip / slocal.c

/* slocal.c -- asynchronously filter and deliver new mail
 *
 * This code is Copyright (c) 2002, by the authors of nmh.  See the
 * COPYRIGHT file in the root directory of the nmh distribution for
 * complete copyright information.
 */

/*
 *  Under sendmail, users should add the line
 *
 *      "| /usr/local/nmh/lib/slocal"
 *
 *  to their $HOME/.forward file.
 *
 */

/* Changed to use getutent() and friends.  Assumes that when getutent() exists,
 * a number of other things also exist.  Please check.
 * Ruud de Rooij <ruud@ruud.org>  Sun, 28 May 2000 17:28:55 +0200
 */

#include <h/mh.h>
#include <h/dropsbr.h>
#include <h/rcvmail.h>
#include <h/signals.h>
#include <setjmp.h>
#include <h/tws.h>
#include <h/mts.h>
#include "h/done.h"
#include <h/utils.h>
#include "sbr/lock_file.h"
#include "sbr/m_mktemp.h"

#include <pwd.h>
#include <sys/ioctl.h>
#include <fcntl.h>

/* Hopefully, grp.h declares initgroups().  If we run into a platform
   where it doesn't, we could consider declaring it here as well. */
#include <grp.h>

/* This define is needed for Berkeley db v2 and above to
 * make the header file expose the 'historical' ndbm APIs.
 * We define it unconditionally because this is simple and
 * harmless.
 */
#define DB_DBM_HSEARCH 1
#ifdef DB_DBM_HSEARCH
#endif /* Use DB_DBM_HSEARCH to prevent warning from gcc -Wunused-macros. */
#ifdef NDBM_HEADER
#include NDBM_HEADER
#endif

#ifdef HAVE_GETUTXENT
#include <utmpx.h>
#endif /* HAVE_GETUTXENT */

#define SLOCAL_SWITCHES \
    X("addr address", 0, ADDRSW) \
    X("user name", 0, USERSW) \
    X("file file", 0, FILESW) \
    X("sender address", 0, SENDERSW) \
    X("mailbox file", 0, MAILBOXSW) \
    X("home directory", -4, HOMESW) \
    X("info data", 0, INFOSW) \
    X("maildelivery file", 0, MAILSW) \
    X("verbose", 0, VERBSW) \
    X("noverbose", 0, NVERBSW) \
    X("suppressdup", 0, SUPPRESSDUP) \
    X("nosuppressdup", 0, NSUPPRESSDUP) \
    X("debug", 0, DEBUGSW) \
    X("version", 0, VERSIONSW) \
    X("help", 0, HELPSW) \

#define X(sw, minchars, id) id,
DEFINE_SWITCH_ENUM(SLOCAL);
#undef X

#define X(sw, minchars, id) { sw, minchars, id },
DEFINE_SWITCH_ARRAY(SLOCAL, switches);
#undef X

static int globbed = 0;         /* have we built "vars" table yet?        */
static int parsed = 0;          /* have we built header field table yet   */
static int utmped = 0;          /* have we scanned umtp(x) file yet       */
static bool suppressdup;        /* are we suppressing duplicate messages? */

static bool verbose;
static bool debug;

static char *addr = NULL;
static char *user = NULL;
static char *info = NULL;
static char *file = NULL;
static char *sender = NULL;
static char *envelope = NULL;   /* envelope information ("From " line)  */
static char *mbox = NULL;
static char *home = NULL;

static struct passwd *pw;       /* passwd file entry */

static char ddate[BUFSIZ];      /* record the delivery date */
struct tws *now;

static jmp_buf myctx;

/* flags for pair->p_flags */
#define P_NIL  0x00
#define P_ADR  0x01     /* field is address     */
#define P_HID  0x02     /* special (fake) field */
#define P_CHK  0x04

struct pair {
    char *p_name;
    char *p_value;
    char  p_flags;
};

#define NVEC 100

/*
 * Lookup table for matching fields and patterns
 * in messages.  The rest of the table is added
 * when the message is parsed.
 */
static struct pair hdrs[NVEC + 1] = {
    { "source",          NULL, P_HID },
    { "addr",            NULL, P_HID },
    { "Return-Path",     NULL, P_ADR },
    { "Reply-To",        NULL, P_ADR },
    { "From",            NULL, P_ADR },
    { "Sender",          NULL, P_ADR },
    { "To",              NULL, P_ADR },
    { "cc",              NULL, P_ADR },
    { "Resent-Reply-To", NULL, P_ADR },
    { "Resent-From",     NULL, P_ADR },
    { "Resent-Sender",   NULL, P_ADR },
    { "Resent-To",       NULL, P_ADR },
    { "Resent-cc",       NULL, P_ADR },
    { NULL, NULL, 0 }
};

/*
 * The list of builtin variables to expand in a string
 * before it is executed by the "pipe" or "qpipe" action.
 */
static struct pair vars[] = {
    { "sender",   NULL, P_NIL },
    { "address",  NULL, P_NIL },
    { "size",     NULL, P_NIL },
    { "reply-to", NULL, P_CHK },
    { "info",     NULL, P_NIL },
    { NULL, NULL, 0 }
};

extern char **environ;

/*
 * static prototypes
 */
static int localmail (int, char *);
static int usr_delivery (int, char *, int);
static int split (char *, char **);
static int parse (int);
static void expand (char *, char *, int);
static void glob (int);
static struct pair *lookup (struct pair *, char *) PURE;
static int logged_in (void);
static int timely (char *, char *);
static int usr_file (int, char *, int);
static int usr_pipe (int, char *, char *, char **, int);
static int usr_folder (int, char *);
static void alrmser (int);
static void get_sender (char *, char **);
static int copy_message (int, char *, int);
static void verbose_printf (char *fmt, ...) CHECK_PRINTF(1, 2);
static void adorn (char *, char *, ...) CHECK_PRINTF(2, 3);
static void debug_printf (char *fmt, ...) CHECK_PRINTF(1, 2);
static int suppress_duplicates (int, char *);
static char *trim (char *);


int
main (int argc, char **argv)
{
    int fd, status;
    FILE *fp;
    char *cp, *mdlvr = NULL, buf[BUFSIZ];
    char mailbox[BUFSIZ], tmpfil[BUFSIZ];
    char **argp, **arguments;

    if (nmh_init(argv[0], false, false)) { return 1; }

    mts_init ();
    arguments = getarguments (invo_name, argc, argv, 0);
    argp = arguments;

    /* Parse arguments */
    while ((cp = *argp++)) {
        if (*cp == '-') {
            switch (smatch (++cp, switches)) {
                case AMBIGSW: 
                    ambigsw (cp, switches);
                    done (1);
                case UNKWNSW: 
                    die("-%s unknown", cp);

                case HELPSW: 
                    snprintf (buf, sizeof(buf), "%s [switches]", invo_name);
                    print_help (buf, switches, 0);
                    done (0);
                case VERSIONSW:
                    print_version(invo_name);
                    done (0);

                case ADDRSW: 
                    if (!(addr = *argp++))/* allow -xyz arguments */
                        die("missing argument to %s", argp[-2]);
                    continue;
                case INFOSW: 
                    if (!(info = *argp++))/* allow -xyz arguments */
                        die("missing argument to %s", argp[-2]);
                    continue;
                case USERSW: 
                    if (!(user = *argp++))/* allow -xyz arguments */
                        die("missing argument to %s", argp[-2]);
                    continue;
                case FILESW: 
                    if (!(file = *argp++) || *file == '-')
                        die("missing argument to %s", argp[-2]);
                    continue;
                case SENDERSW: 
                    if (!(sender = *argp++))/* allow -xyz arguments */
                        die("missing argument to %s", argp[-2]);
                    continue;
                case MAILBOXSW: 
                    if (!(mbox = *argp++) || *mbox == '-')
                        die("missing argument to %s", argp[-2]);
                    continue;
                case HOMESW: 
                    if (!(home = *argp++) || *home == '-')
                        die("missing argument to %s", argp[-2]);
                    continue;

                case MAILSW: 
                    if (!(cp = *argp++) || *cp == '-')
                        die("missing argument to %s", argp[-2]);
                    if (mdlvr)
                        die("only one maildelivery file at a time!");
                    mdlvr = cp;
                    continue;

                case VERBSW: 
                    verbose = true;
                    continue;
                case NVERBSW: 
                    verbose = false;
                    continue;

                case SUPPRESSDUP:
                    suppressdup = true;
                    continue;
                case NSUPPRESSDUP:
                    suppressdup = false;
                    continue;
                case DEBUGSW: 
                    debug = true;
                    continue;
            }
        } else {
                die("only switch arguments are supported");
        }
    }

    if (addr == NULL)
        addr = getusername ();
    if (user == NULL) {
        user = getusername ();
    }
    if ((pw = getpwnam (user)) == NULL)
        die("no such local user as %s", user);

    if (chdir (pw->pw_dir) == -1)
        if (chdir ("/") < 0) {
            advise ("/", "chdir");
        }
    umask (0077);

    if (geteuid() == 0) {
        if (setgid (pw->pw_gid) != 0) {
            adios ("setgid", "unable to set group to %ld", (long) pw->pw_gid);
        }
        initgroups (pw->pw_name, pw->pw_gid);
        if (setuid (pw->pw_uid) != 0) {
            adios ("setuid", "unable to set user to %ld", (long) pw->pw_uid);
        }
    }

    if (info == NULL)
        info = "";

    setbuf (stdin, NULL);

    /* Record the delivery time */
    if ((now = dlocaltimenow ()) == NULL)
        die("unable to ascertain local time");
    snprintf (ddate, sizeof(ddate), "Delivery-Date: %s\n", dtimenow (0));

    /*
     * Copy the message to a temporary file
     */
    if (file) {
        int tempfd;

        /* getting message from file */
        if ((tempfd = open (file, O_RDONLY)) == -1)
            adios (file, "unable to open");
        if (debug)
            debug_printf ("retrieving message from file \"%s\"\n", file);
        if ((fd = copy_message (tempfd, tmpfil, 1)) == -1)
            die("unable to create temporary file in %s",
                  get_temp_dir());
        close (tempfd);
    } else {
        /* getting message from stdin */
        if (debug)
            debug_printf ("retrieving message from stdin\n");
        if ((fd = copy_message (fileno (stdin), tmpfil, 1)) == -1)
            die("unable to create temporary file in %s",
                  get_temp_dir());
    }

    if (debug)
        debug_printf ("temporary file=\"%s\"\n", tmpfil);

    /* Delete the temp file now or a copy of every single message passed through
       slocal will be left in the /tmp directory until deleted manually!  This
       unlink() used to be under an 'else' of the 'if (debug)' above, but since
       some people like to always run slocal with -debug and log the results,
       the /tmp directory would get choked over time.  Of course, now that we
       always delete the temp file, the "temporary file=" message above is
       somewhat pointless -- someone watching debug output wouldn't have a
       chance to 'tail -f' or 'ln' the temp file before it's unlinked.  The best
       thing would be to delay this unlink() until later if debug == 1, but I'll
       leave that for someone who cares about the temp-file-accessing
       functionality (they'll have to watch out for cases where we adios()). */
    (void) m_unlink (tmpfil);

    if (!(fp = fdopen (fd, "r+")))
        die("unable to access temporary file");

    /*
     * If no sender given, extract it
     * from envelope information.  */
    if (sender == NULL)
        get_sender (envelope, &sender);

    if (mbox == NULL) {
        snprintf (mailbox, sizeof(mailbox), "%s/%s",
                mmdfldir[0] ? mmdfldir : pw->pw_dir,
                mmdflfil[0] ? mmdflfil : pw->pw_name);
        mbox = mailbox;
    }
    if (home == NULL)
        home = pw->pw_dir;

    if (debug) {
        debug_printf ("addr=\"%s\"\n", trim(addr));
        debug_printf ("user=\"%s\"\n", trim(user));
        debug_printf ("info=\"%s\"\n", trim(info));
        debug_printf ("sender=\"%s\"\n", trim(sender));
        debug_printf ("envelope=\"%s\"\n", envelope ? trim(envelope) : "");
        debug_printf ("mbox=\"%s\"\n", trim(mbox));
        debug_printf ("home=\"%s\"\n", trim(home));
        debug_printf ("ddate=\"%s\"\n", trim(ddate));
        debug_printf ("now=%02d:%02d\n\n", now->tw_hour, now->tw_min);
    }

    /* deliver the message */
    status = localmail (fd, mdlvr);

    done (status != -1 ? RCV_MOK : RCV_MBX);
    return 1;
}


/*
 * Main routine for delivering message.
 */

static int
localmail (int fd, char *mdlvr)
{
    /* check if this message is a duplicate */
    if (suppressdup &&
        suppress_duplicates(fd, mdlvr ? mdlvr : ".maildelivery") == DONE)
        return 0;

    /* delivery according to personal Maildelivery file */
    if (usr_delivery (fd, mdlvr ? mdlvr : ".maildelivery", 0) != -1)
        return 0;

    /* delivery according to global Maildelivery file */
    if (usr_delivery (fd, maildelivery, 1) != -1)
        return 0;

    if (verbose)
        verbose_printf ("(delivering to standard mail spool)\n");

    /* last resort - deliver to standard mail spool */
    return usr_file (fd, mbox, MBOX_FORMAT);
}


#define matches(a,b) (stringdex (b, a) >= 0)

/*
 * Parse the delivery file, and process incoming message.
 */

static int
usr_delivery (int fd, char *delivery, int su)
{
    int i;
    bool accept;
    int status=1;
    bool won;
    int vecp;
    bool next;
    char *field, *pattern, *action, *result, *string;
    char buffer[BUFSIZ], tmpbuf[BUFSIZ];
    char *vec[NVEC];
    struct stat st;
    struct pair *p;
    FILE *fp;

    /* open the delivery file */
    if ((fp = fopen (delivery, "r")) == NULL)
        return -1;

    /* check if delivery file has bad ownership or permissions */
    if (fstat (fileno (fp), &st) == -1
            || (st.st_uid != 0 && (su || st.st_uid != pw->pw_uid))
            || st.st_mode & (S_IWGRP|S_IWOTH)) {
        if (verbose) {
            verbose_printf ("WARNING: %s has bad ownership/modes (su=%d,uid=%d,owner=%d,mode=0%o)\n",
                    delivery, su, (int) pw->pw_uid, (int) st.st_uid, (int) st.st_mode);
        }
        return -1;
    }

    won = false;
    next = true;

    /* read and process delivery file */
    while (fgets (buffer, sizeof(buffer), fp)) {
        /* skip comments and empty lines */
        if (*buffer == '#' || *buffer == '\n')
            continue;

        trim_suffix_c(buffer, '\n');

        /* split buffer into fields */
        vecp = split (buffer, vec);

        /* check for too few fields */
        if (vecp < 5) {
            if (debug)
                debug_printf ("WARNING: entry with only %d fields, skipping.\n", vecp);
            continue;
        }

        if (debug) {
            for (i = 0; vec[i]; i++)
                debug_printf ("vec[%d]: \"%s\"\n", i, trim(vec[i]));
        }

        field   = vec[0];
        pattern = vec[1];
        action  = vec[2];
        result  = vec[3];
        string  = vec[4];

        /* find out how to perform the action */
        switch (result[0]) {
            case 'N':
            case 'n':
                /*
                 * If previous condition failed, don't
                 * do this - else fall through
                 */
                if (!next)
                    continue;
                /* FALLTHRU */

            case '?': 
                /*
                 * If already delivered, skip this action.  Else
                 * consider delivered if action is successful.
                 */
                if (won)
                    continue;
                /* FALLTHRU */

            case 'A': 
            case 'a': 
                /*
                 * Take action, and consider delivered if
                 * action is successful.
                 */
                accept = true;
                break;

            case 'R': 
            case 'r': 
            default: 
                /*
                 * Take action, but don't consider delivered, even
                 * if action is successful
                 */
                accept = false;
                break;
        }

        if (vecp > 5) {
            if (!strcasecmp (vec[5], "select")) {
                if (logged_in () != -1)
                    continue;
                if (vecp > 7 && timely (vec[6], vec[7]) == -1)
                    continue;
            }
        }

        /* check if the field matches */
        switch (*field) {
            case '*': 
            /* always matches */
                break;

            case 'd': 
            /*
             * "default" matches only if the message hasn't
             * been delivered yet.
             */
                if (!strcasecmp (field, "default")) {
                    if (won)
                        continue;
                    break;
                }
                /* FALLTHRU */

            default: 
                /* parse message and build lookup table */
                if (!parsed && parse (fd) == -1) {
                    fclose (fp);
                    return -1;
                }
                /*
                 * find header field in lookup table, and
                 * see if the pattern matches.
                 */
                if ((p = lookup (hdrs, field)) && (p->p_value != NULL)
                        && matches (p->p_value, pattern)) {
                    next = true;
                } else {
                    next = false;
                    continue;
                }
                break;
        }

        /* find out the action to perform */
        switch (*action) {
            case 'q':
                /* deliver to quoted pipe */
                if (strcasecmp (action, "qpipe"))
                    continue;
                /* FALLTHRU */
            case '^':
                expand (tmpbuf, string, fd);
                if (split (tmpbuf, vec) < 1)
                    continue;
                status = usr_pipe (fd, tmpbuf, vec[0], vec, 0);
                break;

            case 'p': 
                /* deliver to pipe */
                if (strcasecmp (action, "pipe"))
                    continue;
                /* FALLTHRU */
            case '|': 
                vec[2] = "sh";
                vec[3] = "-c";
                expand (tmpbuf, string, fd);
                vec[4] = tmpbuf;
                vec[5] = NULL;
                status = usr_pipe (fd, tmpbuf, "/bin/sh", vec + 2, 0);
                break;

            case 'f': 
                /* mbox format */
                if (!strcasecmp (action, "file")) {
                    status = usr_file (fd, string, MBOX_FORMAT);
                    break;
                }
                /* deliver to nmh folder */
                else if (strcasecmp (action, "folder"))
                    continue;
                /* FALLTHRU */
            case '+':
                status = usr_folder (fd, string);
                break;

            case 'm':
                /* mmdf format */
                if (!strcasecmp (action, "mmdf")) {
                    status = usr_file (fd, string, MMDF_FORMAT);
                    break;
                }
                /* mbox format */
                else if (strcasecmp (action, "mbox"))
                    continue;
                /* FALLTHRU */

            case '>': 
                /* mbox format */
                status = usr_file (fd, string, MBOX_FORMAT);
                break;

            case 'd': 
                /* ignore message */
                if (strcasecmp (action, "destroy"))
                    continue;
                status = 0;
                break;
        }

        if (status) next = false; /* action failed, mark for 'N' result */

        if (accept && status == 0)
            won = true;
    }

    fclose (fp);
    return won ? 0 : -1;
}


#define QUOTE   '\\'

/*
 * Split buffer into fields (delimited by whitespace or
 * comma's).  Return the number of fields found.
 */

static int
split (char *cp, char **vec)
{
    int i;
    char *s;

    s = cp;

    /* split into a maximum of NVEC fields */
    for (i = 0; i <= NVEC;) {
        vec[i] = NULL;

        /* zap any whitespace and comma's */
        while (isspace ((unsigned char) *s) || *s == ',')
            *s++ = 0;

        /* end of buffer, time to leave */
        if (*s == 0)
            break;

        /* get double quote text as a single field */
        if (*s == '"') {
            for (vec[i++] = ++s; *s && *s != '"'; s++) {
                /*
                 * Check for escaped double quote.  We need
                 * to shift the string to remove slash.
                 */
                if (*s == QUOTE) {
                    if (*++s == '"')
                        strcpy (s - 1, s);
                    s--;
                }
            }
            if (*s == '"')      /* zap trailing double quote */
                *s++ = 0;
            continue;
        }

        if (*s == QUOTE && *++s != '"')
            s--;
        vec[i++] = s++;

        /* move forward to next field delimiter */
        while (*s && !isspace ((unsigned char) *s) && *s != ',')
            s++;
    }
    vec[i] = NULL;

    return i;
}


/*
 * Parse the headers of a message, and build the
 * lookup table for matching fields and patterns.
 */

static int
parse (int fd)
{
    int i, state;
    int fd1;
    char *cp, *dp, *lp;
    char name[NAMESZ], field[NMH_BUFSIZ];
    struct pair *p, *q;
    FILE  *in;
    m_getfld_state_t gstate;

    if (parsed++)
        return 0;

    /* get a new FILE pointer to message */
    if ((fd1 = dup (fd)) == -1)
        return -1;
    if ((in = fdopen (fd1, "r")) == NULL) {
        close (fd1);
        return -1;
    }
    rewind (in);

    /* add special entries to lookup table */
    if ((p = lookup (hdrs, "source")))
        p->p_value = getcpy (sender);
    if ((p = lookup (hdrs, "addr")))
        p->p_value = getcpy (addr);

    /*
     * Scan the headers of the message and build
     * a lookup table.
     */
    gstate = m_getfld_state_init(in);
    for (i = 0;;) {
        int fieldsz = sizeof field;
        switch (state = m_getfld2(&gstate, name, field, &fieldsz)) {
            case FLD: 
            case FLDPLUS: 
                lp = mh_xstrdup(field);
                while (state == FLDPLUS) {
                    fieldsz = sizeof field;
                    state = m_getfld2(&gstate, name, field, &fieldsz);
                    lp = add (field, lp);
                }
                for (p = hdrs; p->p_name; p++) {
                    if (!strcasecmp (p->p_name, name)) {
                        if (!(p->p_flags & P_HID)) {
                            if ((cp = p->p_value)) {
                                if (p->p_flags & P_ADR) {
                                    dp = cp + strlen (cp) - 1;
                                    if (*dp == '\n')
                                        *dp = 0;
                                    cp = add (",\n\t", cp);
                                } else {
                                    cp = add ("\t", cp);
                                }
                            }
                            p->p_value = add (lp, cp);
                        }
                        free (lp);
                        break;
                    }
                }
                if (p->p_name == NULL && i < NVEC) {
                    p->p_name = mh_xstrdup(name);
                    p->p_value = lp;
                    p->p_flags = P_NIL;
                    p++, i++;
                    p->p_name = NULL;
                }
                continue;

            case BODY: 
            case FILEEOF: 
                break;

            case LENERR: 
            case FMTERR: 
                inform("format error in message");
                break;

            default: 
                inform("internal error in m_getfld2");
                fclose (in);
                return -1;
        }
        break;
    }
    m_getfld_state_destroy (&gstate);
    fclose (in);

    if ((p = lookup (vars, "reply-to"))) {
        if ((q = lookup (hdrs, "reply-to")) == NULL || q->p_value == NULL)
            q = lookup (hdrs, "from");
        p->p_value = getcpy (q ? q->p_value : "");
        p->p_flags &= ~P_CHK;
        if (debug)
            debug_printf ("vars[%td]: name=\"%s\" value=\"%s\"\n",
                p - vars, p->p_name, trim(p->p_value));
    }
    if (debug) {
        for (p = hdrs; p->p_name; p++)
            debug_printf ("hdrs[%td]: name=\"%s\" value=\"%s\"\n",
                p - hdrs, p->p_name, p->p_value ? trim(p->p_value) : "");
    }

    return 0;
}


#define LPAREN  '('
#define RPAREN  ')'

/*
 * Expand any builtin variables such as $(sender),
 * $(address), etc., in a string.
 */

static void
expand (char *s1, char *s2, int fd)
{
    char c, *cp;
    struct pair *p;

    if (!globbed)
        glob (fd);

    while ((c = *s2++)) {
        if (c != '$' || *s2 != LPAREN) {
            *s1++ = c;
        } else {
            for (cp = ++s2; *s2 && *s2 != RPAREN; s2++)
                continue;
            if (*s2 != RPAREN) {
                s2 = --cp;
                continue;
            }
            *s2++ = 0;
            if ((p = lookup (vars, cp))) {
                if (!parsed && (p->p_flags & P_CHK))
                    parse (fd);

                strcpy (s1, p->p_value);
                s1 += strlen (s1);
            }
        }
    }
    *s1 = 0;
}


/*
 * Fill in the information missing from the "vars"
 * table, which is necessary to expand any builtin
 * variables in the string for a "pipe" or "qpipe"
 * action.
 */

static void
glob (int fd)
{
    char buffer[BUFSIZ];
    struct stat st;
    struct pair *p;

    if (globbed++)
        return;

    if ((p = lookup (vars, "sender")))
        p->p_value = getcpy (sender);
    if ((p = lookup (vars, "address")))
        p->p_value = getcpy (addr);
    if ((p = lookup (vars, "size"))) {
        snprintf (buffer, sizeof(buffer), "%d",
                fstat (fd, &st) != -1 ? (int) st.st_size : 0);
        p->p_value = mh_xstrdup(buffer);
    }
    if ((p = lookup (vars, "info")))
        p->p_value = getcpy (info);

    if (debug) {
        for (p = vars; p->p_name; p++)
            debug_printf ("vars[%td]: name=\"%s\" value=\"%s\"\n",
                    p - vars, p->p_name, trim(p->p_value));
    }
}


/*
 * Find a matching name in a lookup table.  If found,
 * return the "pairs" entry, else return NULL.
 */

static struct pair *
lookup (struct pair *pairs, char *key)
{
    for (; pairs->p_name; pairs++)
        if (!strcasecmp (pairs->p_name, key))
            return pairs;

    return NULL;
}


/*
 * Check utmp(x) file to see if user is currently
 * logged in.
 */

static int
logged_in (void)
{
#if HAVE_GETUTXENT
    struct utmpx *utp;

    if (utmped)
        return utmped;

    setutxent();

    while ((utp = getutxent()) != NULL) {
        if ( utp->ut_type == USER_PROCESS && utp->ut_user[0] != 0
                && strncmp (user, utp->ut_user, sizeof(utp->ut_user)) == 0) {
            if (debug)
                continue;
            endutxent();
            return utmped = DONE;
        }
    }

    endutxent();
#endif /* HAVE_GETUTXENT */
    return utmped = NOTOK;
}

#define check(t,a,b)            if (t < a || t > b) return -1
#define cmpar(h1,m1,h2,m2)      if (h1 < h2 || (h1 == h2 && m1 < m2)) return 0

static int
timely (char *t1, char *t2)
{
    int t1hours, t1mins, t2hours, t2mins;

    if (sscanf (t1, "%d:%d", &t1hours, &t1mins) != 2)
        return -1;
    check (t1hours, 0, 23);
    check (t1mins, 0, 59);

    if (sscanf (t2, "%d:%d", &t2hours, &t2mins) != 2)
        return -1;
    check (t2hours, 0, 23);
    check (t2mins, 0, 59);

    cmpar (now->tw_hour, now->tw_min, t1hours, t1mins);
    cmpar (t2hours, t2mins, now->tw_hour, now->tw_min);

    return -1;
}


/*
 * Deliver message by appending to a file.
 */

static int
usr_file (int fd, char *mailbox, int mbx_style)
{
    int md;

    if (verbose) {
        verbose_printf("delivering to file \"%s\" (%s style)", mailbox,
            mbx_style == MBOX_FORMAT ? "mbox" : "mmdf");
    }

    /* open and lock the file */
    if ((md = mbx_open (mailbox, mbx_style, pw->pw_uid, pw->pw_gid, m_gmprot())) == -1) {
        if (verbose)
            adorn ("", "unable to open:");
        return -1;
    }

    lseek(fd, 0, SEEK_SET);

    /* append message to file */
    if (mbx_copy (mailbox, mbx_style, md, fd, NULL) == -1) {
        if (verbose)
            adorn ("", "error writing to:");
        return -1;
    }

    /* close and unlock file */
    if (mbx_close (mailbox, md) == NOTOK) {
        if (verbose)
            adorn ("", "error closing:");
        return -1;
    }

    if (verbose)
        verbose_printf (", success.\n");
    return 0;
}


/*
 * Deliver message to a nmh folder.
 */

static int
usr_folder (int fd, char *string)
{
    int status;
    char folder[BUFSIZ], *vec[3];

    /* get folder name ready */
    if (*string == '+')
        strncpy(folder, string, sizeof(folder));
    else
        snprintf(folder, sizeof(folder), "+%s", string);

    if (verbose)
        verbose_printf ("delivering to folder \"%s\"", folder + 1);

    vec[0] = "rcvstore";
    vec[1] = folder;
    vec[2] = NULL;

    /* use rcvstore to put message in folder */
    status = usr_pipe (fd, "rcvstore", rcvstoreproc, vec, 1);

    return status;
}

/*
 * Deliver message to a process.
 */

static int
usr_pipe (int fd_arg, char *cmd, char *pgm, char **vec, int suppress)
{
    volatile int fd = fd_arg;
    pid_t child_id;
    int bytes, seconds, status;
    struct stat st;

    if (verbose && !suppress)
        verbose_printf ("delivering to pipe \"%s\"", cmd);

    lseek(fd, 0, SEEK_SET);

    child_id = fork();
    switch (child_id) {
        case -1: 
            /* fork error */
            if (verbose)
                adorn ("fork", "unable to");
            return -1;

        case 0: 
            /* child process */
            if (fd != 0)
                dup2 (fd, 0);
            if (freopen ("/dev/null", "w", stdout) == NULL) {
                advise ("stdout", "freopen");
            }
            if (freopen ("/dev/null", "w", stderr) == NULL) {
                advise ("stderr", "freopen");
            }
            if (fd != 3)
                dup2 (fd, 3);
            closefds (4);

#ifdef TIOCNOTTY
            if ((fd = open ("/dev/tty", O_RDWR)) != -1) {
                ioctl (fd, TIOCNOTTY, NULL);
                close (fd);
            }
#endif /* TIOCNOTTY */

            setpgid(0, getpid());       /* put in own process group */

            *environ = NULL;
            setenv("USER", pw->pw_name, 1);
            setenv("HOME", pw->pw_dir, 1);
            setenv("SHELL", pw->pw_shell, 1);

            execvp (pgm, vec);
            _exit(1);

        default: 
            /* parent process */
            if (! setjmp (myctx)) {
                SIGNAL (SIGALRM, alrmser);
                bytes = fstat (fd, &st) != -1 ? (int) st.st_size : 100;

                /* amount of time to wait depends on message size */
                if (bytes <= 100) {
                    /* give at least 5 minutes */
                    seconds = 300;
                } else if (bytes >= 90000) {
                    /* a half hour is long enough */
                    seconds = 1800;
                } else {
                    seconds = (bytes / 60) + 300;
                }
                alarm ((unsigned int) seconds);
                status = pidwait (child_id, 0);
                alarm (0);

                if (verbose) {
                    if (status == 0)
                        verbose_printf (", success.\n");
                    else if ((status & 0xff00) == 0xff00)
                        verbose_printf (", system error\n");
                    else
                        pidstatus (status, stdout, ", failed");
                }
                return status == 0 ? 0 : -1;
            }
            /*
             * Ruthlessly kill the child and anything
             * else in its process group.
             */
            killpg(child_id, SIGKILL);
            if (verbose)
                verbose_printf (", timed-out; terminated\n");
            return -1;
    }
}


static void
alrmser (int i)
{
    NMH_UNUSED (i);

    longjmp (myctx, DONE);
}


/*
 * Get the `sender' from the envelope
 * information ("From " line).
 */

static void
get_sender (char *envelope, char **sender)
{
    int i;
    char *cp;
    char buffer[BUFSIZ];

    if (envelope == NULL) {
        *sender = mh_xstrdup("");
        return;
    }

    i = LEN("From ");
    strncpy (buffer, envelope + i, sizeof(buffer));
    if ((cp = strchr(buffer, '\n'))) {
        *cp = 0;
        cp -= 24;
        if (cp < buffer)
            cp = buffer;
    } else {
        cp = buffer;
    }
    *cp = 0;

    for (cp = buffer + strlen (buffer) - 1; cp >= buffer; cp--)
        if (isspace ((unsigned char) *cp))
            *cp = 0;
        else
            break;
    *sender = mh_xstrdup(buffer);
}


/*
 * Copy message into a temporary file.
 * While copying, it will do some header processing
 * including the extraction of the envelope information.
 */

static int
copy_message (int qd, char *tmpfil, int fold)
{
    int i, first = 1, fd1, fd2;
    char buffer[BUFSIZ];
    FILE *qfp, *ffp;
    char *tfile = NULL;

    tfile = m_mktemp2(NULL, invo_name, &fd1, NULL);
    if (tfile == NULL) return -1;
    strncpy (tmpfil, tfile, BUFSIZ);

    if (!fold) {
        while ((i = read (qd, buffer, sizeof(buffer))) > 0)
            if (write (fd1, buffer, i) != i) {
you_lose:
                close (fd1);
                (void) m_unlink (tmpfil);
                return -1;
            }
        if (i == -1)
            goto you_lose;
        lseek(fd1, 0, SEEK_SET);
        return fd1;
    }

    /* dup the fd for incoming message */
    if ((fd2 = dup (qd)) == -1) {
        close (fd1);
        return -1;
    }

    /* now create a FILE pointer for it */
    if ((qfp = fdopen (fd2, "r")) == NULL) {
        close (fd1);
        close (fd2);
        return -1;
    }

    /* dup the fd for temporary file */
    if ((fd2 = dup (fd1)) == -1) {
        close (fd1);
        fclose (qfp);
        return -1;
    }

    /* now create a FILE pointer for it */
    if ((ffp = fdopen (fd2, "r+")) == NULL) {
        close (fd1);
        close (fd2);
        fclose (qfp);
        return -1;
    }

    /*
     * copy message into temporary file
     * and massage the headers.  Save
     * a copy of the "From " line for later.
     */
    while (fgets (buffer, sizeof(buffer), qfp)) {
        if (first) {
            first = 0;
            if (has_prefix(buffer, "From ")) {
                /* get copy of envelope information ("From " line) */
                envelope = mh_xstrdup(buffer);

                /* Put the delivery date in message */
                fputs (ddate, ffp);
                if (ferror (ffp))
                    goto fputs_error;

                continue;
            }
        }

        fputs (buffer, ffp);
        if (ferror (ffp))
            goto fputs_error;
    }

    fclose (ffp);
    if (ferror (qfp)) {
        close (fd1);
        fclose (qfp);
        return -1;
    }
    fclose (qfp);
    lseek(fd1, 0, SEEK_SET);
    return fd1;


fputs_error:
    close (fd1);
    fclose (ffp);
    fclose (qfp);
    return -1;
}

/*
 * Trim strings for pretty printing of debugging output
 */

static char *
trim (char *cp)
{
    static char buffer[BUFSIZ * 4];
    char *bp, *sp;

    if (cp == NULL)
        return NULL;

    /* copy string into temp buffer */
    strncpy (buffer, cp, sizeof(buffer));
    bp = buffer;

    /* skip over leading whitespace */
    while (isspace((unsigned char) *bp))
        bp++;

    /* start at the end and zap trailing whitespace */
    for (sp = bp + strlen(bp) - 1; sp >= bp; sp--) {
        if (isspace((unsigned char) *sp))
            *sp = 0;
        else
            break;
    }

    /* replace remaining whitespace with spaces */
    for (sp = bp; *sp; sp++)
        if (isspace((unsigned char) *sp))
            *sp = ' ';

    return bp;
}

/*
 * Function for printing `verbose' messages.
 */

static void
verbose_printf (char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);

    fflush (stdout);    /* now flush output */
}


/*
 * Function for printing `verbose' delivery
 * error messages.
 */

static void
adorn (char *what, char *fmt, ...)
{
    va_list ap;
    int eindex;
    char *s;

    eindex = errno;     /* save the errno */
    fputs(", ", stdout);

    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);

    if (what) {
        if (*what)
            printf(" %s: ", what);
        if ((s = strerror (eindex)))
            fputs(s, stdout);
        else
            printf("Error %d", eindex);
    }

    putchar('\n');
    fflush (stdout);
}


/*
 * Function for printing `debug' messages.
 */

static void
debug_printf (char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vfprintf (stderr, fmt, ap);
    va_end(ap);
}


/*
 * Check ndbm/db file(s) to see if the Message-Id of this
 * message matches the Message-Id of a previous message,
 * so we can discard it.  If it doesn't match, we add the
 * Message-Id of this message to the ndbm/db file.
 */
static int
suppress_duplicates (int fd, char *file)
{
    int fd1, lockfd, state, result;
    char *cp, buf[NMH_BUFSIZ], name[NAMESZ];
    datum key, value;
    DBM *db;
    FILE *in;
    m_getfld_state_t gstate;

    if ((fd1 = dup (fd)) == -1)
        return -1;
    if (!(in = fdopen (fd1, "r"))) {
        close (fd1);
        return -1;
    }
    rewind (in);

    gstate = m_getfld_state_init(in);
    for (;;) {
        int failed_to_lock = 0;
        int bufsz = sizeof buf;
        state = m_getfld2(&gstate, name, buf, &bufsz);
        switch (state) {
            case FLD:
            case FLDPLUS:
                /* Search for the message ID */
                if (strcasecmp (name, "Message-ID")) {
                    while (state == FLDPLUS) {
                        bufsz = sizeof buf;
                        state = m_getfld2(&gstate, name, buf, &bufsz);
                    }
                    continue;
                }

                cp = mh_xstrdup(buf);
                while (state == FLDPLUS) {
                    bufsz = sizeof buf;
                    state = m_getfld2(&gstate, name, buf, &bufsz);
                    cp = add (buf, cp);
                }
                key.dptr = trimcpy (cp);
                key.dsize = strlen (key.dptr) + 1;
                free (cp);
                cp = key.dptr;

                if (!(db = dbm_open (file, O_RDWR | O_CREAT, 0600))) {
                    advise (file, "unable to perform dbm_open on");
                    free (cp);
                    fclose (in);
                    return -1;
                }
                /*
                 * Since it is difficult to portable lock a ndbm file,
                 * we will open and lock the Maildelivery file instead.
                 * This will fail if your Maildelivery file doesn't
                 * exist.
                 */
                if ((lockfd = lkopendata(file, O_RDWR, 0, &failed_to_lock))
                    == -1) {
                    advise (file, "unable to perform file locking on");
                    free (cp);
                    fclose (in);
                    return -1;
                }
                value = dbm_fetch (db, key);
                if (value.dptr) {
                    if (verbose)
                        verbose_printf ("Message-ID: %s\n            already received on %s",
                                 cp, value.dptr);
                    result = DONE;
                } else {
                    value.dptr  = ddate + sizeof("Delivery-Date:");
                    value.dsize = strlen(value.dptr) + 1;
                    if (dbm_store (db, key, value, DBM_INSERT))
                        advise (file, "possibly corrupt file");
                    result = 0;
                }

                dbm_close (db);
                lkclosedata(lockfd, file);
                free (cp);
                fclose (in);
                return result;

           case BODY:
           case FILEEOF:
                break;

           case LENERR:
           case FMTERR:
           default:
                break;
        }

        break;
    }
    m_getfld_state_destroy (&gstate);

    fclose (in);
    return 0;
}