#pragma ident "%Z%%M% %I% %E% SMI"

#include <sendmail.h>

#if MILTER

# include <libmilter/mfapi.h>

# include <libmilter/mfdef.h>

#endif /* MILTER */

SM_RCSID("@(#)$Id: srvrsmtp.c,v 8.906 2005/03/16 00:36:09 ca Exp $")

#include <sys/time.h>

#include <sm/fdset.h>

#if SASL || STARTTLS

# include "sfsasl.h"

#endif /* SASL || STARTTLS */

#if SASL

# define ENC64LEN(l) (((l) + 2) * 4 / 3 + 1)

static int saslmechs __P((sasl_conn_t *, char **));

#endif /* SASL */

#if STARTTLS

# include <sysexits.h>

static SSL_CTX *srv_ctx = NULL; /* TLS server context */

static SSL *srv_ssl = NULL; /* per connection context */

static bool tls_ok_srv = false;

extern void tls_set_verify __P((SSL_CTX *, SSL *, bool));

# define TLS_VERIFY_CLIENT() tls_set_verify(srv_ctx, srv_ssl, \

bitset(SRV_VRFY_CLT, features))

#endif /* STARTTLS */

#define SRV_NONE 0x0000 /* none... */

#define SRV_OFFER_TLS 0x0001 /* offer STARTTLS */

#define SRV_VRFY_CLT 0x0002 /* request a cert */

#define SRV_OFFER_AUTH 0x0004 /* offer AUTH */

#define SRV_OFFER_ETRN 0x0008 /* offer ETRN */

#define SRV_OFFER_VRFY 0x0010 /* offer VRFY (not yet used) */

#define SRV_OFFER_EXPN 0x0020 /* offer EXPN */

#define SRV_OFFER_VERB 0x0040 /* offer VERB */

#define SRV_OFFER_DSN 0x0080 /* offer DSN */

#if PIPELINING

# define SRV_OFFER_PIPE 0x0100 /* offer PIPELINING */

# if _FFR_NO_PIPE

# define SRV_NO_PIPE 0x0200 /* disable PIPELINING, sleep if used */

# endif /* _FFR_NO_PIPE */

#endif /* PIPELINING */

#define SRV_REQ_AUTH 0x0400 /* require AUTH */

#define SRV_REQ_SEC 0x0800 /* require security - equiv to AuthOptions=p */

#define SRV_TMP_FAIL 0x1000 /* ruleset caused a temporary failure */

static unsigned int srvfeatures __P((ENVELOPE *, char *, unsigned int));

#define STOP_ATTACK ((time_t) -1)

static time_t checksmtpattack __P((volatile unsigned int *, unsigned int,

bool, char *, ENVELOPE *));

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

static void printvrfyaddr __P((ADDRESS *, bool, bool));

static void rcpt_esmtp_args __P((ADDRESS *, char *, char *, ENVELOPE *));

static char *skipword __P((char *volatile, char *));

static void setup_smtpd_io __P((void));

#if SASL

# if SASL >= 20000

static int reset_saslconn __P((sasl_conn_t **_conn, char *_hostname,

char *_remoteip, char *_localip,

char *_auth_id, sasl_ssf_t *_ext_ssf));

# define RESET_SASLCONN \

do \

{ \

result = reset_saslconn(&conn, AuthRealm, remoteip, \

localip, auth_id, &ext_ssf); \

if (result != SASL_OK) \

sasl_ok = false; \

} while (0)

# else /* SASL >= 20000 */

static int reset_saslconn __P((sasl_conn_t **_conn, char *_hostname,

struct sockaddr_in *_saddr_r,

struct sockaddr_in *_saddr_l,

sasl_external_properties_t *_ext_ssf));

# define RESET_SASLCONN \

do \

{ \

result = reset_saslconn(&conn, AuthRealm, &saddr_r, \

&saddr_l, &ext_ssf); \

if (result != SASL_OK) \

sasl_ok = false; \

} while (0)

# endif /* SASL >= 20000 */

#endif /* SASL */

extern ENVELOPE BlankEnvelope;

#define NBADRCPTS \

do \

{ \

char buf[16]; \

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

BadRcptThrottle > 0 && n_badrcpts > BadRcptThrottle \

? n_badrcpts - 1 : n_badrcpts); \

macdefine(&e->e_macro, A_TEMP, macid("{nbadrcpts}"), buf); \

} while (0)

#define SKIP_SPACE(s) while (isascii(*s) && isspace(*s)) \

(s)++

struct cmd

{

char *cmd_name; /* command name */

int cmd_code; /* internal code, see below */

};

#define CMDERROR 0 /* bad command */

#define CMDMAIL 1 /* mail -- designate sender */

#define CMDRCPT 2 /* rcpt -- designate recipient */

#define CMDDATA 3 /* data -- send message text */

#define CMDRSET 4 /* rset -- reset state */

#define CMDVRFY 5 /* vrfy -- verify address */

#define CMDEXPN 6 /* expn -- expand address */

#define CMDNOOP 7 /* noop -- do nothing */

#define CMDQUIT 8 /* quit -- close connection and die */

#define CMDHELO 9 /* helo -- be polite */

#define CMDHELP 10 /* help -- give usage info */

#define CMDEHLO 11 /* ehlo -- extended helo (RFC 1425) */

#define CMDETRN 12 /* etrn -- flush queue */

#if SASL

# define CMDAUTH 13 /* auth -- SASL authenticate */

#endif /* SASL */

#if STARTTLS

# define CMDSTLS 14 /* STARTTLS -- start TLS session */

#endif /* STARTTLS */

#define CMDVERB 17 /* verb -- go into verbose mode */

#define CMDUNIMPL 19 /* unimplemented rfc821 commands */

#define CMDLOGBOGUS 23 /* bogus command that should be logged */

#define CMDDBGQSHOW 24 /* showq -- show send queue */

#define CMDDBGDEBUG 25 /* debug -- set debug mode */

static struct cmd CmdTab[] =

{

{ "mail", CMDMAIL },

{ "rcpt", CMDRCPT },

{ "data", CMDDATA },

{ "rset", CMDRSET },

{ "vrfy", CMDVRFY },

{ "expn", CMDEXPN },

{ "help", CMDHELP },

{ "noop", CMDNOOP },

{ "quit", CMDQUIT },

{ "helo", CMDHELO },

{ "ehlo", CMDEHLO },

{ "etrn", CMDETRN },

{ "verb", CMDVERB },

{ "send", CMDUNIMPL },

{ "saml", CMDUNIMPL },

{ "soml", CMDUNIMPL },

{ "turn", CMDUNIMPL },

#if SASL

{ "auth", CMDAUTH, },

#endif /* SASL */

#if STARTTLS

{ "starttls", CMDSTLS, },

#endif /* STARTTLS */

/* remaining commands are here only to trap and log attempts to use them */

{ "showq", CMDDBGQSHOW },

{ "debug", CMDDBGDEBUG },

{ "wiz", CMDLOGBOGUS },

{ NULL, CMDERROR }

};

static char *CurSmtpClient; /* who's at the other end of channel */

#ifndef MAXBADCOMMANDS

# define MAXBADCOMMANDS 25 /* maximum number of bad commands */

#endif /* ! MAXBADCOMMANDS */

#ifndef MAXNOOPCOMMANDS

# define MAXNOOPCOMMANDS 20 /* max "noise" commands before slowdown */

#endif /* ! MAXNOOPCOMMANDS */

#ifndef MAXHELOCOMMANDS

# define MAXHELOCOMMANDS 3 /* max HELO/EHLO commands before slowdown */

#endif /* ! MAXHELOCOMMANDS */

#ifndef MAXVRFYCOMMANDS

# define MAXVRFYCOMMANDS 6 /* max VRFY/EXPN commands before slowdown */

#endif /* ! MAXVRFYCOMMANDS */

#ifndef MAXETRNCOMMANDS

# define MAXETRNCOMMANDS 8 /* max ETRN commands before slowdown */

#endif /* ! MAXETRNCOMMANDS */

#ifndef MAXTIMEOUT

# define MAXTIMEOUT (4 * 60) /* max timeout for bad commands */

#endif /* ! MAXTIMEOUT */

#ifndef MAXSHIFT

# define MAXSHIFT 8

#endif /* ! MAXSHIFT */

#if MAXSHIFT > 31

ERROR _MAXSHIFT > 31 is invalid

#endif /* MAXSHIFT */

#if MAXBADCOMMANDS > 0

# define STOP_IF_ATTACK(r) do \

{ \

if ((r) == STOP_ATTACK) \

goto stopattack; \

} while (0)

#else /* MAXBADCOMMANDS > 0 */

# define STOP_IF_ATTACK(r) r

#endif /* MAXBADCOMMANDS > 0 */

#if SM_HEAP_CHECK

static SM_DEBUG_T DebugLeakSmtp = SM_DEBUG_INITIALIZER("leak_smtp",

"@(#)$Debug: leak_smtp - trace memory leaks during SMTP processing $");

#endif /* SM_HEAP_CHECK */

typedef struct

{

bool sm_gotmail; /* mail command received */

unsigned int sm_nrcpts; /* number of successful RCPT commands */

bool sm_discard;

#if MILTER

bool sm_milterize;

bool sm_milterlist; /* any filters in the list? */

#endif /* MILTER */

char *sm_quarmsg; /* carry quarantining across messages */

} SMTP_T;

static bool smtp_data __P((SMTP_T *, ENVELOPE *));

#define MSG_TEMPFAIL "451 4.3.2 Please try again later"

#if MILTER

# define MILTER_ABORT(e) milter_abort((e))

# define MILTER_REPLY(str) \

