don't alias \-quoted addresses

[unix-history] / usr / src / usr.sbin / sendmail / src / recipient.c

diff --git a/usr/src/usr.sbin/sendmail/src/recipient.c b/usr/src/usr.sbin/sendmail/src/recipient.c
index af232ee..af46314 100644 (file)
--- a/usr/src/usr.sbin/sendmail/src/recipient.c
+++ b/usr/src/usr.sbin/sendmail/src/recipient.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 1983 Eric P. Allman
+ * Copyright (c) 1983, 1995 Eric P. Allman

  * Copyright (c) 1988, 1993
  *     The Regents of the University of California.  All rights reserved.
  *
  * Copyright (c) 1988, 1993
  *     The Regents of the University of California.  All rights reserved.
  *


@@ -7,11 +7,10 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)recipient.c        8.15 (Berkeley) %G%";
+static char sccsid[] = "@(#)recipient.c        8.96 (Berkeley) %G%";

 #endif /* not lint */
 
 # include "sendmail.h"
 #endif /* not lint */
 
 # include "sendmail.h"

-# include <pwd.h>

 
 /*
 **  SENDTOLIST -- Designate a send list.
 
 /*
 **  SENDTOLIST -- Designate a send list.


@@ -33,6 +32,8 @@ static char sccsid[] = "@(#)recipient.c       8.15 (Berkeley) %G%";
 **                     expansion.
 **             sendq -- a pointer to the head of a queue to put
 **                     these people into.
 **                     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.
 **             qflags -- special flags to set in the q_flags field.
 **
 **             e -- the envelope in which to add these recipients.
 **             qflags -- special flags to set in the q_flags field.
 **


@@ -43,13 +44,18 @@ static char sccsid[] = "@(#)recipient.c     8.15 (Berkeley) %G%";
 **             none.
 */
 
 **             none.
 */
 

-# define MAXRCRSN      10
+#define MAXRCRSN       10      /* maximum levels of alias recursion */

 
 

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

 ADDRESS *
 sendto(list, copyf, ctladdr, qflags)
        char *list;
        ADDRESS *ctladdr;
        ADDRESS **sendq;
 ADDRESS *
 sendto(list, copyf, ctladdr, qflags)
        char *list;
        ADDRESS *ctladdr;
        ADDRESS **sendq;

