Adding upstream version 1:2.3.21+dfsg1.upstream/1%2.3.21+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 876 insertions, 0 deletions

diff --git a/src/lib-smtp/smtp-server-reply.c b/src/lib-smtp/smtp-server-reply.c
new file mode 100644
index 0000000..60342db
--- /dev/null
+++ b/src/lib-smtp/smtp-server-reply.c
@@ -0,0 +1,876 @@
+/* Copyright (c) 2013-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "str.h"
+#include "array.h"
+#include "istream.h"
+#include "ostream.h"
+#include "smtp-address.h"
+#include "smtp-reply.h"
+
+#include "smtp-server-private.h"
+
+/*
+ * Reply
+ */
+
+static void smtp_server_reply_destroy(struct smtp_server_reply *reply)
+{
+	if (reply->command == NULL)
+		return;
+
+	if (reply->event != NULL) {
+		e_debug(reply->event, "Destroy");
+		event_unref(&reply->event);
+	}
+
+	if (reply->content == NULL)
+		return;
+	str_free(&reply->content->text);
+}
+
+static void smtp_server_reply_clear(struct smtp_server_reply *reply)
+{
+	smtp_server_reply_destroy(reply);
+	if (reply->submitted) {
+		i_assert(reply->command->replies_submitted > 0);
+		reply->command->replies_submitted--;
+	}
+	reply->submitted = FALSE;
+	reply->forwarded = FALSE;
+}
+
+static void smtp_server_reply_update_event(struct smtp_server_reply *reply)
+{
+	struct smtp_server_command *command = reply->command;
+
+	event_add_int(reply->event, "index", reply->index);
+	event_add_int(reply->event, "status", reply->content->status);
+
+	if (command->replies_expected > 1) {
+		event_set_append_log_prefix(reply->event,
+			t_strdup_printf("%u reply [%u/%u]: ",
+					reply->content->status,
+					reply->index+1,
+					command->replies_expected));
+	} else {
+		event_set_append_log_prefix(reply->event,
+			t_strdup_printf("%u reply: ",
+					reply->content->status));
+	}
+}
+
+static struct smtp_server_reply *
+smtp_server_reply_alloc(struct smtp_server_command *cmd, unsigned int index)
+{
+	struct smtp_server_reply *reply;
+	pool_t pool = cmd->context.pool;
+
+	if (array_is_created(&cmd->replies)) {
+		reply = array_idx_modifiable(&cmd->replies, index);
+		/* get rid of any existing reply */
+		i_assert(!reply->sent);
+		smtp_server_reply_clear(reply);
+	} else {
+		p_array_init(&cmd->replies, pool, cmd->replies_expected);
+		array_idx_clear(&cmd->replies, cmd->replies_expected - 1);
+		reply = array_idx_modifiable(&cmd->replies, index);
+	}
+	reply->event = event_create(cmd->context.event);
+
+	return reply;
+}
+
+static void
+smtp_server_reply_update_prefix(struct smtp_server_reply *reply,
+				unsigned int status, const char *enh_code)
+{
+	pool_t pool = reply->command->context.pool;
+	string_t *textbuf, *new_text;
+	const char *new_prefix, *text, *p;
+	size_t text_len, prefix_len, line_len;
+
+	if (enh_code == NULL || *enh_code == '\0') {
+		new_prefix = p_strdup_printf(pool, "%03u-", status);
+	} else {
+		new_prefix = p_strdup_printf(pool, "%03u-%s ",
+					     status, enh_code);
+	}
+
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+
+	if (textbuf == NULL || str_len(textbuf) == 0) {
+		reply->content->status_prefix = new_prefix;
+		return;
+	}
+	new_text = str_new(default_pool, 256);
+
+	prefix_len = strlen(reply->content->status_prefix);
+	text = str_c(textbuf);
+	text_len = str_len(textbuf);
+
+	i_assert(text_len > prefix_len);
+	text_len -= prefix_len;
+	text += prefix_len;
+
+	for (;;) {
+		reply->content->last_line = str_len(new_text);
+
+		p = strchr(text, '\n');
+		i_assert(p != NULL && p > text && *(p-1) == '\r');
+		p++;
+
+		str_append(new_text, new_prefix);
+		str_append_data(new_text, text, p - text);
+
+		line_len = (size_t)(p - text);
+		i_assert(text_len >= line_len);
+		text_len -= line_len;
+		text = p;
+
+		if (text_len <= prefix_len)
+			break;
+
+		text_len -= prefix_len;
+		text += prefix_len;
+	}
+
+	str_free(&textbuf);
+	reply->content->text = new_text;
+	reply->content->status_prefix = new_prefix;
+}
+
+void smtp_server_reply_set_status(struct smtp_server_reply *reply,
+				  unsigned int status, const char *enh_code)
+{
+	pool_t pool = reply->command->context.pool;
+
+	/* RFC 5321, Section 4.2:
+
+	   In the absence of extensions negotiated with the client, SMTP servers
+	   MUST NOT send reply codes whose first digits are other than 2, 3, 4,
+	   or 5.  Clients that receive such out-of-range codes SHOULD normally
+	   treat them as fatal errors and terminate the mail transaction.
+	 */
+	i_assert(status >= 200 && status < 560);
+
+	/* RFC 2034, Section 4:
+
+	   All status codes returned by the server must agree with the primary
+	   response code, that is, a 2xx response must incorporate a 2.X.X code,
+	   a 4xx response must incorporate a 4.X.X code, and a 5xx response must
+	   incorporate a 5.X.X code.
+	 */
+	i_assert(enh_code == NULL || *enh_code == '\0' ||
+		((unsigned int)(enh_code[0] - '0') == (status / 100)
+			&& enh_code[1] == '.'));
+
+	if (reply->content->status == status &&
+	    null_strcmp(reply->content->enhanced_code, enh_code) == 0)
+		return;
+
+	smtp_server_reply_update_prefix(reply, status, enh_code);
+	reply->content->status = status;
+	reply->content->enhanced_code = p_strdup(pool, enh_code);
+}
+
+unsigned int smtp_server_reply_get_status(struct smtp_server_reply *reply,
+					  const char **enh_code_r)
+{
+	if (enh_code_r != NULL)
+		*enh_code_r = reply->content->enhanced_code;
+	return reply->content->status;
+}
+
+struct smtp_server_reply *
+smtp_server_reply_create_index(struct smtp_server_command *cmd,
+			       unsigned int index, unsigned int status,
+			       const char *enh_code)
+{
+	struct smtp_server_reply *reply;
+	pool_t pool = cmd->context.pool;
+
+	i_assert(cmd->replies_expected > 0);
+	i_assert(index < cmd->replies_expected);
+
+	reply = smtp_server_reply_alloc(cmd, index);
+	reply->index = index;
+	reply->command = cmd;
+
+	if (reply->content == NULL)
+		reply->content = p_new(pool, struct smtp_server_reply_content, 1);
+	smtp_server_reply_set_status(reply, status, enh_code);
+	reply->content->text = str_new(default_pool, 256);
+
+	smtp_server_reply_update_event(reply);
+
+	return reply;
+}
+
+struct smtp_server_reply *
+smtp_server_reply_create(struct smtp_server_command *cmd,
+			 unsigned int status, const char *enh_code)
+{
+	return smtp_server_reply_create_index(cmd, 0, status, enh_code);
+}
+
+struct smtp_server_reply *
+smtp_server_reply_create_forward(struct smtp_server_command *cmd,
+	unsigned int index, const struct smtp_reply *from)
+{
+	struct smtp_server_reply *reply;
+	string_t *textbuf;
+	char *text;
+	size_t last_line, i;
+
+	reply = smtp_server_reply_create_index(cmd, index,
+		from->status, smtp_reply_get_enh_code(from));
+	smtp_reply_write(reply->content->text, from);
+
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+	text = str_c_modifiable(textbuf);
+
+	/* Find the last line */
+	reply->content->last_line = last_line = 0;
+	for (i = 0; i < str_len(textbuf); i++) {
+		if (text[i] == '\n') {
+			reply->content->last_line = last_line;
+			last_line = i + 1;
+		}
+	}
+
+	/* Make this reply suitable for further amendment with
+	   smtp_server_reply_add_text() */
+	if ((reply->content->last_line + 3) < str_len(textbuf)) {
+		i_assert(text[reply->content->last_line + 3] == ' ');
+		text[reply->content->last_line + 3] = '-';
+	} else {
+		str_append_c(textbuf, '-');
+	}
+
+	reply->forwarded = TRUE;
+
+	return reply;
+}
+
+void smtp_server_reply_free(struct smtp_server_command *cmd)
+{
+	unsigned int i;
+
+	if (!array_is_created(&cmd->replies))
+		return;
+
+	for (i = 0; i < cmd->replies_expected; i++) {
+		struct smtp_server_reply *reply =
+			array_idx_modifiable(&cmd->replies, i);
+		smtp_server_reply_destroy(reply);
+	}
+}
+
+void smtp_server_reply_add_text(struct smtp_server_reply *reply,
+				const char *text)
+{
+	string_t *textbuf = reply->content->text;
+
+	i_assert(!reply->submitted);
+
+	if (*text == '\0')
+		return;
+
+	do {
+		const char *p;
+
+		reply->content->last_line = str_len(textbuf);
+
+		p = strchr(text, '\n');
+		str_append(textbuf, reply->content->status_prefix);
+		if (p == NULL) {
+			str_append(textbuf, text);
+			text = NULL;
+		} else {
+			if (p > text && *(p-1) == '\r')
+				str_append_data(textbuf, text, p - text - 1);
+			else
+				str_append_data(textbuf, text, p - text);
+			text = p + 1;
+		}
+		str_append(textbuf, "\r\n");
+	} while (text != NULL && *text != '\0');
+}
+
+static size_t
+smtp_server_reply_get_path_len(struct smtp_server_reply *reply)
+{
+	size_t prefix_len = strlen(reply->content->status_prefix);
+	size_t text_len = str_len(reply->content->text), line_len, path_len;
+	const char *text = str_c(reply->content->text);
+	const char *text_end = text + text_len, *line_end;
+
+	i_assert(prefix_len <= text_len);
+
+	line_end = strchr(text, '\r');
+	if (line_end == NULL) {
+		line_end = text_end;
+		line_len = text_len;
+	} else {
+		i_assert(line_end + 1 < text_end);
+		i_assert(*(line_end + 1) == '\n');
+		line_len = line_end - text;
+	}
+
+	if (prefix_len == line_len || text[prefix_len] != '<') {
+		path_len = 0;
+	} else {
+		const char *path_begin = &text[prefix_len], *path_end;
+
+		path_end = strchr(path_begin, '>');
+		if (path_end == NULL || path_end > line_end)
+			path_len = 0;
+		else {
+			i_assert(path_end < line_end);
+			path_end++;
+			path_len = path_end - path_begin;
+			if (path_end < line_end && *path_end != ' ')
+				path_len = 0;
+		}
+	}
+
+	i_assert(prefix_len + path_len <= text_len);
+	return path_len;
+}
+
+void smtp_server_reply_prepend_text(struct smtp_server_reply *reply,
+				    const char *text_prefix)
+{
+	const char *text = str_c(reply->content->text);
+	size_t tlen = str_len(reply->content->text), offset;
+
+	i_assert(!reply->sent);
+	i_assert(reply->content != NULL);
+	i_assert(reply->content->text != NULL);
+
+	offset = strlen(reply->content->status_prefix) +
+		smtp_server_reply_get_path_len(reply);
+	i_assert(offset < tlen);
+	if (text[offset] == ' ')
+		offset++;
+
+	str_insert(reply->content->text, offset, text_prefix);
+
+	if (reply->content->last_line > 0)
+		reply->content->last_line += strlen(text_prefix);
+}
+
+void smtp_server_reply_replace_path(struct smtp_server_reply *reply,
+				    struct smtp_address *path, bool add)
+{
+	size_t prefix_len, path_len;
+	const char *path_text;
+
+	i_assert(!reply->sent);
+	i_assert(reply->content != NULL);
+	i_assert(reply->content->text != NULL);
+
+	prefix_len = strlen(reply->content->status_prefix);
+	path_len = smtp_server_reply_get_path_len(reply);
+
+	if (path_len > 0) {
+		path_text = smtp_address_encode_path(path);
+		str_replace(reply->content->text, prefix_len, path_len,
+			    path_text);
+	} else if (add) {
+		path_text = t_strdup_printf(
+			"<%s> ", smtp_address_encode(path));
+		str_insert(reply->content->text, prefix_len, path_text);
+	}
+}
+
+void smtp_server_reply_submit(struct smtp_server_reply *reply)
+{
+	i_assert(!reply->submitted);
+	i_assert(reply->content != NULL);
+	i_assert(str_len(reply->content->text) >= 5);
+	e_debug(reply->event, "Submitted");
+
+	reply->command->replies_submitted++;
+	reply->submitted = TRUE;
+	smtp_server_command_submit_reply(reply->command);
+}
+
+void smtp_server_reply_submit_duplicate(struct smtp_server_cmd_ctx *_cmd,
+					unsigned int index,
+					unsigned int from_index)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+	struct smtp_server_reply *reply, *from_reply;
+
+	i_assert(cmd->replies_expected > 0);
+	i_assert(index < cmd->replies_expected);
+	i_assert(from_index < cmd->replies_expected);
+	i_assert(array_is_created(&cmd->replies));
+
+	from_reply = array_idx_modifiable(&cmd->replies, from_index);
+	i_assert(from_reply->content != NULL);
+	i_assert(from_reply->submitted);
+
+	reply = smtp_server_reply_alloc(cmd, index);
+	reply->index = index;
+	reply->command = cmd;
+	reply->content = from_reply->content;
+	smtp_server_reply_update_event(reply);
+
+	smtp_server_reply_submit(reply);
+}
+
+void smtp_server_reply_indexv(struct smtp_server_cmd_ctx *_cmd,
+	unsigned int index, unsigned int status, const char *enh_code,
+	const char *fmt, va_list args)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+	struct smtp_server_reply *reply;
+
+	reply = smtp_server_reply_create_index(cmd, index, status, enh_code);
+	smtp_server_reply_add_text(reply, t_strdup_vprintf(fmt, args));
+	smtp_server_reply_submit(reply);
+}
+
+void smtp_server_reply(struct smtp_server_cmd_ctx *_cmd,
+	unsigned int status, const char *enh_code, const char *fmt, ...)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+	va_list args;
+
+	i_assert(cmd->replies_expected <= 1);
+
+	va_start(args, fmt);
+	smtp_server_reply_indexv(_cmd, 0, status, enh_code, fmt, args);
+	va_end(args);
+}
+
+void smtp_server_reply_index(struct smtp_server_cmd_ctx *_cmd,
+	unsigned int index, unsigned int status, const char *enh_code,
+	const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	smtp_server_reply_indexv(_cmd, index, status, enh_code, fmt, args);
+	va_end(args);
+}
+
+void smtp_server_reply_index_forward(struct smtp_server_cmd_ctx *cmd,
+	unsigned int index, const struct smtp_reply *from)
+{
+	smtp_server_reply_submit(
+		smtp_server_reply_create_forward(cmd->cmd, index, from));
+}
+
+void smtp_server_reply_forward(struct smtp_server_cmd_ctx *_cmd,
+			       const struct smtp_reply *from)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+
+	i_assert(cmd->replies_expected <= 1);
+
+	smtp_server_reply_submit(
+		smtp_server_reply_create_forward(cmd, 0, from));
+}
+
+static void ATTR_FORMAT(4, 0)
+smtp_server_reply_allv(struct smtp_server_cmd_ctx *_cmd,
+		       unsigned int status, const char *enh_code,
+		       const char *fmt, va_list args)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+	struct smtp_server_reply *reply;
+	const char *text;
+	unsigned int first, i = 0;
+
+	/* find the first unsent reply */
+	if (array_is_created(&cmd->replies)) {
+		for (; i < cmd->replies_expected; i++) {
+			struct smtp_server_reply *reply =
+				array_idx_modifiable(&cmd->replies, i);
+			if (!reply->sent)
+				break;
+		}
+		i_assert (i < cmd->replies_expected);
+	}
+	first = i++;
+
+	/* compose the reply text */
+	text = t_strdup_vprintf(fmt, args);
+
+	/* submit the first remaining reply */
+	reply = smtp_server_reply_create_index(cmd, first, status, enh_code);
+	smtp_server_reply_add_text(reply, text);
+	smtp_server_reply_submit(reply);
+
+	/* duplicate the rest from it */
+	for (; i < cmd->replies_expected; i++)
+		smtp_server_reply_submit_duplicate(_cmd, i, first);
+}
+
+void smtp_server_reply_all(struct smtp_server_cmd_ctx *_cmd,
+			   unsigned int status, const char *enh_code,
+			   const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	smtp_server_reply_allv(_cmd, status, enh_code, fmt, args);
+	va_end(args);
+}
+
+void smtp_server_reply_early(struct smtp_server_cmd_ctx *_cmd,
+			     unsigned int status, const char *enh_code,
+			     const char *fmt, ...)
+{
+	va_list args;
+
+	_cmd->cmd->reply_early = TRUE;
+
+	va_start(args, fmt);
+	smtp_server_reply_allv(_cmd, status, enh_code, fmt, args);
+	va_end(args);
+}
+
+void smtp_server_reply_quit(struct smtp_server_cmd_ctx *_cmd)
+{
+	struct smtp_server_command *cmd = _cmd->cmd;
+	struct smtp_server_reply *reply;
+
+	reply = smtp_server_reply_create(cmd, 221, "2.0.0");
+	smtp_server_reply_add_text(reply, "Bye");
+	smtp_server_reply_submit(reply);
+}
+
+static void
+smtp_server_reply_write_one_line(const struct smtp_server_reply *reply,
+				 string_t *str, bool skip_status)
+{
+	string_t *textbuf;
+	const char *text, *p;
+	size_t text_len, prefix_len, line_len;
+
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+	i_assert(str_len(textbuf) > 0);
+
+	prefix_len = strlen(reply->content->status_prefix);
+	text = str_c(textbuf);
+	text_len = str_len(textbuf);
+
+	if (skip_status) {
+		i_assert(text_len > prefix_len);
+		text_len -= prefix_len;
+		text += prefix_len;
+	}
+
+	for (;;) {
+		p = strchr(text, '\n');
+		i_assert(p != NULL && p > text && *(p-1) == '\r');
+		str_append_data(str, text, p - text - 1);
+		line_len = (size_t)(p - text) + 1;
+		i_assert(text_len >= line_len);
+		text_len -= line_len;
+		text = p + 1;
+
+		if (text_len <= prefix_len)
+			break;
+
+		text_len -= prefix_len;
+		text += prefix_len;
+		str_append_c(str, ' ');
+	}
+}
+
+const char *
+smtp_server_reply_get_one_line(const struct smtp_server_reply *reply)
+{
+	string_t *str = t_str_new(256);
+
+	smtp_server_reply_write_one_line(reply, str, FALSE);
+	return str_c(str);
+}
+
+const char *
+smtp_server_reply_get_message(const struct smtp_server_reply *reply)
+{
+	string_t *str = t_str_new(256);
+
+	smtp_server_reply_write_one_line(reply, str, TRUE);
+	return str_c(str);
+}
+
+static int smtp_server_reply_send_real(struct smtp_server_reply *reply)
+{
+	struct smtp_server_command *cmd = reply->command;
+	struct smtp_server_connection *conn = cmd->context.conn;
+	struct ostream *output = conn->conn.output;
+	string_t *textbuf;
+	char *text;
+	int ret = 0;
+
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+	i_assert(str_len(textbuf) > 0);
+
+	/* substitute '-' with ' ' in last line */
+	text = str_c_modifiable(textbuf);
+	text = text + reply->content->last_line + 3;
+	if (text[0] != ' ') {
+		i_assert(text[0] == '-');
+		text[0] = ' ';
+	}
+
+	if (o_stream_send(output, str_data(textbuf), str_len(textbuf)) < 0) {
+		e_debug(reply->event, "Send failed: %s",
+			o_stream_get_disconnect_reason(output));
+		smtp_server_connection_handle_output_error(conn);
+		return -1;
+	}
+
+	e_debug(reply->event, "Sent: %s",
+		smtp_server_reply_get_one_line(reply));
+	return ret;
+}
+
+int smtp_server_reply_send(struct smtp_server_reply *reply)
+{
+	int ret;
+
+	if (reply->sent)
+		return 0;
+
+	T_BEGIN {
+		ret = smtp_server_reply_send_real(reply);
+	} T_END;
+
+	reply->sent = TRUE;
+	return ret;
+}
+
+bool smtp_server_reply_is_success(const struct smtp_server_reply *reply)
+{
+	i_assert(reply->content != NULL);
+	return (reply->content->status / 100 == 2);
+}
+
+void smtp_server_reply_add_to_event(const struct smtp_server_reply *reply,
+				    struct event_passthrough *e)
+{
+	i_assert(reply->content != NULL);
+	e->add_int("status_code", reply->content->status);
+	if (reply->content->enhanced_code != NULL &&
+	    reply->content->enhanced_code[0] != '\0')
+		e->add_str("enhanced_code", reply->content->enhanced_code);
+	if (!smtp_server_reply_is_success(reply))
+		e->add_str("error", smtp_server_reply_get_message(reply));
+}
+
+/*
+ * EHLO reply
+ */
+
+struct smtp_server_reply *
+smtp_server_reply_create_ehlo(struct smtp_server_command *cmd)
+{
+	struct smtp_server_connection *conn = cmd->context.conn;
+	struct smtp_server_reply *reply;
+	string_t *textbuf;
+
+	reply = smtp_server_reply_create(cmd, 250, "");
+	textbuf = reply->content->text;
+	str_append(textbuf, reply->content->status_prefix);
+	str_append(textbuf, conn->set.hostname);
+	str_append(textbuf, "\r\n");
+
+	return reply;
+}
+
+void smtp_server_reply_ehlo_add(struct smtp_server_reply *reply,
+				const char *keyword)
+{
+	string_t *textbuf;
+
+	i_assert(!reply->submitted);
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+
+	reply->content->last_line = str_len(textbuf);
+	str_append(textbuf, reply->content->status_prefix);
+	str_append(textbuf, keyword);
+	str_append(textbuf, "\r\n");
+}
+
+void smtp_server_reply_ehlo_add_param(struct smtp_server_reply *reply,
+	const char *keyword, const char *param_fmt, ...)
+{
+	va_list args;
+	string_t *textbuf;
+
+	i_assert(!reply->submitted);
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+
+	reply->content->last_line = str_len(textbuf);
+	str_append(textbuf, reply->content->status_prefix);
+	str_append(textbuf, keyword);
+	if (*param_fmt != '\0') {
+		va_start(args, param_fmt);
+		str_append_c(textbuf, ' ');
+		str_vprintfa(textbuf, param_fmt, args);
+		va_end(args);
+	}
+	str_append(textbuf, "\r\n");
+}
+
+void smtp_server_reply_ehlo_add_params(struct smtp_server_reply *reply,
+				       const char *keyword,
+				       const char *const *params)
+{
+	string_t *textbuf;
+
+	i_assert(!reply->submitted);
+	i_assert(reply->content != NULL);
+	textbuf = reply->content->text;
+
+	reply->content->last_line = str_len(textbuf);
+	str_append(textbuf, reply->content->status_prefix);
+	str_append(textbuf, keyword);
+	if (params != NULL) {
+		while (*params != NULL) {
+			str_append_c(textbuf, ' ');
+			str_append(textbuf, *params);
+			params++;
+		}
+	}
+	str_append(textbuf, "\r\n");
+}
+
+void smtp_server_reply_ehlo_add_8bitmime(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_8BITMIME) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "8BITMIME");
+}
+
+void smtp_server_reply_ehlo_add_binarymime(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_BINARYMIME) == 0 ||
+	    (caps & SMTP_CAPABILITY_CHUNKING) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "BINARYMIME");
+}
+
+void smtp_server_reply_ehlo_add_chunking(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_CHUNKING) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "CHUNKING");
+}
+
+void smtp_server_reply_ehlo_add_dsn(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_DSN) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "DSN");
+}
+
+void smtp_server_reply_ehlo_add_enhancedstatuscodes(
+	struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_ENHANCEDSTATUSCODES) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "ENHANCEDSTATUSCODES");
+}
+
+void smtp_server_reply_ehlo_add_pipelining(struct smtp_server_reply *reply)
+{
+	smtp_server_reply_ehlo_add(reply, "PIPELINING");
+}
+
+void smtp_server_reply_ehlo_add_size(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+	uoff_t cap_size = conn->set.max_message_size;
+
+	if ((caps & SMTP_CAPABILITY_SIZE) == 0)
+		return;
+
+	if (cap_size > 0 && cap_size != UOFF_T_MAX) {
+		smtp_server_reply_ehlo_add_param(reply,
+			"SIZE", "%"PRIuUOFF_T, cap_size);
+	} else {
+		smtp_server_reply_ehlo_add(reply, "SIZE");
+	}
+}
+
+void smtp_server_reply_ehlo_add_starttls(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_STARTTLS) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "STARTTLS");
+}
+
+void smtp_server_reply_ehlo_add_vrfy(struct smtp_server_reply *reply)
+{
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+	enum smtp_capability caps = conn->set.capabilities;
+
+	if ((caps & SMTP_CAPABILITY_VRFY) == 0)
+		return;
+	smtp_server_reply_ehlo_add(reply, "VRFY");
+}
+
+void smtp_server_reply_ehlo_add_xclient(struct smtp_server_reply *reply)
+{
+	static const char *base_fields =
+		"ADDR PORT PROTO HELO LOGIN SESSION TTL TIMEOUT";
+	struct smtp_server_cmd_ctx *cmd = &reply->command->context;
+	struct smtp_server_connection *conn = cmd->conn;
+
+	if (!smtp_server_connection_is_trusted(conn))
+		return;
+	if (conn->set.xclient_extensions == NULL ||
+	    *conn->set.xclient_extensions == NULL) {
+		smtp_server_reply_ehlo_add_param(reply, "XCLIENT", "%s",
+			base_fields);
+		return;
+	}
+
+	smtp_server_reply_ehlo_add_param(reply, "XCLIENT", "%s",
+		t_strconcat(base_fields, " ",
+			t_strarray_join(conn->set.xclient_extensions, " "),
+			NULL));
+}