/* Copyright (c) Pigeonhole authors, see top-level COPYING file */

#include "lib.h"
#include "array.h"
#include "str-sanitize.h"
#include "home-expand.h"
#include "settings.h"

#include "sieve-common.h"
#include "sieve-error.h"
#include "sieve-script.h"
#include "sieve-storage.h"
#include "sieve-ast.h"
#include "sieve-binary.h"
#include "sieve-commands.h"
#include "sieve-validator.h"
#include "sieve-generator.h"
#include "sieve-interpreter.h"

#include "ext-include-common.h"
#include "ext-include-binary.h"
#include "ext-include-variables.h"


/*
 * Forward declarations
 */

/* Generator context */

struct ext_include_generator_context {
	unsigned int nesting_depth;
	enum ext_include_script_location location;
	const char *script_name;
	struct sieve_script *script;
	struct ext_include_generator_context *parent;
};

static inline struct ext_include_generator_context *
ext_include_get_generator_context(const struct sieve_extension *ext_this,
				  struct sieve_generator *gentr);

/* Interpreter context */

struct ext_include_interpreter_global {
	ARRAY(struct sieve_script *) included_scripts;

	struct sieve_variable_scope_binary *var_scope;
	struct sieve_variable_storage *var_storage;
};

struct ext_include_interpreter_context {
	struct ext_include_interpreter_context *parent;
	struct ext_include_interpreter_global *global;

	struct sieve_interpreter *interp;
	pool_t pool;

	unsigned int nesting_depth;

	struct sieve_script *script;
	const struct ext_include_script_info *script_info;

	/* Persistent sieve_execute_env for the currently active child
	   sub-interpreter. The child interpreter stores a pointer to this
	   in its runenv, so it must outlive the child. Reused across
	   successive children, since at most one child is active at a time. */
	struct sieve_execute_env child_eenv;

	const struct ext_include_script_info *include;
	bool returned;
};

/*
 * Extension configuration
 */

/* Extension hooks */

int ext_include_load(const struct sieve_extension *ext, void **context_r)
{
	struct sieve_instance *svinst = ext->svinst;
	const struct sieve_extension *var_ext;
	const struct ext_include_settings *set;
	struct ext_include_context *extctx;
	const char *error;

	/* Extension dependencies */
	if (sieve_ext_variables_get_extension(ext->svinst, &var_ext) < 0)
		return -1;

	if (settings_get(svinst->event, &ext_include_setting_parser_info, 0,
			 &set, &error) < 0) {
		e_error(svinst->event, "%s", error);
		return -1;
	}

	extctx = i_new(struct ext_include_context, 1);
	extctx->var_ext = var_ext;
	extctx->set = set;

	*context_r = extctx;
	return 0;
}

void ext_include_unload(const struct sieve_extension *ext)
{
	struct ext_include_context *extctx = ext->context;

	if (extctx == NULL)
		return;
	sieve_storage_unref(&extctx->personal_storage);
	settings_free(extctx->set);
	i_free(extctx);
}

/*
 * Script access
 */

static int
ext_include_open_script_personal(struct sieve_instance *svinst,
				 struct ext_include_context *extctx,
				 const char *cause, const char *script_name,
				 struct sieve_script **script_r,
				 enum sieve_error *error_code_r)
{
	if (extctx->personal_storage == NULL &&
	    sieve_storage_create_personal(svinst, NULL, cause, 0,
					  &extctx->personal_storage,
					  error_code_r) < 0)
		return -1;

	return sieve_storage_open_script(extctx->personal_storage, script_name,
					 script_r, error_code_r);
}

static int
ext_include_open_script_global(struct sieve_instance *svinst,
			       const char *cause, const char *script_name,
			       struct sieve_script **script_r,
			       enum sieve_error *error_code_r)
{
	return sieve_script_create_open(svinst, cause,
					SIEVE_STORAGE_TYPE_GLOBAL, script_name,
					script_r, error_code_r, NULL);
}

int ext_include_open_script(const struct sieve_extension *ext,
			    enum ext_include_script_location location,
			    const char *cause, const char *script_name,
			    struct sieve_script **script_r,
			    enum sieve_error *error_code_r)
{
	struct sieve_instance *svinst = ext->svinst;
	struct ext_include_context *extctx = ext->context;
	int ret;

