#define _DEFINE

#include <sendmail.h>

#include <sm/sendmail.h>

#include <sm/xtrap.h>

#include <sm/signal.h>

#ifndef lint

SM_UNUSED(static char copyright[]) =

@(#) Use is subject to license terms.\n";

#endif /* ! lint */

SM_RCSID("@(#)$Id: main.c,v 8.971 2009/12/18 17:08:01 ca Exp $")

#if NETINET || NETINET6

# include <arpa/inet.h>

#endif /* NETINET || NETINET6 */

#include <sendmail/pathnames.h>

static SM_DEBUG_T

DebugNoPRestart = SM_DEBUG_INITIALIZER("no_persistent_restart",

"@(#)$Debug: no_persistent_restart - don't restart, log only $");

static void dump_class __P((STAB *, int));

static void obsolete __P((char **));

static void testmodeline __P((char *, ENVELOPE *));

static char *getextenv __P((const char *));

static void sm_printoptions __P((char **));

static SIGFUNC_DECL intindebug __P((int));

static SIGFUNC_DECL sighup __P((int));

static SIGFUNC_DECL sigpipe __P((int));

static SIGFUNC_DECL sigterm __P((int));

#ifdef SIGUSR1

static SIGFUNC_DECL sigusr1 __P((int));

#endif /* SIGUSR1 */

char *FullName; /* sender's full name */

ENVELOPE BlankEnvelope; /* a "blank" envelope */

static ENVELOPE MainEnvelope; /* the envelope around the basic letter */

ADDRESS NullAddress = /* a null address */

{ "", "", NULL, "" };

char *CommandLineArgs; /* command line args for pid file */

bool Warn_Q_option = false; /* warn about Q option use */

static int MissingFds = 0; /* bit map of fds missing on startup */

char *Mbdb = "pw"; /* mailbox database defaults to /etc/passwd */

#ifdef NGROUPS_MAX

GIDSET_T InitialGidSet[NGROUPS_MAX];

#endif /* NGROUPS_MAX */

#define MAXCONFIGLEVEL 10 /* highest config version level known */

#if SASL

static sasl_callback_t srvcallbacks[] =

{

{ SASL_CB_VERIFYFILE, &safesaslfile, NULL },

{ SASL_CB_PROXY_POLICY, &proxy_policy, NULL },

{ SASL_CB_LIST_END, NULL, NULL }

};

#endif /* SASL */

unsigned int SubmitMode;

int SyslogPrefixLen; /* estimated length of syslog prefix */

#define PIDLEN 6 /* pid length for computing SyslogPrefixLen */

#ifndef SL_FUDGE

# define SL_FUDGE 10 /* fudge offset for SyslogPrefixLen */

#endif /* ! SL_FUDGE */

#define SLDLL 8 /* est. length of default syslog label */

#define CHECK_AGAINST_OPMODE(cmd) \

{ \

if (extraprivs && \

OpMode != MD_DELIVER && OpMode != MD_SMTP && \

OpMode != MD_ARPAFTP && OpMode != MD_CHECKCONFIG && \

OpMode != MD_VERIFY && OpMode != MD_TEST) \

{ \

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, \

"WARNING: Ignoring submission mode -%c option (not in submission mode)\n", \

(cmd)); \

break; \

} \

if (extraprivs && queuerun) \

{ \

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, \

"WARNING: Ignoring submission mode -%c option with -q\n", \

(cmd)); \

break; \

} \

}

main(argc, argv, envp)

int argc;

char **argv;

char **envp;

{

register char *p;

char **av;

extern char Version[];

char *ep, *from;

STAB *st;

register int i;

int j;

int dp;

int fill_errno;

int qgrp = NOQGRP; /* queue group to process */

bool safecf = true;

BITMAP256 *p_flags = NULL; /* daemon flags */

bool warn_C_flag = false;

bool auth = true; /* whether to set e_auth_param */

char warn_f_flag = '\0';

bool run_in_foreground = false; /* -bD mode */

bool queuerun = false, debug = false;

struct passwd *pw;

struct hostent *hp;

char *nullserver = NULL;

char *authinfo = NULL;

char *sysloglabel = NULL; /* label for syslog */

char *conffile = NULL; /* name of .cf file */

char *queuegroup = NULL; /* queue group to process */

char *quarantining = NULL; /* quarantine queue items? */

bool extraprivs;

bool forged, negate;

bool queuepersistent = false; /* queue runner process runs forever */

bool foregroundqueue = false; /* queue run in foreground */

bool save_val; /* to save some bool var. */

int cftype; /* which cf file to use? */

SM_FILE_T *smdebug;

static time_t starttime = 0; /* when was process started */

struct stat traf_st; /* for TrafficLog FIFO check */

char buf[MAXLINE];

char jbuf[MAXHOSTNAMELEN]; /* holds MyHostName */

static char rnamebuf[MAXNAME]; /* holds RealUserName */

char *emptyenviron[1];

#if STARTTLS

bool tls_ok;

#endif /* STARTTLS */

QUEUE_CHAR *new;

ENVELOPE *e;

extern int DtableSize;

extern int optind;

extern int opterr;

extern char *optarg;

extern char **environ;

#if SASL

extern void sm_sasl_init __P((void));

#endif /* SASL */

#if USE_ENVIRON

envp = environ;

#endif /* USE_ENVIRON */

/* turn off profiling */

SM_PROF(0);

/* install default exception handler */

sm_exc_newthread(fatal_error);

/* set the default in/out channel so errors reported to screen */

InChannel = smioin;

OutChannel = smioout;

/*

if (starttime != 0)

{

syserr("main: reentered!");

abort();

}

starttime = curtime();

/* avoid null pointer dereferences */

TermEscape.te_rv_on = TermEscape.te_under_on = TermEscape.te_normal = "";

RealUid = getuid();

RealGid = getgid();

/* Check if sendmail is running with extra privs */

extraprivs = (RealUid != 0 &&

(geteuid() != getuid() || getegid() != getgid()));

CurrentPid = getpid();

/* get whatever .cf file is right for the opmode */

cftype = SM_GET_RIGHT_CF;

/* in 4.4BSD, the table can be huge; impose a reasonable limit */

DtableSize = getdtsize();

if (DtableSize > 256)

DtableSize = 256;

/*

/* reset errno and fill_errno; the latter is used way down below */

errno = fill_errno = 0;

fill_fd(STDIN_FILENO, NULL);

if (errno != 0)

fill_errno = errno;

fill_fd(STDOUT_FILENO, NULL);

if (errno != 0)

fill_errno = errno;

fill_fd(STDERR_FILENO, NULL);

if (errno != 0)

fill_errno = errno;

sm_closefrom(STDERR_FILENO + 1, DtableSize);

errno = 0;

smdebug = NULL;

#if LOG

# ifndef SM_LOG_STR

# define SM_LOG_STR "sendmail"

# endif /* ! SM_LOG_STR */

# ifdef LOG_MAIL

openlog(SM_LOG_STR, LOG_PID, LOG_MAIL);

# else /* LOG_MAIL */

openlog(SM_LOG_STR, LOG_PID);

# endif /* LOG_MAIL */

#endif /* LOG */

/*

seed_random();

/* do machine-dependent initializations */

init_md(argc, argv);

SyslogPrefixLen = PIDLEN + (MAXQFNAME - 3) + SL_FUDGE + SLDLL;

/* reset status from syserr() calls for missing file descriptors */

Errors = 0;

ExitStat = EX_OK;

SubmitMode = SUBMIT_UNKNOWN;

#if _FFR_LOCAL_DAEMON

LocalDaemon = false;

#endif /* _FFR_LOCAL_DAEMON */

#if XDEBUG

checkfd012("after openlog");

#endif /* XDEBUG */

tTsetup(tTdvect, sizeof(tTdvect), "0-99.1,*_trace_*.1");

#ifdef NGROUPS_MAX

/* save initial group set for future checks */

i = getgroups(NGROUPS_MAX, InitialGidSet);

if (i <= 0)

{

InitialGidSet[0] = (GID_T) -1;

i = 0;

}

while (i < NGROUPS_MAX)

InitialGidSet[i++] = InitialGidSet[0];

#endif /* NGROUPS_MAX */

/* drop group id privileges (RunAsUser not yet set) */

dp = drop_privileges(false);

setstat(dp);

#ifdef SIGUSR1

/* Only allow root (or non-set-*-ID binaries) to use SIGUSR1 */

if (!extraprivs)

{

/* arrange to dump state on user-1 signal */

(void) sm_signal(SIGUSR1, sigusr1);

}

else

{

/* ignore user-1 signal */

(void) sm_signal(SIGUSR1, SIG_IGN);

}

#endif /* SIGUSR1 */

/* initialize for setproctitle */

initsetproctitle(argc, argv, envp);

/* Handle any non-getoptable constructions. */

obsolete(argv);

/*

/* find initial opMode */

OpMode = MD_DELIVER;

av = argv;

p = strrchr(*av, '/');

if (p++ == NULL)

p = *av;

if (strcmp(p, "newaliases") == 0)

OpMode = MD_INITALIAS;

else if (strcmp(p, "mailq") == 0)

OpMode = MD_PRINT;

else if (strcmp(p, "smtpd") == 0)

OpMode = MD_DAEMON;

else if (strcmp(p, "hoststat") == 0)

OpMode = MD_HOSTSTAT;

else if (strcmp(p, "purgestat") == 0)

OpMode = MD_PURGESTAT;

#if defined(__osf__) || defined(_AIX3)

# define OPTIONS "A:B:b:C:cD:d:e:F:f:Gh:IiL:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:x"

#endif /* defined(__osf__) || defined(_AIX3) */

#if defined(sony_news)

# define OPTIONS "A:B:b:C:cD:d:E:e:F:f:Gh:IiJ:L:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:"

#endif /* defined(sony_news) */

#ifndef OPTIONS

# define OPTIONS "A:B:b:C:cD:d:e:F:f:Gh:IiL:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:"

#endif /* ! OPTIONS */

/* Set to 0 to allow -b; need to check optarg before using it! */

opterr = 0;

while ((j = getopt(argc, argv, OPTIONS)) != -1)

{

switch (j)

{

case 'b': /* operations mode */

j = (optarg == NULL) ? ' ' : *optarg;

switch (j)

{

case MD_DAEMON:

case MD_FGDAEMON:

case MD_SMTP:

case MD_INITALIAS:

case MD_DELIVER:

case MD_VERIFY:

case MD_TEST:

case MD_PRINT:

case MD_PRINTNQE:

case MD_HOSTSTAT:

case MD_PURGESTAT:

case MD_ARPAFTP:

#if _FFR_CHECKCONFIG

case MD_CHECKCONFIG:

#endif /* _FFR_CHECKCONFIG */

OpMode = j;

break;

#if _FFR_LOCAL_DAEMON

case MD_LOCAL:

OpMode = MD_DAEMON;

LocalDaemon = true;

break;

#endif /* _FFR_LOCAL_DAEMON */

case MD_FREEZE:

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Frozen configurations unsupported\n");

return EX_USAGE;

default:

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Invalid operation mode %c\n",

j);

return EX_USAGE;

}

break;

case 'D':

if (debug)

{

errno = 0;

syserr("-D file must be before -d");

ExitStat = EX_USAGE;

break;

}

dp = drop_privileges(true);

setstat(dp);

smdebug = sm_io_open(SmFtStdio, SM_TIME_DEFAULT,

optarg, SM_IO_APPEND, NULL);

if (smdebug == NULL)

{

syserr("cannot open %s", optarg);

ExitStat = EX_CANTCREAT;

break;

}

sm_debug_setfile(smdebug);

break;

case 'd':

debug = true;

tTflag(optarg);

(void) sm_io_setvbuf(sm_debug_file(), SM_TIME_DEFAULT,

(char *) NULL, SM_IO_NBF,

SM_IO_BUFSIZ);

break;

case 'G': /* relay (gateway) submission */

SubmitMode = SUBMIT_MTA;

break;

case 'L':

if (optarg == NULL)

{

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"option requires an argument -- '%c'",

(char) j);

return EX_USAGE;

}

j = SM_MIN(strlen(optarg), 32) + 1;

sysloglabel = xalloc(j);

(void) sm_strlcpy(sysloglabel, optarg, j);

SyslogPrefixLen = PIDLEN + (MAXQFNAME - 3) +

SL_FUDGE + j;

break;

case 'Q':

case 'q':

/* just check if it is there */

queuerun = true;

break;

}

}

