/* Copyright (c) 2002-2018 Pigeonhole authors, see the included COPYING file
 */

#include "lib.h"
#include "str.h"
#include "str-sanitize.h"
#include "array.h"
#include "buffer.h"
#include "mempool.h"
#include "hash.h"

#include "sieve-common.h"
#include "sieve-extensions.h"
#include "sieve-script.h"
#include "sieve-ast.h"
#include "sieve-commands.h"
#include "sieve-validator.h"

#include "sieve-comparators.h"
#include "sieve-address-parts.h"

/*
 * Forward declarations
 */

static void
sieve_validator_register_core_commands(struct sieve_validator *valdtr);
static void
sieve_validator_register_core_tests(struct sieve_validator *valdtr);

/*
 * Types
 */

/* Tag registration */

struct sieve_tag_registration {
	const struct sieve_argument_def *tag_def;
	const struct sieve_extension *ext;

	const char *identifier;
	int id_code;
};

/* Command registration */

struct sieve_command_registration {
	const struct sieve_command_def *cmd_def;
	const struct sieve_extension *ext;

	ARRAY(struct sieve_tag_registration *) normal_tags;
	ARRAY(struct sieve_tag_registration *) instanced_tags;
	ARRAY(struct sieve_tag_registration *) persistent_tags;
};

/* Default (literal) arguments */

struct sieve_default_argument {
	const struct sieve_argument_def *arg_def;
	const struct sieve_extension *ext;

	struct sieve_default_argument *overrides;
};

/*
 * Validator extension
 */

struct sieve_validator_extension_reg {
	const struct sieve_validator_extension *valext;
	const struct sieve_extension *ext;
	struct sieve_ast_argument *arg;
	void *context;

	bool loaded:1;
	bool required:1;
};

/*
 * Validator
 */

struct sieve_validator {
	pool_t pool;

	struct sieve_instance *svinst;
	struct sieve_ast *ast;
	struct sieve_script *script;
	enum sieve_compile_flags flags;

	struct sieve_error_handler *ehandler;

	bool finished_require;

	/* Registries */

	HASH_TABLE(const char *, struct sieve_command_registration *) commands;

	ARRAY(struct sieve_validator_extension_reg) extensions;

	/* This is currently a wee bit ugly and needs more thought */
	struct sieve_default_argument default_arguments[SAT_COUNT];

	/* Default argument processing state (FIXME: ugly) */
	struct sieve_default_argument *current_defarg;
	enum sieve_argument_type current_defarg_type;
	bool current_defarg_constant;

	bool failed:1;
};

/*
 * Validator object
 */

struct sieve_validator *
sieve_validator_create(struct sieve_ast *ast,
		       struct sieve_error_handler *ehandler,
		       enum sieve_compile_flags flags)
{
	pool_t pool;
	struct sieve_validator *valdtr;
	const struct sieve_extension *const *ext_preloaded;
	unsigned int i, ext_count;

	pool = pool_alloconly_create("sieve_validator", 16384);
	valdtr = p_new(pool, struct sieve_validator, 1);
	valdtr->pool = pool;

	valdtr->ehandler = ehandler;
	sieve_error_handler_ref(ehandler);

	valdtr->ast = ast;
	sieve_ast_ref(ast);

	valdtr->script = sieve_ast_script(ast);
	valdtr->svinst = sieve_script_svinst(valdtr->script);
	valdtr->flags = flags;

	/* Setup default arguments */
	valdtr->default_arguments[SAT_NUMBER].arg_def = &number_argument;
	valdtr->default_arguments[SAT_NUMBER].ext = NULL;
	valdtr->default_arguments[SAT_VAR_STRING].arg_def = &string_argument;
	valdtr->default_arguments[SAT_VAR_STRING].ext = NULL;
	valdtr->default_arguments[SAT_CONST_STRING].arg_def = &string_argument;
	valdtr->default_arguments[SAT_CONST_STRING].ext = NULL;
	valdtr->default_arguments[SAT_STRING_LIST].arg_def = &string_list_argument;
	valdtr->default_arguments[SAT_STRING_LIST].ext = NULL;

	/* Setup storage for extension contexts */
	p_array_init(&valdtr->extensions, pool,
		     sieve_extensions_get_count(valdtr->svinst));

	/* Setup command registry */
	hash_table_create(&valdtr->commands, pool, 0, strcase_hash, strcasecmp);
	sieve_validator_register_core_commands(valdtr);
	sieve_validator_register_core_tests(valdtr);

	/* Pre-load core language features implemented as 'extensions' */
	ext_preloaded =
		sieve_extensions_get_preloaded(valdtr->svinst, &ext_count);
	for (i = 0; i < ext_count; i++) {
		const struct sieve_extension_def *ext_def =
			ext_preloaded[i]->def;

		if (ext_def != NULL && ext_def->validator_load != NULL)
			(void)ext_def->validator_load(ext_preloaded[i], valdtr);
	}

	return valdtr;
}

void sieve_validator_free(struct sieve_validator **valdtr)
{
	const struct sieve_validator_extension_reg *extrs;
	unsigned int ext_count, i;

	hash_table_destroy(&(*valdtr)->commands);
	sieve_ast_unref(&(*valdtr)->ast);

	sieve_error_handler_unref(&(*valdtr)->ehandler);

	/* Signal registered extensions that the validator is being destroyed */
	extrs = array_get(&(*valdtr)->extensions, &ext_count);
	for (i = 0; i < ext_count; i++) {
		if (extrs[i].valext != NULL && extrs[i].valext->free != NULL)
			extrs[i].valext->free(extrs[i].ext, *valdtr,
					      extrs[i].context);
	}

	pool_unref(&(*valdtr)->pool);

	*valdtr = NULL;
}

/*
 * Accessors
 */

// FIXME: build validate environment

pool_t sieve_validator_pool(struct sieve_validator *valdtr)
{
	return valdtr->pool;
}

struct sieve_error_handler *
sieve_validator_error_handler(struct sieve_validator *valdtr)
{
	return valdtr->ehandler;
}

struct sieve_ast *sieve_validator_ast(struct sieve_validator *valdtr)
{
	return valdtr->ast;
}

struct sieve_script *sieve_validator_script(struct sieve_validator *valdtr)
{
	return valdtr->script;
}

const char *sieve_validator_script_cause(struct sieve_validator *valdtr)
{
	return sieve_script_cause(valdtr->script);
}