	*script_r = NULL;
	switch (location) {
	case EXT_INCLUDE_LOCATION_PERSONAL:
		ret = ext_include_open_script_personal(svinst, extctx, cause,
						       script_name,
						       script_r, error_code_r);
		break;
	case EXT_INCLUDE_LOCATION_GLOBAL:
		ret = ext_include_open_script_global(svinst, cause, script_name,
						     script_r, error_code_r);
		break;
	default:
		i_unreached();
	}
	return ret;
}

/*
 * AST context management
 */

static void
ext_include_ast_free(const struct sieve_extension *ext ATTR_UNUSED,
		     struct sieve_ast *ast ATTR_UNUSED, void *context)
{
	struct ext_include_ast_context *actx =
		(struct ext_include_ast_context *)context;
	struct sieve_script **scripts;
	unsigned int count, i;

	/* Unreference included scripts */
	scripts = array_get_modifiable(&actx->included_scripts, &count);
	for (i = 0; i < count; i++) {
		sieve_script_unref(&scripts[i]);
	}

	/* Unreference variable scopes */
	if (actx->global_vars != NULL)
		sieve_variable_scope_unref(&actx->global_vars);
}

static const struct sieve_ast_extension include_ast_extension = {
	&include_extension,
	ext_include_ast_free
};

struct ext_include_ast_context *
ext_include_create_ast_context(const struct sieve_extension *this_ext,
			       struct sieve_ast *ast, struct sieve_ast *parent)
{
	struct ext_include_ast_context *actx;

	pool_t pool = sieve_ast_pool(ast);
	actx = p_new(pool, struct ext_include_ast_context, 1);
	p_array_init(&actx->included_scripts, pool, 32);

	if (parent != NULL) {
		struct ext_include_ast_context *parent_ctx =
			(struct ext_include_ast_context *)
			sieve_ast_extension_get_context(parent, this_ext);

		actx->global_vars = parent_ctx->global_vars;
		i_assert(actx->global_vars != NULL);

		sieve_variable_scope_ref(actx->global_vars);
	} else {
		struct ext_include_context *extctx =
			ext_include_get_context(this_ext);

		actx->global_vars = sieve_variable_scope_create(
			this_ext->svinst, extctx->var_ext, this_ext);
	}

	sieve_ast_extension_register(ast, this_ext, &include_ast_extension,
				     actx);
	return actx;
}

struct ext_include_ast_context *
ext_include_get_ast_context(const struct sieve_extension *this_ext,
			    struct sieve_ast *ast)
{
	struct ext_include_ast_context *actx =
		(struct ext_include_ast_context *)
		sieve_ast_extension_get_context(ast, this_ext);

	if (actx != NULL)
		return actx;
	return ext_include_create_ast_context(this_ext, ast, NULL);
}

void ext_include_ast_link_included_script(
	const struct sieve_extension *this_ext, struct sieve_ast *ast,
	struct sieve_script *script)
{
	struct ext_include_ast_context *actx =
		ext_include_get_ast_context(this_ext, ast);

	array_append(&actx->included_scripts, &script, 1);
}

bool ext_include_validator_have_variables(
	const struct sieve_extension *this_ext, struct sieve_validator *valdtr)
{
	struct ext_include_context *extctx = ext_include_get_context(this_ext);

	return sieve_ext_variables_is_active(extctx->var_ext, valdtr);
}

/*
 * Generator context management
 */

static struct ext_include_generator_context *
ext_include_create_generator_context(
	struct sieve_generator *gentr,
	struct ext_include_generator_context *parent,
	enum ext_include_script_location location, const char *script_name,
	struct sieve_script *script)
{
	struct ext_include_generator_context *ctx;

	pool_t pool = sieve_generator_pool(gentr);
	ctx = p_new(pool, struct ext_include_generator_context, 1);
	ctx->parent = parent;
	ctx->location = location;
	ctx->script_name = p_strdup(pool, script_name);
	ctx->script = script;
	if (parent == NULL)
		ctx->nesting_depth = 0;
	else
		ctx->nesting_depth = parent->nesting_depth + 1;