opterr = 1;

/* Don't leak queue information via debug flags */

if (extraprivs && queuerun && debug)

{

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"WARNING: Can not use -d with -q. Disabling debugging.\n");

sm_debug_close();

sm_debug_setfile(NULL);

(void) memset(tTdvect, '\0', sizeof(tTdvect));

}

#if LOG

if (sysloglabel != NULL)

{

/* Sanitize the string */

for (p = sysloglabel; *p != '\0'; p++)

{

if (!isascii(*p) || !isprint(*p) || *p == '%')

*p = '*';

}

closelog();

# ifdef LOG_MAIL

openlog(sysloglabel, LOG_PID, LOG_MAIL);

# else /* LOG_MAIL */

openlog(sysloglabel, LOG_PID);

# endif /* LOG_MAIL */

}

#endif /* LOG */

/* set up the blank envelope */

BlankEnvelope.e_puthdr = putheader;

BlankEnvelope.e_putbody = putbody;

BlankEnvelope.e_xfp = NULL;

STRUCTCOPY(NullAddress, BlankEnvelope.e_from);

CurEnv = &BlankEnvelope;

STRUCTCOPY(NullAddress, MainEnvelope.e_from);

/*

setdefaults(&BlankEnvelope);

initmacros(&BlankEnvelope);

/* reset macro */

set_op_mode(OpMode);

if (OpMode == MD_DAEMON)

DaemonPid = CurrentPid; /* needed for finis() to work */

pw = sm_getpwuid(RealUid);

if (pw != NULL)

(void) sm_strlcpy(rnamebuf, pw->pw_name, sizeof(rnamebuf));

else

(void) sm_snprintf(rnamebuf, sizeof(rnamebuf), "Unknown UID %d",

(int) RealUid);

RealUserName = rnamebuf;

if (tTd(0, 101))

{

sm_dprintf("Version %s\n", Version);

finis(false, true, EX_OK);

/* NOTREACHED */

}

/*

if (RealUid != 0 && geteuid() == RealUid)

{

if (tTd(47, 1))

sm_dprintf("Non-set-user-ID binary: RunAsUid = RealUid = %d\n",

(int) RealUid);

RunAsUid = RealUid;

}

else if (geteuid() != 0)

RunAsUid = geteuid();

EffGid = getegid();

if (RealUid != 0 && EffGid == RealGid)

RunAsGid = RealGid;

if (tTd(47, 5))

{

sm_dprintf("main: e/ruid = %d/%d e/rgid = %d/%d\n",

(int) geteuid(), (int) getuid(),

(int) getegid(), (int) getgid());

sm_dprintf("main: RunAsUser = %d:%d\n",

(int) RunAsUid, (int) RunAsGid);

}

/* save command line arguments */

j = 0;

for (av = argv; *av != NULL; )

j += strlen(*av++) + 1;

SaveArgv = (char **) xalloc(sizeof(char *) * (argc + 1));

CommandLineArgs = xalloc(j);

p = CommandLineArgs;

for (av = argv, i = 0; *av != NULL; )

{

int h;

SaveArgv[i++] = newstr(*av);

if (av != argv)

*p++ = ' ';

(void) sm_strlcpy(p, *av++, j);

h = strlen(p);

p += h;

j -= h + 1;

}

SaveArgv[i] = NULL;

if (tTd(0, 1))

{

extern char *CompileOptions[];

sm_dprintf("Version %s\n Compiled with:", Version);

sm_printoptions(CompileOptions);

}

if (tTd(0, 10))

{

extern char *OsCompileOptions[];

sm_dprintf(" OS Defines:");

sm_printoptions(OsCompileOptions);

#ifdef _PATH_UNIX

sm_dprintf("Kernel symbols:\t%s\n", _PATH_UNIX);

#endif /* _PATH_UNIX */

sm_dprintf(" Conf file:\t%s (default for MSP)\n",

getcfname(OpMode, SubmitMode, SM_GET_SUBMIT_CF,

conffile));

sm_dprintf(" Conf file:\t%s (default for MTA)\n",

getcfname(OpMode, SubmitMode, SM_GET_SENDMAIL_CF,

conffile));

sm_dprintf(" Pid file:\t%s (default)\n", PidFile);

}

if (tTd(0, 12))

{

extern char *SmCompileOptions[];

sm_dprintf(" libsm Defines:");

sm_printoptions(SmCompileOptions);

}

if (tTd(0, 13))

{

extern char *FFRCompileOptions[];

sm_dprintf(" FFR Defines:");

sm_printoptions(FFRCompileOptions);

}

/* clear sendmail's environment */

ExternalEnviron = environ;

emptyenviron[0] = NULL;

environ = emptyenviron;

/*

if ((p = getextenv("TZ")) != NULL)

{

char *tz;

int tzlen;

/* XXX check for reasonable length? */

tzlen = strlen(p) + 4;

tz = xalloc(tzlen);

(void) sm_strlcpyn(tz, tzlen, 2, "TZ=", p);

/* XXX check return code? */

(void) putenv(tz);

}

/* prime the child environment */

sm_setuserenv("AGENT", "sendmail");

(void) sm_signal(SIGPIPE, SIG_IGN);

OldUmask = umask(022);

FullName = getextenv("NAME");

if (FullName != NULL)

FullName = newstr(FullName);

/*

#if NAMED_BIND

if (!bitset(RES_INIT, _res.options))

(void) res_init();

if (tTd(8, 8))

_res.options |= RES_DEBUG;

else

_res.options &= ~RES_DEBUG;

# ifdef RES_NOALIASES

_res.options |= RES_NOALIASES;

# endif /* RES_NOALIASES */

TimeOuts.res_retry[RES_TO_DEFAULT] = _res.retry;

TimeOuts.res_retry[RES_TO_FIRST] = _res.retry;

TimeOuts.res_retry[RES_TO_NORMAL] = _res.retry;

TimeOuts.res_retrans[RES_TO_DEFAULT] = _res.retrans;

TimeOuts.res_retrans[RES_TO_FIRST] = _res.retrans;

TimeOuts.res_retrans[RES_TO_NORMAL] = _res.retrans;