{ \

int savelogusrerrs = LogUsrErrs; \

\

switch (state) \

{ \

case SMFIR_REPLYCODE: \

if (MilterLogLevel > 3) \

{ \

sm_syslog(LOG_INFO, e->e_id, \

"Milter: %s=%s, reject=%s", \

str, addr, response); \

LogUsrErrs = false; \

} \

if (strncmp(response, "421 ", 4) == 0) \

{ \

bool tsave = QuickAbort; \

\

QuickAbort = false; \

usrerr(response); \

QuickAbort = tsave; \

e->e_sendqueue = NULL; \

goto doquit; \

} \

else \

usrerr(response); \

break; \

\

case SMFIR_REJECT: \

if (MilterLogLevel > 3) \

{ \

sm_syslog(LOG_INFO, e->e_id, \

"Milter: %s=%s, reject=550 5.7.1 Command rejected", \

str, addr); \

LogUsrErrs = false; \

} \

usrerr("550 5.7.1 Command rejected"); \

break; \

\

case SMFIR_DISCARD: \

if (MilterLogLevel > 3) \

sm_syslog(LOG_INFO, e->e_id, \

"Milter: %s=%s, discard", \

str, addr); \

e->e_flags |= EF_DISCARD; \

break; \

\

case SMFIR_TEMPFAIL: \

if (MilterLogLevel > 3) \

{ \

sm_syslog(LOG_INFO, e->e_id, \

"Milter: %s=%s, reject=%s", \

str, addr, MSG_TEMPFAIL); \

LogUsrErrs = false; \

} \

usrerr(MSG_TEMPFAIL); \

break; \

} \

LogUsrErrs = savelogusrerrs; \

if (response != NULL) \

sm_free(response); /* XXX */ \

}

#else /* MILTER */

# define MILTER_ABORT(e)

#endif /* MILTER */

#define CLEAR_STATE(cmd) \

do \

{ \

/* abort milter filters */ \

MILTER_ABORT(e); \

\

if (smtp.sm_nrcpts > 0) \

{ \

logundelrcpts(e, cmd, 10, false); \

smtp.sm_nrcpts = 0; \

macdefine(&e->e_macro, A_PERM, \

macid("{nrcpts}"), "0"); \

} \

\

e->e_sendqueue = NULL; \

e->e_flags |= EF_CLRQUEUE; \

\

if (LogLevel > 4 && bitset(EF_LOGSENDER, e->e_flags)) \

logsender(e, NULL); \

e->e_flags &= ~EF_LOGSENDER; \

\

/* clean up a bit */ \

smtp.sm_gotmail = false; \

SuprErrs = true; \

dropenvelope(e, true, false); \

sm_rpool_free(e->e_rpool); \

e = newenvelope(e, CurEnv, sm_rpool_new_x(NULL)); \

CurEnv = e; \

\

/* put back discard bit */ \

if (smtp.sm_discard) \

e->e_flags |= EF_DISCARD; \

\

/* restore connection quarantining */ \

if (smtp.sm_quarmsg == NULL) \

{ \

e->e_quarmsg = NULL; \

macdefine(&e->e_macro, A_PERM, \

macid("{quarantine}"), ""); \

} \

else \

{ \

e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \

smtp.sm_quarmsg); \

macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \

e->e_quarmsg); \

} \

} while (0)

#define MIN_DELAY_LOG 15 /* wait before logging this again */

#define DELAY_CONN(cmd) \

if (DelayLA > 0 && (CurrentLA = getla()) >= DelayLA) \

{ \

time_t dnow; \

\

sm_setproctitle(true, e, \

"%s: %s: delaying %s: load average: %d", \

qid_printname(e), CurSmtpClient, \

cmd, DelayLA); \

if (LogLevel > 8 && (dnow = curtime()) > log_delay) \

{ \

sm_syslog(LOG_INFO, e->e_id, \

"delaying=%s, load average=%d >= %d", \

cmd, CurrentLA, DelayLA); \

log_delay = dnow + MIN_DELAY_LOG; \

} \

(void) sleep(1); \

sm_setproctitle(true, e, "%s %s: %.80s", \

qid_printname(e), CurSmtpClient, inp); \

}

smtp(nullserver, d_flags, e)

char *volatile nullserver;

BITMAP256 d_flags;

register ENVELOPE *volatile e;

{

register char *volatile p;

register struct cmd *volatile c = NULL;

char *cmd;

auto ADDRESS *vrfyqueue;

ADDRESS *a;

volatile bool gothello; /* helo command received */

bool vrfy; /* set if this is a vrfy command */

char *volatile protocol; /* sending protocol */

char *volatile sendinghost; /* sending hostname */

char *volatile peerhostname; /* name of SMTP peer or "localhost" */

auto char *delimptr;

char *id;

volatile unsigned int n_badcmds = 0; /* count of bad commands */

volatile unsigned int n_badrcpts = 0; /* number of rejected RCPT */

volatile unsigned int n_verifies = 0; /* count of VRFY/EXPN */

volatile unsigned int n_etrn = 0; /* count of ETRN */

volatile unsigned int n_noop = 0; /* count of NOOP/VERB/etc */

volatile unsigned int n_helo = 0; /* count of HELO/EHLO */

volatile int save_sevenbitinput;

bool ok;

#if _FFR_BLOCK_PROXIES

volatile bool first;

#endif /* _FFR_BLOCK_PROXIES */

volatile bool tempfail = false;

volatile time_t wt; /* timeout after too many commands */

volatile time_t previous; /* time after checksmtpattack() */

volatile bool lognullconnection = true;

register char *q;

SMTP_T smtp;

char *addr;

char *greetcode = "220";

char *hostname; /* my hostname ($j) */

QUEUE_CHAR *new;

int argno;

char *args[MAXSMTPARGS];

char inp[MAXLINE];

char cmdbuf[MAXLINE];

#if SASL

sasl_conn_t *conn;

volatile bool sasl_ok;

volatile unsigned int n_auth = 0; /* count of AUTH commands */

bool ismore;

int result;

volatile int authenticating;

char *user;

char *in, *out2;

# if SASL >= 20000

char *auth_id;

const char *out;

sasl_ssf_t ext_ssf;

char localip[60], remoteip[60];

# else /* SASL >= 20000 */

char *out;

const char *errstr;

sasl_external_properties_t ext_ssf;

struct sockaddr_in saddr_l;

struct sockaddr_in saddr_r;

# endif /* SASL >= 20000 */

sasl_security_properties_t ssp;

sasl_ssf_t *ssf;

unsigned int inlen, out2len;

unsigned int outlen;

char *volatile auth_type;

char *mechlist;

volatile unsigned int n_mechs;

unsigned int len;

#endif /* SASL */

int r;

#if STARTTLS

int fdfl;

int rfd, wfd;

volatile bool tls_active = false;

volatile bool smtps = bitnset(D_SMTPS, d_flags);

bool saveQuickAbort;

bool saveSuprErrs;

time_t tlsstart;

#endif /* STARTTLS */

volatile unsigned int features;

#if PIPELINING

# if _FFR_NO_PIPE

int np_log = 0;

# endif /* _FFR_NO_PIPE */

#endif /* PIPELINING */

volatile time_t log_delay = (time_t) 0;

save_sevenbitinput = SevenBitInput;

smtp.sm_nrcpts = 0;

#if MILTER

smtp.sm_milterize = (nullserver == NULL);

smtp.sm_milterlist = false;

#endif /* MILTER */

/* setup I/O fd correctly for the SMTP server */

setup_smtpd_io();

#if SM_HEAP_CHECK

if (sm_debug_active(&DebugLeakSmtp, 1))

{

sm_heap_newgroup();

sm_dprintf("smtp() heap group #%d\n", sm_heap_group());

}

#endif /* SM_HEAP_CHECK */

/* XXX the rpool should be set when e is initialized in main() */

e->e_rpool = sm_rpool_new_x(NULL);

e->e_macro.mac_rpool = e->e_rpool;

settime(e);

sm_getla();

peerhostname = RealHostName;

if (peerhostname == NULL)

peerhostname = "localhost";

CurHostName = peerhostname;

CurSmtpClient = macvalue('_', e);

if (CurSmtpClient == NULL)

CurSmtpClient = CurHostName;

/* check_relay may have set discard bit, save for later */

smtp.sm_discard = bitset(EF_DISCARD, e->e_flags);

#if PIPELINING

/* auto-flush output when reading input */

(void) sm_io_autoflush(InChannel, OutChannel);

#endif /* PIPELINING */

sm_setproctitle(true, e, "server %s startup", CurSmtpClient);

/* Set default features for server. */

features = ((bitset(PRIV_NOETRN, PrivacyFlags) ||

bitnset(D_NOETRN, d_flags)) ? SRV_NONE : SRV_OFFER_ETRN)

| (bitnset(D_AUTHREQ, d_flags) ? SRV_REQ_AUTH : SRV_NONE)

| (bitset(PRIV_NOEXPN, PrivacyFlags) ? SRV_NONE

: (SRV_OFFER_EXPN

| (bitset(PRIV_NOVERB, PrivacyFlags)

? SRV_NONE : SRV_OFFER_VERB)))

| (bitset(PRIV_NORECEIPTS, PrivacyFlags) ? SRV_NONE

: SRV_OFFER_DSN)

#if SASL

| (bitnset(D_NOAUTH, d_flags) ? SRV_NONE : SRV_OFFER_AUTH)

| (bitset(SASL_SEC_NOPLAINTEXT, SASLOpts) ? SRV_REQ_SEC

: SRV_NONE)

#endif /* SASL */

#if PIPELINING

| SRV_OFFER_PIPE

#endif /* PIPELINING */

#if STARTTLS

| (bitnset(D_NOTLS, d_flags) ? SRV_NONE : SRV_OFFER_TLS)

| (bitset(TLS_I_NO_VRFY, TLS_Srv_Opts) ? SRV_NONE

: SRV_VRFY_CLT)

#endif /* STARTTLS */

;

if (nullserver == NULL)

{

features = srvfeatures(e, CurSmtpClient, features);

if (bitset(SRV_TMP_FAIL, features))

{

if (LogLevel > 4)

sm_syslog(LOG_ERR, NOQID,

"ERROR: srv_features=tempfail, relay=%.100s, access temporarily disabled",

CurSmtpClient);

nullserver = "450 4.3.0 Please try again later.";

}

else

{

#if PIPELINING

# if _FFR_NO_PIPE

if (bitset(SRV_NO_PIPE, features))

{

/* for consistency */

features &= ~SRV_OFFER_PIPE;

}

# endif /* _FFR_NO_PIPE */

#endif /* PIPELINING */

#if SASL

if (bitset(SRV_REQ_SEC, features))

SASLOpts |= SASL_SEC_NOPLAINTEXT;

else

SASLOpts &= ~SASL_SEC_NOPLAINTEXT;

#endif /* SASL */

}

}

else if (strncmp(nullserver, "421 ", 4) == 0)

{

message(nullserver);

goto doquit;

}

hostname = macvalue('j', e);

#if SASL

if (AuthRealm == NULL)

AuthRealm = hostname;

sasl_ok = bitset(SRV_OFFER_AUTH, features);

n_mechs = 0;

authenticating = SASL_NOT_AUTH;

/* SASL server new connection */

if (sasl_ok)

{

# if SASL >= 20000

result = sasl_server_new("smtp", AuthRealm, NULL, NULL, NULL,

NULL, 0, &conn);

# elif SASL > 10505

/* use empty realm: only works in SASL > 1.5.5 */

result = sasl_server_new("smtp", AuthRealm, "", NULL, 0, &conn);

# else /* SASL >= 20000 */

/* use no realm -> realm is set to hostname by SASL lib */

result = sasl_server_new("smtp", AuthRealm, NULL, NULL, 0,

&conn);

# endif /* SASL >= 20000 */

sasl_ok = result == SASL_OK;

if (!sasl_ok)

{

if (LogLevel > 9)

sm_syslog(LOG_WARNING, NOQID,

"AUTH error: sasl_server_new failed=%d",

result);

}

}

if (sasl_ok)

{

/*

# if SASL >= 20000

localip[0] = remoteip[0] = '\0';

# if NETINET || NETINET6

in = macvalue(macid("{daemon_family}"), e);

if (in != NULL && (

# if NETINET6

strcmp(in, "inet6") == 0 ||

# endif /* NETINET6 */

strcmp(in, "inet") == 0))