struct sieve_instance *sieve_validator_svinst(struct sieve_validator *valdtr)
{
	return valdtr->svinst;
}

enum sieve_compile_flags
sieve_validator_compile_flags(struct sieve_validator *valdtr)
{
	return valdtr->flags;
}

bool sieve_validator_failed(struct sieve_validator *valdtr)
{
	return valdtr->failed;
}

/*
 * Command registry
 */

/* Dummy command object to mark unknown commands in the registry */

static bool _cmd_unknown_validate(struct sieve_validator *valdtr ATTR_UNUSED,
				  struct sieve_command *cmd ATTR_UNUSED)
{
	i_unreached();
}

static const struct sieve_command_def unknown_command = {
	.identifier = "",
	.type = SCT_NONE,
	.positional_args = 0,
	.subtests = 0,
	.block_allowed = FALSE,
	.block_required = FALSE,
	.validate = _cmd_unknown_validate
};

/* Registration of the core commands of the language */

static void
sieve_validator_register_core_tests(struct sieve_validator *valdtr)
{
	unsigned int i;

	for (i = 0; i < sieve_core_tests_count; i++) {
		sieve_validator_register_command(valdtr, NULL,
						 sieve_core_tests[i]);
	}
}

static void
sieve_validator_register_core_commands(struct sieve_validator *valdtr)
{
	unsigned int i;

	for (i = 0; i < sieve_core_commands_count; i++) {
		sieve_validator_register_command(valdtr, NULL,
						 sieve_core_commands[i]);
	}
}

/* Registry functions */

static struct sieve_command_registration *
sieve_validator_find_command_registration(struct sieve_validator *valdtr,
					  const char *command)
{
	return hash_table_lookup(valdtr->commands, command);
}

static struct sieve_command_registration *
_sieve_validator_register_command(struct sieve_validator *valdtr,
				  const struct sieve_extension *ext,
				  const struct sieve_command_def *cmd_def,
				  const char *identifier)
{
	struct sieve_command_registration *cmd_reg =
		p_new(valdtr->pool, struct sieve_command_registration, 1);

	cmd_reg->cmd_def = cmd_def;
	cmd_reg->ext = ext;

	hash_table_insert(valdtr->commands, identifier, cmd_reg);

	return cmd_reg;
}

void sieve_validator_register_command(struct sieve_validator *valdtr,
				      const struct sieve_extension *ext,
				      const struct sieve_command_def *cmd_def)
{
	struct sieve_command_registration *cmd_reg =
		sieve_validator_find_command_registration(
			valdtr, cmd_def->identifier);

	if (cmd_reg == NULL) {
		cmd_reg = _sieve_validator_register_command(
			valdtr, ext, cmd_def, cmd_def->identifier);
	} else {
		cmd_reg->cmd_def = cmd_def;
		cmd_reg->ext = ext;
	}

	if (cmd_def->registered != NULL)
		cmd_def->registered(valdtr, ext, cmd_reg);
}

static void
sieve_validator_register_unknown_command(struct sieve_validator *valdtr,
					 const char *command)
{
	struct sieve_command_registration *cmd_reg =
		sieve_validator_find_command_registration(valdtr, command);

	if (cmd_reg == NULL) {
		(void)_sieve_validator_register_command(
			valdtr, NULL, &unknown_command, command);
	} else {
		i_assert(cmd_reg->cmd_def == NULL);
		cmd_reg->cmd_def = &unknown_command;
	}
}

/*const struct sieve_command *sieve_validator_find_command
(struct sieve_validator *valdtr, const char *command)
{
  struct sieve_command_registration *cmd_reg =
  	sieve_validator_find_command_registration(valdtr, command);

  return ( record == NULL ? NULL : record->command );
}*/

/*
 * Per-command tagged argument registry
 */

/* Dummy argument object to mark unknown arguments in the registry */

static bool
_unknown_tag_validate(struct sieve_validator *valdtr ATTR_UNUSED,
		      struct sieve_ast_argument **arg ATTR_UNUSED,
		      struct sieve_command *tst ATTR_UNUSED)
{
	i_unreached();
}

static const struct sieve_argument_def _unknown_tag = {
	.identifier = "",
	.validate = _unknown_tag_validate,
};

static inline bool
_tag_registration_is_unknown(struct sieve_tag_registration *tag_reg)
{
	return (tag_reg != NULL && tag_reg->tag_def == &_unknown_tag);
}

/* Registry functions */

static void
_sieve_validator_register_tag(struct sieve_validator *valdtr,
			      struct sieve_command_registration *cmd_reg,
			      const struct sieve_extension *ext,
			      const struct sieve_argument_def *tag_def,
			      const char *identifier, int id_code)
{
	struct sieve_tag_registration *reg;

	reg = p_new(valdtr->pool, struct sieve_tag_registration, 1);
	reg->ext = ext;
	reg->tag_def = tag_def;
	reg->id_code = id_code;
	if (identifier == NULL)
		reg->identifier = tag_def->identifier;
	else
		reg->identifier = p_strdup(valdtr->pool, identifier);

	if (!array_is_created(&cmd_reg->normal_tags))
		p_array_init(&cmd_reg->normal_tags, valdtr->pool, 4);

	array_append(&cmd_reg->normal_tags, &reg, 1);
}

void sieve_validator_register_persistent_tag(
	struct sieve_validator *valdtr, const char *command,
	const struct sieve_extension *ext,
	const struct sieve_argument_def *tag_def)
{
	/* Add the tag to the persistent tags list if necessary */
	if (tag_def->validate_persistent != NULL) {
		struct sieve_command_registration *cmd_reg =
			sieve_validator_find_command_registration(
				valdtr, command);

		if (cmd_reg == NULL) {
			cmd_reg = _sieve_validator_register_command(
				valdtr, NULL, NULL, command);
		}

		struct sieve_tag_registration *reg;

		if (!array_is_created(&cmd_reg->persistent_tags)) {
			p_array_init(&cmd_reg->persistent_tags,
				     valdtr->pool, 4);
		} else {
			struct sieve_tag_registration *reg_idx;

			/* Avoid dupplicate registration */
			array_foreach_elem(&cmd_reg->persistent_tags, reg_idx) {
				if (reg_idx->tag_def == tag_def)
					return;
			}
		}

		reg = p_new(valdtr->pool, struct sieve_tag_registration, 1);
		reg->ext = ext;
		reg->tag_def = tag_def;
		reg->id_code = -1;

		array_append(&cmd_reg->persistent_tags, &reg, 1);
	}
}

