static bool cmd_test_config_set_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
/* Check syntax:
* <setting: string> <value: string>
*/
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "setting", 1, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, cmd, arg, FALSE) )
return FALSE;
arg = sieve_ast_argument_next(arg);
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "value", 2, SAAT_STRING) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, cmd, arg, FALSE);
}
static bool cmd_fileinto_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "folder", 1, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, cmd, arg, FALSE) )
return FALSE;
/* Check name validity when folder argument is not a variable */
if ( sieve_argument_is_string_literal(arg) ) {
const char *folder = sieve_ast_argument_strc(arg), *error;
if ( !sieve_mailbox_check_name(folder, &error) ) {
sieve_command_validate_error(valdtr, cmd,
"invalid folder name `%s' specified for fileinto command: %s",
str_sanitize(folder, 256), error);
return FALSE;
}
}
return TRUE;
}
static bool cmd_test_binary_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "binary-name", 1, SAAT_STRING) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, cmd, arg, FALSE);
}
static bool tst_mailboxexists_validate
(struct sieve_validator *valdtr, struct sieve_command *tst)
{
struct sieve_ast_argument *arg = tst->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, tst, arg, "mailbox-names", 1, SAAT_STRING_LIST) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, tst, arg, FALSE);
}
static bool tst_vnotifym_validate
(struct sieve_validator *valdtr, struct sieve_command *tst)
{
struct sieve_ast_argument *arg = tst->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, tst, arg, "notification-uris", 1, SAAT_STRING_LIST) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, tst, arg, FALSE);
}
static bool cmd_error_validate
(struct sieve_validator *valdtr, struct sieve_command *tst)
{
struct sieve_ast_argument *arg = tst->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, tst, arg, "message", 1, SAAT_STRING) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, tst, arg, FALSE);
}
static bool cmd_test_imap_metadata_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "annotation", 2, SAAT_STRING) )
return FALSE;
if (!sieve_validator_argument_activate(valdtr, cmd, arg, FALSE))
return FALSE;
arg = sieve_ast_argument_next(arg);
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "value", 3, SAAT_STRING) )
return FALSE;
if (!sieve_validator_argument_activate(valdtr, cmd, arg, FALSE))
return FALSE;
return TRUE;
}
static bool tst_exists_validate
(struct sieve_validator *valdtr, struct sieve_command *tst)
{
struct sieve_ast_argument *arg = tst->first_positional;
if ( !sieve_validate_positional_argument
(valdtr, tst, arg, "header names", 1, SAAT_STRING_LIST) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, tst, arg, FALSE) )
return FALSE;
return sieve_command_verify_headers_argument(valdtr, arg);
}
static bool tag_match_type_validate
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct cmd_denotify_context_data *cmd_data =
(struct cmd_denotify_context_data *) cmd->data;
struct sieve_ast_argument *tag = *arg;
if ( !match_type_tag.validate(valdtr, arg, cmd) )
return FALSE;
if ( *arg == NULL ) {
sieve_argument_validate_error(valdtr, tag,
"the MATCH-TYPE argument (:%s) for the denotify command requires "
"an additional key-string parameter, but no more arguments were found",
sieve_ast_argument_tag(tag));
return FALSE;
}
if ( sieve_ast_argument_type(*arg) != SAAT_STRING )
{
sieve_argument_validate_error(valdtr, *arg,
"the MATCH-TYPE argument (:%s) for the denotify command requires "
"an additional key-string parameter, but %s was found",
sieve_ast_argument_tag(tag), sieve_ast_argument_name(*arg));
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, cmd, *arg, FALSE) )
return FALSE;
tag->argument->def = &match_type_tag;
tag->argument->ext = NULL;
(*arg)->argument->id_code = OPT_MATCH_KEY;
cmd_data->match_key_arg = *arg;
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
static bool tst_body_validate
(struct sieve_validator *valdtr, struct sieve_command *tst)
{
struct sieve_ast_argument *arg = tst->first_positional;
const struct sieve_match_type mcht_default =
SIEVE_MATCH_TYPE_DEFAULT(is_match_type);
const struct sieve_comparator cmp_default =
SIEVE_COMPARATOR_DEFAULT(i_ascii_casemap_comparator);
if ( !sieve_validate_positional_argument
(valdtr, tst, arg, "key list", 1, SAAT_STRING_LIST) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, tst, arg, FALSE) )
return FALSE;
/* Validate the key argument to a specified match type */
return sieve_match_type_validate
(valdtr, tst, arg, &mcht_default, &cmp_default);
}
static bool cmd_test_set_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
/* Check arguments */
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "object", 1, SAAT_STRING) ) {
return FALSE;
}
if ( !testsuite_object_argument_activate(valdtr, arg, cmd) )
return FALSE;
arg = sieve_ast_argument_next(arg);
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "value", 2, SAAT_STRING) ) {
return FALSE;
}
return sieve_validator_argument_activate(valdtr, cmd, arg, FALSE);
}
bool sieve_extprogram_command_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
struct sieve_ast_argument *stritem;
struct _arg_validate_context actx;
string_t *program_name;
if ( arg == NULL ) {
sieve_command_validate_error(valdtr, cmd,
"the %s %s expects at least one positional argument, but none was found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
/* <program-name: string> argument */
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "program-name", 1, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, cmd, arg, FALSE) )
return FALSE;
/* Variables are not allowed */
if ( !sieve_argument_is_string_literal(arg) ) {
sieve_argument_validate_error(valdtr, arg,
"the %s %s requires a constant string "
"for its program-name argument",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
/* Check program name */
program_name = sieve_ast_argument_str(arg);
if ( !sieve_extprogram_name_is_valid(program_name) ) {
sieve_argument_validate_error(valdtr, arg,
"%s %s: invalid program name '%s'",
sieve_command_identifier(cmd), sieve_command_type_name(cmd),
str_sanitize(str_c(program_name), 80));
return FALSE;
}
/* Optional <arguments: string-list> argument */
arg = sieve_ast_argument_next(arg);
if ( arg == NULL )
return TRUE;
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "arguments", 2, SAAT_STRING_LIST) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate(valdtr, cmd, arg, FALSE) )
return FALSE;
/* Check arguments */
actx.valdtr = valdtr;
actx.cmd = cmd;
stritem = arg;
if ( sieve_ast_stringlist_map
(&stritem, (void *)&actx, _arg_validate) <= 0 ) {
return FALSE;
}
if ( sieve_ast_argument_next(arg) != NULL ) {
sieve_command_validate_error(valdtr, cmd,
"the %s %s expects at most two positional arguments, but more were found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
return TRUE;
}
bool ext_imap4flags_command_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
struct sieve_ast_argument *arg2;
const struct sieve_extension *var_ext;
/* Check arguments */
if ( arg == NULL ) {
sieve_command_validate_error(valdtr, cmd,
"the %s %s expects at least one argument, but none was found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
if ( sieve_ast_argument_type(arg) != SAAT_STRING &&
sieve_ast_argument_type(arg) != SAAT_STRING_LIST )
{
sieve_argument_validate_error(valdtr, arg,
"the %s %s expects either a string (variable name) or "
"a string-list (list of flags) as first argument, but %s was found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd),
sieve_ast_argument_name(arg));
return FALSE;
}
arg2 = sieve_ast_argument_next(arg);
if ( arg2 != NULL ) {
/* First, check syntax sanity */
if ( sieve_ast_argument_type(arg) != SAAT_STRING )
{
if ( sieve_command_is(cmd, tst_hasflag) ) {
if ( sieve_ast_argument_type(arg) != SAAT_STRING_LIST ) {
sieve_argument_validate_error(valdtr, arg,
"if a second argument is specified for the hasflag, the first "
"must be a string-list (variable-list), but %s was found",
sieve_ast_argument_name(arg));
return FALSE;
}
} else {
sieve_argument_validate_error(valdtr, arg,
"if a second argument is specified for the %s %s, the first "
"must be a string (variable name), but %s was found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd),
sieve_ast_argument_name(arg));
return FALSE;
}
}
/* Then, check whether the second argument is permitted */
var_ext = sieve_ext_variables_get_extension(cmd->ext->svinst);
if ( var_ext == NULL || !sieve_ext_variables_is_active(var_ext, valdtr) )
{
sieve_argument_validate_error(valdtr,arg,
"the %s %s only allows for the specification of a "
"variable name when the variables extension is active",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
if ( !sieve_variable_argument_activate
(var_ext, valdtr, cmd, arg, !sieve_command_is(cmd, tst_hasflag) ) )
return FALSE;
if ( sieve_ast_argument_type(arg2) != SAAT_STRING &&
sieve_ast_argument_type(arg2) != SAAT_STRING_LIST )
{
sieve_argument_validate_error(valdtr, arg2,
"the %s %s expects a string list (list of flags) as "
"second argument when two arguments are specified, "
"but %s was found",
sieve_command_identifier(cmd), sieve_command_type_name(cmd),
sieve_ast_argument_name(arg2));
return FALSE;
}
} else
arg2 = arg;
if ( !sieve_validator_argument_activate(valdtr, cmd, arg2, FALSE) )
return FALSE;
if ( !sieve_command_is(cmd, tst_hasflag) &&
sieve_argument_is_string_literal(arg2) ) {
struct ext_imap4flags_iter fiter;
const char *flag;
/* Warn the user about validity of verifiable flags */
ext_imap4flags_iter_init(&fiter, sieve_ast_argument_str(arg));
while ( (flag=ext_imap4flags_iter_get_flag(&fiter)) != NULL ) {
if ( !sieve_ext_imap4flags_flag_is_valid(flag) ) {
sieve_argument_validate_warning(valdtr, arg,
"IMAP flag '%s' specified for the %s command is invalid "
"and will be ignored (only first invalid is reported)",
str_sanitize(flag, 64), sieve_command_identifier(cmd));
break;
}
}
}
return TRUE;
}
static bool cmd_report_validate
(struct sieve_validator *valdtr, struct sieve_command *cmd)
{
struct sieve_ast_argument *arg = cmd->first_positional;
/* type */
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "feedback-type", 1, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate
(valdtr, cmd, arg, FALSE) )
return FALSE;
if ( sieve_argument_is_string_literal(arg) ) {
string_t *fbtype = sieve_ast_argument_str(arg);
const char *feedback_type;
T_BEGIN {
/* Check feedback type */
feedback_type = ext_vnd_report_parse_feedback_type
(str_c(fbtype));
if ( feedback_type == NULL ) {
sieve_argument_validate_error(valdtr, arg,
"specified feedback type `%s' is invalid",
str_sanitize(str_c(fbtype),128));
}
} T_END;
if ( feedback_type == NULL )
return FALSE;
}
arg = sieve_ast_argument_next(arg);
/* message */
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "message", 2, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate
(valdtr, cmd, arg, FALSE) )
return FALSE;
arg = sieve_ast_argument_next(arg);
/* address */
if ( !sieve_validate_positional_argument
(valdtr, cmd, arg, "address", 3, SAAT_STRING) ) {
return FALSE;
}
if ( !sieve_validator_argument_activate
(valdtr, cmd, arg, FALSE) )
return FALSE;
/* We can only assess the validity of the outgoing address when it is
* a string literal. For runtime-generated strings this needs to be
* done at runtime.
*/
if ( sieve_argument_is_string_literal(arg) ) {
string_t *address = sieve_ast_argument_str(arg);
const char *error;
const char *norm_address;
T_BEGIN {
/* Verify and normalize the address to 'local_part@domain' */
norm_address = sieve_address_normalize(address, &error);
if ( norm_address == NULL ) {
sieve_argument_validate_error(valdtr, arg,
"specified redirect address `%s' is invalid: %s",
str_sanitize(str_c(address),128), error);
} else {
/* Replace string literal in AST */
sieve_ast_argument_string_setc(arg, norm_address);
}
} T_END;
return ( norm_address != NULL );
}
return TRUE;
}