	return ctx;
}

static inline struct ext_include_generator_context *
ext_include_get_generator_context(const struct sieve_extension *this_ext,
				  struct sieve_generator *gentr)
{
	return (struct ext_include_generator_context *)
		sieve_generator_extension_get_context(gentr, this_ext);
}

static inline void
ext_include_initialize_generator_context(
	const struct sieve_extension *this_ext, struct sieve_generator *gentr,
	struct ext_include_generator_context *parent,
	enum ext_include_script_location location, const char *script_name,
	struct sieve_script *script)
{
	sieve_generator_extension_set_context(
		gentr, this_ext,
		ext_include_create_generator_context(gentr, parent,
						     location, script_name,
						     script));
}

void ext_include_register_generator_context(
	const struct sieve_extension *this_ext,
	const struct sieve_codegen_env *cgenv)
{
	struct ext_include_generator_context *ctx =
		ext_include_get_generator_context(this_ext, cgenv->gentr);

	/* Initialize generator context if necessary */
	if (ctx == NULL) {
		i_assert(cgenv->script != NULL);

		enum ext_include_script_location location;
		const char *storage_type =
			sieve_script_storage_type(cgenv->script);

		if (strcasecmp(storage_type,
			       SIEVE_STORAGE_TYPE_PERSONAL) == 0)
			location = EXT_INCLUDE_LOCATION_PERSONAL;
		else if (strcasecmp(storage_type,
				    SIEVE_STORAGE_TYPE_GLOBAL) == 0)
			location = EXT_INCLUDE_LOCATION_GLOBAL;
		else
			location = EXT_INCLUDE_LOCATION_INVALID;

		ctx = ext_include_create_generator_context(
			cgenv->gentr, NULL, location,
			sieve_script_name(cgenv->script), cgenv->script);

		sieve_generator_extension_set_context(
			cgenv->gentr, this_ext, ctx);
	}

	/* Initialize ast context if necessary */
	(void)ext_include_get_ast_context(this_ext, cgenv->ast);
	(void)ext_include_binary_init(this_ext, cgenv->sbin, cgenv->ast);
}

/*
 * Runtime initialization
 */

static int
ext_include_runtime_init(const struct sieve_extension *this_ext,
			 const struct sieve_runtime_env *renv,
			 void *context, bool deferred ATTR_UNUSED)
{
	struct ext_include_interpreter_context *ctx =
		(struct ext_include_interpreter_context *)context;
	struct ext_include_context *extctx = ext_include_get_context(this_ext);

	if (ctx->parent == NULL) {
		ctx->global = p_new(ctx->pool,
				    struct ext_include_interpreter_global, 1);
		p_array_init(&ctx->global->included_scripts, ctx->pool, 10);

		ctx->global->var_scope =
			ext_include_binary_get_global_scope(
				this_ext, renv->sbin);
		ctx->global->var_storage =
			sieve_variable_storage_create(extctx->var_ext,
						      ctx->pool,
						      ctx->global->var_scope);
	} else {
		ctx->global = ctx->parent->global;
	}

	sieve_ext_variables_runtime_set_storage(extctx->var_ext, renv, this_ext,
						ctx->global->var_storage);
	return SIEVE_EXEC_OK;
}

static struct sieve_interpreter_extension include_interpreter_extension = {
	.ext_def = &include_extension,
	.run = ext_include_runtime_init
};

/*
 * Interpreter context management
 */

static struct ext_include_interpreter_context *
ext_include_interpreter_context_create(
	struct sieve_interpreter *interp,
	struct ext_include_interpreter_context *parent,
	struct sieve_script *script,
	const struct ext_include_script_info *sinfo)
{
	struct ext_include_interpreter_context *ctx;

	pool_t pool = sieve_interpreter_pool(interp);
	ctx = p_new(pool, struct ext_include_interpreter_context, 1);
	ctx->pool = pool;
	ctx->parent = parent;
	ctx->interp = interp;
	ctx->script = script;
	ctx->script_info = sinfo;

	if (parent == NULL)
		ctx->nesting_depth = 0;
	else
		ctx->nesting_depth = parent->nesting_depth + 1;
	return ctx;
}