void sieve_validator_register_external_tag(
	struct sieve_validator *valdtr, const char *command,
	const struct sieve_extension *ext,
	const struct sieve_argument_def *tag_def, int id_code)
{
	struct sieve_command_registration *cmd_reg =
		sieve_validator_find_command_registration(valdtr, command);

	if (cmd_reg == NULL) {
		cmd_reg = _sieve_validator_register_command(
			valdtr, NULL, NULL, command);
	}

	_sieve_validator_register_tag(valdtr, cmd_reg, ext, tag_def,
				      NULL, id_code);
}

void sieve_validator_register_tag(
	struct sieve_validator *valdtr,
	struct sieve_command_registration *cmd_reg,
	const struct sieve_extension *ext,
	const struct sieve_argument_def *tag_def, int id_code)
{
	if (tag_def->is_instance_of == NULL) {
		_sieve_validator_register_tag(valdtr, cmd_reg, ext, tag_def,
					      NULL, id_code);
	} else {
		struct sieve_tag_registration *reg =
			p_new(valdtr->pool, struct sieve_tag_registration, 1);
		reg->ext = ext;
		reg->tag_def = tag_def;
		reg->id_code = id_code;

		if (!array_is_created(&cmd_reg->instanced_tags))
			p_array_init(&cmd_reg->instanced_tags, valdtr->pool, 4);

		array_append(&cmd_reg->instanced_tags, &reg, 1);
	}
}

static void
sieve_validator_register_unknown_tag(struct sieve_validator *valdtr,
				     struct sieve_command_registration *cmd_reg,
				     const char *tag)
{
	_sieve_validator_register_tag(valdtr, cmd_reg, NULL,
				      &_unknown_tag, tag, 0);
}

static struct sieve_tag_registration *
_sieve_validator_command_tag_get(struct sieve_validator *valdtr,
				 struct sieve_command *cmd,
				 const char *tag, void **data)
{
	struct sieve_command_registration *cmd_reg = cmd->reg;
	struct sieve_tag_registration *const *regs;
	unsigned int i, reg_count;

	/* First check normal tags */
	if (array_is_created(&cmd_reg->normal_tags)) {
		regs = array_get(&cmd_reg->normal_tags, &reg_count);

		for (i = 0; i < reg_count; i++) {
			if (regs[i]->tag_def != NULL &&
			    strcasecmp(regs[i]->identifier, tag) == 0) {

				return regs[i];
			}
		}
	}

	/* Not found so far, try the instanced tags */
	if (array_is_created(&cmd_reg->instanced_tags)) {
		regs = array_get(&cmd_reg->instanced_tags, &reg_count);

		for (i = 0; i < reg_count; i++) {
			if (regs[i]->tag_def != NULL) {
				if (regs[i]->tag_def->is_instance_of(
					valdtr, cmd, regs[i]->ext, tag, data))
					return regs[i];
			}
		}
	}

	return NULL;
}

static bool
sieve_validator_command_tag_exists(struct sieve_validator *valdtr,
				   struct sieve_command *cmd, const char *tag)
{
	return (_sieve_validator_command_tag_get(valdtr, cmd,
						 tag, NULL) != NULL);
}

static struct sieve_tag_registration *
sieve_validator_command_tag_get(struct sieve_validator *valdtr,
				struct sieve_command *cmd,
				struct sieve_ast_argument *arg, void **data)
{
	const char *tag = sieve_ast_argument_tag(arg);

	return _sieve_validator_command_tag_get(valdtr, cmd, tag, data);
}

/*
 * Extension support
 */

static bool
sieve_validator_extensions_check_conficts(struct sieve_validator *valdtr,
					  struct sieve_ast_argument *ext_arg,
					  const struct sieve_extension *ext)
{
	struct sieve_validator_extension_reg *ext_reg;
	struct sieve_validator_extension_reg *regs;
	unsigned int count, i;

	if (ext->id < 0)
		return TRUE;

	ext_reg = array_idx_get_space(&valdtr->extensions,
				      (unsigned int) ext->id);

	regs = array_get_modifiable(&valdtr->extensions, &count);
	for (i = 0; i < count; i++) {
		bool required = ext_reg->required && regs[i].required;

		if (regs[i].ext == NULL)
			continue;
		if (regs[i].ext == ext)
			continue;
		if (!regs[i].loaded)
			continue;

		/* Check this extension vs other extension */
		if (ext_reg->valext != NULL &&
		    ext_reg->valext->check_conflict != NULL) {
			struct sieve_ast_argument *this_ext_arg =
				(ext_arg == NULL ? regs[i].arg : ext_arg);

			if (!ext_reg->valext->check_conflict(
				ext, valdtr, ext_reg->context, this_ext_arg,
				regs[i].ext, required))
				return FALSE;
		}

		/* Check other extension vs this extension */
		if (regs[i].valext != NULL &&
		    regs[i].valext->check_conflict != NULL) {
			if (!regs[i].valext->check_conflict(
				regs[i].ext, valdtr, regs[i].context,
				regs[i].arg, ext, required))
				return FALSE;
		}
	}
	return TRUE;
}

bool sieve_validator_extension_load(struct sieve_validator *valdtr,
				    struct sieve_command *cmd,
				    struct sieve_ast_argument *ext_arg,
				    const struct sieve_extension *ext,
				    bool required)
{
	const struct sieve_extension_def *extdef = ext->def;
	struct sieve_validator_extension_reg *reg = NULL;

	if (ext->global &&
	    (valdtr->flags & SIEVE_COMPILE_FLAG_NOGLOBAL) != 0) {
		const char *cmd_prefix = (cmd == NULL ? "" :
			t_strdup_printf("%s %s: ",
					sieve_command_identifier(cmd),
					sieve_command_type_name(cmd)));
		sieve_argument_validate_error(
			valdtr, ext_arg,
			"%sfailed to load Sieve capability '%s': "
			"its use is restricted to global scripts",
			cmd_prefix, sieve_extension_name(ext));
		return FALSE;
	}

	/* Register extension no matter what and store the
	 * AST argument registering it */
	if (ext->id >= 0) {
		reg = array_idx_get_space(&valdtr->extensions,
					  (unsigned int)ext->id);
		i_assert(reg->ext == NULL || reg->ext == ext);
		reg->ext = ext;
		reg->required = reg->required || required;
		if (reg->arg == NULL)
			reg->arg = ext_arg;
	}

	if (extdef->validator_load != NULL &&
	    !extdef->validator_load(ext, valdtr)) {
		const char *cmd_prefix = (cmd == NULL ? "" :
			t_strdup_printf("%s %s: ",
					sieve_command_identifier(cmd),
					sieve_command_type_name(cmd)));
		sieve_argument_validate_error(
			valdtr, ext_arg,
			"%sfailed to load Sieve capability '%s'",
			cmd_prefix, sieve_extension_name(ext));
		return FALSE;
	}

	/* Check conflicts with other extensions */
	if (!sieve_validator_extensions_check_conficts(valdtr, ext_arg, ext))
		return FALSE;

	/* Link extension to AST for use at code generation */
	if (reg != NULL) {
		sieve_ast_extension_link(valdtr->ast, ext, reg->required);
		reg->loaded = TRUE;
	}

	return TRUE;
}

