Imported Upstream version 8.8.8upstream/8.8.8

1 files changed, 871 insertions, 0 deletions

diff --git a/src/alias.c b/src/alias.c
new file mode 100644
index 0000000..cebd805
--- /dev/null
+++ b/src/alias.c
@@ -0,0 +1,871 @@
+/*
+ * Copyright (c) 1983, 1995-1997 Eric P. Allman
+ * Copyright (c) 1988, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+# include "sendmail.h"
+
+#ifndef lint
+static char sccsid[] = "@(#)alias.c	8.73 (Berkeley) 5/8/97";
+#endif /* not lint */
+
+
+MAP	*AliasFileMap = NULL;	/* the actual aliases.files map */
+int	NAliasFileMaps;		/* the number of entries in AliasFileMap */
+/*
+**  ALIAS -- Compute aliases.
+**
+**	Scans the alias file for an alias for the given address.
+**	If found, it arranges to deliver to the alias list instead.
+**	Uses libdbm database if -DDBM.
+**
+**	Parameters:
+**		a -- address to alias.
+**		sendq -- a pointer to the head of the send queue
+**			to put the aliases in.
+**		aliaslevel -- the current alias nesting depth.
+**		e -- the current envelope.
+**
+**	Returns:
+**		none
+**
+**	Side Effects:
+**		Aliases found are expanded.
+**
+**	Deficiencies:
+**		It should complain about names that are aliased to
+**			nothing.
+*/
+
+void
+alias(a, sendq, aliaslevel, e)
+	register ADDRESS *a;
+	ADDRESS **sendq;
+	int aliaslevel;
+	register ENVELOPE *e;
+{
+	register char *p;
+	char *owner;
+	auto int stat = EX_OK;
+	char obuf[MAXNAME + 7];
+	extern char *aliaslookup();
+
+	if (tTd(27, 1))
+		printf("alias(%s)\n", a->q_user);
+
+	/* don't realias already aliased names */
+	if (bitset(QDONTSEND|QBADADDR|QVERIFIED, a->q_flags))
+		return;
+
+	if (NoAlias)
+		return;
+
+	e->e_to = a->q_paddr;
+
+	/*
+	**  Look up this name.
+	**
+	**	If the map was unavailable, we will queue this message
+	**	until the map becomes available; otherwise, we could
+	**	bounce messages inappropriately.
+	*/
+
+	p = aliaslookup(a->q_user, &stat, e);
+	if (stat == EX_TEMPFAIL || stat == EX_UNAVAILABLE)
+	{
+		a->q_flags |= QQUEUEUP;
+		if (e->e_message == NULL)
+			e->e_message = "alias database unavailable";
+		return;
+	}
+	if (p == NULL)
+		return;
+
+	/*
+	**  Match on Alias.
+	**	Deliver to the target list.
+	*/
+
+	if (tTd(27, 1))
+		printf("%s (%s, %s) aliased to %s\n",
+		    a->q_paddr, a->q_host, a->q_user, p);
+	if (bitset(EF_VRFYONLY, e->e_flags))
+	{
+		a->q_flags |= QVERIFIED;
+		return;
+	}
+	message("aliased to %s", shortenstring(p, 203));
+	if (LogLevel > 9)
+		sm_syslog(LOG_INFO, e->e_id,
+			"alias %.100s => %s",
+			a->q_paddr, shortenstring(p, 203));
+	a->q_flags &= ~QSELFREF;
+	if (tTd(27, 5))
+	{
+		printf("alias: QDONTSEND ");
+		printaddr(a, FALSE);
+	}
+	a->q_flags |= QDONTSEND;
+	(void) sendtolist(p, a, sendq, aliaslevel + 1, e);
+	if (bitset(QSELFREF, a->q_flags))
+		a->q_flags &= ~QDONTSEND;
+
+	/*
+	**  Look for owner of alias
+	*/
+
+	(void) strcpy(obuf, "owner-");
+	if (strncmp(a->q_user, "owner-", 6) == 0 ||
+	    strlen(a->q_user) > (SIZE_T) sizeof obuf - 7)
+		(void) strcat(obuf, "owner");
+	else
+		(void) strcat(obuf, a->q_user);
+	owner = aliaslookup(obuf, &stat, e);
+	if (owner == NULL)
+		return;
+
+	/* reflect owner into envelope sender */
+	if (strpbrk(owner, ",:/|\"") != NULL)
+		owner = obuf;
+	a->q_owner = newstr(owner);
+
+	/* announce delivery to this alias; NORECEIPT bit set later */
+	if (e->e_xfp != NULL)
+		fprintf(e->e_xfp, "Message delivered to mailing list %s\n",
+			a->q_paddr);
+	e->e_flags |= EF_SENDRECEIPT;
+	a->q_flags |= QDELIVERED|QEXPANDED;
+}
+/*
+**  ALIASLOOKUP -- look up a name in the alias file.
+**
+**	Parameters:
+**		name -- the name to look up.
+**		pstat -- a pointer to a place to put the status.
+**		e -- the current envelope.
+**
+**	Returns:
+**		the value of name.
+**		NULL if unknown.
+**
+**	Side Effects:
+**		none.
+**
+**	Warnings:
+**		The return value will be trashed across calls.
+*/
+
+char *
+aliaslookup(name, pstat, e)
+	char *name;
+	int *pstat;
+	ENVELOPE *e;
+{
+	static MAP *map = NULL;
+
+	if (map == NULL)
+	{
+		STAB *s = stab("aliases", ST_MAP, ST_FIND);
+
+		if (s == NULL)
+			return NULL;
+		map = &s->s_map;
+	}
+	if (!bitset(MF_OPEN, map->map_mflags))
+		return NULL;
+
+	/* special case POstMastER -- always use lower case */
+	if (strcasecmp(name, "postmaster") == 0)
+		name = "postmaster";
+
+	return (*map->map_class->map_lookup)(map, name, NULL, pstat);
+}
+/*
+**  SETALIAS -- set up an alias map
+**
+**	Called when reading configuration file.
+**
+**	Parameters:
+**		spec -- the alias specification
+**
+**	Returns:
+**		none.
+*/
+
+void
+setalias(spec)
+	char *spec;
+{
+	register char *p;
+	register MAP *map;
+	char *class;
+	STAB *s;
+
+	if (tTd(27, 8))
+		printf("setalias(%s)\n", spec);
+
+	for (p = spec; p != NULL; )
+	{
+		char buf[50];
+
+		while (isspace(*p))
+			p++;
+		if (*p == '\0')
+			break;
+		spec = p;
+
+		if (NAliasFileMaps >= MAXMAPSTACK)
+		{
+			syserr("Too many alias databases defined, %d max",
+				MAXMAPSTACK);
+			return;
+		}
+		if (AliasFileMap == NULL)
+		{
+			strcpy(buf, "aliases.files sequence");
+			AliasFileMap = makemapentry(buf);
+			if (AliasFileMap == NULL)
+			{
+				syserr("setalias: cannot create aliases.files map");
+				return;
+			}
+		}
+		(void) snprintf(buf, sizeof buf, "Alias%d", NAliasFileMaps);
+		s = stab(buf, ST_MAP, ST_ENTER);
+		map = &s->s_map;
+		bzero(map, sizeof *map);
+		map->map_mname = s->s_name;
+
+		p = strpbrk(p, " ,/:");
+		if (p != NULL && *p == ':')
+		{
+			/* map name */
+			*p++ = '\0';
+			class = spec;
+			spec = p;
+		}
+		else
+		{
+			class = "implicit";
+			map->map_mflags = MF_INCLNULL;
+		}
+
+		/* find end of spec */
+		if (p != NULL)
+			p = strchr(p, ',');
+		if (p != NULL)
+			*p++ = '\0';
+
+		if (tTd(27, 20))
+			printf("  map %s:%s %s\n", class, s->s_name, spec);
+
+		/* look up class */
+		s = stab(class, ST_MAPCLASS, ST_FIND);
+		if (s == NULL)
+		{
+			syserr("setalias: unknown alias class %s", class);
+		}
+		else if (!bitset(MCF_ALIASOK, s->s_mapclass.map_cflags))
+		{
+			syserr("setalias: map class %s can't handle aliases",
+				class);
+		}
+		else
+		{
+			map->map_class = &s->s_mapclass;
+			if (map->map_class->map_parse(map, spec))
+			{
+				map->map_mflags |= MF_VALID|MF_ALIAS;
+				AliasFileMap->map_stack[NAliasFileMaps++] = map;
+			}
+		}
+	}
+}
+/*
+**  ALIASWAIT -- wait for distinguished @:@ token to appear.
+**
+**	This can decide to reopen or rebuild the alias file
+**
+**	Parameters:
+**		map -- a pointer to the map descriptor for this alias file.
+**		ext -- the filename extension (e.g., ".db") for the
+**			database file.
+**		isopen -- if set, the database is already open, and we
+**			should check for validity; otherwise, we are
+**			just checking to see if it should be created.
+**
+**	Returns:
+**		TRUE -- if the database is open when we return.
+**		FALSE -- if the database is closed when we return.
+*/
+
+bool
+aliaswait(map, ext, isopen)
+	MAP *map;
+	char *ext;
+	int isopen;
+{
+	bool attimeout = FALSE;
+	time_t mtime;
+	struct stat stb;
+	char buf[MAXNAME + 1];
+
+	if (tTd(27, 3))
+		printf("aliaswait(%s:%s)\n",
+			map->map_class->map_cname, map->map_file);
+	if (bitset(MF_ALIASWAIT, map->map_mflags))
+		return isopen;
+	map->map_mflags |= MF_ALIASWAIT;
+
+	if (SafeAlias > 0)
+	{
+		auto int st;
+		time_t toolong = curtime() + SafeAlias;
+		unsigned int sleeptime = 2;
+
+		while (isopen &&
+		       map->map_class->map_lookup(map, "@", NULL, &st) == NULL)
+		{
+			if (curtime() > toolong)
+			{
+				/* we timed out */
+				attimeout = TRUE;
+				break;
+			}
+
+			/*
+			**  Close and re-open the alias database in case
+			**  the one is mv'ed instead of cp'ed in.
+			*/
+
+			if (tTd(27, 2))
+				printf("aliaswait: sleeping for %d seconds\n",
+					sleeptime);
+
+			map->map_class->map_close(map);
+			map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
+			sleep(sleeptime);
+			sleeptime *= 2;
+			if (sleeptime > 60)
+				sleeptime = 60;
+			isopen = map->map_class->map_open(map, O_RDONLY);
+		}
+	}
+
+	/* see if we need to go into auto-rebuild mode */
+	if (!bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
+	{
+		if (tTd(27, 3))
+			printf("aliaswait: not rebuildable\n");
+		map->map_mflags &= ~MF_ALIASWAIT;
+		return isopen;
+	}
+	if (stat(map->map_file, &stb) < 0)
+	{
+		if (tTd(27, 3))
+			printf("aliaswait: no source file\n");
+		map->map_mflags &= ~MF_ALIASWAIT;
+		return isopen;
+	}
+	mtime = stb.st_mtime;
+	snprintf(buf, sizeof buf, "%s%s",
+		map->map_file, ext == NULL ? "" : ext);
+	if (stat(buf, &stb) < 0 || stb.st_mtime < mtime || attimeout)
+	{
+		/* database is out of date */
+		if (AutoRebuild && stb.st_ino != 0 && stb.st_uid == geteuid())
+		{
+			bool oldSuprErrs;
+
+			message("auto-rebuilding alias database %s", buf);
+			oldSuprErrs = SuprErrs;
+			SuprErrs = TRUE;
+			if (isopen)
+			{
+				map->map_class->map_close(map);
+				map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
+			}
+			rebuildaliases(map, TRUE);
+			isopen = map->map_class->map_open(map, O_RDONLY);
+			SuprErrs = oldSuprErrs;
+		}
+		else
+		{
+			if (LogLevel > 3)
+				sm_syslog(LOG_INFO, NOQID,
+					"alias database %s out of date",
+					buf);
+			message("Warning: alias database %s out of date", buf);
+		}
+	}
+	map->map_mflags &= ~MF_ALIASWAIT;
+	return isopen;
+}
+/*
+**  REBUILDALIASES -- rebuild the alias database.
+**
+**	Parameters:
+**		map -- the database to rebuild.
+**		automatic -- set if this was automatically generated.
+**
+**	Returns:
+**		none.
+**
+**	Side Effects:
+**		Reads the text version of the database, builds the
+**		DBM or DB version.
+*/
+
+void
+rebuildaliases(map, automatic)
+	register MAP *map;
+	bool automatic;
+{
+	FILE *af;
+	bool nolock = FALSE;
+	int sff = SFF_OPENASROOT|SFF_REGONLY|SFF_NOLOCK|SFF_NOWLINK|SFF_NOWFILES;
+	sigfunc_t oldsigint, oldsigquit;
+#ifdef SIGTSTP
+	sigfunc_t oldsigtstp;
+#endif
+
+	if (!bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
+		return;
+
+	/* try to lock the source file */
+	if ((af = safefopen(map->map_file, O_RDWR, 0, sff)) == NULL)
+	{
+		struct stat stb;
+
+		if ((errno != EACCES && errno != EROFS) || automatic ||
+		    (af = safefopen(map->map_file, O_RDONLY, 0, sff)) == NULL)
+		{
+			int saveerr = errno;
+
+			if (tTd(27, 1))
+				printf("Can't open %s: %s\n",
+					map->map_file, errstring(saveerr));
+			if (!automatic && !bitset(MF_OPTIONAL, map->map_mflags))
+				message("newaliases: cannot open %s: %s",
+					map->map_file, errstring(saveerr));
+			errno = 0;
+			return;
+		}
+		nolock = TRUE;
+		if (tTd(27, 1) ||
+		    fstat(fileno(af), &stb) < 0 ||
+		    bitset(S_IWUSR|S_IWGRP|S_IWOTH, stb.st_mode))
+			message("warning: cannot lock %s: %s",
+				map->map_file, errstring(errno));
+	}
+
+	/* see if someone else is rebuilding the alias file */
+	if (!nolock &&
+	    !lockfile(fileno(af), map->map_file, NULL, LOCK_EX|LOCK_NB))
+	{
+		/* yes, they are -- wait until done */
+		message("Alias file %s is locked (maybe being rebuilt)",
+			map->map_file);
+		if (OpMode != MD_INITALIAS)
+		{
+			/* wait for other rebuild to complete */
+			(void) lockfile(fileno(af), map->map_file, NULL,
+					LOCK_EX);
+		}
+		(void) xfclose(af, "rebuildaliases1", map->map_file);
+		errno = 0;
+		return;
+	}
+
+	oldsigint = setsignal(SIGINT, SIG_IGN);
+	oldsigquit = setsignal(SIGQUIT, SIG_IGN);
+#ifdef SIGTSTP
+	oldsigtstp = setsignal(SIGTSTP, SIG_IGN);
+#endif
+
+	if (map->map_class->map_open(map, O_RDWR))
+	{
+		if (LogLevel > 7)
+		{
+			sm_syslog(LOG_NOTICE, NOQID,
+				"alias database %s %srebuilt by %s",
+				map->map_file, automatic ? "auto" : "",
+				username());
+		}
+		map->map_mflags |= MF_OPEN|MF_WRITABLE;
+		readaliases(map, af, !automatic, TRUE);
+	}
+	else
+	{
+		if (tTd(27, 1))
+			printf("Can't create database for %s: %s\n",
+				map->map_file, errstring(errno));
+		if (!automatic)
+			syserr("Cannot create database for alias file %s",
+				map->map_file);
+	}
+
+	/* close the file, thus releasing locks */
+	xfclose(af, "rebuildaliases2", map->map_file);
+
+	/* add distinguished entries and close the database */
+	if (bitset(MF_OPEN, map->map_mflags))
+	{
+		map->map_class->map_close(map);
+		map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
+	}
+
+	/* restore the old signals */
+	(void) setsignal(SIGINT, oldsigint);
+	(void) setsignal(SIGQUIT, oldsigquit);
+#ifdef SIGTSTP
+	(void) setsignal(SIGTSTP, oldsigtstp);
+#endif
+}
+/*
+**  READALIASES -- read and process the alias file.
+**
+**	This routine implements the part of initaliases that occurs
+**	when we are not going to use the DBM stuff.
+**
+**	Parameters:
+**		map -- the alias database descriptor.
+**		af -- file to read the aliases from.
+**		announcestats -- anounce statistics regarding number of
+**			aliases, longest alias, etc.
+**		logstats -- lot the same info.
+**
+**	Returns:
+**		none.
+**
+**	Side Effects:
+**		Reads aliasfile into the symbol table.
+**		Optionally, builds the .dir & .pag files.
+*/
+
+void
+readaliases(map, af, announcestats, logstats)
+	register MAP *map;
+	FILE *af;
+	bool announcestats;
+	bool logstats;
+{
+	register char *p;
+	char *rhs;
+	bool skipping;
+	long naliases, bytes, longest;
+	ADDRESS al, bl;
+	char line[BUFSIZ];
+
+	/*
+	**  Read and interpret lines
+	*/
+
+	FileName = map->map_file;
+	LineNumber = 0;
+	naliases = bytes = longest = 0;
+	skipping = FALSE;
+	while (fgets(line, sizeof (line), af) != NULL)
+	{
+		int lhssize, rhssize;
+		int c;
+
+		LineNumber++;
+		p = strchr(line, '\n');
+#if _FFR_BACKSLASH_IN_ALIASES
+		while (p != NULL && p > line && p[-1] == '\\')
+		{
+			p--;
+			if (fgets(p, SPACELEFT(line, p), af) == NULL)
+				break;
+			p = strchr(p, '\n');
+		}
+#endif
+		if (p != NULL)
+			*p = '\0';
+		else if (!feof(af))
+		{
+			syserr("554 alias line too long");
+
+			/* flush to end of line */
+			while ((c = getc(af)) != EOF && c != '\n')
+				continue;
+
+			/* skip any continuation lines */
+			skipping = TRUE;
+			continue;
+		}
+		switch (line[0])
+		{
+		  case '#':
+		  case '\0':
+			skipping = FALSE;
+			continue;
+
+		  case ' ':
+		  case '\t':
+			if (!skipping)
+				syserr("554 Non-continuation line starts with space");
+			skipping = TRUE;
+			continue;
+		}
+		skipping = FALSE;
+
+		/*
+		**  Process the LHS
+		**	Find the colon separator, and parse the address.
+		**	It should resolve to a local name -- this will
+		**	be checked later (we want to optionally do
+		**	parsing of the RHS first to maximize error
+		**	detection).
+		*/
+
+		for (p = line; *p != '\0' && *p != ':' && *p != '\n'; p++)
+			continue;
+		if (*p++ != ':')
+		{
+			syserr("554 missing colon");
+			continue;
+		}
+		if (parseaddr(line, &al, RF_COPYALL, ':', NULL, CurEnv) == NULL)
+		{
+			syserr("554 %.40s... illegal alias name", line);
+			continue;
+		}
+
+		/*
+		**  Process the RHS.
+		**	'al' is the internal form of the LHS address.
+		**	'p' points to the text of the RHS.
+		*/
+
+		while (isascii(*p) && isspace(*p))
+			p++;
+		rhs = p;
+		for (;;)
+		{
+			register char *nlp;
+
+			nlp = &p[strlen(p)];
+			if (nlp[-1] == '\n')
+				*--nlp = '\0';
+
+			if (CheckAliases)
+			{
+				/* do parsing & compression of addresses */
+				while (*p != '\0')
+				{
+					auto char *delimptr;
+
+					while ((isascii(*p) && isspace(*p)) ||
+								*p == ',')
+						p++;
+					if (*p == '\0')
+						break;
+					if (parseaddr(p, &bl, RF_COPYNONE, ',',
+						      &delimptr, CurEnv) == NULL)
+						usrerr("553 %s... bad address", p);
+					p = delimptr;
+				}
+			}
+			else
+			{
+				p = nlp;
+			}
+
+			/* see if there should be a continuation line */
+			c = getc(af);
+			if (!feof(af))
+				(void) ungetc(c, af);
+			if (c != ' ' && c != '\t')
+				break;
+
+			/* read continuation line */
+			if (fgets(p, sizeof line - (p - line), af) == NULL)
+				break;
+			LineNumber++;
+
+			/* check for line overflow */
+			if (strchr(p, '\n') == NULL && !feof(af))
+			{
+				usrerr("554 alias too long");
+				while ((c = fgetc(af)) != EOF && c != '\n')
+					continue;
+				skipping = TRUE;
+				break;
+			}
+		}
+
+		if (skipping)
+			continue;
+
+		if (!bitnset(M_ALIASABLE, al.q_mailer->m_flags))
+		{
+			syserr("554 %s... cannot alias non-local names",
+				al.q_paddr);
+			continue;
+		}
+
+		/*
+		**  Insert alias into symbol table or database file.
+		**
+		**	Special case pOStmaStER -- always make it lower case.
+		*/
+
+		if (strcasecmp(al.q_user, "postmaster") == 0)
+			makelower(al.q_user);
+
+		lhssize = strlen(al.q_user);
+		rhssize = strlen(rhs);
+		map->map_class->map_store(map, al.q_user, rhs);
+
+		if (al.q_paddr != NULL)
+			free(al.q_paddr);
+		if (al.q_host != NULL)
+			free(al.q_host);
+		if (al.q_user != NULL)
+			free(al.q_user);
+
+		/* statistics */
+		naliases++;
+		bytes += lhssize + rhssize;
+		if (rhssize > longest)
+			longest = rhssize;
+	}
+
+	CurEnv->e_to = NULL;
+	FileName = NULL;
+	if (Verbose || announcestats)
+		message("%s: %d aliases, longest %d bytes, %d bytes total",
+			map->map_file, naliases, longest, bytes);
+	if (LogLevel > 7 && logstats)
+		sm_syslog(LOG_INFO, NOQID,
+			"%s: %d aliases, longest %d bytes, %d bytes total",
+			map->map_file, naliases, longest, bytes);
+}
+/*
+**  FORWARD -- Try to forward mail
+**
+**	This is similar but not identical to aliasing.
+**
+**	Parameters:
+**		user -- the name of the user who's mail we would like
+**			to forward to.  It must have been verified --
+**			i.e., the q_home field must have been filled
+**			in.
+**		sendq -- a pointer to the head of the send queue to
+**			put this user's aliases in.
+**		aliaslevel -- the current alias nesting depth.
+**		e -- the current envelope.
+**
+**	Returns:
+**		none.
+**
+**	Side Effects:
+**		New names are added to send queues.
+*/
+
+void
+forward(user, sendq, aliaslevel, e)
+	ADDRESS *user;
+	ADDRESS **sendq;
+	int aliaslevel;
+	register ENVELOPE *e;
+{
+	char *pp;
+	char *ep;
+	bool got_transient;
+
+	if (tTd(27, 1))
+		printf("forward(%s)\n", user->q_paddr);
+
+	if (!bitnset(M_HASPWENT, user->q_mailer->m_flags) ||
+	    bitset(QBADADDR, user->q_flags))
+		return;
+	if (user->q_home == NULL)
+	{
+		syserr("554 forward: no home");
+		user->q_home = "/no/such/directory";
+	}
+
+	/* good address -- look for .forward file in home */
+	define('z', user->q_home, e);
+	define('u', user->q_user, e);
+	define('h', user->q_host, e);
+	if (ForwardPath == NULL)
+		ForwardPath = newstr("\201z/.forward");
+
+	got_transient = FALSE;
+	for (pp = ForwardPath; pp != NULL; pp = ep)
+	{
+		int err;
+		char buf[MAXPATHLEN+1];
+
+		ep = strchr(pp, ':');
+		if (ep != NULL)
+			*ep = '\0';
+		expand(pp, buf, sizeof buf, e);
+		if (ep != NULL)
+			*ep++ = ':';
+		if (buf[0] == '\0')
+			continue;
+		if (tTd(27, 3))
+			printf("forward: trying %s\n", buf);
+
+		err = include(buf, TRUE, user, sendq, aliaslevel, e);
+		if (err == 0)
+			break;
+		else if (transienterror(err))
+		{
+			/* we may have to suspend this message */
+			got_transient = TRUE;
+			if (tTd(27, 2))
+				printf("forward: transient error on %s\n", buf);
+			if (LogLevel > 2)
+				sm_syslog(LOG_ERR, e->e_id,
+					"forward %s: transient error: %s",
+					buf, errstring(err));
+		}
+	}
+	if (pp == NULL && got_transient)
+	{
+		/*
+		**  There was no successful .forward open and at least one
+		**  transient open.  We have to defer this address for
+		**  further delivery.
+		*/
+
+		message("transient .forward open error: message queued");
+		user->q_flags |= QQUEUEUP;
+		return;
+	}
+}