#endif /* NAMED_BIND */

errno = 0;

from = NULL;

/* initialize some macros, etc. */

init_vendor_macros(&BlankEnvelope);

/* version */

macdefine(&BlankEnvelope.e_macro, A_PERM, 'v', Version);

/* hostname */

hp = myhostname(jbuf, sizeof(jbuf));

if (jbuf[0] != '\0')

{

struct utsname utsname;

if (tTd(0, 4))

sm_dprintf("Canonical name: %s\n", jbuf);

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'w', jbuf);

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'j', jbuf);

setclass('w', jbuf);

p = strchr(jbuf, '.');

if (p != NULL && p[1] != '\0')

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'm', &p[1]);

if (uname(&utsname) >= 0)

p = utsname.nodename;

else

{

if (tTd(0, 22))

sm_dprintf("uname failed (%s)\n",

sm_errstring(errno));

makelower(jbuf);

p = jbuf;

}

if (tTd(0, 4))

sm_dprintf(" UUCP nodename: %s\n", p);

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'k', p);

setclass('k', p);

setclass('w', p);

}

if (hp != NULL)

{

for (av = hp->h_aliases; av != NULL && *av != NULL; av++)

{

if (tTd(0, 4))

sm_dprintf("\ta.k.a.: %s\n", *av);

setclass('w', *av);

}

#if NETINET || NETINET6

for (i = 0; i >= 0 && hp->h_addr_list[i] != NULL; i++)

{

# if NETINET6

char *addr;

char buf6[INET6_ADDRSTRLEN];

struct in6_addr ia6;

# endif /* NETINET6 */

# if NETINET

struct in_addr ia;

# endif /* NETINET */

char ipbuf[103];

ipbuf[0] = '\0';

switch (hp->h_addrtype)

{

# if NETINET

case AF_INET:

if (hp->h_length != INADDRSZ)

break;

memmove(&ia, hp->h_addr_list[i], INADDRSZ);

(void) sm_snprintf(ipbuf, sizeof(ipbuf),

"[%.100s]", inet_ntoa(ia));

break;

# endif /* NETINET */

# if NETINET6

case AF_INET6:

if (hp->h_length != IN6ADDRSZ)

break;

memmove(&ia6, hp->h_addr_list[i], IN6ADDRSZ);

addr = anynet_ntop(&ia6, buf6, sizeof(buf6));

if (addr != NULL)

(void) sm_snprintf(ipbuf, sizeof(ipbuf),

"[%.100s]", addr);

break;

# endif /* NETINET6 */

}

if (ipbuf[0] == '\0')

break;

if (tTd(0, 4))

sm_dprintf("\ta.k.a.: %s\n", ipbuf);

setclass('w', ipbuf);

}

#endif /* NETINET || NETINET6 */

#if NETINET6

freehostent(hp);

hp = NULL;

#endif /* NETINET6 */

}

/* current time */

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'b', arpadate((char *) NULL));

/* current load average */

sm_getla();

QueueLimitRecipient = (QUEUE_CHAR *) NULL;

QueueLimitSender = (QUEUE_CHAR *) NULL;

QueueLimitId = (QUEUE_CHAR *) NULL;

QueueLimitQuarantine = (QUEUE_CHAR *) NULL;

/*

optind = 1;

while ((j = getopt(argc, argv, OPTIONS)) != -1)

{

switch (j)

{

case 'b': /* operations mode */

/* already done */

break;

case 'A': /* use Alternate sendmail/submit.cf */

cftype = optarg[0] == 'c' ? SM_GET_SUBMIT_CF

: SM_GET_SENDMAIL_CF;

break;

case 'B': /* body type */

CHECK_AGAINST_OPMODE(j);

BlankEnvelope.e_bodytype = newstr(optarg);

break;

case 'C': /* select configuration file (already done) */

if (RealUid != 0)

warn_C_flag = true;

conffile = newstr(optarg);

dp = drop_privileges(true);

setstat(dp);

safecf = false;

break;

case 'D':

case 'd': /* debugging */

/* already done */

break;

case 'f': /* from address */

case 'r': /* obsolete -f flag */

CHECK_AGAINST_OPMODE(j);

if (from != NULL)

{

usrerr("More than one \"from\" person");

ExitStat = EX_USAGE;

break;

}

if (optarg[0] == '\0')

from = newstr("<>");

else

from = newstr(denlstring(optarg, true, true));

if (strcmp(RealUserName, from) != 0)

warn_f_flag = j;

break;

case 'F': /* set full name */

CHECK_AGAINST_OPMODE(j);

FullName = newstr(optarg);

break;

case 'G': /* relay (gateway) submission */

/* already set */

CHECK_AGAINST_OPMODE(j);

break;

case 'h': /* hop count */

CHECK_AGAINST_OPMODE(j);

BlankEnvelope.e_hopcount = (short) strtol(optarg, &ep,

10);

(void) sm_snprintf(buf, sizeof(buf), "%d",

BlankEnvelope.e_hopcount);

macdefine(&BlankEnvelope.e_macro, A_TEMP, 'c', buf);

if (*ep)

{

usrerr("Bad hop count (%s)", optarg);

ExitStat = EX_USAGE;

}

break;

case 'L': /* program label */

/* already set */

break;

case 'n': /* don't alias */

CHECK_AGAINST_OPMODE(j);

NoAlias = true;

break;

case 'N': /* delivery status notifications */

CHECK_AGAINST_OPMODE(j);

DefaultNotify |= QHASNOTIFY;

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{dsn_notify}"), optarg);

if (sm_strcasecmp(optarg, "never") == 0)

break;

for (p = optarg; p != NULL; optarg = p)

{

p = strchr(p, ',');

if (p != NULL)

*p++ = '\0';

if (sm_strcasecmp(optarg, "success") == 0)

DefaultNotify |= QPINGONSUCCESS;

else if (sm_strcasecmp(optarg, "failure") == 0)

DefaultNotify |= QPINGONFAILURE;

else if (sm_strcasecmp(optarg, "delay") == 0)

DefaultNotify |= QPINGONDELAY;

else

{

usrerr("Invalid -N argument");

ExitStat = EX_USAGE;

}

}

break;

case 'o': /* set option */

setoption(*optarg, optarg + 1, false, true,

&BlankEnvelope);

break;

case 'O': /* set option (long form) */

setoption(' ', optarg, false, true, &BlankEnvelope);

break;

case 'p': /* set protocol */

CHECK_AGAINST_OPMODE(j);

p = strchr(optarg, ':');

if (p != NULL)

{

*p++ = '\0';

if (*p != '\0')

{

i = strlen(p) + 1;

ep = sm_malloc_x(i);

cleanstrcpy(ep, p, i);

macdefine(&BlankEnvelope.e_macro,

A_HEAP, 's', ep);

}

}

if (*optarg != '\0')

{

i = strlen(optarg) + 1;

ep = sm_malloc_x(i);

cleanstrcpy(ep, optarg, i);

macdefine(&BlankEnvelope.e_macro, A_HEAP,

'r', ep);

}

break;

case 'Q': /* change quarantining on queued items */

/* sanity check */

if (OpMode != MD_DELIVER &&

OpMode != MD_QUEUERUN)

{

usrerr("Can not use -Q with -b%c", OpMode);

ExitStat = EX_USAGE;

break;

}

if (OpMode == MD_DELIVER)

set_op_mode(MD_QUEUERUN);

FullName = NULL;

quarantining = newstr(optarg);

break;

case 'q': /* run queue files at intervals */

/* sanity check */

if (OpMode != MD_DELIVER &&

OpMode != MD_DAEMON &&

OpMode != MD_FGDAEMON &&

OpMode != MD_PRINT &&

OpMode != MD_PRINTNQE &&

OpMode != MD_QUEUERUN)

{

usrerr("Can not use -q with -b%c", OpMode);

ExitStat = EX_USAGE;

break;

}

/* don't override -bd, -bD or -bp */

if (OpMode == MD_DELIVER)

set_op_mode(MD_QUEUERUN);

FullName = NULL;

negate = optarg[0] == '!';

if (negate)

{

/* negate meaning of pattern match */

optarg++; /* skip '!' for next switch */

}

switch (optarg[0])

{

case 'G': /* Limit by queue group name */

if (negate)

{

usrerr("Can not use -q!G");

ExitStat = EX_USAGE;

break;

}

if (queuegroup != NULL)

{

usrerr("Can not use multiple -qG options");

ExitStat = EX_USAGE;

break;

}

queuegroup = newstr(&optarg[1]);

break;

case 'I': /* Limit by ID */

new = (QUEUE_CHAR *) xalloc(sizeof(*new));

new->queue_match = newstr(&optarg[1]);

new->queue_negate = negate;

new->queue_next = QueueLimitId;

QueueLimitId = new;

break;

case 'R': /* Limit by recipient */

new = (QUEUE_CHAR *) xalloc(sizeof(*new));

new->queue_match = newstr(&optarg[1]);

new->queue_negate = negate;

new->queue_next = QueueLimitRecipient;

QueueLimitRecipient = new;

break;

case 'S': /* Limit by sender */

new = (QUEUE_CHAR *) xalloc(sizeof(*new));

new->queue_match = newstr(&optarg[1]);

new->queue_negate = negate;

new->queue_next = QueueLimitSender;

QueueLimitSender = new;

break;

case 'f': /* foreground queue run */

foregroundqueue = true;

break;

case 'Q': /* Limit by quarantine message */

if (optarg[1] != '\0')

{

new = (QUEUE_CHAR *) xalloc(sizeof(*new));

new->queue_match = newstr(&optarg[1]);

new->queue_negate = negate;

new->queue_next = QueueLimitQuarantine;

QueueLimitQuarantine = new;

}

QueueMode = QM_QUARANTINE;

break;

case 'L': /* act on lost items */

QueueMode = QM_LOST;

break;

case 'p': /* Persistent queue */

queuepersistent = true;

if (QueueIntvl == 0)

QueueIntvl = 1;

if (optarg[1] == '\0')

break;

++optarg;

/* FALLTHROUGH */

default:

i = Errors;

QueueIntvl = convtime(optarg, 'm');

if (QueueIntvl < 0)

{

usrerr("Invalid -q value");

ExitStat = EX_USAGE;

}

/* check for bad conversion */

if (i < Errors)

ExitStat = EX_USAGE;

break;

}

