1817N/A

355N/A#include "lib.h"

355N/A#include "ioloop.h"

355N/A#include "array.h"

355N/A#include "str.h"

355N/A#include "strescape.h"

355N/A#include "hostpid.h"

1817N/A#include "istream.h"

355N/A#include "istream-concat.h"

355N/A#include "ostream.h"

355N/A#include "istream-dot.h"

355N/A#include "safe-mkstemp.h"

355N/A#include "hex-dec.h"

355N/A#include "time-util.h"

355N/A#include "var-expand.h"

355N/A#include "restrict-access.h"

355N/A#include "settings-parser.h"

355N/A#include "anvil-client.h"

355N/A#include "master-service.h"

355N/A#include "master-service-ssl.h"

355N/A#include "iostream-ssl.h"

355N/A#include "rfc822-parser.h"

355N/A#include "message-date.h"

355N/A#include "auth-master.h"

355N/A#include "mail-storage-service.h"

355N/A#include "index/raw/raw-storage.h"

355N/A#include "lda-settings.h"

355N/A#include "lmtp-settings.h"

355N/A#include "mail-namespace.h"

355N/A#include "mail-deliver.h"

355N/A#include "main.h"

355N/A#include "client.h"

355N/A#include "commands.h"

355N/A#include "lmtp-proxy.h"

355N/A

355N/A#define ERRSTR_TEMP_MAILBOX_FAIL "451 4.3.0 <%s> Temporary internal error"

355N/A#define ERRSTR_TEMP_USERDB_FAIL_PREFIX "451 4.3.0 <%s> "

355N/A#define ERRSTR_TEMP_USERDB_FAIL \

355N/A ERRSTR_TEMP_USERDB_FAIL_PREFIX "Temporary user lookup failure"

355N/A

355N/A#define LMTP_PROXY_DEFAULT_TIMEOUT_MSECS (1000*125)

355N/A

355N/Aint cmd_lhlo(struct client *client, const char *args)

355N/A{

355N/A struct rfc822_parser_context parser;

355N/A string_t *domain = t_str_new(128);

355N/A const char *p;

355N/A int ret = 0;

355N/A

355N/A if (*args == '\0') {

355N/A client_send_line(client, "501 Missing hostname");

355N/A return 0;

355N/A }

355N/A

355N/A /* domain / address-literal */

355N/A rfc822_parser_init(&parser, (const unsigned char *)args, strlen(args),

355N/A NULL);

1817N/A if (*args != '[')

355N/A ret = rfc822_parse_dot_atom(&parser, domain);

355N/A else {

355N/A for (p = args+1; *p != ']'; p++) {

355N/A if (*p == '\\' || *p == '[')

355N/A break;

355N/A }

355N/A if (strcmp(p, "]") != 0)

355N/A ret = -1;

355N/A }

355N/A if (ret < 0) {

355N/A str_truncate(domain, 0);

355N/A str_append(domain, "invalid");

355N/A }

355N/A

355N/A client_state_reset(client, "LHLO");

355N/A client_send_line(client, "250-%s", client->my_domain);

355N/A if (master_service_ssl_is_enabled(master_service) &&

355N/A client->ssl_iostream == NULL)

355N/A client_send_line(client, "250-STARTTLS");

355N/A if (client_is_trusted(client))

355N/A client_send_line(client, "250-XCLIENT ADDR PORT TTL TIMEOUT");

355N/A client_send_line(client, "250-8BITMIME");

355N/A client_send_line(client, "250-ENHANCEDSTATUSCODES");

355N/A client_send_line(client, "250 PIPELINING");

355N/A

355N/A i_free(client->lhlo);

355N/A client->lhlo = i_strdup(str_c(domain));

355N/A client_state_set(client, "LHLO", "");

355N/A return 0;

355N/A}

355N/A

355N/Aint cmd_starttls(struct client *client)

355N/A{

355N/A struct ostream *plain_output = client->output;

355N/A const char *error;

355N/A

355N/A if (client->ssl_iostream != NULL) {

355N/A o_stream_nsend_str(client->output,

355N/A "443 5.5.1 TLS is already active.\r\n");

355N/A return 0;

355N/A }

355N/A

355N/A if (master_service_ssl_init(master_service,

355N/A &client->input, &client->output,

355N/A &client->ssl_iostream, &error) < 0) {

355N/A i_error("TLS initialization failed: %s", error);

355N/A o_stream_nsend_str(client->output,

355N/A "454 4.7.0 Internal error, TLS not available.\r\n");

355N/A return 0;

355N/A }

355N/A o_stream_nsend_str(plain_output,

355N/A "220 2.0.0 Begin TLS negotiation now.\r\n");

355N/A if (ssl_iostream_handshake(client->ssl_iostream) < 0) {

355N/A client_destroy(client, NULL, NULL);

355N/A return -1;

355N/A }

355N/A return 0;

355N/A}

355N/A

355N/Astatic int parse_address(const char *str, const char **address_r,

355N/A const char **rest_r)

