source: trunk/third/sendmail/sendmail/recipient.c @ 19204

/*
 * Copyright (c) 1998-2002 Sendmail, Inc. and its suppliers.
 *      All rights reserved.
 * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
 * Copyright (c) 1988, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * By using this file, you agree to the terms and conditions set
 * forth in the LICENSE file which can be found at the top level of
 * the sendmail distribution.
 *
 */

#include <sendmail.h>

SM_RCSID("@(#)$Id: recipient.c,v 1.1.1.1 2003-04-08 15:08:04 zacheiss Exp $")

static void     includetimeout __P((void));
static ADDRESS  *self_reference __P((ADDRESS *));
static int      sortexpensive __P((ADDRESS *, ADDRESS *));
static int      sortbysignature __P((ADDRESS *, ADDRESS *));
static int      sorthost __P((ADDRESS *, ADDRESS *));

typedef int     sortfn_t __P((ADDRESS *, ADDRESS *));

/*
**  SORTHOST -- strcmp()-like func for host portion of an ADDRESS
**
**      Parameters:
**              xx -- first ADDRESS
**              yy -- second ADDRESS
**
**      Returns:
**              <0 when xx->q_host is less than yy->q_host
**              >0 when xx->q_host is greater than yy->q_host
**              0 when equal
*/

static int
sorthost(xx, yy)
        register ADDRESS *xx;
        register ADDRESS *yy;
{
#if _FFR_HOST_SORT_REVERSE
        /* XXX maybe compare hostnames from the end? */
        return sm_strrevcasecmp(xx->q_host, yy->q_host);
#else /* _FFR_HOST_SORT_REVERSE */
        return sm_strcasecmp(xx->q_host, yy->q_host);
#endif /* _FFR_HOST_SORT_REVERSE */
}

/*
**  SORTEXPENSIVE -- strcmp()-like func for expensive mailers
**
**  The mailer has been noted already as "expensive" for 'xx'. This
**  will give a result relative to 'yy'. Expensive mailers get rated
**  "greater than" non-expensive mailers because during the delivery phase
**  it will get queued -- no use it getting in the way of less expensive
**  recipients. We avoid an MX RR lookup when both 'xx' and 'yy' are
**  expensive since an MX RR lookup happens when extracted from the queue
**  later.
**
**      Parameters:
**              xx -- first ADDRESS
**              yy -- second ADDRESS
**
**      Returns:
**              <0 when xx->q_host is less than yy->q_host and both are
**                      expensive
**              >0 when xx->q_host is greater than yy->q_host, or when
**                      'yy' is non-expensive
**              0 when equal (by expense and q_host)
*/

static int
sortexpensive(xx, yy)
        ADDRESS *xx;
        ADDRESS *yy;
{
        if (!bitnset(M_EXPENSIVE, yy->q_mailer->m_flags))
                return 1; /* xx should go later */
#if _FFR_HOST_SORT_REVERSE
        /* XXX maybe compare hostnames from the end? */
        return sm_strrevcasecmp(xx->q_host, yy->q_host);
#else /* _FFR_HOST_SORT_REVERSE */
        return sm_strcasecmp(xx->q_host, yy->q_host);
#endif /* _FFR_HOST_SORT_REVERSE */
}

/*
**  SORTBYSIGNATURE -- a strcmp()-like func for q_mailer and q_host in ADDRESS
**
**      Parameters:
**              xx -- first ADDRESS
**              yy -- second ADDRESS
**
**      Returns:
**              0 when the "signature"'s are same
**              <0 when xx->q_signature is less than yy->q_signature
**              >0 when xx->q_signature is greater than yy->q_signature
**
**      Side Effect:
**              May set ADDRESS pointer for q_signature if not already set.
*/

static int
sortbysignature(xx, yy)
        ADDRESS *xx;
        ADDRESS *yy;
{
        register int ret;

        /* Let's avoid redoing the signature over and over again */
        if (xx->q_signature == NULL)
                xx->q_signature = hostsignature(xx->q_mailer, xx->q_host);
        if (yy->q_signature == NULL)
                yy->q_signature = hostsignature(yy->q_mailer, yy->q_host);
        ret = strcmp(xx->q_signature, yy->q_signature);

        /*
        **  If the two signatures are the same then we will return a sort
        **  value based on 'q_user'. But note that we have reversed xx and yy
        **  on purpose. This additional compare helps reduce the number of
        **  sameaddr() calls and loops in recipient() for the case when
        **  the rcpt list has been provided already in-order.
        */

        if (ret == 0)
                return strcmp(yy->q_user, xx->q_user);
        else
                return ret;
}

/*
**  SENDTOLIST -- Designate a send list.
**
**      The parameter is a comma-separated list of people to send to.
**      This routine arranges to send to all of them.
**
**      Parameters:
**              list -- the send list.
**              ctladdr -- the address template for the person to
**                      send to -- effective uid/gid are important.
**                      This is typically the alias that caused this
**                      expansion.
**              sendq -- a pointer to the head of a queue to put
**                      these people into.
**              aliaslevel -- the current alias nesting depth -- to
**                      diagnose loops.
**              e -- the envelope in which to add these recipients.
**
**      Returns:
**              The number of addresses actually on the list.
*/

/* q_flags bits inherited from ctladdr */
#define QINHERITEDBITS  (QPINGONSUCCESS|QPINGONFAILURE|QPINGONDELAY|QHASNOTIFY)

int
sendtolist(list, ctladdr, sendq, aliaslevel, e)
        char *list;
        ADDRESS *ctladdr;
        ADDRESS **sendq;
        int aliaslevel;
        register ENVELOPE *e;
{
        register char *p;
        register ADDRESS *SM_NONVOLATILE al; /* list of addresses to send to */
        SM_NONVOLATILE char delimiter;          /* the address delimiter */
        SM_NONVOLATILE int naddrs;
        SM_NONVOLATILE int i;
        char *oldto = e->e_to;
        char *SM_NONVOLATILE bufp;
        char buf[MAXNAME + 1];

        if (list == NULL)
        {
                syserr("sendtolist: null list");
                return 0;
        }

        if (tTd(25, 1))
        {
                sm_dprintf("sendto: %s\n   ctladdr=", list);
                printaddr(ctladdr, false);
        }

        /* heuristic to determine old versus new style addresses */
        if (ctladdr == NULL &&
            (strchr(list, ',') != NULL || strchr(list, ';') != NULL ||
             strchr(list, '<') != NULL || strchr(list, '(') != NULL))
                e->e_flags &= ~EF_OLDSTYLE;
        delimiter = ' ';
        if (!bitset(EF_OLDSTYLE, e->e_flags) || ctladdr != NULL)
                delimiter = ',';

        al = NULL;
        naddrs = 0;

        /* make sure we have enough space to copy the string */
        i = strlen(list) + 1;
        if (i <= sizeof buf)
        {
                bufp = buf;
                i = sizeof buf;
        }
        else
                bufp = sm_malloc_x(i);

        SM_TRY
        {
                (void) sm_strlcpy(bufp, denlstring(list, false, true), i);

                macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e r");
                for (p = bufp; *p != '\0'; )
                {
                        auto char *delimptr;
                        register ADDRESS *a;

                        /* parse the address */
                        while ((isascii(*p) && isspace(*p)) || *p == ',')
                                p++;
                        a = parseaddr(p, NULLADDR, RF_COPYALL, delimiter,
                                      &delimptr, e, true);
                        p = delimptr;
                        if (a == NULL)
                                continue;
                        a->q_next = al;
                        a->q_alias = ctladdr;

                        /* arrange to inherit attributes from parent */
                        if (ctladdr != NULL)
                        {
                                ADDRESS *b;

                                /* self reference test */
                                if (sameaddr(ctladdr, a))
                                {
                                        if (tTd(27, 5))
                                        {
                                                sm_dprintf("sendtolist: QSELFREF ");
                                                printaddr(ctladdr, false);
                                        }
                                        ctladdr->q_flags |= QSELFREF;
                                }

                                /* check for address loops */
                                b = self_reference(a);
                                if (b != NULL)
                                {
                                        b->q_flags |= QSELFREF;
                                        if (tTd(27, 5))
                                        {
                                                sm_dprintf("sendtolist: QSELFREF ");
                                                printaddr(b, false);
                                        }
                                        if (a != b)
                                        {
                                                if (tTd(27, 5))
                                                {
                                                        sm_dprintf("sendtolist: QS_DONTSEND ");
                                                        printaddr(a, false);
                                                }
                                                a->q_state = QS_DONTSEND;
                                                b->q_flags |= a->q_flags & QNOTREMOTE;
                                                continue;
                                        }
                                }

                                /* full name */
                                if (a->q_fullname == NULL)
                                        a->q_fullname = ctladdr->q_fullname;

                                /* various flag bits */
                                a->q_flags &= ~QINHERITEDBITS;
                                a->q_flags |= ctladdr->q_flags & QINHERITEDBITS;

                                /* DSN recipient information */
                                a->q_finalrcpt = ctladdr->q_finalrcpt;
                                a->q_orcpt = ctladdr->q_orcpt;
                        }

                        al = a;
                }

                /* arrange to send to everyone on the local send list */
                while (al != NULL)
                {
                        register ADDRESS *a = al;

                        al = a->q_next;
                        a = recipient(a, sendq, aliaslevel, e);
                        naddrs++;
                }
        }
        SM_FINALLY
        {
                e->e_to = oldto;
                if (bufp != buf)
                        sm_free(bufp);
                macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), NULL);
        }
        SM_END_TRY
        return naddrs;
}
#if MILTER
/*
**  REMOVEFROMLIST -- Remove addresses from a send list.
**
**      The parameter is a comma-separated list of recipients to remove.
**      Note that it only deletes matching addresses.  If those addresses
**      have been expanded already in the sendq, it won't mark the
**      expanded recipients as QS_REMOVED.
**
**      Parameters:
**              list -- the list to remove.
**              sendq -- a pointer to the head of a queue to remove
**                      these addresses from.
**              e -- the envelope in which to remove these recipients.
**
**      Returns:
**              The number of addresses removed from the list.
**
*/

