static void
smtp_client_connection_commands_fail_reply(struct smtp_client_connection *conn,
- const struct smtp_reply *reply)
+ const struct smtp_reply *reply)
{
smtp_client_commands_list_fail_reply(conn->cmd_wait_list_head,
conn->cmd_wait_list_count, reply);
static void
smtp_client_connection_commands_fail(struct smtp_client_connection *conn,
- unsigned int status, const char *error)
+ unsigned int status, const char *error)
{
struct smtp_reply reply;
static void
smtp_client_connection_login_callback(struct smtp_client_connection *conn,
- const struct smtp_reply *reply)
+ const struct smtp_reply *reply)
{
smtp_client_command_callback_t *callback = conn->login_callback;
void *context = conn->login_context;
static void
smtp_client_connection_login_fail(struct smtp_client_connection *conn,
- unsigned int status, const char *error)
+ unsigned int status, const char *error)
{
struct smtp_reply reply;
smtp_client_connection_ref(conn);
e_error(conn->event, "Command timed out, disconnecting");
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_TIMED_OUT,
- "Command timed out");
+ smtp_client_connection_fail(conn, SMTP_CLIENT_COMMAND_ERROR_TIMED_OUT,
+ "Command timed out");
smtp_client_connection_unref(&conn);
}
e_debug(conn->event, "Start timeout");
if (conn->to_commands == NULL) {
- conn->to_commands = timeout_add
- (msecs, smtp_client_command_timeout, conn);
+ conn->to_commands = timeout_add(
+ msecs, smtp_client_command_timeout, conn);
}
}
if (status == SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED &&
!smtp_client_connection_last_ip(conn)) {
i_assert(conn->to_connect == NULL);
- conn->to_connect = timeout_add_short(0, smtp_client_connection_connect_next_ip,
- conn);
+ conn->to_connect = timeout_add_short(
+ 0, smtp_client_connection_connect_next_ip, conn);
return;
}
e_error(conn->event, "Connection lost: write(%s) failed: %s",
o_stream_get_name(conn->conn.output),
o_stream_get_error(conn->conn.output));
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
"Lost connection to remote server: "
"Write failure");
} else {
e_error(conn->event, "Connection lost: Remote disconnected");
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
"Lost connection to remote server: "
"Remote closed connection unexpectedly");
}
{
timeout_remove(&conn->to_connect);
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_READY);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_READY);
conn->reset_needed = FALSE;
e_debug(conn->event, "Connection ready");
SMTP_CLIENT_COMMAND_FLAG_PRIORITY;
cmd = smtp_client_command_new(conn, flags,
- smtp_client_connection_xclient_cb, conn);
+ smtp_client_connection_xclient_cb, conn);
smtp_client_command_write(cmd, cmdstr);
smtp_client_command_submit(cmd);
e_error(conn->event, "Authentication failed: "
"Server returned multi-line reply: %s",
smtp_reply_log(reply));
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Authentication protocol error");
return;
}
input_len = strlen(reply->text_lines[0]);
buf = buffer_create_dynamic(pool_datastack_create(),
MAX_BASE64_DECODED_SIZE(input_len));
- if (base64_decode
- (reply->text_lines[0], input_len, NULL, buf) < 0) {
+ if (base64_decode(reply->text_lines[0], input_len,
+ NULL, buf) < 0) {
e_error(conn->event, "Authentication failed: "
"Server sent non-base64 input for AUTH: %s",
reply->text_lines[0]);
} else if (dsasl_client_input(conn->sasl_client,
- buf->data, buf->used, &error) < 0) {
+ buf->data, buf->used,
+ &error) < 0) {
e_error(conn->event, "Authentication failed: %s",
error);
- } else if (dsasl_client_output(conn->sasl_client,
- &sasl_output, &sasl_output_len, &error) < 0) {
+ } else if (dsasl_client_output(conn->sasl_client, &sasl_output,
+ &sasl_output_len, &error) < 0) {
e_error(conn->event, "Authentication failed: %s",
error);
} else {
string_t *smtp_output = t_str_new(
- MAX_BASE64_ENCODED_SIZE(sasl_output_len)+2);
- base64_encode(sasl_output,
- sasl_output_len, smtp_output);
+ MAX_BASE64_ENCODED_SIZE(sasl_output_len) + 2);
+ base64_encode(sasl_output, sasl_output_len,
+ smtp_output);
str_append(smtp_output, "\r\n");
- o_stream_nsend(conn->conn.output,
- str_data(smtp_output), str_len(smtp_output));
+ o_stream_nsend(conn->conn.output, str_data(smtp_output),
+ str_len(smtp_output));
return;
}
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Authentication failed");
return;
}
mechanisms = t_strsplit_spaces(set->sasl_mechanisms, ", ");
for (; *mechanisms != NULL; mechanisms++) {
if (str_array_icase_find(conn->caps.auth_mechanisms,
- *mechanisms)) {
+ *mechanisms)) {
*mech_r = dsasl_client_mech_find(*mechanisms);
if (*mech_r != NULL)
return 0;
}
*error_r = t_strdup_printf(
"Server doesn't support any of "
- "the requested SASL mechanisms: %s",
- set->sasl_mechanisms);
+ "the requested SASL mechanisms: %s", set->sasl_mechanisms);
return -1;
}
return TRUE;
if ((conn->caps.standard & SMTP_CAPABILITY_AUTH) == 0) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Authentication not supported");
return FALSE;
}
e_debug(conn->event, "Authenticating as %s", set->username);
}
- if (smtp_client_connection_get_sasl_mech(conn,
- &sasl_mech, &error) < 0) {
+ if (smtp_client_connection_get_sasl_mech(conn, &sasl_mech,
+ &error) < 0) {
e_error(conn->event, "Authentication failed: %s", error);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Server authentication mechanisms incompatible");
return FALSE;
}
e_error(conn->event,
"Failed to create initial %s SASL reply: %s",
dsasl_client_mech_get_name(sasl_mech), error);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Internal authentication failure");
return FALSE;
}
init_resp = (str_len(sasl_output_base64) == 0 ?
"=" : str_c(sasl_output_base64));
- cmd = smtp_client_command_new(conn,
- SMTP_CLIENT_COMMAND_FLAG_PRELOGIN,
- smtp_client_connection_auth_cb, conn);
+ cmd = smtp_client_command_new(conn, SMTP_CLIENT_COMMAND_FLAG_PRELOGIN,
+ smtp_client_connection_auth_cb, conn);
smtp_client_command_printf(cmd, "AUTH %s %s",
- dsasl_client_mech_get_name(sasl_mech), init_resp);
+ dsasl_client_mech_get_name(sasl_mech),
+ init_resp);
smtp_client_command_submit(cmd);
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_AUTHENTICATING);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_AUTHENTICATING);
return FALSE;
}
}
if (smtp_client_connection_ssl_init(conn, &error) < 0) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED, error);
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED, error);
} else {
if (conn->to_connect != NULL)
timeout_reset(conn->to_connect);
if ((conn->caps.standard & SMTP_CAPABILITY_STARTTLS) == 0) {
e_error(conn->event, "Requested STARTTLS, "
"but server doesn't support it");
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
"STARTTLS not supported");
return FALSE;
}
e_debug(conn->event, "Starting TLS");
- cmd = smtp_client_command_new(conn,
- SMTP_CLIENT_COMMAND_FLAG_PRELOGIN,
+ cmd = smtp_client_command_new(
+ conn, SMTP_CLIENT_COMMAND_FLAG_PRELOGIN,
smtp_client_connection_starttls_cb, conn);
smtp_client_command_write(cmd, "STARTTLS");
smtp_client_command_submit(cmd);
"command not recognized" response to EHLO, the client SHOULD
be able to fall back and send HELO. */
if (conn->protocol == SMTP_PROTOCOL_SMTP && !conn->old_smtp &&
- (reply->status == 500 || reply->status == 502)) {
+ (reply->status == 500 || reply->status == 502)) {
/* try HELO */
conn->old_smtp = TRUE;
smtp_client_connection_handshake(conn);
lines = reply->text_lines;
if (*lines == NULL) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
"Invalid handshake reply");
return;
}
const char *const *params;
const char *cap_name, *error;
- if (smtp_ehlo_line_parse(*lines,
- &cap_name, ¶ms, &error) <= 0) {
+ if (smtp_ehlo_line_parse(*lines, &cap_name, ¶ms,
+ &error) <= 0) {
e_warning(conn->event,
"Received invalid EHLO response line: %s",
error);
e_debug(conn->event, "Sending %s handshake", command);
- cmd = smtp_client_command_new(conn, flags,
- smtp_client_connection_handshake_cb, conn);
+ cmd = smtp_client_command_new(
+ conn, flags, smtp_client_connection_handshake_cb, conn);
smtp_client_command_write(cmd, command);
smtp_client_command_write(cmd, " ");
smtp_client_command_write(cmd, conn->set.my_hostname);
smtp_client_command_submit(cmd);
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_HANDSHAKING);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_HANDSHAKING);
}
static int
smtp_reply_log(reply));
if (reply->status != 220) {
if (smtp_reply_is_success(reply)) {
- smtp_client_connection_fail(conn,
+ smtp_client_connection_fail(
+ conn,
SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
"Received inappropriate greeting");
} else {
if (conn->cmd_wait_list_head == NULL) {
e_debug(conn->event, "Unexpected reply: %s",
smtp_reply_log(reply));
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
"Got unexpected reply");
return -1;
}
!conn->cmd_wait_list_head->stream_finished) {
e_debug(conn->event, "Early reply: %s", smtp_reply_log(reply));
if (smtp_reply_is_success(reply)) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
"Got early success reply");
return -1;
}
ret = smtp_client_command_input_reply(conn->cmd_wait_list_head, reply);
if (conn->state == SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED ||
- conn->conn.output == NULL)
+ conn->conn.output == NULL)
return -1;
-
return ret;
}
struct smtp_client_connection *conn =
(struct smtp_client_connection *)_conn;
bool enhanced_codes = ((conn->caps.standard &
- SMTP_CAPABILITY_ENHANCEDSTATUSCODES) != 0);
+ SMTP_CAPABILITY_ENHANCEDSTATUSCODES) != 0);
struct smtp_reply *reply;
const char *error = NULL;
int ret;
if (conn->ssl_iostream != NULL &&
- !ssl_iostream_is_handshaked(conn->ssl_iostream)) {
+ !ssl_iostream_is_handshaked(conn->ssl_iostream)) {
/* finish SSL negotiation by reading from input stream */
- while ((ret=i_stream_read(conn->conn.input)) > 0 || ret == -2) {
+ while ((ret = i_stream_read(conn->conn.input)) > 0 ||
+ ret == -2) {
if (ssl_iostream_is_handshaked(conn->ssl_iostream))
break;
}
i_stream_get_error(conn->conn.input));
e_debug(conn->event, "connect(%s) failed: %s",
_conn->name, error);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED, error);
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ error);
return;
}
for (;;) {
if (conn->cmd_wait_list_head != NULL &&
conn->cmd_wait_list_head->ehlo) {
- if ((ret=smtp_reply_parse_ehlo(conn->reply_parser,
- &reply, &error)) <= 0)
+ if ((ret = smtp_reply_parse_ehlo(conn->reply_parser,
+ &reply, &error)) <= 0)
break;
} else {
- if ((ret=smtp_reply_parse_next(conn->reply_parser,
- enhanced_codes, &reply, &error)) <= 0)
+ if ((ret = smtp_reply_parse_next(conn->reply_parser,
+ enhanced_codes,
+ &reply, &error)) <= 0)
break;
}
if (ret < 0 || (ret == 0 && conn->conn.input->eof)) {
if (conn->conn.input->stream_errno == ENOBUFS) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
"Command reply line too long");
} else if (conn->conn.input->stream_errno != 0) {
e_error(conn->event, "read(%s) failed: %s",
i_stream_get_name(conn->conn.input),
i_stream_get_error(conn->conn.input));
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
"Lost connection to remote server "
"(read failure)");
} else if (!i_stream_have_bytes_left(conn->conn.input)) {
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST,
"Lost connection to remote server "
"(disconnected in input)");
} else {
i_assert(error != NULL);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_BAD_REPLY,
t_strdup_printf("Invalid command reply: %s",
error));
}
if (conn->to_connect != NULL)
timeout_reset(conn->to_connect);
- if ((ret=o_stream_flush(conn->conn.output)) <= 0) {
+ ret = o_stream_flush(conn->conn.output);
+ if (ret <= 0) {
if (ret < 0)
smtp_client_connection_handle_output_error(conn);
return ret;
case CONNECTION_DISCONNECT_CONNECT_TIMEOUT:
e_error(conn->event, "connect(%s) failed: Connection timed out",
_conn->name);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
"Connect timed out");
break;
default:
case CONNECTION_DISCONNECT_CONN_CLOSED:
if (conn->connect_failed)
break;
- error = _conn->input == NULL ? "Connection lost" :
- t_strdup_printf("Connection lost: %s",
- i_stream_get_error(_conn->input));
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST, error);
+ error = (_conn->input == NULL ?
+ "Connection lost" :
+ t_strdup_printf("Connection lost: %s",
+ i_stream_get_error(_conn->input)));
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECTION_LOST, error);
break;
}
}
}
if (conn->set.ssl == NULL) {
- *error_r = "Requested SSL connection, but no SSL settings given";
+ *error_r =
+ "Requested SSL connection, but no SSL settings given";
return -1;
}
- if (ssl_iostream_client_context_cache_get(conn->set.ssl,
- &conn->ssl_ctx, &error) < 0) {
- *error_r = t_strdup_printf("Couldn't initialize SSL context: %s",
- error);
+ if (ssl_iostream_client_context_cache_get(conn->set.ssl, &conn->ssl_ctx,
+ &error) < 0) {
+ *error_r = t_strdup_printf(
+ "Couldn't initialize SSL context: %s", error);
return -1;
}
return 0;
}
connection_input_halt(&conn->conn);
- if (io_stream_create_ssl_client(conn->ssl_ctx,
- conn->host, conn->set.ssl,
+ if (io_stream_create_ssl_client(
+ conn->ssl_ctx, conn->host, conn->set.ssl,
&conn->conn.input, &conn->conn.output,
&conn->ssl_iostream, &error) < 0) {
*error_r = t_strdup_printf(
connection_input_resume(&conn->conn);
smtp_client_connection_streams_changed(conn);
- ssl_iostream_set_handshake_callback(conn->ssl_iostream,
- smtp_client_connection_ssl_handshaked, conn);
+ ssl_iostream_set_handshake_callback(
+ conn->ssl_iostream, smtp_client_connection_ssl_handshaked,
+ conn);
if (ssl_iostream_handshake(conn->ssl_iostream) < 0) {
- *error_r = t_strdup_printf("SSL handshake to %s failed: %s",
- conn->conn.name,
+ *error_r = t_strdup_printf(
+ "SSL handshake to %s failed: %s", conn->conn.name,
ssl_iostream_get_last_error(conn->ssl_iostream));
return -1;
}
} else {
/* wait for handshake to complete; connection input handler
does the rest by reading from the input stream */
- o_stream_set_flush_callback(conn->conn.output,
- smtp_client_connection_output, conn);
+ o_stream_set_flush_callback(
+ conn->conn.output, smtp_client_connection_output, conn);
}
return 0;
}
i_assert(conn->to_connect != NULL);
timeout_remove(&conn->to_connect);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
"Failed to connect to remote server");
}
e_error(conn->event, "connect(%s) failed: %m", _conn->name);
conn->connect_failed = TRUE;
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add_short(0,
- smtp_client_connection_delayed_connect_failure, conn);
+ conn->to_connect = timeout_add_short(
+ 0, smtp_client_connection_delayed_connect_failure,
+ conn);
return;
}
e_error(conn->event, "connect(%s) failed: %s",
_conn->name, error);
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add_short(0,
+ conn->to_connect = timeout_add_short(
+ 0,
smtp_client_connection_delayed_connect_failure,
conn);
}
"Connection timed out after %u seconds",
conn->conn.name,
conn->set.connect_timeout_msecs/1000);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
"Connect timed out");
break;
case SMTP_CLIENT_CONNECTION_STATE_HANDSHAKING:
e_error(conn->event,
"SMTP handshake timed out after %u seconds",
conn->set.connect_timeout_msecs/1000);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_CONNECT_FAILED,
"Handshake timed out");
break;
case SMTP_CLIENT_CONNECTION_STATE_AUTHENTICATING:
e_error(conn->event,
"Authentication timed out after %u seconds",
conn->set.connect_timeout_msecs/1000);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_AUTH_FAILED,
"Authentication timed out");
break;
default:
msecs = conn->set.command_timeout_msecs;
i_assert(conn->to_connect == NULL);
if (msecs > 0) {
- conn->to_connect = timeout_add(msecs,
- smtp_client_connection_connect_timeout, conn);
+ conn->to_connect = timeout_add(
+ msecs, smtp_client_connection_connect_timeout, conn);
}
}
i_assert(conn->to_connect != NULL);
timeout_remove(&conn->to_connect);
- smtp_client_connection_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_HOST_LOOKUP_FAILED,
+ smtp_client_connection_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_HOST_LOOKUP_FAILED,
"Failed to lookup remote server");
}
static void
smtp_client_connection_dns_callback(const struct dns_lookup_result *result,
- struct smtp_client_connection *conn)
+ struct smtp_client_connection *conn)
{
conn->dns_lookup = NULL;
e_error(conn->event, "dns_lookup(%s) failed: %s",
conn->host, result->error);
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add_short(0,
- smtp_client_connection_delayed_host_lookup_failure, conn);
+ conn->to_connect = timeout_add_short(
+ 0, smtp_client_connection_delayed_host_lookup_failure,
+ conn);
return;
}
conn->host_is_ip = TRUE;
} else if (conn->set.dns_client != NULL) {
e_debug(conn->event, "Performing asynchronous DNS lookup");
- (void)dns_client_lookup(conn->set.dns_client, conn->host,
+ (void)dns_client_lookup(
+ conn->set.dns_client, conn->host,
smtp_client_connection_dns_callback, conn,
&conn->dns_lookup);
} else if (conn->set.dns_client_socket_path != NULL) {
dns_set.timeout_msecs = conn->set.connect_timeout_msecs;
e_debug(conn->event, "Performing asynchronous DNS lookup");
(void)dns_lookup(conn->host, &dns_set,
- smtp_client_connection_dns_callback, conn,
- &conn->dns_lookup);
+ smtp_client_connection_dns_callback, conn,
+ &conn->dns_lookup);
} else {
/* no dns-conn, use blocking lookup */
ret = net_gethostbyname(conn->host, &ips, &ips_count);
e_error(conn->event, "net_gethostbyname(%s) failed: %s",
conn->host, net_gethosterror(ret));
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add_short(0,
- smtp_client_connection_delayed_host_lookup_failure, conn);
+ conn->to_connect = timeout_add_short(
+ 0,
+ smtp_client_connection_delayed_host_lookup_failure,
+ conn);
return;
}
}
}
-void smtp_client_connection_connect(struct smtp_client_connection *conn,
+void smtp_client_connection_connect(
+ struct smtp_client_connection *conn,
smtp_client_command_callback_t login_callback, void *login_context)
{
if (conn->state != SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED) {
conn->login_callback = login_callback;
conn->login_context = login_context;
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_CONNECTING);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_CONNECTING);
if (conn->path == NULL) {
smtp_client_connection_lookup_ip(conn);
/* always work asynchronously */
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add(0,
- smtp_client_connection_connect_next_ip, conn);
+ conn->to_connect = timeout_add(
+ 0, smtp_client_connection_connect_next_ip, conn);
} else {
/* always work asynchronously */
timeout_remove(&conn->to_connect);
- conn->to_connect = timeout_add(0,
- smtp_client_connection_connect_unix, conn);
+ conn->to_connect = timeout_add(
+ 0, smtp_client_connection_connect_unix, conn);
}
}
.client_connected = smtp_client_connection_connected
};
-struct connection_list *
-smtp_client_connection_list_init(void)
+struct connection_list *smtp_client_connection_list_init(void)
{
- return connection_list_init
- (&smtp_client_connection_set, &smtp_client_connection_vfuncs);
+ return connection_list_init(&smtp_client_connection_set,
+ &smtp_client_connection_vfuncs);
}
void smtp_client_connection_disconnect(struct smtp_client_connection *conn)
smtp_client_connection_clear_password(conn);
if (conn->conn.output != NULL && !conn->sent_quit &&
- !conn->sending_command) {
+ !conn->sending_command) {
/* Close the connection gracefully if possible */
o_stream_nsend_str(conn->conn.output, "QUIT\r\n");
o_stream_uncork(conn->conn.output);
connection_disconnect(&conn->conn);
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED);
if (!conn->failing) {
- smtp_client_connection_login_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_ABORTED,
+ smtp_client_connection_login_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_ABORTED,
"Disconnected from server");
- smtp_client_connection_commands_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_ABORTED,
+ smtp_client_connection_commands_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_ABORTED,
"Disconnected from server");
}
conn->cmd_streaming = NULL;
*conn->set.my_hostname != '\0');
conn->caps.standard = conn->set.forced_capabilities;
- conn->cap_pool = pool_alloconly_create
- ("smtp client connection capabilities", 128);
+ conn->cap_pool = pool_alloconly_create(
+ "smtp client connection capabilities", 128);
if (set != NULL && set->event_parent != NULL)
conn_event = event_create(set->event_parent);
struct smtp_client_connection *
smtp_client_connection_create(struct smtp_client *client,
- enum smtp_protocol protocol, const char *host, in_port_t port,
- enum smtp_client_connection_ssl_mode ssl_mode,
- const struct smtp_client_settings *set)
+ enum smtp_protocol protocol,
+ const char *host, in_port_t port,
+ enum smtp_client_connection_ssl_mode ssl_mode,
+ const struct smtp_client_settings *set)
{
struct smtp_client_connection *conn;
const char *name = t_strdup_printf("%s:%u", host, port);
struct smtp_client_connection *
smtp_client_connection_create_ip(struct smtp_client *client,
- enum smtp_protocol protocol, const struct ip_addr *ip, in_port_t port,
- const char *hostname, enum smtp_client_connection_ssl_mode ssl_mode,
- const struct smtp_client_settings *set)
+ enum smtp_protocol protocol,
+ const struct ip_addr *ip, in_port_t port,
+ const char *hostname,
+ enum smtp_client_connection_ssl_mode ssl_mode,
+ const struct smtp_client_settings *set)
{
struct smtp_client_connection *conn;
bool host_is_ip = FALSE;
if (conn->reply_parser != NULL)
smtp_reply_parser_deinit(&conn->reply_parser);
- smtp_client_connection_login_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_ABORTED,
+ smtp_client_connection_login_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_ABORTED,
"Connection destroy");
- smtp_client_connection_commands_fail(conn,
- SMTP_CLIENT_COMMAND_ERROR_ABORTED,
+ smtp_client_connection_commands_fail(
+ conn, SMTP_CLIENT_COMMAND_ERROR_ABORTED,
"Connection destroy");
connection_deinit(&conn->conn);
conn->reset_needed = FALSE;
- (void)smtp_client_command_rset_submit(conn,
- SMTP_CLIENT_COMMAND_FLAG_PRIORITY,
+ (void)smtp_client_command_rset_submit(
+ conn, SMTP_CLIENT_COMMAND_FLAG_PRIORITY,
smtp_client_connection_rset_dummy_cb, conn);
}
if (conn->state != SMTP_CLIENT_CONNECTION_STATE_TRANSACTION)
return;
if (conn->transactions_head == NULL) {
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_READY);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_READY);
return;
}
if (conn->to_trans != NULL)
return;
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_TRANSACTION);
- conn->to_trans = timeout_add_short(0,
- smtp_client_connection_do_start_transaction, conn);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_TRANSACTION);
+ conn->to_trans = timeout_add_short(
+ 0, smtp_client_connection_do_start_transaction, conn);
}
void smtp_client_connection_add_transaction(
{
e_debug(conn->event, "Add transaction");
- DLLIST2_APPEND(&conn->transactions_head,
- &conn->transactions_tail, trans);
+ DLLIST2_APPEND(&conn->transactions_head, &conn->transactions_tail,
+ trans);
smtp_client_connection_connect(conn, NULL, NULL);
smtp_client_connection_start_transaction(conn);
e_debug(conn->event, "Abort transaction");
- DLLIST2_REMOVE(&conn->transactions_head,
- &conn->transactions_tail, trans);
+ DLLIST2_REMOVE(&conn->transactions_head, &conn->transactions_tail,
+ trans);
if (!was_first)
return;
next transaction */
conn->reset_needed = TRUE;
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_READY);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_READY);
smtp_client_connection_start_transaction(conn);
}
i_assert(trans == conn->transactions_head);
- DLLIST2_REMOVE(&conn->transactions_head,
- &conn->transactions_tail, trans);
+ DLLIST2_REMOVE(&conn->transactions_head, &conn->transactions_tail,
+ trans);
i_assert(conn->state != SMTP_CLIENT_CONNECTION_STATE_READY);
if (conn->state != SMTP_CLIENT_CONNECTION_STATE_TRANSACTION)
return;
- smtp_client_connection_set_state(conn,
- SMTP_CLIENT_CONNECTION_STATE_READY);
+ smtp_client_connection_set_state(
+ conn, SMTP_CLIENT_CONNECTION_STATE_READY);
smtp_client_connection_start_transaction(conn);
}
projects / thirdparty / dovecot / core.git / commitdiff