355N/A{

355N/A const char *start;

355N/A

355N/A if (*str++ != '<')

355N/A return -1;

355N/A start = str;

355N/A if (*str == '"') {

355N/A /* "quoted-string"@domain */

355N/A for (str++; *str != '"'; str++) {

355N/A if (*str == '\\')

355N/A str++;

355N/A if (*str == '\0')

355N/A return -1;

355N/A }

355N/A str++;

355N/A }

355N/A for (; *str != '>'; str++) {

355N/A if (*str == '\0' || *str == ' ')

355N/A return -1;

355N/A }

355N/A *address_r = t_strdup_until(start, str);

355N/A if (*str++ != '>')

355N/A return -1;

355N/A

355N/A if (*str == ' ')

355N/A str++;

355N/A else if (*str != '\0')

355N/A return -1;

355N/A *rest_r = str;

355N/A return 0;

355N/A}

355N/A

355N/Astatic const char *

355N/Aparse_xtext(struct client *client, const char *value)

355N/A{

355N/A const char *p;

355N/A string_t *str;

355N/A unsigned int i;

355N/A

355N/A p = strchr(value, '+');

355N/A if (p == NULL)

355N/A return p_strdup(client->state_pool, value);

355N/A

355N/A /*

355N/A str = t_str_new(128);

355N/A for (i = 0; value[i] != '\0'; i++) {

355N/A if (value[i] == '+' && value[i+1] != '\0' && value[i+2] != '\0') {

355N/A str_append_c(str, hex2dec((const void *)(value+i+1), 2));

355N/A i += 2;

355N/A } else {

355N/A str_append_c(str, value[i]);

355N/A }

355N/A }

355N/A return p_strdup(client->state_pool, str_c(str));

355N/A}

355N/A

355N/Astatic void lmtp_anvil_init(void)

355N/A{

355N/A if (anvil == NULL) {

355N/A const char *path = t_strdup_printf("%s/anvil", base_dir);

355N/A anvil = anvil_client_init(path, NULL, 0);

355N/A }

355N/A}

355N/A

355N/Aint cmd_mail(struct client *client, const char *args)

355N/A{

355N/A const char *addr, *const *argv;

355N/A

355N/A if (client->state.mail_from != NULL) {

355N/A client_send_line(client, "503 5.5.1 MAIL already given");

355N/A return 0;

355N/A }

355N/A

355N/A if (strncasecmp(args, "FROM:", 5) != 0 ||

355N/A parse_address(args + 5, &addr, &args) < 0) {

355N/A client_send_line(client, "501 5.5.4 Invalid parameters");

355N/A return 0;

355N/A }

355N/A

355N/A argv = t_strsplit(args, " ");

355N/A for (; *argv != NULL; argv++) {

355N/A if (strcasecmp(*argv, "BODY=7BIT") == 0)

355N/A client->state.mail_body_7bit = TRUE;

355N/A else if (strcasecmp(*argv, "BODY=8BITMIME") == 0)

355N/A client->state.mail_body_8bitmime = TRUE;

355N/A else {

355N/A client_send_line(client,

355N/A "501 5.5.4 Unsupported options");

355N/A return 0;

355N/A }

355N/A }

355N/A

355N/A client->state.mail_from = p_strdup(client->state_pool, addr);

355N/A p_array_init(&client->state.rcpt_to, client->state_pool, 64);

355N/A client_send_line(client, "250 2.1.0 OK");

355N/A client_state_set(client, "MAIL FROM", client->state.mail_from);

355N/A

355N/A if (client->lmtp_set->lmtp_user_concurrency_limit > 0) {

355N/A /* connect to anvil before dropping privileges */

355N/A lmtp_anvil_init();

355N/A }

355N/A

355N/A client->state.mail_from_timeval = ioloop_timeval;

355N/A return 0;

355N/A}

355N/A

355N/Astatic bool

355N/Aclient_proxy_rcpt_parse_fields(struct lmtp_proxy_rcpt_settings *set,

355N/A const char *const *args, const char **address)