break;

case 'R': /* DSN RET: what to return */

CHECK_AGAINST_OPMODE(j);

if (bitset(EF_RET_PARAM, BlankEnvelope.e_flags))

{

usrerr("Duplicate -R flag");

ExitStat = EX_USAGE;

break;

}

BlankEnvelope.e_flags |= EF_RET_PARAM;

if (sm_strcasecmp(optarg, "hdrs") == 0)

BlankEnvelope.e_flags |= EF_NO_BODY_RETN;

else if (sm_strcasecmp(optarg, "full") != 0)

{

usrerr("Invalid -R value");

ExitStat = EX_USAGE;

}

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{dsn_ret}"), optarg);

break;

case 't': /* read recipients from message */

CHECK_AGAINST_OPMODE(j);

GrabTo = true;

break;

case 'V': /* DSN ENVID: set "original" envelope id */

CHECK_AGAINST_OPMODE(j);

if (!xtextok(optarg))

{

usrerr("Invalid syntax in -V flag");

ExitStat = EX_USAGE;

}

else

{

BlankEnvelope.e_envid = newstr(optarg);

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{dsn_envid}"), optarg);

}

break;

case 'X': /* traffic log file */

dp = drop_privileges(true);

setstat(dp);

if (stat(optarg, &traf_st) == 0 &&

S_ISFIFO(traf_st.st_mode))

TrafficLogFile = sm_io_open(SmFtStdio,

SM_TIME_DEFAULT,

optarg,

SM_IO_WRONLY, NULL);

else

TrafficLogFile = sm_io_open(SmFtStdio,

SM_TIME_DEFAULT,

optarg,

SM_IO_APPEND, NULL);

if (TrafficLogFile == NULL)

{

syserr("cannot open %s", optarg);

ExitStat = EX_CANTCREAT;

break;

}

(void) sm_io_setvbuf(TrafficLogFile, SM_TIME_DEFAULT,

NULL, SM_IO_LBF, 0);

break;

/* compatibility flags */

case 'c': /* connect to non-local mailers */

case 'i': /* don't let dot stop me */

case 'm': /* send to me too */

case 'T': /* set timeout interval */

case 'v': /* give blow-by-blow description */

setoption(j, "T", false, true, &BlankEnvelope);

break;

case 'e': /* error message disposition */

case 'M': /* define macro */

setoption(j, optarg, false, true, &BlankEnvelope);

break;

case 's': /* save From lines in headers */

setoption('f', "T", false, true, &BlankEnvelope);

break;

#ifdef DBM

case 'I': /* initialize alias DBM file */

set_op_mode(MD_INITALIAS);

break;

#endif /* DBM */

#if defined(__osf__) || defined(_AIX3)

case 'x': /* random flag that OSF/1 & AIX mailx passes */

break;

#endif /* defined(__osf__) || defined(_AIX3) */

#if defined(sony_news)

case 'E':

case 'J': /* ignore flags for Japanese code conversion

break;

#endif /* defined(sony_news) */

default:

finis(true, true, EX_USAGE);

/* NOTREACHED */

break;

}

}

/* if we've had errors so far, exit now */

if ((ExitStat != EX_OK && OpMode != MD_TEST && OpMode != MD_CHECKCONFIG) ||

ExitStat == EX_OSERR)

{

finis(false, true, ExitStat);

/* NOTREACHED */

}

if (bitset(SUBMIT_MTA, SubmitMode))

{

/* If set daemon_flags on command line, don't reset it */

if (macvalue(macid("{daemon_flags}"), &BlankEnvelope) == NULL)

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{daemon_flags}"), "CC f");

}

else if (OpMode == MD_DELIVER || OpMode == MD_SMTP)

{

SubmitMode = SUBMIT_MSA;

/* If set daemon_flags on command line, don't reset it */

if (macvalue(macid("{daemon_flags}"), &BlankEnvelope) == NULL)

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{daemon_flags}"), "c u");

}

/*

#if XDEBUG

checkfd012("before readcf");

#endif /* XDEBUG */

vendor_pre_defaults(&BlankEnvelope);

readcf(getcfname(OpMode, SubmitMode, cftype, conffile),

safecf, &BlankEnvelope);

#if !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_)

ConfigFileRead = true;

#endif /* !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) */

vendor_post_defaults(&BlankEnvelope);

/* now we can complain about missing fds */

if (MissingFds != 0 && LogLevel > 8)

{

char mbuf[MAXLINE];

mbuf[0] = '\0';

if (bitset(1 << STDIN_FILENO, MissingFds))

(void) sm_strlcat(mbuf, ", stdin", sizeof(mbuf));

if (bitset(1 << STDOUT_FILENO, MissingFds))

(void) sm_strlcat(mbuf, ", stdout", sizeof(mbuf));

if (bitset(1 << STDERR_FILENO, MissingFds))

(void) sm_strlcat(mbuf, ", stderr", sizeof(mbuf));

/* Notice: fill_errno is from high above: fill_fd() */

sm_syslog(LOG_WARNING, NOQID,

"File descriptors missing on startup: %s; %s",

&mbuf[2], sm_errstring(fill_errno));

}

/* Remove the ability for a normal user to send signals */

if (RealUid != 0 && RealUid != geteuid())

{

uid_t new_uid = geteuid();

#if HASSETREUID

/*

if (new_uid == 0)

new_uid = DefUid;

if (tTd(47, 5))

sm_dprintf("Changing real uid to %d\n", (int) new_uid);

if (setreuid(new_uid, geteuid()) < 0)

{

syserr("main: setreuid(%d, %d) failed",

(int) new_uid, (int) geteuid());

finis(false, true, EX_OSERR);

/* NOTREACHED */

}

if (tTd(47, 10))

sm_dprintf("Now running as e/ruid %d:%d\n",

(int) geteuid(), (int) getuid());

#else /* HASSETREUID */

/*

if (tTd(47, 5))

sm_dprintf("Changing uid to %d\n", (int) new_uid);

if (setuid(new_uid) < 0)

{

syserr("main: setuid(%d) failed", (int) new_uid);

finis(false, true, EX_OSERR);

/* NOTREACHED */

}

if (tTd(47, 10))

sm_dprintf("Now running as e/ruid %d:%d\n",

(int) geteuid(), (int) getuid());

#endif /* HASSETREUID */

}

#if NAMED_BIND

if (FallbackMX != NULL)

(void) getfallbackmxrr(FallbackMX);

#endif /* NAMED_BIND */

if (SuperSafe == SAFE_INTERACTIVE && CurEnv->e_sendmode != SM_DELIVER)

{

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"WARNING: SuperSafe=interactive should only be used with\n DeliveryMode=interactive\n");

}

if (UseMSP && (OpMode == MD_DAEMON || OpMode == MD_FGDAEMON))

{

usrerr("Mail submission program cannot be used as daemon");

finis(false, true, EX_USAGE);

}

if (OpMode == MD_DELIVER || OpMode == MD_SMTP ||

OpMode == MD_QUEUERUN || OpMode == MD_ARPAFTP ||

OpMode == MD_DAEMON || OpMode == MD_FGDAEMON)

makeworkgroups();

/* set up the basic signal handlers */

if (sm_signal(SIGINT, SIG_IGN) != SIG_IGN)

(void) sm_signal(SIGINT, intsig);

(void) sm_signal(SIGTERM, intsig);

/* Enforce use of local time (null string overrides this) */

if (TimeZoneSpec == NULL)

unsetenv("TZ");

else if (TimeZoneSpec[0] != '\0')

sm_setuserenv("TZ", TimeZoneSpec);

else

sm_setuserenv("TZ", NULL);

tzset();

/* initialize mailbox database */

i = sm_mbdb_initialize(Mbdb);

if (i != EX_OK)

{

usrerr("Can't initialize mailbox database \"%s\": %s",

Mbdb, sm_strexit(i));

ExitStat = i;

}

/* avoid denial-of-service attacks */

resetlimits();

if (OpMode == MD_TEST)

{

/* can't be done after readcf if RunAs* is used */

dp = drop_privileges(true);

if (dp != EX_OK)

{

finis(false, true, dp);

/* NOTREACHED */

}

}

else if (OpMode != MD_DAEMON && OpMode != MD_FGDAEMON)

