client.c

/* Copyright (c) 2009-2018 Dovecot authors, see the included COPYING file */

#include "lib.h"
#include "array.h"
#include "base64.h"
#include "str.h"
#include "llist.h"
#include "iostream.h"
#include "istream.h"
#include "ostream.h"
#include "hostpid.h"
#include "process-title.h"
#include "var-expand.h"
#include "settings-parser.h"
#include "smtp-server.h"
#include "master-service.h"
#include "master-service-ssl.h"
#include "master-service-settings.h"
#include "iostream-ssl.h"
#include "mail-namespace.h"
#include "mail-storage.h"
#include "mail-storage-service.h"
#include "raw-storage.h"
#include "main.h"
#include "lda-settings.h"
#include "lmtp-settings.h"
#include "lmtp-local.h"
#include "lmtp-proxy.h"
#include "commands.h"
#include "client.h"

#include <unistd.h>

#define CLIENT_IDLE_TIMEOUT_MSECS (1000*60*5)

static struct client *clients = NULL;
static unsigned int clients_count = 0;

static bool verbose_proctitle = FALSE;

static const struct smtp_server_callbacks lmtp_callbacks;

static const char *client_remote_id(struct client *client)
{
	const char *addr;

	addr = net_ip2addr(&client->remote_ip);
	if (addr[0] == '\0')
		addr = "local";
	return addr;
}

static void refresh_proctitle(void)
{
	struct client *client;
	string_t *title;

	if (!verbose_proctitle)
		return;

	title = t_str_new(128);
	str_append_c(title, '[');
	switch (clients_count) {
	case 0:
		str_append(title, "idling");
		break;
	case 1:
		client = clients;
		str_append(title, client_remote_id(client));
		str_append_c(title, ' ');
		str_append(title, client_state_get_name(client));
		break;
	default:
		str_printfa(title, "%u connections", clients_count);
		break;
	}
	str_append_c(title, ']');
	process_title_set(str_c(title));
}

static void client_raw_user_create(struct client *client)
{
	void **sets;

	sets = master_service_settings_get_others(master_service);
	client->raw_mail_user =
		raw_storage_create_from_set(client->user_set_info, sets[0]);
}

static void client_read_settings(struct client *client, bool ssl)
{
	struct mail_storage_service_input input;
	const struct setting_parser_context *set_parser;
	struct lmtp_settings *lmtp_set;
	struct lda_settings *lda_set;
	const char *error;

	i_zero(&input);
	input.module = input.service = "lmtp";
	input.local_ip = client->local_ip;
	input.remote_ip = client->remote_ip;
	input.local_port = client->local_port;
	input.remote_port = client->remote_port;
	input.conn_secured = ssl;
	input.conn_ssl_secured = ssl;
	input.username = "";

	if (mail_storage_service_read_settings(storage_service, &input,
					       client->pool,
					       &client->user_set_info,
					       &set_parser, &error) < 0)
		i_fatal("%s", error);

	lmtp_settings_dup(set_parser, client->pool, &lmtp_set, &lda_set);
	const struct var_expand_table *tab =
		mail_storage_service_get_var_expand_table(storage_service, &input);
	if (settings_var_expand(&lmtp_setting_parser_info, lmtp_set,
				client->pool, tab, &error) <= 0)
		i_fatal("Failed to expand settings: %s", error);
	client->service_set = master_service_settings_get(master_service);
	client->lmtp_set = lmtp_set;
	client->unexpanded_lda_set = lda_set;
}

struct client *client_create(int fd_in, int fd_out,
			     const struct master_service_connection *conn)
{
	struct smtp_server_settings lmtp_set;
	struct client *client;
	pool_t pool;

	pool = pool_alloconly_create("lmtp client", 2048);
	client = p_new(pool, struct client, 1);
	client->pool = pool;
	client->remote_ip = conn->remote_ip;
	client->remote_port = conn->remote_port;
	client->local_ip = conn->local_ip;
	client->local_port = conn->local_port;
	client->state_pool = pool_alloconly_create("client state", 4096);

	client_read_settings(client, conn->ssl);
	client_raw_user_create(client);
	client->my_domain = client->unexpanded_lda_set->hostname;

	if (client->service_set->verbose_proctitle)
		verbose_proctitle = TRUE;

	i_zero(&lmtp_set);
	lmtp_set.capabilities =
		SMTP_CAPABILITY_PIPELINING |
		SMTP_CAPABILITY_ENHANCEDSTATUSCODES |
		SMTP_CAPABILITY_8BITMIME |
		SMTP_CAPABILITY_CHUNKING |
		SMTP_CAPABILITY_XCLIENT |
		SMTP_CAPABILITY__ORCPT;
	if (!conn->ssl && master_service_ssl_is_enabled(master_service))
		lmtp_set.capabilities |= SMTP_CAPABILITY_STARTTLS;
	lmtp_set.hostname = client->unexpanded_lda_set->hostname;
	lmtp_set.rcpt_domain_optional = TRUE;
	lmtp_set.max_client_idle_time_msecs = CLIENT_IDLE_TIMEOUT_MSECS;
	lmtp_set.rawlog_dir = client->lmtp_set->lmtp_rawlog_dir;

	client->conn = smtp_server_connection_create
		(lmtp_server, fd_in, fd_out,
			&conn->remote_ip, conn->remote_port,
			conn->ssl, &lmtp_set, &lmtp_callbacks, client);

	DLLIST_PREPEND(&clients, client);
	clients_count++;

	smtp_server_connection_start(client->conn);
	i_info("Connect from %s", client_remote_id(client));
	refresh_proctitle();
	return client;
}