static inline struct ext_include_interpreter_context *
ext_include_get_interpreter_context(const struct sieve_extension *this_ext,
				    struct sieve_interpreter *interp)
{
	return (struct ext_include_interpreter_context *)
		sieve_interpreter_extension_get_context(interp, this_ext);
}

static inline struct ext_include_interpreter_context *
ext_include_interpreter_context_init_child(
	const struct sieve_extension *this_ext,
	struct sieve_interpreter *interp,
	struct ext_include_interpreter_context *parent,
	struct sieve_script *script,
	const struct ext_include_script_info *sinfo)
{
	struct ext_include_interpreter_context *ctx =
		ext_include_interpreter_context_create(interp, parent,
						       script, sinfo);

	sieve_interpreter_extension_register(interp, this_ext,
					     &include_interpreter_extension,
					     ctx);
	return ctx;
}

void ext_include_interpreter_context_init(
	const struct sieve_extension *this_ext,
	struct sieve_interpreter *interp)
{
	struct ext_include_interpreter_context *ctx =
		ext_include_get_interpreter_context(this_ext, interp);

	/* Is this is the top-level interpreter ? */
	if (ctx == NULL) {
		struct sieve_script *script;

		/* Initialize top context */
		script = sieve_interpreter_script(interp);
		ctx = ext_include_interpreter_context_create(interp, NULL,
							     script, NULL);

		sieve_interpreter_extension_register(
			interp, this_ext, &include_interpreter_extension,
			ctx);
	}
}

struct sieve_variable_storage *
ext_include_interpreter_get_global_variables(
	const struct sieve_extension *this_ext,
	struct sieve_interpreter *interp)
{
	struct ext_include_interpreter_context *ctx =
		ext_include_get_interpreter_context(this_ext, interp);

	return ctx->global->var_storage;
}

/*
 * Including a script during code generation
 */