int
removefromlist(list, sendq, e)
        char *list;
        ADDRESS **sendq;
        ENVELOPE *e;
{
        SM_NONVOLATILE char delimiter;          /* the address delimiter */
        SM_NONVOLATILE int naddrs;
        SM_NONVOLATILE int i;
        char *p;
        char *oldto = e->e_to;
        char *SM_NONVOLATILE bufp;
        char buf[MAXNAME + 1];

        if (list == NULL)
        {
                syserr("removefromlist: null list");
                return 0;
        }

        if (tTd(25, 1))
                sm_dprintf("removefromlist: %s\n", list);

        /* heuristic to determine old versus new style addresses */
        if (strchr(list, ',') != NULL || strchr(list, ';') != NULL ||
            strchr(list, '<') != NULL || strchr(list, '(') != NULL)
                e->e_flags &= ~EF_OLDSTYLE;
        delimiter = ' ';
        if (!bitset(EF_OLDSTYLE, e->e_flags))
                delimiter = ',';

        naddrs = 0;

        /* make sure we have enough space to copy the string */
        i = strlen(list) + 1;
        if (i <= sizeof buf)
        {
                bufp = buf;
                i = sizeof buf;
        }
        else
                bufp = sm_malloc_x(i);

        SM_TRY
        {
                (void) sm_strlcpy(bufp, denlstring(list, false, true), i);

                macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e r");
                for (p = bufp; *p != '\0'; )
                {
                        ADDRESS a;      /* parsed address to be removed */
                        ADDRESS *q;
                        ADDRESS **pq;
                        char *delimptr;

                        /* parse the address */
                        while ((isascii(*p) && isspace(*p)) || *p == ',')
                                p++;
                        if (parseaddr(p, &a, RF_COPYALL,
                                      delimiter, &delimptr, e, true) == NULL)
                        {
                                p = delimptr;
                                continue;
                        }
                        p = delimptr;
                        for (pq = sendq; (q = *pq) != NULL; pq = &q->q_next)
                        {
                                if (!QS_IS_DEAD(q->q_state) &&
                                    sameaddr(q, &a))
                                {
                                        if (tTd(25, 5))
                                        {
                                                sm_dprintf("removefromlist: QS_REMOVED ");
                                                printaddr(&a, false);
                                        }
                                        q->q_state = QS_REMOVED;
                                        naddrs++;
                                        break;
                                }
                        }
                }
        }
        SM_FINALLY
        {
                e->e_to = oldto;
                if (bufp != buf)
                        sm_free(bufp);
                macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), NULL);
        }
        SM_END_TRY
        return naddrs;
}
#endif /* MILTER */
/*
**  RECIPIENT -- Designate a message recipient
**
**      Saves the named person for future mailing.
**
**      Parameters:
**              new -- the (preparsed) address header for the recipient.
**              sendq -- a pointer to the head of a queue to put the
**                      recipient in.  Duplicate suppression is done
**                      in this queue.
**              aliaslevel -- the current alias nesting depth.
**              e -- the current envelope.
**
**      Returns:
**              The actual address in the queue.  This will be "a" if
**              the address is not a duplicate, else the original address.
**
*/