{

SOCKADDR_LEN_T addrsize;

SOCKADDR saddr_l;

SOCKADDR saddr_r;

addrsize = sizeof(saddr_r);

if (getpeername(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,

NULL),

(struct sockaddr *) &saddr_r,

&addrsize) == 0)

{

if (iptostring(&saddr_r, addrsize,

remoteip, sizeof remoteip))

{

sasl_setprop(conn, SASL_IPREMOTEPORT,

remoteip);

}

addrsize = sizeof(saddr_l);

if (getsockname(sm_io_getinfo(InChannel,

SM_IO_WHAT_FD,

NULL),

(struct sockaddr *) &saddr_l,

&addrsize) == 0)

{

if (iptostring(&saddr_l, addrsize,

localip,

sizeof localip))

{

sasl_setprop(conn,

SASL_IPLOCALPORT,

localip);

}

}

}

}

# endif /* NETINET || NETINET6 */

# else /* SASL >= 20000 */

# if NETINET

in = macvalue(macid("{daemon_family}"), e);

if (in != NULL && strcmp(in, "inet") == 0)

{

SOCKADDR_LEN_T addrsize;

addrsize = sizeof(struct sockaddr_in);

if (getpeername(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,

NULL),

(struct sockaddr *)&saddr_r,

&addrsize) == 0)

{

sasl_setprop(conn, SASL_IP_REMOTE, &saddr_r);

addrsize = sizeof(struct sockaddr_in);

if (getsockname(sm_io_getinfo(InChannel,

SM_IO_WHAT_FD,

NULL),

(struct sockaddr *)&saddr_l,

&addrsize) == 0)

sasl_setprop(conn, SASL_IP_LOCAL,

&saddr_l);

}

}

# endif /* NETINET */

# endif /* SASL >= 20000 */

auth_type = NULL;

mechlist = NULL;

user = NULL;

# if 0

macdefine(&BlankEnvelope.e_macro, A_PERM,

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

# endif /* 0 */

/* set properties */

(void) memset(&ssp, '\0', sizeof ssp);

/* XXX should these be options settable via .cf ? */

/* ssp.min_ssf = 0; is default due to memset() */

{

ssp.max_ssf = MaxSLBits;

ssp.maxbufsize = MAXOUTLEN;

}

ssp.security_flags = SASLOpts & SASL_SEC_MASK;

sasl_ok = sasl_setprop(conn, SASL_SEC_PROPS, &ssp) == SASL_OK;

if (sasl_ok)

{

/*

# if SASL >= 20000

ext_ssf = 0;

auth_id = NULL;

sasl_ok = ((sasl_setprop(conn, SASL_SSF_EXTERNAL,

&ext_ssf) == SASL_OK) &&

(sasl_setprop(conn, SASL_AUTH_EXTERNAL,

auth_id) == SASL_OK));

# else /* SASL >= 20000 */

ext_ssf.ssf = 0;

ext_ssf.auth_id = NULL;

sasl_ok = sasl_setprop(conn, SASL_SSF_EXTERNAL,

&ext_ssf) == SASL_OK;

# endif /* SASL >= 20000 */

}

if (sasl_ok)

n_mechs = saslmechs(conn, &mechlist);

}

#endif /* SASL */

#if STARTTLS

#endif /* STARTTLS */

#if MILTER

if (smtp.sm_milterize)

{

char state;

/* initialize mail filter connection */

smtp.sm_milterlist = milter_init(e, &state);

switch (state)

{

case SMFIR_REJECT:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: initialization failed, rejecting commands");

greetcode = "554";

nullserver = "Command rejected";

smtp.sm_milterize = false;

break;

case SMFIR_TEMPFAIL:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: initialization failed, temp failing commands");

tempfail = true;

smtp.sm_milterize = false;

break;

}

}

if (smtp.sm_milterlist && smtp.sm_milterize &&

!bitset(EF_DISCARD, e->e_flags))

{

char state;

char *response;

response = milter_connect(peerhostname, RealHostAddr,

e, &state);

switch (state)

{

case SMFIR_REPLYCODE: /* REPLYCODE shouldn't happen */

case SMFIR_REJECT:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: connect: host=%s, addr=%s, rejecting commands",

peerhostname,

anynet_ntoa(&RealHostAddr));

greetcode = "554";

nullserver = "Command rejected";

smtp.sm_milterize = false;

break;

case SMFIR_TEMPFAIL:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: connect: host=%s, addr=%s, temp failing commands",

peerhostname,

anynet_ntoa(&RealHostAddr));

tempfail = true;

smtp.sm_milterize = false;

break;

case SMFIR_SHUTDOWN:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: connect: host=%s, addr=%s, shutdown",

peerhostname,

anynet_ntoa(&RealHostAddr));

tempfail = true;

smtp.sm_milterize = false;

message("421 4.7.0 %s closing connection",

MyHostName);

/* arrange to ignore send list */

e->e_sendqueue = NULL;

goto doquit;

}

if (response != NULL)

sm_free(response); /* XXX */

}

#endif /* MILTER */

/*

if (

#if STARTTLS

!smtps &&

#endif /* STARTTLS */

*greetcode == '2')

{

time_t msecs = 0;

char **pvp;

char pvpbuf[PSBUFSIZE];

/* Ask the rulesets how long to pause */

pvp = NULL;

r = rscap("greet_pause", peerhostname,

anynet_ntoa(&RealHostAddr), e,

&pvp, pvpbuf, sizeof(pvpbuf));

if (r == EX_OK && pvp != NULL && pvp[0] != NULL &&

(pvp[0][0] & 0377) == CANONNET && pvp[1] != NULL)

{

msecs = strtol(pvp[1], NULL, 10);

}

if (msecs > 0)

{

int fd;

fd_set readfds;

struct timeval timeout;

/* pause for a moment */

timeout.tv_sec = msecs / 1000;

timeout.tv_usec = (msecs % 1000) * 1000;

/* Obey RFC 2821: 4.3.5.2: 220 timeout of 5 minutes */

if (timeout.tv_sec >= 300)

{

timeout.tv_sec = 300;

timeout.tv_usec = 0;

}

/* check if data is on the socket during the pause */

fd = sm_io_getinfo(InChannel, SM_IO_WHAT_FD, NULL);

FD_ZERO(&readfds);

SM_FD_SET(fd, &readfds);

if (select(fd + 1, FDSET_CAST &readfds,

NULL, NULL, &timeout) > 0 &&

FD_ISSET(fd, &readfds))

{

greetcode = "554";

nullserver = "Command rejected";

sm_syslog(LOG_INFO, e->e_id,

"rejecting commands from %s [%s] due to pre-greeting traffic",

peerhostname,

anynet_ntoa(&RealHostAddr));

}

}

}

#if STARTTLS

/* If this an smtps connection, start TLS now */

if (smtps)

{

Errors = 0;

goto starttls;

}

greeting:

#endif /* STARTTLS */

/* output the first line, inserting "ESMTP" as second word */

if (*greetcode == '5')