int ext_include_generate_include(
	const struct sieve_codegen_env *cgenv, struct sieve_command *cmd,
	enum ext_include_script_location location, const char *script_name,
	enum ext_include_flags flags, struct sieve_script *script,
	const struct ext_include_script_info **included_r)
{
	const struct sieve_extension *this_ext = cmd->ext;
	struct ext_include_context *extctx = this_ext->context;
	int result = 1;
	struct sieve_ast *ast;
	struct sieve_binary *sbin = cgenv->sbin;
	struct sieve_generator *gentr = cgenv->gentr;
	struct ext_include_binary_context *binctx;
	struct sieve_generator *subgentr;
	struct ext_include_generator_context *ctx =
		ext_include_get_generator_context(this_ext, gentr);
	struct ext_include_generator_context *pctx;
	struct sieve_error_handler *ehandler =
		sieve_generator_error_handler(gentr);
	struct ext_include_script_info *included;

	*included_r = NULL;

	/* Just to be sure: do not include more scripts when errors have occured
	   already.
	 */
	if (sieve_get_errors(ehandler) > 0)
		return -1;

	/* Limit nesting level */
	if (ctx->nesting_depth >= extctx->set->max_nesting_depth) {
		sieve_command_generate_error(
			gentr, cmd,
			"cannot nest includes deeper than %d levels",
			extctx->set->max_nesting_depth);
		return -1;
	}

	/* Check for circular include */
	if ((flags & EXT_INCLUDE_FLAG_ONCE) == 0) {
		pctx = ctx;
		while (pctx != NULL) {
			if (pctx->location == location &&
			    strcmp(pctx->script_name, script_name) == 0 &&
			    (pctx->script == NULL || script == NULL ||
			     sieve_script_equals(pctx->script, script))) {
				/* Just drop circular include when uploading
				   inactive script;  not an error
				 */
				if ((cgenv->flags & SIEVE_COMPILE_FLAG_UPLOADED) != 0 &&
				    (cgenv->flags & SIEVE_COMPILE_FLAG_ACTIVATED) == 0) {
					sieve_command_generate_warning(
						gentr, cmd,
						"circular include (ignored during upload)");
					return 0;
				}

				sieve_command_generate_error(gentr, cmd,
							     "circular include");
				return -1;
			}

			pctx = pctx->parent;
		}
	}

	/* Get binary context */
	binctx = ext_include_binary_init(this_ext, sbin, cgenv->ast);

	/* Is the script already compiled into the current binary? */
	included = ext_include_binary_script_get_include_info(
		binctx, location, script_name);
	if (included != NULL) {
		/* Yes, only update flags */
		if ((flags & EXT_INCLUDE_FLAG_OPTIONAL) == 0)
			included->flags &= ENUM_NEGATE(EXT_INCLUDE_FLAG_OPTIONAL);
		if ((flags & EXT_INCLUDE_FLAG_ONCE) == 0)
			included->flags &= ENUM_NEGATE(EXT_INCLUDE_FLAG_ONCE);
	} else 	{
		enum sieve_compile_flags cpflags = cgenv->flags;

		/* No, include new script */

		/* Check whether include limit is exceeded */
		if (ext_include_binary_script_get_count(binctx) >=
		    extctx->set->max_includes) {
	 		sieve_command_generate_error(
				gentr, cmd, "failed to include script '%s': "
				"no more than %u includes allowed",
				str_sanitize(script_name, 80),
				extctx->set->max_includes);
	 		return -1;
		}

		/* Allocate a new block in the binary and mark the script as
		   included. */
		if (script == NULL) {
			/* Just making an empty entry to mark a missing script
			 */
			i_assert((flags & EXT_INCLUDE_FLAG_MISSING_AT_UPLOAD) != 0 ||
				 (flags & EXT_INCLUDE_FLAG_OPTIONAL) != 0);
			included = ext_include_binary_script_include(
				binctx, location, script_name, flags, NULL,
				NULL);
			result = 0;
		} else {
			struct sieve_binary_block *inc_block =
				sieve_binary_block_create(sbin);

			/* Real include */
			included = ext_include_binary_script_include(
				binctx, location, script_name, flags, script,
				inc_block);

			/* Parse */
			if ((ast = sieve_parse(script, ehandler,
					       NULL)) == NULL) {
		 		sieve_command_generate_error(
					gentr, cmd,
		 			"failed to parse included script '%s'",
					str_sanitize(script_name, 80));
		 		return -1;
			}

			/* Included scripts inherit global variable scope */
			(void)ext_include_create_ast_context(
				this_ext, ast, cmd->ast_node->ast);

			if (location == EXT_INCLUDE_LOCATION_GLOBAL) {
				cpflags &=
					ENUM_NEGATE(SIEVE_EXECUTE_FLAG_NOGLOBAL);
			} else {
				cpflags |= SIEVE_EXECUTE_FLAG_NOGLOBAL;
			}

			/* Validate */
			if (!sieve_validate(ast, ehandler, cpflags, NULL)) {
				sieve_command_generate_error(
					gentr, cmd,
					"failed to validate included script '%s'",
					str_sanitize(script_name, 80));
		 		sieve_ast_unref(&ast);
		 		return -1;
		 	}

			/* Generate

			   FIXME: It might not be a good idea to recurse code
			   generation for included scripts.
			 */
		 	subgentr = sieve_generator_create(ast, ehandler, cpflags);
			ext_include_initialize_generator_context(
				cmd->ext, subgentr, ctx, location, script_name,
				script);

			if (sieve_generator_run(subgentr, &inc_block) == NULL) {
				sieve_command_generate_error(
					gentr, cmd,
					"failed to generate code for included script '%s'",
					str_sanitize(script_name, 80));
		 		result = -1;
			}

			sieve_generator_free(&subgentr);

			/* Cleanup */
			sieve_ast_unref(&ast);
		}
	}

	if (result > 0)
		*included_r = included;
	return result;
}

/*
 * Executing an included script during interpretation
 */

static bool
ext_include_runtime_check_circular(
	struct ext_include_interpreter_context *ctx,
	const struct ext_include_script_info *include)
{
	struct ext_include_interpreter_context *pctx;

	pctx = ctx;
	while (pctx != NULL) {

		if (sieve_script_equals(include->script, pctx->script))
			return TRUE;

		pctx = pctx->parent;
	}

	return FALSE;
}

