/*++
/* NAME
/*	smtp-sink 8
/* SUMMARY
/*	multi-threaded SMTP/LMTP test server
/* SYNOPSIS
/*	smtp-sink [-cLpv] [-w delay] [host]:port backlog
/* DESCRIPTION
/*	\\\\fIsmtp-sink\\\\fR listens on the named host (or address) and port.
/*	It takes SMTP messages from the network and throws them away.
/*	The purpose is to measure SMTP client performance, not protocol
/*	compliance.
/*	This program is the complement of the \\\\fIsmtp-source\\\\fR program.
/* .IP -c
/*	Display a running counter that is updated whenever an SMTP
/*	QUIT command is executed.
/* .IP -L
/*	Speak LMTP rather than SMTP.
/* .IP -p
/*	Disable ESMTP command pipelining.
/* .IP -v
/*	Show the SMTP conversations.
/* .IP \\\"-w delay\\\"
/*	Wait \\\\fIdelay\\\\fR seconds before responding to a DATA command.
/* SEE ALSO
/*	smtp-source, SMTP/LMTP test message generator
/* LICENSE
/* .ad
/* .fi
/*	The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*	Wietse Venema
/*	IBM T.J. Watson Research
/*	P.O. Box 704
/*	Yorktown Heights, NY 10598, USA
/*--*/

/* System library. */

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#ifdef STRCASECMP_IN_STRINGS_H
#include 
#endif

/* Utility library. */

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

/* Global library. */

#include 

/* Application-specific. */

typedef struct SINK_STATE {
    VSTREAM *stream;
    int     data_state;
    int     (*read) (struct SINK_STATE *);
    int     rcpts;
} SINK_STATE;

#define ST_ANY			0
#define ST_CR			1
#define ST_CR_LF		2
#define ST_CR_LF_DOT		3
#define ST_CR_LF_DOT_CR		4
#define ST_CR_LF_DOT_CR_LF	5

static int var_tmout;
static int var_max_line_length;
static char *var_myhostname;
static VSTRING *buffer;
static int command_read(SINK_STATE *);
static int data_read(SINK_STATE *);
static void disconnect(SINK_STATE *);
static int count;
static int counter;
static int disable_pipelining;
static int fixed_delay;
static int enable_lmtp;

/* ehlo_response - respond to EHLO command */

