static void stats_top(const char *path, const char *sort_type)
{
struct top_context ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.path = path;
ctx.fd = doveadm_connect(path);
ctx.prev_pool = pool_alloconly_create("stats top", 1024*16);
ctx.cur_pool = pool_alloconly_create("stats top", 1024*16);
i_array_init(&ctx.lines, 128);
hash_table_create(&ctx.sessions, default_pool, 0, str_hash, strcmp);
net_set_nonblock(ctx.fd, FALSE);
ctx.input = i_stream_create_fd(ctx.fd, (size_t)-1, TRUE);
if (strstr(sort_type, "cpu") != NULL)
ctx.lines_sort = sort_cpu;
else
ctx.lines_sort = sort_num;
ctx.sort_type = sort_type;
stats_top_start(&ctx);
i_stream_destroy(&ctx.input);
hash_table_destroy(&ctx.sessions);
array_free(&ctx.lines);
pool_unref(&ctx.prev_pool);
pool_unref(&ctx.cur_pool);
i_close_fd(&ctx.fd);
}
void index_mail_free(struct mail *_mail)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct mailbox_header_lookup_ctx *headers_ctx =
(struct mailbox_header_lookup_ctx *)mail->wanted_headers;
mail->mail.v.close(_mail);
i_assert(mail->trans->mail_ref_count > 0);
mail->trans->mail_ref_count--;
if (mail->header_data != NULL)
buffer_free(&mail->header_data);
if (array_is_created(&mail->header_lines))
array_free(&mail->header_lines);
if (array_is_created(&mail->header_match))
array_free(&mail->header_match);
if (array_is_created(&mail->header_match_lines))
array_free(&mail->header_match_lines);
if (headers_ctx != NULL)
mailbox_header_lookup_unref(&headers_ctx);
pool_unref(&mail->data_pool);
pool_unref(&mail->mail.pool);
}
static void acl_backend_vfile_deinit(struct acl_backend *_backend)
{
struct acl_backend_vfile *backend =
(struct acl_backend_vfile *)_backend;
if (backend->acllist_pool != NULL) {
array_free(&backend->acllist);
pool_unref(&backend->acllist_pool);
}
if (_backend->global_file != NULL)
acl_global_file_deinit(&_backend->global_file);
pool_unref(&backend->backend.pool);
}
int mailbox_list_index_iter_deinit(struct mailbox_list_iterate_context *_ctx)
{
struct mailbox_list_index *ilist = INDEX_LIST_CONTEXT_REQUIRE(_ctx->list);
if (!_ctx->index_iteration)
return ilist->module_ctx.super.iter_deinit(_ctx);
struct mailbox_list_index_iterate_context *ctx =
(struct mailbox_list_index_iterate_context *)_ctx;
int ret = ctx->failed ? -1 : 0;
pool_unref(&ctx->mailbox_pool);
pool_unref(&ctx->info_pool);
pool_unref(&_ctx->pool);
return ret;
}
void hash_format_deinit_free(struct hash_format **_format)
{
struct hash_format *format = *_format;
*_format = NULL;
pool_unref(&format->pool);
}
int hash_format_init(const char *format_string, struct hash_format **format_r,
const char **error_r)
{
struct hash_format *format;
pool_t pool;
int ret;
pool = pool_alloconly_create("hash format", 1024);
format = p_new(pool, struct hash_format, 1);
format->pool = pool;
format->str = p_strdup(pool, format_string);
format->pos = &format->list;
T_BEGIN {
ret = hash_format_string_analyze(format, format_string,
error_r);
if (ret < 0)
*error_r = p_strdup(format->pool, *error_r);
} T_END;
if (ret < 0) {
*error_r = t_strdup(*error_r);
pool_unref(&pool);
return -1;
}
*format_r = format;
return 0;
}
void test_mempool_alloconly(void)
{
#define PMALLOC_MAX_COUNT 128
pool_t pool;
unsigned int i, j, k;
void *mem[PMALLOC_MAX_COUNT + 1];
bool success = TRUE;
for (i = 0; i < 64; i++) {
for (j = 1; j <= 128; j++) {
pool = pool_alloconly_create(MEMPOOL_GROWING"test", i);
mem[0] = p_malloc(pool, j);
memset(mem[0], j, j);
for (k = 1; k <= PMALLOC_MAX_COUNT; k++) {
mem[k] = p_malloc(pool, k);
memset(mem[k], k, k);
}
if (!mem_has_bytes(mem[0], j, j))
success = FALSE;
for (k = 1; k <= PMALLOC_MAX_COUNT; k++) {
if (!mem_has_bytes(mem[k], k, k))
success = FALSE;
}
pool_unref(&pool);
}
}
test_out("mempool_alloconly", success);
}
static int
imap_master_client_input_line(struct connection *conn, const char *line)
{
char *const *args;
pool_t pool;
int fd_client, ret;
if (!conn->version_received) {
if (connection_verify_version(conn, t_strsplit_tabescaped(line)) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
fd_client = i_stream_unix_get_read_fd(conn->input);
if (fd_client == -1) {
i_error("imap-master: IMAP client fd not received");
return -1;
}
if (imap_debug)
i_debug("imap-master: Client input: %s", line);
pool = pool_alloconly_create("imap master client cmd", 1024);
args = p_strsplit_tabescaped(pool, line);
ret = imap_master_client_input_args(conn, (void *)args, fd_client, pool);
pool_unref(&pool);
return ret;
}
bool smtp_server_command_unref(struct smtp_server_command **_cmd)
{
struct smtp_server_command *cmd = *_cmd;
struct smtp_server_connection *conn = cmd->context.conn;
*_cmd = NULL;
i_assert(cmd->refcount > 0);
if (--cmd->refcount > 0)
return TRUE;
smtp_server_command_debug(&cmd->context, "Destroy");
if (cmd->state < SMTP_SERVER_COMMAND_STATE_FINISHED) {
cmd->state = SMTP_SERVER_COMMAND_STATE_ABORTED;
DLLIST2_REMOVE(&conn->command_queue_head,
&conn->command_queue_tail, cmd);
conn->command_queue_count--;
}
/* execute hooks */
if (cmd->context.hook_destroy != NULL)
cmd->context.hook_destroy(&cmd->context);
if (cmd->hook_destroy != NULL)
cmd->hook_destroy(&cmd->context);
smtp_server_reply_free(cmd);
pool_unref(&cmd->context.pool);
return FALSE;
}
enum fatal_test_state fatal_mempool(int stage)
{
static pool_t pool;
switch(stage) {
case 0: /* forbidden size */
test_begin("fatal_mempool");
pool = pool_alloconly_create(MEMPOOL_GROWING"fatal", 1);
(void)p_malloc(pool, 0);
return FATAL_TEST_FAILURE;
case 1: /* logically impossible size */
(void)p_malloc(pool, SSIZE_T_MAX + 1ULL);
return FATAL_TEST_FAILURE;
case 2: /* physically impossible size */
(void)p_malloc(pool, SSIZE_T_MAX - (size_t)MEM_ALIGN(1));
return FATAL_TEST_FAILURE;
/* Continue with other tests as follows:
case 3:
something_fatal();
return FATAL_TEST_FAILURE;
*/
}
/* Either our tests have finished, or the test suite has got confused. */
pool_unref(&pool);
test_end();
return FATAL_TEST_FINISHED;
}
static void
doveadm_mail_cmd_server_run(struct client_connection *conn,
struct doveadm_mail_cmd_context *ctx,
const struct mail_storage_service_input *input)
{
const char *error;
int ret;
ctx->conn = conn;
if (ctx->v.preinit != NULL)
ctx->v.preinit(ctx);
ret = doveadm_mail_single_user(ctx, input, &error);
doveadm_mail_server_flush();
ctx->v.deinit(ctx);
doveadm_print_flush();
mail_storage_service_deinit(&ctx->storage_service);
if (ret < 0) {
i_error("%s: %s", ctx->cmd->name, error);
o_stream_nsend(conn->output, "\n-\n", 3);
} else if (ret == 0) {
o_stream_nsend_str(conn->output, "\n-NOUSER\n");
} else if (ctx->exit_code != 0) {
/* maybe not an error, but not a full success either */
o_stream_nsend_str(conn->output,
t_strdup_printf("\n-%u\n", ctx->exit_code));
} else {
o_stream_nsend(conn->output, "\n+\n", 3);
}
pool_unref(&ctx->pool);
}
int sieve_file_storage_save_commit
(struct sieve_storage_save_context *sctx)
{
struct sieve_file_save_context *fsctx =
(struct sieve_file_save_context *)sctx;
struct sieve_storage *storage = sctx->storage;
struct sieve_file_storage *fstorage =
(struct sieve_file_storage *)sctx->storage;
const char *dest_path;
bool failed = FALSE;
i_assert(fsctx->output == NULL);
T_BEGIN {
dest_path = t_strconcat(fstorage->path, "/",
sieve_script_file_from_name(sctx->scriptname), NULL);
failed = ( sieve_file_storage_script_move(fsctx, dest_path) < 0 );
if ( sctx->mtime != (time_t)-1 )
sieve_file_storage_update_mtime(storage, dest_path, sctx->mtime);
} T_END;
pool_unref(&sctx->pool);
return ( failed ? -1 : 0 );
}
static void test_imap_match_globs_equal(void)
{
struct imap_match_glob *glob;
pool_t pool;
pool = pool_alloconly_create("imap match globs equal", 1024);
test_begin("imap match globs equal");
glob = imap_match_init(pool, "1", FALSE, '/');
test_assert(imap_match_globs_equal(glob,
imap_match_init(pool, "1", FALSE, '/')));
test_assert(imap_match_globs_equal(glob,
imap_match_init(pool, "1", TRUE, '/')));
test_assert(!imap_match_globs_equal(glob,
imap_match_init(pool, "1", FALSE, '.')));
test_assert(!imap_match_globs_equal(glob,
imap_match_init(pool, "11", FALSE, '/')));
glob = imap_match_init(pool, "in%", TRUE, '/');
test_assert(!imap_match_globs_equal(glob,
imap_match_init(pool, "in%", FALSE, '/')));
test_assert(!imap_match_globs_equal(glob,
imap_match_init(pool, "In%", TRUE, '/')));
pool_unref(&pool);
test_end();
}
static void config_export_free(struct config_export_context *ctx)
{
if (ctx->dup_parsers != NULL)
config_filter_parsers_free(ctx->dup_parsers);
hash_table_destroy(&ctx->keys);
pool_unref(&ctx->pool);
}
void dict_transaction_memory_rollback(struct dict_transaction_context *_ctx)
{
struct dict_transaction_memory_context *ctx =
(struct dict_transaction_memory_context *)_ctx;
pool_unref(&ctx->pool);
}
static void maildir_list_deinit(struct mailbox_list *_list)
{
struct maildir_mailbox_list *list =
(struct maildir_mailbox_list *)_list;
pool_unref(&list->list.pool);
}
bool client_unref(struct client **_client)
{
struct client *client = *_client;
i_assert(client->refcount > 0);
if (--client->refcount > 0)
return TRUE;
*_client = NULL;
i_assert(client->destroyed);
i_assert(client->ssl_proxy == NULL);
i_assert(client->login_proxy == NULL);
if (client->input != NULL)
i_stream_unref(&client->input);
if (client->output != NULL)
o_stream_unref(&client->output);
i_free(client->proxy_user);
i_free(client->proxy_master_user);
i_free(client->virtual_user);
i_free(client->auth_mech_name);
pool_unref(&client->pool);
i_assert(clients_count > 0);
clients_count--;
master_service_client_connection_destroyed(master_service);
login_refresh_proctitle();
return FALSE;
}
bool http_server_request_unref(struct http_server_request **_req)
{
struct http_server_request *req = *_req;
struct http_server_connection *conn = req->conn;
i_assert(req->refcount > 0);
*_req = NULL;
if (--req->refcount > 0)
return TRUE;
http_server_request_debug(req, "Free");
if (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED) {
req->state = HTTP_SERVER_REQUEST_STATE_ABORTED;
http_server_connection_remove_request(conn, req);
}
if (req->destroy_callback != NULL) {
req->destroy_callback(req->destroy_context);
req->destroy_callback = NULL;
}
if (req->response != NULL)
http_server_response_free(req->response);
pool_unref(&req->pool);
return FALSE;
}
struct istream *
istream_attachment_connector_finish(struct istream_attachment_connector **_conn)
{
struct istream_attachment_connector *conn = *_conn;
struct istream **inputs, *input;
uoff_t trailer_size;
*_conn = NULL;
if (conn->base_input_offset != conn->msg_size) {
i_assert(conn->base_input_offset < conn->msg_size);
trailer_size = conn->msg_size - conn->encoded_offset;
input = i_stream_create_range(conn->base_input,
conn->base_input_offset,
trailer_size);
array_append(&conn->streams, &input, 1);
}
array_append_zero(&conn->streams);
inputs = array_idx_modifiable(&conn->streams, 0);
input = i_stream_create_concat(inputs);
i_stream_unref(&conn->base_input);
pool_unref(&conn->pool);
return input;
}
static void test_message_parser_small_blocks(void)
{
struct message_parser_ctx *parser;
struct istream *input;
struct message_part *parts, *parts2;
struct message_block block;
unsigned int i, end_of_headers_idx;
pool_t pool;
int ret;
test_begin("message parser in small blocks");
pool = pool_alloconly_create("message parser", 10240);
input = test_istream_create(test_msg);
/* full parsing */
parser = message_parser_init(pool, input, 0, 0);
while ((ret = message_parser_parse_next_block(parser, &block)) > 0) ;
test_assert(ret < 0);
test_assert(message_parser_deinit(&parser, &parts) == 0);
/* parsing in small blocks */
i_stream_seek(input, 0);
test_istream_set_allow_eof(input, FALSE);
parser = message_parser_init(pool, input, 0, 0);
for (i = 1; i <= TEST_MSG_LEN*2+1; i++) {
test_istream_set_size(input, i/2);
if (i > TEST_MSG_LEN*2)
test_istream_set_allow_eof(input, TRUE);
while ((ret = message_parser_parse_next_block(parser,
&block)) > 0) ;
test_assert((ret == 0 && i <= TEST_MSG_LEN*2) ||
(ret < 0 && i > TEST_MSG_LEN*2));
}
test_assert(message_parser_deinit(&parser, &parts2) == 0);
test_assert(msg_parts_cmp(parts, parts2));
/* parsing in small blocks from preparsed parts */
i_stream_seek(input, 0);
test_istream_set_allow_eof(input, FALSE);
end_of_headers_idx = (strstr(test_msg, "\n-----") - test_msg);
parser = message_parser_init_from_parts(parts, input, 0,
MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK);
for (i = 1; i <= TEST_MSG_LEN*2+1; i++) {
test_istream_set_size(input, i/2);
if (i > TEST_MSG_LEN*2)
test_istream_set_allow_eof(input, TRUE);
while ((ret = message_parser_parse_next_block(parser,
&block)) > 0) ;
test_assert((ret == 0 && i/2 <= end_of_headers_idx) ||
(ret < 0 && i/2 > end_of_headers_idx));
}
test_assert(message_parser_deinit(&parser, &parts2) == 0);
test_assert(msg_parts_cmp(parts, parts2));
i_stream_unref(&input);
pool_unref(&pool);
test_end();
}
static int fts_mailbox_search_deinit(struct mail_search_context *ctx)
{
struct fts_mailbox *fbox = FTS_CONTEXT(ctx->transaction->box);
struct fts_transaction_context *ft = FTS_CONTEXT(ctx->transaction);
struct fts_search_context *fctx = FTS_CONTEXT(ctx);
int ret = 0;
if (fctx != NULL) {
if (fctx->indexer_ctx != NULL) {
if (fts_indexer_deinit(&fctx->indexer_ctx) < 0)
ft->failed = TRUE;
}
if (fctx->indexing_timed_out)
ret = -1;
if (!fctx->fts_lookup_success && fctx->enforced) {
/* FTS lookup failed and we didn't want to fallback to
opening all the mails and searching manually */
mail_storage_set_internal_error(ctx->transaction->box->storage);
ret = -1;
}
buffer_free(&fctx->orig_matches);
array_free(&fctx->levels);
pool_unref(&fctx->result_pool);
fts_scores_unref(&fctx->scores);
i_free(fctx);
} else {
if (ft->failed)
ret = -1;
}
if (fbox->module_ctx.super.search_deinit(ctx) < 0)
ret = -1;
return ret;
}
int mailbox_list_index_iter_deinit(struct mailbox_list_iterate_context *_ctx)
{
struct mailbox_list_index_iterate_context *ctx =
(struct mailbox_list_index_iterate_context *)_ctx;
struct mailbox_list_index *ilist = INDEX_LIST_CONTEXT(_ctx->list);
int ret = ctx->failed ? -1 : 0;
if (ctx->backend_ctx != NULL)
ret = ilist->module_ctx.super.iter_deinit(ctx->backend_ctx);
else
pool_unref(&ctx->mailbox_pool);
pool_unref(&ctx->info_pool);
pool_unref(&_ctx->pool);
return ret;
}
void mech_register_deinit(struct mechanisms_register **_reg)
{
struct mechanisms_register *reg = *_reg;
*_reg = NULL;
pool_unref(®->pool);
}
void mail_storage_service_init_settings(struct mail_storage_service_ctx *ctx,
const struct mail_storage_service_input *input)
{
const struct setting_parser_info *user_info;
const struct mail_user_settings *user_set;
const struct setting_parser_context *set_parser;
const char *error;
pool_t temp_pool;
void **sets;
if (ctx->conn != NULL)
return;
temp_pool = pool_alloconly_create("service all settings", 4096);
if (mail_storage_service_read_settings(ctx, input, temp_pool,
&user_info, &set_parser,
&error) < 0)
i_fatal("%s", error);
sets = master_service_settings_parser_get_others(master_service,
set_parser);
user_set = sets[0];
mail_storage_service_first_init(ctx, user_info, user_set);
pool_unref(&temp_pool);
}
void auth_client_request_server_input(struct auth_client_request *request,
enum auth_request_status status,
const char *const *args)
{
const char *const *tmp, *base64_data = NULL;
if (request->callback == NULL) {
/* aborted already */
return;
}
switch (status) {
case AUTH_REQUEST_STATUS_OK:
for (tmp = args; *tmp != NULL; tmp++) {
if (strncmp(*tmp, "resp=", 5) == 0) {
base64_data = *tmp + 5;
break;
}
}
break;
case AUTH_REQUEST_STATUS_CONTINUE:
base64_data = args[0];
args = NULL;
break;
case AUTH_REQUEST_STATUS_FAIL:
case AUTH_REQUEST_STATUS_INTERNAL_FAIL:
case AUTH_REQUEST_STATUS_ABORT:
break;
}
call_callback(request, status, base64_data, args);
if (status != AUTH_REQUEST_STATUS_CONTINUE)
pool_unref(&request->pool);
}
static void fts_filter_stopwords_destroy(struct fts_filter *filter)
{
struct fts_filter_stopwords *sp = (struct fts_filter_stopwords *)filter;
if (hash_table_is_created(sp->stopwords))
hash_table_destroy(&sp->stopwords);
pool_unref(&sp->pool);
}
void testsuite_smtp_deinit(void)
{
if ( unlink_directory(testsuite_smtp_tmp, TRUE) < 0 )
i_warning("failed to remove temporary directory '%s': %m.",
testsuite_smtp_tmp);
pool_unref(&testsuite_smtp_pool);
}
void dsync_deserializer_deinit(struct dsync_deserializer **_deserializer)
{
struct dsync_deserializer *deserializer = *_deserializer;
*_deserializer = NULL;
pool_unref(&deserializer->pool);
}
static void virtual_mail_free(struct mail *mail)
{
struct virtual_mail *vmail = (struct virtual_mail *)mail;
struct mail **mails;
unsigned int i, count;
mails = array_get_modifiable(&vmail->backend_mails, &count);
for (i = 0; i < count; i++)
mail_free(&mails[i]);
array_free(&vmail->backend_mails);
if (vmail->wanted_headers != NULL)
mailbox_header_lookup_unref(&vmail->wanted_headers);
pool_unref(&vmail->imail.data_pool);
pool_unref(&vmail->imail.mail.pool);
}
int pop3c_sync_get_uidls(struct pop3c_mailbox *mbox)
{
ARRAY_TYPE(const_string) uidls;
struct istream *input;
const char *error, *cline;
char *line, *p;
unsigned int seq, line_seq;
if (mbox->msg_uidls != NULL)
return 0;
if ((pop3c_client_get_capabilities(mbox->client) &
POP3C_CAPABILITY_UIDL) == 0) {
mail_storage_set_error(mbox->box.storage,
MAIL_ERROR_NOTPOSSIBLE,
"UIDLs not supported by server");
return -1;
}
if (pop3c_client_cmd_stream(mbox->client, "UIDL\r\n",
&input, &error) < 0) {
mail_storage_set_critical(mbox->box.storage,
"UIDL failed: %s", error);
return -1;
}
mbox->uidl_pool = pool_alloconly_create("POP3 UIDLs", 1024*32);
p_array_init(&uidls, mbox->uidl_pool, 64); seq = 0;
while ((line = i_stream_read_next_line(input)) != NULL) {
seq++;
p = strchr(line, ' ');
if (p == NULL) {
mail_storage_set_critical(mbox->box.storage,
"Invalid UIDL line: %s", line);
break;
}
*p++ = '\0';
if (str_to_uint(line, &line_seq) < 0 || line_seq != seq) {
mail_storage_set_critical(mbox->box.storage,
"Unexpected UIDL seq: %s != %u", line, seq);
break;
}
cline = p_strdup(mbox->uidl_pool, p);
array_append(&uidls, &cline, 1);
}
i_stream_destroy(&input);
if (line != NULL) {
pool_unref(&mbox->uidl_pool);
return -1;
}
if (seq == 0) {
/* make msg_uidls non-NULL */
array_append_zero(&uidls);
}
mbox->msg_uidls = array_idx(&uidls, 0);
mbox->msg_count = seq;
return 0;
}
