login_proxy_free_full(struct login_proxy **_proxy, const char *reason,
bool delayed)
{
struct login_proxy *proxy = *_proxy;
struct client *client = proxy->client;
const char *ipstr;
unsigned int delay_ms = 0;
*_proxy = NULL;
if (proxy->destroying)
return;
proxy->destroying = TRUE;
/* we'll disconnect server side in any case. */
login_proxy_disconnect(proxy);
if (proxy->client_fd != -1) {
/* detached proxy */
DLLIST_REMOVE(&login_proxies, proxy);
if (delayed)
delay_ms = login_proxy_delay_disconnect(proxy);
ipstr = net_ip2addr(&proxy->client->ip);
client_log(proxy->client, t_strdup_printf(
"proxy(%s): disconnecting %s%s%s",
proxy->client->virtual_user,
ipstr != NULL ? ipstr : "",
reason == NULL ? "" : t_strdup_printf(" (%s)", reason),
delay_ms == 0 ? "" : t_strdup_printf(" - disconnecting client in %ums", delay_ms)));
if (proxy->client_io != NULL)
io_remove(&proxy->client_io);
} else {
i_assert(proxy->client_io == NULL);
i_assert(proxy->client_input == NULL);
i_assert(proxy->client_output == NULL);
i_assert(proxy->client_fd == -1);
DLLIST_REMOVE(&login_proxies_pending, proxy);
if (proxy->callback != NULL)
proxy->callback(proxy->client);
}
if (delay_ms == 0)
login_proxy_free_final(proxy);
else {
proxy->client_io = io_add_istream(proxy->client_input,
proxy_client_disconnected_input, proxy);
}
client->login_proxy = NULL;
client_unref(&client);
}
/*---------------------------------------------------------------------------*/
void _rtp_timer_add_new_jobs (RTPTimerJob* toTimerList, RTPTimerJob* fromTimerList)
{
RTPTimerJob *next;
RTPTimerJob *newJob;
RTPTimerJob *job;
long timeDifference;
newJob = fromTimerList->next;
while (newJob != fromTimerList)
{
next = newJob->next;
newJob->scheduledTimeMsec += rtp_get_system_msec();
job = toTimerList->next;
while (job != toTimerList)
{
timeDifference = (long) (job->scheduledTimeMsec - newJob->scheduledTimeMsec);
if (timeDifference > 0)
{
break;
}
job = job->next;
}
DLLIST_REMOVE(newJob);
DLLIST_INSERT_BEFORE(job, newJob);
newJob->listId = RTP_TIMER_LIST_ACTIVE;
newJob = next;
}
}
void login_connection_deinit(struct login_connection **_conn)
{
struct login_connection *conn = *_conn;
*_conn = NULL;
if (conn->destroyed)
return;
conn->destroyed = TRUE;
DLLIST_REMOVE(&login_connections, conn);
io_remove(&conn->io);
if (conn->input != NULL)
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(login connection) failed: %m");
conn->fd = -1;
if (conn->auth != NULL)
auth_connection_deinit(&conn->auth);
login_connection_unref(&conn);
master_service_client_connection_destroyed(master_service);
}
static void login_proxy_free_final(struct login_proxy *proxy)
{
if (proxy->delayed_disconnect) {
DLLIST_REMOVE(&login_proxies_disconnecting, proxy);
i_assert(proxy->state_rec->num_delayed_client_disconnects > 0);
if (--proxy->state_rec->num_delayed_client_disconnects == 0)
proxy->state_rec->num_disconnects_since_ts = 0;
timeout_remove(&proxy->to);
}
if (proxy->client_io != NULL)
io_remove(&proxy->client_io);
if (proxy->client_input != NULL)
i_stream_destroy(&proxy->client_input);
if (proxy->client_output != NULL)
o_stream_destroy(&proxy->client_output);
if (proxy->client_fd != -1)
net_disconnect(proxy->client_fd);
if (proxy->ssl_server_proxy != NULL) {
ssl_proxy_destroy(proxy->ssl_server_proxy);
ssl_proxy_free(&proxy->ssl_server_proxy);
}
i_free(proxy->host);
i_free(proxy);
}
void auth_client_connection_destroy(struct auth_client_connection **_conn)
{
struct auth_client_connection *conn = *_conn;
*_conn = NULL;
if (conn->fd == -1)
return;
DLLIST_REMOVE(&auth_client_connections, conn);
i_stream_close(conn->input);
o_stream_close(conn->output);
if (conn->io != NULL)
io_remove(&conn->io);
net_disconnect(conn->fd);
conn->fd = -1;
if (conn->request_handler != NULL) {
auth_request_handler_abort_requests(conn->request_handler);
auth_request_handler_destroy(&conn->request_handler);
}
master_service_client_connection_destroyed(master_service);
auth_client_connection_unref(&conn);
}
void client_command_free(struct client_command_context **_cmd)
{
struct client_command_context *cmd = *_cmd;
struct client *client = cmd->client;
enum client_command_state state = cmd->state;
*_cmd = NULL;
i_assert(client->output_cmd_lock == NULL);
/* reset input idle time because command output might have taken a
long time and we don't want to disconnect client immediately then */
client->last_input = ioloop_time;
timeout_reset(client->to_idle);
if (cmd->cancel) {
cmd->cancel = FALSE;
client_send_tagline(cmd, "NO Command cancelled.");
}
if (!cmd->param_error)
client->bad_counter = 0;
if (client->input_lock == cmd)
client->input_lock = NULL;
if (client->mailbox_change_lock == cmd)
client->mailbox_change_lock = NULL;
if (client->free_parser == NULL) {
imap_parser_reset(cmd->parser);
client->free_parser = cmd->parser;
} else if (cmd->parser != NULL) {
imap_parser_unref(&cmd->parser);
}
client->command_queue_size--;
DLLIST_REMOVE(&client->command_queue, cmd);
cmd = NULL;
if (client->command_queue == NULL) {
/* no commands left in the queue, we can clear the pool */
p_clear(client->command_pool);
if (client->to_idle_output != NULL)
timeout_remove(&client->to_idle_output);
}
imap_client_notify_command_freed(client);
imap_refresh_proctitle();
/* if command finished from external event, check input for more
unhandled commands since we may not be executing from client_input
or client_output. */
if (state == CLIENT_COMMAND_STATE_WAIT_EXTERNAL &&
!client->disconnected) {
client_add_missing_io(client);
if (client->to_delayed_input == NULL) {
client->to_delayed_input =
timeout_add(0, client_input, client);
}
}
}
static void
io_loop_notify_free(struct ioloop_notify_handler_context *ctx,
struct io_notify *io)
{
DLLIST_REMOVE(&ctx->notifies, io);
i_free(io);
}
static void
auth_postfix_connection_destroy(struct auth_postfix_connection **_conn)
{
struct auth_postfix_connection *conn = *_conn;
*_conn = NULL;
if (conn->destroyed)
return;
conn->destroyed = TRUE;
DLLIST_REMOVE(&auth_postfix_connections, conn);
if (conn->input != NULL)
i_stream_close(conn->input);
if (conn->output != NULL)
o_stream_close(conn->output);
if (conn->io != NULL)
io_remove(&conn->io);
if (conn->fd != -1) {
if (close(conn->fd) < 0)
i_error("close(%s): %m", conn->path);
conn->fd = -1;
}
master_service_client_connection_destroyed(master_service);
auth_postfix_connection_unref(&conn);
}
void service_process_destroy(struct service_process *process)
{
struct service *service = process->service;
struct service_list *service_list = service->list;
DLLIST_REMOVE(&service->processes, process);
hash_table_remove(service_pids, POINTER_CAST(process->pid));
if (process->available_count > 0)
service->process_avail--;
service->process_count--;
i_assert(service->process_avail <= service->process_count);
if (process->to_status != NULL)
timeout_remove(&process->to_status);
if (process->to_idle != NULL)
timeout_remove(&process->to_idle);
if (service->list->log_byes != NULL)
service_process_notify_add(service->list->log_byes, process);
process->destroyed = TRUE;
service_process_unref(process);
if (service->process_count < service->process_limit &&
service->type == SERVICE_TYPE_LOGIN)
service_login_notify(service, FALSE);
service_list_unref(service_list);
}
/*---------------------------------------------------------------------------*/
void _rtp_timer_process_expired_jobs (RTPTimerJob* timerList)
{
RTPTimerJob *job = timerList->next;
long timeDifferenceMsec;
unsigned long currentMsec = rtp_get_system_msec();
void (*timerFunction) (int,void*);
void* timerData;
while (job != timerList)
{
rtpTimerNextToProcess = job->next;
timeDifferenceMsec = (long) (currentMsec - job->scheduledTimeMsec);
if (timeDifferenceMsec > 0)
{
DLLIST_REMOVE(job);
if (job->repeat == RTP_TIMER_REPEAT_INFINITE)
{
DLLIST_INSERT_BEFORE(&rtpTimerNewList, job);
job->listId = RTP_TIMER_LIST_NEW;
}
else
{
if (job->repeat > 0)
{
/* if this timer has more repeats left, add it to the
new list */
job->repeat--;
DLLIST_INSERT_BEFORE(&rtpTimerNewList, job);
job->listId = RTP_TIMER_LIST_NEW;
}
else
{
DLLIST_INIT(job);
job->listId = RTP_TIMER_LIST_NONE;
}
}
if (job->timerFunction)
{
timerFunction = job->timerFunction;
timerData = job->timerData;
rtp_sig_mutex_release(rtpTimerLock);
timerFunction(0, timerData);
rtp_sig_mutex_claim(rtpTimerLock);
}
}
else
{
break;
}
job = rtpTimerNextToProcess;
}
rtpTimerNextToProcess = 0;
}
static void client_destroy(struct client *client)
{
char **app;
i_set_failure_prefix("imap-urlauth[%s](%s): ",
my_pid, client->access_user);
if (client->url != NULL) {
/* deinitialize url */
i_stream_close(client->input);
o_stream_close(client->output);
(void)client_run_url(client);
i_assert(client->url == NULL);
}
imap_urlauth_worker_client_count--;
DLLIST_REMOVE(&imap_urlauth_worker_clients, client);
if (client->urlauth_ctx != NULL)
imap_urlauth_deinit(&client->urlauth_ctx);
if (client->mail_user != NULL)
mail_user_unref(&client->mail_user);
if (client->io != NULL)
io_remove(&client->io);
if (client->ctrl_io != NULL)
io_remove(&client->ctrl_io);
if (client->to_idle != NULL)
timeout_remove(&client->to_idle);
if (client->input != NULL)
i_stream_destroy(&client->input);
if (client->output != NULL)
o_stream_destroy(&client->output);
if (client->ctrl_input != NULL)
i_stream_destroy(&client->ctrl_input);
if (client->ctrl_output != NULL)
o_stream_destroy(&client->ctrl_output);
if (client->fd_in >= 0)
net_disconnect(client->fd_in);
if (client->fd_out >= 0 && client->fd_in != client->fd_out)
net_disconnect(client->fd_out);
if (client->fd_ctrl >= 0)
net_disconnect(client->fd_ctrl);
if (client->service_user != NULL)
mail_storage_service_user_free(&client->service_user);
i_free(client->access_user);
array_foreach_modifiable(&client->access_apps, app)
i_free(*app);
array_free(&client->access_apps);
i_free(client);
imap_urlauth_worker_refresh_proctitle();
master_service_client_connection_destroyed(master_service);
}
/*---------------------------------------------------------------------------*/
void _HTTP_HostRemoveRealm (
HTTPAuthenticationHost *host,
HTTPAuthenticationRealm *realm
)
{
DLLIST_REMOVE(&realm->node);
realm->host = 0;
}
void login_proxy_detach(struct login_proxy *proxy)
{
struct client *client = proxy->client;
const unsigned char *data;
size_t size;
i_assert(proxy->client_fd == -1);
i_assert(proxy->server_input != NULL);
i_assert(proxy->server_output != NULL);
if (proxy->to != NULL)
timeout_remove(&proxy->to);
proxy->client_fd = i_stream_get_fd(client->input);
proxy->client_input = client->input;
proxy->client_output = client->output;
i_stream_set_persistent_buffers(client->input, FALSE);
o_stream_set_max_buffer_size(client->output, (size_t)-1);
o_stream_set_flush_callback(client->output, proxy_client_output, proxy);
client->input = NULL;
client->output = NULL;
/* send all pending client input to proxy */
data = i_stream_get_data(proxy->client_input, &size);
if (size != 0)
o_stream_nsend(proxy->server_output, data, size);
/* from now on, just do dummy proxying */
io_remove(&proxy->server_io);
proxy->server_io =
io_add(proxy->server_fd, IO_READ, server_input, proxy);
proxy->client_io =
io_add_istream(proxy->client_input, proxy_client_input, proxy);
o_stream_set_flush_callback(proxy->server_output, server_output, proxy);
i_stream_destroy(&proxy->server_input);
if (proxy->notify_refresh_secs != 0) {
proxy->to_notify =
timeout_add(proxy->notify_refresh_secs * 1000,
login_proxy_notify, proxy);
}
proxy->callback = NULL;
if (login_proxy_ipc_server == NULL) {
login_proxy_ipc_server =
ipc_server_init(LOGIN_PROXY_IPC_PATH,
LOGIN_PROXY_IPC_NAME,
login_proxy_ipc_cmd);
}
DLLIST_REMOVE(&login_proxies_pending, proxy);
DLLIST_PREPEND(&login_proxies, proxy);
client->fd = -1;
client->login_proxy = NULL;
}
static void stats_transaction_free(struct stats_user *suser,
struct stats_transaction_context *strans)
{
DLLIST_REMOVE(&suser->transactions, strans);
trans_stats_add(&suser->session_stats.trans_stats,
&strans->trans->stats);
i_free(strans);
}
void connection_deinit(struct connection *conn)
{
i_assert(conn->list->connections_count > 0);
conn->list->connections_count--;
DLLIST_REMOVE(&conn->list->connections, conn);
connection_disconnect(conn);
i_free(conn->name);
}
static void
master_service_haproxy_conn_free(struct master_service_haproxy_conn *hpconn)
{
struct master_service *service = hpconn->service;
DLLIST_REMOVE(&service->haproxy_conns, hpconn);
io_remove(&hpconn->io);
timeout_remove(&hpconn->to);
pool_unref(&hpconn->pool);
}
void fifo_input_connection_destroy(struct fifo_input_connection **_conn)
{
struct fifo_input_connection *conn = *_conn;
*_conn = NULL;
DLLIST_REMOVE(&fifo_conns, conn);
io_remove(&conn->io);
i_stream_destroy(&conn->input);
if (close(conn->fd) < 0)
i_error("close(conn) failed: %m");
i_free(conn);
}
static void
master_service_haproxy_conn_free(struct master_service_haproxy_conn *hpconn)
{
struct master_service *service = hpconn->service;
DLLIST_REMOVE(&service->haproxy_conns, hpconn);
if (hpconn->io != NULL)
io_remove(&hpconn->io);
if (hpconn->to != NULL)
timeout_remove(&hpconn->to);
i_free(hpconn);
}
void config_connection_destroy(struct config_connection *conn)
{
DLLIST_REMOVE(&config_connections, conn);
io_remove(&conn->io);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(config conn) failed: %m");
i_free(conn);
master_service_client_connection_destroyed(master_service);
}
void notify_contexts_mail_transaction_rollback(struct mailbox_transaction_context *t)
{
struct notify_context *ctx;
struct notify_mail_txn *mail_txn;
for (ctx = ctx_list; ctx != NULL; ctx = ctx->next) {
mail_txn = notify_context_find_mail_txn(ctx, t);
if (ctx->v.mail_transaction_rollback != NULL)
ctx->v.mail_transaction_rollback(mail_txn->txn);
DLLIST_REMOVE(&ctx->mail_txn_list, mail_txn);
i_free(mail_txn);
}
}
/* ----------
* remoteListen_cleanup
*
* Free resources used by the remoteListen thread
* ----------
*/
static void
remoteListen_cleanup(struct listat ** listat_head, struct listat ** listat_tail)
{
struct listat *listat;
/*
* Free the listen status list
*/
while ((listat = *listat_head) != NULL)
{
DLLIST_REMOVE(*listat_head, *listat_tail, listat);
free(listat);
}
}
void notify_unregister(struct notify_context *ctx)
{
struct notify_mail_txn *mail_txn = ctx->mail_txn_list;
for (; mail_txn != NULL; mail_txn = mail_txn->next) {
if (ctx->v.mail_transaction_rollback != NULL)
ctx->v.mail_transaction_rollback(mail_txn->txn);
}
if (ctx->mailbox_delete_txn != NULL &&
ctx->v.mailbox_delete_rollback != NULL)
ctx->v.mailbox_delete_rollback(ctx->mailbox_delete_txn);
DLLIST_REMOVE(&ctx_list, ctx);
i_free(ctx);
}
static void
http_client_request_remove(struct http_client_request *req)
{
struct http_client *client = req->client;
if (req->listed) {
/* only decrease pending request counter if this request was submitted */
DLLIST_REMOVE(&client->requests_list, req);
client->requests_count--;
}
req->listed = FALSE;
if (client->requests_count == 0 && client->ioloop != NULL)
io_loop_stop(client->ioloop);
}
void notify_contexts_mail_transaction_commit(struct mailbox_transaction_context *t,
struct mail_transaction_commit_changes *changes)
{
struct notify_context *ctx;
struct notify_mail_txn *mail_txn;
for (ctx = ctx_list; ctx != NULL; ctx = ctx->next) {
if (ctx->v.mail_transaction_commit == NULL)
continue;
mail_txn = notify_context_find_mail_txn(ctx, t);
if (ctx->v.mail_transaction_commit != NULL)
ctx->v.mail_transaction_commit(mail_txn->txn, changes);
DLLIST_REMOVE(&ctx->mail_txn_list, mail_txn);
i_free(mail_txn);
}
}
static void stats_transaction_free(struct stats_user *suser,
struct stats_transaction_context *strans)
{
const struct mailbox_transaction_stats *src = &strans->trans->stats;
struct mailbox_transaction_stats *dest =
&suser->finished_transaction_stats;
DLLIST_REMOVE(&suser->transactions, strans);
dest->open_lookup_count += src->open_lookup_count;
dest->stat_lookup_count += src->stat_lookup_count;
dest->fstat_lookup_count += src->fstat_lookup_count;
dest->files_read_count += src->files_read_count;
dest->files_read_bytes += src->files_read_bytes;
dest->cache_hit_count += src->cache_hit_count;
i_free(strans);
}
void mail_index_transaction_unref(struct mail_index_transaction **_t)
{
struct mail_index_transaction *t = *_t;
*_t = NULL;
if (--t->refcount > 0)
return;
mail_index_transaction_reset_v(t);
DLLIST_REMOVE(&t->view->transactions_list, t);
array_free(&t->module_contexts);
mail_index_view_transaction_unref(t->view);
if (t->latest_view != NULL)
mail_index_view_close(&t->latest_view);
mail_index_view_close(&t->view);
i_free(t);
}
static void notify_connection_destroy(struct notify_connection *conn)
{
if (conn->destroyed)
return;
conn->destroyed = TRUE;
DLLIST_REMOVE(&connections, conn);
io_remove(&conn->io);
i_stream_close(conn->input);
o_stream_close(conn->output);
if (close(conn->fd) < 0)
i_error("close(notify connection) failed: %m");
conn->fd = -1;
notify_connection_unref(&conn);
master_service_client_connection_destroyed(master_service);
}
static void notify_connection_destroy(struct notify_connection *conn)
{
i_assert(conn->fd != -1);
if (!CONNECTION_IS_FIFO(conn))
master_service_client_connection_destroyed(master_service);
DLLIST_REMOVE(&conns, conn);
io_remove(&conn->io);
i_stream_close(conn->input);
if (conn->output != NULL)
o_stream_close(conn->output);
net_disconnect(conn->fd);
conn->fd = -1;
notify_connection_unref(conn);
}
static void view_close(struct mail_index_view *view)
{
i_assert(view->refcount == 0);
i_assert(view->index->views != NULL);
DLLIST_REMOVE(&view->index->views, view);
mail_transaction_log_view_close(&view->log_view);
if (array_is_created(&view->syncs_hidden))
array_free(&view->syncs_hidden);
mail_index_unmap(&view->map);
if (array_is_created(&view->map_refs)) {
mail_index_view_unref_maps(view);
array_free(&view->map_refs);
}
array_free(&view->module_contexts);
i_free(view);
}
void client_destroy(struct client **_client)
{
struct client *client = *_client;
*_client = NULL;
DLLIST_REMOVE(&clients, client);
if (client->io != NULL)
io_remove(&client->io);
i_stream_destroy(&client->input);
o_stream_destroy(&client->output);
if (close(client->fd) < 0)
i_error("close(client) failed: %m");
client_unref_iters(client);
pool_unref(&client->cmd_pool);
i_free(client);
master_service_client_connection_destroyed(master_service);
}