From: Karl Fleischmann Date: Fri, 1 Mar 2024 12:07:46 +0000 (+0100) Subject: lib-imap-client, global: Replace imapc_client_settings with imapc_settings X-Git-Tag: 2.4.1~820 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=df6dfeae3f87634b2aabdbda66e7f0dacd762cd7;p=thirdparty%2Fdovecot%2Fcore.git lib-imap-client, global: Replace imapc_client_settings with imapc_settings --- diff --git a/src/auth/passdb-imap.c b/src/auth/passdb-imap.c index b918777fb8..150c522891 100644 --- a/src/auth/passdb-imap.c +++ b/src/auth/passdb-imap.c @@ -13,7 +13,7 @@ struct imap_passdb_module { struct passdb_module module; - struct imapc_client_settings set; + struct imapc_settings set; bool set_have_vars; }; @@ -86,7 +86,7 @@ passdb_imap_verify_plain(struct auth_request *auth_request, struct imap_passdb_module *module = (struct imap_passdb_module *)_module; struct imap_auth_request *request; - struct imapc_client_settings set; + struct imapc_settings set; struct imapc_parameters params = {}; const char *error; string_t *str; @@ -95,34 +95,34 @@ passdb_imap_verify_plain(struct auth_request *auth_request, set.dns_client_socket_path = t_strconcat(auth_request->set->base_dir, "/", DNS_CLIENT_SOCKET_NAME, NULL); - set.password = password; - set.max_idle_time = IMAPC_DEFAULT_MAX_IDLE_TIME; + set.imapc_password = password; + set.imapc_max_idle_time = IMAPC_DEFAULT_MAX_IDLE_TIME; if (module->set_have_vars) { str = t_str_new(128); - if (auth_request_var_expand(str, set.username, auth_request, + if (auth_request_var_expand(str, set.imapc_user, auth_request, NULL, &error) <= 0) { e_error(authdb_event(auth_request), "Failed to expand username=%s: %s", - set.username, error); + set.imapc_user, error); callback(PASSDB_RESULT_INTERNAL_FAILURE, auth_request); return; } - set.username = t_strdup(str_c(str)); + set.imapc_user = t_strdup(str_c(str)); str_truncate(str, 0); - if (auth_request_var_expand(str, set.host, auth_request, + if (auth_request_var_expand(str, set.imapc_host, auth_request, NULL, &error) <= 0) { e_error(authdb_event(auth_request), "Failed to expand host=%s: %s", - set.host, error); + set.imapc_host, error); callback(PASSDB_RESULT_INTERNAL_FAILURE, auth_request); return; } - set.host = t_strdup(str_c(str)); + set.imapc_host = t_strdup(str_c(str)); } e_debug(authdb_event(auth_request), - "lookup host=%s port=%d", set.host, set.port); + "lookup host=%s port=%d", set.imapc_host, set.imapc_port); request = p_new(auth_request->pool, struct imap_auth_request, 1); request->client = imapc_client_init(&set, ¶ms, authdb_event(auth_request)); @@ -144,10 +144,10 @@ passdb_imap_preinit(pool_t pool, const char *args) module = p_new(pool, struct imap_passdb_module, 1); module->module.default_pass_scheme = "PLAIN"; - module->set.port = IMAP_DEFAULT_PORT; - module->set.ssl_mode = IMAPC_CLIENT_SSL_MODE_NONE; - module->set.username = "%u"; - module->set.rawlog_dir = ""; + module->set.imapc_port = IMAP_DEFAULT_PORT; + module->set.imapc_ssl = "no"; + module->set.imapc_user = "%u"; + module->set.imapc_rawlog_dir = ""; for (tmp = p_strsplit(pool, args, " "); *tmp != NULL; tmp++) { key = *tmp; @@ -157,24 +157,22 @@ passdb_imap_preinit(pool_t pool, const char *args) else key = t_strdup_until(key, value++); if (strcmp(key, "host") == 0) - module->set.host = value; + module->set.imapc_host = value; else if (strcmp(key, "port") == 0) { - if (net_str2port(value, &module->set.port) < 0) + if (net_str2port(value, &module->set.imapc_port) < 0) i_fatal("passdb imap: Invalid port: %s", value); port_set = TRUE; } else if (strcmp(key, "username") == 0) - module->set.username = value; + module->set.imapc_user = value; else if (strcmp(key, "rawlog_dir") == 0) - module->set.rawlog_dir = value; + module->set.imapc_rawlog_dir = value; else if (strcmp(key, "ssl") == 0) { if (strcmp(value, "imaps") == 0) { if (!port_set) - module->set.port = IMAPS_DEFAULT_PORT; - module->set.ssl_mode = - IMAPC_CLIENT_SSL_MODE_IMMEDIATE; + module->set.imapc_port = IMAPS_DEFAULT_PORT; + module->set.imapc_ssl = "imaps"; } else if (strcmp(value, "starttls") == 0) { - module->set.ssl_mode = - IMAPC_CLIENT_SSL_MODE_STARTTLS; + module->set.imapc_ssl = "starttls"; } else { i_fatal("passdb imap: Invalid ssl mode: %s", value); @@ -184,12 +182,12 @@ passdb_imap_preinit(pool_t pool, const char *args) } } - if (module->set.host == NULL) + if (module->set.imapc_host == NULL) i_fatal("passdb imap: Missing host parameter"); module->set_have_vars = - strchr(module->set.username, '%') != NULL || - strchr(module->set.host, '%') != NULL; + strchr(module->set.imapc_user, '%') != NULL || + strchr(module->set.imapc_host, '%') != NULL; return &module->module; } diff --git a/src/lib-imap-client/imapc-client-private.h b/src/lib-imap-client/imapc-client-private.h index d831632524..bc1ee942b2 100644 --- a/src/lib-imap-client/imapc-client-private.h +++ b/src/lib-imap-client/imapc-client-private.h @@ -16,8 +16,9 @@ struct imapc_client { int refcount; struct event *event; - struct imapc_client_settings set; + struct imapc_settings *set; struct imapc_parameters params; + enum imapc_client_ssl_mode ssl_mode; imapc_untagged_callback_t *untagged_callback; void *untagged_context; diff --git a/src/lib-imap-client/imapc-client.c b/src/lib-imap-client/imapc-client.c index 5665430c32..e0e93c819f 100644 --- a/src/lib-imap-client/imapc-client.c +++ b/src/lib-imap-client/imapc-client.c @@ -48,15 +48,15 @@ default_untagged_callback(const struct imapc_untagged_reply *reply ATTR_UNUSED, } struct imapc_client * -imapc_client_init(const struct imapc_client_settings *set, +imapc_client_init(const struct imapc_settings *set, const struct imapc_parameters *params, struct event *event_parent) { struct imapc_client *client; pool_t pool; - i_assert(set->connect_retry_count == 0 || - set->connect_retry_interval_msecs > 0); + i_assert(set->imapc_connection_retry_count == 0 || + set->imapc_connection_retry_interval > 0); pool = pool_alloconly_create("imapc client", 1024); client = p_new(pool, struct imapc_client, 1); @@ -64,44 +64,38 @@ imapc_client_init(const struct imapc_client_settings *set, client->refcount = 1; client->event = event_create(event_parent); event_set_append_log_prefix(client->event, t_strdup_printf( - "imapc(%s:%u): ", set->host, set->port)); - - client->set.host = p_strdup(pool, set->host); - client->set.port = set->port; - client->set.master_user = p_strdup_empty(pool, set->master_user); - client->set.username = p_strdup(pool, set->username); - client->set.password = p_strdup(pool, set->password); - client->set.sasl_mechanisms = p_strdup(pool, set->sasl_mechanisms); - client->set.session_id_prefix = p_strdup(pool, set->session_id_prefix); - client->set.use_proxyauth = set->use_proxyauth; - client->set.no_qresync = set->no_qresync; - client->set.dns_client_socket_path = + "imapc(%s:%u): ", set->imapc_host, set->imapc_port)); + + client->set = p_new(pool, struct imapc_settings, 1); + client->set->imapc_host = p_strdup(pool, set->imapc_host); + client->set->imapc_port = set->imapc_port; + client->set->imapc_master_user = p_strdup_empty(pool, set->imapc_master_user); + client->set->imapc_user = p_strdup(pool, set->imapc_user); + client->set->imapc_password = p_strdup(pool, set->imapc_password); + client->set->imapc_sasl_mechanisms = p_strdup(pool, set->imapc_sasl_mechanisms); + client->set->parsed_features = set->parsed_features; + client->set->dns_client_socket_path = p_strdup(pool, set->dns_client_socket_path); - client->set.temp_path_prefix = - p_strdup(pool, set->temp_path_prefix); - client->set.rawlog_dir = p_strdup(pool, set->rawlog_dir); - client->set.max_idle_time = set->max_idle_time; - client->set.connect_timeout_msecs = set->connect_timeout_msecs != 0 ? - set->connect_timeout_msecs : + client->set->imapc_rawlog_dir = p_strdup(pool, set->imapc_rawlog_dir); + client->set->imapc_max_idle_time = set->imapc_max_idle_time; + client->set->imapc_connection_timeout_interval = set->imapc_connection_timeout_interval != 0 ? + set->imapc_connection_timeout_interval : IMAPC_DEFAULT_CONNECT_TIMEOUT_MSECS; - client->set.connect_retry_count = set->connect_retry_count; - client->set.connect_retry_interval_msecs = set->connect_retry_interval_msecs; - client->set.cmd_timeout_msecs = set->cmd_timeout_msecs != 0 ? - set->cmd_timeout_msecs : IMAPC_DEFAULT_COMMAND_TIMEOUT_MSECS; - client->set.max_line_length = set->max_line_length != 0 ? - set->max_line_length : IMAPC_DEFAULT_MAX_LINE_LENGTH; - client->set.throttle_set = set->throttle_set; - client->set.ssl_mode = set->ssl_mode; - client->set.ssl_allow_invalid_cert = set->ssl_allow_invalid_cert; - - if (client->set.throttle_set.init_msecs == 0) - client->set.throttle_set.init_msecs = IMAPC_THROTTLE_DEFAULT_INIT_MSECS; - if (client->set.throttle_set.max_msecs == 0) - client->set.throttle_set.max_msecs = IMAPC_THROTTLE_DEFAULT_MAX_MSECS; - if (client->set.throttle_set.shrink_min_msecs == 0) - client->set.throttle_set.shrink_min_msecs = IMAPC_THROTTLE_DEFAULT_SHRINK_MIN_MSECS; - - client->untagged_callback = default_untagged_callback; + client->set->imapc_connection_retry_count = set->imapc_connection_retry_count; + client->set->imapc_connection_retry_interval = set->imapc_connection_retry_interval; + client->set->imapc_cmd_timeout = set->imapc_cmd_timeout != 0 ? + (set->imapc_cmd_timeout * 1000) : IMAPC_DEFAULT_COMMAND_TIMEOUT_MSECS; + client->set->imapc_max_line_length = set->imapc_max_line_length != 0 ? + set->imapc_max_line_length : IMAPC_DEFAULT_MAX_LINE_LENGTH; + client->set->imapc_ssl = p_strdup(pool, set->imapc_ssl); + client->set->imapc_ssl_verify = set->imapc_ssl_verify; + + client->set->throttle_init_msecs = set->throttle_init_msecs != 0 ? + set->throttle_init_msecs : IMAPC_THROTTLE_DEFAULT_INIT_MSECS; + client->set->throttle_max_msecs = set->throttle_max_msecs != 0 ? + set->throttle_max_msecs : IMAPC_THROTTLE_DEFAULT_MAX_MSECS; + client->set->throttle_shrink_min_msecs = set->throttle_shrink_min_msecs != 0 ? + set->throttle_shrink_min_msecs : IMAPC_THROTTLE_DEFAULT_SHRINK_MIN_MSECS; client->params.session_id_prefix = p_strdup(pool, params->session_id_prefix); @@ -111,12 +105,21 @@ imapc_client_init(const struct imapc_client_settings *set, /* Only override if the parameter is set. */ if (params->override_dns_client_socket_path != NULL) - client->set.dns_client_socket_path = + client->set->dns_client_socket_path = p_strdup(pool, params->override_dns_client_socket_path); if (params->override_rawlog_dir != NULL) - client->set.rawlog_dir = + client->set->imapc_rawlog_dir = p_strdup(pool, params->override_rawlog_dir); + client->untagged_callback = default_untagged_callback; + + client->ssl_mode = IMAPC_CLIENT_SSL_MODE_NONE; + if (strcmp(set->imapc_ssl, "imaps") == 0) { + client->ssl_mode = IMAPC_CLIENT_SSL_MODE_IMMEDIATE; + } else if (strcmp(set->imapc_ssl, "starttls") == 0) { + client->ssl_mode = IMAPC_CLIENT_SSL_MODE_STARTTLS; + } + p_array_init(&client->conns, pool, 8); return client; } diff --git a/src/lib-imap-client/imapc-client.h b/src/lib-imap-client/imapc-client.h index e16b8ff8a7..b0f58ce741 100644 --- a/src/lib-imap-client/imapc-client.h +++ b/src/lib-imap-client/imapc-client.h @@ -3,6 +3,7 @@ #include "net.h" #include "iostream-ssl.h" +#include "imapc-settings.h" /* IMAP RFC defines this to be at least 30 minutes. */ #define IMAPC_DEFAULT_MAX_IDLE_TIME (60*29) @@ -197,7 +198,7 @@ typedef void imapc_state_change_callback_t(void *context, const char *error); struct imapc_client * -imapc_client_init(const struct imapc_client_settings *set, +imapc_client_init(const struct imapc_settings *set, const struct imapc_parameters *params, struct event *event_parent); void imapc_client_disconnect(struct imapc_client *client); diff --git a/src/lib-imap-client/imapc-connection.c b/src/lib-imap-client/imapc-connection.c index 31150d8fae..769ea11955 100644 --- a/src/lib-imap-client/imapc-connection.c +++ b/src/lib-imap-client/imapc-connection.c @@ -221,7 +221,7 @@ imapc_connection_init(struct imapc_client *client, conn->login_context = login_context; conn->fd = -1; conn->literal.fd = -1; - conn->reconnect_ok = (client->set.connect_retry_count>0); + conn->reconnect_ok = (client->set->imapc_connection_retry_count>0); i_array_init(&conn->cmd_send_queue, 8); i_array_init(&conn->cmd_wait_list, 32); i_array_init(&conn->literal_files, 4); @@ -526,9 +526,9 @@ static bool imapc_connection_can_reconnect(struct imapc_connection *conn) { if (conn->client->logging_out) return FALSE; - if (conn->client->set.connect_retry_count == 0 || - (conn->client->set.connect_retry_count < UINT_MAX && - conn->reconnect_count >= conn->client->set.connect_retry_count)) + if (conn->client->set->imapc_connection_retry_count == 0 || + (conn->client->set->imapc_connection_retry_count < UINT_MAX && + conn->reconnect_count >= conn->client->set->imapc_connection_retry_count)) return FALSE; if (conn->selected_box != NULL) @@ -783,7 +783,7 @@ imapc_connection_parse_capability(struct imapc_connection *conn, "CAPABILITY list is missing IMAP4REV1"); return -1; } - if (conn->client->set.no_qresync) + if ((conn->client->set->parsed_features & IMAPC_FEATURE_NO_QRESYNC) != 0) conn->capabilities &= ENUM_NEGATE(IMAPC_CAPABILITY_QRESYNC); return 0; } @@ -912,14 +912,14 @@ imapc_connection_proxyauth_login_cb(const struct imapc_command_reply *reply, void *context) { struct imapc_connection *conn = context; - const struct imapc_client_settings *set = &conn->client->set; + const struct imapc_settings *set = conn->client->set; struct imapc_command *cmd; if (reply->state == IMAPC_COMMAND_STATE_OK) { cmd = imapc_connection_cmd(conn, imapc_connection_login_cb, conn); imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN); - imapc_command_sendf(cmd, "PROXYAUTH %s", set->username); + imapc_command_sendf(cmd, "PROXYAUTH %s", set->imapc_user); imapc_command_send_more(conn); } else { imapc_connection_auth_finish(conn, reply); @@ -984,9 +984,9 @@ imapc_connection_get_sasl_mech(struct imapc_connection *conn, const struct dsasl_client_mech **mech_r, const char **error_r) { - const struct imapc_client_settings *set = &conn->client->set; + const struct imapc_settings *set = conn->client->set; const char *const *mechanisms = - t_strsplit_spaces(set->sasl_mechanisms, ", "); + settings_boollist_get(&set->imapc_sasl_mechanisms); /* find one of the specified SASL mechanisms */ for (; *mechanisms != NULL; mechanisms++) { @@ -1001,26 +1001,26 @@ imapc_connection_get_sasl_mech(struct imapc_connection *conn, } } *error_r = t_strdup_printf("IMAP server doesn't support any of the requested SASL mechanisms: %s", - set->sasl_mechanisms); + t_strarray_join(mechanisms, ", ")); return -1; } static void imapc_connection_authenticate(struct imapc_connection *conn) { - const struct imapc_client_settings *set = &conn->client->set; + const struct imapc_settings *set = conn->client->set; struct imapc_command *cmd; struct dsasl_client_settings sasl_set; const struct dsasl_client_mech *sasl_mech = NULL; const char *error; - if (set->master_user == NULL) { - e_debug(conn->event, "Authenticating as %s", set->username); + if (set->imapc_master_user == NULL) { + e_debug(conn->event, "Authenticating as %s", set->imapc_user); } else { e_debug(conn->event, "Authenticating as %s for user %s", - set->master_user, set->username); + set->imapc_master_user, set->imapc_user); } - if (set->sasl_mechanisms != NULL && set->sasl_mechanisms[0] != '\0') { + if (array_not_empty(&set->imapc_sasl_mechanisms)) { if (imapc_connection_get_sasl_mech(conn, &sasl_mech, &error) < 0) { struct imapc_command_reply reply; i_zero(&reply); @@ -1032,36 +1032,37 @@ static void imapc_connection_authenticate(struct imapc_connection *conn) } } - if (set->use_proxyauth && set->master_user != NULL) { + if ((set->parsed_features & IMAPC_FEATURE_PROXYAUTH) != 0 && + set->imapc_master_user != NULL) { /* We can use LOGIN command */ cmd = imapc_connection_cmd(conn, imapc_connection_proxyauth_login_cb, conn); imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN); imapc_command_sendf(cmd, "LOGIN %s %s", - set->master_user, set->password); + set->imapc_master_user, set->imapc_password); return; } if (sasl_mech == NULL && - ((set->master_user == NULL && - !need_literal(set->username) && !need_literal(set->password)) || + ((set->imapc_master_user == NULL && + !need_literal(set->imapc_user) && !need_literal(set->imapc_password)) || (conn->capabilities & IMAPC_CAPABILITY_AUTH_PLAIN) == 0)) { /* We can use LOGIN command */ cmd = imapc_connection_cmd(conn, imapc_connection_login_cb, conn); imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN); imapc_command_sendf(cmd, "LOGIN %s %s", - set->username, set->password); + set->imapc_user, set->imapc_password); return; } i_zero(&sasl_set); - if (set->master_user == NULL) - sasl_set.authid = set->username; + if (set->imapc_master_user == NULL) + sasl_set.authid = set->imapc_user; else { - sasl_set.authid = set->master_user; - sasl_set.authzid = set->username; + sasl_set.authid = set->imapc_master_user; + sasl_set.authzid = set->imapc_user; } - sasl_set.password = set->password; + sasl_set.password = set->imapc_password; if (sasl_mech == NULL) sasl_mech = &dsasl_client_mech_plain; @@ -1147,7 +1148,7 @@ static void imapc_connection_starttls(struct imapc_connection *conn) { struct imapc_command *cmd; - if (conn->client->set.ssl_mode == IMAPC_CLIENT_SSL_MODE_STARTTLS && + if (conn->client->ssl_mode == IMAPC_CLIENT_SSL_MODE_STARTTLS && conn->ssl_iostream == NULL) { if ((conn->capabilities & IMAPC_CAPABILITY_STARTTLS) == 0) { e_error(conn->event, "Requested STARTTLS, " @@ -1347,7 +1348,7 @@ imapc_connection_throttle_shrink_timeout(struct imapc_connection *conn) else conn->throttle_msecs = conn->throttle_msecs*3 / 4; - if (conn->throttle_shrink_msecs <= conn->client->set.throttle_set.shrink_min_msecs) + if (conn->throttle_shrink_msecs <= conn->client->set->throttle_shrink_min_msecs) conn->throttle_shrink_msecs = 0; else conn->throttle_shrink_msecs = conn->throttle_shrink_msecs*3 / 4; @@ -1372,16 +1373,16 @@ imapc_connection_throttle(struct imapc_connection *conn, it as resp-text-code also in here if it's uppercased). */ if (strstr(reply->text_full, "[THROTTLED]") != NULL) { if (conn->throttle_msecs == 0) - conn->throttle_msecs = conn->client->set.throttle_set.init_msecs; + conn->throttle_msecs = conn->client->set->throttle_init_msecs; else if (conn->throttle_msecs < conn->last_successful_throttle_msecs) conn->throttle_msecs = conn->last_successful_throttle_msecs; else { conn->throttle_msecs *= 2; - if (conn->throttle_msecs > conn->client->set.throttle_set.max_msecs) - conn->throttle_msecs = conn->client->set.throttle_set.max_msecs; + if (conn->throttle_msecs > conn->client->set->throttle_max_msecs) + conn->throttle_msecs = conn->client->set->throttle_max_msecs; } if (conn->throttle_shrink_msecs == 0) - conn->throttle_shrink_msecs = conn->client->set.throttle_set.shrink_min_msecs; + conn->throttle_shrink_msecs = conn->client->set->throttle_shrink_min_msecs; else conn->throttle_shrink_msecs *= 2; if (conn->to_throttle_shrink != NULL) @@ -1655,7 +1656,7 @@ static int imapc_connection_ssl_handshaked(const char **error_r, void *context) const char *error; if (ssl_iostream_check_cert_validity(conn->ssl_iostream, - conn->client->set.host, &error) == 0) { + conn->client->set->imapc_host, &error) == 0) { e_debug(conn->event, "SSL handshake successful"); return 0; } else if (ssl_iostream_get_allow_invalid_cert(conn->ssl_iostream)) { @@ -1686,9 +1687,10 @@ static int imapc_connection_ssl_init(struct imapc_connection *conn) io_remove(&conn->io); enum ssl_iostream_flags ssl_flags = 0; - if (conn->client->set.ssl_allow_invalid_cert) + if (!conn->client->set->imapc_ssl_verify) ssl_flags |= SSL_IOSTREAM_FLAG_ALLOW_INVALID_CERT; - if (io_stream_autocreate_ssl_client(conn->event, conn->client->set.host, + if (io_stream_autocreate_ssl_client(conn->event, + conn->client->set->imapc_host, ssl_flags, &conn->input, &conn->output, &conn->ssl_iostream, &error) < 0) { @@ -1706,8 +1708,8 @@ static int imapc_connection_ssl_init(struct imapc_connection *conn) return -1; } - if (*conn->client->set.rawlog_dir != '\0') { - iostream_rawlog_create(conn->client->set.rawlog_dir, + if (*conn->client->set->imapc_rawlog_dir != '\0') { + iostream_rawlog_create(conn->client->set->imapc_rawlog_dir, &conn->input, &conn->output); } @@ -1728,20 +1730,20 @@ static int imapc_connection_connected(struct imapc_connection *conn) if (err != 0) { imapc_connection_try_reconnect(conn, t_strdup_printf( "connect(%s, %u) failed: %s", - net_ip2addr(ip), conn->client->set.port, - strerror(err)), conn->client->set.connect_retry_interval_msecs, TRUE); + net_ip2addr(ip), conn->client->set->imapc_port, + strerror(err)), conn->client->set->imapc_connection_retry_interval, TRUE); return -1; } if (net_getsockname(conn->fd, &local_ip, &local_port) < 0) local_port = 0; e_info(conn->event, "Connected to %s:%u (local %s:%u)", - net_ip2addr(ip), conn->client->set.port, + net_ip2addr(ip), conn->client->set->imapc_port, net_ip2addr(&local_ip), local_port); conn->io = io_add(conn->fd, IO_READ, imapc_connection_input, conn); o_stream_set_flush_callback(conn->output, imapc_connection_output, conn); - if (conn->client->set.ssl_mode == IMAPC_CLIENT_SSL_MODE_IMMEDIATE) { + if (conn->client->ssl_mode == IMAPC_CLIENT_SSL_MODE_IMMEDIATE) { if (imapc_connection_ssl_init(conn) < 0) { imapc_connection_disconnect(conn); return -1; @@ -1759,13 +1761,13 @@ static void imapc_connection_timeout(struct imapc_connection *conn) switch (conn->state) { case IMAPC_CONNECTION_STATE_CONNECTING: errstr = t_strdup_printf("connect(%s, %u) timed out after %u seconds", - net_ip2addr(ip), conn->client->set.port, - conn->client->set.connect_timeout_msecs/1000); + net_ip2addr(ip), conn->client->set->imapc_port, + conn->client->set->imapc_connection_timeout_interval/1000); connect_error = TRUE; break; case IMAPC_CONNECTION_STATE_AUTHENTICATING: errstr = t_strdup_printf("Authentication timed out after %u seconds", - conn->client->set.connect_timeout_msecs/1000); + conn->client->set->imapc_connection_timeout_interval/1000); break; default: i_unreached(); @@ -1809,12 +1811,12 @@ static void imapc_connection_connect_next_ip(struct imapc_connection *conn) unsigned int i; int fd; - i_assert(conn->client->set.max_idle_time > 0); + i_assert(conn->client->set->imapc_max_idle_time > 0); for (i = 0; iips_count;) { conn->prev_connect_idx = (conn->prev_connect_idx+1) % conn->ips_count; ip = &conn->ips[conn->prev_connect_idx]; - fd = net_connect_ip(ip, conn->client->set.port, NULL); + fd = net_connect_ip(ip, conn->client->set->imapc_port, NULL); if (fd != -1) break; @@ -1823,10 +1825,10 @@ static void imapc_connection_connect_next_ip(struct imapc_connection *conn) before failing completely. */ const char *error = t_strdup_printf( "net_connect_ip(%s:%u) failed: %m", - net_ip2addr(ip), conn->client->set.port); + net_ip2addr(ip), conn->client->set->imapc_port); if (conn->prev_connect_idx+1 == conn->ips_count) { imapc_connection_try_reconnect(conn, error, - conn->client->set.connect_retry_interval_msecs, TRUE); + conn->client->set->imapc_connection_retry_interval, TRUE); return; } e_error(conn->event, "%s", error); @@ -1836,13 +1838,13 @@ static void imapc_connection_connect_next_ip(struct imapc_connection *conn) conn->fd = fd; conn->input = conn->raw_input = - i_stream_create_fd(fd, conn->client->set.max_line_length); + i_stream_create_fd(fd, conn->client->set->imapc_max_line_length); conn->output = conn->raw_output = o_stream_create_fd(fd, SIZE_MAX); o_stream_set_no_error_handling(conn->output, TRUE); - if (*conn->client->set.rawlog_dir != '\0' && - conn->client->set.ssl_mode != IMAPC_CLIENT_SSL_MODE_IMMEDIATE) { - iostream_rawlog_create(conn->client->set.rawlog_dir, + if (*conn->client->set->imapc_rawlog_dir != '\0' && + conn->client->ssl_mode != IMAPC_CLIENT_SSL_MODE_IMMEDIATE) { + iostream_rawlog_create(conn->client->set->imapc_rawlog_dir, &conn->input, &conn->output); } @@ -1850,13 +1852,13 @@ static void imapc_connection_connect_next_ip(struct imapc_connection *conn) o_stream_set_flush_callback(conn->output, imapc_connection_connected, conn); conn->parser = imap_parser_create(conn->input, NULL, - conn->client->set.max_line_length); - conn->to = timeout_add(conn->client->set.connect_timeout_msecs, + conn->client->set->imapc_max_line_length); + conn->to = timeout_add(conn->client->set->imapc_connection_timeout_interval, imapc_connection_timeout, conn); - conn->to_output = timeout_add(conn->client->set.max_idle_time*1000, + conn->to_output = timeout_add(conn->client->set->imapc_max_idle_time*1000, imapc_connection_reset_idle, conn); e_debug(conn->event, "Connecting to %s:%u", net_ip2addr(ip), - conn->client->set.port); + conn->client->set->imapc_port); } static void @@ -1867,7 +1869,7 @@ imapc_connection_dns_callback(const struct dns_lookup_result *result, if (result->ret != 0) { e_error(conn->event, "dns_lookup(%s) failed: %s", - conn->client->set.host, result->error); + conn->client->set->imapc_host, result->error); imapc_connection_set_disconnected(conn); return; } @@ -1915,8 +1917,8 @@ void imapc_connection_connect(struct imapc_connection *conn) i_zero(&dns_set); dns_set.dns_client_socket_path = - conn->client->set.dns_client_socket_path; - dns_set.timeout_msecs = conn->client->set.connect_timeout_msecs; + conn->client->set->dns_client_socket_path; + dns_set.timeout_msecs = conn->client->set->imapc_connection_timeout_interval; dns_set.event_parent = conn->event; imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_CONNECTING); @@ -1926,16 +1928,16 @@ void imapc_connection_connect(struct imapc_connection *conn) e_error(conn->event, "imapc host is empty"); imapc_connection_set_disconnected(conn); return; - } else if (net_addr2ip(conn->client->set.host, &ip) == 0) { + } else if (net_addr2ip(conn->client->set->imapc_host, &ip) == 0) { conn->ips_count = 1; conn->ips = i_new(struct ip_addr, conn->ips_count); conn->ips[0] = ip; } else if (*dns_set.dns_client_socket_path == '\0') { - ret = net_gethostbyname(conn->client->set.host, + ret = net_gethostbyname(conn->client->set->imapc_host, &ips, &ips_count); if (ret != 0) { e_error(conn->event, "net_gethostbyname(%s) failed: %s", - conn->client->set.host, + conn->client->set->imapc_host, net_gethosterror(ret)); imapc_connection_set_disconnected(conn); return; @@ -1944,7 +1946,7 @@ void imapc_connection_connect(struct imapc_connection *conn) conn->ips = i_new(struct ip_addr, ips_count); memcpy(conn->ips, ips, ips_count * sizeof(*ips)); } else { - (void)dns_lookup(conn->client->set.host, &dns_set, + (void)dns_lookup(conn->client->set->imapc_host, &dns_set, imapc_connection_dns_callback, conn, &conn->dns_lookup); return; @@ -2269,7 +2271,7 @@ static void imapc_command_send_more(struct imapc_connection *conn) conn->to = timeout_add(IMAPC_LOGOUT_TIMEOUT_MSECS, imapc_command_timeout, conn); } else if (conn->to == NULL) { - conn->to = timeout_add(conn->client->set.cmd_timeout_msecs, + conn->to = timeout_add(conn->client->set->imapc_cmd_timeout, imapc_command_timeout, conn); } @@ -2329,7 +2331,7 @@ static void imapc_connection_send_idle_done(struct imapc_connection *conn) conn->idle_stopping = TRUE; o_stream_nsend_str(conn->output, "DONE\r\n"); if (conn->to == NULL) { - conn->to = timeout_add(conn->client->set.cmd_timeout_msecs, + conn->to = timeout_add(conn->client->set->imapc_cmd_timeout, imapc_command_timeout, conn); } } diff --git a/src/lib-imap-client/test-imapc-client.c b/src/lib-imap-client/test-imapc-client.c index b324d763cf..7a798d4fb8 100644 --- a/src/lib-imap-client/test-imapc-client.c +++ b/src/lib-imap-client/test-imapc-client.c @@ -45,19 +45,20 @@ static void main_deinit(void); * Test client */ -static struct imapc_client_settings test_imapc_default_settings = { - .host = "127.0.0.1", - .username = "testuser", - .password = "testpass", +static struct imapc_settings test_imapc_default_settings = { + .imapc_host = "127.0.0.1", + .imapc_user = "testuser", + .imapc_password = "testpass", .dns_client_socket_path = "", - .rawlog_dir = "", + .imapc_rawlog_dir = "", - .connect_timeout_msecs = 5000, - .connect_retry_count = 3, - .connect_retry_interval_msecs = 10, + .imapc_connection_timeout_interval = 5000, + .imapc_connection_retry_count = 3, + .imapc_connection_retry_interval = 10, - .max_idle_time = 10000, + .imapc_max_idle_time = 10000, + .imapc_ssl = "no", }; static const struct imapc_parameters imapc_params = { @@ -230,7 +231,7 @@ static int test_run_server(test_server_init_t *server_test) } static void -test_run_client(const struct imapc_client_settings *client_set, +test_run_client(struct imapc_settings *client_set, test_client_init_t *client_test) { struct ioloop *ioloop; @@ -256,11 +257,11 @@ test_run_client(const struct imapc_client_settings *client_set, } static void -test_run_client_server(const struct imapc_client_settings *client_set, +test_run_client_server(struct imapc_settings *client_set, test_client_init_t *client_test, test_server_init_t *server_test) { - struct imapc_client_settings client_set_copy = *client_set; + struct imapc_settings client_set_copy = *client_set; const char *error; imapc_client_cmd_tag_counter = 0; @@ -271,7 +272,7 @@ test_run_client_server(const struct imapc_client_settings *client_set, server.pid = (pid_t)-1; server.fd = -1; server.fd_listen = test_open_server_fd(&server.port); - client_set_copy.port = server.port; + client_set_copy.imapc_port = server.port; if (mkdir(imapc_params.temp_path_prefix, 0700) < 0 && errno != EEXIST) i_fatal("mkdir(%s) failed: %m", imapc_params.temp_path_prefix); @@ -310,7 +311,7 @@ static void test_imapc_connect_failed_client(void) static void test_imapc_connect_failed(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc connect failed"); test_run_client_server(&set, test_imapc_connect_failed_client, NULL); @@ -344,8 +345,8 @@ static void test_imapc_banner_hangs_server(void) static void test_imapc_banner_hangs(void) { - struct imapc_client_settings set = test_imapc_default_settings; - set.connect_timeout_msecs = 500; + struct imapc_settings set = test_imapc_default_settings; + set.imapc_connection_timeout_interval = 500; test_begin("imapc banner hangs"); test_run_client_server(&set, test_imapc_banner_hangs_client, @@ -392,8 +393,8 @@ static void test_imapc_login_hangs_server(void) static void test_imapc_login_hangs(void) { - struct imapc_client_settings set = test_imapc_default_settings; - set.connect_timeout_msecs = 500; + struct imapc_settings set = test_imapc_default_settings; + set.imapc_connection_timeout_interval = 500; test_begin("imapc login hangs"); test_run_client_server(&set, test_imapc_login_hangs_client, @@ -426,7 +427,7 @@ static void test_imapc_login_fails_server(void) static void test_imapc_login_fails(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc login fails"); test_run_client_server(&set, test_imapc_login_fails_client, @@ -491,7 +492,7 @@ static void test_imapc_reconnect_server(void) static void test_imapc_reconnect(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc reconnect"); test_run_client_server(&set, test_imapc_reconnect_client, @@ -565,7 +566,7 @@ static void test_imapc_reconnect_resend_cmds_server(void) static void test_imapc_reconnect_resend_commands(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc reconnect resend commands"); test_run_client_server(&set, test_imapc_reconnect_resend_cmds_client, @@ -630,12 +631,11 @@ static void test_imapc_reconnect_resend_cmds_failed_server(void) static void test_imapc_reconnect_resend_commands_failed(void) { - struct imapc_client_settings set = test_imapc_default_settings; - set.connect_timeout_msecs = 500; + struct imapc_settings set = test_imapc_default_settings; + set.imapc_connection_timeout_interval = 500; test_begin("imapc reconnect resend commands failed"); - test_run_client_server(&set, - test_imapc_reconnect_resend_cmds_failed_client, + test_run_client_server(&set, test_imapc_reconnect_resend_cmds_failed_client, test_imapc_reconnect_resend_cmds_failed_server); test_end(); } @@ -718,7 +718,7 @@ static void test_imapc_reconnect_mailbox_server(void) static void test_imapc_reconnect_mailbox(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc reconnect mailbox"); test_run_client_server(&set, test_imapc_reconnect_mailbox_client, @@ -755,7 +755,7 @@ static void test_imapc_client_get_capabilities_server(void) static void test_imapc_client_get_capabilities(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc_client_get_capabilities()"); test_run_client_server(&set, test_imapc_client_get_capabilities_client, @@ -797,7 +797,7 @@ static void test_imapc_client_get_capabilities_reconnected_server(void) static void test_imapc_client_get_capabilities_reconnected(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc_client_get_capabilities() reconnected"); @@ -829,7 +829,7 @@ static void test_imapc_client_get_capabilities_disconnected_server(void) static void test_imapc_client_get_capabilities_disconnected(void) { - struct imapc_client_settings set = test_imapc_default_settings; + struct imapc_settings set = test_imapc_default_settings; test_begin("imapc_client_get_capabilities() disconnected"); diff --git a/src/lib-storage/index/imapc/imapc-storage.c b/src/lib-storage/index/imapc/imapc-storage.c index ab50541e22..c5c851eaf1 100644 --- a/src/lib-storage/index/imapc/imapc-storage.c +++ b/src/lib-storage/index/imapc/imapc-storage.c @@ -314,7 +314,6 @@ int imapc_storage_client_create(struct mailbox_list *list, struct mail_namespace *ns = list->ns; const struct imapc_settings *imapc_set; struct imapc_storage_client *client; - struct imapc_client_settings set; struct imapc_parameters params = {}; string_t *str; @@ -322,42 +321,25 @@ int imapc_storage_client_create(struct mailbox_list *list, &imapc_set, error_r) < 0) return -1; - i_zero(&set); - set.host = imapc_set->imapc_host; - if ((ns->flags & NAMESPACE_FLAG_UNUSABLE) != 0 || *set.host == '\0') { + if ((ns->flags & NAMESPACE_FLAG_UNUSABLE) != 0 || + *imapc_set->imapc_host == '\0') /* Shared namespace user doesn't actually exist. Don't try to access the user via imapc, but also don't make this a visible error. If any code path tries to connect to imapc, it's a bug. */ params.flags |= IMAPC_PARAMETER_CLIENT_DISABLED; - } - set.port = imapc_set->imapc_port; - if (imapc_set->imapc_user[0] != '\0') - set.username = imapc_set->imapc_user; - else if (ns->owner != NULL) - set.username = ns->owner->username; - else - set.username = ns->user->username; - set.master_user = imapc_set->imapc_master_user; - set.password = imapc_set->imapc_password; - if (*set.password == '\0') { + + if (*imapc_set->imapc_password == '\0') { *error_r = "missing imapc_password"; settings_free(imapc_set); return -1; } - set.sasl_mechanisms = t_array_const_string_join(&imapc_set->imapc_sasl_mechanisms, ","); - set.use_proxyauth = (imapc_set->parsed_features & IMAPC_FEATURE_PROXYAUTH) != 0; - set.no_qresync = (imapc_set->parsed_features & IMAPC_FEATURE_NO_QRESYNC) != 0; - set.cmd_timeout_msecs = imapc_set->imapc_cmd_timeout * 1000; - set.connect_retry_count = imapc_set->imapc_connection_retry_count; - set.connect_retry_interval_msecs = imapc_set->imapc_connection_retry_interval; - set.max_idle_time = imapc_set->imapc_max_idle_time; - set.max_line_length = imapc_set->imapc_max_line_length; params.override_dns_client_socket_path = *ns->user->set->base_dir == '\0' ? "" : t_strconcat(ns->user->set->base_dir, "/", DNS_CLIENT_SOCKET_NAME, NULL); params.override_rawlog_dir = mail_user_home_expand(ns->user, imapc_set->imapc_rawlog_dir); + if ((imapc_set->parsed_features & IMAPC_FEATURE_SEND_ID) != 0) params.session_id_prefix = ns->user->session_id; @@ -365,25 +347,11 @@ int imapc_storage_client_create(struct mailbox_list *list, mail_user_set_get_temp_prefix(str, ns->user->set); params.temp_path_prefix = str_c(str); - if (!imapc_set->imapc_ssl_verify) - set.ssl_allow_invalid_cert = TRUE; - - if (strcmp(imapc_set->imapc_ssl, "imaps") == 0) - set.ssl_mode = IMAPC_CLIENT_SSL_MODE_IMMEDIATE; - else if (strcmp(imapc_set->imapc_ssl, "starttls") == 0) - set.ssl_mode = IMAPC_CLIENT_SSL_MODE_STARTTLS; - else - set.ssl_mode = IMAPC_CLIENT_SSL_MODE_NONE; - - set.throttle_set.init_msecs = imapc_set->throttle_init_msecs; - set.throttle_set.max_msecs = imapc_set->throttle_max_msecs; - set.throttle_set.shrink_min_msecs = imapc_set->throttle_shrink_min_msecs; - client = i_new(struct imapc_storage_client, 1); client->refcount = 1; client->set = imapc_set; i_array_init(&client->untagged_callbacks, 16); - client->client = imapc_client_init(&set, ¶ms, list->event); + client->client = imapc_client_init(client->set, ¶ms, list->event); imapc_client_register_untagged(client->client, imapc_storage_client_untagged_cb, client);