* Copyright (c) 1983 Eric P. Allman
* Copyright (c) 1988 Regents of the University of California.
* %sccs.include.redist.c%
static char sccsid
[] = "@(#)recipient.c 6.6 (Berkeley) %G%";
** 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.
** The `ctladdr' is the address that expanded to be this one,
** e.g., in an alias expansion. This is used for a number of
** purposed, most notably inheritance of uid/gid for protection
** purposes. It is also used to detect self-reference in group
** expansions and the like.
** 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
** sendq -- a pointer to the head of a queue to put
** qflags -- special flags to set in the q_flags field.
** pointer to chain of addresses.
sendto(list
, copyf
, ctladdr
, qflags
)
register ADDRESS
*al
; /* list of addresses to send to */
bool firstone
; /* set on first address sent */
bool selfref
; /* set if this list includes ctladdr */
char delimiter
; /* the address delimiter */
ADDRESS
*sibl
; /* sibling pointer in tree */
ADDRESS
*prev
; /* previous sibling */
printf("sendto: %s\n ctladdr=", list
);
printaddr(ctladdr
, FALSE
);
/* heuristic to determine old versus new style addresses */
(strchr(list
, ',') != NULL
|| strchr(list
, ';') != NULL
||
strchr(list
, '<') != NULL
|| strchr(list
, '(') != NULL
))
e
->e_flags
&= ~EF_OLDSTYLE
;
if (!bitset(EF_OLDSTYLE
, e
->e_flags
) || ctladdr
!= NULL
)
for (p
= list
; *p
!= '\0'; )
extern char *DelimChar
; /* defined in prescan */
while (isspace(*p
) || *p
== ',')
a
= parseaddr(p
, (ADDRESS
*) NULL
, 1, delimiter
, e
);
a
->q_flags
|= ctladdr
->q_flags
& ~QPRIMARY
;
/* see if this should be marked as a primary address */
(firstone
&& *p
== '\0' && bitset(QPRIMARY
, ctladdr
->q_flags
)))
if (ctladdr
!= NULL
&& sameaddr(ctladdr
, a
))
/* if this alias doesn't include itself, delete ctladdr */
if (!selfref
&& ctladdr
!= NULL
)
printf("sendtolist: QDONTSEND ");
printaddr(ctladdr
, FALSE
);
ctladdr
->q_flags
|= QDONTSEND
;
/* arrange to send to everyone on the local send list */
register ADDRESS
*a
= al
;
extern ADDRESS
*recipient();
extern ADDRESS
*recipient();
extern ADDRESS
*addrref();
if (sibl
->q_fullname
== NULL
&& ctladdr
!= NULL
)
sibl
->q_fullname
= ctladdr
->q_fullname
;
/* link tree together (but only if the node is new) */
** ADDRREF -- return pointer to address that references another address.
** a -- address to check.
** r -- reference to find.
** address of node in tree rooted at 'a' that references
** NULL if no such node exists.
if (a
->q_child
== r
|| a
->q_sibling
== r
)
q
= addrref(a
->q_child
, r
);
** RECIPIENT -- Designate a message recipient
** Saves the named person for future mailing.
** a -- the (preparsed) address header for the recipient.
** sendq -- a pointer to the head of a queue to put the
** recipient in. Duplicate supression is done
** e -- the current envelope.
** pointer to address actually inserted in send list.
extern ADDRESS
*getctladdr();
extern char *RcptLogFile
;
register ADDRESS
**sendq
;
register struct mailer
*m
;
bool quoted
= FALSE
; /* set if the addr has a quote bit */
char buf
[MAXNAME
]; /* unquoted image of the user name */
/* break aliasing loops */
if (AliasLevel
> MAXRCRSN
)
usrerr("aliasing/forwarding loop broken");
** Finish setting up address structure.
/* set the queue timeout */
/* map user & host to lower case if requested on non-aliases */
/* get unquoted user for file, program or user.name check */
(void) strcpy(buf
, a
->q_user
);
for (p
= buf
; *p
!= '\0' && !quoted
; p
++)
/* check for direct mailing to restricted mailers */
if (a
->q_alias
== NULL
&& m
== ProgMailer
)
a
->q_flags
|= QDONTSEND
|QBADADDR
;
usrerr("Cannot mail directly to programs", m
->m_name
);
** 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 QDONTSEND bit will be set in the send list.
** [Please note: the emphasis is on "hack."]
for (pq
= sendq
; (q
= *pq
) != NULL
; pq
= &q
->q_next
)
if (!ForceMail
&& sameaddr(q
, a
))
printf("%s in sendq: ", a
->q_paddr
);
if (Verbose
&& !bitset(QDONTSEND
|QPSEUDO
, a
->q_flags
))
message(Arpa_Info
, "duplicate suppressed");
if (!bitset(QPRIMARY
, q
->q_flags
))
q
->q_flags
|= a
->q_flags
;
if (!bitset(QPSEUDO
, a
->q_flags
))
/* add address on list */
if (a
->q_alias
== NULL
&& RcptLogFile
!= NULL
&&
!bitset(QDONTSEND
, a
->q_flags
))
static int RcptLogFd
= -1;
** Log the incoming recipient name before aliasing,
** expanding, forwarding, rewriting, and all that jazz.
** We'll use this to track down out-of-date aliases,
** host names, and so forth.
/* try to open the log file */
RcptLogFd
= open(RcptLogFile
, O_WRONLY
|O_APPEND
|O_CREAT
, 0666);
(void) fcntl(RcptLogFd
, F_SETFD
, 1);
int l
= strlen(a
->q_paddr
);
if (write(RcptLogFd
, a
->q_paddr
, l
+ 1) < 0)
** Alias the name and handle special mailer types.
printf("at trylocaluser %s\n", a
->q_user
);
if (bitset(QDONTSEND
, a
->q_flags
))
usrerr("Cannot mail directly to :include:s");
message(Arpa_Info
, "including file %s", &a
->q_user
[9]);
(void) include(&a
->q_user
[9], FALSE
, a
, sendq
, e
);
else if (m
== FileMailer
)
/* check if writable or creatable */
if (a
->q_alias
== NULL
&& !QueueRun
)
a
->q_flags
|= QDONTSEND
|QBADADDR
;
usrerr("Cannot mail directly to files");
else if ((stat(buf
, &stb
) >= 0) ? (!writable(&stb
)) :
(*p
= '\0', !safefile(buf
, getruid(), S_IWRITE
|S_IEXEC
)))
giveresponse(EX_CANTCREAT
, m
, e
);
if (!bitset(QDONTSEND
, a
->q_flags
))
/* if not aliased, look it up in the user database */
if (!bitset(QDONTSEND
|QNOTREMOTE
, a
->q_flags
))
if (udbexpand(a
, sendq
, e
) == EX_TEMPFAIL
)
if (e
->e_message
== NULL
)
e
->e_message
= newstr("Deferred: user database error");
syslog(LOG_INFO
, "%s: deferred: udbexpand",
message(Arpa_Info
, "queued (user database error)");
/* if it was an alias or a UDB expansion, just return now */
if (bitset(QDONTSEND
, a
->q_flags
))
** 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 send rewrite it to another mailer. This gives us a hook
** after local aliasing has been done.
printf("recipient: testing local? cl=%d, rr5=%x\n\t",
ConfigLevel
, RewriteRules
[5]);
if (!bitset(QNOTREMOTE
, a
->q_flags
) && ConfigLevel
>= 2 &&
maplocaluser(a
, sendq
, e
);
** If it didn't get rewritten to another mailer, go ahead
if (!bitset(QDONTSEND
, a
->q_flags
))
register struct passwd
*pw
;
extern struct passwd
*finduser();
/* warning -- finduser may trash buf */
pw
= finduser(buf
, &fuzzy
);
giveresponse(EX_NOUSER
, m
, e
);
/* name was a fuzzy match */
a
->q_user
= newstr(pw
->pw_name
);
usrerr("aliasing/forwarding loop for %s broken",
(void) strcpy(buf
, pw
->pw_name
);
a
->q_home
= newstr(pw
->pw_dir
);
buildfname(pw
->pw_gecos
, pw
->pw_name
, nbuf
);
a
->q_fullname
= newstr(nbuf
);
if (!bitset(QDONTSEND
, a
->q_flags
))
** 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.
** 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.
** A pointer to a pw struct.
** NULL if name is unknown or ambiguous.
register struct passwd
*pw
;
extern struct passwd
*getpwent();
extern struct passwd
*getpwnam();
printf("finduser(%s): ", name
);
/* map upper => lower case */
for (p
= name
; *p
!= '\0'; p
++)
if (isascii(*p
) && isupper(*p
))
/* look up this login name using fast path */
if ((pw
= getpwnam(name
)) != NULL
)
printf("found (non-fuzzy)\n");
/* see if fuzzy matching allowed */
printf("not found (fuzzy disabled)\n");
/* search for a matching full name instead */
for (p
= name
; *p
!= '\0'; p
++)
if (*p
== (SpaceSub
& 0177) || *p
== '_')
while ((pw
= getpwent()) != NULL
)
if (strchr(buf
, ' ') != NULL
&& !strcasecmp(buf
, name
))
printf("fuzzy matches %s\n", pw
->pw_name
);
message(Arpa_Info
, "sending to %s <%s>",
printf("no fuzzy match found\n");
** 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.
** s -- pointer to a stat struct for the file.
** TRUE -- if we will be able to write this file.
** FALSE -- if we cannot write this file.
if (bitset(0111, s
->st_mode
))
if (bitset(S_ISUID
, s
->st_mode
))
if (bitset(S_ISGID
, s
->st_mode
))
return ((s
->st_mode
& bits
) != 0);
** INCLUDE -- handle :include: specification.
** 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
** sendq -- a pointer to the head of the send queue
** to put these addresses in.
** reads the :include: file and sends to everyone
static jmp_buf CtxIncludeTimeout
;
include(fname
, forwarding
, ctladdr
, sendq
, e
)
char *oldfilename
= FileName
;
int oldlinenumber
= LineNumber
;
register EVENT
*ev
= NULL
;
static int includetimeout();
printf("include(%s)\n", fname
);
** 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
|QDONTSEND
;
usrerr("451 open timeout on %s", fname
);
ev
= setevent((time_t) 60, includetimeout
, 0);
/* if forwarding, the input file must be marked safe */
if (forwarding
&& !safefile(fname
, ctladdr
->q_uid
, S_IREAD
))
/* don't use this .forward file */
printf("include: not safe (uid=%d)\n", ctladdr
->q_uid
);
usrerr("Cannot open %s", fname
);
if (getctladdr(ctladdr
) == NULL
)
if (fstat(fileno(fp
), &st
) < 0)
syserr("Cannot fstat %s!", fname
);
ctladdr
->q_uid
= st
.st_uid
;
ctladdr
->q_gid
= st
.st_gid
;
ctladdr
->q_flags
|= QGOODUID
;
/* read the file -- each line is a comma-separated list. */
while (fgets(buf
, sizeof buf
, fp
) != NULL
)
register char *p
= strchr(buf
, '\n');
if (buf
[0] == '#' || buf
[0] == '\0')
message(Arpa_Info
, "%s to %s",
forwarding
? "forwarding" : "sending", buf
);
sendto(buf
, 1, ctladdr
, 0);
LineNumber
= oldlinenumber
;
longjmp(CtxIncludeTimeout
, 1);
** SENDTOARGV -- send to an argument vector.
** argv -- argument vector to send to.
** puts all addresses on the argument vector onto the
while ((p
= *argv
++) != NULL
)
if (argv
[0] != NULL
&& argv
[1] != NULL
&& !strcasecmp(argv
[0], "at"))
if (strlen(p
) + strlen(argv
[1]) + 2 > sizeof nbuf
)
usrerr("address overflow");
(void) strcat(nbuf
, "@");
(void) strcat(nbuf
, argv
[1]);
sendto(p
, 0, (ADDRESS
*) NULL
, 0);
** GETCTLADDR -- get controlling address from an address header.
** If none, get one corresponding to the effective userid.
** a -- the address to find the controller of.
** the controlling address.
while (a
!= NULL
&& !bitset(QGOODUID
, a
->q_flags
))