void pop3c_client_deinit(struct pop3c_client **_client)
{
struct pop3c_client *client = *_client;
pop3c_client_disconnect(client);
if (client->ssl_ctx != NULL)
ssl_iostream_context_deinit(&client->ssl_ctx);
pool_unref(&client->pool);
}
void http_server_deinit(struct http_server **_server)
{
struct http_server *server = *_server;
connection_list_deinit(&server->conn_list);
if (server->ssl_ctx != NULL)
ssl_iostream_context_deinit(&server->ssl_ctx);
pool_unref(&server->pool);
*_server = NULL;
}
void master_service_ssl_ctx_init(struct master_service *service)
{
const struct master_service_ssl_settings *set;
struct ssl_iostream_settings ssl_set;
const char *error;
if (service->ssl_ctx_initialized)
return;
service->ssl_ctx_initialized = TRUE;
/* must be called after master_service_init_finish() so that if
initialization fails we can close the SSL listeners */
i_assert(service->listeners != NULL || service->socket_count == 0);
set = master_service_ssl_settings_get(service);
if (strcmp(set->ssl, "no") == 0) {
/* SSL disabled, don't use it */
return;
}
memset(&ssl_set, 0, sizeof(ssl_set));
ssl_set.protocols = set->ssl_protocols;
ssl_set.cipher_list = set->ssl_cipher_list;
ssl_set.ca = set->ssl_ca;
ssl_set.cert = set->ssl_cert;
ssl_set.key = set->ssl_key;
ssl_set.key_password = set->ssl_key_password;
ssl_set.cert_username_field = set->ssl_cert_username_field;
ssl_set.crypto_device = set->ssl_crypto_device;
ssl_set.verbose = set->verbose_ssl;
ssl_set.verify_remote_cert = set->ssl_verify_client_cert;
ssl_set.prefer_server_ciphers = set->ssl_prefer_server_ciphers;
ssl_set.compression = set->parsed_opts.compression;
if (ssl_iostream_context_init_server(&ssl_set, &service->ssl_ctx,
&error) < 0) {
i_error("SSL context initialization failed, disabling SSL: %s",
error);
master_service_ssl_io_listeners_remove(service);
return;
}
if (ssl_refresh_parameters(service) < 0) {
i_error("Couldn't initialize SSL parameters, disabling SSL");
ssl_iostream_context_deinit(&service->ssl_ctx);
master_service_ssl_io_listeners_remove(service);
return;
}
}
void http_client_deinit(struct http_client **_client)
{
struct http_client *client = *_client;
struct http_client_request *req;
struct http_client_host *host;
struct http_client_peer *peer;
*_client = NULL;
/* destroy requests without calling callbacks */
req = client->requests_list;
while (req != NULL) {
struct http_client_request *next_req = req->next;
http_client_request_destroy(&req);
req = next_req;
}
i_assert(client->requests_count == 0);
/* free peers */
while (client->peers_list != NULL) {
peer = client->peers_list;
http_client_peer_close(&peer);
}
hash_table_destroy(&client->peers);
/* free hosts */
while (client->hosts_list != NULL) {
host = client->hosts_list;
http_client_host_free(&host);
}
hash_table_destroy(&client->hosts);
array_free(&client->delayed_failing_requests);
if (client->to_failing_requests != NULL)
timeout_remove(&client->to_failing_requests);
connection_list_deinit(&client->conn_list);
if (client->ssl_ctx != NULL)
ssl_iostream_context_deinit(&client->ssl_ctx);
pool_unref(&client->pool);
}
void http_client_deinit(struct http_client **_client)
{
struct http_client *client = *_client;
struct http_client_request *req, *const *req_idx;
struct http_client_host *host;
struct http_client_peer *peer;
/* drop delayed failing requests */
while (array_count(&client->delayed_failing_requests) > 0) {
req_idx = array_idx(&client->delayed_failing_requests, 0);
req = *req_idx;
i_assert(req->refcount == 1);
http_client_request_error_delayed(&req);
}
array_free(&client->delayed_failing_requests);
if (client->to_failing_requests != NULL)
timeout_remove(&client->to_failing_requests);
/* free peers */
while (client->peers_list != NULL) {
peer = client->peers_list;
http_client_peer_free(&peer);
}
hash_table_destroy(&client->peers);
/* free hosts */
while (client->hosts_list != NULL) {
host = client->hosts_list;
http_client_host_free(&host);
}
hash_table_destroy(&client->hosts);
connection_list_deinit(&client->conn_list);
if (client->ssl_ctx != NULL)
ssl_iostream_context_deinit(&client->ssl_ctx);
pool_unref(&client->pool);
*_client = NULL;
}
static int
cmd_dsync_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
{
struct dsync_cmd_context *ctx = (struct dsync_cmd_context *)_ctx;
struct dsync_ibc *ibc, *ibc2 = NULL;
struct dsync_brain *brain;
struct dsync_brain_settings set;
enum dsync_brain_flags brain_flags;
bool remote_errors_logged = FALSE;
bool changes_during_sync = FALSE;
int status = 0, ret = 0;
memset(&set, 0, sizeof(set));
set.sync_box = ctx->mailbox;
memcpy(set.sync_box_guid, ctx->mailbox_guid, sizeof(set.sync_box_guid));
set.lock_timeout_secs = ctx->lock_timeout;
set.state = ctx->state_input;
if (array_count(&ctx->exclude_mailboxes) > 0) {
/* array is NULL-terminated in init() */
set.exclude_mailboxes = array_idx(&ctx->exclude_mailboxes, 0);
}
doveadm_user_init_dsync(user);
if (ctx->namespace_prefix != NULL) {
set.sync_ns = mail_namespace_find(user->namespaces,
ctx->namespace_prefix);
}
if (ctx->run_type == DSYNC_RUN_TYPE_LOCAL)
dsync_ibc_init_pipe(&ibc, &ibc2);
else {
string_t *temp_prefix = t_str_new(64);
mail_user_set_get_temp_prefix(temp_prefix, user->set);
ibc = cmd_dsync_icb_stream_init(ctx, ctx->remote_name,
str_c(temp_prefix));
if (ctx->fd_err != -1) {
ctx->io_err = io_add(ctx->fd_err, IO_READ,
remote_error_input, ctx);
}
}
brain_flags = DSYNC_BRAIN_FLAG_SEND_MAIL_REQUESTS;
if (ctx->sync_visible_namespaces)
brain_flags |= DSYNC_BRAIN_FLAG_SYNC_VISIBLE_NAMESPACES;
if (ctx->purge_remote)
brain_flags |= DSYNC_BRAIN_FLAG_PURGE_REMOTE;
if (ctx->reverse_backup)
brain_flags |= DSYNC_BRAIN_FLAG_BACKUP_RECV;
else if (ctx->backup)
brain_flags |= DSYNC_BRAIN_FLAG_BACKUP_SEND;
if (ctx->no_mail_sync)
brain_flags |= DSYNC_BRAIN_FLAG_NO_MAIL_SYNC;
if (ctx->oneway)
brain_flags |= DSYNC_BRAIN_FLAG_NO_BACKUP_OVERWRITE;
if (doveadm_debug)
brain_flags |= DSYNC_BRAIN_FLAG_DEBUG;
brain = dsync_brain_master_init(user, ibc, ctx->sync_type,
brain_flags, &set);
if (ctx->run_type == DSYNC_RUN_TYPE_LOCAL) {
if (cmd_dsync_run_local(ctx, user, brain, ibc2,
&changes_during_sync) < 0)
ret = -1;
} else {
cmd_dsync_run_remote(user);
}
if (ctx->state_input != NULL) {
string_t *state_str = t_str_new(128);
dsync_brain_get_state(brain, state_str);
doveadm_print(str_c(state_str));
}
if (dsync_brain_has_unexpected_changes(brain) || changes_during_sync) {
/* don't log a warning when running via doveadm server
(e.g. called by replicator) */
if (ctx->ctx.conn == NULL) {
i_warning("Mailbox changes caused a desync. "
"You may want to run dsync again.");
}
ctx->ctx.exit_code = 2;
}
if (dsync_brain_deinit(&brain) < 0) {
ctx->ctx.exit_code = EX_TEMPFAIL;
ret = -1;
}
dsync_ibc_deinit(&ibc);
if (ibc2 != NULL)
dsync_ibc_deinit(&ibc2);
if (ctx->ssl_iostream != NULL)
ssl_iostream_destroy(&ctx->ssl_iostream);
if (ctx->ssl_ctx != NULL)
ssl_iostream_context_deinit(&ctx->ssl_ctx);
if (ctx->input != NULL)
i_stream_unref(&ctx->input);
if (ctx->output != NULL)
o_stream_unref(&ctx->output);
if (ctx->fd_in != -1) {
if (ctx->fd_out != ctx->fd_in)
i_close_fd(&ctx->fd_out);
i_close_fd(&ctx->fd_in);
}
if (ctx->run_type == DSYNC_RUN_TYPE_CMD)
cmd_dsync_wait_remote(ctx, &status);
/* print any final errors after the process has died. not closing
stdin/stdout before wait() may cause the process to hang, but stderr
shouldn't (at least with ssh) and we need stderr to be open to be
able to print the final errors */
if (ctx->err_stream != NULL) {
remote_error_input(ctx);
remote_errors_logged = ctx->err_stream->v_offset > 0;
i_stream_destroy(&ctx->err_stream);
}
if (ctx->run_type == DSYNC_RUN_TYPE_CMD)
cmd_dsync_log_remote_status(status, remote_errors_logged);
if (ctx->io_err != NULL)
io_remove(&ctx->io_err);
if (ctx->fd_err != -1)
i_close_fd(&ctx->fd_err);
return ret;
}
void master_service_ssl_ctx_deinit(struct master_service *service)
{
if (service->ssl_ctx != NULL)
ssl_iostream_context_deinit(&service->ssl_ctx);
service->ssl_ctx_initialized = FALSE;
}
