static inline struct ext_imap4flags_result_context *_get_result_context
(const struct sieve_extension *this_ext, struct sieve_result *result)
{
struct ext_imap4flags_result_context *rctx =
(struct ext_imap4flags_result_context *)
sieve_result_extension_get_context(result, this_ext);
if ( rctx == NULL ) {
pool_t pool = sieve_result_pool(result);
rctx =p_new(pool, struct ext_imap4flags_result_context, 1);
rctx->internal_flags = str_new(pool, 32);
_get_initial_flags(result, rctx->internal_flags);
sieve_result_extension_set_context
(result, this_ext, rctx);
}
struct sieve_multiscript *sieve_multiscript_start_execute
(struct sieve_instance *svinst, const struct sieve_message_data *msgdata,
const struct sieve_script_env *senv)
{
pool_t pool;
struct sieve_result *result;
struct sieve_multiscript *mscript;
result = sieve_result_create(svinst, msgdata, senv);
pool = sieve_result_pool(result);
sieve_result_set_keep_action(result, NULL, NULL);
mscript = p_new(pool, struct sieve_multiscript, 1);
mscript->svinst = svinst;
mscript->result = result;
mscript->msgdata = msgdata;
mscript->scriptenv = senv;
mscript->status = SIEVE_EXEC_OK;
mscript->active = TRUE;
mscript->keep = TRUE;
return mscript;
}
int ext_enotify_runtime_check_operands
(const struct sieve_runtime_env *renv,
string_t *method_uri, string_t *message, string_t *from,
struct sieve_stringlist *options,
const struct sieve_enotify_method **method_r, void **method_context)
{
const struct sieve_enotify_method *method;
const char *uri_body;
/* Get method */
method = ext_enotify_get_method(renv, method_uri, &uri_body);
if ( method == NULL ) return SIEVE_EXEC_FAILURE;
/* Check provided operands */
if ( method->def != NULL && method->def->runtime_check_operands != NULL ) {
struct sieve_enotify_env nenv;
int result = SIEVE_EXEC_OK;
memset(&nenv, 0, sizeof(nenv));
nenv.svinst = renv->svinst;
nenv.method = method;
nenv.ehandler = sieve_prefix_ehandler_create
(renv->ehandler, sieve_runtime_get_full_command_location(renv),
"notify action");
/* Execute check function */
if ( method->def->runtime_check_operands
(&nenv, str_c(method_uri), uri_body, message, from,
sieve_result_pool(renv->result), method_context) ) {
/* Check any provided options */
if ( options != NULL ) {
string_t *option = NULL;
int ret;
/* Iterate through all provided options */
while ( (ret=sieve_stringlist_next_item(options, &option)) > 0 ) {
const char *opt_name = NULL, *opt_value = NULL;
/* Parse option into <optionname> and <value> */
if ( ext_enotify_option_parse
(&nenv, str_c(option), FALSE, &opt_name, &opt_value) ) {
/* Set option */
if ( method->def->runtime_set_option != NULL ) {
(void) method->def->runtime_set_option
(&nenv, *method_context, opt_name, opt_value);
}
}
}
/* Check for binary corruptions encountered during string list iteration
*/
if ( ret >= 0 ) {
*method_r = method;
} else {
/* Binary corrupt */
sieve_runtime_trace_error
(renv, "invalid item in options string list");
result = SIEVE_EXEC_BIN_CORRUPT;
}
} else {
/* No options */
*method_r = method;
}
} else {
/* Operand check failed */
result = SIEVE_EXEC_FAILURE;
}
sieve_error_handler_unref(&nenv.ehandler);
return result;
}
/* No check function defined: a most unlikely situation */
*method_context = NULL;
*method_r = method;
return SIEVE_EXEC_OK;
}
static int cmd_report_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct act_report_data *act;
string_t *fbtype, *message, *to_address;
const char *norm_address, *feedback_type, *error;
int opt_code = 0, ret = 0;
bool headers_only = FALSE;
pool_t pool;
/*
* Read operands
*/
/* Optional operands */
for (;;) {
int opt;
if ( (opt=sieve_opr_optional_read(renv, address, &opt_code)) < 0 )
return SIEVE_EXEC_BIN_CORRUPT;
if ( opt == 0 ) break;
switch ( opt_code ) {
case OPT_HEADERS_ONLY:
headers_only = TRUE;
break;
default:
sieve_runtime_trace_error(renv, "unknown optional operand");
return SIEVE_EXEC_BIN_CORRUPT;
}
}
/* Fixed operands */
if ( (ret=sieve_opr_string_read
(renv, address, "feedback-type", &fbtype)) <= 0 )
return ret;
if ( (ret=sieve_opr_string_read
(renv, address, "message", &message)) <= 0 )
return ret;
if ( (ret=sieve_opr_string_read
(renv, address, "address", &to_address)) <= 0 )
return ret;
/*
* Perform operation
*/
/* Verify and trim feedback type */
feedback_type = ext_vnd_report_parse_feedback_type(str_c(fbtype));
if ( feedback_type == NULL ) {
sieve_runtime_error(renv, NULL,
"specified report feedback type `%s' is invalid",
str_sanitize(str_c(fbtype), 256));
return SIEVE_EXEC_FAILURE;
}
/* Verify and normalize the address to 'local_part@domain' */
norm_address = sieve_address_normalize(to_address, &error);
if ( norm_address == NULL ) {
sieve_runtime_error(renv, NULL,
"specified report address `%s' is invalid: %s",
str_sanitize(str_c(to_address), 256), error);
return SIEVE_EXEC_FAILURE;
}
/* Trace */
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_ACTIONS) ) {
sieve_runtime_trace(renv, 0, "report action");
sieve_runtime_trace_descend(renv);
sieve_runtime_trace(renv, 0,
"report incoming message as `%s' to address `%s'",
str_sanitize(str_c(fbtype), 32),
str_sanitize(norm_address, 80));
}
/* Add report action to the result */
pool = sieve_result_pool(renv->result);
act = p_new(pool, struct act_report_data, 1);
act->headers_only = headers_only;
act->feedback_type = p_strdup(pool, feedback_type);
act->message = p_strdup(pool, str_c(message));
act->to_address = p_strdup(pool, norm_address);
if ( sieve_result_add_action(renv,
NULL, &act_report, NULL, (void *) act, 0, TRUE) < 0 )
return SIEVE_EXEC_FAILURE;
return SIEVE_EXEC_OK;
}