{

/* drop privileges -- daemon mode done after socket/bind */

dp = drop_privileges(false);

setstat(dp);

if (dp == EX_OK && UseMSP && (geteuid() == 0 || getuid() == 0))

{

usrerr("Mail submission program must have RunAsUser set to non root user");

finis(false, true, EX_CONFIG);

/* NOTREACHED */

}

}

#if NAMED_BIND

_res.retry = TimeOuts.res_retry[RES_TO_DEFAULT];

_res.retrans = TimeOuts.res_retrans[RES_TO_DEFAULT];

#endif /* NAMED_BIND */

/*

authinfo = getauthinfo(STDIN_FILENO, &forged);

macdefine(&BlankEnvelope.e_macro, A_TEMP, '_', authinfo);

/* suppress error printing if errors mailed back or whatever */

if (BlankEnvelope.e_errormode != EM_PRINT)

HoldErrs = true;

/* set up the $=m class now, after .cf has a chance to redefine $m */

expand("\201m", jbuf, sizeof(jbuf), &BlankEnvelope);

if (jbuf[0] != '\0')

setclass('m', jbuf);

/* probe interfaces and locate any additional names */

if (DontProbeInterfaces != DPI_PROBENONE)

load_if_names();

if (tTd(0, 10))

{

char pidpath[MAXPATHLEN];

/* Now we know which .cf file we use */

sm_dprintf(" Conf file:\t%s (selected)\n",

getcfname(OpMode, SubmitMode, cftype, conffile));

expand(PidFile, pidpath, sizeof(pidpath), &BlankEnvelope);

sm_dprintf(" Pid file:\t%s (selected)\n", pidpath);

}

if (tTd(0, 1))

{

sm_dprintf("\n============ SYSTEM IDENTITY (after readcf) ============");

sm_dprintf("\n (short domain name) $w = ");

xputs(sm_debug_file(), macvalue('w', &BlankEnvelope));

sm_dprintf("\n (canonical domain name) $j = ");

xputs(sm_debug_file(), macvalue('j', &BlankEnvelope));

sm_dprintf("\n (subdomain name) $m = ");

xputs(sm_debug_file(), macvalue('m', &BlankEnvelope));

sm_dprintf("\n (node name) $k = ");

xputs(sm_debug_file(), macvalue('k', &BlankEnvelope));

sm_dprintf("\n========================================================\n\n");

}

/*

/* process authorization warnings from command line */

if (warn_C_flag)

auth_warning(&BlankEnvelope, "Processed by %s with -C %s",

RealUserName, conffile);

if (Warn_Q_option && !wordinclass(RealUserName, 't'))

auth_warning(&BlankEnvelope, "Processed from queue %s",

QueueDir);

if (sysloglabel != NULL && !wordinclass(RealUserName, 't') &&

RealUid != 0 && RealUid != TrustedUid && LogLevel > 1)

sm_syslog(LOG_WARNING, NOQID, "user %d changed syslog label",

(int) RealUid);

/* check body type for legality */

i = check_bodytype(BlankEnvelope.e_bodytype);

if (i == BODYTYPE_ILLEGAL)

{

usrerr("Illegal body type %s", BlankEnvelope.e_bodytype);

BlankEnvelope.e_bodytype = NULL;

}

else if (i != BODYTYPE_NONE)

SevenBitInput = (i == BODYTYPE_7BIT);

/* tweak default DSN notifications */

if (DefaultNotify == 0)

DefaultNotify = QPINGONFAILURE|QPINGONDELAY;

/* check for sane configuration level */

if (ConfigLevel > MAXCONFIGLEVEL)

{

syserr("Warning: .cf version level (%d) exceeds sendmail version %s functionality (%d)",

ConfigLevel, Version, MAXCONFIGLEVEL);

}

/* need MCI cache to have persistence */

if (HostStatDir != NULL && MaxMciCache == 0)

{

HostStatDir = NULL;

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Warning: HostStatusDirectory disabled with ConnectionCacheSize = 0\n");

}

/* need HostStatusDir in order to have SingleThreadDelivery */

if (SingleThreadDelivery && HostStatDir == NULL)

{

SingleThreadDelivery = false;

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Warning: HostStatusDirectory required for SingleThreadDelivery\n");

}

#if _FFR_MEMSTAT

j = sm_memstat_open();

if (j < 0 && (RefuseLowMem > 0 || QueueLowMem > 0) && LogLevel > 4)

{

sm_syslog(LOG_WARNING, NOQID,

"cannot get memory statistics, settings ignored, error=%d"

, j);

}

#endif /* _FFR_MEMSTAT */

/* check for permissions */

if (RealUid != 0 &&

RealUid != TrustedUid)

