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; }