355N/A{

355N/A const char *p, *key, *value;

355N/A bool proxying = FALSE, port_set = FALSE;

355N/A

355N/A for (; *args != NULL; args++) {

355N/A p = strchr(*args, '=');

355N/A if (p == NULL) {

355N/A key = *args;

355N/A value = "";

355N/A } else {

355N/A key = t_strdup_until(*args, p);

355N/A value = p + 1;

355N/A }

355N/A

355N/A if (strcmp(key, "proxy") == 0)

355N/A proxying = TRUE;

355N/A else if (strcmp(key, "host") == 0)

355N/A set->host = value;

355N/A else if (strcmp(key, "port") == 0) {

355N/A if (net_str2port(value, &set->port) < 0) {

355N/A i_error("proxy: Invalid port number %s", value);

355N/A return FALSE;

355N/A }

355N/A port_set = TRUE;

355N/A } else if (strcmp(key, "proxy_timeout") == 0) {

1817N/A if (str_to_uint(value, &set->timeout_msecs) < 0) {

355N/A i_error("proxy: Invalid proxy_timeout value %s", value);

355N/A return FALSE;

355N/A }

355N/A set->timeout_msecs *= 1000;

355N/A } else if (strcmp(key, "protocol") == 0) {

355N/A if (strcmp(value, "lmtp") == 0) {

355N/A set->protocol = LMTP_CLIENT_PROTOCOL_LMTP;

355N/A if (!port_set)

355N/A set->port = 24;

355N/A } else if (strcmp(value, "smtp") == 0) {

355N/A set->protocol = LMTP_CLIENT_PROTOCOL_SMTP;

355N/A if (!port_set)

355N/A set->port = 25;

355N/A } else {

355N/A i_error("proxy: Unknown protocol %s", value);

355N/A return FALSE;

355N/A }

355N/A } else if (strcmp(key, "user") == 0 ||

355N/A strcmp(key, "destuser") == 0) {

355N/A /* changing the username */

355N/A *address = value;

1817N/A } else {

/* just ignore it */

}

}

if (proxying && set->host == NULL) {

i_error("proxy: host not given");

return FALSE;

}

return proxying;

}

static bool

client_proxy_is_ourself(const struct client *client,

const struct lmtp_proxy_rcpt_settings *set)

{

struct ip_addr ip;

if (set->port != client->local_port)

return FALSE;

if (net_addr2ip(set->host, &ip) < 0)

return FALSE;

if (!net_ip_compare(&ip, &client->local_ip))

return FALSE;

return TRUE;

}

static const char *

address_add_detail(const char *username, char delim_c,

const char *detail)

{

const char *domain;

const char delim[] = {delim_c, '\0'};

domain = strchr(username, '@');

if (domain == NULL)

return t_strconcat(username, delim, detail, NULL);

else {

username = t_strdup_until(username, domain);

return t_strconcat(username, delim, detail, domain, NULL);

}

}

static bool client_proxy_rcpt(struct client *client, const char *address,

const char *username, const char *detail, char delim,

const struct lmtp_recipient_params *params)

{

struct auth_master_connection *auth_conn;

struct lmtp_proxy_rcpt_settings set;

struct auth_user_info info;

struct mail_storage_service_input input;

const char *args, *const *fields, *errstr, *orig_username = username;

pool_t pool;

int ret;

i_zero(&input);

input.module = input.service = "lmtp";

mail_storage_service_init_settings(storage_service, &input);

i_zero(&info);

info.service = master_service_get_name(master_service);

info.local_ip = client->local_ip;

info.remote_ip = client->remote_ip;

info.local_port = client->local_port;

info.remote_port = client->remote_port;

pool = pool_alloconly_create("auth lookup", 1024);

auth_conn = mail_storage_service_get_auth_conn(storage_service);

ret = auth_master_pass_lookup(auth_conn, username, &info,

pool, &fields);

if (ret <= 0) {

errstr = ret < 0 && fields[0] != NULL ? t_strdup(fields[0]) :

t_strdup_printf(ERRSTR_TEMP_USERDB_FAIL, address);

pool_unref(&pool);

if (ret < 0) {

client_send_line(client, "%s", errstr);

return TRUE;

} else {

/* user not found from passdb. try userdb also. */

return FALSE;

}

}

i_zero(&set);

set.port = client->local_port;

set.protocol = LMTP_CLIENT_PROTOCOL_LMTP;

set.timeout_msecs = LMTP_PROXY_DEFAULT_TIMEOUT_MSECS;

set.params = *params;

if (!client_proxy_rcpt_parse_fields(&set, fields, &username)) {

/* not proxying this user */

pool_unref(&pool);

return FALSE;

}

if (strcmp(username, orig_username) != 0) {

/* username changed. change the address as well */

if (*detail == '\0')

address = username;

else

address = address_add_detail(username, delim, detail);

} else if (client_proxy_is_ourself(client, &set)) {

i_error("Proxying to <%s> loops to itself", username);

client_send_line(client, "554 5.4.6 <%s> "

"Proxying loops to itself", address);

pool_unref(&pool);

return TRUE;

}

if (client->proxy_ttl <= 1) {

i_error("Proxying to <%s> appears to be looping (TTL=0)",

username);

client_send_line(client, "554 5.4.6 <%s> "

"Proxying appears to be looping (TTL=0)",

username);

pool_unref(&pool);

return TRUE;

}

if (array_count(&client->state.rcpt_to) != 0) {

client_send_line(client, "451 4.3.0 <%s> "

"Can't handle mixed proxy/non-proxy destinations",

address);

pool_unref(&pool);

return TRUE;

}

if (client->proxy == NULL) {

struct lmtp_proxy_settings proxy_set;

i_zero(&proxy_set);

proxy_set.my_hostname = client->my_domain;

proxy_set.dns_client_socket_path = dns_client_socket_path;

proxy_set.session_id = client->state.session_id;

proxy_set.source_ip = client->remote_ip;

proxy_set.source_port = client->remote_port;

proxy_set.proxy_ttl = client->proxy_ttl-1;

client->proxy = lmtp_proxy_init(&proxy_set, client->output);

if (client->state.mail_body_8bitmime)

args = " BODY=8BITMIME";

else if (client->state.mail_body_7bit)

args = " BODY=7BIT";

else

args = "";

lmtp_proxy_mail_from(client->proxy, t_strdup_printf(

"<%s>%s", client->state.mail_from, args));

}

if (lmtp_proxy_add_rcpt(client->proxy, address, &set) < 0)

client_send_line(client, ERRSTR_TEMP_REMOTE_FAILURE);

else

client_send_line(client, "250 2.1.5 OK");

pool_unref(&pool);

return TRUE;

}