{

char *action = NULL;

switch (OpMode)

{

case MD_QUEUERUN:

if (quarantining != NULL)

action = "quarantine jobs";

else

{

/* Normal users can do a single queue run */

if (QueueIntvl == 0)

break;

}

/* but not persistent queue runners */

if (action == NULL)

action = "start a queue runner daemon";

/* FALLTHROUGH */

case MD_PURGESTAT:

if (action == NULL)

action = "purge host status";

/* FALLTHROUGH */

case MD_DAEMON:

case MD_FGDAEMON:

if (action == NULL)

action = "run daemon";

if (tTd(65, 1))

sm_dprintf("Deny user %d attempt to %s\n",

(int) RealUid, action);

if (LogLevel > 1)

sm_syslog(LOG_ALERT, NOQID,

"user %d attempted to %s",

(int) RealUid, action);

HoldErrs = false;

usrerr("Permission denied (real uid not trusted)");

finis(false, true, EX_USAGE);

/* NOTREACHED */

break;

case MD_VERIFY:

if (bitset(PRIV_RESTRICTEXPAND, PrivacyFlags))

{

/*

if (tTd(65, 1))

sm_dprintf("Drop privs for user %d attempt to expand (RestrictExpand)\n",

(int) RealUid);

dp = drop_privileges(true);

/* Fake address safety */

if (tTd(65, 1))

sm_dprintf("Faking DontBlameSendmail=NonRootSafeAddr\n");

setbitn(DBS_NONROOTSAFEADDR, DontBlameSendmail);

if (dp != EX_OK)

{

if (tTd(65, 1))

sm_dprintf("Failed to drop privs for user %d attempt to expand, exiting\n",

(int) RealUid);

CurEnv->e_id = NULL;

finis(true, true, dp);

/* NOTREACHED */

}

}

break;

case MD_TEST:

case MD_CHECKCONFIG:

case MD_PRINT:

case MD_PRINTNQE:

case MD_FREEZE:

case MD_HOSTSTAT:

/* Nothing special to check */

break;

case MD_INITALIAS:

if (!wordinclass(RealUserName, 't'))

{

if (tTd(65, 1))

sm_dprintf("Deny user %d attempt to rebuild the alias map\n",

(int) RealUid);

if (LogLevel > 1)

sm_syslog(LOG_ALERT, NOQID,

"user %d attempted to rebuild the alias map",

(int) RealUid);

HoldErrs = false;

usrerr("Permission denied (real uid not trusted)");

finis(false, true, EX_USAGE);

/* NOTREACHED */

}

if (UseMSP)

{

HoldErrs = false;

usrerr("User %d cannot rebuild aliases in mail submission program",

(int) RealUid);

finis(false, true, EX_USAGE);

/* NOTREACHED */

}

/* FALLTHROUGH */

default:

if (bitset(PRIV_RESTRICTEXPAND, PrivacyFlags) &&

Verbose != 0)

{

/*

if (tTd(65, 1))

sm_dprintf("Dropping verbosity for user %d (RestrictExpand)\n",

(int) RealUid);

Verbose = 0;

}

break;

}

}

if (MeToo)

BlankEnvelope.e_flags |= EF_METOO;

switch (OpMode)

{

case MD_TEST:

/* don't have persistent host status in test mode */

HostStatDir = NULL;

/* FALLTHROUGH */

case MD_CHECKCONFIG:

if (Verbose == 0)

Verbose = 2;

BlankEnvelope.e_errormode = EM_PRINT;

HoldErrs = false;

break;

case MD_VERIFY:

BlankEnvelope.e_errormode = EM_PRINT;

HoldErrs = false;

/* arrange to exit cleanly on hangup signal */

if (sm_signal(SIGHUP, SIG_IGN) == (sigfunc_t) SIG_DFL)

(void) sm_signal(SIGHUP, intsig);

if (geteuid() != 0)

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Notice: -bv may give misleading output for non-privileged user\n");

break;

case MD_FGDAEMON:

run_in_foreground = true;

set_op_mode(MD_DAEMON);

/* FALLTHROUGH */

case MD_DAEMON:

vendor_daemon_setup(&BlankEnvelope);

/* remove things that don't make sense in daemon mode */

FullName = NULL;

GrabTo = false;

/* arrange to restart on hangup signal */

if (SaveArgv[0] == NULL || SaveArgv[0][0] != '/')

sm_syslog(LOG_WARNING, NOQID,

"daemon invoked without full pathname; kill -1 won't work");

break;

case MD_INITALIAS:

Verbose = 2;

BlankEnvelope.e_errormode = EM_PRINT;

HoldErrs = false;

/* FALLTHROUGH */

default:

/* arrange to exit cleanly on hangup signal */

if (sm_signal(SIGHUP, SIG_IGN) == (sigfunc_t) SIG_DFL)

(void) sm_signal(SIGHUP, intsig);

break;

}

/* special considerations for FullName */

if (FullName != NULL)

{

char *full = NULL;

/* full names can't have newlines */

if (strchr(FullName, '\n') != NULL)

{

full = newstr(denlstring(FullName, true, true));

FullName = full;

}

/* check for characters that may have to be quoted */

if (!rfc822_string(FullName))

{

/*

FullName = addquotes(FullName, NULL);

if (full != NULL)

sm_free(full); /* XXX */

}

}

/* do heuristic mode adjustment */

if (Verbose)

{

/* turn off noconnect option */

setoption('c', "F", true, false, &BlankEnvelope);

/* turn on interactive delivery */

setoption('d', "", true, false, &BlankEnvelope);

}

#ifdef VENDOR_CODE

/* check for vendor mismatch */

if (VendorCode != VENDOR_CODE)

{

message("Warning: .cf file vendor code mismatch: sendmail expects vendor %s, .cf file vendor is %s",

getvendor(VENDOR_CODE), getvendor(VendorCode));

}

#endif /* VENDOR_CODE */

/* check for out of date configuration level */

if (ConfigLevel < MAXCONFIGLEVEL)

{

message("Warning: .cf file is out of date: sendmail %s supports version %d, .cf file is version %d",

Version, MAXCONFIGLEVEL, ConfigLevel);

}

if (ConfigLevel < 3)

UseErrorsTo = true;

/* set options that were previous macros */

if (SmtpGreeting == NULL)

{

if (ConfigLevel < 7 &&

(p = macvalue('e', &BlankEnvelope)) != NULL)

SmtpGreeting = newstr(p);

else

SmtpGreeting = "\201j Sendmail \201v ready at \201b";

}

if (UnixFromLine == NULL)

{

if (ConfigLevel < 7 &&

(p = macvalue('l', &BlankEnvelope)) != NULL)

UnixFromLine = newstr(p);

else

UnixFromLine = "From \201g \201d";

}

SmtpError[0] = '\0';

/* our name for SMTP codes */

expand("\201j", jbuf, sizeof(jbuf), &BlankEnvelope);

if (jbuf[0] == '\0')

PSTRSET(MyHostName, "localhost");

else

PSTRSET(MyHostName, jbuf);

if (strchr(MyHostName, '.') == NULL)

message("WARNING: local host name (%s) is not qualified; see cf/README: WHO AM I?",

MyHostName);

/* make certain that this name is part of the $=w class */

setclass('w', MyHostName);

/* fill in the structure of the *default* queue */

st = stab("mqueue", ST_QUEUE, ST_FIND);

if (st == NULL)

syserr("No default queue (mqueue) defined");

else

set_def_queueval(st->s_quegrp, true);

/* the indices of built-in mailers */

st = stab("local", ST_MAILER, ST_FIND);

if (st != NULL)

LocalMailer = st->s_mailer;

else if (OpMode != MD_TEST || !warn_C_flag)

syserr("No local mailer defined");

st = stab("prog", ST_MAILER, ST_FIND);

if (st == NULL)

syserr("No prog mailer defined");

else

{

ProgMailer = st->s_mailer;

clrbitn(M_MUSER, ProgMailer->m_flags);

}

st = stab("*file*", ST_MAILER, ST_FIND);

if (st == NULL)

syserr("No *file* mailer defined");

else

{

FileMailer = st->s_mailer;

clrbitn(M_MUSER, FileMailer->m_flags);

}

st = stab("*include*", ST_MAILER, ST_FIND);

if (st == NULL)

syserr("No *include* mailer defined");

else

InclMailer = st->s_mailer;

if (ConfigLevel < 6)

{

/* heuristic tweaking of local mailer for back compat */

if (LocalMailer != NULL)

{

setbitn(M_ALIASABLE, LocalMailer->m_flags);

setbitn(M_HASPWENT, LocalMailer->m_flags);

setbitn(M_TRYRULESET5, LocalMailer->m_flags);

setbitn(M_CHECKINCLUDE, LocalMailer->m_flags);

setbitn(M_CHECKPROG, LocalMailer->m_flags);

setbitn(M_CHECKFILE, LocalMailer->m_flags);

setbitn(M_CHECKUDB, LocalMailer->m_flags);

}

if (ProgMailer != NULL)

setbitn(M_RUNASRCPT, ProgMailer->m_flags);

if (FileMailer != NULL)

setbitn(M_RUNASRCPT, FileMailer->m_flags);

}

if (ConfigLevel < 7)

{

if (LocalMailer != NULL)

setbitn(M_VRFY250, LocalMailer->m_flags);

if (ProgMailer != NULL)

setbitn(M_VRFY250, ProgMailer->m_flags);

if (FileMailer != NULL)

setbitn(M_VRFY250, FileMailer->m_flags);

}

/* MIME Content-Types that cannot be transfer encoded */

setclass('n', "multipart/signed");

/* MIME message/xxx subtypes that can be treated as messages */

setclass('s', "rfc822");

/* MIME Content-Transfer-Encodings that can be encoded */

setclass('e', "7bit");

setclass('e', "8bit");

setclass('e', "binary");

#ifdef USE_B_CLASS

/* MIME Content-Types that should be treated as binary */

setclass('b', "image");

setclass('b', "audio");

setclass('b', "video");

setclass('b', "application/octet-stream");

#endif /* USE_B_CLASS */

/* MIME headers which have fields to check for overflow */

setclass(macid("{checkMIMEFieldHeaders}"), "content-disposition");

setclass(macid("{checkMIMEFieldHeaders}"), "content-type");

/* MIME headers to check for length overflow */

setclass(macid("{checkMIMETextHeaders}"), "content-description");

/* MIME headers to check for overflow and rebalance */

setclass(macid("{checkMIMEHeaders}"), "content-disposition");

setclass(macid("{checkMIMEHeaders}"), "content-id");

setclass(macid("{checkMIMEHeaders}"), "content-transfer-encoding");

setclass(macid("{checkMIMEHeaders}"), "content-type");

setclass(macid("{checkMIMEHeaders}"), "mime-version");

/* Macros to save in the queue file -- don't remove any */

setclass(macid("{persistentMacros}"), "r");

setclass(macid("{persistentMacros}"), "s");

setclass(macid("{persistentMacros}"), "_");

setclass(macid("{persistentMacros}"), "{if_addr}");

setclass(macid("{persistentMacros}"), "{daemon_flags}");

/* operate in queue directory */

if (QueueDir == NULL || *QueueDir == '\0')

{

if (OpMode != MD_TEST)

{

syserr("QueueDirectory (Q) option must be set");

ExitStat = EX_CONFIG;

}

}

else

{

if (OpMode != MD_TEST)

setup_queues(OpMode == MD_DAEMON);

}

/* check host status directory for validity */

if (HostStatDir != NULL && !path_is_dir(HostStatDir, false))

{

/* cannot use this value */

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Warning: Cannot use HostStatusDirectory = %s: %s\n",

HostStatDir, sm_errstring(errno));

HostStatDir = NULL;

}

if (OpMode == MD_QUEUERUN &&

RealUid != 0 && bitset(PRIV_RESTRICTQRUN, PrivacyFlags))

{

struct stat stbuf;

/* check to see if we own the queue directory */

if (stat(".", &stbuf) < 0)

syserr("main: cannot stat %s", QueueDir);

if (stbuf.st_uid != RealUid)

{

/* nope, really a botch */

HoldErrs = false;

usrerr("You do not have permission to process the queue");

finis(false, true, EX_NOPERM);

/* NOTREACHED */

}

}

#if MILTER

/* sanity checks on milter filters */

if (OpMode == MD_DAEMON || OpMode == MD_SMTP)

{

milter_config(InputFilterList, InputFilters, MAXFILTERS);

setup_daemon_milters();

}

#endif /* MILTER */

/* Convert queuegroup string to qgrp number */

if (queuegroup != NULL)

{

qgrp = name2qid(queuegroup);

if (qgrp == NOQGRP)

{

HoldErrs = false;

usrerr("Queue group %s unknown", queuegroup);

finis(false, true, ExitStat);

/* NOTREACHED */

}

}

/* if checking config or have had errors so far, exit now */

if (OpMode == MD_CHECKCONFIG || (ExitStat != EX_OK && OpMode != MD_TEST))

{

finis(false, true, ExitStat);

/* NOTREACHED */

}

#if SASL

/* sendmail specific SASL initialization */

sm_sasl_init();

#endif /* SASL */

#if XDEBUG

checkfd012("before main() initmaps");

#endif /* XDEBUG */

/*

switch (OpMode)

{

case MD_PRINT:

/* print the queue */

HoldErrs = false;

(void) dropenvelope(&BlankEnvelope, true, false);

(void) sm_signal(SIGPIPE, sigpipe);

if (qgrp != NOQGRP)

{

int j;

/* Selecting a particular queue group to run */

for (j = 0; j < Queue[qgrp]->qg_numqueues; j++)

{

if (StopRequest)

stop_sendmail();

(void) print_single_queue(qgrp, j);

}

finis(false, true, EX_OK);

/* NOTREACHED */

}

printqueue();

finis(false, true, EX_OK);

/* NOTREACHED */

break;

case MD_PRINTNQE:

/* print number of entries in queue */

(void) dropenvelope(&BlankEnvelope, true, false);

(void) sm_signal(SIGPIPE, sigpipe);

printnqe(smioout, NULL);

finis(false, true, EX_OK);

/* NOTREACHED */

break;

case MD_QUEUERUN:

/* only handle quarantining here */

if (quarantining == NULL)

break;

if (QueueMode != QM_QUARANTINE &&

QueueMode != QM_NORMAL)

{

HoldErrs = false;

usrerr("Can not use -Q with -q%c", QueueMode);

ExitStat = EX_USAGE;

finis(false, true, ExitStat);

/* NOTREACHED */

}

quarantine_queue(quarantining, qgrp);

finis(false, true, EX_OK);

break;

case MD_HOSTSTAT:

(void) sm_signal(SIGPIPE, sigpipe);

(void) mci_traverse_persistent(mci_print_persistent, NULL);

finis(false, true, EX_OK);

/* NOTREACHED */

break;

case MD_PURGESTAT:

(void) mci_traverse_persistent(mci_purge_persistent, NULL);

finis(false, true, EX_OK);

/* NOTREACHED */

break;

case MD_INITALIAS:

/* initialize maps */

initmaps();

finis(false, true, ExitStat);

/* NOTREACHED */

break;

case MD_SMTP:

case MD_DAEMON:

/* reset DSN parameters */

DefaultNotify = QPINGONFAILURE|QPINGONDELAY;

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{dsn_notify}"), NULL);

BlankEnvelope.e_envid = NULL;

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{dsn_envid}"), NULL);

BlankEnvelope.e_flags &= ~(EF_RET_PARAM|EF_NO_BODY_RETN);

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{dsn_ret}"), NULL);

/* don't open maps for daemon -- done below in child */

break;

}