static void ehlo_response(SINK_STATE *state)
{
    smtp_printf(state->stream, \\\"250-%s\\\", var_myhostname);
    if (!disable_pipelining)
	smtp_printf(state->stream, \\\"250-PIPELINING\\\");
    smtp_printf(state->stream, \\\"250 8BITMIME\\\");
}

/* ok_response - send 250 OK */

static void ok_response(SINK_STATE *state)
{
    smtp_printf(state->stream, \\\"250 Ok\\\");
}

/* mail_response - reset recipient count, send 250 OK */

static void mail_response(SINK_STATE *state)
{
    state->rcpts = 0;
    ok_response(state);
}

/* rcpt_response - bump recipient count, send 250 OK */

static void rcpt_response(SINK_STATE *state)
{
    state->rcpts++;
    ok_response(state);
}

/* data_response - respond to DATA command */

static void data_response(SINK_STATE *state)
{
    state->data_state = ST_CR_LF;
    smtp_printf(state->stream, \\\"354 End data with .\\\");
    state->read = data_read;
}

/* data_event - delayed response to DATA command */

static void data_event(int unused_event, char *context)
{
    SINK_STATE *state = (SINK_STATE *) context;

    data_response(state);
}

/* dot_response - response to . command */

static void dot_response(SINK_STATE *state)
{
    if (enable_lmtp) {
	while (state->rcpts-- > 0)	/* XXX this could block */
	    ok_response(state);
    } else {
	ok_response(state);
    }
}

/* quit_response - respond to QUIT command */

static void quit_response(SINK_STATE *state)
{
    smtp_printf(state->stream, \\\"221 Bye\\\");
    if (count) {
	counter++;
	vstream_printf(\\\"%d\\\\r\\\", counter);
	vstream_fflush(VSTREAM_OUT);
    }
}

/* data_read - read data from socket */

static int data_read(SINK_STATE *state)
{
    int     ch;
    struct data_trans {
	int     state;
	int     want;
	int     next_state;
    };
    static struct data_trans data_trans[] = {
	ST_ANY, \\\'\\\\r\\\', ST_CR,
	ST_CR, \\\'\\\\n\\\', ST_CR_LF,
	ST_CR_LF, \\\'.\\\', ST_CR_LF_DOT,
	ST_CR_LF_DOT, \\\'\\\\r\\\', ST_CR_LF_DOT_CR,
	ST_CR_LF_DOT_CR, \\\'\\\\n\\\', ST_CR_LF_DOT_CR_LF,
    };
    struct data_trans *dp;

    /*
     * We must avoid blocking I/O, so get out of here as soon as both the
     * VSTREAM and kernel read buffers dry up.
     */
    while (vstream_peek(state->stream) > 0
	   || peekfd(vstream_fileno(state->stream)) > 0) {
	if ((ch = VSTREAM_GETC(state->stream)) == VSTREAM_EOF)
	    return (-1);
	for (dp = data_trans; dp->state != state->data_state; dp++)
	     /* void */ ;

	/*
	 * Try to match the current character desired by the state machine.
	 * If that fails, try to restart the machine with a match for its
	 * first state.  This covers the case of a CR/LF/CR/LF sequence
	 * (empty line) right before the end of the message data.
	 */
	if (ch == dp->want)
	    state->data_state = dp->next_state;
	else if (ch == data_trans[0].want)
	    state->data_state = data_trans[0].next_state;
	else
	    state->data_state = ST_ANY;
	if (state->data_state == ST_CR_LF_DOT_CR_LF) {
	    if (msg_verbose)
		msg_info(\\\".\\\");
	    dot_response(state);
	    state->read = command_read;
	    break;
	}
    }
    return (0);
}

 /*
  * The table of all SMTP commands that we can handle.
  */
typedef struct SINK_COMMAND {
    char   *name;
    void    (*response) (SINK_STATE *);
} SINK_COMMAND;

static SINK_COMMAND command_table[] = {
    \\\"helo\\\", ok_response,
    \\\"ehlo\\\", ehlo_response,
    \\\"lhlo\\\", ehlo_response,
    \\\"mail\\\", mail_response,
    \\\"rcpt\\\", rcpt_response,
    \\\"data\\\", data_response,
    \\\"rset\\\", ok_response,
    \\\"noop\\\", ok_response,
    \\\"vrfy\\\", ok_response,
    \\\"quit\\\", quit_response,
    0,
};

/* command_read - talk the SMTP protocol, server side */

static int command_read(SINK_STATE *state)
{
    char   *command;
    SINK_COMMAND *cmdp;

    smtp_get(buffer, state->stream, var_max_line_length);
    if ((command = strtok(vstring_str(buffer), \\\" \\\\t\\\")) == 0) {
	smtp_printf(state->stream, \\\"500 Error: unknown command\\\");
	return (0);
    }
    if (msg_verbose)
	msg_info(\\\"%s\\\", command);
    for (cmdp = command_table; cmdp->name != 0; cmdp++)
	if (strcasecmp(command, cmdp->name) == 0)
	    break;
    if (cmdp->name == 0) {
	smtp_printf(state->stream, \\\"500 Error: unknown command\\\");
	return (0);
    }
    if (cmdp->response == data_response && fixed_delay > 0) {
	event_request_timer(data_event, (char *) state, fixed_delay);
    } else {
	cmdp->response(state);
	if (cmdp->response == quit_response)
	    return (-1);
    }
    return (0);
}

/* read_event - handle command or data read events */

static void read_event(int unused_event, char *context)
{
    SINK_STATE *state = (SINK_STATE *) context;

    do {
	switch (vstream_setjmp(state->stream)) {

	default:
	    msg_panic(\\\"unknown error reading input\\\");

	case SMTP_ERR_TIME:
	    msg_panic(\\\"attempt to read non-readable socket\\\");
	    /* NOTREACHED */

	case SMTP_ERR_EOF:
	    msg_warn(\\\"lost connection\\\");
	    disconnect(state);
	    return;

	case 0:
	    if (state->read(state) < 0) {
		if (msg_verbose)
		    msg_info(\\\"disconnect\\\");
		disconnect(state);
		return;
	    }
	}
    } while (vstream_peek(state->stream) > 0);
}

/* disconnect - handle disconnection events */

static void disconnect(SINK_STATE *state)
{
    event_disable_readwrite(vstream_fileno(state->stream));
    vstream_fclose(state->stream);
    myfree((char *) state);
}

/* connect_event - handle connection events */

static void connect_event(int unused_event, char *context)
{
    int     sock = (int) context;
    SINK_STATE *state;
    int     fd;

    if ((fd = accept(sock, (struct sockaddr *) 0, (SOCKADDR_SIZE *) 0)) >= 0) {
	if (msg_verbose)
	    msg_info(\\\"connect\\\");
	non_blocking(fd, NON_BLOCKING);
	state = (SINK_STATE *) mymalloc(sizeof(*state));
	state->stream = vstream_fdopen(fd, O_RDWR);
	state->read = command_read;
	state->data_state = 0;
	smtp_timeout_setup(state->stream, var_tmout);
	smtp_printf(state->stream, \\\"220 %s ESMTP\\\", var_myhostname);
	event_enable_read(fd, read_event, (char *) state);
    }
}

/* usage - explain */

static void usage(char *myname)
{
    msg_fatal(\\\"usage: %s [-cLpv] [host]:port backlog\\\", myname);
}

int     main(int argc, char **argv)
{
    int     sock;
    int     backlog;
    int     ch;

    /*
     * Initialize diagnostics.
     */
    msg_vstream_init(argv[0], VSTREAM_ERR);

    /*
     * Parse JCL.
     */
    while ((ch = GETOPT(argc, argv, \\\"cLpvw:\\\")) > 0) {
	switch (ch) {
	case \\\'c\\\':
	    count++;
	    break;
	case \\\'L\\\':
	    enable_lmtp = 1;
	    break;
	case \\\'p\\\':
	    disable_pipelining = 1;
	    break;
	case \\\'v\\\':
	    msg_verbose++;
	    break;
	case \\\'w\\\':
	    if ((fixed_delay = atoi(optarg)) <= 0)
		usage(argv[0]);
	    break;
	default:
	    usage(argv[0]);
	}
    }
    if (argc - optind != 2)
	usage(argv[0]);
    if ((backlog = atoi(argv[optind + 1])) <= 0)
	usage(argv[0]);

    /*
     * Initialize.
     */
    buffer = vstring_alloc(1024);
    var_myhostname = \\\"smtp-sink\\\";
    sock = inet_listen(argv[optind], backlog, BLOCKING);

    /*
     * Start the event handler.
     */
    event_enable_read(sock, connect_event, (char *) sock);
    for (;;)
	event_loop(-1);
}