static bool cmd_include_validate_location_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct cmd_include_context_data *ctx_data =
(struct cmd_include_context_data *) cmd->data;
if ( ctx_data->location_assigned) {
sieve_argument_validate_error(valdtr, *arg,
"include: cannot use location tags ':personal' and ':global' "
"multiple times");
return FALSE;
}
if ( sieve_argument_is(*arg, include_personal_tag) )
ctx_data->location = EXT_INCLUDE_LOCATION_PERSONAL;
else if ( sieve_argument_is(*arg, include_global_tag) )
ctx_data->location = EXT_INCLUDE_LOCATION_GLOBAL;
else
return FALSE;
ctx_data->location_assigned = TRUE;
/* Delete this tag (for now) */
*arg = sieve_ast_arguments_detach(*arg, 1);
return TRUE;
}
static bool cmd_execute_validate_output_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
struct sieve_extprograms_config *ext_config =
(struct sieve_extprograms_config *) cmd->ext->context;
if ( ext_config == NULL || ext_config->var_ext == NULL ||
!sieve_ext_variables_is_active(ext_config->var_ext, valdtr) ) {
sieve_argument_validate_error(valdtr,*arg,
"the %s %s only allows for the specification of an "
":output argument when the variables extension is active",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg, 1);
if ( !sieve_variable_argument_activate
(ext_config->var_ext, valdtr, cmd, *arg, TRUE) )
return FALSE;
(*arg)->argument->id_code = tag->argument->id_code;
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
static bool cmd_execute_validate_input_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
if ( (bool) cmd->data ) {
sieve_argument_validate_error(valdtr, *arg,
"multiple :input or :pipe arguments specified for the %s %s",
sieve_command_identifier(cmd), sieve_command_type_name(cmd));
return FALSE;
}
cmd->data = (void *) TRUE;
/* Skip tag */
*arg = sieve_ast_argument_next(*arg);
if ( sieve_argument_is(tag, execute_input_tag) ) {
/* Check syntax:
* :input <input-data: string>
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, FALSE) ) {
return FALSE;
}
/* Assign tag parameters */
tag->parameters = *arg;
*arg = sieve_ast_arguments_detach(*arg,1);
}
return TRUE;
}
static bool cmd_vacation_validate_number_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
const struct sieve_extension *ext = sieve_argument_ext(*arg);
const struct ext_vacation_config *config =
(const struct ext_vacation_config *) ext->context;
struct sieve_ast_argument *tag = *arg;
sieve_number_t period, seconds;
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg,1);
/* Check syntax:
* :days number
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_NUMBER, FALSE) ) {
return FALSE;
}
period = sieve_ast_argument_number(*arg);
if ( sieve_argument_is(tag, vacation_days_tag) ) {
seconds = period * (24*60*60);
} else if ( sieve_argument_is(tag, vacation_seconds_tag) ) {
seconds = period;
} else {
i_unreached();
}
/* Enforce :seconds >= min_period */
if ( seconds < config->min_period ) {
seconds = config->min_period;
sieve_argument_validate_warning(valdtr, *arg,
"specified :%s value '%lu' is under the minimum",
sieve_argument_identifier(tag), (unsigned long) period);
/* Enforce :days <= max_period */
} else if ( config->max_period > 0 && seconds > config->max_period ) {
seconds = config->max_period;
sieve_argument_validate_warning(valdtr, *arg,
"specified :%s value '%lu' is over the maximum",
sieve_argument_identifier(tag), (unsigned long) period);
}
sieve_ast_argument_number_set(*arg, seconds);
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
static bool tag_body_transform_validate
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
enum tst_body_transform transform;
struct sieve_ast_argument *tag = *arg;
/* BODY-TRANSFORM:
* :raw
* / :content <content-types: string-list>
* / :text
*/
if ( (bool) cmd->data ) {
sieve_argument_validate_error(valdtr, *arg,
"the :raw, :content and :text arguments for the body test are mutually "
"exclusive, but more than one was specified");
return FALSE;
}
/* Skip tag */
*arg = sieve_ast_argument_next(*arg);
/* :content tag has a string-list argument */
if ( sieve_argument_is(tag, body_raw_tag) )
transform = TST_BODY_TRANSFORM_RAW;
else if ( sieve_argument_is(tag, body_text_tag) )
transform = TST_BODY_TRANSFORM_TEXT;
else if ( sieve_argument_is(tag, body_content_tag) ) {
/* Check syntax:
* :content <content-types: string-list>
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING_LIST, FALSE) ) {
return FALSE;
}
/* Assign tag parameters */
tag->parameters = *arg;
*arg = sieve_ast_arguments_detach(*arg,1);
transform = TST_BODY_TRANSFORM_CONTENT;
} else
return FALSE;
/* Signal the presence of this tag */
cmd->data = (void *) TRUE;
/* Assign context data */
tag->argument->data = (void *) transform;
return TRUE;
}
static bool cmd_foreverypart_validate_name_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct ext_foreverypart_loop *loop =
(struct ext_foreverypart_loop *)cmd->data;
struct sieve_ast_argument *tag = *arg;
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg, 1);
/* Check syntax:
* :name <string>
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, TRUE) )
return FALSE;
loop->name = sieve_ast_argument_strc(*arg);
/* Detach parameter */
*arg = sieve_ast_arguments_detach(*arg, 1);
return TRUE;
}
static bool tag_comparator_validate
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
const struct sieve_comparator *cmp;
/* Skip tag */
*arg = sieve_ast_argument_next(*arg);
/* Check syntax:
* ":comparator" <comparator-name: string>
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, FALSE) ) {
return FALSE;
}
/* FIXME: We can currently only handle string literal argument, so
* variables are not allowed.
*/
if ( !sieve_argument_is_string_literal(*arg) ) {
sieve_argument_validate_error(valdtr, *arg,
"this Sieve implementation currently only supports "
"a literal string argument for the :comparator tag");
return FALSE;
}
/* Get comparator from registry */
cmp = sieve_comparator_create(valdtr, cmd, sieve_ast_argument_strc(*arg));
if ( cmp == NULL ) {
sieve_argument_validate_error(valdtr, *arg,
"unknown comparator '%s'",
str_sanitize(sieve_ast_argument_strc(*arg),80));
return FALSE;
}
/* String argument not needed during code generation, so detach it from
* argument list
*/
*arg = sieve_ast_arguments_detach(*arg, 1);
/* Store comparator in context */
tag->argument->data = (void *) cmp;
return TRUE;
}
static bool cmd_vacation_validate_string_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
struct cmd_vacation_context_data *ctx_data =
(struct cmd_vacation_context_data *) cmd->data;
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg,1);
/* Check syntax:
* :subject string
* :from string
* :handle string
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, FALSE) ) {
return FALSE;
}
if ( sieve_argument_is(tag, vacation_from_tag) ) {
if ( sieve_argument_is_string_literal(*arg) ) {
string_t *address = sieve_ast_argument_str(*arg);
const char *error;
bool result;
T_BEGIN {
result = sieve_address_validate(address, &error);
if ( !result ) {
sieve_argument_validate_error(valdtr, *arg,
"specified :from address '%s' is invalid for vacation action: %s",
str_sanitize(str_c(address), 128), error);
}
} T_END;
if ( !result )
return FALSE;
}
ctx_data->from = sieve_ast_argument_str(*arg);
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
} else if ( sieve_argument_is(tag, vacation_subject_tag) ) {
static bool tst_size_validate_over_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *tst)
{
struct tst_size_context_data *ctx_data =
(struct tst_size_context_data *) tst->data;
if ( ctx_data->type != SIZE_UNASSIGNED ) {
sieve_argument_validate_error(valdtr, *arg, TST_SIZE_ERROR_DUP_TAG);
return FALSE;
}
ctx_data->type = SIZE_OVER;
/* Delete this tag */
*arg = sieve_ast_arguments_detach(*arg, 1);
return TRUE;
}
static bool cmd_test_imap_metadata_validate_mailbox_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
/* Delete this tag */
*arg = sieve_ast_arguments_detach(*arg, 1);
/* Check syntax:
* :mailbox string
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, FALSE) ) {
return FALSE;
}
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
static bool tst_test_error_validate_index_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg,1);
/* Check syntax:
* :index number
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_NUMBER, FALSE) ) {
return FALSE;
}
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
static bool cmd_test_config_reload_validate_tag
(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
struct sieve_command *cmd)
{
struct sieve_ast_argument *tag = *arg;
/* Detach the tag itself */
*arg = sieve_ast_arguments_detach(*arg,1);
/* Check syntax:
* :extension <extension: string>
*/
if ( !sieve_validate_tag_parameter
(valdtr, cmd, tag, *arg, NULL, 0, SAAT_STRING, TRUE) ) {
return FALSE;
}
/* Skip parameter */
*arg = sieve_ast_argument_next(*arg);
return TRUE;
}
bool ext_enotify_compile_check_arguments
(struct sieve_validator *valdtr, struct sieve_command *cmd,
struct sieve_ast_argument *uri_arg, struct sieve_ast_argument *msg_arg,
struct sieve_ast_argument *from_arg, struct sieve_ast_argument *options_arg)
{
const struct sieve_extension *this_ext = cmd->ext;
struct sieve_instance *svinst = this_ext->svinst;
const char *uri = sieve_ast_argument_strc(uri_arg);
const char *scheme;
const struct sieve_enotify_method *method;
struct sieve_enotify_env nenv;
bool result = TRUE;
/* If the uri string is not a constant literal, we cannot determine which
* method is used, so we bail out successfully and defer checking to runtime.
*/
if ( !sieve_argument_is_string_literal(uri_arg) )
return TRUE;
/* Parse scheme part of URI */
if ( (scheme=ext_enotify_uri_scheme_parse(&uri)) == NULL ) {
sieve_argument_validate_error(valdtr, uri_arg,
"notify command: invalid scheme part for method URI '%s'",
str_sanitize(sieve_ast_argument_strc(uri_arg), 80));
return FALSE;
}
/* Find used method with the parsed scheme identifier */
if ( (method=ext_enotify_method_find(this_ext, scheme)) == NULL ) {
sieve_argument_validate_error(valdtr, uri_arg,
"notify command: invalid method '%s'", scheme);
return FALSE;
}
if ( method->def == NULL ) return TRUE;
/* Compose log structure */
memset(&nenv, 0, sizeof(nenv));
nenv.svinst = svinst;
nenv.method = method;
/* Check URI itself */
if ( result && method->def->compile_check_uri != NULL ) {
/* Set log location to location of URI argument */
nenv.ehandler = sieve_prefix_ehandler_create
(sieve_validator_error_handler(valdtr),
sieve_error_script_location
(sieve_validator_script(valdtr), uri_arg->source_line),
"notify command");
/* Execute method check function */
result = method->def->compile_check_uri
(&nenv, sieve_ast_argument_strc(uri_arg), uri);
}
/* Check :message argument */
if ( result && msg_arg != NULL && sieve_argument_is_string_literal(msg_arg)
&& method->def->compile_check_message != NULL ) {
/* Set log location to location of :message argument */
sieve_error_handler_unref(&nenv.ehandler);
nenv.ehandler = sieve_prefix_ehandler_create
(sieve_validator_error_handler(valdtr),
sieve_error_script_location
(sieve_validator_script(valdtr), msg_arg->source_line),
"notify command");
/* Execute method check function */
result = method->def->compile_check_message
(&nenv, sieve_ast_argument_str(msg_arg));
}
/* Check :from argument */
if ( result && from_arg != NULL && sieve_argument_is_string_literal(from_arg)
&& method->def->compile_check_from != NULL ) {
/* Set log location to location of :from argument */
sieve_error_handler_unref(&nenv.ehandler);
nenv.ehandler = sieve_prefix_ehandler_create
(sieve_validator_error_handler(valdtr),
sieve_error_script_location
(sieve_validator_script(valdtr), from_arg->source_line),
"notify command");
/* Execute method check function */
result = method->def->compile_check_from
(&nenv, sieve_ast_argument_str(from_arg));
}
sieve_error_handler_unref(&nenv.ehandler);
/* Check :options argument */
if ( result && options_arg != NULL ) {
struct sieve_ast_argument *option = options_arg;
struct _ext_enotify_option_check_context optn_context =
{ svinst, valdtr, method };
/* Parse and check options */
result = ( sieve_ast_stringlist_map
(&option, (void *) &optn_context, _ext_enotify_option_check) > 0 );
/* Discard argument if options are not accepted by method */
if ( result && method->def->compile_check_option == NULL ) {
sieve_argument_validate_warning(valdtr, options_arg,
"notify command: method '%s' accepts no options", scheme);
(void)sieve_ast_arguments_detach(options_arg,1);
}
}
return result;
}