(void) sm_snprintf(inp, sizeof inp, "%s not accepting messages",

hostname);

else

expand(SmtpGreeting, inp, sizeof inp, e);

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

if (p != NULL)

*p++ = '\0';

id = strchr(inp, ' ');

if (id == NULL)

id = &inp[strlen(inp)];

if (p == NULL)

(void) sm_snprintf(cmdbuf, sizeof cmdbuf,

"%s %%.*s ESMTP%%s", greetcode);

else

(void) sm_snprintf(cmdbuf, sizeof cmdbuf,

"%s-%%.*s ESMTP%%s", greetcode);

message(cmdbuf, (int) (id - inp), inp, id);

/* output remaining lines */

while ((id = p) != NULL && (p = strchr(id, '\n')) != NULL)

{

*p++ = '\0';

if (isascii(*id) && isspace(*id))

id++;

(void) sm_strlcpyn(cmdbuf, sizeof cmdbuf, 2, greetcode, "-%s");

message(cmdbuf, id);

}

if (id != NULL)

{

if (isascii(*id) && isspace(*id))

id++;

(void) sm_strlcpyn(cmdbuf, sizeof cmdbuf, 2, greetcode, " %s");

message(cmdbuf, id);

}

protocol = NULL;

sendinghost = macvalue('s', e);

/* If quarantining by a connect/ehlo action, save between messages */

if (e->e_quarmsg == NULL)

smtp.sm_quarmsg = NULL;

else

smtp.sm_quarmsg = newstr(e->e_quarmsg);

/* sendinghost's storage must outlive the current envelope */

if (sendinghost != NULL)

sendinghost = sm_strdup_x(sendinghost);

#if _FFR_BLOCK_PROXIES

first = true;

#endif /* _FFR_BLOCK_PROXIES */

gothello = false;

smtp.sm_gotmail = false;

for (;;)

{

SM_TRY

{

QuickAbort = false;

HoldErrs = false;

SuprErrs = false;

LogUsrErrs = false;

OnlyOneError = true;

e->e_flags &= ~(EF_VRFYONLY|EF_GLOBALERRS);

/* setup for the read */

e->e_to = NULL;

Errors = 0;

FileName = NULL;

(void) sm_io_flush(smioout, SM_TIME_DEFAULT);

/* read the input line */

SmtpPhase = "server cmd read";

sm_setproctitle(true, e, "server %s cmd read", CurSmtpClient);

#if SASL

/*

#endif /* SASL */

/* handle errors */

if (sm_io_error(OutChannel) ||

(p = sfgets(inp, sizeof inp, InChannel,

TimeOuts.to_nextcommand, SmtpPhase)) == NULL)

{

char *d;

d = macvalue(macid("{daemon_name}"), e);

if (d == NULL)

d = "stdin";

/* end of file, just die */

disconnect(1, e);

#if MILTER

/* close out milter filters */

milter_quit(e);

#endif /* MILTER */

message("421 4.4.1 %s Lost input channel from %s",

MyHostName, CurSmtpClient);

if (LogLevel > (smtp.sm_gotmail ? 1 : 19))

sm_syslog(LOG_NOTICE, e->e_id,

"lost input channel from %s to %s after %s",

CurSmtpClient, d,

(c == NULL || c->cmd_name == NULL) ? "startup" : c->cmd_name);

/*

if (bitset(EF_CLRQUEUE, e->e_flags))

e->e_sendqueue = NULL;

goto doquit;

}

#if _FFR_BLOCK_PROXIES

if (first)

{

size_t inplen, cmdlen;

int idx;

char *http_cmd;

static char *http_cmds[] = { "GET", "POST",

"CONNECT", "USER", NULL };

inplen = strlen(inp);

for (idx = 0; (http_cmd = http_cmds[idx]) != NULL;

idx++)

{

cmdlen = strlen(http_cmd);

if (cmdlen < inplen &&

sm_strncasecmp(inp, http_cmd, cmdlen) == 0 &&

isascii(inp[cmdlen]) && isspace(inp[cmdlen]))

{

/* Open proxy, drop it */

message("421 4.7.0 %s Rejecting open proxy %s",

MyHostName, CurSmtpClient);

sm_syslog(LOG_INFO, e->e_id,

"%s: probable open proxy: command=%.40s",

CurSmtpClient, inp);

goto doquit;

}

}

first = false;

}

#endif /* _FFR_BLOCK_PROXIES */

/* clean up end of line */

fixcrlf(inp, true);

#if PIPELINING

# if _FFR_NO_PIPE

/*

if (bitset(SRV_NO_PIPE, features) &&

sm_io_getinfo(InChannel, SM_IO_IS_READABLE, NULL) > 0)

{

if (++np_log < 3)

sm_syslog(LOG_INFO, NOQID,

"unauthorized PIPELINING, sleeping");

sleep(1);

}

# endif /* _FFR_NO_PIPE */

#endif /* PIPELINING */

#if SASL

if (authenticating == SASL_PROC_AUTH)

{

# if 0

if (*inp == '\0')

{

authenticating = SASL_NOT_AUTH;

message("501 5.5.2 missing input");

RESET_SASLCONN;

continue;

}

# endif /* 0 */

if (*inp == '*' && *(inp + 1) == '\0')

{

authenticating = SASL_NOT_AUTH;

/* rfc 2254 4. */

message("501 5.0.0 AUTH aborted");

RESET_SASLCONN;

continue;

}

/* could this be shorter? XXX */

# if SASL >= 20000

in = xalloc(strlen(inp) + 1);

result = sasl_decode64(inp, strlen(inp), in,

strlen(inp), &inlen);

# else /* SASL >= 20000 */

out = xalloc(strlen(inp));

result = sasl_decode64(inp, strlen(inp), out, &outlen);

# endif /* SASL >= 20000 */

if (result != SASL_OK)

{

authenticating = SASL_NOT_AUTH;

/* rfc 2254 4. */

message("501 5.5.4 cannot decode AUTH parameter %s",

inp);

# if SASL >= 20000

sm_free(in);

# endif /* SASL >= 20000 */

RESET_SASLCONN;

continue;

}

# if SASL >= 20000

result = sasl_server_step(conn, in, inlen,

&out, &outlen);

sm_free(in);

# else /* SASL >= 20000 */

result = sasl_server_step(conn, out, outlen,

&out, &outlen, &errstr);

# endif /* SASL >= 20000 */

/* get an OK if we're done */

if (result == SASL_OK)

{

authenticated:

message("235 2.0.0 OK Authenticated");

authenticating = SASL_IS_AUTH;

macdefine(&BlankEnvelope.e_macro, A_TEMP,

macid("{auth_type}"), auth_type);

# if SASL >= 20000

user = macvalue(macid("{auth_authen}"), e);

/* get security strength (features) */

result = sasl_getprop(conn, SASL_SSF,

(const void **) &ssf);

# else /* SASL >= 20000 */

result = sasl_getprop(conn, SASL_USERNAME,

(void **)&user);

if (result != SASL_OK)

{

user = "";

macdefine(&BlankEnvelope.e_macro,

A_PERM,

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

}

else

{

macdefine(&BlankEnvelope.e_macro,

A_TEMP,

macid("{auth_authen}"),

xtextify(user, "<>\")"));

}

# if 0

/* get realm? */

sasl_getprop(conn, SASL_REALM, (void **) &data);

# endif /* 0 */

/* get security strength (features) */

result = sasl_getprop(conn, SASL_SSF,

(void **) &ssf);

# endif /* SASL >= 20000 */

if (result != SASL_OK)

{

macdefine(&BlankEnvelope.e_macro,

A_PERM,

macid("{auth_ssf}"), "0");

ssf = NULL;

}

else

{

char pbuf[8];

(void) sm_snprintf(pbuf, sizeof pbuf,

"%u", *ssf);

macdefine(&BlankEnvelope.e_macro,

A_TEMP,

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

if (tTd(95, 8))

sm_dprintf("AUTH auth_ssf: %u\n",

*ssf);

}

/*

if (ssf != NULL && *ssf > 0)

{

/*

if (sfdcsasl(&InChannel, &OutChannel,

conn) == 0)

{

/* restart dialogue */

n_helo = 0;

# if PIPELINING

(void) sm_io_autoflush(InChannel,

OutChannel);

# endif /* PIPELINING */

}

else

syserr("503 5.3.3 SASL TLS failed");

}

/* NULL pointer ok since it's our function */

if (LogLevel > 8)

sm_syslog(LOG_INFO, NOQID,

"AUTH=server, relay=%s, authid=%.128s, mech=%.16s, bits=%d",

CurSmtpClient,

shortenstring(user, 128),

auth_type, *ssf);

}

else if (result == SASL_CONTINUE)

{

len = ENC64LEN(outlen);

out2 = xalloc(len);

result = sasl_encode64(out, outlen, out2, len,

&out2len);

if (result != SASL_OK)

{

/* correct code? XXX */

/* 454 Temp. authentication failure */

message("454 4.5.4 Internal error: unable to encode64");

if (LogLevel > 5)

sm_syslog(LOG_WARNING, e->e_id,

"AUTH encode64 error [%d for \"%s\"]",

result, out);

/* start over? */

authenticating = SASL_NOT_AUTH;

}

else

{

message("334 %s", out2);

if (tTd(95, 2))

sm_dprintf("AUTH continue: msg='%s' len=%u\n",

out2, out2len);

}

# if SASL >= 20000

sm_free(out2);

# endif /* SASL >= 20000 */

}

else

{

/* not SASL_OK or SASL_CONT */

message("535 5.7.0 authentication failed");

if (LogLevel > 9)

sm_syslog(LOG_WARNING, e->e_id,

"AUTH failure (%s): %s (%d) %s",

auth_type,

sasl_errstring(result, NULL,

NULL),

result,

# if SASL >= 20000

sasl_errdetail(conn));

# else /* SASL >= 20000 */

errstr == NULL ? "" : errstr);

# endif /* SASL >= 20000 */

RESET_SASLCONN;

authenticating = SASL_NOT_AUTH;

}

}