static const char *lmtp_unescape_address(const char *name)

{

string_t *str;

const char *p;

if (*name != '"')

return name;

/* quoted-string local-part. drop the quotes unless there's a

str = t_str_new(128);

for (p = name+1; *p != '"'; p++) {

if (*p == '\0')

return name;

if (*p == '\\') {

if (p[1] == '\0') {

/* error */

return name;

}

p++;

}

if (*p == '@')

return name;

str_append_c(str, *p);

}

p++;

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

return name;

str_append(str, p);

return str_c(str);

}

static void rcpt_address_parse(struct client *client, const char *address,

const char **username_r, char *delim_r,

const char **detail_r)

{

const char *p, *domain;

size_t idx;

*username_r = address;

*detail_r = "";

if (*client->unexpanded_lda_set->recipient_delimiter == '\0')

return;

domain = strchr(address, '@');

/* first character that matches the recipient_delimiter */

idx = strcspn(address, client->unexpanded_lda_set->recipient_delimiter);

p = address[idx] != '\0' ? address + idx : NULL;

if (p != NULL && (domain == NULL || p < domain)) {

*delim_r = *p;

/* user+detail@domain */

*username_r = t_strdup_until(*username_r, p);

if (domain == NULL)

*detail_r = p+1;

else {

*detail_r = t_strdup_until(p+1, domain);

*username_r = t_strconcat(*username_r, domain, NULL);

}

}

}

static void lmtp_address_translate(struct client *client, const char **address)

{

const char *transpos = client->lmtp_set->lmtp_address_translate;

const char *p, *nextstr, *addrpos = *address;

size_t len;

string_t *username, *domain, *dest = NULL;

if (*transpos == '\0')

return;

username = t_str_new(64);

domain = t_str_new(64);

/* check that string matches up to the first '%' */

p = strchr(transpos, '%');

if (p == NULL)

len = strlen(transpos);

else

len = p-transpos;

if (strncmp(transpos, addrpos, len) != 0)

return;

transpos += len;

addrpos += len;

while (*transpos != '\0') {

switch (transpos[1]) {

case 'n':

case 'u':

dest = username;

break;

case 'd':

dest = domain;

break;

default:

return;

}

transpos += 2;

/* find where the next string starts */

if (*transpos == '\0') {

str_append(dest, addrpos);

break;

}

p = strchr(transpos, '%');

if (p == NULL)

nextstr = transpos;

else

nextstr = t_strdup_until(transpos, p);

p = strstr(addrpos, nextstr);

if (p == NULL)

return;

str_append_n(dest, addrpos, p-addrpos);

len = strlen(nextstr);

transpos += len;

addrpos = p + len;

}

str_append_c(username, '@');

if (domain != NULL)

str_append_str(username, domain);

*address = str_c(username);

}

static void

client_send_line_overquota(struct client *client,

const struct mail_recipient *rcpt, const char *error)

{

struct lda_settings *lda_set =

mail_storage_service_user_get_set(rcpt->service_user)[1];

client_send_line(client, "%s <%s> %s", lda_set->quota_full_tempfail ?

"452 4.2.2" : "552 5.2.2", rcpt->address, error);

}

static int

lmtp_rcpt_to_is_over_quota(struct client *client,

const struct mail_recipient *rcpt)

{

struct mail_user *user;

struct mail_namespace *ns;

struct mailbox *box;

struct mailbox_status status;

const char *errstr;

enum mail_error error;

int ret;

if (!client->lmtp_set->lmtp_rcpt_check_quota)

return 0;

ret = mail_storage_service_next(storage_service,

rcpt->service_user, &user, &errstr);

if (ret < 0) {

i_error("Failed to initialize user %s: %s", rcpt->address, errstr);

return -1;

}

ns = mail_namespace_find_inbox(user->namespaces);

box = mailbox_alloc(ns->list, "INBOX", 0);

ret = mailbox_get_status(box, STATUS_CHECK_OVER_QUOTA, &status);

if (ret < 0) {

errstr = mailbox_get_last_error(box, &error);

if (error == MAIL_ERROR_NOQUOTA) {

client_send_line_overquota(client, rcpt, errstr);

ret = 1;

} else {

i_error("mailbox_get_status(%s, STATUS_CHECK_OVER_QUOTA) "

"failed: %s",

mailbox_get_vname(box),

mailbox_get_last_internal_error(box, NULL));

}

}

mailbox_free(&box);

mail_user_unref(&user);

return ret;

}

