struct imap_passdb_module {
struct passdb_module module;
- struct imapc_client_settings set;
+ struct imapc_settings set;
bool set_have_vars;
};
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;
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));
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;
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);
}
}
- 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;
}
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;
}
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);
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);
/* 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;
}
#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)
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);
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);
{
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)
"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;
}
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);
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++) {
}
}
*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);
}
}
- 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;
{
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, "
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;
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)
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)) {
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) {
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);
}
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;
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();
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; i<conn->ips_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;
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);
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);
}
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
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;
}
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);
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;
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;
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);
}
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);
}
}
* 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 = {
}
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;
}
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;
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);
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);
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,
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,
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,
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,
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,
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();
}
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,
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,
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");
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");
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;
&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;
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);
projects / thirdparty / dovecot / core.git / commitdiff
