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;
}