const struct sieve_extension *
sieve_validator_extension_load_by_name(struct sieve_validator *valdtr,
				       struct sieve_command *cmd,
				       struct sieve_ast_argument *ext_arg,
				       const char *ext_name)
{
	const struct sieve_extension *ext;

	ext = sieve_extension_get_by_name(valdtr->svinst, ext_name);

	if (ext == NULL || ext->def == NULL || !ext->enabled) {
		unsigned int i;
		bool core_test = FALSE;
		bool core_command = FALSE;

		for (i = 0; !core_command && i < sieve_core_commands_count;
		     i++) {
			if (strcasecmp(sieve_core_commands[i]->identifier,
				       ext_name) == 0)
				core_command = TRUE;
		}

		for (i = 0; !core_test && i < sieve_core_tests_count; i++) {
			if (strcasecmp(sieve_core_tests[i]->identifier,
				       ext_name) == 0)
				core_test = TRUE;
		}

		if (core_test || core_command) {
			sieve_argument_validate_error(
				valdtr, ext_arg,
				"%s %s: '%s' is not known as a Sieve capability, "
				"but it is known as a Sieve %s that is always available",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd),
				str_sanitize(ext_name, 128),
				(core_test ? "test" : "command"));
		} else {
			sieve_argument_validate_error(
				valdtr, ext_arg,
				"%s %s: unknown Sieve capability '%s'",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd),
				str_sanitize(ext_name, 128));
		}
		return NULL;
	}

	if (!sieve_validator_extension_load(valdtr, cmd, ext_arg, ext, TRUE))
		return NULL;

	return ext;
}

const struct sieve_extension *
sieve_validator_extension_load_implicit(struct sieve_validator *valdtr,
					const char *ext_name)
{
	const struct sieve_extension *ext;

	ext = sieve_extension_get_by_name(valdtr->svinst, ext_name);

	if (ext == NULL || ext->def == NULL)
		return NULL;

	if (!sieve_validator_extension_load(valdtr, NULL, NULL, ext, TRUE))
		return NULL;

	return ext;
}

void sieve_validator_extension_register(
	struct sieve_validator *valdtr,	const struct sieve_extension *ext,
	const struct sieve_validator_extension *valext, void *context)
{
	struct sieve_validator_extension_reg *reg;

	if (ext->id < 0)
		return;

	reg = array_idx_get_space(&valdtr->extensions, (unsigned int) ext->id);
	i_assert(reg->ext == NULL || reg->ext == ext);
	reg->ext = ext;
	reg->valext = valext;
	reg->context = context;
}

bool sieve_validator_extension_loaded(struct sieve_validator *valdtr,
				      const struct sieve_extension *ext)
{
	const struct sieve_validator_extension_reg *reg;

	if (ext->id < 0 || ext->id >= (int) array_count(&valdtr->extensions))
		return FALSE;

	reg = array_idx(&valdtr->extensions, (unsigned int) ext->id);

	return (reg->loaded);
}

void sieve_validator_extension_set_context(struct sieve_validator *valdtr,
					   const struct sieve_extension *ext,
					   void *context)
{
	struct sieve_validator_extension_reg *reg;

	if (ext->id < 0)
		return;

	reg = array_idx_get_space(&valdtr->extensions, (unsigned int) ext->id);
	reg->context = context;
}

void *sieve_validator_extension_get_context(struct sieve_validator *valdtr,
					    const struct sieve_extension *ext)
{
	const struct sieve_validator_extension_reg *reg;

	if (ext->id < 0 || ext->id >= (int) array_count(&valdtr->extensions))
		return NULL;

	reg = array_idx(&valdtr->extensions, (unsigned int) ext->id);

	return reg->context;
}

/*
 * Overriding the default literal arguments
 */

void sieve_validator_argument_override(struct sieve_validator *valdtr,
				       enum sieve_argument_type type,
				       const struct sieve_extension *ext,
				       const struct sieve_argument_def *arg_def)
{
	struct sieve_default_argument *arg;

	if (valdtr->default_arguments[type].arg_def != NULL) {
		arg = p_new(valdtr->pool, struct sieve_default_argument, 1);
		*arg = valdtr->default_arguments[type];

		valdtr->default_arguments[type].overrides = arg;
	}

	valdtr->default_arguments[type].arg_def = arg_def;
	valdtr->default_arguments[type].ext = ext;
}

static bool
sieve_validator_argument_default_activate(struct sieve_validator *valdtr,
					  struct sieve_command *cmd,
					  struct sieve_default_argument *defarg,
					  struct sieve_ast_argument *arg)
{
	bool result = TRUE;
	struct sieve_default_argument *prev_defarg;

	prev_defarg = valdtr->current_defarg;
	valdtr->current_defarg = defarg;

	if (arg->argument == NULL) {
		arg->argument = sieve_argument_create(arg->ast, defarg->arg_def,
						      defarg->ext, 0);
	} else {
		arg->argument->def = defarg->arg_def;
		arg->argument->ext = defarg->ext;
	}

	if (defarg->arg_def != NULL && defarg->arg_def->validate != NULL)
		result = defarg->arg_def->validate(valdtr, &arg, cmd);

	valdtr->current_defarg = prev_defarg;

	return result;
}