ADDRESS *
recipient(new, sendq, aliaslevel, e)
        register ADDRESS *new;
        register ADDRESS **sendq;
        int aliaslevel;
        register ENVELOPE *e;
{
        register ADDRESS *q;
        ADDRESS **pq;
        ADDRESS **prev;
        register struct mailer *m;
        register char *p;
        int i, buflen;
        bool quoted;            /* set if the addr has a quote bit */
        bool insert;
        int findusercount;
        bool initialdontsend;
        char *buf;
        char buf0[MAXNAME + 1];         /* unquoted image of the user name */
        sortfn_t *sortfn;

        p = NULL;
        quoted = false;
        insert = false;
        findusercount = 0;
        initialdontsend = QS_IS_DEAD(new->q_state);
        e->e_to = new->q_paddr;
        m = new->q_mailer;
        errno = 0;
        if (aliaslevel == 0)
                new->q_flags |= QPRIMARY;
        if (tTd(26, 1))
        {
                sm_dprintf("\nrecipient (%d): ", aliaslevel);
                printaddr(new, false);
        }

        /* if this is primary, use it as original recipient */
        if (new->q_alias == NULL)
        {
                if (e->e_origrcpt == NULL)
                        e->e_origrcpt = new->q_paddr;
                else if (e->e_origrcpt != new->q_paddr)
                        e->e_origrcpt = "";
        }

        /* find parent recipient for finalrcpt and orcpt */
        for (q = new; q->q_alias != NULL; q = q->q_alias)
                continue;

        /* find final recipient DSN address */
        if (new->q_finalrcpt == NULL &&
            e->e_from.q_mailer != NULL)
        {
                char frbuf[MAXLINE];

                p = e->e_from.q_mailer->m_addrtype;
                if (p == NULL)
                        p = "rfc822";
                if (sm_strcasecmp(p, "rfc822") != 0)
                {
                        (void) sm_snprintf(frbuf, sizeof frbuf, "%s; %.800s",
                                           q->q_mailer->m_addrtype,
                                           q->q_user);
                }
                else if (strchr(q->q_user, '@') != NULL)
                {
                        (void) sm_snprintf(frbuf, sizeof frbuf, "%s; %.800s",
                                           p, q->q_user);
                }
                else if (strchr(q->q_paddr, '@') != NULL)
                {
                        char *qp;
                        bool b;

                        qp = q->q_paddr;

                        /* strip brackets from address */
                        b = false;
                        if (*qp == '<')
                        {
                                b = qp[strlen(qp) - 1] == '>';
                                if (b)
                                        qp[strlen(qp) - 1] = '\0';
                                qp++;
                        }
                        (void) sm_snprintf(frbuf, sizeof frbuf, "%s; %.800s",
                                           p, qp);

                        /* undo damage */
                        if (b)
                                qp[strlen(qp)] = '>';
                }
                else
                {
                        (void) sm_snprintf(frbuf, sizeof frbuf,
                                           "%s; %.700s@%.100s",
                                           p, q->q_user, MyHostName);
                }
                new->q_finalrcpt = sm_rpool_strdup_x(e->e_rpool, frbuf);
        }

#if _FFR_GEN_ORCPT
        /* set ORCPT DSN arg if not already set */
        if (new->q_orcpt == NULL)
        {
                /* check for an existing ORCPT */
                if (q->q_orcpt != NULL)
                        new->q_orcpt = q->q_orcpt;
                else
                {
                        /* make our own */
                        bool b = false;
                        char *qp;
                        char obuf[MAXLINE];

                        if (e->e_from.q_mailer != NULL)
                                p = e->e_from.q_mailer->m_addrtype;
                        if (p == NULL)
                                p = "rfc822";
                        (void) sm_strlcpyn(obuf, sizeof obuf, 2, p, ";");

                        qp = q->q_paddr;

                        /* FFR: Needs to strip comments from stdin addrs */

                        /* strip brackets from address */
                        if (*qp == '<')
                        {
                                b = qp[strlen(qp) - 1] == '>';
                                if (b)
                                        qp[strlen(qp) - 1] = '\0';
                                qp++;
                        }

                        p = xtextify(denlstring(qp, true, false), NULL);

                        if (sm_strlcat(obuf, p, sizeof obuf) >= sizeof obuf)
                        {
                                /* if too big, don't use it */
                                obuf[0] = '\0';
                        }

                        /* undo damage */
                        if (b)
                                qp[strlen(qp)] = '>';

                        if (obuf[0] != '\0')
                                new->q_orcpt =
                                        sm_rpool_strdup_x(e->e_rpool, obuf);
                }
        }
#endif /* _FFR_GEN_ORCPT */

        /* break aliasing loops */
        if (aliaslevel > MaxAliasRecursion)
        {
                new->q_state = QS_BADADDR;
                new->q_status = "5.4.6";
                usrerrenh(new->q_status,
                          "554 aliasing/forwarding loop broken (%d aliases deep; %d max)",
                          aliaslevel, MaxAliasRecursion);
                return new;
        }

        /*
        **  Finish setting up address structure.
        */

        /* get unquoted user for file, program or user.name check */
        i = strlen(new->q_user);
        if (i >= sizeof buf0)
        {
                buflen = i + 1;
                buf = xalloc(buflen);
        }
        else
        {
                buf = buf0;
                buflen = sizeof buf0;
        }
        (void) sm_strlcpy(buf, new->q_user, buflen);
        for (p = buf; *p != '\0' && !quoted; p++)
        {
                if (*p == '\\')
                        quoted = true;
        }
        stripquotes(buf);

        /* check for direct mailing to restricted mailers */
        if (m == ProgMailer)
        {
                if (new->q_alias == NULL || UseMSP ||
                    bitset(EF_UNSAFE, e->e_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        usrerrenh(new->q_status,
                                  "550 Cannot mail directly to programs");
                }
                else if (bitset(QBOGUSSHELL, new->q_alias->q_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        if (new->q_alias->q_ruser == NULL)
                                usrerrenh(new->q_status,
                                          "550 UID %d is an unknown user: cannot mail to programs",
                                          new->q_alias->q_uid);
                        else
                                usrerrenh(new->q_status,
                                          "550 User %s@%s doesn't have a valid shell for mailing to programs",
                                          new->q_alias->q_ruser, MyHostName);
                }
                else if (bitset(QUNSAFEADDR, new->q_alias->q_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        new->q_rstatus = "550 Unsafe for mailing to programs";
                        usrerrenh(new->q_status,
                                  "550 Address %s is unsafe for mailing to programs",
                                  new->q_alias->q_paddr);
                }
        }

        /*
        **  Look up this person in the recipient list.
        **      If they are there already, return, otherwise continue.
        **      If the list is empty, just add it.  Notice the cute
        **      hack to make from addresses suppress things correctly:
        **      the QS_DUPLICATE state will be set in the send list.
        **      [Please note: the emphasis is on "hack."]
        */

        prev = NULL;

        /*
        **  If this message is going to the queue or FastSplit is set
        **  and it is the first try and the envelope hasn't split, then we
        **  avoid doing an MX RR lookup now because one will be done when the
        **  message is extracted from the queue later. It can go to the queue
        **  because all messages are going to the queue or this mailer of
        **  the current recipient is marked expensive.
        */

        if (UseMSP || WILL_BE_QUEUED(e->e_sendmode) ||
            (!bitset(EF_SPLIT, e->e_flags) && e->e_ntries == 0 &&
             FastSplit > 0))
                sortfn = sorthost;
        else if (NoConnect && bitnset(M_EXPENSIVE, new->q_mailer->m_flags))
                sortfn = sortexpensive;
        else
                sortfn = sortbysignature;

        for (pq = sendq; (q = *pq) != NULL; pq = &q->q_next)
        {
                /*
                **  If address is "less than" it should be inserted now.
                **  If address is "greater than" current comparison it'll
                **  insert later in the list; so loop again (if possible).
                **  If address is "equal" (different equal than sameaddr()
                **  call) then check if sameaddr() will be true.
                **  Because this list is now sorted, it'll mean fewer
                **  comparisons and fewer loops which is important for more
                **  recipients.
                */

                i = (*sortfn)(new, q);
                if (i == 0) /* equal */
                {
                        /*
                        **  Sortbysignature() has said that the two have
                        **  equal MX RR's and the same user. Calling sameaddr()
                        **  now checks if the two hosts are as identical as the
                        **  MX RR's are (which might not be the case)
                        **  before saying these are the identical addresses.
                        */

                        if (sameaddr(q, new) &&
                            (bitset(QRCPTOK, q->q_flags) ||
                             !bitset(QPRIMARY, q->q_flags)))
                        {
                                if (tTd(26, 1))
                                {
                                        sm_dprintf("%s in sendq: ",
                                                   new->q_paddr);
                                        printaddr(q, false);
                                }
                                if (!bitset(QPRIMARY, q->q_flags))
                                {
                                        if (!QS_IS_DEAD(new->q_state))
                                                message("duplicate suppressed");
                                        else
                                                q->q_state = QS_DUPLICATE;
                                        q->q_flags |= new->q_flags;
                                }
                                else if (bitset(QSELFREF, q->q_flags)
                                         || q->q_state == QS_REMOVED)
                                {
                                        /*
                                        **  If an earlier milter removed the
                                        **  address, a later one can still add
                                        **  it back.
                                        */

                                        q->q_state = new->q_state;
                                        q->q_flags |= new->q_flags;
                                }
                                new = q;
                                goto done;
                        }
                }
                else if (i < 0) /* less than */
                {
                        insert = true;
                        break;
                }
                prev = pq;
        }

        /* pq should point to an address, never NULL */
        SM_ASSERT(pq != NULL);

        /* add address on list */
        if (insert)
        {
                /*
                **  insert before 'pq'. Only possible when at least 1
                **  ADDRESS is in the list already.
                */

                new->q_next = *pq;
                if (prev == NULL)
                        *sendq = new; /* To be the first ADDRESS */
                else
                        (*prev)->q_next = new;
        }
        else
        {
                /*
                **  Place in list at current 'pq' position. Possible
                **  when there are 0 or more ADDRESS's in the list.
                */

                new->q_next = NULL;
                *pq = new;
        }

        /* added a new address: clear split flag */
        e->e_flags &= ~EF_SPLIT;

        /*
        **  Alias the name and handle special mailer types.
        */

  trylocaluser:
        if (tTd(29, 7))
        {
                sm_dprintf("at trylocaluser: ");
                printaddr(new, false);
        }

        if (!QS_IS_OK(new->q_state))
        {
                if (QS_IS_UNDELIVERED(new->q_state))
                        e->e_nrcpts++;
                goto testselfdestruct;
        }

        if (m == InclMailer)
        {
                new->q_state = QS_INCLUDED;
                if (new->q_alias == NULL || UseMSP ||
                    bitset(EF_UNSAFE, e->e_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        usrerrenh(new->q_status,
                                  "550 Cannot mail directly to :include:s");
                }
                else
                {
                        int ret;

                        message("including file %s", new->q_user);
                        ret = include(new->q_user, false, new,
                                      sendq, aliaslevel, e);
                        if (transienterror(ret))
                        {
                                if (LogLevel > 2)
                                        sm_syslog(LOG_ERR, e->e_id,
                                                  "include %s: transient error: %s",
                                                  shortenstring(new->q_user,
                                                                MAXSHORTSTR),
                                                                sm_errstring(ret));
                                new->q_state = QS_QUEUEUP;
                                usrerr("451 4.2.4 Cannot open %s: %s",
                                        shortenstring(new->q_user,
                                                      MAXSHORTSTR),
                                        sm_errstring(ret));
                        }
                        else if (ret != 0)
                        {
                                new->q_state = QS_BADADDR;
                                new->q_status = "5.2.4";
                                usrerrenh(new->q_status,
                                          "550 Cannot open %s: %s",
                                          shortenstring(new->q_user,
                                                        MAXSHORTSTR),
                                          sm_errstring(ret));
                        }
                }
        }
        else if (m == FileMailer)
        {
                /* check if allowed */
                if (new->q_alias == NULL || UseMSP ||
                    bitset(EF_UNSAFE, e->e_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        usrerrenh(new->q_status,
                                  "550 Cannot mail directly to files");
                }
                else if (bitset(QBOGUSSHELL, new->q_alias->q_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        if (new->q_alias->q_ruser == NULL)
                                usrerrenh(new->q_status,
                                          "550 UID %d is an unknown user: cannot mail to files",
                                          new->q_alias->q_uid);
                        else
                                usrerrenh(new->q_status,
                                          "550 User %s@%s doesn't have a valid shell for mailing to files",
                                          new->q_alias->q_ruser, MyHostName);
                }
                else if (bitset(QUNSAFEADDR, new->q_alias->q_flags))
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.7.1";
                        new->q_rstatus = "550 Unsafe for mailing to files";
                        usrerrenh(new->q_status,
                                  "550 Address %s is unsafe for mailing to files",
                                  new->q_alias->q_paddr);
                }
        }

        /* try aliasing */
        if (!quoted && QS_IS_OK(new->q_state) &&
            bitnset(M_ALIASABLE, m->m_flags))
                alias(new, sendq, aliaslevel, e);

#if USERDB
        /* if not aliased, look it up in the user database */
        if (!bitset(QNOTREMOTE, new->q_flags) &&
            QS_IS_SENDABLE(new->q_state) &&
            bitnset(M_CHECKUDB, m->m_flags))
        {
                if (udbexpand(new, sendq, aliaslevel, e) == EX_TEMPFAIL)
                {
                        new->q_state = QS_QUEUEUP;
                        if (e->e_message == NULL)
                                e->e_message = "Deferred: user database error";
                        if (new->q_message == NULL)
                                new->q_message = "Deferred: user database error";
                        if (LogLevel > 8)
                                sm_syslog(LOG_INFO, e->e_id,
                                          "deferred: udbexpand: %s",
                                          sm_errstring(errno));
                        message("queued (user database error): %s",
                                sm_errstring(errno));
                        e->e_nrcpts++;
                        goto testselfdestruct;
                }
        }
#endif /* USERDB */

        /*
        **  If we have a level two config file, then pass the name through
        **  Ruleset 5 before sending it off.  Ruleset 5 has the right
        **  to rewrite it to another mailer.  This gives us a hook
        **  after local aliasing has been done.
        */

        if (tTd(29, 5))
        {
                sm_dprintf("recipient: testing local?  cl=%d, rr5=%p\n\t",
                           ConfigLevel, RewriteRules[5]);
                printaddr(new, false);
        }
        if (ConfigLevel >= 2 && RewriteRules[5] != NULL &&
            bitnset(M_TRYRULESET5, m->m_flags) &&
            !bitset(QNOTREMOTE, new->q_flags) &&
            QS_IS_OK(new->q_state))
        {
                maplocaluser(new, sendq, aliaslevel + 1, e);
        }

        /*
        **  If it didn't get rewritten to another mailer, go ahead
        **  and deliver it.
        */

        if (QS_IS_OK(new->q_state) &&
            bitnset(M_HASPWENT, m->m_flags))
        {
                auto bool fuzzy;
                SM_MBDB_T user;
                int status;

                /* warning -- finduser may trash buf */
                status = finduser(buf, &fuzzy, &user);
                switch (status)
                {
                  case EX_TEMPFAIL:
                        new->q_state = QS_QUEUEUP;
                        new->q_status = "4.5.2";
                        giveresponse(EX_TEMPFAIL, new->q_status, m, NULL,
                                     new->q_alias, (time_t) 0, e, new);
                        break;
                  default:
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.1.1";
                        new->q_rstatus = "550 5.1.1 User unknown";
                        giveresponse(EX_NOUSER, new->q_status, m, NULL,
                                     new->q_alias, (time_t) 0, e, new);
                        break;
                  case EX_OK:
                        if (fuzzy)
                        {
                                /* name was a fuzzy match */
                                new->q_user = sm_rpool_strdup_x(e->e_rpool,
                                                                user.mbdb_name);
                                if (findusercount++ > 3)
                                {
                                        new->q_state = QS_BADADDR;
                                        new->q_status = "5.4.6";
                                        usrerrenh(new->q_status,
                                                  "554 aliasing/forwarding loop for %s broken",
                                                  user.mbdb_name);
                                        goto done;
                                }

                                /* see if it aliases */
                                (void) sm_strlcpy(buf, user.mbdb_name, buflen);
                                goto trylocaluser;
                        }
                        if (*user.mbdb_homedir == '\0')
                                new->q_home = NULL;
                        else if (strcmp(user.mbdb_homedir, "/") == 0)
                                new->q_home = "";
                        else
                                new->q_home = sm_rpool_strdup_x(e->e_rpool,
                                                        user.mbdb_homedir);
                        if (user.mbdb_uid != SM_NO_UID)
                        {
                                new->q_uid = user.mbdb_uid;
                                new->q_gid = user.mbdb_gid;
                                new->q_flags |= QGOODUID;
                        }
                        new->q_ruser = sm_rpool_strdup_x(e->e_rpool,
                                                         user.mbdb_name);
                        if (user.mbdb_fullname[0] != '\0')
                                new->q_fullname = sm_rpool_strdup_x(e->e_rpool,
                                                        user.mbdb_fullname);
                        if (!usershellok(user.mbdb_name, user.mbdb_shell))
                        {
                                new->q_flags |= QBOGUSSHELL;
                        }
                        if (bitset(EF_VRFYONLY, e->e_flags))
                        {
                                /* don't do any more now */
                                new->q_state = QS_VERIFIED;
                        }
                        else if (!quoted)
                                forward(new, sendq, aliaslevel, e);
                }
        }
        if (!QS_IS_DEAD(new->q_state))
                e->e_nrcpts++;

  testselfdestruct:
        new->q_flags |= QTHISPASS;
        if (tTd(26, 8))
        {
                sm_dprintf("testselfdestruct: ");
                printaddr(new, false);
                if (tTd(26, 10))
                {
                        sm_dprintf("SENDQ:\n");
                        printaddr(*sendq, true);
                        sm_dprintf("----\n");
                }
        }
        if (new->q_alias == NULL && new != &e->e_from &&
            QS_IS_DEAD(new->q_state))
        {
                for (q = *sendq; q != NULL; q = q->q_next)
                {
                        if (!QS_IS_DEAD(q->q_state))
                                break;
                }
                if (q == NULL)
                {
                        new->q_state = QS_BADADDR;
                        new->q_status = "5.4.6";
                        usrerrenh(new->q_status,
                                  "554 aliasing/forwarding loop broken");
                }
        }

  done:
        new->q_flags |= QTHISPASS;
        if (buf != buf0)
                sm_free(buf); /* XXX leak if above code raises exception */

        /*
        **  If we are at the top level, check to see if this has
        **  expanded to exactly one address.  If so, it can inherit
        **  the primaryness of the address.
        **
        **  While we're at it, clear the QTHISPASS bits.
        */

        if (aliaslevel == 0)
        {
                int nrcpts = 0;
                ADDRESS *only = NULL;

                for (q = *sendq; q != NULL; q = q->q_next)
                {
                        if (bitset(QTHISPASS, q->q_flags) &&
                            QS_IS_SENDABLE(q->q_state))
                        {
                                nrcpts++;
                                only = q;
                        }
                        q->q_flags &= ~QTHISPASS;
                }
                if (nrcpts == 1)
                {
                        /* check to see if this actually got a new owner */
                        q = only;
                        while ((q = q->q_alias) != NULL)
                        {
                                if (q->q_owner != NULL)
                                        break;
                        }
                        if (q == NULL)
                                only->q_flags |= QPRIMARY;
                }
                else if (!initialdontsend && nrcpts > 0)
                {
                        /* arrange for return receipt */
                        e->e_flags |= EF_SENDRECEIPT;
                        new->q_flags |= QEXPANDED;
                        if (e->e_xfp != NULL &&
                            bitset(QPINGONSUCCESS, new->q_flags))
                                (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
                                                     "%s... expanded to multiple addresses\n",
                                                     new->q_paddr);
                }
        }
        new->q_flags |= QRCPTOK;
        (void) sm_snprintf(buf0, sizeof buf0, "%d", e->e_nrcpts);
        macdefine(&e->e_macro, A_TEMP, macid("{nrcpts}"), buf0);
        return new;
}
/*
**  FINDUSER -- find the password entry for a user.
**
**      This looks a lot like getpwnam, except that it may want to
**      do some fancier pattern matching in /etc/passwd.
**
**      This routine contains most of the time of many sendmail runs.
**      It deserves to be optimized.
**
**      Parameters:
**              name -- the name to match against.
**              fuzzyp -- an outarg that is set to true if this entry
**                      was found using the fuzzy matching algorithm;
**                      set to false otherwise.
**              user -- structure to fill in if user is found
**
**      Returns:
**              On success, fill in *user, set *fuzzyp and return EX_OK.
**              If the user was not found, return EX_NOUSER.
**              On error, return EX_TEMPFAIL or EX_OSERR.
**
**      Side Effects:
**              may modify name.
*/

int
finduser(name, fuzzyp, user)
        char *name;
        bool *fuzzyp;
        SM_MBDB_T *user;
{
#if MATCHGECOS
        register struct passwd *pw;
#endif /* MATCHGECOS */
        register char *p;
        bool tryagain;
        int status;

        if (tTd(29, 4))
                sm_dprintf("finduser(%s): ", name);

        *fuzzyp = false;

#if HESIOD
        /* DEC Hesiod getpwnam accepts numeric strings -- short circuit it */
        for (p = name; *p != '\0'; p++)
                if (!isascii(*p) || !isdigit(*p))
                        break;
        if (*p == '\0')
        {
                if (tTd(29, 4))
                        sm_dprintf("failed (numeric input)\n");
                return EX_NOUSER;
        }
#endif /* HESIOD */

        /* look up this login name using fast path */
        status = sm_mbdb_lookup(name, user);
        if (status != EX_NOUSER)
        {
                if (tTd(29, 4))
                        sm_dprintf("%s (non-fuzzy)\n", sm_strexit(status));
                return status;
        }

        /* try mapping it to lower case */
        tryagain = false;
        for (p = name; *p != '\0'; p++)
        {
                if (isascii(*p) && isupper(*p))
                {
                        *p = tolower(*p);
                        tryagain = true;
                }
        }
        if (tryagain && (status = sm_mbdb_lookup(name, user)) != EX_NOUSER)
        {
                if (tTd(29, 4))
                        sm_dprintf("%s (lower case)\n", sm_strexit(status));
                *fuzzyp = true;
                return status;
        }

#if MATCHGECOS
        /* see if fuzzy matching allowed */
        if (!MatchGecos)
        {
                if (tTd(29, 4))
                        sm_dprintf("not found (fuzzy disabled)\n");
                return EX_NOUSER;
        }

        /* search for a matching full name instead */
        for (p = name; *p != '\0'; p++)
        {
                if (*p == (SpaceSub & 0177) || *p == '_')
                        *p = ' ';
        }
        (void) setpwent();
        while ((pw = getpwent()) != NULL)
        {
                char buf[MAXNAME + 1];

# if 0
                if (sm_strcasecmp(pw->pw_name, name) == 0)
                {
                        if (tTd(29, 4))
                                sm_dprintf("found (case wrapped)\n");
                        break;
                }
# endif /* 0 */

                sm_pwfullname(pw->pw_gecos, pw->pw_name, buf, sizeof buf);
                if (strchr(buf, ' ') != NULL && sm_strcasecmp(buf, name) == 0)
                {
                        if (tTd(29, 4))
                                sm_dprintf("fuzzy matches %s\n", pw->pw_name);
                        message("sending to login name %s", pw->pw_name);
                        break;
                }
        }
        if (pw != NULL)
                *fuzzyp = true;
        else if (tTd(29, 4))
                sm_dprintf("no fuzzy match found\n");
# if DEC_OSF_BROKEN_GETPWENT    /* DEC OSF/1 3.2 or earlier */
        endpwent();
# endif /* DEC_OSF_BROKEN_GETPWENT */
        if (pw == NULL)
                return EX_NOUSER;
        sm_mbdb_frompw(user, pw);
        return EX_OK;
#else /* MATCHGECOS */
        if (tTd(29, 4))
                sm_dprintf("not found (fuzzy disabled)\n");
        return EX_NOUSER;
#endif /* MATCHGECOS */
}
/*
**  WRITABLE -- predicate returning if the file is writable.
**
**      This routine must duplicate the algorithm in sys/fio.c.
**      Unfortunately, we cannot use the access call since we
**      won't necessarily be the real uid when we try to
**      actually open the file.
**
**      Notice that ANY file with ANY execute bit is automatically
**      not writable.  This is also enforced by mailfile.
**
**      Parameters:
**              filename -- the file name to check.
**              ctladdr -- the controlling address for this file.
**              flags -- SFF_* flags to control the function.
**
**      Returns:
**              true -- if we will be able to write this file.
**              false -- if we cannot write this file.
**
**      Side Effects:
**              none.
*/

bool
writable(filename, ctladdr, flags)
        char *filename;
        ADDRESS *ctladdr;
        long flags;
{
        uid_t euid = 0;
        gid_t egid = 0;
        char *user = NULL;

        if (tTd(44, 5))
                sm_dprintf("writable(%s, 0x%lx)\n", filename, flags);

        /*
        **  File does exist -- check that it is writable.
        */

        if (geteuid() != 0)
        {
                euid = geteuid();
                egid = getegid();
                user = NULL;
        }
        else if (ctladdr != NULL)
        {
                euid = ctladdr->q_uid;
                egid = ctladdr->q_gid;
                user = ctladdr->q_user;
        }
        else if (bitset(SFF_RUNASREALUID, flags))
        {
                euid = RealUid;
                egid = RealGid;
                user = RealUserName;
        }
        else if (FileMailer != NULL && !bitset(SFF_ROOTOK, flags))
        {
                euid = FileMailer->m_uid;
                egid = FileMailer->m_gid;
                user = NULL;
        }
        else
        {
                euid = egid = 0;
                user = NULL;
        }
        if (!bitset(SFF_ROOTOK, flags))
        {
                if (euid == 0)
                {
                        euid = DefUid;
                        user = DefUser;
                }
                if (egid == 0)
                        egid = DefGid;
        }
        if (geteuid() == 0 &&
            (ctladdr == NULL || !bitset(QGOODUID, ctladdr->q_flags)))
                flags |= SFF_SETUIDOK;

        if (!bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail))
                flags |= SFF_NOSLINK;
        if (!bitnset(DBS_FILEDELIVERYTOHARDLINK, DontBlameSendmail))
                flags |= SFF_NOHLINK;

        errno = safefile(filename, euid, egid, user, flags, S_IWRITE, NULL);
        return errno == 0;
}
/*
**  INCLUDE -- handle :include: specification.
**
**      Parameters:
**              fname -- filename to include.
**              forwarding -- if true, we are reading a .forward file.
**                      if false, it's a :include: file.
**              ctladdr -- address template to use to fill in these
**                      addresses -- effective user/group id are
**                      the important things.
**              sendq -- a pointer to the head of the send queue
**                      to put these addresses in.
**              aliaslevel -- the alias nesting depth.
**              e -- the current envelope.
**
**      Returns:
**              open error status
**
**      Side Effects:
**              reads the :include: file and sends to everyone
**              listed in that file.
**
**      Security Note:
**              If you have restricted chown (that is, you can't
**              give a file away), it is reasonable to allow programs
**              and files called from this :include: file to be to be
**              run as the owner of the :include: file.  This is bogus
**              if there is any chance of someone giving away a file.
**              We assume that pre-POSIX systems can give away files.
**
**              There is an additional restriction that if you
**              forward to a :include: file, it will not take on
**              the ownership of the :include: file.  This may not
**              be necessary, but shouldn't hurt.
*/

static jmp_buf  CtxIncludeTimeout;

int
include(fname, forwarding, ctladdr, sendq, aliaslevel, e)
        char *fname;
        bool forwarding;
        ADDRESS *ctladdr;
        ADDRESS **sendq;
        int aliaslevel;
        ENVELOPE *e;
{
        SM_FILE_T *volatile fp = NULL;
        char *oldto = e->e_to;
        char *oldfilename = FileName;
        int oldlinenumber = LineNumber;
        register SM_EVENT *ev = NULL;
        int nincludes;
        int mode;
        volatile bool maxreached = false;
        register ADDRESS *ca;
        volatile uid_t saveduid;
        volatile gid_t savedgid;
        volatile uid_t uid;
        volatile gid_t gid;
        char *volatile user;
        int rval = 0;
        volatile long sfflags = SFF_REGONLY;
        register char *p;
        bool safechown = false;
        volatile bool safedir = false;
        struct stat st;
        char buf[MAXLINE];

        if (tTd(27, 2))
                sm_dprintf("include(%s)\n", fname);
        if (tTd(27, 4))
                sm_dprintf("   ruid=%d euid=%d\n",
                        (int) getuid(), (int) geteuid());
        if (tTd(27, 14))
        {
                sm_dprintf("ctladdr ");
                printaddr(ctladdr, false);
        }

        if (tTd(27, 9))
                sm_dprintf("include: old uid = %d/%d\n",
                           (int) getuid(), (int) geteuid());

        if (forwarding)
        {
                sfflags |= SFF_MUSTOWN|SFF_ROOTOK;
                if (!bitnset(DBS_GROUPWRITABLEFORWARDFILE, DontBlameSendmail))
                        sfflags |= SFF_NOGWFILES;
                if (!bitnset(DBS_WORLDWRITABLEFORWARDFILE, DontBlameSendmail))
                        sfflags |= SFF_NOWWFILES;
        }
        else
        {
                if (!bitnset(DBS_GROUPWRITABLEINCLUDEFILE, DontBlameSendmail))
                        sfflags |= SFF_NOGWFILES;
                if (!bitnset(DBS_WORLDWRITABLEINCLUDEFILE, DontBlameSendmail))
                        sfflags |= SFF_NOWWFILES;
        }

        /*
        **  If RunAsUser set, won't be able to run programs as user
        **  so mark them as unsafe unless the administrator knows better.
        */

        if ((geteuid() != 0 || RunAsUid != 0) &&
            !bitnset(DBS_NONROOTSAFEADDR, DontBlameSendmail))
        {
                if (tTd(27, 4))
                        sm_dprintf("include: not safe (euid=%d, RunAsUid=%d)\n",
                                   (int) geteuid(), (int) RunAsUid);
                ctladdr->q_flags |= QUNSAFEADDR;
        }

        ca = getctladdr(ctladdr);
        if (ca == NULL ||
            (ca->q_uid == DefUid && ca->q_gid == 0))
        {
                uid = DefUid;
                gid = DefGid;
                user = DefUser;
        }
        else
        {
                uid = ca->q_uid;
                gid = ca->q_gid;
                user = ca->q_user;
        }
#if MAILER_SETUID_METHOD != USE_SETUID
        saveduid = geteuid();
        savedgid = getegid();
        if (saveduid == 0)
        {
                if (!DontInitGroups)
                {
                        if (initgroups(user, gid) == -1)
                        {
                                rval = EAGAIN;
                                syserr("include: initgroups(%s, %d) failed",
                                        user, gid);
                                goto resetuid;
                        }
                }
                else
                {
                        GIDSET_T gidset[1];

                        gidset[0] = gid;
                        if (setgroups(1, gidset) == -1)
                        {
                                rval = EAGAIN;
                                syserr("include: setgroups() failed");
                                goto resetuid;
                        }
                }

                if (gid != 0 && setgid(gid) < -1)
                {
                        rval = EAGAIN;
                        syserr("setgid(%d) failure", gid);
                        goto resetuid;
                }
                if (uid != 0)
                {
# if MAILER_SETUID_METHOD == USE_SETEUID
                        if (seteuid(uid) < 0)
                        {
                                rval = EAGAIN;
                                syserr("seteuid(%d) failure (real=%d, eff=%d)",
                                        uid, (int) getuid(), (int) geteuid());
                                goto resetuid;
                        }
# endif /* MAILER_SETUID_METHOD == USE_SETEUID */
# if MAILER_SETUID_METHOD == USE_SETREUID
                        if (setreuid(0, uid) < 0)
                        {
                                rval = EAGAIN;
                                syserr("setreuid(0, %d) failure (real=%d, eff=%d)",
                                        uid, (int) getuid(), (int) geteuid());
                                goto resetuid;
                        }
# endif /* MAILER_SETUID_METHOD == USE_SETREUID */
                }
        }
#endif /* MAILER_SETUID_METHOD != USE_SETUID */

        if (tTd(27, 9))
                sm_dprintf("include: new uid = %d/%d\n",
                           (int) getuid(), (int) geteuid());

        /*
        **  If home directory is remote mounted but server is down,
        **  this can hang or give errors; use a timeout to avoid this
        */

        if (setjmp(CtxIncludeTimeout) != 0)
        {
                ctladdr->q_state = QS_QUEUEUP;
                errno = 0;

                /* return pseudo-error code */
                rval = E_SM_OPENTIMEOUT;
                goto resetuid;
        }
        if (TimeOuts.to_fileopen > 0)
                ev = sm_setevent(TimeOuts.to_fileopen, includetimeout, 0);
        else
                ev = NULL;


        /* check for writable parent directory */
        p = strrchr(fname, '/');
        if (p != NULL)
        {
                int ret;

                *p = '\0';
                ret = safedirpath(fname, uid, gid, user,
                                  sfflags|SFF_SAFEDIRPATH, 0, 0);
                if (ret == 0)
                {
                        /* in safe directory: relax chown & link rules */
                        safedir = true;
                        sfflags |= SFF_NOPATHCHECK;
                }
                else
                {
                        if (bitnset((forwarding ?
                                     DBS_FORWARDFILEINUNSAFEDIRPATH :
                                     DBS_INCLUDEFILEINUNSAFEDIRPATH),
                                    DontBlameSendmail))
                                sfflags |= SFF_NOPATHCHECK;
                        else if (bitnset((forwarding ?
                                          DBS_FORWARDFILEINGROUPWRITABLEDIRPATH :
                                          DBS_INCLUDEFILEINGROUPWRITABLEDIRPATH),
                                         DontBlameSendmail) &&
                                 ret == E_SM_GWDIR)
                        {
                                setbitn(DBS_GROUPWRITABLEDIRPATHSAFE,
                                        DontBlameSendmail);
                                ret = safedirpath(fname, uid, gid, user,
                                                  sfflags|SFF_SAFEDIRPATH,
                                                  0, 0);
                                clrbitn(DBS_GROUPWRITABLEDIRPATHSAFE,
                                        DontBlameSendmail);
                                if (ret == 0)
                                        sfflags |= SFF_NOPATHCHECK;
                                else
                                        sfflags |= SFF_SAFEDIRPATH;
                        }
                        else
                                sfflags |= SFF_SAFEDIRPATH;
                        if (ret > E_PSEUDOBASE &&
                            !bitnset((forwarding ?
                                      DBS_FORWARDFILEINUNSAFEDIRPATHSAFE :
                                      DBS_INCLUDEFILEINUNSAFEDIRPATHSAFE),
                                     DontBlameSendmail))
                        {
                                if (LogLevel > 11)
                                        sm_syslog(LOG_INFO, e->e_id,
                                                  "%s: unsafe directory path, marked unsafe",
                                                  shortenstring(fname, MAXSHORTSTR));
                                ctladdr->q_flags |= QUNSAFEADDR;
                        }
                }
                *p = '/';
        }

        /* allow links only in unwritable directories */
        if (!safedir &&
            !bitnset((forwarding ?
                      DBS_LINKEDFORWARDFILEINWRITABLEDIR :
                      DBS_LINKEDINCLUDEFILEINWRITABLEDIR),
                     DontBlameSendmail))
                sfflags |= SFF_NOLINK;

        rval = safefile(fname, uid, gid, user, sfflags, S_IREAD, &st);
        if (rval != 0)
        {
                /* don't use this :include: file */
                if (tTd(27, 4))
                        sm_dprintf("include: not safe (uid=%d): %s\n",
                                   (int) uid, sm_errstring(rval));
        }
        else if ((fp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, fname,
                                  SM_IO_RDONLY, NULL)) == NULL)
        {
                rval = errno;
                if (tTd(27, 4))
                        sm_dprintf("include: open: %s\n", sm_errstring(rval));
        }
        else if (filechanged(fname, sm_io_getinfo(fp,SM_IO_WHAT_FD, NULL), &st))
        {
                rval = E_SM_FILECHANGE;
                if (tTd(27, 4))
                        sm_dprintf("include: file changed after open\n");
        }
        if (ev != NULL)
                sm_clrevent(ev);

resetuid:

#if HASSETREUID || USESETEUID
        if (saveduid == 0)
        {
                if (uid != 0)
                {
# if USESETEUID
                        if (seteuid(0) < 0)
                                syserr("!seteuid(0) failure (real=%d, eff=%d)",
                                       (int) getuid(), (int) geteuid());
# else /* USESETEUID */
                        if (setreuid(-1, 0) < 0)
                                syserr("!setreuid(-1, 0) failure (real=%d, eff=%d)",
                                       (int) getuid(), (int) geteuid());
                        if (setreuid(RealUid, 0) < 0)
                                syserr("!setreuid(%d, 0) failure (real=%d, eff=%d)",
                                       (int) RealUid, (int) getuid(),
                                       (int) geteuid());
# endif /* USESETEUID */
                }
                if (setgid(savedgid) < 0)
                        syserr("!setgid(%d) failure (real=%d eff=%d)",
                               (int) savedgid, (int) getgid(),
                               (int) getegid());
        }
#endif /* HASSETREUID || USESETEUID */

        if (tTd(27, 9))
                sm_dprintf("include: reset uid = %d/%d\n",
                           (int) getuid(), (int) geteuid());

        if (rval == E_SM_OPENTIMEOUT)
                usrerr("451 4.4.1 open timeout on %s", fname);

        if (fp == NULL)
                return rval;

        if (fstat(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), &st) < 0)
        {
                rval = errno;
                syserr("Cannot fstat %s!", fname);
                (void) sm_io_close(fp, SM_TIME_DEFAULT);
                return rval;
        }

        /* if path was writable, check to avoid file giveaway tricks */
        safechown = chownsafe(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), safedir);
        if (tTd(27, 6))
                sm_dprintf("include: parent of %s is %s, chown is %ssafe\n",
                           fname, safedir ? "safe" : "dangerous",
                           safechown ? "" : "un");

        /* if no controlling user or coming from an alias delivery */
        if (safechown &&
            (ca == NULL ||
             (ca->q_uid == DefUid && ca->q_gid == 0)))
        {
                ctladdr->q_uid = st.st_uid;
                ctladdr->q_gid = st.st_gid;
                ctladdr->q_flags |= QGOODUID;
        }
        if (ca != NULL && ca->q_uid == st.st_uid)
        {
                /* optimization -- avoid getpwuid if we already have info */
                ctladdr->q_flags |= ca->q_flags & QBOGUSSHELL;
                ctladdr->q_ruser = ca->q_ruser;
        }
        else if (!forwarding)
        {
                register struct passwd *pw;

                pw = sm_getpwuid(st.st_uid);
                if (pw == NULL)
                {
                        ctladdr->q_uid = st.st_uid;
                        ctladdr->q_flags |= QBOGUSSHELL;
                }
                else
                {
                        char *sh;

                        ctladdr->q_ruser = sm_rpool_strdup_x(e->e_rpool,
                                                             pw->pw_name);
                        if (safechown)
                                sh = pw->pw_shell;
                        else
                                sh = "/SENDMAIL/ANY/SHELL/";
                        if (!usershellok(pw->pw_name, sh))
                        {
                                if (LogLevel > 11)
                                        sm_syslog(LOG_INFO, e->e_id,
                                                  "%s: user %s has bad shell %s, marked %s",
                                                  shortenstring(fname,
                                                                MAXSHORTSTR),
                                                  pw->pw_name, sh,
                                                  safechown ? "bogus" : "unsafe");
                                if (safechown)
                                        ctladdr->q_flags |= QBOGUSSHELL;
                                else
                                        ctladdr->q_flags |= QUNSAFEADDR;
                        }
                }
        }

        if (bitset(EF_VRFYONLY, e->e_flags))
        {
                /* don't do any more now */
                ctladdr->q_state = QS_VERIFIED;
                e->e_nrcpts++;
                (void) sm_io_close(fp, SM_TIME_DEFAULT);
                return rval;
        }

        /*
        **  Check to see if some bad guy can write this file
        **
        **      Group write checking could be more clever, e.g.,
        **      guessing as to which groups are actually safe ("sys"
        **      may be; "user" probably is not).
        */

        mode = S_IWOTH;
        if (!bitnset((forwarding ?
                      DBS_GROUPWRITABLEFORWARDFILESAFE :
                      DBS_GROUPWRITABLEINCLUDEFILESAFE),
                     DontBlameSendmail))
                mode |= S_IWGRP;

        if (bitset(mode, st.st_mode))
        {
                if (tTd(27, 6))
                        sm_dprintf("include: %s is %s writable, marked unsafe\n",
                                   shortenstring(fname, MAXSHORTSTR),
                                   bitset(S_IWOTH, st.st_mode) ? "world"
                                                               : "group");
                if (LogLevel > 11)
                        sm_syslog(LOG_INFO, e->e_id,
                                  "%s: %s writable %s file, marked unsafe",
                                  shortenstring(fname, MAXSHORTSTR),
                                  bitset(S_IWOTH, st.st_mode) ? "world" : "group",
                                  forwarding ? "forward" : ":include:");
                ctladdr->q_flags |= QUNSAFEADDR;
        }

        /* read the file -- each line is a comma-separated list. */
        FileName = fname;
        LineNumber = 0;
        ctladdr->q_flags &= ~QSELFREF;
        nincludes = 0;
        while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf, sizeof buf) != NULL &&
               !maxreached)
        {
                fixcrlf(buf, true);
                LineNumber++;
                if (buf[0] == '#' || buf[0] == '\0')
                        continue;

                /* <sp>#@# introduces a comment anywhere */
                /* for Japanese character sets */
                for (p = buf; (p = strchr(++p, '#')) != NULL; )
                {
                        if (p[1] == '@' && p[2] == '#' &&
                            isascii(p[-1]) && isspace(p[-1]) &&
                            (p[3] == '\0' || (isascii(p[3]) && isspace(p[3]))))
                        {
                                --p;
                                while (p > buf && isascii(p[-1]) &&
                                       isspace(p[-1]))
                                        --p;
                                p[0] = '\0';
                                break;
                        }
                }
                if (buf[0] == '\0')
                        continue;

                e->e_to = NULL;
                message("%s to %s",
                        forwarding ? "forwarding" : "sending", buf);
                if (forwarding && LogLevel > 10)
                        sm_syslog(LOG_INFO, e->e_id,
                                  "forward %.200s => %s",
                                  oldto, shortenstring(buf, MAXSHORTSTR));

                nincludes += sendtolist(buf, ctladdr, sendq, aliaslevel + 1, e);

                if (forwarding &&
                    MaxForwardEntries > 0 &&
                    nincludes >= MaxForwardEntries)
                {
                        /* just stop reading and processing further entries */
#if 0
                        /* additional: (?) */
                        ctladdr->q_state = QS_DONTSEND;
#endif /* 0 */

                        syserr("Attempt to forward to more than %d addresses (in %s)!",
                                MaxForwardEntries, fname);
                        maxreached = true;
                }
        }

        if (sm_io_error(fp) && tTd(27, 3))
                sm_dprintf("include: read error: %s\n", sm_errstring(errno));
        if (nincludes > 0 && !bitset(QSELFREF, ctladdr->q_flags))
        {
                if (tTd(27, 5))
                {
                        sm_dprintf("include: QS_DONTSEND ");
                        printaddr(ctladdr, false);
                }
                ctladdr->q_state = QS_DONTSEND;
        }

        (void) sm_io_close(fp, SM_TIME_DEFAULT);
        FileName = oldfilename;
        LineNumber = oldlinenumber;
        e->e_to = oldto;
        return rval;
}

