static int cmd_test_set_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct testsuite_object tobj;
string_t *value;
int member_id;
int ret;
if ( !testsuite_object_read_member
(renv->sblock, address, &tobj, &member_id) ) {
sieve_runtime_trace_error(renv, "invalid testsuite object member");
return SIEVE_EXEC_BIN_CORRUPT;
}
if ( (ret=sieve_opr_string_read(renv, address, "string", &value)) <= 0 )
return ret;
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS) ) {
sieve_runtime_trace(renv, 0, "testsuite: test_set command");
sieve_runtime_trace_descend(renv);
sieve_runtime_trace(renv, 0,
"set test parameter '%s' = \"%s\"",
testsuite_object_member_name(&tobj, member_id), str_c(value));
}
if ( tobj.def == NULL || tobj.def->set_member == NULL ) {
sieve_runtime_trace_error(renv, "unimplemented testsuite object");
return SIEVE_EXEC_FAILURE;
}
tobj.def->set_member(renv, member_id, value);
return SIEVE_EXEC_OK;
}
static int opc_global_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_extension *this_ext = renv->oprtn->ext;
struct sieve_variable_scope_binary *global_vars;
struct sieve_variable_scope *global_scope;
struct sieve_variable_storage *storage;
struct sieve_variable * const *vars;
unsigned int var_count, count, i;
if ( !sieve_binary_read_unsigned(renv->sblock, address, &count) ) {
sieve_runtime_trace_error(renv,
"global: count operand invalid");
return SIEVE_EXEC_BIN_CORRUPT;
}
global_vars = ext_include_binary_get_global_scope(this_ext, renv->sbin);
global_scope = sieve_variable_scope_binary_get(global_vars);
vars = sieve_variable_scope_get_variables(global_scope, &var_count);
storage = ext_include_interpreter_get_global_variables
(this_ext, renv->interp);
for ( i = 0; i < count; i++ ) {
unsigned int index;
if ( !sieve_binary_read_unsigned(renv->sblock, address, &index) ) {
sieve_runtime_trace_error(renv,
"global: variable index operand invalid");
return SIEVE_EXEC_BIN_CORRUPT;
}
if ( index >= var_count ) {
sieve_runtime_trace_error(renv,
"global: variable index %u is invalid in global storage (> %u)",
index, var_count);
return SIEVE_EXEC_BIN_CORRUPT;
}
sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS,
"global: exporting variable '%s' [gvid: %u, vid: %u]",
vars[index]->identifier, i, index);
/* Make sure variable is initialized (export) */
(void)sieve_variable_get_modifiable(storage, index, NULL);
}
return SIEVE_EXEC_OK;
}
static int tst_exists_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct sieve_stringlist *hdr_list;
struct mail *mail = sieve_message_get_mail(renv->msgctx);
string_t *hdr_item;
bool matched;
int ret;
/*
* Read operands
*/
/* Read header-list */
if ( (ret=sieve_opr_stringlist_read(renv, address, "header-list", &hdr_list))
<= 0 )
return ret;
/*
* Perfrom test
*/
sieve_runtime_trace(renv, SIEVE_TRLVL_TESTS, "exists test");
sieve_runtime_trace_descend(renv);
/* Iterate through all requested headers to match (must find all specified) */
hdr_item = NULL;
matched = TRUE;
while ( matched &&
(ret=sieve_stringlist_next_item(hdr_list, &hdr_item)) > 0 ) {
const char *const *headers;
if ( mail_get_headers(mail, str_c(hdr_item), &headers) < 0 ||
headers[0] == NULL ) {
matched = FALSE;
}
sieve_runtime_trace(renv, SIEVE_TRLVL_MATCHING,
"header `%s' %s", str_sanitize(str_c(hdr_item), 80),
( matched ? "exists" : "is missing" ));
}
if ( matched )
sieve_runtime_trace(renv, SIEVE_TRLVL_MATCHING, "all headers exist");
else
sieve_runtime_trace(renv, SIEVE_TRLVL_MATCHING, "headers are missing");
/* Set test result for subsequent conditional jump */
if ( ret >= 0 ) {
sieve_interpreter_set_test_result(renv->interp, matched);
return SIEVE_EXEC_OK;
}
sieve_runtime_trace_error(renv, "invalid header-list item");
return SIEVE_EXEC_BIN_CORRUPT;
}
int sieve_extprogram_command_read_operands
(const struct sieve_runtime_env *renv, sieve_size_t *address,
string_t **pname_r, struct sieve_stringlist **args_list_r)
{
string_t *arg;
int ret;
/*
* Read fixed operands
*/
if ( (ret=sieve_opr_string_read
(renv, address, "program-name", pname_r)) <= 0 )
return ret;
if ( (ret=sieve_opr_stringlist_read_ex
(renv, address, "arguments", TRUE, args_list_r)) <= 0 )
return ret;
/*
* Check operands
*/
arg = NULL;
while ( *args_list_r != NULL &&
(ret=sieve_stringlist_next_item(*args_list_r, &arg)) > 0 ) {
if ( !sieve_extprogram_arg_is_valid(arg) ) {
sieve_runtime_error(renv, NULL,
"specified :args item `%s' is invalid",
str_sanitize(str_c(arg), 128));
return SIEVE_EXEC_FAILURE;
}
}
if ( ret < 0 ) {
sieve_runtime_trace_error(renv, "invalid args-list item");
return SIEVE_EXEC_BIN_CORRUPT;
}
return SIEVE_EXEC_OK;
}
static int tst_vnotifym_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct sieve_stringlist *notify_uris;
string_t *uri_item;
bool all_valid = TRUE;
int ret;
/*
* Read operands
*/
/* Read notify uris */
if ( (ret=sieve_opr_stringlist_read
(renv, address, "notify-uris", ¬ify_uris)) <= 0 )
return ret;
/*
* Perform operation
*/
sieve_runtime_trace(renv, SIEVE_TRLVL_TESTS, "valid_notify_method test");
uri_item = NULL;
while ( (ret=sieve_stringlist_next_item(notify_uris, &uri_item)) > 0 ) {
if ( !ext_enotify_runtime_method_validate(renv, uri_item) ) {
all_valid = FALSE;
break;
}
}
if ( ret < 0 ) {
sieve_runtime_trace_error(renv, "invalid method uri item");
return SIEVE_EXEC_BIN_CORRUPT;
}
sieve_interpreter_set_test_result(renv->interp, all_valid);
return SIEVE_EXEC_OK;
}
static int cmd_test_imap_metadata_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_operation *oprtn = renv->oprtn;
int opt_code = 0;
string_t *mailbox = NULL, *annotation = NULL, *value = NULL;
int ret;
/*
* 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_MAILBOX:
ret = sieve_opr_string_read(renv, address, "mailbox", &mailbox);
break;
default:
sieve_runtime_trace_error(renv, "unknown optional operand");
ret = SIEVE_EXEC_BIN_CORRUPT;
}
if ( ret <= 0 ) return ret;
}
/* Fixed operands */
if ( (ret=sieve_opr_string_read
(renv, address, "annotation", &annotation)) <= 0 )
return ret;
if ( (ret=sieve_opr_string_read
(renv, address, "value", &value)) <= 0 )
return ret;
/*
* Perform operation
*/
if ( sieve_operation_is(oprtn, test_imap_metadata_set_operation) ) {
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS) ) {
sieve_runtime_trace(renv, 0, "testsuite/test_imap_metadata_set command");
sieve_runtime_trace_descend(renv);
if (mailbox == NULL) {
sieve_runtime_trace(renv, 0,
"set server annotation `%s'", str_c(annotation));
} else {
sieve_runtime_trace(renv, 0,
"set annotation `%s' for mailbox `%s'",
str_c(annotation), str_c(mailbox));
}
}
if (testsuite_mailstore_set_imap_metadata
(( mailbox == NULL ? NULL : str_c(mailbox) ),
str_c(annotation), str_c(value)) < 0)
return SIEVE_EXEC_FAILURE;
}
return SIEVE_EXEC_OK;
}
static int tst_mailboxexists_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct sieve_stringlist *mailbox_names;
string_t *mailbox_item;
bool trace = FALSE;
bool all_exist = TRUE;
int ret;
/*
* Read operands
*/
/* Read notify uris */
if ( (ret=sieve_opr_stringlist_read
(renv, address, "mailbox-names", &mailbox_names)) <= 0 )
return ret;
/*
* Perform operation
*/
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_TESTS) ) {
sieve_runtime_trace(renv, 0, "mailboxexists test");
sieve_runtime_trace_descend(renv);
trace = sieve_runtime_trace_active(renv, SIEVE_TRLVL_MATCHING);
}
if ( renv->scriptenv->user != NULL ) {
int ret;
mailbox_item = NULL;
while ( (ret=sieve_stringlist_next_item(mailbox_names, &mailbox_item)) > 0 )
{
struct mail_namespace *ns;
const char *mailbox = str_c(mailbox_item);
struct mailbox *box;
/* Find the namespace */
ns = mail_namespace_find(renv->scriptenv->user->namespaces, mailbox);
if ( ns == NULL) {
if ( trace ) {
sieve_runtime_trace(renv, 0, "mailbox `%s' not found",
str_sanitize(mailbox, 80));
}
all_exist = FALSE;
break;
}
/* Open the box */
box = mailbox_alloc(ns->list, mailbox, 0);
if ( mailbox_open(box) < 0 ) {
if ( trace ) {
sieve_runtime_trace(renv, 0, "mailbox `%s' cannot be opened",
str_sanitize(mailbox, 80));
}
all_exist = FALSE;
mailbox_free(&box);
break;
}
/* Also fail when it is readonly */
if ( mailbox_is_readonly(box) ) {
if ( trace ) {
sieve_runtime_trace(renv, 0, "mailbox `%s' is read-only",
str_sanitize(mailbox, 80));
}
all_exist = FALSE;
mailbox_free(&box);
break;
}
/* FIXME: check acl for 'p' or 'i' ACL permissions as required by RFC */
if ( trace ) {
sieve_runtime_trace(renv, 0, "mailbox `%s' exists",
str_sanitize(mailbox, 80));
}
/* Close mailbox */
mailbox_free(&box);
}
if ( ret < 0 ) {
sieve_runtime_trace_error(renv, "invalid mailbox name item");
return SIEVE_EXEC_BIN_CORRUPT;
}
}
if ( trace ) {
if ( all_exist )
sieve_runtime_trace(renv, 0, "all mailboxes are available");
else
sieve_runtime_trace(renv, 0, "some mailboxes are unavailable");
}
sieve_interpreter_set_test_result(renv->interp, all_exist);
return SIEVE_EXEC_OK;
}
static int cmd_test_config_reload_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_extension *ext;
int opt_code = 0;
string_t *extension = NULL;
int ret;
/*
* 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_EXTENSION:
ret = sieve_opr_string_read(renv, address, "extension", &extension);
break;
default:
sieve_runtime_trace_error(renv, "unknown optional operand");
ret = SIEVE_EXEC_BIN_CORRUPT;
}
if ( ret <= 0 ) return ret;
}
/*
* Perform operation
*/
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS) ) {
sieve_runtime_trace(renv, 0,
"testsuite: test_config_reload command");
sieve_runtime_trace_descend(renv);
}
if ( extension == NULL ) {
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS) ) {
sieve_runtime_trace(renv, 0,
"reload configuration for sieve engine");
}
sieve_settings_load(renv->svinst);
} else {
if ( sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS) ) {
sieve_runtime_trace(renv, 0,
"reload configuration for extension `%s'",
str_c(extension));
}
ext = sieve_extension_get_by_name(renv->svinst, str_c(extension));
if ( ext == NULL ) {
testsuite_test_failf("test_config_reload: "
"unknown extension '%s'", str_c(extension));
return SIEVE_EXEC_OK;
}
sieve_extension_reload(ext);
}
return SIEVE_EXEC_OK;
}
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_filter_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_extension *this_ext = renv->oprtn->ext;
unsigned int is_test = 0;
struct sieve_stringlist *args_list = NULL;
enum sieve_error error = SIEVE_ERROR_NONE;
string_t *pname = NULL;
const char *program_name = NULL;
const char *const *args = NULL;
struct istream *newmsg = NULL;
struct sieve_extprogram *sprog;
int ret;
/*
* Read operands
*/
/* The is_test flag */
if ( !sieve_binary_read_byte(renv->sblock, address, &is_test) ) {
sieve_runtime_trace_error(renv, "invalid is_test flag");
return SIEVE_EXEC_BIN_CORRUPT;
}
/* Optional operands */
if ( sieve_action_opr_optional_read(renv, address, NULL, &ret, NULL) != 0 )
return ret;
/* Fixed operands */
if ( (ret=sieve_extprogram_command_read_operands
(renv, address, &pname, &args_list)) <= 0 )
return ret;
program_name = str_c(pname);
if ( args_list != NULL &&
sieve_stringlist_read_all(args_list, pool_datastack_create(), &args) < 0 ) {
sieve_runtime_trace_error(renv, "failed to read args operand");
return args_list->exec_status;
}
/*
* Perform operation
*/
/* Trace */
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS, "filter action");
sieve_runtime_trace_descend(renv);
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"execute program `%s'", str_sanitize(program_name, 128));
sprog = sieve_extprogram_create
(this_ext, renv->scriptenv, renv->msgdata, "filter", program_name, args,
&error);
if ( sprog != NULL ) {
struct mail *mail = sieve_message_get_mail(renv->msgctx);
if ( sieve_extprogram_set_input_mail(sprog, mail) < 0 ) {
sieve_extprogram_destroy(&sprog);
return sieve_runtime_mail_error(renv, mail,
"filter action: failed to read input message");
}
sieve_extprogram_set_output_seekable(sprog);
ret = sieve_extprogram_run(sprog);
} else {
ret = -1;
}
if ( ret > 0 )
newmsg = sieve_extprogram_get_output_seekable(sprog);
if ( sprog != NULL )
sieve_extprogram_destroy(&sprog);
if ( ret > 0 && newmsg != NULL ) {
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"executed program successfully");
i_stream_set_name(newmsg,
t_strdup_printf("filter %s output", program_name));
newmsg->blocking = TRUE;
if ( (ret=sieve_message_substitute(renv->msgctx, newmsg)) >= 0 ) {
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"changed message");
} else {
sieve_runtime_critical(renv, NULL, "filter action",
"filter action: failed to substitute message");
}
i_stream_unref(&newmsg);
} else if ( ret < 0 ) {
if ( error == SIEVE_ERROR_NOT_FOUND ) {
sieve_runtime_error(renv, NULL,
"filter action: program `%s' not found",
str_sanitize(program_name, 80));
} else {
sieve_extprogram_exec_error(renv->ehandler,
sieve_runtime_get_full_command_location(renv),
"filter action: failed to execute to program `%s'",
str_sanitize(program_name, 80));
}
} else {
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"filter action: program indicated false result");
}
if ( is_test > 0 ) {
sieve_interpreter_set_test_result(renv->interp, ( ret > 0 ));
return SIEVE_EXEC_OK;
}
return ( ret >= 0 ? SIEVE_EXEC_OK : SIEVE_EXEC_FAILURE );
}
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;
}
static int tst_spamvirustest_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_operation *op = renv->oprtn;
const struct sieve_extension *this_ext = op->ext;
int opt_code = 0;
struct sieve_match_type mcht =
SIEVE_MATCH_TYPE_DEFAULT(is_match_type);
struct sieve_comparator cmp =
SIEVE_COMPARATOR_DEFAULT(i_ascii_casemap_comparator);
bool percent = FALSE;
struct sieve_stringlist *value_list, *key_list;
const char *score_value;
int match, ret;
/* Read optional operands */
for (;;) {
int opt;
if ( (opt=sieve_match_opr_optional_read
(renv, address, &opt_code, &ret, &cmp, &mcht)) < 0 )
return ret;
if ( opt == 0 ) break;
switch ( opt_code ) {
case OPT_SPAMTEST_PERCENT:
percent = TRUE;
break;
default:
sieve_runtime_trace_error(renv, "unknown optional operand");
return SIEVE_EXEC_BIN_CORRUPT;
}
}
/* Read value part */
if ( (ret=sieve_opr_stringlist_read(renv, address, "value", &key_list)) <= 0 )
return ret;
/* Perform test */
if ( sieve_operation_is(op, spamtest_operation) ) {
sieve_runtime_trace
(renv, SIEVE_TRLVL_TESTS, "spamtest test [percent=%s]",
( percent ? "true" : "false" ));
} else {
sieve_runtime_trace
(renv, SIEVE_TRLVL_TESTS, "virustest test");
}
/* Get score value */
sieve_runtime_trace_descend(renv);
if ( (ret=ext_spamvirustest_get_value
(renv, this_ext, percent, &score_value)) <= 0 )
return ret;
sieve_runtime_trace_ascend(renv);
/* Construct value list */
value_list = sieve_single_stringlist_create_cstr(renv, score_value, TRUE);
/* Perform match */
if ( (match=sieve_match(renv, &mcht, &cmp, value_list, key_list, &ret)) < 0 )
return ret;
/* Set test result for subsequent conditional jump */
sieve_interpreter_set_test_result(renv->interp, match > 0);
return SIEVE_EXEC_OK;
}
static int cmd_execute_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
const struct sieve_extension *this_ext = renv->oprtn->ext;
struct sieve_side_effects_list *slist = NULL;
int opt_code = 0;
unsigned int is_test = 0;
struct sieve_stringlist *args_list = NULL;
string_t *pname = NULL, *input = NULL;
struct sieve_variable_storage *var_storage = NULL;
unsigned int var_index;
bool have_input = FALSE;
const char *program_name = NULL;
const char *const *args = NULL;
enum sieve_error error = SIEVE_ERROR_NONE;
buffer_t *outbuf = NULL;
struct sieve_extprogram *sprog = NULL;
int ret;
/*
* Read operands
*/
/* The is_test flag */
if ( !sieve_binary_read_byte(renv->sblock, address, &is_test) ) {
sieve_runtime_trace_error(renv, "invalid is_test flag");
return SIEVE_EXEC_BIN_CORRUPT;
}
/* Optional operands */
for (;;) {
int opt;
if ( (opt=sieve_action_opr_optional_read
(renv, address, &opt_code, &ret, &slist)) < 0 )
return ret;
if ( opt == 0 ) break;
switch ( opt_code ) {
case OPT_INPUT:
ret = sieve_opr_string_read_ex
(renv, address, "input", TRUE, &input, NULL);
have_input = TRUE;
break;
case OPT_OUTPUT:
ret = sieve_variable_operand_read
(renv, address, "output", &var_storage, &var_index);
break;
default:
sieve_runtime_trace_error(renv, "unknown optional operand");
return SIEVE_EXEC_BIN_CORRUPT;
}
if ( ret <= 0 ) return ret;
}
/* Fixed operands */
if ( (ret=sieve_extprogram_command_read_operands
(renv, address, &pname, &args_list)) <= 0 )
return ret;
program_name = str_c(pname);
if ( args_list != NULL &&
sieve_stringlist_read_all(args_list, pool_datastack_create(), &args) < 0 ) {
sieve_runtime_trace_error(renv, "failed to read args operand");
return args_list->exec_status;
}
/*
* Perform operation
*/
/* Trace */
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS, "execute action");
sieve_runtime_trace_descend(renv);
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"execute program `%s'", str_sanitize(program_name, 128));
sprog = sieve_extprogram_create
(this_ext, renv->scriptenv, renv->msgdata, "execute", program_name, args,
&error);
if ( sprog != NULL ) {
if ( var_storage != NULL ) {
// FIXME: limit output size
struct ostream *outdata;
outbuf = buffer_create_dynamic(pool_datastack_create(), 1024);
outdata = o_stream_create_buffer(outbuf);
sieve_extprogram_set_output(sprog, outdata);
o_stream_unref(&outdata);
}
if ( input == NULL && have_input ) {
struct mail *mail = sieve_message_get_mail(renv->msgctx);
if ( sieve_extprogram_set_input_mail(sprog, mail) < 0 ) {
sieve_extprogram_destroy(&sprog);
return sieve_runtime_mail_error(renv, mail,
"execute action: failed to read input message");
}
ret = 1;
} else if ( input != NULL ) {
struct istream *indata =
i_stream_create_from_data(str_data(input), str_len(input));
sieve_extprogram_set_input(sprog, indata);
i_stream_unref(&indata);
ret = 1;
}
if ( ret >= 0 )
ret = sieve_extprogram_run(sprog);
sieve_extprogram_destroy(&sprog);
} else {
ret = -1;
}
if ( ret > 0 ) {
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"executed program successfully");
if ( var_storage != NULL ) {
string_t *var;
if ( sieve_variable_get_modifiable(var_storage, var_index, &var) ) {
str_truncate(var, 0);
str_append_str(var, outbuf);
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"assigned output variable");
} // FIXME: handle failure
}
} else if ( ret < 0 ) {
if ( error == SIEVE_ERROR_NOT_FOUND ) {
sieve_runtime_error(renv, NULL,
"execute action: program `%s' not found",
str_sanitize(program_name, 80));
} else {
sieve_extprogram_exec_error(renv->ehandler,
sieve_runtime_get_full_command_location(renv),
"execute action: failed to execute to program `%s'",
str_sanitize(program_name, 80));
}
} else {
sieve_runtime_trace(renv, SIEVE_TRLVL_ACTIONS,
"execute action: program indicated false result");
}
if ( outbuf != NULL )
buffer_free(&outbuf);
if ( is_test )
sieve_interpreter_set_test_result(renv->interp, ( ret > 0 ));
return SIEVE_EXEC_OK;
}