static bool cmd_rcpt_finish(struct client *client, struct mail_recipient *rcpt)

{

int ret;

if ((ret = lmtp_rcpt_to_is_over_quota(client, rcpt)) != 0) {

if (ret < 0) {

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

rcpt->address);

}

mail_storage_service_user_unref(&rcpt->service_user);

return FALSE;

}

array_append(&client->state.rcpt_to, &rcpt, 1);

client_send_line(client, "250 2.1.5 OK");

return TRUE;

}

static void rcpt_anvil_lookup_callback(const char *reply, void *context)

{

struct mail_recipient *rcpt = context;

struct client *client = rcpt->client;

const struct mail_storage_service_input *input;

unsigned int parallel_count = 0;

rcpt->anvil_query = NULL;

if (reply == NULL) {

/* lookup failed */

} else if (str_to_uint(reply, &parallel_count) < 0) {

i_error("Invalid reply from anvil: %s", reply);

}

if (parallel_count >= client->lmtp_set->lmtp_user_concurrency_limit) {

client_send_line(client, ERRSTR_TEMP_USERDB_FAIL_PREFIX

"Too many concurrent deliveries for user",

rcpt->address);

mail_storage_service_user_unref(&rcpt->service_user);

} else if (cmd_rcpt_finish(client, rcpt)) {

rcpt->anvil_connect_sent = TRUE;

input = mail_storage_service_user_get_input(rcpt->service_user);

master_service_anvil_send(master_service, t_strconcat(

"CONNECT\t", my_pid, "\t", master_service_get_name(master_service),

"/", input->username, "\n", NULL));

}

client_io_reset(client);

client_input_handle(client);

}

int cmd_rcpt(struct client *client, const char *args)

{

struct mail_recipient *rcpt;

struct mail_storage_service_input input;

const char *params, *address, *username, *detail;

const char *const *argv;

const char *error = NULL;

char delim = '\0';

int ret = 0;

if (client->state.mail_from == NULL) {

client_send_line(client, "503 5.5.1 MAIL needed first");

return 0;

}

if (strncasecmp(args, "TO:", 3) != 0 ||

parse_address(args + 3, &address, &params) < 0) {

client_send_line(client, "501 5.5.4 Invalid parameters");

return 0;

}

rcpt = p_new(client->state_pool, struct mail_recipient, 1);

rcpt->client = client;

address = lmtp_unescape_address(address);

argv = t_strsplit(params, " ");

for (; *argv != NULL; argv++) {

if (strncasecmp(*argv, "ORCPT=", 6) == 0) {

rcpt->params.dsn_orcpt = parse_xtext(client, *argv + 6);

} else {

client_send_line(client, "501 5.5.4 Unsupported options");

return 0;

}

}

rcpt_address_parse(client, address, &username, &delim, &detail);

client_state_set(client, "RCPT TO", address);

if (client->lmtp_set->lmtp_proxy) {

if (client_proxy_rcpt(client, address, username, detail, delim,

&rcpt->params))

return 0;

}

/* Use a unique session_id for each mail delivery. This is especially

if (array_count(&client->state.rcpt_to) == 0)

rcpt->session_id = client->state.session_id;

else {

rcpt->session_id =

p_strdup_printf(client->state_pool, "%s:%u",

client->state.session_id,

array_count(&client->state.rcpt_to)+1);

}

i_zero(&input);

input.module = input.service = "lmtp";

input.username = username;

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.session_id = rcpt->session_id;

ret = mail_storage_service_lookup(storage_service, &input,

&rcpt->service_user, &error);

if (ret < 0) {

i_error("Failed to lookup user %s: %s", username, error);

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL, address);

return 0;

}

if (ret == 0) {

client_send_line(client,

"550 5.1.1 <%s> User doesn't exist: %s",

address, username);

return 0;

}

if (client->proxy != NULL) {

/* NOTE: if this restriction is ever removed, we'll also need

client_send_line(client, "451 4.3.0 <%s> "

"Can't handle mixed proxy/non-proxy destinations",

address);

mail_storage_service_user_unref(&rcpt->service_user);

return 0;

}

lmtp_address_translate(client, &address);

rcpt->address = p_strdup(client->state_pool, address);

rcpt->detail = p_strdup(client->state_pool, detail);

if (client->lmtp_set->lmtp_user_concurrency_limit == 0) {

(void)cmd_rcpt_finish(client, rcpt);

return 0;

} else {

/* NOTE: username may change as the result of the userdb

const struct mail_storage_service_input *input =

mail_storage_service_user_get_input(rcpt->service_user);

const char *query = t_strconcat("LOOKUP\t",

master_service_get_name(master_service),

"/", str_tabescape(input->username), NULL);

io_remove(&client->io);

rcpt->anvil_query = anvil_client_query(anvil, query,

rcpt_anvil_lookup_callback, rcpt);

/* stop processing further commands while anvil query is

return rcpt->anvil_query == NULL ? 0 : -1;

}

}

int cmd_quit(struct client *client, const char *args ATTR_UNUSED)

{

client_send_line(client, "221 2.0.0 OK");

/* don't log the (state name) for successful QUITs */

i_info("Disconnect from %s: Successful quit", client_remote_id(client));

client->disconnected = TRUE;

client_destroy(client, NULL, NULL);

return -1;

}