void client_state_reset(struct client *client)
{
	if (client->local != NULL)
		lmtp_local_deinit(&client->local);
	if (client->proxy != NULL)
		lmtp_proxy_deinit(&client->proxy);

	o_stream_unref(&client->state.mail_data_output);

	i_zero(&client->state);
	p_clear(client->state_pool);
}

void client_destroy(struct client *client, const char *enh_code,
		    const char *reason)
{
	if (client->destroyed)
		return;
	client->destroyed = TRUE;

	client_disconnect(client, enh_code, reason);

	clients_count--;
	DLLIST_REMOVE(&clients, client);

	if (client->raw_mail_user != NULL)
		mail_user_unref(&client->raw_mail_user);

	client_state_reset(client);
	pool_unref(&client->state_pool);
	pool_unref(&client->pool);

	master_service_client_connection_destroyed(master_service);
}

const char *client_state_get_name(struct client *client)
{
	enum smtp_server_state state;

	if (client->conn == NULL)
		state = client->last_state;
	else
		state = smtp_server_connection_get_state(client->conn);
	return smtp_server_state_names[state];
}

void client_disconnect(struct client *client, const char *enh_code,
		       const char *reason)
{
	struct smtp_server_connection *conn = client->conn;

	if (client->disconnected)
		return;
	client->disconnected = TRUE;

	if (reason == NULL)
		reason = "Connection closed";
	i_info("Disconnect from %s: %s (state = %s)", client_remote_id(client),
	       reason, client_state_get_name(client));

	if (conn != NULL) {
		client->last_state = smtp_server_connection_get_state(conn);
		smtp_server_connection_terminate(&conn,
			(enh_code == NULL ? "4.0.0" : enh_code), reason);
	}
}

static void
client_connection_trans_free(void *context,
			     struct smtp_server_transaction *trans ATTR_UNUSED)
{
	struct client *client = (struct client *)context;

	client_state_reset(client);
}

static void
client_connection_state_changed(void *context ATTR_UNUSED,
	enum smtp_server_state newstate ATTR_UNUSED)
{
	if (clients_count == 1)
		refresh_proctitle();
}

static void
client_connection_proxy_data_updated(void *context,
				     const struct smtp_proxy_data *data)
{
	struct client *client = (struct client *)context;

	client->remote_ip = data->source_ip;
	client->remote_port = data->source_port;

	if (clients_count == 1)
		refresh_proctitle();
}

static void client_connection_disconnect(void *context, const char *reason)
{
	struct client *client = (struct client *)context;
	struct smtp_server_connection *conn = client->conn;

	if (conn != NULL)
		client->last_state = smtp_server_connection_get_state(conn);
	client_disconnect(client, NULL, reason);
}

static void client_connection_destroy(void *context)
{
	struct client *client = (struct client *)context;

	client_destroy(client, NULL, NULL);
}

static bool client_connection_is_trusted(void *context)
{
	struct client *client = (struct client *)context;
	const char *const *net;
	struct ip_addr net_ip;
	unsigned int bits;

	if (client->lmtp_set->login_trusted_networks == NULL)
		return FALSE;

	net = t_strsplit_spaces(client->lmtp_set->login_trusted_networks, ", ");
	for (; *net != NULL; net++) {
		if (net_parse_range(*net, &net_ip, &bits) < 0) {
			i_error("login_trusted_networks: "
				"Invalid network '%s'", *net);
			break;
		}

		if (net_is_in_network(&client->remote_ip, &net_ip, bits))
			return TRUE;
	}
	return FALSE;
}

void clients_destroy(void)
{
	while (clients != NULL) {
		client_destroy(clients, "4.3.2", "Shutting down");
	}
}

static const struct smtp_server_callbacks lmtp_callbacks = {
	.conn_cmd_mail = cmd_mail,
	.conn_cmd_rcpt = cmd_rcpt,
	.conn_cmd_data_begin = cmd_data_begin,
	.conn_cmd_data_continue = cmd_data_continue,

	.conn_trans_free = client_connection_trans_free,

	.conn_state_changed = client_connection_state_changed,

	.conn_proxy_data_updated = client_connection_proxy_data_updated,

	.conn_disconnect = client_connection_disconnect,
	.conn_destroy = client_connection_destroy,

	.conn_is_trusted = client_connection_is_trusted
};