else

{

/* don't want to do any of this if authenticating */

#endif /* SASL */

/* echo command to transcript */

if (e->e_xfp != NULL)

(void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,

"<<< %s\n", inp);

if (LogLevel > 14)

sm_syslog(LOG_INFO, e->e_id, "<-- %s", inp);

/* break off command */

for (p = inp; isascii(*p) && isspace(*p); p++)

continue;

cmd = cmdbuf;

while (*p != '\0' &&

!(isascii(*p) && isspace(*p)) &&

cmd < &cmdbuf[sizeof cmdbuf - 2])

*cmd++ = *p++;

*cmd = '\0';

/* throw away leading whitespace */

SKIP_SPACE(p);

/* decode command */

for (c = CmdTab; c->cmd_name != NULL; c++)

{

if (sm_strcasecmp(c->cmd_name, cmdbuf) == 0)

break;

}

/* reset errors */

errno = 0;

/* check whether a "non-null" command has been used */

switch (c->cmd_code)

{

#if SASL

case CMDAUTH:

/* avoid information leak; take first two words? */

q = "AUTH";

break;

#endif /* SASL */

case CMDMAIL:

case CMDEXPN:

case CMDVRFY:

case CMDETRN:

lognullconnection = false;

/* FALLTHROUGH */

default:

q = inp;

break;

}

if (e->e_id == NULL)

sm_setproctitle(true, e, "%s: %.80s",

CurSmtpClient, q);

else

sm_setproctitle(true, e, "%s %s: %.80s",

qid_printname(e),

CurSmtpClient, q);

/*

if (nullserver != NULL || bitnset(D_ETRNONLY, d_flags))

{

switch (c->cmd_code)

{

case CMDQUIT:

case CMDHELO:

case CMDEHLO:

case CMDNOOP:

case CMDRSET:

case CMDERROR:

/* process normally */

break;

case CMDETRN:

if (bitnset(D_ETRNONLY, d_flags) &&

nullserver == NULL)

break;

DELAY_CONN("ETRN");

/* FALLTHROUGH */

default:

#if MAXBADCOMMANDS > 0

/* theoretically this could overflow */

if (nullserver != NULL &&

++n_badcmds > MAXBADCOMMANDS)

{

message("421 4.7.0 %s Too many bad commands; closing connection",

MyHostName);

/* arrange to ignore send list */

e->e_sendqueue = NULL;

goto doquit;

}

#endif /* MAXBADCOMMANDS > 0 */

if (nullserver != NULL)

{

if (ISSMTPREPLY(nullserver))

usrerr(nullserver);

else

usrerr("550 5.0.0 %s",

nullserver);

}

else

usrerr("452 4.4.5 Insufficient disk space; try again later");

continue;

}

}

switch (c->cmd_code)

{

#if SASL

case CMDAUTH: /* sasl */

DELAY_CONN("AUTH");

if (!sasl_ok || n_mechs <= 0)

{

message("503 5.3.3 AUTH not available");

break;

}

if (authenticating == SASL_IS_AUTH)

{

message("503 5.5.0 Already Authenticated");

break;

}

if (smtp.sm_gotmail)

{

message("503 5.5.0 AUTH not permitted during a mail transaction");

break;

}

if (tempfail)

{

if (LogLevel > 9)

sm_syslog(LOG_INFO, e->e_id,

"SMTP AUTH command (%.100s) from %s tempfailed (due to previous checks)",

p, CurSmtpClient);

usrerr("454 4.3.0 Please try again later");

break;

}

ismore = false;

/* crude way to avoid crack attempts */

STOP_IF_ATTACK(checksmtpattack(&n_auth, n_mechs + 1,

true, "AUTH", e));

/* make sure mechanism (p) is a valid string */

for (q = p; *q != '\0' && isascii(*q); q++)

{

if (isspace(*q))

{

*q = '\0';

while (*++q != '\0' &&

isascii(*q) && isspace(*q))

continue;

*(q - 1) = '\0';

ismore = (*q != '\0');

break;

}

}

if (*p == '\0')

{

message("501 5.5.2 AUTH mechanism must be specified");

break;

}

/* check whether mechanism is available */

if (iteminlist(p, mechlist, " ") == NULL)

{

message("504 5.3.3 AUTH mechanism %.32s not available",

p);

break;

}

if (ismore)

{

/* could this be shorter? XXX */

# if SASL >= 20000

in = xalloc(strlen(q) + 1);

result = sasl_decode64(q, strlen(q), in,

strlen(q), &inlen);

# else /* SASL >= 20000 */

in = sm_rpool_malloc(e->e_rpool, strlen(q));

result = sasl_decode64(q, strlen(q), in,

&inlen);

# endif /* SASL >= 20000 */

if (result != SASL_OK)

{

message("501 5.5.4 cannot BASE64 decode '%s'",

q);

if (LogLevel > 5)

sm_syslog(LOG_WARNING, e->e_id,

"AUTH decode64 error [%d for \"%s\"]",

result, q);

/* start over? */

authenticating = SASL_NOT_AUTH;

# if SASL >= 20000

sm_free(in);

# endif /* SASL >= 20000 */

in = NULL;

inlen = 0;

break;

}

}

else

{

in = NULL;

inlen = 0;

}

/* see if that auth type exists */

# if SASL >= 20000

result = sasl_server_start(conn, p, in, inlen,

&out, &outlen);

if (in != NULL)

sm_free(in);

# else /* SASL >= 20000 */

result = sasl_server_start(conn, p, in, inlen,

&out, &outlen, &errstr);

# endif /* SASL >= 20000 */

if (result != SASL_OK && result != SASL_CONTINUE)

{

message("535 5.7.0 authentication failed");

if (LogLevel > 9)

sm_syslog(LOG_ERR, e->e_id,

"AUTH failure (%s): %s (%d) %s",

p,

sasl_errstring(result, NULL,

NULL),

result,

# if SASL >= 20000

sasl_errdetail(conn));

# else /* SASL >= 20000 */

errstr);

# endif /* SASL >= 20000 */

RESET_SASLCONN;

break;

}

auth_type = newstr(p);

if (result == SASL_OK)

{

/* ugly, but same code */

goto authenticated;

/* authenticated by the initial response */

}

/* len is at least 2 */

len = ENC64LEN(outlen);

out2 = xalloc(len);

result = sasl_encode64(out, outlen, out2, len,

&out2len);

if (result != SASL_OK)

{

message("454 4.5.4 Temporary authentication failure");

if (LogLevel > 5)

sm_syslog(LOG_WARNING, e->e_id,

"AUTH encode64 error [%d for \"%s\"]",

result, out);

/* start over? */

authenticating = SASL_NOT_AUTH;

RESET_SASLCONN;

}

else

{

message("334 %s", out2);

authenticating = SASL_PROC_AUTH;

}

# if SASL >= 20000

sm_free(out2);

# endif /* SASL >= 20000 */

break;

#endif /* SASL */

#if STARTTLS

case CMDSTLS: /* starttls */

DELAY_CONN("STARTTLS");

if (*p != '\0')

{

message("501 5.5.2 Syntax error (no parameters allowed)");

break;

}

if (!bitset(SRV_OFFER_TLS, features))

{

message("503 5.5.0 TLS not available");

break;

}

if (!tls_ok_srv)

{

message("454 4.3.3 TLS not available after start");

break;

}

if (smtp.sm_gotmail)

{

message("503 5.5.0 TLS not permitted during a mail transaction");

break;

}

if (tempfail)

{

if (LogLevel > 9)

sm_syslog(LOG_INFO, e->e_id,

"SMTP STARTTLS command (%.100s) from %s tempfailed (due to previous checks)",

p, CurSmtpClient);

usrerr("454 4.7.0 Please try again later");

break;

}

starttls:

# if TLS_NO_RSA

/*

# else /* TLS_NO_RSA */

# endif /* TLS_NO_RSA */

# if TLS_VRFY_PER_CTX

/*

TLS_VERIFY_CLIENT();

# endif /* TLS_VRFY_PER_CTX */

if (srv_ssl != NULL)

SSL_clear(srv_ssl);

else if ((srv_ssl = SSL_new(srv_ctx)) == NULL)

{

message("454 4.3.3 TLS not available: error generating SSL handle");

if (LogLevel > 8)

tlslogerr("server");

goto tls_done;

}

# if !TLS_VRFY_PER_CTX

/*

TLS_VERIFY_CLIENT();

# endif /* !TLS_VRFY_PER_CTX */

rfd = sm_io_getinfo(InChannel, SM_IO_WHAT_FD, NULL);

wfd = sm_io_getinfo(OutChannel, SM_IO_WHAT_FD, NULL);

if (rfd < 0 || wfd < 0 ||

SSL_set_rfd(srv_ssl, rfd) <= 0 ||

SSL_set_wfd(srv_ssl, wfd) <= 0)

{

message("454 4.3.3 TLS not available: error set fd");

SSL_free(srv_ssl);

srv_ssl = NULL;

goto tls_done;

}

if (!smtps)

message("220 2.0.0 Ready to start TLS");

# if PIPELINING

(void) sm_io_flush(OutChannel, SM_TIME_DEFAULT);

# endif /* PIPELINING */

SSL_set_accept_state(srv_ssl);

# define SSL_ACC(s) SSL_accept(s)

tlsstart = curtime();

fdfl = fcntl(rfd, F_GETFL);