bool sieve_validator_argument_activate_super(struct sieve_validator *valdtr,
					     struct sieve_command *cmd,
					     struct sieve_ast_argument *arg,
					     bool constant ATTR_UNUSED)
{
	struct sieve_default_argument *defarg;

	if (valdtr->current_defarg == NULL ||
	    valdtr->current_defarg->overrides == NULL)
		return FALSE;

	if (valdtr->current_defarg->overrides->arg_def == &string_argument) {
		switch (valdtr->current_defarg_type) {
		case SAT_CONST_STRING:
			if (!valdtr->current_defarg_constant) {
				valdtr->current_defarg_type = SAT_VAR_STRING;
				defarg = &valdtr->default_arguments[SAT_VAR_STRING];
			} else {
				defarg = valdtr->current_defarg->overrides;
			}
			break;
		case SAT_VAR_STRING:
			defarg = valdtr->current_defarg->overrides;
			break;
		default:
			return FALSE;
		}
	} else {
		defarg = valdtr->current_defarg->overrides;
	}

	return sieve_validator_argument_default_activate(valdtr, cmd,
							 defarg, arg);
}

/*
 * Argument Validation API
 */

bool sieve_validator_argument_activate(struct sieve_validator *valdtr,
				       struct sieve_command *cmd,
				       struct sieve_ast_argument *arg,
				       bool constant)
{
	struct sieve_default_argument *defarg;

	switch (sieve_ast_argument_type(arg)) {
	case SAAT_NUMBER:
		valdtr->current_defarg_type = SAT_NUMBER;
		break;
	case SAAT_STRING:
		valdtr->current_defarg_type = SAT_CONST_STRING;
		break;
	case SAAT_STRING_LIST:
		valdtr->current_defarg_type = SAT_STRING_LIST;
		break;
	default:
		return FALSE;
	}

	valdtr->current_defarg_constant = constant;
	defarg = &valdtr->default_arguments[valdtr->current_defarg_type];

	if (!constant && defarg->arg_def == &string_argument) {
		valdtr->current_defarg_type = SAT_VAR_STRING;
		defarg = &valdtr->default_arguments[SAT_VAR_STRING];
	}

	return sieve_validator_argument_default_activate(valdtr, cmd,
							 defarg, arg);
}

bool sieve_validate_positional_argument(struct sieve_validator *valdtr,
					struct sieve_command *cmd,
					struct sieve_ast_argument *arg,
					const char *arg_name,
					unsigned int arg_pos,
					enum sieve_ast_argument_type req_type)
{
	i_assert(arg != NULL);

	if (sieve_ast_argument_type(arg) != req_type &&
	    (sieve_ast_argument_type(arg) != SAAT_STRING ||
	     req_type != SAAT_STRING_LIST))
	{
		sieve_argument_validate_error(
			valdtr, arg,
			"the %s %s expects %s as argument %d (%s), "
			"but %s was found",
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd),
			sieve_ast_argument_type_name(req_type),
			arg_pos, arg_name, sieve_ast_argument_name(arg));
		return FALSE;
	}

	return TRUE;
}

bool sieve_validate_tag_parameter(struct sieve_validator *valdtr,
				  struct sieve_command *cmd,
				  struct sieve_ast_argument *tag,
				  struct sieve_ast_argument *param,
				  const char *arg_name, unsigned int arg_pos,
				  enum sieve_ast_argument_type req_type,
				  bool constant)
{
	i_assert(tag != NULL);

	if (param == NULL) {
		const char *position = (arg_pos == 0 ? "" :
			t_strdup_printf(" %d (%s)", arg_pos, arg_name));

		sieve_argument_validate_error(
			valdtr, tag,
			"the :%s tag for the %s %s requires %s as parameter%s, "
			"but no parameters were found",
			sieve_ast_argument_tag(tag),
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd),
			sieve_ast_argument_type_name(req_type), position);
		return FALSE;
	}

	if (sieve_ast_argument_type(param) != req_type &&
	    (sieve_ast_argument_type(param) != SAAT_STRING ||
	     req_type != SAAT_STRING_LIST))
	{
		const char *position = (arg_pos == 0 ? "" :
			t_strdup_printf(" %d (%s)", arg_pos, arg_name));

		sieve_argument_validate_error(
			valdtr, param,
			"the :%s tag for the %s %s requires %s as parameter%s, "
			"but %s was found",
			sieve_ast_argument_tag(tag),
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd),
			sieve_ast_argument_type_name(req_type),	position,
			sieve_ast_argument_name(param));
		return FALSE;
	}

	if (!sieve_validator_argument_activate(valdtr, cmd, param, constant))
		return FALSE;

	param->argument->id_code = tag->argument->id_code;

	return TRUE;
}

/*
 * Command argument validation
 */

static bool
sieve_validate_command_arguments(struct sieve_validator *valdtr,
				 struct sieve_command *cmd)
{
	int arg_count = cmd->def->positional_args;
	int real_count = 0;
	struct sieve_ast_argument *arg;
	struct sieve_command_registration *cmd_reg = cmd->reg;

