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);
}
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);
}
static void client_destroy(struct connection *conn)
{
struct doveadm_connection *client = (struct doveadm_connection *)conn;
connection_deinit(&client->conn);
i_free(client);
master_service_client_connection_destroyed(master_service);
}
static void imap_hibernate_client_destroy(struct connection *conn)
{
struct imap_hibernate_client *client = (struct imap_hibernate_client *)conn;
if (!client->imap_client_created)
master_service_client_connection_destroyed(master_service);
connection_deinit(conn);
i_free(conn);
}
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);
}
static void
client_connected_finish(const struct master_service_connection *conn)
{
struct client *client;
struct ssl_proxy *proxy;
struct ip_addr local_ip;
const struct login_settings *set;
const struct master_service_ssl_settings *ssl_set;
unsigned int local_port;
pool_t pool;
int fd_ssl;
void **other_sets;
if (net_getsockname(conn->fd, &local_ip, &local_port) < 0) {
memset(&local_ip, 0, sizeof(local_ip));
local_port = 0;
}
pool = pool_alloconly_create("login client", 8*1024);
set = login_settings_read(pool, &local_ip,
&conn->remote_ip, NULL, &ssl_set, &other_sets);
if (!ssl_connections && !conn->ssl) {
client = client_create(conn->fd, FALSE, pool,
set, ssl_set, other_sets,
&local_ip, &conn->remote_ip);
} else {
fd_ssl = ssl_proxy_alloc(conn->fd, &conn->remote_ip, pool,
set, ssl_set, &proxy);
if (fd_ssl == -1) {
net_disconnect(conn->fd);
pool_unref(&pool);
master_service_client_connection_destroyed(master_service);
return;
}
client = client_create(fd_ssl, TRUE, pool,
set, ssl_set, other_sets,
&local_ip, &conn->remote_ip);
client->ssl_proxy = proxy;
ssl_proxy_set_client(proxy, client);
ssl_proxy_start(proxy);
}
client->real_remote_port = client->remote_port = conn->remote_port;
client->real_local_port = client->local_port = local_port;
if (auth_client_to != NULL)
timeout_remove(&auth_client_to);
}
static void tcpwrap_client_destroy(struct tcpwrap_client **_client)
{
struct tcpwrap_client *client = *_client;
*_client = NULL;
timeout_remove(&client->to);
io_remove(&client->io);
if (close(client->fd) < 0)
i_error("close() failed: %m");
i_free(client);
tcpwrap_client = NULL;
master_service_client_connection_destroyed(master_service);
}
void master_connection_destroy(struct master_connection **_conn)
{
struct master_connection *conn = *_conn;
*_conn = NULL;
io_remove(&conn->io);
i_stream_destroy(&conn->input);
if (close(conn->fd) < 0)
i_error("close(master conn) failed: %m");
i_free(conn);
master_service_client_connection_destroyed(master_service);
}
static void login_access_lookup_free(struct login_access_lookup *lookup)
{
if (lookup->io != NULL)
io_remove(&lookup->io);
if (lookup->access != NULL)
access_lookup_destroy(&lookup->access);
if (lookup->conn.fd != -1) {
if (close(lookup->conn.fd) < 0)
i_error("close(client) failed: %m");
master_service_client_connection_destroyed(master_service);
}
p_strsplit_free(default_pool, lookup->sockets);
i_free(lookup);
}
static void dns_client_destroy(struct dns_client **_client)
{
struct dns_client *client = *_client;
*_client = NULL;
io_remove(&client->io);
i_stream_destroy(&client->input);
o_stream_destroy(&client->output);
if (close(client->fd) < 0)
i_error("close() failed: %m");
i_free(client);
dns_client = NULL;
master_service_client_connection_destroyed(master_service);
}
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);
}
void client_connection_destroy(struct client_connection **_conn)
{
struct client_connection *conn = *_conn;
*_conn = NULL;
if (conn->ssl_iostream != NULL)
ssl_iostream_destroy(&conn->ssl_iostream);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
io_remove(&conn->io);
if (close(conn->fd) < 0)
i_error("close(client) failed: %m");
pool_unref(&conn->pool);
doveadm_client = NULL;
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);
}
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);
}
void auth_worker_client_destroy(struct auth_worker_client **_client)
{
struct auth_worker_client *client = *_client;
*_client = NULL;
if (client->fd == -1)
return;
i_stream_close(client->input);
o_stream_close(client->output);
if (client->io != NULL)
io_remove(&client->io);
net_disconnect(client->fd);
client->fd = -1;
auth_worker_client_unref(&client);
auth_worker_client = NULL;
master_service_client_connection_destroyed(master_service);
}
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);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(login connection) failed: %m");
conn->fd = -1;
auth_connection_deinit(&conn->auth);
login_connection_unref(&conn);
master_service_client_connection_destroyed(master_service);
}
static void
client_connected_finish(const struct master_service_connection *conn)
{
struct client *client;
struct ssl_proxy *proxy;
const struct login_settings *set;
const struct master_service_ssl_settings *ssl_set;
pool_t pool;
int fd_ssl;
void **other_sets;
pool = pool_alloconly_create("login client", 8*1024);
set = login_settings_read(pool, &conn->local_ip,
&conn->remote_ip, NULL, &ssl_set, &other_sets);
if (!ssl_connections && !conn->ssl) {
(void)client_create(conn->fd, FALSE, pool, conn,
set, ssl_set, other_sets);
} else {
fd_ssl = ssl_proxy_alloc(conn->fd, &conn->remote_ip, pool,
set, ssl_set, &proxy);
if (fd_ssl == -1) {
net_disconnect(conn->fd);
pool_unref(&pool);
master_service_client_connection_destroyed(master_service);
return;
}
client = client_create(fd_ssl, TRUE, pool, conn,
set, ssl_set, other_sets);
client->ssl_proxy = proxy;
ssl_proxy_set_client(proxy, client);
ssl_proxy_start(proxy);
}
if (auth_client_to != NULL)
timeout_remove(&auth_client_to);
}
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->login_proxy == NULL);
if (client->ssl_proxy != NULL)
ssl_proxy_free(&client->ssl_proxy);
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->virtual_user_orig);
i_free(client->virtual_auth_user);
i_free(client->auth_mech_name);
i_free(client->master_data_prefix);
pool_unref(&client->pool);
i_assert(clients_count > 0);
clients_count--;
master_service_client_connection_destroyed(master_service);
login_refresh_proctitle();
return FALSE;
}
void client_destroy(struct client *client, const char *prefix,
const char *reason)
{
if (client->destroyed)
return;
client->destroyed = TRUE;
client_disconnect(client, prefix, reason);
submission_client_count--;
DLLIST_REMOVE(&submission_clients, client);
if (client->proxy_conn != NULL)
smtp_client_connection_close(&client->proxy_conn);
if (client->anvil_sent) {
master_service_anvil_send(master_service, t_strconcat(
"DISCONNECT\t", my_pid, "\tsubmission/",
mail_user_get_anvil_userip_ident(client->user),
"\n", NULL));
}
if (client->urlauth_ctx != NULL)
imap_urlauth_deinit(&client->urlauth_ctx);
mail_user_unref(&client->user);
mail_storage_service_user_unref(&client->service_user);
client_state_reset(client);
i_free(client->session_id);
i_free(client);
master_service_client_connection_destroyed(master_service);
submission_refresh_proctitle();
}
static void client_deinit(struct ostream *output)
{
o_stream_destroy(&output);
master_service_client_connection_destroyed(master_service);
}
static void client_default_destroy(struct client *client, const char *reason)
{
struct client_command_context *cmd;
const char *cmd_status = "";
i_assert(!client->destroyed);
client->destroyed = TRUE;
if (!client->disconnected) {
client->disconnected = TRUE;
if (reason == NULL) {
reason = io_stream_get_disconnect_reason(client->input,
client->output);
cmd_status = client_get_commands_status(client);
}
i_info("%s%s %s", reason, cmd_status, client_stats(client));
}
i_stream_close(client->input);
o_stream_close(client->output);
/* finish off all the queued commands. */
if (client->output_cmd_lock != NULL)
client_command_cancel(&client->output_cmd_lock);
while (client->command_queue != NULL) {
cmd = client->command_queue;
client_command_cancel(&cmd);
}
/* handle the input_lock command last. it might have been waiting on
other queued commands (although we probably should just drop the
command at that point since it hasn't started running. but this may
change in future). */
if (client->input_lock != NULL)
client_command_cancel(&client->input_lock);
if (client->mailbox != NULL) {
client_search_updates_free(client);
mailbox_free(&client->mailbox);
}
if (client->notify_ctx != NULL)
imap_notify_deinit(&client->notify_ctx);
if (client->urlauth_ctx != NULL)
imap_urlauth_deinit(&client->urlauth_ctx);
if (client->anvil_sent) {
master_service_anvil_send(master_service, t_strconcat(
"DISCONNECT\t", my_pid, "\timap/",
mail_user_get_anvil_userip_ident(client->user),
"\n", NULL));
}
mail_user_unref(&client->user);
if (client->free_parser != NULL)
imap_parser_unref(&client->free_parser);
if (client->io != NULL)
io_remove(&client->io);
if (client->to_idle_output != NULL)
timeout_remove(&client->to_idle_output);
if (client->to_delayed_input != NULL)
timeout_remove(&client->to_delayed_input);
timeout_remove(&client->to_idle);
i_stream_destroy(&client->input);
o_stream_destroy(&client->output);
net_disconnect(client->fd_in);
if (client->fd_in != client->fd_out)
net_disconnect(client->fd_out);
if (array_is_created(&client->search_saved_uidset))
array_free(&client->search_saved_uidset);
if (array_is_created(&client->search_updates))
array_free(&client->search_updates);
pool_unref(&client->command_pool);
mail_storage_service_user_free(&client->service_user);
imap_client_count--;
DLLIST_REMOVE(&imap_clients, client);
pool_unref(&client->pool);
master_service_client_connection_destroyed(master_service);
imap_refresh_proctitle();
}