if (fdfl != -1)

fcntl(rfd, F_SETFL, fdfl|O_NONBLOCK);

ssl_retry:

if ((r = SSL_ACC(srv_ssl)) <= 0)

{

int i;

bool timedout;

time_t left;

time_t now = curtime();

struct timeval tv;

/* what to do in this case? */

i = SSL_get_error(srv_ssl, r);

/*

left = TimeOuts.to_starttls - (now - tlsstart);

timedout = left <= 0;

if (!timedout)

{

tv.tv_sec = left;

tv.tv_usec = 0;

}

if (!timedout && FD_SETSIZE > 0 &&

(rfd >= FD_SETSIZE ||

(i == SSL_ERROR_WANT_WRITE &&

wfd >= FD_SETSIZE)))

{

if (LogLevel > 5)

{

sm_syslog(LOG_ERR, NOQID,

"STARTTLS=server, error: fd %d/%d too large",

rfd, wfd);

if (LogLevel > 8)

tlslogerr("server");

}

goto tlsfail;

}

/* XXX what about SSL_pending() ? */

if (!timedout && i == SSL_ERROR_WANT_READ)

{

fd_set ssl_maskr, ssl_maskx;

FD_ZERO(&ssl_maskr);

FD_SET(rfd, &ssl_maskr);

FD_ZERO(&ssl_maskx);

FD_SET(rfd, &ssl_maskx);

if (select(rfd + 1, &ssl_maskr, NULL,

&ssl_maskx, &tv) > 0)

goto ssl_retry;

}

if (!timedout && i == SSL_ERROR_WANT_WRITE)

{

fd_set ssl_maskw, ssl_maskx;

FD_ZERO(&ssl_maskw);

FD_SET(wfd, &ssl_maskw);

FD_ZERO(&ssl_maskx);

FD_SET(rfd, &ssl_maskx);

if (select(wfd + 1, NULL, &ssl_maskw,

&ssl_maskx, &tv) > 0)

goto ssl_retry;

}

if (LogLevel > 5)

{

sm_syslog(LOG_WARNING, NOQID,

"STARTTLS=server, error: accept failed=%d, SSL_error=%d, timedout=%d, errno=%d",

r, i, (int) timedout, errno);

if (LogLevel > 8)

tlslogerr("server");

}

tlsfail:

tls_ok_srv = false;

SSL_free(srv_ssl);

srv_ssl = NULL;

/*

/* arrange to ignore any current send list */

e->e_sendqueue = NULL;

goto doquit;

}

if (fdfl != -1)

fcntl(rfd, F_SETFL, fdfl);

/* ignore return code for now, it's in {verify} */

(void) tls_get_info(srv_ssl, true,

CurSmtpClient,

&BlankEnvelope.e_macro,

bitset(SRV_VRFY_CLT, features));

/*

saveQuickAbort = QuickAbort;

saveSuprErrs = SuprErrs;

SuprErrs = true;

QuickAbort = false;

if (rscheck("tls_client",

macvalue(macid("{verify}"), e),

"STARTTLS", e,

RSF_RMCOMM|RSF_COUNT,

5, NULL, NOQID) != EX_OK ||

Errors > 0)

{

extern char MsgBuf[];

if (MsgBuf[0] != '\0' && ISSMTPREPLY(MsgBuf))

nullserver = newstr(MsgBuf);

else

nullserver = "503 5.7.0 Authentication required.";

}

QuickAbort = saveQuickAbort;

SuprErrs = saveSuprErrs;

tls_ok_srv = false; /* don't offer STARTTLS again */

n_helo = 0;

# if SASL

if (sasl_ok)

{

int cipher_bits;

bool verified;

char *s, *v, *c;

s = macvalue(macid("{cipher_bits}"), e);

v = macvalue(macid("{verify}"), e);

c = macvalue(macid("{cert_subject}"), e);

verified = (v != NULL && strcmp(v, "OK") == 0);

if (s != NULL && (cipher_bits = atoi(s)) > 0)

{

# if SASL >= 20000

ext_ssf = cipher_bits;

auth_id = verified ? c : NULL;

sasl_ok = ((sasl_setprop(conn,

SASL_SSF_EXTERNAL,

&ext_ssf) == SASL_OK) &&

(sasl_setprop(conn,

SASL_AUTH_EXTERNAL,

auth_id) == SASL_OK));

# else /* SASL >= 20000 */

ext_ssf.ssf = cipher_bits;

ext_ssf.auth_id = verified ? c : NULL;

sasl_ok = sasl_setprop(conn,

SASL_SSF_EXTERNAL,

&ext_ssf) == SASL_OK;

# endif /* SASL >= 20000 */

mechlist = NULL;

if (sasl_ok)

n_mechs = saslmechs(conn,

&mechlist);

}

}

# endif /* SASL */

/* switch to secure connection */

if (sfdctls(&InChannel, &OutChannel, srv_ssl) == 0)

{

tls_active = true;

# if PIPELINING

(void) sm_io_autoflush(InChannel, OutChannel);

# endif /* PIPELINING */

}

else

{

/*

nullserver = "454 4.3.3 TLS not available: can't switch to encrypted layer";

syserr("STARTTLS: can't switch to encrypted layer");

}

tls_done:

if (smtps)

{

if (tls_active)

goto greeting;

else

goto doquit;

}

break;

#endif /* STARTTLS */

case CMDHELO: /* hello -- introduce yourself */

case CMDEHLO: /* extended hello */

DELAY_CONN("EHLO");

if (c->cmd_code == CMDEHLO)

{

protocol = "ESMTP";

SmtpPhase = "server EHLO";

}

else

{

protocol = "SMTP";

SmtpPhase = "server HELO";

}

/* avoid denial-of-service */

STOP_IF_ATTACK(checksmtpattack(&n_helo, MAXHELOCOMMANDS,

true, "HELO/EHLO", e));

#if 0

/* RFC2821 4.1.4 allows duplicate HELO/EHLO */

/* check for duplicate HELO/EHLO per RFC 1651 4.2 */

if (gothello)

{

usrerr("503 %s Duplicate HELO/EHLO",

MyHostName);

break;

}

#endif /* 0 */

/* check for valid domain name (re 1123 5.2.5) */

if (*p == '\0' && !AllowBogusHELO)

{

usrerr("501 %s requires domain address",

cmdbuf);

break;

}

/* check for long domain name (hides Received: info) */

if (strlen(p) > MAXNAME)

{

usrerr("501 Invalid domain name");

if (LogLevel > 9)

sm_syslog(LOG_INFO, CurEnv->e_id,

"invalid domain name (too long) from %s",

CurSmtpClient);

break;

}

ok = true;

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

{

if (!isascii(*q))

break;

if (isalnum(*q))

continue;

if (isspace(*q))

{

*q = '\0';

/* only complain if strict check */

ok = AllowBogusHELO;

/* allow trailing whitespace */

while (!ok && *++q != '\0' &&

isspace(*q))

;

if (*q == '\0')

ok = true;

break;

}

if (strchr("[].-_#:", *q) == NULL)

break;

}

if (*q == '\0' && ok)

{

q = "pleased to meet you";

sendinghost = sm_strdup_x(p);

}

else if (!AllowBogusHELO)

{

usrerr("501 Invalid domain name");

if (LogLevel > 9)

sm_syslog(LOG_INFO, CurEnv->e_id,

"invalid domain name (%s) from %.100s",

p, CurSmtpClient);

break;

}

else

{

q = "accepting invalid domain name";

}

if (gothello)

{

CLEAR_STATE(cmdbuf);

}

#if MILTER

if (smtp.sm_milterlist && smtp.sm_milterize &&

!bitset(EF_DISCARD, e->e_flags))

{

char state;

char *response;

response = milter_helo(p, e, &state);

switch (state)

{

case SMFIR_REPLYCODE:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: helo=%s, reject=%s",

p, response);

nullserver = newstr(response);

smtp.sm_milterize = false;

break;

case SMFIR_REJECT:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: helo=%s, reject=Command rejected",

p);

nullserver = "Command rejected";

smtp.sm_milterize = false;

break;

case SMFIR_TEMPFAIL:

if (MilterLogLevel > 3)

sm_syslog(LOG_INFO, e->e_id,

"Milter: helo=%s, reject=%s",

p, MSG_TEMPFAIL);

tempfail = true;

smtp.sm_milterize = false;

break;

}

if (response != NULL)

sm_free(response);

/*

if (smtp.sm_quarmsg == NULL &&

e->e_quarmsg != NULL)

smtp.sm_quarmsg = newstr(e->e_quarmsg);

}

#endif /* MILTER */

gothello = true;

/* print HELO response message */

if (c->cmd_code != CMDEHLO)

{

message("250 %s Hello %s, %s",

MyHostName, CurSmtpClient, q);

break;

}

message("250-%s Hello %s, %s",

MyHostName, CurSmtpClient, q);

/* offer ENHSC even for nullserver */

if (nullserver != NULL)

{

message("250 ENHANCEDSTATUSCODES");

break;

}

/*

message("250-ENHANCEDSTATUSCODES");

#if PIPELINING

if (bitset(SRV_OFFER_PIPE, features))

message("250-PIPELINING");

#endif /* PIPELINING */

if (bitset(SRV_OFFER_EXPN, features))

{

message("250-EXPN");

if (bitset(SRV_OFFER_VERB, features))

message("250-VERB");

}

#if MIME8TO7

message("250-8BITMIME");

#endif /* MIME8TO7 */

if (MaxMessageSize > 0)

message("250-SIZE %ld", MaxMessageSize);

else

message("250-SIZE");

#if DSN

if (SendMIMEErrors && bitset(SRV_OFFER_DSN, features))