+       int aliaslevel;

        register ENVELOPE *e;
        u_short qflags;
 {
        register ENVELOPE *e;
        u_short qflags;
 {


@@ -58,7 +64,10 @@ sendto(list, copyf, ctladdr, qflags)
        bool firstone;          /* set on first address sent */
        char delimiter;         /* the address delimiter */
        int naddrs;
        bool firstone;          /* set on first address sent */
        char delimiter;         /* the address delimiter */
        int naddrs;

+       int i;

        char *oldto = e->e_to;
        char *oldto = e->e_to;

+       char *bufp;
+       char buf[MAXNAME + 1];

        ADDRESS *sibl;          /* sibling pointer in tree */
        ADDRESS *prev;          /* previous sibling */
 
        ADDRESS *sibl;          /* sibling pointer in tree */
        ADDRESS *prev;          /* previous sibling */
 


@@ -87,7 +96,15 @@ sendto(list, copyf, ctladdr, qflags)
        al = NULL;
        naddrs = 0;
 
        al = NULL;
        naddrs = 0;
 

-       for (p = list; *p != '\0'; )
+       /* make sure we have enough space to copy the string */
+       i = strlen(list) + 1;
+       if (i <= sizeof buf)
+               bufp = buf;
+       else
+               bufp = xalloc(i);
+       strcpy(bufp, denlstring(list, FALSE, TRUE));
+
+       for (p = bufp; *p != '\0'; )

        {
                auto char *delimptr;
                register ADDRESS *a;
        {
                auto char *delimptr;
                register ADDRESS *a;


@@ -105,27 +122,6 @@ sendto(list, copyf, ctladdr, qflags)
                        a->q_flags |= ctladdr->q_flags & ~QPRIMARY;
                a->q_flags |= qflags;
 
                        a->q_flags |= ctladdr->q_flags & ~QPRIMARY;
                a->q_flags |= qflags;
 

-               /* see if this should be marked as a primary address */
-               if (ctladdr == NULL ||
-                   (firstone && *p == '\0' && bitset(QPRIMARY, ctladdr->q_flags)))
-                       a->q_flags |= QPRIMARY;
-
-               if (ctladdr != NULL && sameaddr(ctladdr, a))
-                       ctladdr->q_flags |= QSELFREF;
-               al = a;
-               firstone = FALSE;
-       }
-
-       /* arrange to send to everyone on the local send list */
-       prev = sibl = NULL;
-       if (ctladdr != NULL)
-               prev = ctladdr->q_child;
-       while (al != NULL)
-       {
-               register ADDRESS *a = al;
-               extern ADDRESS *recipient();
-
-               al = a->q_next;

                sibl = recipient(a);
                if (sibl != NULL)
                {
                sibl = recipient(a);
                if (sibl != NULL)
                {


@@ -145,6 +141,8 @@ sendto(list, copyf, ctladdr, qflags)
        }
 
        e->e_to = oldto;
        }
 
        e->e_to = oldto;

+       if (bufp != buf)
+               free(bufp);

        return (naddrs);
        if (ctladdr != NULL)
                ctladdr->q_child = prev;
        return (naddrs);
        if (ctladdr != NULL)
                ctladdr->q_child = prev;


@@ -194,6 +192,7 @@ addrref(a, r)
 **             sendq -- a pointer to the head of a queue to put the
 **                     recipient in.  Duplicate supression is done
 **                     in this queue.
 **             sendq -- a pointer to the head of a queue to put the
 **                     recipient in.  Duplicate supression is done
 **                     in this queue.

+**             aliaslevel -- the current alias nesting depth.

 **             e -- the current envelope.
 **
 **     Returns:
 **             e -- the current envelope.
 **
 **     Returns:


@@ -205,9 +204,10 @@ addrref(a, r)
 
 ADDRESS *
 ADDRESS *
 
 ADDRESS *
 ADDRESS *

-recipient(a, sendq, e)
+recipient(a, sendq, aliaslevel, e)

        register ADDRESS *a;
        register ADDRESS **sendq;
        register ADDRESS *a;
        register ADDRESS **sendq;

+       int aliaslevel;

        register ENVELOPE *e;
 {
        register ADDRESS *q;
        register ENVELOPE *e;
 {
        register ADDRESS *q;


@@ -216,15 +216,20 @@ recipient(a, sendq, e)
        register char *p;
        bool quoted = FALSE;            /* set if the addr has a quote bit */
        int findusercount = 0;
        register char *p;
        bool quoted = FALSE;            /* set if the addr has a quote bit */
        int findusercount = 0;

-       char buf[MAXNAME];              /* unquoted image of the user name */
+       bool initialdontsend = bitset(QDONTSEND, a->q_flags);
+       int i;
+       char *buf;
+       char buf0[MAXNAME + 1];         /* unquoted image of the user name */

        extern int safefile();
 
        e->e_to = a->q_paddr;
        m = a->q_mailer;
        errno = 0;
        extern int safefile();
 
        e->e_to = a->q_paddr;
        m = a->q_mailer;
        errno = 0;

+       if (aliaslevel == 0)
+               a->q_flags |= QPRIMARY;

        if (tTd(26, 1))
        {
        if (tTd(26, 1))
        {

-               printf("\nrecipient: ");
+               printf("\nrecipient (%d): ", aliaslevel);

                printaddr(a, FALSE);
        }
 
                printaddr(a, FALSE);
        }
 


@@ -238,9 +243,11 @@ recipient(a, sendq, e)
        }
 
        /* break aliasing loops */
        }
 
        /* break aliasing loops */

-       if (AliasLevel > MAXRCRSN)
+       if (aliaslevel > MAXRCRSN)

        {
        {

-               usrerr("554 aliasing/forwarding loop broken");
+               a->q_status = "5.4.6";
+               usrerr("554 aliasing/forwarding loop broken (%d aliases deep; %d max",
+                       aliaslevel, MAXRCRSN);

                return (NULL);
        }
 
                return (NULL);
        }
 


@@ -248,10 +255,12 @@ recipient(a, sendq, e)
        **  Finish setting up address structure.
        */
 
        **  Finish setting up address structure.
        */
 

-       /* set the queue timeout */
-       a->q_timeout = TimeOuts.to_q_return;
-

        /* get unquoted user for file, program or user.name check */
        /* get unquoted user for file, program or user.name check */

+       i = strlen(a->q_user);
+       if (i >= sizeof buf0)
+               buf = xalloc(i + 1);
+       else
+               buf = buf0;

        (void) strcpy(buf, a->q_user);
        for (p = buf; *p != '\0' && !quoted; p++)
        {
        (void) strcpy(buf, a->q_user);
        for (p = buf; *p != '\0' && !quoted; p++)
        {


@@ -261,11 +270,28 @@ recipient(a, sendq, e)
        stripquotes(buf);
 
        /* check for direct mailing to restricted mailers */
        stripquotes(buf);
 
        /* check for direct mailing to restricted mailers */

-       if (a->q_alias == NULL && m == ProgMailer &&
-           !bitset(EF_QUEUERUN, e->e_flags))
+       if (m == ProgMailer)

        {
        {

-               a->q_flags |= QBADADDR;
-               usrerr("550 Cannot mail directly to programs");
+               if (a->q_alias == NULL)
+               {
+                       a->q_flags |= QBADADDR;
+                       a->q_status = "5.7.1";
+                       usrerr("550 Cannot mail directly to programs");
+               }
+               else if (bitset(QBOGUSSHELL, a->q_alias->q_flags))
+               {
+                       a->q_flags |= QBADADDR;
+                       a->q_status = "5.7.1";
+                       usrerr("550 User %s@%s doesn't have a valid shell for mailing to programs",
+                               a->q_alias->q_ruser, MyHostName);
+               }
+               else if (bitset(QUNSAFEADDR, a->q_alias->q_flags))
+               {
+                       a->q_flags |= QBADADDR;
+                       a->q_status = "5.7.1";
+                       usrerr("550 Address %s is unsafe for mailing to programs",
+                               a->q_alias->q_paddr);
+               }

        }
 
        /*
        }
 
        /*


@@ -296,6 +322,8 @@ recipient(a, sendq, e)
                                        message("duplicate suppressed");
                                q->q_flags |= a->q_flags;
                        }
                                        message("duplicate suppressed");
                                q->q_flags |= a->q_flags;
                        }

+                       else if (bitset(QSELFREF, q->q_flags))
+                               q->q_flags |= a->q_flags & ~QDONTSEND;

                        if (!bitset(QPSEUDO, a->q_flags))
                                q->q_flags &= ~QPSEUDO;
                        return (q);
                        if (!bitset(QPSEUDO, a->q_flags))
                                q->q_flags &= ~QPSEUDO;
                        return (q);


@@ -325,9 +353,10 @@ recipient(a, sendq, e)
        if (m == InclMailer)
        {
                a->q_flags |= QDONTSEND;
        if (m == InclMailer)
        {
                a->q_flags |= QDONTSEND;

-               if (a->q_alias == NULL && !bitset(EF_QUEUERUN, e->e_flags))
+               if (a->q_alias == NULL)

                {
                        a->q_flags |= QBADADDR;
                {
                        a->q_flags |= QBADADDR;

+                       a->q_status = "5.7.1";

                        usrerr("550 Cannot mail directly to :include:s");
                }
                else
                        usrerr("550 Cannot mail directly to :include:s");
                }
                else


@@ -335,21 +364,24 @@ recipient(a, sendq, e)
                        int ret;
 
                        message("including file %s", a->q_user);
                        int ret;
 
                        message("including file %s", a->q_user);

-                       ret = include(a->q_user, FALSE, a, sendq, e);
+                       ret = include(a->q_user, FALSE, a, sendq, aliaslevel, e);

                        if (transienterror(ret))
                        {
 #ifdef LOG
                                if (LogLevel > 2)
                        if (transienterror(ret))
                        {
 #ifdef LOG
                                if (LogLevel > 2)

-                                       syslog(LOG_ERR, "%s: include %s: transient error: %e",
-                                               e->e_id, a->q_user, errstring(ret));
+                                       syslog(LOG_ERR, "%s: include %s: transient error: %s",
+                                               e->e_id == NULL ? "NOQUEUE" : e->e_id,
+                                               a->q_user, errstring(ret));

 #endif
                                a->q_flags |= QQUEUEUP;
 #endif
                                a->q_flags |= QQUEUEUP;

+                               a->q_flags &= ~QDONTSEND;

                                usrerr("451 Cannot open %s: %s",
                                        a->q_user, errstring(ret));
                        }
                        else if (ret != 0)
                        {
                                a->q_flags |= QBADADDR;
                                usrerr("451 Cannot open %s: %s",
                                        a->q_user, errstring(ret));
                        }
                        else if (ret != 0)
                        {
                                a->q_flags |= QBADADDR;

+                               a->q_status = "5.2.4";

                                usrerr("550 Cannot open %s: %s",
                                        a->q_user, errstring(ret));
                        }
                                usrerr("550 Cannot open %s: %s",
                                        a->q_user, errstring(ret));
                        }


@@ -357,42 +389,50 @@ recipient(a, sendq, e)
        }
        else if (m == FileMailer)
        {
        }
        else if (m == FileMailer)
        {

-               struct stat stb;

                extern bool writable();
 
                extern bool writable();
 

-               p = strrchr(buf, '/');

                /* check if writable or creatable */
                /* check if writable or creatable */

-               if (a->q_alias == NULL && !bitset(EF_QUEUERUN, e->e_flags))
+               if (a->q_alias == NULL)

                {
                        a->q_flags |= QBADADDR;
                {
                        a->q_flags |= QBADADDR;

+                       a->q_status = "5.7.1";

                        usrerr("550 Cannot mail directly to files");
                }
                        usrerr("550 Cannot mail directly to files");
                }

-               else if ((stat(buf, &stb) >= 0) ? (!writable(&stb)) :
-                   (*p = '\0', safefile(buf, RealUid, RealGid, NULL, TRUE, S_IWRITE|S_IEXEC) != 0))
+               else if (bitset(QBOGUSSHELL, a->q_alias->q_flags))

                {
                        a->q_flags |= QBADADDR;
                {
                        a->q_flags |= QBADADDR;

-                       giveresponse(EX_CANTCREAT, m, NULL, e);
+                       a->q_status = "5.7.1";
+                       usrerr("550 User %s@%s doesn't have a valid shell for mailing to files",
+                               a->q_alias->q_ruser, MyHostName);
+               }
+               else if (bitset(QUNSAFEADDR, a->q_alias->q_flags))
+               {
+                       a->q_flags |= QBADADDR;
+                       a->q_status = "5.7.1";
+                       usrerr("550 Address %s is unsafe for mailing to files",
+                               a->q_alias->q_paddr);
+               }
+               else if (!writable(buf, getctladdr(a), SFF_CREAT))
+               {
+                       a->q_flags |= QBADADDR;
+                       giveresponse(EX_CANTCREAT, m, NULL, a->q_alias,
+                                    (time_t) 0, e);

                }
                }

-       }
-
-       if (m != LocalMailer)
-       {
-               if (!bitset(QDONTSEND, a->q_flags))
-                       e->e_nrcpts++;
-               goto testselfdestruct;

        }
 
        /* try aliasing */
        }
 
        /* try aliasing */

-       alias(a, sendq, e);
+       if (!quoted && !bitset(QDONTSEND, a->q_flags) &&
+           bitnset(M_ALIASABLE, m->m_flags))
+               alias(a, sendq, aliaslevel, e);

 
 

-# ifdef USERDB
+# if USERDB

        /* if not aliased, look it up in the user database */
        /* if not aliased, look it up in the user database */

-       if (!bitset(QDONTSEND|QNOTREMOTE|QVERIFIED, a->q_flags))
+       if (!bitset(QDONTSEND|QNOTREMOTE|QVERIFIED, a->q_flags) &&
+           bitnset(M_CHECKUDB, m->m_flags))

        {
                extern int udbexpand();
        {
                extern int udbexpand();

-               extern int errno;

 
 

-               if (udbexpand(a, sendq, e) == EX_TEMPFAIL)
+               if (udbexpand(a, sendq, aliaslevel, e) == EX_TEMPFAIL)

                {
                        a->q_flags |= QQUEUEUP;
                        if (e->e_message == NULL)
                {
                        a->q_flags |= QQUEUEUP;
                        if (e->e_message == NULL)


@@ -400,7 +440,8 @@ recipient(a, sendq, e)
 # ifdef LOG
                        if (LogLevel > 8)
                                syslog(LOG_INFO, "%s: deferred: udbexpand: %s",
 # ifdef LOG
                        if (LogLevel > 8)
                                syslog(LOG_INFO, "%s: deferred: udbexpand: %s",

-                                       e->e_id, errstring(errno));
+                                       e->e_id == NULL ? "NOQUEUE" : e->e_id,
+                                       errstring(errno));

 # endif
                        message("queued (user database error): %s",
                                errstring(errno));
 # endif
                        message("queued (user database error): %s",
                                errstring(errno));


@@ -410,10 +451,6 @@ recipient(a, sendq, e)
        }
 # endif
 
        }
 # endif
 

-       /* if it was an alias or a UDB expansion, just return now */
-       if (bitset(QDONTSEND|QQUEUEUP|QVERIFIED, a->q_flags))
-               goto testselfdestruct;
-

        /*
        **  If we have a level two config file, then pass the name through
        **  Ruleset 5 before sending it off.  Ruleset 5 has the right
        /*
        **  If we have a level two config file, then pass the name through
        **  Ruleset 5 before sending it off.  Ruleset 5 has the right


@@ -427,10 +464,11 @@ recipient(a, sendq, e)
                        ConfigLevel, RewriteRules[5]);
                printaddr(a, FALSE);
        }
                        ConfigLevel, RewriteRules[5]);
                printaddr(a, FALSE);
        }

-       if (!bitset(QNOTREMOTE, a->q_flags) && ConfigLevel >= 2 &&
-           RewriteRules[5] != NULL)
+       if (!bitset(QNOTREMOTE|QDONTSEND|QQUEUEUP|QVERIFIED, a->q_flags) &&
+           ConfigLevel >= 2 && RewriteRules[5] != NULL &&
+           bitnset(M_TRYRULESET5, m->m_flags))

        {
        {

-               maplocaluser(a, sendq, e);
+               maplocaluser(a, sendq, aliaslevel + 1, e);

        }
 
        /*
        }
 
        /*


@@ -438,7 +476,8 @@ recipient(a, sendq, e)
        **  and deliver it.
        */
 
        **  and deliver it.
        */
 

-       if (!bitset(QDONTSEND|QQUEUEUP, a->q_flags))
+       if (!bitset(QDONTSEND|QQUEUEUP|QVERIFIED, a->q_flags) &&
+           bitnset(M_HASPWENT, m->m_flags))

        {
                auto bool fuzzy;
                register struct passwd *pw;
        {
                auto bool fuzzy;
                register struct passwd *pw;


@@ -449,11 +488,13 @@ recipient(a, sendq, e)
                if (pw == NULL)
                {
                        a->q_flags |= QBADADDR;
                if (pw == NULL)
                {
                        a->q_flags |= QBADADDR;

-                       giveresponse(EX_NOUSER, m, NULL, e);
+                       a->q_status = "5.1.1";
+                       giveresponse(EX_NOUSER, m, NULL, a->q_alias,
+                                    (time_t) 0, e);

                }
                else
                {
                }
                else
                {

-                       char nbuf[MAXNAME];
+                       char nbuf[MAXNAME + 1];

 
                        if (fuzzy)
                        {
 
                        if (fuzzy)
                        {


@@ -462,16 +503,20 @@ recipient(a, sendq, e)
                                if (findusercount++ > 3)
                                {
                                        a->q_flags |= QBADADDR;
                                if (findusercount++ > 3)
                                {
                                        a->q_flags |= QBADADDR;

+                                       a->q_status = "5.4.6";

                                        usrerr("554 aliasing/forwarding loop for %s broken",
                                                pw->pw_name);
                                        usrerr("554 aliasing/forwarding loop for %s broken",
                                                pw->pw_name);

-                                       return (a);
+                                       goto done;

                                }
 
                                /* see if it aliases */
                                (void) strcpy(buf, pw->pw_name);
                                goto trylocaluser;
                        }
                                }
 
                                /* see if it aliases */
                                (void) strcpy(buf, pw->pw_name);
                                goto trylocaluser;
                        }

-                       a->q_home = newstr(pw->pw_dir);
+                       if (strcmp(pw->pw_dir, "/") == 0)
+                               a->q_home = "";
+                       else
+                               a->q_home = newstr(pw->pw_dir);

                        a->q_uid = pw->pw_uid;
                        a->q_gid = pw->pw_gid;
                        a->q_ruser = newstr(pw->pw_name);
                        a->q_uid = pw->pw_uid;
                        a->q_gid = pw->pw_gid;
                        a->q_ruser = newstr(pw->pw_name);


@@ -479,31 +524,104 @@ recipient(a, sendq, e)
                        buildfname(pw->pw_gecos, pw->pw_name, nbuf);
                        if (nbuf[0] != '\0')
                                a->q_fullname = newstr(nbuf);
                        buildfname(pw->pw_gecos, pw->pw_name, nbuf);
                        if (nbuf[0] != '\0')
                                a->q_fullname = newstr(nbuf);

-                       if (!quoted)
-                               forward(a, sendq, e);
+                       if (!usershellok(pw->pw_name, pw->pw_shell))
+                       {
+                               a->q_flags |= QBOGUSSHELL;
+                       }
+                       if (bitset(EF_VRFYONLY, e->e_flags))
+                       {
+                               /* don't do any more now */
+                               a->q_flags |= QVERIFIED;
+                       }
+                       else if (!quoted)
+                               forward(a, sendq, aliaslevel, e);

                }
        }
        if (!bitset(QDONTSEND, a->q_flags))
                e->e_nrcpts++;
 
   testselfdestruct:
                }
        }
        if (!bitset(QDONTSEND, a->q_flags))
                e->e_nrcpts++;
 
   testselfdestruct:

+       a->q_flags |= QTHISPASS;

        if (tTd(26, 8))
        {
                printf("testselfdestruct: ");
        if (tTd(26, 8))
        {
                printf("testselfdestruct: ");

-               printaddr(a, TRUE);
+               printaddr(a, FALSE);
+               if (tTd(26, 10))
+               {
+                       printf("SENDQ:\n");
+                       printaddr(*sendq, TRUE);
+                       printf("----\n");
+               }

        }
        if (a->q_alias == NULL && a != &e->e_from &&
            bitset(QDONTSEND, a->q_flags))
        {
        }
        if (a->q_alias == NULL && a != &e->e_from &&
            bitset(QDONTSEND, a->q_flags))
        {

-               q = *sendq;
-               while (q != NULL && bitset(QDONTSEND, q->q_flags))
-                       q = q->q_next;
+               for (q = *sendq; q != NULL; q = q->q_next)
+               {
+                       if (!bitset(QDONTSEND, q->q_flags) &&
+                           bitset(QTHISPASS, q->q_flags))
+                               break;
+               }

                if (q == NULL)
                {
                        a->q_flags |= QBADADDR;
                if (q == NULL)
                {
                        a->q_flags |= QBADADDR;

+                       a->q_status = "5.4.6";

                        usrerr("554 aliasing/forwarding loop broken");
                }
        }
                        usrerr("554 aliasing/forwarding loop broken");
                }
        }

+
+  done:
+       a->q_flags |= QTHISPASS;
+       if (buf != buf0)
+               free(buf);
+
+       /*
+       **  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;
+
+               for (q = *sendq; q != NULL; q = q->q_next)
+               {
+                       if (bitset(QTHISPASS, q->q_flags) &&
+                           !bitset(QDONTSEND|QBADADDR, q->q_flags))
+                       {
+                               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;
+                       a->q_flags |= QEXPANDED;
+                       if (e->e_xfp != NULL)
+                               fprintf(e->e_xfp,
+                                       "%s... expanded to multiple addresses\n",
+                                       a->q_paddr);
+               }
+       }
+

        return (a);
 
        return (a);
        return (a);
 
        return (a);


@@ -538,23 +656,34 @@ finduser(name, fuzzyp)
 {
        register struct passwd *pw;
        register char *p;
 {
        register struct passwd *pw;
        register char *p;

-       extern struct passwd *getpwent();
-       extern struct passwd *getpwnam();

 
        if (tTd(29, 4))
                printf("finduser(%s): ", name);
 
        *fuzzyp = FALSE;
 
 
        if (tTd(29, 4))
                printf("finduser(%s): ", name);
 
        *fuzzyp = FALSE;
 

+#ifdef 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))
+                       printf("failed (numeric input)\n");
+               return NULL;
+       }
+#endif
+

        /* look up this login name using fast path */
        /* look up this login name using fast path */

-       if ((pw = getpwnam(name)) != NULL)
+       if ((pw = sm_getpwnam(name)) != NULL)

        {
                if (tTd(29, 4))
                        printf("found (non-fuzzy)\n");
                return (pw);
        }
 
        {
                if (tTd(29, 4))
                        printf("found (non-fuzzy)\n");
                return (pw);
        }
 

-#ifdef MATCHGECOS
+#if MATCHGECOS

        /* see if fuzzy matching allowed */
        if (!MatchGecos)
        {
        /* see if fuzzy matching allowed */
        if (!MatchGecos)
        {


@@ -604,7 +733,9 @@ finduser(name, fuzzyp)
 **     not writable.  This is also enforced by mailfile.
 **
 **     Parameters:
 **     not writable.  This is also enforced by mailfile.
 **
 **     Parameters:

-**             s -- pointer to a stat struct for the file.
+**             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.
 **
 **     Returns:
 **             TRUE -- if we will be able to write this file.


@@ -615,35 +746,62 @@ finduser(name, fuzzyp)
 */
 
 bool
 */
 
 bool

-writable(s)
-       register struct stat *s;
+writable(filename, ctladdr, flags)
+       char *filename;
+       ADDRESS *ctladdr;
+       int flags;

 {
        uid_t euid;
        gid_t egid;
 {
        uid_t euid;
        gid_t egid;

-       int bits;
+       char *uname;

 
 

-       if (bitset(0111, s->st_mode))
-               return (FALSE);
-       euid = RealUid;
-       egid = RealGid;
-       if (geteuid() == 0)
+       if (tTd(29, 5))
+               printf("writable(%s, 0x%x)\n", filename, flags);
+
+#ifdef SUID_ROOT_FILES_OK
+       /* really ought to be passed down -- and not a good idea */
+       flags |= SFF_ROOTOK;
+#endif
+
+       /*
+       **  File does exist -- check that it is writable.
+       */
+
+       if (ctladdr != NULL && geteuid() == 0)

        {
        {

-               if (bitset(S_ISUID, s->st_mode))
-                       euid = s->st_uid;
-               if (bitset(S_ISGID, s->st_mode))
-                       egid = s->st_gid;
+               euid = ctladdr->q_uid;
+               egid = ctladdr->q_gid;
+               uname = ctladdr->q_user;
+       }
+       else if (bitset(SFF_RUNASREALUID, flags))
+       {
+               euid = RealUid;
+               egid = RealGid;
+               uname = RealUserName;
+       }
+       else if (FileMailer != NULL)
+       {
+               euid = FileMailer->m_uid;
+               egid = FileMailer->m_gid;
+               uname = NULL;
+       }
+       else
+       {
+               euid = egid = 0;
+               uname = NULL;

        }
        }

-

        if (euid == 0)
        if (euid == 0)

-               return (TRUE);
-       bits = S_IWRITE;
-       if (euid != s->st_uid)

        {
        {

-               bits >>= 3;
-               if (egid != s->st_gid)
-                       bits >>= 3;
+               euid = DefUid;
+               uname = DefUser;

        }
        }

-       return ((s->st_mode & bits) != 0);
+       if (egid == 0)
+               egid = DefGid;
+       if (geteuid() == 0)
+               flags |= SFF_SETUIDOK;
+
+       errno = safefile(filename, euid, egid, uname, flags, S_IWRITE, NULL);
+       return errno == 0;

 }
 \f/*
 **  INCLUDE -- handle :include: specification.
 }
 \f/*
 **  INCLUDE -- handle :include: specification.


@@ -657,6 +815,8 @@ writable(s)
 **                     the important things.
 **             sendq -- a pointer to the head of the send queue
 **                     to put these addresses in.
 **                     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
 **
 **     Returns:
 **             open error status


@@ -664,31 +824,65 @@ writable(s)
 **     Side Effects:
 **             reads the :include: file and sends to everyone
 **             listed in that file.
 **     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;
 */
 
 static jmp_buf CtxIncludeTimeout;

-static int     includetimeout();
+static void    includetimeout();

 
 int
 
 int

-include(fname, forwarding, ctladdr, sendq, e)
+include(fname, forwarding, ctladdr, sendq, aliaslevel, e)

        char *fname;
        bool forwarding;
        ADDRESS *ctladdr;
        ADDRESS **sendq;
        char *fname;
        bool forwarding;
        ADDRESS *ctladdr;
        ADDRESS **sendq;

+       int aliaslevel;

        ENVELOPE *e;
 {
        ENVELOPE *e;
 {

-       register FILE *fp;
+       FILE *fp = NULL;

        char *oldto = e->e_to;
        char *oldfilename = FileName;
        int oldlinenumber = LineNumber;
        register EVENT *ev = NULL;
        int nincludes;
        char *oldto = e->e_to;
        char *oldfilename = FileName;
        int oldlinenumber = LineNumber;
        register EVENT *ev = NULL;
        int nincludes;

-       int ret;
-       ADDRESS *ca;
-       uid_t uid;
-       gid_t gid;
+       register ADDRESS *ca;
+       uid_t saveduid, uid;
+       gid_t savedgid, gid;

        char *uname;
        char *uname;

+       int rval = 0;
+       int sfflags = SFF_REGONLY;
+       struct stat st;

        char buf[MAXLINE];
        char buf[MAXLINE];

+#ifdef _POSIX_CHOWN_RESTRICTED
+# if _POSIX_CHOWN_RESTRICTED == -1
+#  define safechown    FALSE
+# else
+#  define safechown    TRUE
+# endif
+#else
+# ifdef _PC_CHOWN_RESTRICTED
+       bool safechown;
+# else
+#  ifdef BSD
+#   define safechown   TRUE
+#  else
+#   define safechown   FALSE
+#  endif
+# endif
+#endif
+       extern bool chownsafe();

 
        if (tTd(27, 2))
                printf("include(%s)\n", fname);
 
        if (tTd(27, 2))
                printf("include(%s)\n", fname);


@@ -700,17 +894,18 @@ include(fname, forwarding, ctladdr, sendq, e)
                printaddr(ctladdr, FALSE);
        }
 
                printaddr(ctladdr, FALSE);
        }
 

-       /*
-       **  If home directory is remote mounted but server is down,
-       **  this can hang or give errors; use a timeout to avoid this
-       */
+       if (tTd(27, 9))
+               printf("include: old uid = %d/%d\n", getuid(), geteuid());
+
+       if (forwarding)
+               sfflags |= SFF_MUSTOWN|SFF_ROOTOK|SFF_NOSLINK;

 
        ca = getctladdr(ctladdr);
        if (ca == NULL)
        {
 
        ca = getctladdr(ctladdr);
        if (ca == NULL)
        {

-               uid = 0;
-               gid = 0;
-               uname = NULL;
+               uid = DefUid;
+               gid = DefGid;
+               uname = DefUser;

        }
        else
        {
        }
        else
        {


@@ -718,59 +913,153 @@ include(fname, forwarding, ctladdr, sendq, e)
                gid = ca->q_gid;
                uname = ca->q_user;
        }
                gid = ca->q_gid;
                uname = ca->q_user;
        }

+#if HASSETREUID || USESETEUID
+       saveduid = geteuid();
+       savedgid = getegid();
+       if (saveduid == 0)
+       {
+               initgroups(uname, gid);
+               if (uid != 0)
+               {
+# if USESETEUID
+                       if (seteuid(uid) < 0)
+                               syserr("seteuid(%d) failure (real=%d, eff=%d)",
+                                       uid, getuid(), geteuid());
+# else
+                       if (setreuid(0, uid) < 0)
+                               syserr("setreuid(0, %d) failure (real=%d, eff=%d)",
+                                       uid, getuid(), geteuid());
+# endif
+                       else
+                               sfflags |= SFF_NOPATHCHECK;
+               }
+       }
+#endif
+
+       if (tTd(27, 9))
+               printf("include: new uid = %d/%d\n", getuid(), 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_flags |= QQUEUEUP;
                errno = 0;
 
        if (setjmp(CtxIncludeTimeout) != 0)
        {
                ctladdr->q_flags |= QQUEUEUP;
                errno = 0;

-               usrerr("451 open timeout on %s", fname);

 
                /* return pseudo-error code */
 
                /* return pseudo-error code */

-               return EOPENTIMEOUT;
+               rval = EOPENTIMEOUT;
+               goto resetuid;

        }
        }

-       ev = setevent((time_t) 60, includetimeout, 0);
+       if (TimeOuts.to_fileopen > 0)
+               ev = setevent(TimeOuts.to_fileopen, includetimeout, 0);
+       else
+               ev = NULL;

 
        /* the input file must be marked safe */
 
        /* the input file must be marked safe */

-       ret = safefile(fname, uid, gid, uname, forwarding, S_IREAD);
-       if (ret != 0)
+       rval = safefile(fname, uid, gid, uname, sfflags, S_IREAD, NULL);
+       if (rval != 0)

        {
        {

-               /* don't use this .forward file */
-               clrevent(ev);
+               /* don't use this :include: file */

                if (tTd(27, 4))
                        printf("include: not safe (uid=%d): %s\n",
                if (tTd(27, 4))
                        printf("include: not safe (uid=%d): %s\n",

-                               uid, errstring(ret));
-               return ret;
+                               uid, errstring(rval));

        }
        }

-
-       fp = fopen(fname, "r");
-       if (fp == NULL)
+       else

        {
        {

-               int ret = errno;
-
-               clrevent(ev);
-               if (tTd(27, 4))
-                       printf("include: open: %s\n", errstring(ret));
-               return ret;
+               fp = fopen(fname, "r");
+               if (fp == NULL)
+               {
+                       rval = errno;
+                       if (tTd(27, 4))
+                               printf("include: open: %s\n", errstring(rval));
+               }

        }
        }

+       if (ev != NULL)
+               clrevent(ev);

 
 

-       if (ca == NULL)
-       {
-               struct stat st;
+resetuid:

 
 

-               if (fstat(fileno(fp), &st) < 0)
+#if HASSETREUID || USESETEUID
+       if (saveduid == 0)
+       {
+               if (uid != 0)

                {
                {

-                       int ret = errno;
-
-                       clrevent(ev);
-                       syserr("Cannot fstat %s!", fname);
-                       return ret;
+# if USESETEUID
+                       if (seteuid(0) < 0)
+                               syserr("seteuid(0) failure (real=%d, eff=%d)",
+                                       getuid(), geteuid());
+# else
+                       if (setreuid(-1, 0) < 0)
+                               syserr("setreuid(-1, 0) failure (real=%d, eff=%d)",
+                                       getuid(), geteuid());
+                       if (setreuid(RealUid, 0) < 0)
+                               syserr("setreuid(%d, 0) failure (real=%d, eff=%d)",
+                                       RealUid, getuid(), geteuid());
+# endif

                }
                }

+               setgid(savedgid);
+       }
+#endif
+
+       if (tTd(27, 9))
+               printf("include: reset uid = %d/%d\n", getuid(), geteuid());
+
+       if (rval == EOPENTIMEOUT)
+               usrerr("451 open timeout on %s", fname);
+
+       if (fp == NULL)
+               return rval;
+
+       if (fstat(fileno(fp), &st) < 0)
+       {
+               rval = errno;
+               syserr("Cannot fstat %s!", fname);
+               return rval;
+       }
+
+#ifndef safechown
+       safechown = chownsafe(fileno(fp));
+#endif
+       if (ca == NULL && safechown)
+       {

                ctladdr->q_uid = st.st_uid;
                ctladdr->q_gid = st.st_gid;
                ctladdr->q_flags |= QGOODUID;
        }
                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
+       {
+               register struct passwd *pw;

 
 

-       clrevent(ev);
+               pw = sm_getpwuid(st.st_uid);
+               if (pw == NULL)
+                       ctladdr->q_flags |= QBOGUSSHELL;
+               else
+               {
+                       char *sh;
+
+                       ctladdr->q_ruser = newstr(pw->pw_name);
+                       if (safechown)
+                               sh = pw->pw_shell;
+                       else
+                               sh = "/SENDMAIL/ANY/SHELL/";
+                       if (!usershellok(pw->pw_name, sh))
+                       {
+                               if (safechown)
+                                       ctladdr->q_flags |= QBOGUSSHELL;
+                               else
+                                       ctladdr->q_flags |= QUNSAFEADDR;
+                       }
+               }
+       }

 
        if (bitset(EF_VRFYONLY, e->e_flags))
        {
 
        if (bitset(EF_VRFYONLY, e->e_flags))
        {


@@ -778,9 +1067,22 @@ include(fname, forwarding, ctladdr, sendq, e)
                ctladdr->q_flags |= QVERIFIED;
                e->e_nrcpts++;
                xfclose(fp, "include", fname);
                ctladdr->q_flags |= QVERIFIED;
                e->e_nrcpts++;
                xfclose(fp, "include", fname);

-               return 0;
+               return rval;

        }
 
        }
 

+       /*
+       ** Check to see if some bad guy can write this file
+       **
+       **      This should really do something clever with group
+       **      permissions; currently we just view world writable
+       **      as unsafe.  Also, we don't check for writable
+       **      directories in the path.  We've got to leave
+       **      something for the local sysad to do.
+       */
+
+       if (bitset(S_IWOTH, st.st_mode))
+               ctladdr->q_flags |= QUNSAFEADDR;
+

        /* read the file -- each line is a comma-separated list. */
        FileName = fname;
        LineNumber = 0;
        /* read the file -- each line is a comma-separated list. */
        FileName = fname;
        LineNumber = 0;


@@ -795,18 +1097,33 @@ include(fname, forwarding, ctladdr, sendq, e)
                        *p = '\0';
                if (buf[0] == '#' || buf[0] == '\0')
                        continue;
                        *p = '\0';
                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[-1] = '\0';
+                               break;
+                       }
+               }
+               if (buf[0] == '\0')
+                       continue;
+

                e->e_to = NULL;
                message("%s to %s",
                        forwarding ? "forwarding" : "sending", buf);
 #ifdef LOG
                if (forwarding && LogLevel > 9)
                        syslog(LOG_INFO, "%s: forward %s => %s",
                e->e_to = NULL;
                message("%s to %s",
                        forwarding ? "forwarding" : "sending", buf);
 #ifdef LOG
                if (forwarding && LogLevel > 9)
                        syslog(LOG_INFO, "%s: forward %s => %s",

-                               e->e_id, oldto, buf);
+                               e->e_id == NULL ? "NOQUEUE" : e->e_id,
+                               oldto, buf);

 #endif
 
 #endif
 

-               AliasLevel++;
-               sendto(buf, 1, ctladdr, 0);
-               AliasLevel--;
+               nincludes += sendtolist(buf, ctladdr, sendq, aliaslevel + 1, e);

        }
 
        if (ferror(fp) && tTd(27, 3))
        }
 
        if (ferror(fp) && tTd(27, 3))


@@ -825,10 +1142,10 @@ include(fname, forwarding, ctladdr, sendq, e)
        FileName = oldfilename;
        LineNumber = oldlinenumber;
        e->e_to = oldto;
        FileName = oldfilename;
        LineNumber = oldlinenumber;
        e->e_to = oldto;

-       return 0;
+       return rval;

 }
 
 }
 

-static
+static void

 includetimeout()
 {
        longjmp(CtxIncludeTimeout, 1);
 includetimeout()
 {
        longjmp(CtxIncludeTimeout, 1);


@@ -848,6 +1165,7 @@ includetimeout()
 **                     send queue.
 */
 
 **                     send queue.
 */
 

+void

 sendtoargv(argv, e)
        register char **argv;
        register ENVELOPE *e;
 sendtoargv(argv, e)
        register char **argv;
        register ENVELOPE *e;


@@ -882,3 +1200,93 @@ getctladdr(a)
                a = a->q_alias;
        return (a);
 }
                a = a->q_alias;
        return (a);
 }

+\f/*
+**  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.
+**             e -- the current envelope.
+**
+**     Returns:
+**             The address that should be retained.
+*/
+
+ADDRESS *
+self_reference(a, e)
+       ADDRESS *a;
+       ENVELOPE *e;
+{
+       ADDRESS *b;             /* top entry in self ref loop */
+       ADDRESS *c;             /* entry that point to a real mail box */
+
+       if (tTd(27, 1))
+               printf("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))
+                       printf("\t... no self ref\n");
+               return NULL;
+       }
+
+       /*
+       **  Pick the first address that resolved to a real mail box
+       **  i.e has a pw entry.  The returned value will be marked
+       **  QSELFREF in recipient(), which in turn will disable alias()
+       **  from marking it QDONTSEND, 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->sentolist->recipient->alias
+       **      2) normally, when we return back to alias(), the address
+       **         will be marked QDONTSEND, 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 (bitnset(M_HASPWENT, c->q_mailer->m_flags))
+               {
+                       if (tTd(27, 2))
+                               printf("\t... getpwnam(%s)... ", c->q_user);
+                       if (sm_getpwnam(c->q_user) != NULL)
+                       {
+                               if (tTd(27, 2))
+                                       printf("found\n");
+
+                               /* ought to cache results here */
+                               if (sameaddr(b, c))
+                                       return b;
+                               else
+                                       return c;
+                       }
+                       if (tTd(27, 2))
+                               printf("failed\n");
+               }
+               c = c->q_alias;
+       }
+
+       if (tTd(27, 1))
+               printf("\t... cannot break loop for \"%s\"\n", a->q_paddr);
+
+       return NULL;
+}