static void
includetimeout()
{
        /*
        **  NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
        **      ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
        **      DOING.
        */

        errno = ETIMEDOUT;
        longjmp(CtxIncludeTimeout, 1);
}
/*
**  SENDTOARGV -- send to an argument vector.
**
**      Parameters:
**              argv -- argument vector to send to.
**              e -- the current envelope.
**
**      Returns:
**              none.
**
**      Side Effects:
**              puts all addresses on the argument vector onto the
**                      send queue.
*/

void
sendtoargv(argv, e)
        register char **argv;
        register ENVELOPE *e;
{
        register char *p;

        while ((p = *argv++) != NULL)
                (void) sendtolist(p, NULLADDR, &e->e_sendqueue, 0, e);
}
/*
**  GETCTLADDR -- get controlling address from an address header.
**
**      If none, get one corresponding to the effective userid.
**
**      Parameters:
**              a -- the address to find the controller of.
**
**      Returns:
**              the controlling address.
*/

ADDRESS *
getctladdr(a)
        register ADDRESS *a;
{
        while (a != NULL && !bitset(QGOODUID, a->q_flags))
                a = a->q_alias;
        return a;
}
/*
**  SELF_REFERENCE -- check to see if an address references itself
**
**      The check is done through a chain of aliases.  If it is part of
**      a loop, break the loop at the "best" address, that is, the one
**      that exists as a real user.
**
**      This is to handle the case of:
**              awc:            Andrew.Chang
**              Andrew.Chang:   awc@mail.server
**      which is a problem only on mail.server.
**
**      Parameters:
**              a -- the address to check.
**
**      Returns:
**              The address that should be retained.
*/

