static void test_ostream_dot_one(const struct dot_test *test)
{
struct istream *test_input;
struct ostream *output, *test_output;
buffer_t *output_data;
const unsigned char *data;
size_t size;
ssize_t ret;
test_input = test_istream_create(test->input);
output_data = buffer_create_dynamic(pool_datastack_create(), 1024);
test_output = o_stream_create_buffer(output_data);
output = o_stream_create_dot(test_output, FALSE);
while ((ret = i_stream_read(test_input)) > 0 || ret == -2) {
data = i_stream_get_data(test_input, &size);
ret = o_stream_send(output, data, size);
test_assert(ret >= 0);
if (ret <= 0)
break;
i_stream_skip(test_input, ret);
}
test_assert(test_input->eof);
test_assert(o_stream_flush(output) > 0);
o_stream_unref(&output);
o_stream_unref(&test_output);
test_assert(strcmp(str_c(output_data), test->output) == 0);
i_stream_unref(&test_input);
}
static
void test_write_read_v2(void)
{
test_begin("test_write_read_v2");
unsigned char payload[IO_BLOCK_SIZE*10];
const unsigned char *ptr;
size_t pos = 0, siz;
random_fill_weak(payload, IO_BLOCK_SIZE*10);
buffer_t *buf = buffer_create_dynamic(default_pool, sizeof(payload));
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "aes-256-gcm-sha256", test_v1_kp.pub, IO_STREAM_ENC_INTEGRITY_AEAD);
o_stream_nsend(os_2, payload, sizeof(payload));
test_assert(o_stream_nfinish(os_2) == 0);
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
o_stream_unref(&os);
o_stream_unref(&os_2);
struct istream *is = test_istream_create_data(buf->data, buf->used);
/* test regression where read fails due to incorrect behaviour
when buffer is full before going to decrypt code */
i_stream_set_max_buffer_size(is, 8192);
i_stream_read(is);
struct istream *is_2 = i_stream_create_decrypt(is, test_v1_kp.priv);
size_t offset = 0;
test_istream_set_size(is, 0);
test_istream_set_allow_eof(is, FALSE);
while(i_stream_read_data(is_2, &ptr, &siz, 0)>=0) {
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
test_assert_idx(pos + siz <= sizeof(payload), pos);
if (pos + siz > sizeof(payload)) break;
test_assert_idx(siz == 0 || memcmp(ptr, payload + pos, siz) == 0, pos);
i_stream_skip(is_2, siz); pos += siz;
}
test_assert(is_2->stream_errno == 0);
if (is_2->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_2));
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
static
void test_write_read_v1_short(void)
{
test_begin("test_write_read_v1_short");
unsigned char payload[1];
const unsigned char *ptr;
size_t pos = 0, siz;
random_fill_weak(payload, 1);
buffer_t *buf = buffer_create_dynamic(default_pool, 64);
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "<unused>", test_v2_kp.pub, IO_STREAM_ENC_VERSION_1);
o_stream_nsend(os_2, payload, sizeof(payload));
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
test_assert(os_2->stream_errno == 0);
test_assert(o_stream_nfinish(os_2) == 0);
test_assert(os_2->stream_errno == 0);
o_stream_unref(&os);
o_stream_unref(&os_2);
struct istream *is = test_istream_create_data(buf->data, buf->used);
struct istream *is_2 = i_stream_create_decrypt(is, test_v2_kp.priv);
size_t offset = 0;
test_istream_set_allow_eof(is, FALSE);
test_istream_set_size(is, 0);
while(i_stream_read_data(is_2, &ptr, &siz, 0)>=0) {
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
test_assert_idx(pos + siz <= sizeof(payload), pos);
if (pos + siz > sizeof(payload)) break;
test_assert_idx(siz == 0 || memcmp(ptr, payload + pos, siz) == 0, pos);
i_stream_skip(is_2, siz); pos += siz;
}
test_assert(is_2->stream_errno == 0);
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
static struct dsync_proxy_server *
dsync_proxy_server_init_test(buffer_t *outbuf)
{
struct dsync_proxy_server *server;
server = i_new(struct dsync_proxy_server, 1);
server->worker = dsync_worker_init_test();
server->fd_in = 0;
server->fd_out = 0;
server->cmd_pool = pool_alloconly_create("worker server cmd", 1024);
server->output = o_stream_create_buffer(outbuf);
return server;
}
static
void test_write_read_v1_empty(void)
{
const unsigned char *ptr;
size_t siz;
test_begin("test_write_read_v1_empty");
buffer_t *buf = buffer_create_dynamic(default_pool, 64);
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "<unused>", test_v1_kp.pub, IO_STREAM_ENC_VERSION_1);
test_assert(o_stream_nfinish(os_2) == 0);
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
o_stream_unref(&os);
o_stream_unref(&os_2);
/* this should've been enough */
struct istream *is = test_istream_create_data(buf->data, buf->used);
struct istream *is_2 = i_stream_create_decrypt(is, test_v1_kp.priv);
/* read should not fail */
test_istream_set_allow_eof(is, FALSE);
test_istream_set_size(is, 0);
size_t offset = 0;
ssize_t ret;
while ((ret = i_stream_read_data(is_2, &ptr, &siz, 0)) >= 0) {
test_assert(ret == 0);
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
};
test_assert(is_2->stream_errno == 0);
if (is_2->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_2));
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
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;
}