int cmd_vrfy(struct client *client, const char *args ATTR_UNUSED)

{

client_send_line(client, "252 2.3.3 Try RCPT instead");

return 0;

}

int cmd_rset(struct client *client, const char *args ATTR_UNUSED)

{

client_state_reset(client, "RSET");

client_send_line(client, "250 2.0.0 OK");

return 0;

}

int cmd_noop(struct client *client, const char *args ATTR_UNUSED)

{

client_send_line(client, "250 2.0.0 OK");

return 0;

}

static bool orcpt_get_valid_rfc822(const char *orcpt, const char **addr_r)

{

if (orcpt == NULL || strncasecmp(orcpt, "rfc822;", 7) != 0)

return FALSE;

/* FIXME: we should verify the address further */

*addr_r = orcpt + 7;

return TRUE;

}

static int

client_deliver(struct client *client, const struct mail_recipient *rcpt,

struct mail *src_mail, struct mail_deliver_session *session)

{

struct mail_deliver_context dctx;

struct mail_storage *storage;

const struct mail_storage_service_input *input;

const struct mail_storage_settings *mail_set;

struct lda_settings *lda_set;

struct mail_namespace *ns;

struct setting_parser_context *set_parser;

struct timeval delivery_time_started;

void **sets;

const char *line, *error, *username;

string_t *str;

enum mail_error mail_error;

int ret;

input = mail_storage_service_user_get_input(rcpt->service_user);

username = t_strdup(input->username);

mail_set = mail_storage_service_user_get_mail_set(rcpt->service_user);

set_parser = mail_storage_service_user_get_settings_parser(rcpt->service_user);

if (client->proxy_timeout_secs > 0 &&

(mail_set->mail_max_lock_timeout == 0 ||

mail_set->mail_max_lock_timeout > client->proxy_timeout_secs)) {

/* set lock timeout waits to be less than when proxy has

line = t_strdup_printf("mail_max_lock_timeout=%u",

client->proxy_timeout_secs <= 1 ? 1 :

client->proxy_timeout_secs-1);

if (settings_parse_line(set_parser, line) < 0)

i_unreached();

}

/* get the timestamp before user is created, since it starts the I/O */

io_loop_time_refresh();

delivery_time_started = ioloop_timeval;

client_state_set(client, "DATA", username);

i_set_failure_prefix("lmtp(%s, %s): ", my_pid, username);

if (mail_storage_service_next(storage_service, rcpt->service_user,

&client->state.dest_user, &error) < 0) {

i_error("Failed to initialize user: %s", error);

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

rcpt->address);

return -1;

}

sets = mail_storage_service_user_get_set(rcpt->service_user);

lda_set = sets[1];

if (settings_var_expand(&lda_setting_parser_info, lda_set, client->pool,

mail_user_var_expand_table(client->state.dest_user), &error) <= 0) {

i_error("Failed to expand settings: %s", error);

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

rcpt->address);

return -1;

}

str = t_str_new(256);

if (var_expand_with_funcs(str, client->state.dest_user->set->mail_log_prefix,

mail_user_var_expand_table(client->state.dest_user),

mail_user_var_expand_func_table,

client->state.dest_user, &error) <= 0) {

i_error("Failed to expand mail_log_prefix=%s: %s",

client->state.dest_user->set->mail_log_prefix, error);

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

rcpt->address);

return -1;

}

i_set_failure_prefix("%s", str_c(str));

i_zero(&dctx);

dctx.session = session;

dctx.pool = session->pool;

dctx.set = lda_set;

dctx.timeout_secs = LDA_SUBMISSION_TIMEOUT_SECS;

dctx.session_id = rcpt->session_id;

dctx.src_mail = src_mail;

dctx.src_envelope_sender = client->state.mail_from;

dctx.dest_user = client->state.dest_user;

dctx.session_time_msecs =

timeval_diff_msecs(&client->state.data_end_timeval,

&client->state.mail_from_timeval);

dctx.delivery_time_started = delivery_time_started;

if (orcpt_get_valid_rfc822(rcpt->params.dsn_orcpt, &dctx.dest_addr)) {

/* used ORCPT */

} else if (*dctx.set->lda_original_recipient_header != '\0') {

dctx.dest_addr = mail_deliver_get_address(src_mail,

dctx.set->lda_original_recipient_header);

}

if (dctx.dest_addr == NULL)

dctx.dest_addr = rcpt->address;

dctx.final_dest_addr = rcpt->address;

if (*rcpt->detail == '\0' ||

!client->lmtp_set->lmtp_save_to_detail_mailbox)

dctx.dest_mailbox_name = "INBOX";

else {

ns = mail_namespace_find_inbox(dctx.dest_user->namespaces);

dctx.dest_mailbox_name =

t_strconcat(ns->prefix, rcpt->detail, NULL);

}