if (tTd(0, 15))

{

/* print configuration table (or at least part of it) */

if (tTd(0, 90))

printrules();

for (i = 0; i < MAXMAILERS; i++)

{

if (Mailer[i] != NULL)

printmailer(sm_debug_file(), Mailer[i]);

}

}

/*

CurEnv = newenvelope(&MainEnvelope, &BlankEnvelope,

sm_rpool_new_x(NULL));

MainEnvelope.e_flags = BlankEnvelope.e_flags;

/*

if (OpMode == MD_TEST)

{

if (isatty(sm_io_getinfo(smioin, SM_IO_WHAT_FD, NULL)))

Verbose = 2;

if (Verbose)

{

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"ADDRESS TEST MODE (ruleset 3 NOT automatically invoked)\n");

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"Enter <ruleset> <address>\n");

}

macdefine(&(MainEnvelope.e_macro), A_PERM,

macid("{addr_type}"), "e r");

for (;;)

{

SM_TRY

{

(void) sm_signal(SIGINT, intindebug);

(void) sm_releasesignal(SIGINT);

if (Verbose == 2)

(void) sm_io_fprintf(smioout,

SM_TIME_DEFAULT,

"> ");

(void) sm_io_flush(smioout, SM_TIME_DEFAULT);

if (sm_io_fgets(smioin, SM_TIME_DEFAULT, buf,

sizeof(buf)) == NULL)

testmodeline("/quit", &MainEnvelope);

p = strchr(buf, '\n');

if (p != NULL)

*p = '\0';

if (Verbose < 2)

(void) sm_io_fprintf(smioout,

SM_TIME_DEFAULT,

"> %s\n", buf);

testmodeline(buf, &MainEnvelope);

}

SM_EXCEPT(exc, "[!F]*")

{

/*

(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,

"\n");

sm_exc_print(exc, smioout);

}

SM_END_TRY

}

}

#if STARTTLS

tls_ok = true;

if (OpMode == MD_QUEUERUN || OpMode == MD_DELIVER ||

OpMode == MD_ARPAFTP)

{

/* check whether STARTTLS is turned off for the client */

if (chkclientmodifiers(D_NOTLS))

tls_ok = false;

}

else if (OpMode == MD_DAEMON || OpMode == MD_FGDAEMON ||

OpMode == MD_SMTP)

{

/* check whether STARTTLS is turned off */

if (chkdaemonmodifiers(D_NOTLS) && chkclientmodifiers(D_NOTLS))

tls_ok = false;

}

else /* other modes don't need STARTTLS */

tls_ok = false;

if (tls_ok)

{

/* basic TLS initialization */

tls_ok = init_tls_library();

}

if (!tls_ok && (OpMode == MD_QUEUERUN || OpMode == MD_DELIVER))

{

/* disable TLS for client */

setclttls(false);

}

#endif /* STARTTLS */

/*

if (OpMode == MD_QUEUERUN && QueueIntvl == 0)

{

pid_t pid = -1;

#if STARTTLS

/* init TLS for client, ignore result for now */

(void) initclttls(tls_ok);

#endif /* STARTTLS */

/*

if (Verbose || foregroundqueue || (pid = fork()) <= 0)

{

/*

if (pid == 0)

{

/* Reset global flags */

RestartRequest = NULL;

ShutdownRequest = NULL;

PendingSignal = 0;

/* disconnect from terminal */

disconnect(2, CurEnv);

}

CurrentPid = getpid();

if (qgrp != NOQGRP)