message("250-DSN");

#endif /* DSN */

if (bitset(SRV_OFFER_ETRN, features))

message("250-ETRN");

#if SASL

if (sasl_ok && mechlist != NULL && *mechlist != '\0')

message("250-AUTH %s", mechlist);

#endif /* SASL */

#if STARTTLS

if (tls_ok_srv &&

bitset(SRV_OFFER_TLS, features))

message("250-STARTTLS");

#endif /* STARTTLS */

if (DeliverByMin > 0)

message("250-DELIVERBY %ld",

(long) DeliverByMin);

else if (DeliverByMin == 0)

message("250-DELIVERBY");

/* < 0: no deliver-by */

message("250 HELP");

break;

case CMDMAIL: /* mail -- designate sender */

SmtpPhase = "server MAIL";

DELAY_CONN("MAIL");

/* check for validity of this command */

if (!gothello && bitset(PRIV_NEEDMAILHELO, PrivacyFlags))

{

usrerr("503 5.0.0 Polite people say HELO first");

break;

}

if (smtp.sm_gotmail)

{

usrerr("503 5.5.0 Sender already specified");

break;

}

#if SASL

if (bitset(SRV_REQ_AUTH, features) &&

authenticating != SASL_IS_AUTH)

{

usrerr("530 5.7.0 Authentication required");

break;

}

#endif /* SASL */

p = skipword(p, "from");

if (p == NULL)

break;

if (tempfail)

{

if (LogLevel > 9)

sm_syslog(LOG_INFO, e->e_id,

"SMTP MAIL command (%.100s) from %s tempfailed (due to previous checks)",

p, CurSmtpClient);

usrerr(MSG_TEMPFAIL);

break;

}

/* make sure we know who the sending host is */

if (sendinghost == NULL)

sendinghost = peerhostname;

#if SM_HEAP_CHECK

if (sm_debug_active(&DebugLeakSmtp, 1))

{

sm_heap_newgroup();

sm_dprintf("smtp() heap group #%d\n",

sm_heap_group());

}

#endif /* SM_HEAP_CHECK */

if (Errors > 0)

goto undo_no_pm;

if (!gothello)

{

auth_warning(e, "%s didn't use HELO protocol",

CurSmtpClient);

}

#ifdef PICKY_HELO_CHECK

if (sm_strcasecmp(sendinghost, peerhostname) != 0 &&

(sm_strcasecmp(peerhostname, "localhost") != 0 ||

sm_strcasecmp(sendinghost, MyHostName) != 0))

{

auth_warning(e, "Host %s claimed to be %s",

CurSmtpClient, sendinghost);

}

#endif /* PICKY_HELO_CHECK */

if (protocol == NULL)

protocol = "SMTP";

macdefine(&e->e_macro, A_PERM, 'r', protocol);

macdefine(&e->e_macro, A_PERM, 's', sendinghost);

if (Errors > 0)

goto undo_no_pm;

smtp.sm_nrcpts = 0;

n_badrcpts = 0;

macdefine(&e->e_macro, A_PERM, macid("{ntries}"), "0");

macdefine(&e->e_macro, A_PERM, macid("{nrcpts}"), "0");

macdefine(&e->e_macro, A_PERM, macid("{nbadrcpts}"),

"0");

e->e_flags |= EF_CLRQUEUE;

sm_setproctitle(true, e, "%s %s: %.80s",

qid_printname(e),

CurSmtpClient, inp);

/* do the processing */

SM_TRY

