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 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); }
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 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); }
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; }
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; }
static bool tst_ihave_validate (struct sieve_validator *valdtr, struct sieve_command *tst) { struct _capability { const struct sieve_extension *ext; struct sieve_ast_argument *arg; }; struct sieve_ast_argument *arg = tst->first_positional; struct sieve_ast_argument *stritem; enum sieve_compile_flags cpflags = sieve_validator_compile_flags(valdtr); bool no_global = ( (cpflags & SIEVE_COMPILE_FLAG_NOGLOBAL) != 0 ); ARRAY(struct _capability) capabilities; struct _capability capability; const struct _capability *caps; unsigned int i, count; bool all_known = TRUE; t_array_init(&capabilities, 64); tst->data = (void *) FALSE; /* Check stringlist argument */ if ( !sieve_validate_positional_argument (valdtr, tst, arg, "capabilities", 1, SAAT_STRING_LIST) ) { return FALSE; } switch ( sieve_ast_argument_type(arg) ) { case SAAT_STRING: /* Single string */ capability.arg = arg; capability.ext = sieve_extension_get_by_name (tst->ext->svinst, sieve_ast_argument_strc(arg)); if ( capability.ext == NULL || (no_global && capability.ext->global)) { all_known = FALSE; ext_ihave_ast_add_missing_extension (tst->ext, tst->ast_node->ast, sieve_ast_argument_strc(arg)); } else { array_append(&capabilities, &capability, 1); } break; case SAAT_STRING_LIST: /* String list */ stritem = sieve_ast_strlist_first(arg); while ( stritem != NULL ) { capability.arg = stritem; capability.ext = sieve_extension_get_by_name (tst->ext->svinst, sieve_ast_argument_strc(stritem)); if ( capability.ext == NULL || (no_global && capability.ext->global)) { all_known = FALSE; ext_ihave_ast_add_missing_extension (tst->ext, tst->ast_node->ast, sieve_ast_argument_strc(stritem)); } else { array_append(&capabilities, &capability, 1); } stritem = sieve_ast_strlist_next(stritem); } break; default: i_unreached(); } if ( !all_known ) return TRUE; /* RFC 5463, Section 4, page 4: * * The "ihave" extension is designed to be used with other extensions * that add tests, actions, comparators, or arguments. Implementations * MUST NOT allow it to be used with extensions that change the * underlying Sieve grammar, or extensions like encoded-character * [RFC5228], or variables [RFC5229] that change how the content of * Sieve scripts are interpreted. The test MUST fail and the extension * MUST NOT be enabled if such usage is attempted. * * FIXME: current implementation of this restriction is hardcoded and * therefore highly inflexible */ caps = array_get(&capabilities, &count); for ( i = 0; i < count; i++ ) { if ( sieve_extension_name_is(caps[i].ext, "variables") || sieve_extension_name_is(caps[i].ext, "encoded-character") ) return TRUE; } /* Load all extensions */ caps = array_get(&capabilities, &count); for ( i = 0; i < count; i++ ) { if ( !sieve_validator_extension_load (valdtr, tst, caps[i].arg, caps[i].ext) ) return FALSE; } tst->data = (void *) TRUE; return TRUE; }