dctx.save_dest_mail = array_count(&client->state.rcpt_to) > 1 &&

client->state.first_saved_mail == NULL;

if (mail_deliver(&dctx, &storage) == 0) {

if (dctx.dest_mail != NULL) {

i_assert(client->state.first_saved_mail == NULL);

client->state.first_saved_mail = dctx.dest_mail;

}

client_send_line(client, "250 2.0.0 <%s> %s Saved",

rcpt->address, rcpt->session_id);

ret = 0;

} else if (dctx.tempfail_error != NULL) {

client_send_line(client, "451 4.2.0 <%s> %s",

rcpt->address, dctx.tempfail_error);

ret = -1;

} else if (storage != NULL) {

error = mail_storage_get_last_error(storage, &mail_error);

if (mail_error == MAIL_ERROR_NOQUOTA) {

client_send_line_overquota(client, rcpt, error);

} else {

client_send_line(client, "451 4.2.0 <%s> %s",

rcpt->address, error);

}

ret = -1;

} else {

/* This shouldn't happen */

i_error("BUG: Saving failed to unknown storage");

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

rcpt->address);

ret = -1;

}

return ret;

}

static bool client_deliver_next(struct client *client, struct mail *src_mail,

struct mail_deliver_session *session)

{

struct mail_recipient *const *rcpts;

unsigned int count;

int ret;

rcpts = array_get(&client->state.rcpt_to, &count);

while (client->state.rcpt_idx < count) {

ret = client_deliver(client, rcpts[client->state.rcpt_idx],

src_mail, session);

client_state_set(client, "DATA", "");

i_set_failure_prefix("lmtp(%s): ", my_pid);

client->state.rcpt_idx++;

if (ret == 0)

return TRUE;

/* failed. try the next one. */

if (client->state.dest_user != NULL)

mail_user_unref(&client->state.dest_user);

}

return FALSE;

}

static void client_rcpt_fail_all(struct client *client)

{

struct mail_recipient *const *rcptp;

array_foreach(&client->state.rcpt_to, rcptp) {

client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,

(*rcptp)->address);

}

}

static struct istream *client_get_input(struct client *client)

{

struct client_state *state = &client->state;

struct istream *cinput, *inputs[3];

inputs[0] = i_stream_create_from_data(state->added_headers,

strlen(state->added_headers));

if (state->mail_data_output != NULL) {

o_stream_unref(&state->mail_data_output);

inputs[1] = i_stream_create_fd(state->mail_data_fd,

MAIL_READ_FULL_BLOCK_SIZE);

i_stream_set_init_buffer_size(inputs[1],

MAIL_READ_FULL_BLOCK_SIZE);

} else {

inputs[1] = i_stream_create_from_data(state->mail_data->data,

state->mail_data->used);

}

inputs[2] = NULL;

cinput = i_stream_create_concat(inputs);

i_stream_set_name(cinput, "<lmtp DATA>");

i_stream_unref(&inputs[0]);

i_stream_unref(&inputs[1]);

return cinput;

}

static int client_open_raw_mail(struct client *client, struct istream *input)

{

static const char *wanted_headers[] = {

"From", "To", "Message-ID", "Subject", "Return-Path",

NULL

};

struct mailbox *box;

struct mailbox_transaction_context *trans;

struct mailbox_header_lookup_ctx *headers_ctx;

enum mail_error error;

if (raw_mailbox_alloc_stream(client->raw_mail_user, input,

(time_t)-1, client->state.mail_from,

&box) < 0) {

i_error("Can't open delivery mail as raw: %s",

mailbox_get_last_internal_error(box, &error));

mailbox_free(&box);

client_rcpt_fail_all(client);

return -1;

}

trans = mailbox_transaction_begin(box, 0);

headers_ctx = mailbox_header_lookup_init(box, wanted_headers);

client->state.raw_mail = mail_alloc(trans, 0, headers_ctx);

mailbox_header_lookup_unref(&headers_ctx);

mail_set_seq(client->state.raw_mail, 1);

return 0;

}

static void

client_input_data_write_local(struct client *client, struct istream *input)

