/*

 * Copyright (c) 2014 Sunil Nimmagadda <sunil@nimmagadda.net>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <ctype.h>

#include <err.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <syslog.h>

#include <unistd.h>

#include "imsgev.h"

#include "pop3d.h"

#include "ssl.h"

#define MAXLINESIZE	2048

#define TIMEOUT		600000

enum pop_command {

	CMD_STLS = 0,

	CMD_CAPA,

	CMD_USER,

	CMD_PASS,

	CMD_QUIT,

	CMD_STAT,

	CMD_RETR,

	CMD_LIST,

	CMD_DELE,

	CMD_RSET,

	CMD_TOP,

	CMD_UIDL,

	CMD_NOOP

};

enum arg_constraint {

	OPTIONAL = 1,

	PROHIBITED,

	REQUIRED

};

static struct {int code; enum arg_constraint c; const char *cmd;} commands[] = {

	{CMD_STLS, PROHIBITED, "STLS"},

	{CMD_CAPA, PROHIBITED, "CAPA"},

	{CMD_USER, REQUIRED, "USER"},

	{CMD_PASS, REQUIRED, "PASS"},

	{CMD_QUIT, PROHIBITED, "QUIT"},

	{CMD_STAT, PROHIBITED, "STAT"},

	{CMD_RETR, REQUIRED, "RETR"},

	{CMD_LIST, OPTIONAL, "LIST"},

	{CMD_DELE, REQUIRED, "DELE"},

	{CMD_RSET, PROHIBITED, "RSET"},

	{CMD_TOP,  REQUIRED, "TOP"},

	{CMD_UIDL, OPTIONAL, "UIDL"},

	{CMD_NOOP, PROHIBITED, "NOOP"},

	{-1, OPTIONAL, NULL}

};

static void auth_request(struct session *);

static void capa(struct session *);

static void command(struct session *, int, char *);

static void session_io(struct io *, int);

static void parse(struct session *, char *);

static void auth_command(struct session *, int, char *);

static void trans_command(struct session *, int, char *);

static void get_list_all(struct session *, int);

static void get_list(struct session *, unsigned int, int);

static void maildrop_imsgev(struct imsgev *, int, struct imsg *);

static void handle_init(struct session *, struct imsg *);

static void handle_retr(struct session *, struct imsg *);

static void handle_dele(struct session *, struct imsg *);

static void handle_list(struct session *, struct imsg *);

static void handle_list_all(struct session *, struct imsg *);

static void handle_update(struct session *, struct imsg *);

static void needfd(struct imsgev *);

static void pop3_debug(char *, ...);

static void session_write(struct session *, const char *, size_t);

static const char *strstate(enum state);

struct session_tree	sessions;

static int		_pop3_debug = 1;

void

session_init(struct listener *l, int fd)

{

	struct session	*s;

	void		*ssl;

	extern void	*ssl_ctx;

	s = xcalloc(1, sizeof(*s), "session_init");

	s->l = l;

	if (iobuf_init(&s->iobuf, 0, 0) == -1)

		fatal("iobuf_init");

	io_init(&s->io, fd, s, session_io, &s->iobuf);

	io_set_timeout(&s->io, TIMEOUT);

	s->id = arc4random();

	s->state = AUTH;

	if (s->l->flags & POP3S) {

		s->flags |= POP3S;

		ssl = pop3s_init(ssl_ctx, fd);

		io_set_read(&s->io);

		io_start_tls(&s->io, ssl);

		return;

	}

	log_connect(s->id, &l->ss, l->ss.ss_len);

	SPLAY_INSERT(session_tree, &sessions, s);

	session_reply(s, "%s", "+OK pop3d ready");

	io_set_write(&s->io);

}

void

session_close(struct session *s, int flush)

{

	struct session *entry;

	entry = SPLAY_REMOVE(session_tree, &sessions,  s);

	if (entry == NULL) {

		 /* STARTTLS session was in progress and got interrupted */

		logit(LOG_DEBUG, "%u: not in tree", s->id);

		entry = s;

	}

	if (flush) {

		if (entry->flags & POP3S)

			iobuf_flush_ssl(&entry->iobuf, entry->io.ssl);

		else

			iobuf_flush(&entry->iobuf, entry->io.sock);

	}

	iobuf_clear(&entry->iobuf);

	io_clear(&entry->io);

	imsgev_clear(&entry->iev_maildrop);

	logit(LOG_INFO, "%u: session closed", entry->id);

	free(entry);

}

static void

session_io(struct io *io, int evt)