{

int rwgflags = RWG_NONE;

/*

for (i = 0; i < NumQueue && Queue[i] != NULL;

i++)

Queue[i]->qg_nextrun = (time_t) -1;

Queue[qgrp]->qg_nextrun = 0;

if (Verbose)

rwgflags |= RWG_VERBOSE;

if (queuepersistent)

rwgflags |= RWG_PERSISTENT;

rwgflags |= RWG_FORCE;

(void) run_work_group(Queue[qgrp]->qg_wgrp,

rwgflags);

}

else

(void) runqueue(false, Verbose,

queuepersistent, true);

/* set the title to make it easier to find */

sm_setproctitle(true, CurEnv, "Queue control");

(void) sm_signal(SIGCHLD, SIG_DFL);

while (CurChildren > 0)

{

int status;

pid_t ret;

errno = 0;

while ((ret = sm_wait(&status)) <= 0)

{

if (errno == ECHILD)

{

/*

CurChildren = 0;

break;

}

continue;

}

/* something is really really wrong */

if (errno == ECHILD)

{

sm_syslog(LOG_ERR, NOQID,

"queue control process: lost all children: wait returned ECHILD");

break;

}

/* Only drop when a child gives status */

if (WIFSTOPPED(status))

continue;

proc_list_drop(ret, status, NULL);

}

}

finis(true, true, ExitStat);

/* NOTREACHED */

}

# if SASL

if (OpMode == MD_SMTP || OpMode == MD_DAEMON)

{

/* check whether AUTH is turned off for the server */

if (!chkdaemonmodifiers(D_NOAUTH) &&

(i = sasl_server_init(srvcallbacks, "Sendmail")) != SASL_OK)

syserr("!sasl_server_init failed! [%s]",

sasl_errstring(i, NULL, NULL));

}

# endif /* SASL */

if (OpMode == MD_SMTP)

{

proc_list_add(CurrentPid, "Sendmail SMTP Agent",

PROC_DAEMON, 0, -1, NULL);

/* clean up background delivery children */

(void) sm_signal(SIGCHLD, reapchild);

}

/*

if (OpMode == MD_DAEMON || QueueIntvl > 0)

{

char dtype[200];

/* avoid cleanup in finis(), DaemonPid will be set below */

DaemonPid = 0;

if (!run_in_foreground && !tTd(99, 100))

{

/* put us in background */

i = fork();

if (i < 0)

syserr("daemon: cannot fork");

if (i != 0)

{

finis(false, true, EX_OK);

/* NOTREACHED */

}

/*

/* Reset global flags */

RestartRequest = NULL;

RestartWorkGroup = false;

ShutdownRequest = NULL;

PendingSignal = 0;

CurrentPid = getpid();

sm_exc_newthread(fatal_error);

/* disconnect from our controlling tty */

disconnect(2, &MainEnvelope);

}

dtype[0] = '\0';

if (OpMode == MD_DAEMON)

{

(void) sm_strlcat(dtype, "+SMTP", sizeof(dtype));

DaemonPid = CurrentPid;

}

if (QueueIntvl > 0)

{

(void) sm_strlcat2(dtype,

queuepersistent

? "+persistent-queueing@"

: "+queueing@",

pintvl(QueueIntvl, true),

sizeof(dtype));

}

if (tTd(0, 1))

(void) sm_strlcat(dtype, "+debugging", sizeof(dtype));

sm_syslog(LOG_INFO, NOQID,

"starting daemon (%s): %s", Version, dtype + 1);

#if XLA

xla_create_file();

#endif /* XLA */

/* save daemon type in a macro for possible PidFile use */

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{daemon_info}"), dtype + 1);

/* save queue interval in a macro for possible PidFile use */

macdefine(&MainEnvelope.e_macro, A_TEMP,

macid("{queue_interval}"), pintvl(QueueIntvl, true));

/* workaround: can't seem to release the signal in the parent */

(void) sm_signal(SIGHUP, sighup);

(void) sm_releasesignal(SIGHUP);

(void) sm_signal(SIGTERM, sigterm);

if (QueueIntvl > 0)

{

#if _FFR_RUNPQG

if (qgrp != NOQGRP)

{

int rwgflags = RWG_NONE;

/*

for (i = 0; i < NumQueue && Queue[i] != NULL;

i++)

Queue[i]->qg_nextrun = (time_t) -1;

Queue[qgrp]->qg_nextrun = 0;

if (Verbose)

rwgflags |= RWG_VERBOSE;

if (queuepersistent)

rwgflags |= RWG_PERSISTENT;

rwgflags |= RWG_FORCE;

(void) run_work_group(Queue[qgrp]->qg_wgrp,

rwgflags);

}

else

#endif /* _FFR_RUNPQG */

(void) runqueue(true, false, queuepersistent,

true);

/*

if (OpMode != MD_DAEMON && queuepersistent)

{

/*

log_sendmail_pid(&MainEnvelope);

/* set the title to make it easier to find */

sm_setproctitle(true, CurEnv, "Queue control");

(void) sm_signal(SIGCHLD, SIG_DFL);

while (CurChildren > 0)

{

int status;

pid_t ret;

int group;

CHECK_RESTART;

errno = 0;

while ((ret = sm_wait(&status)) <= 0)

{

/*

if (errno == ECHILD)

{

CurChildren = 0;

break;

}

continue;

}

/* something is really really wrong */

if (errno == ECHILD)

{

sm_syslog(LOG_ERR, NOQID,

"persistent queue runner control process: lost all children: wait returned ECHILD");

break;

}

if (WIFSTOPPED(status))

continue;

/* Probe only on a child status */

proc_list_drop(ret, status, &group);

if (WIFSIGNALED(status))

{

if (WCOREDUMP(status))

{

sm_syslog(LOG_ERR, NOQID,

"persistent queue runner=%d core dumped, signal=%d",

group, WTERMSIG(status));

/* don't restart this */

mark_work_group_restart(

group, -1);

continue;

}

sm_syslog(LOG_ERR, NOQID,

"persistent queue runner=%d died, pid=%ld, signal=%d",

group, (long) ret,

WTERMSIG(status));

}

/*

if (sm_debug_active(&DebugNoPRestart,

1))

{

sm_syslog(LOG_DEBUG, NOQID,

"persistent queue runner=%d, exited",

group);

mark_work_group_restart(group,

-1);

}

CHECK_RESTART;

}

finis(true, true, ExitStat);

/* NOTREACHED */

}

if (OpMode != MD_DAEMON)

{

char qtype[200];

/*

log_sendmail_pid(&MainEnvelope);

/* set the title to make it easier to find */

qtype[0] = '\0';

(void) sm_strlcpyn(qtype, sizeof(qtype), 4,

"Queue runner@",

pintvl(QueueIntvl, true),

" for ",

QueueDir);

sm_setproctitle(true, CurEnv, qtype);

for (;;)

{

(void) pause();

CHECK_RESTART;

if (doqueuerun())

(void) runqueue(true, false,

false, false);

}

}

}

(void) dropenvelope(&MainEnvelope, true, false);

#if STARTTLS

/* init TLS for server, ignore result for now */

(void) initsrvtls(tls_ok);

#endif /* STARTTLS */

nextreq:

p_flags = getrequests(&MainEnvelope);

/* drop privileges */

(void) drop_privileges(false);

/*

authinfo = getauthinfo(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,

NULL), &forged);

macdefine(&BlankEnvelope.e_macro, A_TEMP, '_', authinfo);

/* at this point we are in a child: reset state */

sm_rpool_free(MainEnvelope.e_rpool);

(void) newenvelope(&MainEnvelope, &MainEnvelope,

sm_rpool_new_x(NULL));

}

if (LogLevel > 9)

{

/* log connection information */

sm_syslog(LOG_INFO, NULL, "connect from %s", authinfo);

}

/*

if (OpMode == MD_SMTP || OpMode == MD_DAEMON)

{

char pbuf[20];

/*

if (forged)

{

char ipbuf[103];

(void) sm_snprintf(ipbuf, sizeof(ipbuf), "[%.100s]",

anynet_ntoa(&RealHostAddr));

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{client_name}"), ipbuf);

}

else

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{client_name}"), RealHostName);

macdefine(&BlankEnvelope.e_macro, A_PERM,

macid("{client_ptr}"), RealHostName);

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{client_addr}"), anynet_ntoa(&RealHostAddr));

sm_getla();

switch (RealHostAddr.sa.sa_family)

{

#if NETINET

case AF_INET:

(void) sm_snprintf(pbuf, sizeof(pbuf), "%d",

RealHostAddr.sin.sin_port);

break;

#endif /* NETINET */

#if NETINET6

case AF_INET6:

(void) sm_snprintf(pbuf, sizeof(pbuf), "%d",

RealHostAddr.sin6.sin6_port);

break;

#endif /* NETINET6 */

default:

(void) sm_snprintf(pbuf, sizeof(pbuf), "0");

break;

}

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{client_port}"), pbuf);

if (OpMode == MD_DAEMON)

{

ENVELOPE *saved_env;

/* validate the connection */

HoldErrs = true;

saved_env = CurEnv;

CurEnv = &BlankEnvelope;

nullserver = validate_connection(&RealHostAddr,

macvalue(macid("{client_name}"),

&BlankEnvelope),

&BlankEnvelope);

if (bitset(EF_DISCARD, BlankEnvelope.e_flags))

MainEnvelope.e_flags |= EF_DISCARD;

CurEnv = saved_env;

HoldErrs = false;

}

else if (p_flags == NULL)

{

p_flags = (BITMAP256 *) xalloc(sizeof(*p_flags));

clrbitmap(p_flags);

}

#if STARTTLS

if (OpMode == MD_SMTP)

(void) initsrvtls(tls_ok);

#endif /* STARTTLS */

/* turn off profiling */

SM_PROF(1);

smtp(nullserver, *p_flags, &MainEnvelope);

if (tTd(93, 100))

{

/* turn off profiling */

SM_PROF(0);

if (OpMode == MD_DAEMON)

goto nextreq;

}

}

sm_rpool_free(MainEnvelope.e_rpool);

clearenvelope(&MainEnvelope, false, sm_rpool_new_x(NULL));

if (OpMode == MD_VERIFY)

{

set_delivery_mode(SM_VERIFY, &MainEnvelope);

PostMasterCopy = NULL;

}

else

{

/* interactive -- all errors are global */

MainEnvelope.e_flags |= EF_GLOBALERRS|EF_LOGSENDER;

}

/*

initsys(&MainEnvelope);

macdefine(&MainEnvelope.e_macro, A_PERM, macid("{ntries}"), "0");

macdefine(&MainEnvelope.e_macro, A_PERM, macid("{nrcpts}"), "0");

setsender(from, &MainEnvelope, NULL, '\0', false);

if (warn_f_flag != '\0' && !wordinclass(RealUserName, 't') &&

(!bitnset(M_LOCALMAILER, MainEnvelope.e_from.q_mailer->m_flags) ||

strcmp(MainEnvelope.e_from.q_user, RealUserName) != 0))

{

auth_warning(&MainEnvelope, "%s set sender to %s using -%c",

RealUserName, from, warn_f_flag);

#if SASL

auth = false;

#endif /* SASL */

}

if (auth)

{

char *fv;

/* set the initial sender for AUTH= to $f@$j */

fv = macvalue('f', &MainEnvelope);

if (fv == NULL || *fv == '\0')

MainEnvelope.e_auth_param = NULL;

else

{

if (strchr(fv, '@') == NULL)

{

i = strlen(fv) + strlen(macvalue('j',

&MainEnvelope)) + 2;

p = sm_malloc_x(i);

(void) sm_strlcpyn(p, i, 3, fv, "@",

macvalue('j',

&MainEnvelope));

}

else

p = sm_strdup_x(fv);

MainEnvelope.e_auth_param = sm_rpool_strdup_x(MainEnvelope.e_rpool,

xtextify(p, "="));

sm_free(p); /* XXX */

}

}

if (macvalue('s', &MainEnvelope) == NULL)

macdefine(&MainEnvelope.e_macro, A_PERM, 's', RealHostName);

av = argv + optind;

if (*av == NULL && !GrabTo)

{

MainEnvelope.e_to = NULL;

MainEnvelope.e_flags |= EF_GLOBALERRS;

HoldErrs = false;

SuperSafe = SAFE_NO;

usrerr("Recipient names must be specified");

/* collect body for UUCP return */

if (OpMode != MD_VERIFY)

collect(InChannel, false, NULL, &MainEnvelope, true);

finis(true, true, EX_USAGE);

/* NOTREACHED */

}

/*

save_val = LogUsrErrs;

LogUsrErrs = true;

sendtoargv(av, &MainEnvelope);

LogUsrErrs = save_val;

/* if we have had errors sofar, arrange a meaningful exit stat */

if (Errors > 0 && ExitStat == EX_OK)

ExitStat = EX_USAGE;

#if _FFR_FIX_DASHT

/*

if (GrabTo)

{

ADDRESS *q;

for (q = MainEnvelope.e_sendqueue; q != NULL; q = q->q_next)

q->q_state = QS_REMOVED;

}

#endif /* _FFR_FIX_DASHT */

/*

MainEnvelope.e_to = NULL;

if (OpMode != MD_VERIFY || GrabTo)

{

int savederrors;

unsigned long savedflags;

/*

savederrors = Errors;

savedflags = MainEnvelope.e_flags & EF_FATALERRS;