{

struct mail_deliver_session *session;

struct mail *src_mail;

uid_t old_uid, first_uid = (uid_t)-1;

if (client_open_raw_mail(client, input) < 0)

return;

session = mail_deliver_session_init();

old_uid = geteuid();

src_mail = client->state.raw_mail;

while (client_deliver_next(client, src_mail, session)) {

if (client->state.first_saved_mail == NULL ||

client->state.first_saved_mail == src_mail)

mail_user_unref(&client->state.dest_user);

else {

/* use the first saved message to save it elsewhere too.

client->state.dest_user = NULL;

src_mail = client->state.first_saved_mail;

first_uid = geteuid();

i_assert(first_uid != 0);

}

}

mail_deliver_session_deinit(&session);

if (client->state.first_saved_mail != NULL) {

struct mail *mail = client->state.first_saved_mail;

struct mailbox_transaction_context *trans = mail->transaction;

struct mailbox *box = trans->box;

struct mail_user *user = box->storage->user;

/* just in case these functions are going to write anything,

if (first_uid != old_uid) {

if (seteuid(0) < 0)

i_fatal("seteuid(0) failed: %m");

if (seteuid(first_uid) < 0)

i_fatal("seteuid() failed: %m");

}

mail_free(&mail);

mailbox_transaction_rollback(&trans);

mailbox_free(&box);

mail_user_unref(&user);

}

if (old_uid == 0) {

/* switch back to running as root, since that's what we're

if (seteuid(0) < 0)

i_fatal("seteuid(0) failed: %m");

/* enable core dumping again. we need to chdir also to

restrict_access_allow_coredumps(TRUE);

if (chdir(base_dir) < 0)

i_error("chdir(%s) failed: %m", base_dir);

}

}

static void client_input_data_finish(struct client *client)

{

client_io_reset(client);

client_state_reset(client, "DATA finished");

if (i_stream_have_bytes_left(client->input))

client_input_handle(client);

}

static void client_proxy_finish(void *context)

{

struct client *client = context;

lmtp_proxy_deinit(&client->proxy);

client_input_data_finish(client);

}

static const char *client_get_added_headers(struct client *client)

{

string_t *str = t_str_new(200);

void **sets;

const struct lmtp_settings *lmtp_set;

const char *host, *rcpt_to = NULL;

if (array_count(&client->state.rcpt_to) == 1) {

struct mail_recipient *const *rcptp =

array_idx(&client->state.rcpt_to, 0);

sets = mail_storage_service_user_get_set((*rcptp)->service_user);

lmtp_set = sets[2];

switch (lmtp_set->parsed_lmtp_hdr_delivery_address) {

case LMTP_HDR_DELIVERY_ADDRESS_NONE:

break;

case LMTP_HDR_DELIVERY_ADDRESS_FINAL:

rcpt_to = (*rcptp)->address;

break;

case LMTP_HDR_DELIVERY_ADDRESS_ORIGINAL:

if (!orcpt_get_valid_rfc822((*rcptp)->params.dsn_orcpt,

&rcpt_to))

rcpt_to = (*rcptp)->address;

break;

}

}

/* don't set Return-Path when proxying so it won't get added twice */

if (array_count(&client->state.rcpt_to) > 0) {

str_printfa(str, "Return-Path: <%s>\r\n",

client->state.mail_from);

if (rcpt_to != NULL)

str_printfa(str, "Delivered-To: %s\r\n", rcpt_to);

}

str_printfa(str, "Received: from %s", client->lhlo);

host = net_ip2addr(&client->remote_ip);

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

str_printfa(str, " ([%s])", host);

str_append(str, "\r\n");

if (client->ssl_iostream != NULL) {

str_printfa(str, "\t(using %s)\r\n",

ssl_iostream_get_security_string(client->ssl_iostream));

}

str_printfa(str, "\tby %s with LMTP id %s",

client->my_domain, client->state.session_id);

str_append(str, "\r\n\t");

if (rcpt_to != NULL)

str_printfa(str, "for <%s>", rcpt_to);

str_printfa(str, "; %s\r\n", message_date_create(ioloop_time));

return str_c(str);

}

static void client_input_data_write(struct client *client)

{

struct istream *input;

/* stop handling client input until saving/proxying is finished */

if (client->to_idle != NULL)

timeout_remove(&client->to_idle);

io_remove(&client->io);

i_stream_destroy(&client->dot_input);

client->state.data_end_timeval = ioloop_timeval;

input = client_get_input(client);

if (array_count(&client->state.rcpt_to) != 0)

client_input_data_write_local(client, input);

if (client->proxy != NULL) {

client_state_set(client, "DATA", "proxying");

lmtp_proxy_start(client->proxy, input,

client_proxy_finish, client);

} else {

client_input_data_finish(client);

}

i_stream_unref(&input);

}

static int client_input_add_file(struct client *client,

const unsigned char *data, size_t size)

{

struct client_state *state = &client->state;

string_t *path;

int fd;

if (state->mail_data_output != NULL) {

/* continue writing to file */

if (o_stream_send(state->mail_data_output,

data, size) != (ssize_t)size)

return -1;

return 0;

}

/* move everything to a temporary file. */

path = t_str_new(256);

mail_user_set_get_temp_prefix(path, client->raw_mail_user->set);

fd = safe_mkstemp_hostpid(path, 0600, (uid_t)-1, (gid_t)-1);

if (fd == -1) {

i_error("Temp file creation to %s failed: %m", str_c(path));

return -1;

}

/* we just want the fd, unlink it */

if (i_unlink(str_c(path)) < 0) {

/* shouldn't happen.. */

i_close_fd(&fd);

return -1;

}

state->mail_data_fd = fd;

state->mail_data_output = o_stream_create_fd_file(fd, 0, FALSE);

o_stream_set_name(state->mail_data_output, str_c(path));

o_stream_cork(state->mail_data_output);