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, 1096 insertions, 0 deletions

diff --git a/pigeonhole/src/lib-sieve/sieve-actions.c b/pigeonhole/src/lib-sieve/sieve-actions.c
new file mode 100644
index 0000000..86c9954
--- /dev/null
+++ b/pigeonhole/src/lib-sieve/sieve-actions.c
@@ -0,0 +1,1096 @@
+/* Copyright (c) 2002-2018 Pigeonhole authors, see the included COPYING file
+ */
+
+#include "lib.h"
+#include "str.h"
+#include "strfuncs.h"
+#include "ioloop.h"
+#include "hostpid.h"
+#include "str-sanitize.h"
+#include "unichar.h"
+#include "istream.h"
+#include "istream-header-filter.h"
+#include "ostream.h"
+#include "smtp-params.h"
+#include "mail-storage.h"
+#include "message-date.h"
+#include "message-size.h"
+
+#include "rfc2822.h"
+
+#include "sieve-code.h"
+#include "sieve-settings.h"
+#include "sieve-extensions.h"
+#include "sieve-binary.h"
+#include "sieve-interpreter.h"
+#include "sieve-dump.h"
+#include "sieve-result.h"
+#include "sieve-actions.h"
+#include "sieve-message.h"
+#include "sieve-smtp.h"
+
+/*
+ * Action execution environment
+ */
+
+struct event_passthrough *
+sieve_action_create_finish_event(const struct sieve_action_exec_env *aenv)
+{
+	struct event_passthrough *e =
+		event_create_passthrough(aenv->event)->
+		set_name("sieve_action_finished");
+
+	return e;
+}
+
+/*
+ * Action instance
+ */
+
+bool sieve_action_is_executed(const struct sieve_action *act,
+			      struct sieve_result *result)
+{
+	unsigned int cur_exec_seq = sieve_result_get_exec_seq(result);
+
+	i_assert(act->exec_seq <= cur_exec_seq);
+	return (act->exec_seq < cur_exec_seq);
+}
+
+/*
+ * Side-effect operand
+ */
+
+const struct sieve_operand_class
+sieve_side_effect_operand_class = { "SIDE-EFFECT" };
+
+bool sieve_opr_side_effect_dump(const struct sieve_dumptime_env *denv,
+				sieve_size_t *address)
+{
+	struct sieve_side_effect seffect;
+	const struct sieve_side_effect_def *sdef;
+
+	if (!sieve_opr_object_dump(denv, &sieve_side_effect_operand_class,
+				   address, &seffect.object))
+		return FALSE;
+
+	sdef = seffect.def =
+		(const struct sieve_side_effect_def *)seffect.object.def;
+
+	if (sdef->dump_context != NULL) {
+		sieve_code_descend(denv);
+		if (!sdef->dump_context(&seffect, denv, address))
+			return FALSE;
+		sieve_code_ascend(denv);
+	}
+	return TRUE;
+}
+
+int sieve_opr_side_effect_read(const struct sieve_runtime_env *renv,
+			       sieve_size_t *address,
+			       struct sieve_side_effect *seffect)
+{
+	const struct sieve_side_effect_def *sdef;
+	int ret;
+
+	seffect->context = NULL;
+
+	if (!sieve_opr_object_read(renv, &sieve_side_effect_operand_class,
+				   address, &seffect->object))
+		return SIEVE_EXEC_BIN_CORRUPT;
+
+	sdef = seffect->def =
+		(const struct sieve_side_effect_def *)seffect->object.def;
+
+	if (sdef->read_context != NULL &&
+	    (ret = sdef->read_context(seffect, renv, address,
+				      &seffect->context)) <= 0)
+		return ret;
+	return SIEVE_EXEC_OK;
+}
+
+/*
+ * Optional operands
+ */
+
+int sieve_action_opr_optional_dump(const struct sieve_dumptime_env *denv,
+				   sieve_size_t *address, signed int *opt_code)
+{
+	signed int _opt_code = 0;
+	bool final = FALSE, opok = TRUE;
+
+	if (opt_code == NULL) {
+		opt_code = &_opt_code;
+		final = TRUE;
+	}
+
+	while (opok) {
+		int opt;
+
+		opt = sieve_opr_optional_dump(denv, address, opt_code);
+		if (opt <= 0)
+			return opt;
+
+		if (*opt_code == SIEVE_OPT_SIDE_EFFECT)
+			opok = sieve_opr_side_effect_dump(denv, address);
+		else
+			return (final ? -1 : 1);
+	}
+
+	return -1;
+}
+
+int sieve_action_opr_optional_read(const struct sieve_runtime_env *renv,
+				   sieve_size_t *address,
+				   signed int *opt_code, int *exec_status,
+				   struct sieve_side_effects_list **list)
+{
+	signed int _opt_code = 0;
+	bool final = FALSE;
+	int ret;
+
+	if (opt_code == NULL) {
+		opt_code = &_opt_code;
+		final = TRUE;
+	}
+
+	if (exec_status != NULL)
+		*exec_status = SIEVE_EXEC_OK;
+
+	for (;;) {
+		int opt;
+
+		opt = sieve_opr_optional_read(renv, address, opt_code);
+		if (opt <= 0) {
+			if (opt < 0 && exec_status != NULL)
+				*exec_status = SIEVE_EXEC_BIN_CORRUPT;
+			return opt;
+		}
+
+		if (*opt_code == SIEVE_OPT_SIDE_EFFECT) {
+			struct sieve_side_effect seffect;
+
+			i_assert(list != NULL);
+
+			ret = sieve_opr_side_effect_read(renv, address,
+							 &seffect);
+			if (ret <= 0) {
+				if (exec_status != NULL)
+					*exec_status = ret;
+				return -1;
+			}
+
+			if (*list == NULL) {
+				*list = sieve_side_effects_list_create(
+					renv->result);
+			}
+
+			sieve_side_effects_list_add(*list, &seffect);
+		} else {
+			if (final) {
+				sieve_runtime_trace_error(
+					renv, "invalid optional operand");
+				if (exec_status != NULL)
+					*exec_status = SIEVE_EXEC_BIN_CORRUPT;
+				return -1;
+			}
+			return 1;
+		}
+	}
+
+	i_unreached();
+	return -1;
+}
+
+/*
+ * Store action
+ */
+
+/* Forward declarations */
+
+static bool
+act_store_equals(const struct sieve_script_env *senv,
+		 const struct sieve_action *act1,
+		 const struct sieve_action *act2);
+
+static int
+act_store_check_duplicate(const struct sieve_runtime_env *renv,
+			  const struct sieve_action *act,
+			  const struct sieve_action *act_other);
+static void
+act_store_print(const struct sieve_action *action,
+		const struct sieve_result_print_env *rpenv, bool *keep);
+
+static int
+act_store_start(const struct sieve_action_exec_env *aenv, void **tr_context);
+static int
+act_store_execute(const struct sieve_action_exec_env *aenv, void *tr_context,
+		  bool *keep);
+static int
+act_store_commit(const struct sieve_action_exec_env *aenv, void *tr_context);
+static void
+act_store_rollback(const struct sieve_action_exec_env *aenv, void *tr_context,
+		   bool success);
+
+/* Action object */
+
+const struct sieve_action_def act_store = {
+	.name = "store",
+	.flags =
+		SIEVE_ACTFLAG_TRIES_DELIVER | 
+		SIEVE_ACTFLAG_MAIL_STORAGE,
+	.equals = act_store_equals,
+	.check_duplicate = act_store_check_duplicate,
+	.print = act_store_print,
+	.start = act_store_start,
+	.execute = act_store_execute,
+	.commit = act_store_commit,
+	.rollback = act_store_rollback,
+};
+
+/* API */
+
+int sieve_act_store_add_to_result(const struct sieve_runtime_env *renv,
+				  const char *name,
+				  struct sieve_side_effects_list *seffects,
+				  const char *mailbox)
+{
+	pool_t pool;
+	struct act_store_context *act;
+
+	/* Add redirect action to the result */
+	pool = sieve_result_pool(renv->result);
+	act = p_new(pool, struct act_store_context, 1);
+	act->mailbox = p_strdup(pool, mailbox);
+
+	return sieve_result_add_action(renv, NULL, name, &act_store, seffects,
+				       (void *)act, 0, TRUE);
+}
+
+void sieve_act_store_add_flags(const struct sieve_action_exec_env *aenv,
+			       void *tr_context, const char *const *keywords,
+			       enum mail_flags flags)
+{
+	struct act_store_transaction *trans =
+		(struct act_store_transaction *)tr_context;
+
+	i_assert(trans != NULL);
+
+	/* Assign mail keywords for subsequent mailbox_copy() */
+	if (*keywords != NULL) {
+		const char *const *kw;
+
+		if (!array_is_created(&trans->keywords)) {
+			pool_t pool = sieve_result_pool(aenv->result);
+			p_array_init(&trans->keywords, pool, 2);
+		}
+
+		kw = keywords;
+		while (*kw != NULL) {
+			array_append(&trans->keywords, kw, 1);
+			kw++;
+		}
+	}
+
+	/* Assign mail flags for subsequent mailbox_copy() */
+	trans->flags |= flags;
+
+	trans->flags_altered = TRUE;
+}
+
+/* Equality */
+
+static bool
+act_store_equals(const struct sieve_script_env *senv,
+		 const struct sieve_action *act1,
+		 const struct sieve_action *act2)
+{
+	struct act_store_context *st_ctx1 =
+		(act1 == NULL ?
+		 NULL : (struct act_store_context *)act1->context);
+	struct act_store_context *st_ctx2 =
+		(act2 == NULL ?
+		 NULL : (struct act_store_context *)act2->context);
+	const char *mailbox1, *mailbox2;
+
+	/* FIXME: consider namespace aliases */
+
+	if (st_ctx1 == NULL && st_ctx2 == NULL)
+		return TRUE;
+
+	mailbox1 = (st_ctx1 == NULL ?
+		    SIEVE_SCRIPT_DEFAULT_MAILBOX(senv) : st_ctx1->mailbox);
+	mailbox2 = (st_ctx2 == NULL ?
+		    SIEVE_SCRIPT_DEFAULT_MAILBOX(senv) : st_ctx2->mailbox);
+
+	if (strcmp(mailbox1, mailbox2) == 0)
+		return TRUE;
+
+	return (strcasecmp(mailbox1, "INBOX") == 0 &&
+		strcasecmp(mailbox2, "INBOX") == 0);
+}
+
+/* Result verification */
+
+static int
+act_store_check_duplicate(const struct sieve_runtime_env *renv,
+			  const struct sieve_action *act,
+			  const struct sieve_action *act_other)
+{
+	const struct sieve_execute_env *eenv = renv->exec_env;
+
+	return (act_store_equals(eenv->scriptenv, act, act_other) ? 1 : 0);
+}
+
+/* Result printing */
+
+static void
+act_store_print(const struct sieve_action *action,
+		const struct sieve_result_print_env *rpenv, bool *keep)
+{
+	struct act_store_context *ctx =
+		(struct act_store_context *)action->context;
+	const char *mailbox;
+
+	mailbox = (ctx == NULL ?
+		   SIEVE_SCRIPT_DEFAULT_MAILBOX(rpenv->scriptenv) :
+			ctx->mailbox);
+
+	sieve_result_action_printf(rpenv, "store message in folder: %s",
+				   str_sanitize(mailbox, 128));
+
+	*keep = FALSE;
+}
+
+/* Action implementation */
+
+void sieve_act_store_get_storage_error(const struct sieve_action_exec_env *aenv,
+				       struct act_store_transaction *trans)
+{
+	pool_t pool = sieve_result_pool(aenv->result);
+
+	trans->error = p_strdup(pool,
+		mailbox_get_last_internal_error(trans->box,
+						&trans->error_code));
+}
+
+static bool
+act_store_mailbox_alloc(const struct sieve_action_exec_env *aenv,
+		        const char *mailbox, struct mailbox **box_r,
+			enum mail_error *error_code_r, const char **error_r)
+{
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	struct mailbox *box;
+	struct mail_storage **storage = &(eenv->exec_status->last_storage);
+	enum mailbox_flags flags = MAILBOX_FLAG_POST_SESSION;
+
+	*box_r = NULL;
+	*error_code_r = MAIL_ERROR_NONE;
+	*error_r = NULL;
+
+	if (!uni_utf8_str_is_valid(mailbox)) {
+		/* Just a precaution; already (supposed to be) checked at
+		   compiletime/runtime.
+		 */
+		*error_r = t_strdup_printf("mailbox name not utf-8: %s",
+					   mailbox);
+		*error_code_r = MAIL_ERROR_PARAMS;
+		return FALSE;
+	}
+
+	if (eenv->scriptenv->mailbox_autocreate)
+		flags |= MAILBOX_FLAG_AUTO_CREATE;
+	if (eenv->scriptenv->mailbox_autosubscribe)
+		flags |= MAILBOX_FLAG_AUTO_SUBSCRIBE;
+	*box_r = box = mailbox_alloc_for_user(eenv->scriptenv->user, mailbox,
+					      flags);
+	*storage = mailbox_get_storage(box);
+
+	return TRUE;
+}
+
+static int
+act_store_start(const struct sieve_action_exec_env *aenv, void **tr_context)
+{
+	const struct sieve_action *action = aenv->action;
+	struct act_store_context *ctx =
+		(struct act_store_context *)action->context;
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	const struct sieve_script_env *senv = eenv->scriptenv;
+	struct act_store_transaction *trans;
+	struct mailbox *box = NULL;
+	pool_t pool = sieve_result_pool(aenv->result);
+	const char *error = NULL;
+	enum mail_error error_code = MAIL_ERROR_NONE;
+	bool disabled = FALSE, alloc_failed = FALSE;
+
+	/* If context is NULL, the store action is the result of (implicit)
+	   keep.
+	 */
+	if (ctx == NULL) {
+		ctx = p_new(pool, struct act_store_context, 1);
+		ctx->mailbox =
+			p_strdup(pool, SIEVE_SCRIPT_DEFAULT_MAILBOX(senv));
+	}
+
+	e_debug(aenv->event, "Start storing into mailbox %s", ctx->mailbox);
+
+	/* Open the requested mailbox */
+
+	/* NOTE: The caller of the sieve library is allowed to leave user set
+	   to NULL. This implementation will then skip actually storing the
+	   message.
+	 */
+	if (senv->user != NULL) {
+		if (!act_store_mailbox_alloc(aenv, ctx->mailbox, &box,
+					     &error_code, &error))
+			alloc_failed = TRUE;
+	} else {
+		disabled = TRUE;
+	}
+
+	/* Create transaction context */
+	trans = p_new(pool, struct act_store_transaction, 1);
+
+	trans->context = ctx;
+	trans->box = box;
+	trans->flags = 0;
+
+	trans->mailbox_name = ctx->mailbox;
+	trans->mailbox_identifier =
+		p_strdup_printf(pool, "'%s'", str_sanitize(ctx->mailbox, 256));
+
+	trans->disabled = disabled;
+
+	if (alloc_failed) {
+		trans->error = p_strdup(pool, error);
+		trans->error_code = error_code;
+		e_debug(aenv->event, "Failed to open mailbox %s: %s",
+			trans->mailbox_identifier, trans->error);
+	} else {
+		trans->error_code = MAIL_ERROR_NONE;
+	}
+
+	*tr_context = (void *)trans;
+
+	switch (trans->error_code) {
+	case MAIL_ERROR_NONE:
+	case MAIL_ERROR_NOTFOUND:
+		return SIEVE_EXEC_OK;
+	case MAIL_ERROR_TEMP:
+		return SIEVE_EXEC_TEMP_FAILURE;
+	default:
+		break;
+	}
+	return SIEVE_EXEC_FAILURE;
+}
+
+static struct mail_keywords *
+act_store_keywords_create(const struct sieve_action_exec_env *aenv,
+			  ARRAY_TYPE(const_string) *keywords,
+			  struct mailbox *box, bool create_empty)
+{
+	struct mail_keywords *box_keywords = NULL;
+	const char *const *kwds = NULL;
+
+	if (!array_is_created(keywords) || array_count(keywords) == 0) {
+		if (!create_empty)
+			return NULL;
+	} else {
+		ARRAY_TYPE(const_string) valid_keywords;
+		const char *error;
+		unsigned int count, i;
+
+		kwds = array_get(keywords, &count);
+		t_array_init(&valid_keywords, count);
+
+		for (i = 0; i < count; i++) {
+			if (mailbox_keyword_is_valid(box, kwds[i], &error)) {
+				array_append(&valid_keywords, &kwds[i], 1);
+				continue;
+			}
+
+			sieve_result_warning(aenv,
+				"specified IMAP keyword '%s' is invalid "
+				"(ignored): %s",  str_sanitize(kwds[i], 64),
+				sieve_error_from_external(error));
+		}
+
+		array_append_zero(keywords);
+		kwds = array_idx(keywords, 0);
+	}
+
+	if (mailbox_keywords_create(box, kwds, &box_keywords) < 0) {
+		sieve_result_error(
+			aenv, "invalid keywords set for stored message");
+		return NULL;
+	}
+
+	return box_keywords;
+}
+
+static bool have_equal_keywords(struct mail *mail, struct mail_keywords *new_kw)
+{
+	const ARRAY_TYPE(keyword_indexes) *old_kw_arr =
+		mail_get_keyword_indexes(mail);
+	const unsigned int *old_kw;
+	unsigned int i, j;
+
+	if (array_count(old_kw_arr) != new_kw->count)
+		return FALSE;
+	if (new_kw->count == 0)
+		return TRUE;
+
+	old_kw = array_front(old_kw_arr);
+	for (i = 0; i < new_kw->count; i++) {
+		/* new_kw->count equals old_kw's count and it's easier to use */
+		for (j = 0; j < new_kw->count; j++) {
+			if (old_kw[j] == new_kw->idx[i])
+				break;
+		}
+		if (j == new_kw->count)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static int
+act_store_execute(const struct sieve_action_exec_env *aenv, void *tr_context,
+		  bool *keep)
+{
+	const struct sieve_action *action = aenv->action;
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	struct act_store_transaction *trans =
+		(struct act_store_transaction *)tr_context;
+	struct mail *mail = (action->mail != NULL ?
+			     action->mail : eenv->msgdata->mail);
+	struct mail_save_context *save_ctx;
+	struct mail_keywords *keywords = NULL;
+	struct mailbox *box;
+	bool backends_equal = FALSE;
+	int status = SIEVE_EXEC_OK;
+
+	/* Verify transaction */
+	if (trans == NULL)
+		return SIEVE_EXEC_FAILURE;
+	box = trans->box;
+
+	/* Check whether we need to do anything */
+	if (trans->disabled) {
+		e_debug(aenv->event, "Skip storing into mailbox %s",
+			trans->mailbox_identifier);
+		*keep = FALSE;
+		return SIEVE_EXEC_OK;
+	}
+
+	/* Exit early if mailbox is not available */
+	if (box == NULL)
+		return SIEVE_EXEC_FAILURE;
+
+	e_debug(aenv->event, "Execute storing into mailbox %s",
+		trans->mailbox_identifier);
+
+	/* Mark attempt to use storage. Can only get here when all previous
+	   actions succeeded.
+	 */
+	eenv->exec_status->last_storage = mailbox_get_storage(box);
+
+	/* Open the mailbox (may already be open) */
+	if (trans->error_code == MAIL_ERROR_NONE) {
+		if (mailbox_open(box) < 0) {
+			sieve_act_store_get_storage_error(aenv, trans);
+			e_debug(aenv->event, "Failed to open mailbox %s: %s",
+				trans->mailbox_identifier, trans->error);
+		}
+	}
+
+	/* Exit early if transaction already failed */
+ 	switch (trans->error_code) {
+	case MAIL_ERROR_NONE:
+		break;
+	case MAIL_ERROR_TEMP:
+		return SIEVE_EXEC_TEMP_FAILURE;
+	default:
+		return SIEVE_EXEC_FAILURE;
+	}
+
+	/* If the message originates from the target mailbox, only update the
+	   flags and keywords (if not read-only)
+	 */
+	if (mailbox_backends_equal(box, mail->box)) {
+		backends_equal = TRUE;
+	} else {
+		struct mail *real_mail;
+
+		if (mail_get_backend_mail(mail, &real_mail) < 0)
+			return SIEVE_EXEC_FAILURE;
+		if (real_mail != mail &&
+		    mailbox_backends_equal(box, real_mail->box))
+			backends_equal = TRUE;
+	}
+	if (backends_equal) {
+		trans->redundant = TRUE;
+
+		if (trans->flags_altered && !mailbox_is_readonly(mail->box)) {
+			keywords = act_store_keywords_create(
+				aenv, &trans->keywords, mail->box, TRUE);
+
+			if (keywords != NULL) {
+				if (!have_equal_keywords(mail, keywords)) {
+					eenv->exec_status->significant_action_executed = TRUE;
+					mail_update_keywords(mail, MODIFY_REPLACE, keywords);
+				}
+				mailbox_keywords_unref(&keywords);
+			}
+
+			if ((mail_get_flags(mail) & MAIL_FLAGS_NONRECENT) != trans->flags) {
+				eenv->exec_status->significant_action_executed = TRUE;
+				mail_update_flags(mail, MODIFY_REPLACE, trans->flags);
+			}
+		}
+		e_debug(aenv->event, "Updated existing mail in mailbox %s",
+			trans->mailbox_identifier);
+		return SIEVE_EXEC_OK;
+
+	/* If the message is modified, only store it in the source mailbox when
+	   it is not opened read-only. Mail structs of modified messages have
+	   their own mailbox, unrelated to the orignal mail, so this case needs
+	   to be handled separately.
+	 */
+	} else if (mail != eenv->msgdata->mail &&
+		   mailbox_is_readonly(eenv->msgdata->mail->box) &&
+		   (mailbox_backends_equal(box, eenv->msgdata->mail->box))) {
+		e_debug(aenv->event,
+			"Not modifying exsiting mail in read-only mailbox %s",
+			trans->mailbox_identifier);
+		trans->redundant = TRUE;
+		return SIEVE_EXEC_OK;
+	}
+
+	/* Mark attempt to store in default mailbox */
+	if (strcmp(trans->context->mailbox,
+		   SIEVE_SCRIPT_DEFAULT_MAILBOX(eenv->scriptenv)) == 0)
+		eenv->exec_status->tried_default_save = TRUE;
+
+	/* Start mail transaction */
+	trans->mail_trans = mailbox_transaction_begin(
+		box, MAILBOX_TRANSACTION_FLAG_EXTERNAL, __func__);
+
+	/* Store the message */
+	save_ctx = mailbox_save_alloc(trans->mail_trans);
+
+	/* Apply keywords and flags that side-effects may have added */
+	if (trans->flags_altered) {
+		keywords = act_store_keywords_create(aenv, &trans->keywords,
+						     box, FALSE);
+
+		if (trans->flags != 0 || keywords != NULL) {
+			eenv->exec_status->significant_action_executed = TRUE;
+			mailbox_save_set_flags(save_ctx, trans->flags, keywords);
+		}
+	} else {
+		mailbox_save_copy_flags(save_ctx, mail);
+	}
+
+	if (mailbox_save_using_mail(&save_ctx, mail) < 0) {
+		sieve_act_store_get_storage_error(aenv, trans);
+		e_debug(aenv->event, "Failed to save to mailbox %s: %s",
+			trans->mailbox_identifier, trans->error);
+
+		status = (trans->error_code == MAIL_ERROR_TEMP ?
+			  SIEVE_EXEC_TEMP_FAILURE : SIEVE_EXEC_FAILURE);
+	} else {
+		e_debug(aenv->event, "Saving to mailbox %s successful so far",
+			trans->mailbox_identifier);
+		eenv->exec_status->significant_action_executed = TRUE;
+	}
+
+	/* Deallocate keywords */
+ 	if (keywords != NULL)
+ 		mailbox_keywords_unref(&keywords);
+
+	/* Cancel implicit keep if all went well so far */
+	*keep = (status < SIEVE_EXEC_OK);
+
+	return status;
+}
+
+static void
+act_store_log_status(struct act_store_transaction *trans,
+		     const struct sieve_action_exec_env *aenv,
+		     bool rolled_back, bool status)
+{
+	const char *mailbox_name = trans->mailbox_name;
+	const char *mailbox_identifier = trans->mailbox_identifier;
+
+	if (trans->box != NULL) {
+		const char *mailbox_vname = str_sanitize(mailbox_get_vname(trans->box), 128);
+
+		if (strcmp(trans->mailbox_name, mailbox_vname) != 0) {
+			mailbox_identifier = t_strdup_printf(
+				"%s (%s)", mailbox_identifier,
+				str_sanitize(mailbox_vname, 256));
+		}
+	}
+
+	/* Store disabled? */
+	if (trans->disabled) {
+		sieve_result_global_log(aenv, "store into mailbox %s skipped",
+					mailbox_identifier);
+	/* Store redundant? */
+	} else if (trans->redundant) {
+		sieve_result_global_log(aenv, "left message in mailbox %s",
+					mailbox_identifier);
+	/* Store failed? */
+	} else if (!status) {
+		const char *errstr;
+		enum mail_error error_code;
+
+		if (trans->error == NULL)
+			sieve_act_store_get_storage_error(aenv, trans);
+
+		errstr = trans->error;
+		error_code = trans->error_code;
+
+		if (error_code == MAIL_ERROR_NOQUOTA) {
+			/* Never log quota problems as error in global log */
+			sieve_result_global_log_error(
+				aenv, "failed to store into mailbox %s: %s",
+				mailbox_identifier, errstr);
+		} else if (error_code == MAIL_ERROR_NOTFOUND ||
+			   error_code == MAIL_ERROR_PARAMS ||
+			   error_code == MAIL_ERROR_PERM) {
+			sieve_result_error(
+				aenv, "failed to store into mailbox %s: %s",
+				mailbox_identifier, errstr);
+		} else {
+			sieve_result_global_error(
+				aenv, "failed to store into mailbox %s: %s",
+				mailbox_identifier, errstr);
+		}
+	/* Store aborted? */
+	} else if (rolled_back) {
+		if (!aenv->action->keep) {
+			sieve_result_global_log(
+				aenv, "store into mailbox %s aborted",
+				mailbox_identifier);
+		} else {
+			e_debug(aenv->event, "Store into mailbox %s aborted",
+				mailbox_identifier);
+		}
+	/* Succeeded */
+	} else {
+		struct event_passthrough *e =
+			sieve_action_create_finish_event(aenv)->
+			add_str("fileinto_mailbox_name", mailbox_name)->
+			add_str("fileinto_mailbox", mailbox_identifier);
+		sieve_result_event_log(aenv, e->event(),
+				       "stored mail into mailbox %s",
+				       mailbox_identifier);
+	}
+}
+
+static void act_store_cleanup(struct act_store_transaction *trans)
+{
+	if (trans->mail_trans != NULL)
+		mailbox_transaction_rollback(&trans->mail_trans);
+	if (trans->box != NULL)
+		mailbox_free(&trans->box);
+}
+
+static int
+act_store_commit(const struct sieve_action_exec_env *aenv, void *tr_context)
+{
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	struct act_store_transaction *trans =
+		(struct act_store_transaction *)tr_context;
+	bool bail_out = FALSE, status = TRUE;
+	int ret = SIEVE_EXEC_OK;
+
+	/* Verify transaction */
+	if (trans == NULL)
+		return SIEVE_EXEC_FAILURE;
+
+	e_debug(aenv->event, "Commit storing into mailbox %s",
+		trans->mailbox_identifier);
+
+	/* Check whether we can commit this transaction */
+	if (trans->error_code != MAIL_ERROR_NONE) {
+		/* Transaction already failed */
+		bail_out = TRUE;
+		status = FALSE;
+		if (trans->error_code == MAIL_ERROR_TEMP)
+			ret = SIEVE_EXEC_TEMP_FAILURE;
+		else
+			ret = SIEVE_EXEC_FAILURE;
+	/* Check whether we need to do anything */
+	} else if (trans->disabled) {
+		/* Nothing to do */
+		bail_out = TRUE;
+	} else if (trans->redundant) {
+		/* This transaction is redundant */
+		bail_out = TRUE;
+		eenv->exec_status->keep_original = TRUE;
+		eenv->exec_status->message_saved = TRUE;
+	}
+	if (bail_out) {
+		act_store_log_status(trans, aenv, FALSE, status);
+		act_store_cleanup(trans);
+		return ret;
+	}
+
+	i_assert(trans->box != NULL);
+	i_assert(trans->mail_trans != NULL);
+
+	/* Mark attempt to use storage. Can only get here when all previous
+	   actions succeeded.
+	 */
+	eenv->exec_status->last_storage = mailbox_get_storage(trans->box);
+
+	/* Commit mailbox transaction */
+	status = (mailbox_transaction_commit(&trans->mail_trans) == 0);
+
+	/* Note the fact that the message was stored at least once */
+	if (status)
+		eenv->exec_status->message_saved = TRUE;
+	else
+		eenv->exec_status->store_failed = TRUE;
+
+	/* Log our status */
+	act_store_log_status(trans, aenv, FALSE, status);
+
+	/* Clean up */
+	act_store_cleanup(trans);
+
+	if (status)
+		return SIEVE_EXEC_OK;
+
+	return (trans->error_code == MAIL_ERROR_TEMP ?
+		SIEVE_EXEC_TEMP_FAILURE : SIEVE_EXEC_FAILURE);
+}
+
+static void
+act_store_rollback(const struct sieve_action_exec_env *aenv, void *tr_context,
+		   bool success)
+{
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	struct act_store_transaction *trans =
+		(struct act_store_transaction *)tr_context;
+
+	if (trans == NULL)
+		return;
+
+	e_debug(aenv->event, "Roll back storing into mailbox %s",
+		trans->mailbox_identifier);
+
+	i_assert(trans->box != NULL);
+
+	if (!success) {
+		eenv->exec_status->last_storage =
+			mailbox_get_storage(trans->box);
+		eenv->exec_status->store_failed = TRUE;
+	}
+
+	/* Log status */
+	act_store_log_status(trans, aenv, TRUE, success);
+
+	/* Rollback mailbox transaction and clean up */
+	act_store_cleanup(trans);
+}
+
+/*
+ * Redirect action
+ */
+
+int sieve_act_redirect_add_to_result(const struct sieve_runtime_env *renv,
+				     const char *name,
+				     struct sieve_side_effects_list *seffects,
+				     const struct smtp_address *to_address)
+{
+	const struct sieve_execute_env *eenv = renv->exec_env;
+	struct sieve_instance *svinst = eenv->svinst;
+	struct act_redirect_context *act;
+	pool_t pool;
+
+	pool = sieve_result_pool(renv->result);
+	act = p_new(pool, struct act_redirect_context, 1);
+	act->to_address = smtp_address_clone(pool, to_address);
+
+	if (sieve_result_add_action(renv, NULL, name, &act_redirect, seffects,
+				    (void *)act, svinst->max_redirects,
+				    TRUE) < 0)
+		return SIEVE_EXEC_FAILURE;
+
+	return SIEVE_EXEC_OK;
+}
+
+/*
+ * Action utility functions
+ */
+
+/* Rejecting the mail */
+
+static int
+sieve_action_do_reject_mail(const struct sieve_action_exec_env *aenv,
+			    const struct smtp_address *recipient,
+			    const char *reason)
+{
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	struct sieve_instance *svinst = eenv->svinst;
+	const struct sieve_script_env *senv = eenv->scriptenv;
+	const struct sieve_message_data *msgdata = eenv->msgdata;
+	const struct smtp_address *sender, *orig_recipient;
+	struct istream *input;
+	struct ostream *output;
+	struct sieve_smtp_context *sctx;
+	const char *new_msgid, *boundary, *error;
+	string_t *hdr;
+	int ret;
+
+	sender = sieve_message_get_sender(aenv->msgctx);
+	orig_recipient = msgdata->envelope.rcpt_params->orcpt.addr;
+
+	sctx = sieve_smtp_start_single(senv, sender, NULL, &output);
+
+	/* Just to be sure */
+	if (sctx == NULL) {
+		sieve_result_global_warning(
+			aenv, "reject action has no means to send mail");
+		return SIEVE_EXEC_OK;
+	}
+
+	new_msgid = sieve_message_get_new_id(svinst);
+	boundary = t_strdup_printf("%s/%s", my_pid, svinst->hostname);
+
+	hdr = t_str_new(512);
+	rfc2822_header_write(hdr, "X-Sieve", SIEVE_IMPLEMENTATION);
+	rfc2822_header_write(hdr, "Message-ID", new_msgid);
+	rfc2822_header_write(hdr, "Date", message_date_create(ioloop_time));
+	rfc2822_header_write(hdr, "From", sieve_get_postmaster_address(senv));
+	rfc2822_header_printf(hdr, "To", "<%s>", smtp_address_encode(sender));
+	rfc2822_header_write(hdr, "Subject", "Automatically rejected mail");
+	rfc2822_header_write(hdr, "Auto-Submitted", "auto-replied (rejected)");
+	rfc2822_header_write(hdr, "Precedence", "bulk");
+
+	rfc2822_header_write(hdr, "MIME-Version", "1.0");
+	rfc2822_header_printf(hdr, "Content-Type",
+			      "multipart/report; "
+			      "report-type=disposition-notification;\r\n"
+			      "boundary=\"%s\"", boundary);
+
+	str_append(hdr, "\r\nThis is a MIME-encapsulated message\r\n\r\n");
+
+	/* Human readable status report */
+	str_printfa(hdr, "--%s\r\n", boundary);
+	rfc2822_header_write(hdr, "Content-Type", "text/plain; charset=utf-8");
+	rfc2822_header_write(hdr, "Content-Disposition", "inline");
+	rfc2822_header_write(hdr, "Content-Transfer-Encoding", "8bit");
+
+	str_printfa(hdr, "\r\nYour message to <%s> was automatically rejected:\r\n"
+		    "%s\r\n", smtp_address_encode(recipient), reason);
+
+	/* MDN status report */
+	str_printfa(hdr, "--%s\r\n", boundary);
+	rfc2822_header_write(hdr, "Content-Type",
+			     "message/disposition-notification");
+	str_append(hdr, "\r\n");
+	rfc2822_header_write(hdr,
+			     "Reporting-UA: %s; Dovecot Mail Delivery Agent",
+			     svinst->hostname);	
+	if (orig_recipient != NULL) {
+		rfc2822_header_printf(hdr, "Original-Recipient", "rfc822; %s",
+				      smtp_address_encode(orig_recipient));
+	}
+	rfc2822_header_printf(hdr, "Final-Recipient", "rfc822; %s",
+			      smtp_address_encode(recipient));
+
+	if (msgdata->id != NULL)
+		rfc2822_header_write(hdr, "Original-Message-ID", msgdata->id);
+	rfc2822_header_write(hdr, "Disposition",
+		"automatic-action/MDN-sent-automatically; deleted");
+	str_append(hdr, "\r\n");
+
+	/* original message's headers */
+	str_printfa(hdr, "--%s\r\n", boundary);
+	rfc2822_header_write(hdr, "Content-Type", "message/rfc822");
+	str_append(hdr, "\r\n");
+	o_stream_nsend(output, str_data(hdr), str_len(hdr));
+
+	if (mail_get_hdr_stream(msgdata->mail, NULL, &input) == 0) {
+		/* NOTE: If you add more headers, they need to be sorted. We'll
+		   drop Content-Type because we're not including the message
+		   body, and having a multipart Content-Type may confuse some
+		   MIME parsers when they don't see the message boundaries.
+		 */
+		static const char *const exclude_headers[] = {
+			"Content-Type"
+		};
+
+		input = i_stream_create_header_filter(
+			input, HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR |
+			       HEADER_FILTER_HIDE_BODY,
+			exclude_headers, N_ELEMENTS(exclude_headers),
+			*null_header_filter_callback, (void *)NULL);
+		o_stream_nsend_istream(output, input);
+		i_stream_unref(&input);
+	}
+
+	str_truncate(hdr, 0);
+	str_printfa(hdr, "\r\n\r\n--%s--\r\n", boundary);
+	o_stream_nsend(output, str_data(hdr), str_len(hdr));
+
+	if ((ret = sieve_smtp_finish(sctx, &error)) <= 0) {
+		if (ret < 0) {
+			sieve_result_global_error(aenv,
+				"failed to send rejection message to <%s>: %s "
+				"(temporary failure)",
+				smtp_address_encode(sender),
+				str_sanitize(error, 512));
+		} else {
+			sieve_result_global_log_error(aenv,
+				"failed to send rejection message to <%s>: %s "
+				"(permanent failure)",
+				smtp_address_encode(sender),
+				str_sanitize(error, 512));
+		}
+		return SIEVE_EXEC_FAILURE;
+	}
+
+	return SIEVE_EXEC_OK;
+}
+
+int sieve_action_reject_mail(const struct sieve_action_exec_env *aenv,
+			     const struct smtp_address *recipient,
+			     const char *reason)
+{
+	const struct sieve_execute_env *eenv = aenv->exec_env;
+	const struct sieve_script_env *senv = eenv->scriptenv;
+	int result;
+
+	T_BEGIN {
+		if (senv->reject_mail != NULL) {
+			result = (senv->reject_mail(senv, recipient,
+						    reason) >= 0 ?
+				  SIEVE_EXEC_OK : SIEVE_EXEC_FAILURE);
+		} else {
+			result = sieve_action_do_reject_mail(aenv, recipient,
+							     reason);
+		}
+	} T_END;
+
+	return result;
+}
+
+/*
+ * Mailbox
+ */
+
+bool sieve_mailbox_check_name(const char *mailbox, const char **error_r)
+{
+	if (!uni_utf8_str_is_valid(mailbox)) {
+		*error_r = "invalid utf-8";
+		return FALSE;
+	}
+	return TRUE;
+}
+
+