	/* Resolve tagged arguments */
	arg = sieve_ast_argument_first(cmd->ast_node);
	while (arg != NULL) {
		void *arg_data = NULL;
		struct sieve_tag_registration *tag_reg;
		const struct sieve_argument_def *tag_def;

		if (sieve_ast_argument_type(arg) != SAAT_TAG) {
			arg = sieve_ast_argument_next(arg);
			continue;
		}

		tag_reg = sieve_validator_command_tag_get(valdtr, cmd,
							  arg, &arg_data);

		if (tag_reg == NULL) {
			sieve_argument_validate_error(
				valdtr, arg,
				"unknown tagged argument ':%s' for the %s %s "
				"(reported only once at first occurrence)",
				sieve_ast_argument_tag(arg),
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			sieve_validator_register_unknown_tag(
				valdtr, cmd_reg, sieve_ast_argument_tag(arg));
			return FALSE;
		}

		/* Check whether previously tagged as unknown */
		if (_tag_registration_is_unknown(tag_reg))
			return FALSE;

		tag_def = tag_reg->tag_def;

		/* Assign the tagged argument type to the ast for later
		   reference */
		arg->argument = sieve_argument_create(
			arg->ast, tag_def, tag_reg->ext, tag_reg->id_code);
		arg->argument->data = arg_data;

		arg = sieve_ast_argument_next(arg);
	}

	/* Validate tagged arguments */
	arg = sieve_ast_argument_first(cmd->ast_node);
	while (arg != NULL && sieve_ast_argument_type(arg) == SAAT_TAG) {
		const struct sieve_argument_def *tag_def = arg->argument->def;
		struct sieve_ast_argument *parg;

		/* Scan backwards for any duplicates */
		if ((tag_def->flags & SIEVE_ARGUMENT_FLAG_MULTIPLE) == 0) {
			parg = sieve_ast_argument_prev(arg);
			while (parg != NULL) {
				if ((sieve_ast_argument_type(parg) == SAAT_TAG &&
				     parg->argument->def == tag_def) ||
				    (arg->argument->id_code > 0 &&
				     parg->argument != NULL &&
				     parg->argument->id_code == arg->argument->id_code))
				{
					const char *tag_id = sieve_ast_argument_tag(arg);
					const char *tag_desc =
						strcmp(tag_def->identifier, tag_id) != 0 ?
						t_strdup_printf("%s argument (:%s)",
							        tag_def->identifier, tag_id) :
						t_strdup_printf(":%s argument",
								tag_def->identifier);

					sieve_argument_validate_error(
						valdtr, arg,
						"encountered duplicate %s for the %s %s",
						tag_desc, sieve_command_identifier(cmd),
						sieve_command_type_name(cmd));

					return FALSE;
				}

				parg = sieve_ast_argument_prev(parg);
			}
		}

		/* Call the validation function for the tag (if present)
		     Fail if the validation fails:
		       Let's not whine multiple	times about a single command
		       having multiple bad arguments...
		 */
		if (tag_def->validate != NULL) {
			if (!tag_def->validate(valdtr, &arg, cmd))
				return FALSE;
		} else {
			arg = sieve_ast_argument_next(arg);
		}
	}

	/* Remaining arguments should be positional (tags are not allowed
	   here) */
	cmd->first_positional = arg;

	while (arg != NULL) {
		if (sieve_ast_argument_type(arg) == SAAT_TAG) {
			sieve_argument_validate_error(
				valdtr, arg,
				"encountered an unexpected tagged argument ':%s' "
				"while validating positional arguments for the %s %s",
				sieve_ast_argument_tag(arg),
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;
		}

		real_count++;

		arg = sieve_ast_argument_next(arg);
	}

	/* Check the required count versus the real number of arguments */
	if (arg_count >= 0 && real_count != arg_count) {
		sieve_command_validate_error(
			valdtr, cmd,
			"the %s %s requires %d positional argument(s), "
			"but %d is/are specified",
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd),
			arg_count, real_count);
		return FALSE;
	}

	/* Call initial validation for persistent arguments */
	if (array_is_created(&cmd_reg->persistent_tags)) {
		struct sieve_tag_registration *const *regs;
		unsigned int i, reg_count;

		regs = array_get(&cmd_reg->persistent_tags, &reg_count);
		for (i = 0; i < reg_count; i++) {
			const struct sieve_argument_def *tag_def =
				regs[i]->tag_def;

			if (tag_def != NULL &&
			    tag_def->validate_persistent != NULL) {
				/* To be sure */
				if (!tag_def->validate_persistent(
					valdtr, cmd, regs[i]->ext))
	  				return FALSE;
			}
		}
	}

	return TRUE;
}

static bool
sieve_validate_arguments_context(struct sieve_validator *valdtr,
				 struct sieve_command *cmd)
{
	struct sieve_ast_argument *arg =
		sieve_command_first_argument(cmd);

	while (arg != NULL) {
		const struct sieve_argument *argument = arg->argument;

		if (argument != NULL && argument->def != NULL &&
		    argument->def->validate_context != NULL) {

			if (!argument->def->validate_context(valdtr, arg, cmd))
				return FALSE;
		}

		arg = sieve_ast_argument_next(arg);
	}