{

	struct session	*s = io->arg;

	char		*line;

	size_t		len;

	pop3_debug("%u: %s", s->id, io_strevent(evt));

	switch (evt) {

	case IO_DATAIN:

		line = iobuf_getline(&s->iobuf, &len);

		if (line == NULL) {

			iobuf_normalize(&s->iobuf);

			break;

		}

		if (strncasecmp(line, "PASS", 4) == 0)

			pop3_debug(">>> PASS");

		else

			pop3_debug(">>> %s", line);

		parse(s, line);

		break;

	case IO_LOWAT:

		if (iobuf_queued(&s->iobuf) == 0)

			io_set_read(io);

		break;

	case IO_TLSREADY:

		/* greet only for pop3s, STLS already greeted */

		if (s->flags & POP3S) {

			log_connect(s->id, &s->l->ss, s->l->ss.ss_len);

			session_reply(s, "%s", "+OK pop3 ready");

			io_set_write(&s->io);

		}

		SPLAY_INSERT(session_tree, &sessions, s);

		/* mark STLS session as secure */

		s->flags |= POP3S;

		logit(LOG_INFO, "%u: TLS ready", s->id);

		break;

	case IO_DISCONNECTED:

	case IO_TIMEOUT:

	case IO_ERROR:

		session_close(s, 0);

		break;

	default:

		logit(LOG_DEBUG, "unknown event %s", io_strevent(evt));

		break;

	}

}

static void

parse(struct session *s, char *line)

{

	enum arg_constraint	c = OPTIONAL;

	int			i, cmd = -1;

	char			*args;

	/* trim newline */

	line[strcspn(line, "\n")] = '\0';

	args = strchr(line, ' ');

	if (args) {

		*args++ = '\0';

		while (isspace((unsigned char)*args))

			args++;

	}

	for (i = 0; commands[i].code != -1; i++) {

		if (strcasecmp(line, commands[i].cmd) == 0) {

			cmd = commands[i].code;

			c = commands[i].c;

			break;

		}

	}

	if (cmd == -1) {

		logit(LOG_INFO, "%u: invalid command %s", s->id, line);

		session_reply(s, "%s", "-ERR invalid command");

		io_set_write(&s->io);

		return;

	}

	if (c == PROHIBITED && args) {

		session_reply(s, "%s", "-ERR no arguments allowed");

		io_set_write(&s->io);

		return;

	} else if ((c == REQUIRED) &&

	    (args == NULL || strlen(args) >= ARGLEN)) {

		session_reply(s, "%s", "-ERR args required or too long");

		io_set_write(&s->io);

		return;

	}

	command(s, cmd, args);

}

static void

command(struct session *s, int cmd, char *args)

{

	switch (s->state) {

	case AUTH:

		auth_command(s, cmd, args);

		break;

	case TRANSACTION:

		trans_command(s, cmd, args);

		break;

	case UPDATE:

		session_reply(s, "%s", "-ERR commands not allowed");

		io_set_write(&s->io);

		break;

	default:

		fatalx("Invalid state");

	}

}

static void

auth_command(struct session *s, int cmd, char *args)

{

	extern void	*ssl_ctx;

	void		*ssl;

	switch (cmd) {

	case CMD_STLS:

		if (s->flags & POP3S) {

			session_reply(s, "%s", "-ERR already secured");

			break;

		}

		session_reply(s, "%s", "+OK");

		io_set_write(&s->io);

		iobuf_flush(&s->iobuf, s->io.sock);

		/* add back when IO_TLSREADY. */

		SPLAY_REMOVE(session_tree, &sessions, s);

		ssl = pop3s_init(ssl_ctx, s->io.sock);

		io_set_read(&s->io);

		io_start_tls(&s->io, ssl);

		return;

	case CMD_CAPA:

		capa(s);

		break;

	case CMD_USER:

		(void)strlcpy(s->user, args, sizeof(s->user));

		session_reply(s, "%s", "+OK");

		break;

	case CMD_PASS:

		if (s->user[0] == '\0') {

			session_reply(s, "%s", "-ERR no USER specified");

			break;

		}

		(void)strlcpy(s->pass, args, sizeof(s->pass));

		auth_request(s);

		return;

	case CMD_QUIT:

		session_reply(s, "%s", "+OK");

		io_set_write(&s->io);

		session_close(s, 1);

		return;

	default:

		session_reply(s, "%s", "-ERR invalid command");

		break;

	}

	io_set_write(&s->io);

}

static void

auth_request(struct session *s)

{

	extern struct imsgev	iev_pop3d;

	struct auth_req		req;

	memset(&req, 0, sizeof(req));

	(void)strlcpy(req.user, s->user, sizeof(req.user));

	(void)strlcpy(req.pass, s->pass, sizeof(req.pass));

	imsgev_xcompose(&iev_pop3d, IMSG_AUTH, s->id, 0, -1,

	    &req, sizeof(req), "auth_request");

}

static void

capa(struct session *s)

{

	session_reply(s, "%s", "+OK");

	session_reply(s, "%s", "STLS");

	session_reply(s, "%s", "USER");

	session_reply(s, "%s", "TOP");

	session_reply(s, "%s", "UIDL");

	session_reply(s, "%s", "IMPLEMENTATION pop3d");

	session_reply(s, "%s", ".");

}

static void

trans_command(struct session *s, int cmd, char *args)

{

	struct retr_req	retr_req;

	unsigned int	idx, n;

	char		*c;

	const char	*errstr;

	int		uidl = 0;

	memset(&retr_req, 0, sizeof(retr_req));

	switch (cmd) {

	case CMD_CAPA:

		capa(s);

		break;

	case CMD_STAT:

		session_reply(s, "%s %zu %zu", "+OK", s->nmsgs, s->m_sz);