{

extern char *FullName;

QuickAbort = true;

SM_FREE_CLR(FullName);

/* must parse sender first */

delimptr = NULL;

setsender(p, e, &delimptr, ' ', false);

if (delimptr != NULL && *delimptr != '\0')

*delimptr++ = '\0';

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

/* Successfully set e_from, allow logging */

e->e_flags |= EF_LOGSENDER;

/* put resulting triple from parseaddr() into macros */

if (e->e_from.q_mailer != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{mail_mailer}"),

e->e_from.q_mailer->m_name);

else

macdefine(&e->e_macro, A_PERM,

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

if (e->e_from.q_host != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{mail_host}"),

e->e_from.q_host);

else

macdefine(&e->e_macro, A_PERM,

macid("{mail_host}"), "localhost");

if (e->e_from.q_user != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{mail_addr}"),

e->e_from.q_user);

else

macdefine(&e->e_macro, A_PERM,

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

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

/* check for possible spoofing */

if (RealUid != 0 && OpMode == MD_SMTP &&

!wordinclass(RealUserName, 't') &&

(!bitnset(M_LOCALMAILER,

e->e_from.q_mailer->m_flags) ||

strcmp(e->e_from.q_user, RealUserName) != 0))

{

auth_warning(e, "%s owned process doing -bs",

RealUserName);

}

/* reset to default value */

SevenBitInput = save_sevenbitinput;

/* now parse ESMTP arguments */

e->e_msgsize = 0;

addr = p;

argno = 0;

args[argno++] = p;

p = delimptr;

while (p != NULL && *p != '\0')

{

char *kp;

char *vp = NULL;

char *equal = NULL;

/* locate the beginning of the keyword */

SKIP_SPACE(p);

if (*p == '\0')

break;

kp = p;

/* skip to the value portion */

while ((isascii(*p) && isalnum(*p)) || *p == '-')

p++;

if (*p == '=')

{

equal = p;

*p++ = '\0';

vp = p;

/* skip to the end of the value */

while (*p != '\0' && *p != ' ' &&

!(isascii(*p) && iscntrl(*p)) &&

*p != '=')

p++;

}

if (*p != '\0')

*p++ = '\0';

if (tTd(19, 1))

sm_dprintf("MAIL: got arg %s=\"%s\"\n", kp,

vp == NULL ? "<null>" : vp);

mail_esmtp_args(kp, vp, e);

if (equal != NULL)

*equal = '=';

args[argno++] = kp;

if (argno >= MAXSMTPARGS - 1)

usrerr("501 5.5.4 Too many parameters");

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

}

args[argno] = NULL;

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

#if SASL

# if _FFR_AUTH_PASSING

/* set the default AUTH= if the sender didn't */

if (e->e_auth_param == NULL)

{

/* XXX only do this for an MSA? */

e->e_auth_param = macvalue(macid("{auth_authen}"),

e);

if (e->e_auth_param == NULL)

e->e_auth_param = "<>";

/*

}

# endif /* _FFR_AUTH_PASSING */

#endif /* SASL */

/* do config file checking of the sender */

macdefine(&e->e_macro, A_PERM,

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

#if _FFR_MAIL_MACRO

/* make the "real" sender address available */

macdefine(&e->e_macro, A_TEMP, macid("{mail_from}"),

e->e_from.q_paddr);

#endif /* _FFR_MAIL_MACRO */

if (rscheck("check_mail", addr,

NULL, e, RSF_RMCOMM|RSF_COUNT, 3,

NULL, e->e_id) != EX_OK ||

Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

macdefine(&e->e_macro, A_PERM,

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

if (MaxMessageSize > 0 &&

(e->e_msgsize > MaxMessageSize ||

e->e_msgsize < 0))

{

usrerr("552 5.2.3 Message size exceeds fixed maximum message size (%ld)",

MaxMessageSize);

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

}

/*

if ((NumFileSys == 1 || NumQueue == 1) &&

!enoughdiskspace(e->e_msgsize, e)

#if _FFR_ANY_FREE_FS

&& !filesys_free(e->e_msgsize)

#endif /* _FFR_ANY_FREE_FS */

)

{

/*

usrerr("452 4.4.5 Insufficient disk space; try again later");

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

}

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

LogUsrErrs = true;

#if MILTER

if (smtp.sm_milterlist && smtp.sm_milterize &&

!bitset(EF_DISCARD, e->e_flags))

{

char state;

char *response;

response = milter_envfrom(args, e, &state);

MILTER_REPLY("from");

}

#endif /* MILTER */

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

message("250 2.1.0 Sender ok");

smtp.sm_gotmail = true;

}

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

{

/*

sm_exc_free(exc);

goto undo_no_pm;

}

SM_END_TRY

break;

undo_no_pm:

e->e_flags &= ~EF_PM_NOTIFY;

undo:

break;

case CMDRCPT: /* rcpt -- designate recipient */

DELAY_CONN("RCPT");

if (BadRcptThrottle > 0 &&

n_badrcpts >= BadRcptThrottle)

{

if (LogLevel > 5 &&

n_badrcpts == BadRcptThrottle)

{

sm_syslog(LOG_INFO, e->e_id,

"%s: Possible SMTP RCPT flood, throttling.",

CurSmtpClient);

/* To avoid duplicated message */

n_badrcpts++;

}

NBADRCPTS;

/*

(void) sleep(1);

}

if (!smtp.sm_gotmail)

{

usrerr("503 5.0.0 Need MAIL before RCPT");

break;

}

SmtpPhase = "server RCPT";

SM_TRY

{

QuickAbort = true;

LogUsrErrs = true;

/* limit flooding of our machine */

if (MaxRcptPerMsg > 0 &&

smtp.sm_nrcpts >= MaxRcptPerMsg)

{

/* sleep(1); / * slow down? */

usrerr("452 4.5.3 Too many recipients");

goto rcpt_done;

}

if (e->e_sendmode != SM_DELIVER)

e->e_flags |= EF_VRFYONLY;

#if MILTER

/*

if (milter_can_delrcpts())

e->e_flags |= EF_VRFYONLY;

#endif /* MILTER */

p = skipword(p, "to");

if (p == NULL)

goto rcpt_done;

macdefine(&e->e_macro, A_PERM,

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

a = parseaddr(p, NULLADDR, RF_COPYALL, ' ', &delimptr,

e, true);

macdefine(&e->e_macro, A_PERM,

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

if (Errors > 0)

goto rcpt_done;

if (a == NULL)

{

usrerr("501 5.0.0 Missing recipient");

goto rcpt_done;

}

if (delimptr != NULL && *delimptr != '\0')

*delimptr++ = '\0';

/* put resulting triple from parseaddr() into macros */

if (a->q_mailer != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{rcpt_mailer}"),

a->q_mailer->m_name);

else

macdefine(&e->e_macro, A_PERM,

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

if (a->q_host != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{rcpt_host}"), a->q_host);

else

macdefine(&e->e_macro, A_PERM,

macid("{rcpt_host}"), "localhost");

if (a->q_user != NULL)

macdefine(&e->e_macro, A_PERM,

macid("{rcpt_addr}"), a->q_user);

else

macdefine(&e->e_macro, A_PERM,

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

if (Errors > 0)

goto rcpt_done;

/* now parse ESMTP arguments */

addr = p;

argno = 0;

args[argno++] = p;

p = delimptr;

while (p != NULL && *p != '\0')

{

char *kp;

char *vp = NULL;

char *equal = NULL;

/* locate the beginning of the keyword */

SKIP_SPACE(p);

if (*p == '\0')

break;

kp = p;

/* skip to the value portion */

while ((isascii(*p) && isalnum(*p)) || *p == '-')

p++;

if (*p == '=')

{

equal = p;

*p++ = '\0';

vp = p;

/* skip to the end of the value */

while (*p != '\0' && *p != ' ' &&

!(isascii(*p) && iscntrl(*p)) &&

*p != '=')

p++;

}

if (*p != '\0')

*p++ = '\0';

if (tTd(19, 1))

sm_dprintf("RCPT: got arg %s=\"%s\"\n", kp,

vp == NULL ? "<null>" : vp);

rcpt_esmtp_args(a, kp, vp, e);

if (equal != NULL)

*equal = '=';

args[argno++] = kp;

if (argno >= MAXSMTPARGS - 1)

usrerr("501 5.5.4 Too many parameters");

if (Errors > 0)

break;

}

args[argno] = NULL;

if (Errors > 0)

goto rcpt_done;

/* do config file checking of the recipient */

macdefine(&e->e_macro, A_PERM,

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

if (rscheck("check_rcpt", addr,

NULL, e, RSF_RMCOMM|RSF_COUNT, 3,

NULL, e->e_id) != EX_OK ||

Errors > 0)

goto rcpt_done;

macdefine(&e->e_macro, A_PERM,

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

/* If discarding, don't bother to verify user */

if (bitset(EF_DISCARD, e->e_flags))

a->q_state = QS_VERIFIED;

#if MILTER

if (smtp.sm_milterlist && smtp.sm_milterize &&

!bitset(EF_DISCARD, e->e_flags))

{

char state;

char *response;

response = milter_envrcpt(args, e, &state);

MILTER_REPLY("to");

}

#endif /* MILTER */

macdefine(&e->e_macro, A_PERM,

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

macdefine(&e->e_macro, A_PERM,

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

macdefine(&e->e_macro, A_PERM,

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

macdefine(&e->e_macro, A_PERM,

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

if (Errors > 0)

goto rcpt_done;

/* save in recipient list after ESMTP mods */

a = recipient(a, &e->e_sendqueue, 0, e);

if (Errors > 0)

goto rcpt_done;

/* no errors during parsing, but might be a duplicate */

e->e_to = a->q_paddr;

if (!QS_IS_BADADDR(a->q_state))

{

if (smtp.sm_nrcpts == 0)

initsys(e);

message("250 2.1.5 Recipient ok%s",

QS_IS_QUEUEUP(a->q_state) ?

" (will queue)" : "");

smtp.sm_nrcpts++;

}

else

{

/* punt -- should keep message in ADDRESS.... */

usrerr("550 5.1.1 Addressee unknown");

}

rcpt_done:

if (Errors > 0)

{

++n_badrcpts;

NBADRCPTS;

}

}

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

{

/* An exception occurred while processing RCPT */

e->e_flags &= ~(EF_FATALERRS|EF_PM_NOTIFY);

++n_badrcpts;

NBADRCPTS;

}

SM_END_TRY

break;

case CMDDATA: /* data -- text of mail */

DELAY_CONN("DATA");

if (!smtp_data(&smtp, e))

goto doquit;

break;

case CMDRSET: /* rset -- reset state */

if (tTd(94, 100))

message("451 4.0.0 Test failure");

else

message("250 2.0.0 Reset state");

CLEAR_STATE(cmdbuf);

break;

case CMDVRFY: /* vrfy -- verify address */

case CMDEXPN: /* expn -- expand address */

vrfy = c->cmd_code == CMDVRFY;

DELAY_CONN(vrfy ? "VRFY" : "EXPN");

if (tempfail)

{

if (LogLevel > 9)

sm_syslog(LOG_INFO, e->e_id,

"SMTP %s command (%.100s) from %s tempfailed (due to previous checks)",

vrfy ? "VRFY" : "EXPN",

p, CurSmtpClient);

/* RFC 821 doesn't allow 4xy reply code */

usrerr("550 5.7.1 Please try again later");

break;

}

wt = checksmtpattack(&n_verifies, MAXVRFYCOMMANDS,

false, vrfy ? "VRFY" : "EXPN", e);

STOP_IF_ATTACK(wt);

previous = curtime();

if ((vrfy && bitset(PRIV_NOVRFY, PrivacyFlags)) ||

(!vrfy && !bitset(SRV_OFFER_EXPN, features)))

{

if (vrfy)

message("252 2.5.2 Cannot VRFY user; try RCPT to attempt delivery (or try finger)");

else

message("502 5.7.0 Sorry, we do not allow this operation");

if (LogLevel > 5)

sm_syslog(LOG_INFO, e->e_id,

"%s: %s [rejected]",

CurSmtpClient,

shortenstring(inp, MAXSHORTSTR));

break;

}

else if (!gothello &&

bitset(vrfy ? PRIV_NEEDVRFYHELO : PRIV_NEEDEXPNHELO,

PrivacyFlags))

{

usrerr("503 5.0.0 I demand that you introduce yourself first");

break;

}

if (Errors > 0)

break;

if (LogLevel > 5)

sm_syslog(LOG_INFO, e->e_id, "%s: %s",

CurSmtpClient,

shortenstring(inp, MAXSHORTSTR));

SM_TRY

{

QuickAbort = true;

vrfyqueue = NULL;

if (vrfy)

e->e_flags |= EF_VRFYONLY;

while (*p != '\0' && isascii(*p) && isspace(*p))

p++;

if (*p == '\0')

{

usrerr("501 5.5.2 Argument required");

}

else

{

/* do config file checking of the address */

if (rscheck(vrfy ? "check_vrfy" : "check_expn",

p, NULL, e, RSF_RMCOMM,

3, NULL, NOQID) != EX_OK ||

Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

(void) sendtolist(p, NULLADDR, &vrfyqueue, 0, e);

}

if (wt > 0)

{

time_t t;

t = wt - (curtime() - previous);

if (t > 0)

(void) sleep(t);

}

if (Errors > 0)

sm_exc_raisenew_x(&EtypeQuickAbort, 1);

if (vrfyqueue == NULL)

{

usrerr("554 5.5.2 Nothing to %s", vrfy ? "VRFY" : "EXPN");

}

while (vrfyqueue != NULL)

{

if (!QS_IS_UNDELIVERED(vrfyqueue->q_state))

{

vrfyqueue = vrfyqueue->q_next;

continue;

}

/* see if there is more in the vrfy list */

a = vrfyqueue;

while ((a = a->q_next) != NULL &&

(!QS_IS_UNDELIVERED(a->q_state)))

continue;

printvrfyaddr(vrfyqueue, a == NULL, vrfy);

vrfyqueue = a;

}

}

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

{

/*

sm_exc_free(exc);

goto undo;

}

SM_END_TRY

break;

case CMDETRN: /* etrn -- force queue flush */

DELAY_CONN("ETRN");

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

if (!bitset(SRV_OFFER_ETRN, features) || UseMSP ||

(RealUid != 0 && RealUid != TrustedUid &&

OpMode == MD_SMTP))

{

/* different message for MSA ? */

message("502 5.7.0 Sorry, we do not allow this operation");

if (LogLevel > 5)

sm_syslog(LOG_INFO, e->e_id,

"%s: %s [rejected]",

CurSmtpClient,

shortenstring(inp, MAXSHORTSTR));

break;

}

if (tempfail)

{

if (LogLevel > 9)

sm_syslog(LOG_INFO, e->e_id,

"SMTP ETRN command (%.100s) from %s tempfailed (due to previous checks)",

p, CurSmtpClient);

usrerr(MSG_TEMPFAIL);

break;

}

if (strlen(p) <= 0)

{

usrerr("500 5.5.2 Parameter required");

break;

}

/* crude way to avoid denial-of-service attacks */

STOP_IF_ATTACK(checksmtpattack(&n_etrn, MAXETRNCOMMANDS,

true, "ETRN", e));

/*

if (rscheck("check_etrn", p, NULL, e,

RSF_RMCOMM, 3, NULL, NOQID) != EX_OK ||

Errors > 0)

break;

if (LogLevel > 5)

sm_syslog(LOG_INFO, e->e_id,

"%s: ETRN %s", CurSmtpClient,

shortenstring(p, MAXSHORTSTR));

id = p;

if (*id == '#')

{

int i, qgrp;

id++;

qgrp = name2qid(id);

if (!ISVALIDQGRP(qgrp))

{

usrerr("459 4.5.4 Queue %s unknown",