	return TRUE;
}

/*
 * Command Validation API
 */

static bool
sieve_validate_command_subtests(struct sieve_validator *valdtr,
				struct sieve_command *cmd,
				const unsigned int count)
{
	switch (count) {
	case 0:
	 	if (sieve_ast_test_count(cmd->ast_node) > 0) {
			/* Unexpected command specified */
			enum sieve_command_type ctype = SCT_NONE;
			struct sieve_command_registration *cmd_reg;
			struct sieve_ast_node *test =
				sieve_ast_test_first(cmd->ast_node);

			cmd_reg = sieve_validator_find_command_registration(
				valdtr, test->identifier);

			/* First check what we are dealing with */
			if (cmd_reg != NULL && cmd_reg->cmd_def != NULL)
				ctype = cmd_reg->cmd_def->type;

			switch (ctype) {
			case SCT_TEST: /* Spurious test */
			case SCT_HYBRID:
				sieve_command_validate_error(
					valdtr, cmd,
					"the %s %s accepts no sub-tests, "
					"but tests are specified",
					sieve_command_identifier(cmd),
					sieve_command_type_name(cmd));
				break;
			case SCT_NONE: /* Unknown command */
				/* Is it perhaps a tag for which the ':' was
				   omitted ? */
				if (sieve_validator_command_tag_exists(
					valdtr, cmd, test->identifier)) {
					sieve_command_validate_error(
						valdtr, cmd,
						"missing colon ':' before ':%s' tag in %s %s",
						test->identifier,
						sieve_command_identifier(cmd),
						sieve_command_type_name(cmd));
					break;
				}
				/* Fall through */
			case SCT_COMMAND:
				sieve_command_validate_error(
					valdtr, cmd,
					"missing semicolon ';' after %s %s",
					sieve_command_identifier(cmd),
					sieve_command_type_name(cmd));
				break;
			}
			return FALSE;
		}
		break;
	case 1:
		if (sieve_ast_test_count(cmd->ast_node) == 0) {
			sieve_command_validate_error(
				valdtr, cmd,
				"the %s %s requires one sub-test, "
				"but none is specified",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;

		} else if (sieve_ast_test_count(cmd->ast_node) > 1 ||
			   cmd->ast_node->test_list) {
			sieve_command_validate_error(
				valdtr, cmd,
				"the %s %s requires one sub-test, "
				"but a list of tests is specified",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;
		}
		break;
	default:
		if (sieve_ast_test_count(cmd->ast_node) == 0) {
			sieve_command_validate_error(
				valdtr, cmd,
				"the %s %s requires a list of sub-tests, "
				"but none is specified",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;
		} else if (sieve_ast_test_count(cmd->ast_node) == 1 &&
			   !cmd->ast_node->test_list) {
			sieve_command_validate_error(
				valdtr, cmd,
				"the %s %s requires a list of sub-tests, "
				"but a single test is specified",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;
		}
		break;
	}

	return TRUE;
}

static bool
sieve_validate_command_block(struct sieve_validator *valdtr,
			     struct sieve_command *cmd, bool block_allowed,
			     bool block_required)
{
	i_assert(cmd->ast_node->type == SAT_COMMAND);

	if (block_required) {
		if (!cmd->ast_node->block) {
			sieve_command_validate_error(
				valdtr, cmd,
				"the %s command requires a command block, "
				"but it is missing",
				sieve_command_identifier(cmd));
			return FALSE;
		}
	} else if (!block_allowed && cmd->ast_node->block) {
		sieve_command_validate_error(
			valdtr, cmd,
			"the %s command does not accept a command block, "
			"but one is specified anyway",
			sieve_command_identifier(cmd));
		return FALSE;
	}

	return TRUE;
}

/*
 * AST Validation
 */

static bool
sieve_validate_test_list(struct sieve_validator *valdtr,
			 struct sieve_ast_node *test_list, int *const_r);
static bool
sieve_validate_block(struct sieve_validator *valdtr,
		     struct sieve_ast_node *block);
static bool
sieve_validate_command(struct sieve_validator *valdtr,
		       struct sieve_ast_node *cmd_node, int *const_r);

static bool
sieve_validate_command_context(struct sieve_validator *valdtr,
			       struct sieve_ast_node *cmd_node)
{
	enum sieve_ast_type ast_type = sieve_ast_node_type(cmd_node);
	struct sieve_command_registration *cmd_reg;

	i_assert(ast_type == SAT_TEST || ast_type == SAT_COMMAND);

	/* Verify the command specified by this node */
	cmd_reg = sieve_validator_find_command_registration(
		valdtr, cmd_node->identifier);

	if (cmd_reg != NULL && cmd_reg->cmd_def != NULL) {
		const struct sieve_command_def *cmd_def = cmd_reg->cmd_def;

		/* Identifier = "" when the command was previously marked as
		   unknown */
		if (*(cmd_def->identifier) != '\0') {
			if ((cmd_def->type == SCT_COMMAND && ast_type == SAT_TEST) ||
			    (cmd_def->type == SCT_TEST && ast_type == SAT_COMMAND)) {
				sieve_validator_error(
					valdtr, cmd_node->source_line,
					"attempted to use %s '%s' as %s",
					sieve_command_def_type_name(cmd_def),
					cmd_node->identifier,
					sieve_ast_type_name(ast_type));
			 	return FALSE;
			}

			cmd_node->command = sieve_command_create(
				cmd_node, cmd_reg->ext, cmd_def, cmd_reg);
		} else {
			return FALSE;
		}
	} else {
		sieve_validator_error(
			valdtr, cmd_node->source_line,
			"unknown %s '%s' (only reported once at first occurrence)",
			sieve_ast_type_name(ast_type), cmd_node->identifier);

		sieve_validator_register_unknown_command(
			valdtr, cmd_node->identifier);
		return FALSE;
	}

	return TRUE;
}

static bool
sieve_validate_command(struct sieve_validator *valdtr,
		       struct sieve_ast_node *cmd_node, int *const_r)
{
	enum sieve_ast_type ast_type = sieve_ast_node_type(cmd_node);
	struct sieve_command *cmd =
		(cmd_node == NULL ? NULL : cmd_node->command);
	const struct sieve_command_def *cmd_def =
		(cmd != NULL ? cmd->def : NULL);
	bool result = TRUE;

	i_assert(ast_type == SAT_TEST || ast_type == SAT_COMMAND);

	if (cmd_def != NULL && *(cmd_def->identifier) != '\0') {
		if (cmd_def->pre_validate == NULL ||
		    cmd_def->pre_validate(valdtr, cmd)) {
			/* Check argument syntax */
			if (!sieve_validate_command_arguments(valdtr, cmd)) {
				result = FALSE;

				/* A missing ':' causes a tag to become a test.
				   This can be the cause of the arguments
				   validation failing. Therefore we must produce
				   an error for the sub-tests as well if
				   appropriate. */
				(void)sieve_validate_command_subtests(
					valdtr, cmd, cmd_def->subtests);
			} else if (!sieve_validate_command_subtests(
				valdtr, cmd, cmd_def->subtests) ||
				(ast_type == SAT_COMMAND &&
				 !sieve_validate_command_block(
					valdtr, cmd, cmd_def->block_allowed,
					cmd_def->block_required))) {
				result = FALSE;
			} else {
				/* Call command validation function if specified
				 */
				if (cmd_def->validate != NULL) {
					result = cmd_def->validate(valdtr, cmd) &&
						result;
				}
			}
		} else {
			/* If pre-validation fails, don't bother to validate
			   further as context might be missing and doing so is
			   not very useful for further error reporting anyway */
			valdtr->failed = TRUE;
			return FALSE;
		}

		result = result && sieve_validate_arguments_context(valdtr, cmd);
	}
	if (!result)
		valdtr->failed = TRUE;

	/*
	 * Descend further into the AST
	 */

	if (cmd_def != NULL) {
		/* Tests */
		if (cmd_def->subtests > 0) {
			if (result ||
			    sieve_errors_more_allowed(valdtr->ehandler)) {
				result = sieve_validate_test_list(
					valdtr, cmd_node, const_r) && result;
			}
		} else if (result) {
			if (cmd_def->validate_const != NULL) {
				(void)cmd_def->validate_const(
					valdtr, cmd, const_r, -1);
			} else {
				*const_r = -1;
			}
		}

		/* Skip block if result of test is const FALSE */
		if (result && *const_r == 0)
			return TRUE;

		/* Command block */
		if (cmd_def->block_allowed && ast_type == SAT_COMMAND &&
		    (result || sieve_errors_more_allowed(valdtr->ehandler))) {
			result = sieve_validate_block(valdtr, cmd_node) &&
				result;
		}
	}

	return result;
}

static bool
sieve_validate_test_list(struct sieve_validator *valdtr,
			 struct sieve_ast_node *test_node, int *const_r)
{
	struct sieve_command *tst = test_node->command;
	const struct sieve_command_def *tst_def =
		(tst != NULL ? tst->def : NULL);
	struct sieve_ast_node *test;
	bool result = TRUE;

	if (tst_def != NULL && tst_def->validate_const != NULL) {
		if (!tst_def->validate_const(valdtr, tst, const_r, -2))
			return TRUE;
	}

	test = sieve_ast_test_first(test_node);
	while (test != NULL &&
	       (result || sieve_errors_more_allowed(valdtr->ehandler))) {
		int const_value = -2;

		result = sieve_validate_command_context(valdtr, test) &&
			sieve_validate_command(valdtr, test, &const_value) &&
			result;

		if (!result)
			valdtr->failed = TRUE;
		else {
			if (tst_def != NULL &&
			    tst_def->validate_const != NULL) {
				if (!tst_def->validate_const(
					valdtr, tst, const_r, const_value))
					return TRUE;
			} else {
				*const_r = -1;
			}
		}

		if (result && const_value >= 0)
			test = sieve_ast_node_detach(test);
		else
			test = sieve_ast_test_next(test);
	}

	return result;
}

static bool
sieve_validate_block(struct sieve_validator *valdtr,
		     struct sieve_ast_node *block)
{
	bool result = TRUE, fatal = FALSE, already_failed = valdtr->failed;
	struct sieve_ast_node *cmd_node, *next;

	T_BEGIN {
		cmd_node = sieve_ast_command_first(block);
		while (!fatal && cmd_node != NULL &&
		       (result ||
			sieve_errors_more_allowed(valdtr->ehandler))) {
			bool command_success;
			int const_value = -2;

			next = sieve_ast_command_next(cmd_node);

	 		/* Check if this is the first non-require command */
			if (sieve_ast_node_type(block) == SAT_ROOT &&
			    !valdtr->finished_require &&
			    strcasecmp(cmd_node->identifier,
				       cmd_require.identifier) != 0) {
				const struct sieve_validator_extension_reg *extrs;
				const struct sieve_extension *const *exts;
				unsigned int ext_count, i;

				valdtr->finished_require = TRUE;

				/* Load implicit extensions */
				exts = sieve_extensions_get_all(valdtr->svinst, &ext_count);
				for (i = 0; i < ext_count; i++) {
					if (exts[i]->implicit) {
						(void)sieve_validator_extension_load(
							valdtr, NULL, NULL, exts[i], TRUE);
					}
				}

				/* Validate all 'require'd extensions */
				extrs = array_get(&valdtr->extensions, &ext_count);
				for (i = 0; i < ext_count; i++) {
					if (extrs[i].loaded && extrs[i].valext != NULL &&
					    extrs[i].valext->validate != NULL) {
						if (!extrs[i].valext->validate(
							extrs[i].ext, valdtr,
							extrs[i].context, extrs[i].arg,
							extrs[i].required)) {
							fatal = TRUE;
							break;
						}
					}
				}
			}

			command_success =
				sieve_validate_command_context(valdtr, cmd_node);
			result = command_success && result;

			if (!result || fatal)
				valdtr->failed = TRUE;

			result = !fatal &&
				sieve_validate_command(valdtr, cmd_node,
						       &const_value) && result;

			cmd_node = next;
		}
	} T_END;

	/* Assert that this function returns FALSE if failure is caused here. */
	i_assert(!valdtr->failed || already_failed || !result || fatal);
	return result && !fatal;
}

bool sieve_validator_run(struct sieve_validator *valdtr)
{
	return sieve_validate_block(valdtr, sieve_ast_root(valdtr->ast));
}

/*
 * Validator object registry
 */

struct sieve_validator_object_reg {
	const struct sieve_object_def *obj_def;
	const struct sieve_extension *ext;
};

struct sieve_validator_object_registry {
	struct sieve_validator *valdtr;
	ARRAY(struct sieve_validator_object_reg) registrations;
};

struct sieve_validator_object_registry *
sieve_validator_object_registry_get(struct sieve_validator *valdtr,
				    const struct sieve_extension *ext)
{
	return (struct sieve_validator_object_registry *)
		sieve_validator_extension_get_context(valdtr, ext);
}

void sieve_validator_object_registry_add(
	struct sieve_validator_object_registry *regs,
	const struct sieve_extension *ext,
	const struct sieve_object_def *obj_def)
{
	struct sieve_validator_object_reg *reg;

	reg = array_append_space(&regs->registrations);
	reg->ext = ext;
	reg->obj_def = obj_def;
}

bool sieve_validator_object_registry_find(
	struct sieve_validator_object_registry *regs, const char *identifier,
	struct sieve_object *obj)
{
	unsigned int i;

	for (i = 0; i < array_count(&regs->registrations); i++) {
		const struct sieve_validator_object_reg *reg =
			array_idx(&regs->registrations, i);

		if (strcasecmp(reg->obj_def->identifier, identifier) == 0) {
			if (obj != NULL) {
				obj->def = reg->obj_def;
				obj->ext = reg->ext;
			}
			return TRUE;
		}
	}

	return FALSE;
}

struct sieve_validator_object_registry *
sieve_validator_object_registry_create(struct sieve_validator *valdtr)
{
	pool_t pool = valdtr->pool;
	struct sieve_validator_object_registry *regs =
		p_new(pool, struct sieve_validator_object_registry, 1);

	/* Setup registry */
	p_array_init(&regs->registrations, valdtr->pool, 4);

	regs->valdtr = valdtr;

	return regs;
}

struct sieve_validator_object_registry *
sieve_validator_object_registry_init(struct sieve_validator *valdtr,
				     const struct sieve_extension *ext)
{
	struct sieve_validator_object_registry *regs =
		sieve_validator_object_registry_create(valdtr);

	sieve_validator_extension_set_context(valdtr, ext, regs);
	return regs;
}

/*
 * Error handling
 */

#undef sieve_validator_error
void sieve_validator_error(struct sieve_validator *valdtr,
			   const char *csrc_filename, unsigned int csrc_linenum,
			   unsigned int source_line, const char *fmt, ...)
{
	struct sieve_error_params params = {
		.log_type = LOG_TYPE_ERROR,
		.csrc = {
			.filename = csrc_filename,
			.linenum = csrc_linenum,
		},
	};
	va_list args;

	params.location =
		sieve_error_script_location(valdtr->script, source_line);

	va_start(args, fmt);
	sieve_logv(valdtr->ehandler, &params, fmt, args);
	va_end(args);
}

#undef sieve_validator_warning
void sieve_validator_warning(struct sieve_validator *valdtr,
			     const char *csrc_filename,
			     unsigned int csrc_linenum,
			     unsigned int source_line, const char *fmt, ...)
{
	struct sieve_error_params params = {
		.log_type = LOG_TYPE_WARNING,
		.csrc = {
			.filename = csrc_filename,
			.linenum = csrc_linenum,
		},
	};
	va_list args;

	params.location =
		sieve_error_script_location(valdtr->script, source_line);

	va_start(args, fmt);
	sieve_logv(valdtr->ehandler, &params, fmt, args);
	va_end(args);

}