static bool
ext_include_runtime_include_mark(struct ext_include_interpreter_context *ctx,
				 const struct ext_include_script_info *include,
				 bool once)
{
	struct sieve_script *const *includes;
	unsigned int count, i;

	includes = array_get(&ctx->global->included_scripts, &count);
	for (i = 0; i < count; i++) {
		if (sieve_script_equals(include->script, includes[i]))
			return (!once);
	}

	array_append(&ctx->global->included_scripts, &include->script, 1);
	return TRUE;
}

int ext_include_execute_include(const struct sieve_runtime_env *renv,
				unsigned int include_id,
				enum ext_include_flags flags)
{
	const struct sieve_execute_env *eenv = renv->exec_env;
	const struct sieve_extension *this_ext = renv->oprtn->ext;
	int result = SIEVE_EXEC_OK;
	struct ext_include_interpreter_context *ctx;
	const struct ext_include_script_info *included;
	struct ext_include_binary_context *binctx =
		ext_include_binary_get_context(this_ext, renv->sbin);
	bool once = ((flags & EXT_INCLUDE_FLAG_ONCE) != 0);
	unsigned int block_id;

	/* Check for invalid include id (== corrupt binary) */
	included = ext_include_binary_script_get_included(binctx, include_id);
	if (included == NULL) {
		sieve_runtime_trace_error(
			renv, "include: include id %d is invalid", include_id);
		return SIEVE_EXEC_BIN_CORRUPT;
	}
	if (included->block == NULL) {
		if (!HAS_ALL_BITS(included->flags, EXT_INCLUDE_FLAG_OPTIONAL)) {
			sieve_runtime_trace_error(
				renv, "include: include record %d is corrupt "
				"(block is missing while include is not optional)",
				include_id);
			return SIEVE_EXEC_BIN_CORRUPT;

		}
		return SIEVE_EXEC_OK;
	}

	ctx = ext_include_get_interpreter_context(this_ext, renv->interp);
	block_id = sieve_binary_block_get_id(included->block);

	/* If :once modifier is specified, check for duplicate include */
	if (ext_include_runtime_include_mark(ctx, included, once)) {
		sieve_runtime_trace(
			renv, SIEVE_TRLVL_NONE,
			"include: start script '%s' [inc id: %d, block: %d]",
			sieve_script_name(included->script),
			include_id, block_id);
	} else {
		/* skip */
		sieve_runtime_trace(
			renv, SIEVE_TRLVL_NONE,
			"include: skipped include for script '%s' "
			"[inc id: %d, block: %d]; already run once",
			sieve_script_name(included->script),
			include_id, block_id);
		return result;
	}

	/* Check circular include during interpretation as well.
	 * Let's not trust binaries.
	 */
	if (ext_include_runtime_check_circular(ctx, included)) {
		sieve_runtime_trace_error(renv,
			"include: circular include of script '%s' "
			"[inc id: %d, block: %d]",
			sieve_script_name(included->script),
			include_id, block_id);

		/* Situation has no valid way to emerge at runtime */
		return SIEVE_EXEC_BIN_CORRUPT;
	}