static ADDRESS *
self_reference(a)
        ADDRESS *a;
{
        ADDRESS *b;             /* top entry in self ref loop */
        ADDRESS *c;             /* entry that point to a real mail box */

        if (tTd(27, 1))
                sm_dprintf("self_reference(%s)\n", a->q_paddr);

        for (b = a->q_alias; b != NULL; b = b->q_alias)
        {
                if (sameaddr(a, b))
                        break;
        }

        if (b == NULL)
        {
                if (tTd(27, 1))
                        sm_dprintf("\t... no self ref\n");
                return NULL;
        }

        /*
        **  Pick the first address that resolved to a real mail box
        **  i.e has a mbdb entry.  The returned value will be marked
        **  QSELFREF in recipient(), which in turn will disable alias()
        **  from marking it as QS_IS_DEAD(), which mean it will be used
        **  as a deliverable address.
        **
        **  The 2 key thing to note here are:
        **      1) we are in a recursive call sequence:
        **              alias->sendtolist->recipient->alias
        **      2) normally, when we return back to alias(), the address
        **         will be marked QS_EXPANDED, since alias() assumes the
        **         expanded form will be used instead of the current address.
        **         This behaviour is turned off if the address is marked
        **         QSELFREF.  We set QSELFREF when we return to recipient().
        */

        c = a;
        while (c != NULL)
        {
                if (tTd(27, 10))
                        sm_dprintf("  %s", c->q_user);
                if (bitnset(M_HASPWENT, c->q_mailer->m_flags))
                {
                        SM_MBDB_T user;

                        if (tTd(27, 2))
                                sm_dprintf("\t... getpwnam(%s)... ", c->q_user);
                        if (sm_mbdb_lookup(c->q_user, &user) == EX_OK)
                        {
                                if (tTd(27, 2))
                                        sm_dprintf("found\n");

                                /* ought to cache results here */
                                if (sameaddr(b, c))
                                        return b;
                                else
                                        return c;
                        }
                        if (tTd(27, 2))
                                sm_dprintf("failed\n");
                }
                else
                {
                        /* if local delivery, compare usernames */
                        if (bitnset(M_LOCALMAILER, c->q_mailer->m_flags) &&
                            b->q_mailer == c->q_mailer)
                        {
                                if (tTd(27, 2))
                                        sm_dprintf("\t... local match (%s)\n",
                                                c->q_user);
                                if (sameaddr(b, c))
                                        return b;
                                else
                                        return c;
                        }
                }
                if (tTd(27, 10))
                        sm_dprintf("\n");
                c = c->q_alias;
        }

        if (tTd(27, 1))
                sm_dprintf("\t... cannot break loop for \"%s\"\n", a->q_paddr);

        return NULL;
}