	if (ctx->parent == NULL) {
		struct ext_include_interpreter_context *curctx = NULL;
		struct sieve_error_handler *ehandler = renv->ehandler;
		struct sieve_interpreter *subinterp;
		bool interrupted = FALSE;

		/* We are the top-level interpreter instance */
		if (result == SIEVE_EXEC_OK) {
			ctx->child_eenv = *eenv;

			if (included->location != EXT_INCLUDE_LOCATION_GLOBAL) {
				ctx->child_eenv.flags |=
					SIEVE_EXECUTE_FLAG_NOGLOBAL;
			} else {
				ctx->child_eenv.flags &=
					ENUM_NEGATE(SIEVE_EXECUTE_FLAG_NOGLOBAL);
			}

			/* Create interpreter for top-level included script
			   (first sub-interpreter)
			 */
			subinterp = sieve_interpreter_create_for_block(
				included->block, included->script, renv->interp,
				&ctx->child_eenv, ehandler);
			if (subinterp != NULL) {
				curctx = ext_include_interpreter_context_init_child(
					this_ext, subinterp, ctx, included->script,
					included);

				/* Activate and start the top-level included script */
				result = sieve_interpreter_start(
					subinterp, renv->result, &interrupted);
			} else {
				result = SIEVE_EXEC_BIN_CORRUPT;
			}
		}

		/* Included scripts can have includes of their own. This is not
		   implemented recursively. Rather, the sub-interpreter
		   interrupts and defers the include to the top-level
		   interpreter, which is here. */
		if (result == SIEVE_EXEC_OK && interrupted &&
		    !curctx->returned) {
			while (result == SIEVE_EXEC_OK) {
				if (((interrupted && curctx->returned) ||
				     (!interrupted)) &&
				    curctx->parent != NULL) {
					const struct ext_include_script_info *ended_script =
						curctx->script_info;

					/* Sub-interpreter ended or executed
					   return */

					/* Ascend interpreter stack */
					curctx = curctx->parent;
					sieve_interpreter_free(&subinterp);

					sieve_runtime_trace(renv, SIEVE_TRLVL_NONE,
						"include: script '%s' ended "
						"[inc id: %d, block: %d]",
						sieve_script_name(ended_script->script),
						ended_script->id,
						sieve_binary_block_get_id(ended_script->block));

					/* This is the top-most sub-interpreter,
					   bail out */
					if (curctx->parent == NULL)
						break;

					subinterp = curctx->interp;

					/* Continue parent */
					curctx->include = NULL;
					curctx->returned = FALSE;

					result = sieve_interpreter_continue(
						subinterp, &interrupted);
				} else {
					if (curctx->include != NULL) {
						/* Sub-include requested */

						if (result == SIEVE_EXEC_OK) {
							curctx->child_eenv = *eenv;

							if (curctx->include->location != EXT_INCLUDE_LOCATION_GLOBAL) {
								curctx->child_eenv.flags |=
									SIEVE_EXECUTE_FLAG_NOGLOBAL;
							} else {
								curctx->child_eenv.flags &=
									ENUM_NEGATE(SIEVE_EXECUTE_FLAG_NOGLOBAL);
							}

							/* Create sub-interpreter */
							subinterp = sieve_interpreter_create_for_block(
								curctx->include->block, curctx->include->script,
								curctx->interp, &curctx->child_eenv, ehandler);
							if (subinterp != NULL) {
								curctx = ext_include_interpreter_context_init_child(
									this_ext, subinterp, curctx,
									curctx->include->script, curctx->include);

								/* Start the sub-include's interpreter */
								curctx->include = NULL;
								curctx->returned = FALSE;
								result = sieve_interpreter_start(
									subinterp, renv->result, &interrupted);
							} else {
								result = SIEVE_EXEC_BIN_CORRUPT;
							}
						}
					} else {
						/* Sub-interpreter was interrupted outside
						   this extension, probably stop command was
						   executed. Generate an interrupt ourselves,
						   ending all script execution. */
						sieve_interpreter_interrupt(renv->interp);
						break;
					}
				}
			}
		}

		/* Free any sub-interpreters that might still be active */
		while (curctx != NULL && curctx->parent != NULL) {
			struct ext_include_interpreter_context *nextctx	=
				curctx->parent;
			struct sieve_interpreter *killed_interp = curctx->interp;
			const struct ext_include_script_info *ended_script =
				curctx->script_info;

			/* This kills curctx too */
			sieve_interpreter_free(&killed_interp);

			sieve_runtime_trace(
				renv, SIEVE_TRLVL_NONE,
				"include: script '%s' ended [id: %d, block: %d]",
				sieve_script_name(ended_script->script),
				ended_script->id,
				sieve_binary_block_get_id(ended_script->block));

			/* Luckily we recorded the parent earlier */
			curctx = nextctx;
		}

	} else {
		/* We are an included script already, defer inclusion to main
		   interpreter */
		ctx->include = included;
		sieve_interpreter_interrupt(renv->interp);
	}

	return result;
}

void ext_include_execute_return(const struct sieve_runtime_env *renv)
{
	const struct sieve_extension *this_ext = renv->oprtn->ext;
	struct ext_include_interpreter_context *ctx =
		ext_include_get_interpreter_context(this_ext, renv->interp);

	sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS,
			    "return: exiting included script");
	ctx->returned = TRUE;
	sieve_interpreter_interrupt(renv->interp);
}
