Lines Matching refs:conn
34 smtp_client_connection_ssl_init(struct smtp_client_connection *conn,
37 smtp_client_connection_handshake(struct smtp_client_connection *conn);
39 smtp_client_connection_established(struct smtp_client_connection *conn);
41 smtp_client_connection_start_transaction(struct smtp_client_connection *conn);
48 smtp_client_connection_get_capabilities(struct smtp_client_connection *conn)
50 return conn->capabilities;
54 struct smtp_client_connection *conn)
56 return conn->cap_size;
64 smpt_client_connection_label(struct smtp_client_connection *conn)
66 if (conn->label == NULL) {
67 conn->label = i_strdup_printf("%s:%u [%u]",
68 conn->host, conn->port, conn->id);
70 return conn->label;
74 smtp_client_connection_debug(struct smtp_client_connection *conn,
79 if (conn->set.debug) {
81 i_debug("%s-client: conn %s: %s",
82 smtp_protocol_name(conn->protocol),
83 smpt_client_connection_label(conn),
90 smtp_client_connection_warning(struct smtp_client_connection *conn,
97 i_warning("%s-client: conn %s: %s",
98 smtp_protocol_name(conn->protocol),
99 smpt_client_connection_label(conn),
105 smtp_client_connection_error(struct smtp_client_connection *conn,
111 i_error("%s-client: conn %s: %s",
112 smtp_protocol_name(conn->protocol),
113 smpt_client_connection_label(conn),
123 smtp_client_connection_commands_abort(struct smtp_client_connection *conn)
125 smtp_client_commands_list_abort(conn->cmd_wait_list_head,
126 conn->cmd_wait_list_count);
127 smtp_client_commands_list_abort(conn->cmd_send_queue_head,
128 conn->cmd_send_queue_count);
132 smtp_client_connection_commands_fail_reply(struct smtp_client_connection *conn,
135 smtp_client_commands_list_fail_reply(conn->cmd_wait_list_head,
136 conn->cmd_wait_list_count, reply);
137 smtp_client_commands_list_fail_reply(conn->cmd_send_queue_head,
138 conn->cmd_send_queue_count, reply);
142 smtp_client_connection_commands_fail(struct smtp_client_connection *conn,
150 smtp_client_connection_commands_fail_reply(conn, &reply);
154 smtp_client_connection_login_callback(struct smtp_client_connection *conn,
157 smtp_client_command_callback_t *callback = conn->login_callback;
158 void *context = conn->login_context;
160 conn->login_callback = NULL;
161 conn->login_context = NULL;
163 if (conn->closed)
170 smtp_client_connection_login_fail(struct smtp_client_connection *conn,
178 smtp_client_connection_login_callback(conn, &reply);
182 smtp_client_connection_set_state(struct smtp_client_connection *conn,
185 conn->state = state;
188 void smtp_client_connection_cork(struct smtp_client_connection *conn)
190 conn->corked = TRUE;
191 if (conn->conn.output != NULL)
192 o_stream_cork(conn->conn.output);
195 void smtp_client_connection_uncork(struct smtp_client_connection *conn)
197 conn->corked = FALSE;
198 if (conn->conn.output != NULL) {
199 if (o_stream_uncork_flush(conn->conn.output) < 0) {
200 smtp_client_connection_handle_output_error(conn);
203 smtp_client_connection_trigger_output(conn);
208 smtp_client_connection_get_state(struct smtp_client_connection *conn)
210 return conn->state;
214 smtp_client_command_timeout(struct smtp_client_connection *conn)
216 smtp_client_connection_ref(conn);
218 smtp_client_connection_error(conn,
220 smtp_client_connection_fail(conn,
223 smtp_client_connection_unref(&conn);
227 struct smtp_client_connection *conn)
229 unsigned int msecs = conn->set.command_timeout_msecs;
231 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_READY) {
237 timeout_remove(&conn->to_commands);
240 if (conn->cmd_wait_list_head == NULL &&
241 conn->cmd_send_queue_head == NULL) {
243 timeout_remove(&conn->to_commands);
247 smtp_client_connection_debug(conn, "Start timeout");
248 if (conn->to_commands == NULL) {
249 conn->to_commands = timeout_add
250 (msecs, smtp_client_command_timeout, conn);
255 struct smtp_client_connection *conn)
257 unsigned int msecs = conn->set.command_timeout_msecs;
259 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_READY) {
265 timeout_remove(&conn->to_commands);
269 if (conn->cmd_wait_list_head == NULL &&
270 conn->cmd_send_queue_head == NULL) {
271 if (conn->to_commands != NULL) {
272 smtp_client_connection_debug(conn,
275 timeout_remove(&conn->to_commands);
276 } else if (conn->to_commands != NULL) {
277 smtp_client_connection_debug(conn,
279 timeout_reset(conn->to_commands);
281 smtp_client_connection_start_cmd_timeout(conn);
286 smtp_client_connection_fail_reply(struct smtp_client_connection *conn,
291 smtp_client_connection_debug(conn,
294 smtp_client_connection_ref(conn);
296 smtp_client_connection_login_callback(conn, reply);
297 smtp_client_connection_commands_fail_reply(conn, reply);
298 smtp_client_connection_disconnect(conn);
300 trans = conn->transactions_head;
307 smtp_client_connection_unref(&conn);
310 void smtp_client_connection_fail(struct smtp_client_connection *conn,
321 smtp_client_connection_fail_reply(conn, &reply);
325 struct smtp_client_connection *conn)
327 struct ostream *output = conn->conn.output;
331 smtp_client_connection_error(conn,
333 o_stream_get_name(conn->conn.output),
334 o_stream_get_error(conn->conn.output));
335 smtp_client_connection_fail(conn,
340 smtp_client_connection_error(conn,
342 smtp_client_connection_fail(conn,
349 static void stmp_client_connection_ready(struct smtp_client_connection *conn,
352 timeout_remove(&conn->to_connect);
354 smtp_client_connection_set_state(conn,
356 conn->reset_needed = FALSE;
358 smtp_client_connection_debug(conn, "Connection ready");
360 smtp_client_connection_login_callback(conn, reply);
362 smtp_client_connection_update_cmd_timeout(conn);
364 smtp_client_connection_start_transaction(conn);
368 smtp_client_connection_clear_password(struct smtp_client_connection *conn)
370 if (conn->set.remember_password)
372 if (conn->password == NULL)
374 safe_memset(conn->password, 0, strlen(conn->password));
375 conn->set.password = NULL;
376 conn->password = NULL;
381 struct smtp_client_connection *conn)
390 smtp_client_connection_error(conn,
394 smtp_client_connection_fail(conn,
405 smtp_client_connection_error(conn,
409 } else if (dsasl_client_input(conn->sasl_client,
411 smtp_client_connection_error(conn,
413 } else if (dsasl_client_output(conn->sasl_client,
415 smtp_client_connection_error(conn,
423 o_stream_nsend(conn->conn.output,
428 smtp_client_connection_fail(conn,
435 smtp_client_connection_error(conn,
438 smtp_client_connection_fail_reply(conn, reply);
442 smtp_client_connection_clear_password(conn);
444 if (conn->set.debug) {
445 smtp_client_connection_debug(conn,
448 dsasl_client_free(&conn->sasl_client);
450 if (conn->to_connect != NULL)
451 timeout_reset(conn->to_connect);
452 conn->authenticated = TRUE;
453 smtp_client_connection_handshake(conn);
457 smtp_client_connection_get_sasl_mech(struct smtp_client_connection *conn,
461 const struct smtp_client_settings *set = &conn->set;
467 if (!str_array_icase_find(conn->cap_auth_mechanisms, mech)) {
485 if (str_array_icase_find(conn->cap_auth_mechanisms,
505 smtp_client_connection_authenticate(struct smtp_client_connection *conn)
507 const struct smtp_client_settings *set = &conn->set;
516 if (conn->authenticated)
521 if ((conn->capabilities & SMTP_CAPABILITY_AUTH) == 0) {
522 smtp_client_connection_fail(conn,
528 if (conn->set.debug) {
530 smtp_client_connection_debug(conn,
534 smtp_client_connection_debug(conn,
537 smtp_client_connection_debug(conn,
542 if (smtp_client_connection_get_sasl_mech(conn,
544 smtp_client_connection_error(conn,
546 smtp_client_connection_fail(conn,
561 conn->sasl_client = dsasl_client_new(sasl_mech, &sasl_set);
563 if (dsasl_client_output(conn->sasl_client, &sasl_output,
565 smtp_client_connection_error(conn,
568 smtp_client_connection_fail(conn,
587 cmd = smtp_client_command_new(conn,
589 smtp_client_connection_auth_cb, conn);
594 smtp_client_connection_set_state(conn,
601 struct smtp_client_connection *conn)
603 if (conn->set.debug) {
604 smtp_client_connection_debug(conn,
610 smtp_client_connection_fail_reply(conn, reply);
613 if (conn->state == SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED)
616 if (conn->to_connect != NULL)
617 timeout_reset(conn->to_connect);
618 smtp_client_connection_handshake(conn);
622 smtp_client_connection_send_xclient(struct smtp_client_connection *conn,
625 const char **xclient_args = conn->cap_xclient_args;
629 if (!conn->set.peer_trusted)
631 if ((conn->capabilities & SMTP_CAPABILITY_XCLIENT) == 0 ||
632 conn->cap_xclient_args == NULL)
646 if (conn->protocol != SMTP_PROTOCOL_LMTP &&
692 smtp_client_connection_debug(conn,
698 cmd = smtp_client_command_new(conn, flags,
699 smtp_client_connection_xclient_cb, conn);
706 smtp_client_connection_init_xclient(struct smtp_client_connection *conn)
708 if (!conn->initial_xclient_sent) {
709 conn->initial_xclient_sent = TRUE;
710 smtp_client_connection_send_xclient(conn,
711 &conn->set.proxy_data);
714 return smtp_client_connection_authenticate(conn);
719 struct smtp_client_connection *conn)
723 if (conn->set.debug) {
724 smtp_client_connection_debug(conn,
730 smtp_client_connection_fail_reply(conn, reply);
734 if (smtp_client_connection_ssl_init(conn, &error) < 0) {
735 smtp_client_connection_fail(conn,
738 if (conn->to_connect != NULL)
739 timeout_reset(conn->to_connect);
740 smtp_client_connection_handshake(conn);
745 smtp_client_connection_starttls(struct smtp_client_connection *conn)
749 if (conn->ssl_mode == SMTP_CLIENT_SSL_MODE_STARTTLS &&
750 conn->ssl_iostream == NULL) {
751 if ((conn->capabilities & SMTP_CAPABILITY_STARTTLS) == 0) {
752 smtp_client_connection_error(conn,
755 smtp_client_connection_fail(conn,
761 smtp_client_connection_debug(conn, "Starting TLS");
763 cmd = smtp_client_command_new(conn,
765 smtp_client_connection_starttls_cb, conn);
771 return smtp_client_connection_init_xclient(conn);
776 struct smtp_client_connection *conn)
781 smtp_client_connection_debug(conn, "Received handshake reply");
789 if (conn->protocol == SMTP_PROTOCOL_SMTP && !conn->old_smtp &&
792 conn->old_smtp = TRUE;
793 smtp_client_connection_handshake(conn);
797 smtp_client_connection_fail_reply(conn, reply);
802 p_clear(conn->cap_pool);
803 conn->capabilities = 0;
804 conn->cap_xclient_args = NULL;
805 conn->cap_auth_mechanisms = NULL;
806 conn->cap_size = 0;
810 smtp_client_connection_fail(conn,
827 smtp_client_connection_warning(conn,
845 conn->cap_auth_mechanisms =
846 p_strarray_dup(conn->cap_pool, params);
851 if (str_to_uoff(*params, &conn->cap_size) < 0) {
852 smtp_client_connection_warning(conn,
859 conn->cap_xclient_args =
860 p_strarray_dup(conn->cap_pool, params);
868 conn->capabilities |= cap->capability;
873 smtp_client_connection_debug(conn, "Received server capabilities");
875 if (conn->to_connect != NULL)
876 timeout_reset(conn->to_connect);
877 if (smtp_client_connection_starttls(conn)) {
878 stmp_client_connection_ready(conn, reply);
883 smtp_client_connection_handshake(struct smtp_client_connection *conn)
892 switch (conn->protocol) {
894 command = (conn->old_smtp ? "HELO" : "EHLO");
903 smtp_client_connection_debug(conn,
906 cmd = smtp_client_command_new(conn, flags,
907 smtp_client_connection_handshake_cb, conn);
910 smtp_client_command_write(cmd, conn->set.my_hostname);
912 smtp_client_connection_set_state(conn,
917 smtp_client_connection_input_reply(struct smtp_client_connection *conn,
923 if (conn->state == SMTP_CLIENT_CONNECTION_STATE_CONNECTING) {
924 if (conn->set.debug) {
925 smtp_client_connection_debug(conn,
931 smtp_client_connection_fail(conn,
935 smtp_client_connection_fail_reply(conn, reply);
939 smtp_client_connection_handshake(conn);
944 if (conn->cmd_wait_list_head == NULL) {
945 smtp_client_connection_debug(conn,
950 smtp_client_connection_fail_reply(conn, reply);
952 smtp_client_connection_fail(conn,
960 ret = smtp_client_command_input_reply(conn->cmd_wait_list_head, reply);
962 if (conn->state == SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED ||
963 conn->conn.output == NULL)
971 struct smtp_client_connection *conn =
973 bool enhanced_codes = ((conn->capabilities &
979 if (conn->ssl_iostream != NULL &&
980 !ssl_iostream_is_handshaked(conn->ssl_iostream)) {
982 while ((ret=i_stream_read(conn->conn.input)) > 0 || ret == -2) {
983 if (ssl_iostream_is_handshaked(conn->ssl_iostream))
992 i_stream_get_name(conn->conn.input),
993 i_stream_get_error(conn->conn.input));
994 smtp_client_connection_debug(conn,
996 smtp_client_connection_fail(conn,
1001 if (!ssl_iostream_is_handshaked(conn->ssl_iostream)) {
1008 smtp_client_connection_established(conn);
1011 smtp_client_connection_ref(conn);
1012 o_stream_cork(conn->conn.output);
1014 if (conn->cmd_wait_list_head != NULL &&
1015 conn->cmd_wait_list_head->ehlo) {
1016 if ((ret=smtp_reply_parse_ehlo(conn->reply_parser,
1020 if ((ret=smtp_reply_parse_next(conn->reply_parser,
1026 ret = smtp_client_connection_input_reply(conn, reply);
1029 if (conn->conn.output != NULL && !conn->corked)
1030 o_stream_uncork(conn->conn.output);
1031 smtp_client_connection_unref(&conn);
1036 if (ret < 0 || (ret == 0 && conn->conn.input->eof)) {
1037 if (conn->conn.input->stream_errno == ENOBUFS) {
1038 smtp_client_connection_fail(conn,
1041 } else if (conn->conn.input->stream_errno != 0) {
1042 smtp_client_connection_error(conn,
1044 i_stream_get_name(conn->conn.input),
1045 i_stream_get_error(conn->conn.input));
1046 smtp_client_connection_fail(conn,
1050 } else if (!i_stream_have_bytes_left(conn->conn.input)) {
1051 smtp_client_connection_fail(conn,
1057 smtp_client_connection_fail(conn,
1063 if (ret >= 0 && conn->conn.output != NULL && !conn->corked) {
1064 if (o_stream_uncork_flush(conn->conn.output) < 0)
1065 smtp_client_connection_handle_output_error(conn);
1067 smtp_client_connection_unref(&conn);
1070 static int smtp_client_connection_output(struct smtp_client_connection *conn)
1074 if (conn->to_connect != NULL)
1075 timeout_reset(conn->to_connect);
1077 if ((ret=o_stream_flush(conn->conn.output)) <= 0) {
1079 smtp_client_connection_handle_output_error(conn);
1083 smtp_client_connection_ref(conn);
1084 o_stream_cork(conn->conn.output);
1085 if (smtp_client_command_send_more(conn) < 0)
1087 if (ret >= 0 && conn->conn.output != NULL && !conn->corked) {
1088 if (o_stream_uncork_flush(conn->conn.output) < 0)
1089 smtp_client_connection_handle_output_error(conn);
1091 smtp_client_connection_unref(&conn);
1095 void smtp_client_connection_trigger_output(struct smtp_client_connection *conn)
1097 if (conn->conn.output != NULL)
1098 o_stream_set_flush_pending(conn->conn.output, TRUE);
1103 struct smtp_client_connection *conn =
1111 smtp_client_connection_debug(conn,
1113 smtp_client_connection_commands_abort(conn);
1114 smtp_client_connection_close(&conn);
1117 smtp_client_connection_error(conn,
1120 smtp_client_connection_fail(conn,
1126 if (conn->connect_failed)
1131 smtp_client_connection_fail(conn,
1138 smtp_client_connection_established(struct smtp_client_connection *conn)
1140 if (conn->to_connect != NULL)
1141 timeout_reset(conn->to_connect);
1144 o_stream_set_flush_callback(conn->conn.output,
1145 smtp_client_connection_output, conn);
1151 struct smtp_client_connection *conn = context;
1152 const char *error, *host = conn->host;
1154 if (ssl_iostream_check_cert_validity(conn->ssl_iostream,
1156 smtp_client_connection_debug(conn,
1158 } else if (conn->set.ssl->allow_invalid_cert) {
1159 smtp_client_connection_debug(conn,
1170 smtp_client_connection_streams_changed(struct smtp_client_connection *conn)
1174 if (conn->set.rawlog_dir != NULL &&
1175 stat(conn->set.rawlog_dir, &st) == 0) {
1176 iostream_rawlog_create(conn->set.rawlog_dir,
1177 &conn->conn.input, &conn->conn.output);
1180 if (conn->reply_parser == NULL) {
1181 conn->reply_parser = smtp_reply_parser_init(
1182 conn->conn.input, conn->set.max_reply_size);
1184 smtp_reply_parser_set_stream(conn->reply_parser,
1185 conn->conn.input);
1188 connection_streams_changed(&conn->conn);
1192 smtp_client_connection_init_ssl_ctx(struct smtp_client_connection *conn,
1195 struct smtp_client *client = conn->client;
1198 if (conn->ssl_ctx != NULL)
1201 if (conn->set.ssl == client->set.ssl) {
1204 conn->ssl_ctx = client->ssl_ctx;
1205 ssl_iostream_context_ref(conn->ssl_ctx);
1209 if (conn->set.ssl == NULL) {
1213 if (ssl_iostream_client_context_cache_get(conn->set.ssl,
1214 &conn->ssl_ctx, &error) < 0) {
1223 smtp_client_connection_ssl_init(struct smtp_client_connection *conn,
1228 if (smtp_client_connection_init_ssl_ctx(conn, &error) < 0) {
1234 if (conn->set.debug)
1235 smtp_client_connection_debug(conn, "Starting SSL handshake");
1237 if (conn->raw_input != conn->conn.input) {
1239 i_stream_ref(conn->raw_input);
1240 o_stream_ref(conn->raw_output);
1241 i_stream_destroy(&conn->conn.input);
1242 o_stream_destroy(&conn->conn.output);
1243 conn->conn.input = conn->raw_input;
1244 conn->conn.output = conn->raw_output;
1247 connection_input_halt(&conn->conn);
1248 if (io_stream_create_ssl_client(conn->ssl_ctx,
1249 conn->host, conn->set.ssl,
1250 &conn->conn.input, &conn->conn.output,
1251 &conn->ssl_iostream, &error) < 0) {
1254 conn->conn.name, error);
1257 connection_input_resume(&conn->conn);
1258 smtp_client_connection_streams_changed(conn);
1260 ssl_iostream_set_handshake_callback(conn->ssl_iostream,
1261 smtp_client_connection_ssl_handshaked, conn);
1262 if (ssl_iostream_handshake(conn->ssl_iostream) < 0) {
1264 conn->conn.name,
1265 ssl_iostream_get_last_error(conn->ssl_iostream));
1269 if (ssl_iostream_is_handshaked(conn->ssl_iostream)) {
1270 smtp_client_connection_established(conn);
1274 o_stream_set_flush_callback(conn->conn.output,
1275 smtp_client_connection_output, conn);
1282 struct smtp_client_connection *conn)
1284 smtp_client_connection_debug(conn, "Delayed connect failure");
1286 i_assert(conn->to_connect != NULL);
1287 timeout_remove(&conn->to_connect);
1288 smtp_client_connection_fail(conn,
1296 struct smtp_client_connection *conn =
1298 const struct smtp_client_settings *set = &conn->set;
1302 smtp_client_connection_error(conn,
1304 conn->connect_failed = TRUE;
1305 timeout_remove(&conn->to_connect);
1306 conn->to_connect = timeout_add_short(0,
1307 smtp_client_connection_delayed_connect_failure, conn);
1311 smtp_client_connection_debug(conn, "Connected");
1327 conn->raw_input = conn->conn.input;
1328 conn->raw_output = conn->conn.output;
1329 smtp_client_connection_streams_changed(conn);
1331 if (conn->ssl_mode == SMTP_CLIENT_SSL_MODE_IMMEDIATE) {
1332 if (smtp_client_connection_ssl_init(conn, &error) < 0) {
1333 smtp_client_connection_error(conn,
1335 timeout_remove(&conn->to_connect);
1336 conn->to_connect = timeout_add_short(0,
1338 conn);
1341 smtp_client_connection_established(conn);
1347 smtp_client_connection_connect_timeout(struct smtp_client_connection *conn)
1349 switch (conn->state) {
1351 smtp_client_connection_error(conn,
1354 conn->conn.name,
1355 conn->set.connect_timeout_msecs/1000);
1356 smtp_client_connection_fail(conn,
1361 smtp_client_connection_error(conn,
1363 conn->set.connect_timeout_msecs/1000);
1364 smtp_client_connection_fail(conn,
1369 smtp_client_connection_error(conn,
1371 conn->set.connect_timeout_msecs/1000);
1372 smtp_client_connection_fail(conn,
1382 smtp_client_connection_do_connect(struct smtp_client_connection *conn)
1386 conn->connect_failed = FALSE;
1387 conn->handshake_failed = FALSE;
1388 if (connection_client_connect(&conn->conn) < 0) {
1389 smtp_client_connection_connected(&conn->conn, FALSE);
1395 msecs = conn->set.connect_timeout_msecs;
1397 msecs = conn->set.command_timeout_msecs;
1398 i_assert(conn->to_connect == NULL);
1400 conn->to_connect = timeout_add(msecs,
1401 smtp_client_connection_connect_timeout, conn);
1406 smtp_client_connection_connect_next_ip(struct smtp_client_connection *conn)
1408 const struct ip_addr *ip, *my_ip = &conn->set.my_ip;
1410 timeout_remove(&conn->to_connect);
1412 conn->prev_connect_idx = (conn->prev_connect_idx+1) % conn->ips_count;
1413 ip = &conn->ips[conn->prev_connect_idx];
1416 smtp_client_connection_debug(conn,
1418 net_ip2addr(ip), conn->port, net_ip2addr(my_ip));
1420 smtp_client_connection_debug(conn,
1422 net_ip2addr(ip), conn->port);
1425 connection_init_client_ip_from(conn->client->conn_list,
1426 &conn->conn, ip, conn->port, my_ip);
1428 smtp_client_connection_do_connect(conn);
1433 struct smtp_client_connection *conn)
1435 smtp_client_connection_debug(conn,
1438 i_assert(conn->to_connect != NULL);
1439 timeout_remove(&conn->to_connect);
1440 smtp_client_connection_fail(conn,
1447 struct smtp_client_connection *conn)
1449 conn->dns_lookup = NULL;
1452 smtp_client_connection_error(conn,
1454 conn->host, result->error);
1455 timeout_remove(&conn->to_connect);
1456 conn->to_connect = timeout_add_short(0,
1457 smtp_client_connection_delayed_host_lookup_failure, conn);
1461 smtp_client_connection_debug(conn,
1466 conn->ips_count = result->ips_count;
1467 conn->ips = i_new(struct ip_addr, conn->ips_count);
1468 memcpy(conn->ips, result->ips, sizeof(*conn->ips) * conn->ips_count);
1469 conn->prev_connect_idx = conn->ips_count - 1;
1471 smtp_client_connection_connect_next_ip(conn);
1474 void smtp_client_connection_connect(struct smtp_client_connection *conn,
1482 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED) {
1486 i_assert(conn->login_callback == NULL);
1487 conn->login_callback = login_callback;
1488 conn->login_context = login_context;
1490 smtp_client_connection_debug(conn, "Looking up IP address");
1492 smtp_client_connection_set_state(conn,
1494 if (conn->ips_count == 0 &&
1495 net_addr2ip(conn->host, &ip) == 0) {
1497 conn->ips_count = 1;
1498 conn->ips = i_new(struct ip_addr, conn->ips_count);
1499 conn->ips[0] = ip;
1500 } else if (conn->set.dns_client != NULL) {
1501 smtp_client_connection_debug(conn,
1503 (void)dns_client_lookup(conn->set.dns_client, conn->host,
1504 smtp_client_connection_dns_callback, conn,
1505 &conn->dns_lookup);
1506 } else if (conn->set.dns_client_socket_path != NULL) {
1509 conn->set.dns_client_socket_path;
1510 dns_set.timeout_msecs = conn->set.connect_timeout_msecs;
1511 smtp_client_connection_debug(conn,
1513 (void)dns_lookup(conn->host, &dns_set,
1514 smtp_client_connection_dns_callback, conn,
1515 &conn->dns_lookup);
1517 /* no dns-conn, use blocking lookup */
1518 ret = net_gethostbyname(conn->host, &ips, &ips_count);
1520 smtp_client_connection_error(conn,
1522 conn->host, net_gethosterror(ret));
1523 timeout_remove(&conn->to_connect);
1524 conn->to_connect = timeout_add_short(0,
1525 smtp_client_connection_delayed_host_lookup_failure, conn);
1529 smtp_client_connection_debug(conn,
1532 conn->ips_count = ips_count;
1533 conn->ips = i_new(struct ip_addr, ips_count);
1534 memcpy(conn->ips, ips, ips_count * sizeof(*ips));
1537 if (conn->ips_count == 0)
1541 timeout_remove(&conn->to_connect);
1542 conn->to_connect = timeout_add(0,
1543 smtp_client_connection_connect_next_ip, conn);
1565 void smtp_client_connection_disconnect(struct smtp_client_connection *conn)
1567 if (conn->state == SMTP_CLIENT_CONNECTION_STATE_DISCONNECTED)
1570 smtp_client_connection_debug(conn, "Disconnected");
1572 smtp_client_connection_clear_password(conn);
1574 if (conn->conn.output != NULL && !conn->sent_quit &&
1575 !conn->sending_command) {
1577 o_stream_uncork(conn->conn.output);
1578 o_stream_send_str(conn->conn.output, "QUIT\r\n");
1581 if (conn->dns_lookup != NULL)
1582 dns_lookup_abort(&conn->dns_lookup);
1583 timeout_remove(&conn->to_connect);
1584 timeout_remove(&conn->to_trans);
1585 timeout_remove(&conn->to_commands);
1587 if (conn->ssl_iostream != NULL)
1588 ssl_iostream_unref(&conn->ssl_iostream);
1589 if (conn->ssl_ctx != NULL)
1590 ssl_iostream_context_unref(&conn->ssl_ctx);
1591 if (conn->sasl_client != NULL)
1592 dsasl_client_free(&conn->sasl_client);
1594 o_stream_destroy(&conn->dot_output);
1596 connection_disconnect(&conn->conn);
1598 smtp_client_connection_set_state(conn,
1600 smtp_client_connection_login_fail(conn,
1603 smtp_client_connection_commands_fail(conn,
1615 struct smtp_client_connection *conn;
1619 conn = p_new(pool, struct smtp_client_connection, 1);
1620 conn->refcount = 1;
1621 conn->pool = pool;
1623 conn->client = client;
1624 conn->id = id++;
1625 conn->protocol = protocol;
1626 conn->host = p_strdup(conn->pool, host);
1627 conn->port = port;
1628 conn->ssl_mode = ssl_mode;
1629 conn->conn.name = p_strdup_printf(conn->pool, "%s:%u", host, port);
1631 conn->set = client->set;
1634 conn->set.my_ip = set->my_ip;
1636 conn->set.my_hostname = p_strdup(pool, set->my_hostname);
1639 conn->set.rawlog_dir = p_strdup_empty(pool, set->rawlog_dir);
1642 conn->set.ssl = ssl_iostream_settings_dup(pool, set->ssl);
1645 conn->set.master_user = p_strdup_empty(pool, set->master_user);
1647 conn->set.username = p_strdup_empty(pool, set->username);
1649 conn->password = p_strdup(pool, set->password);
1650 conn->set.password = conn->password;
1653 conn->set.sasl_mech = set->sasl_mech;
1656 conn->set.sasl_mechanisms =
1659 conn->set.remember_password = set->remember_password;
1662 conn->set.command_timeout_msecs = set->command_timeout_msecs;
1664 conn->set.connect_timeout_msecs = set->connect_timeout_msecs;
1666 conn->set.max_reply_size = set->max_reply_size;
1668 conn->set.max_data_chunk_size = set->max_data_chunk_size;
1670 conn->set.max_data_chunk_pipeline = set->max_data_chunk_pipeline;
1673 conn->set.socket_send_buffer_size = set->socket_send_buffer_size;
1675 conn->set.socket_recv_buffer_size = set->socket_recv_buffer_size;
1676 conn->set.debug = conn->set.debug || set->debug;
1679 conn->set.proxy_data.source_ip = set->proxy_data.source_ip;
1680 conn->set.proxy_data.source_port = set->proxy_data.source_port;
1681 conn->set.proxy_data.ttl_plus_1 = set->proxy_data.ttl_plus_1;
1682 conn->set.proxy_data.timeout_secs = set->proxy_data.timeout_secs;
1683 conn->set.proxy_data.helo =
1685 conn->set.proxy_data.login =
1688 conn->set.peer_trusted = set->peer_trusted;
1691 i_assert(conn->set.my_hostname != NULL &&
1692 *conn->set.my_hostname != '\0');
1694 conn->cap_pool = pool_alloconly_create
1697 connection_init(conn->client->conn_list, &conn->conn);
1699 smtp_client_connection_debug(conn, "Connection created");
1701 return conn;
1704 void smtp_client_connection_ref(struct smtp_client_connection *conn)
1706 i_assert(conn->refcount >= 0);
1707 conn->refcount++;
1712 struct smtp_client_connection *conn = *_conn;
1716 i_assert(conn->refcount > 0);
1717 if (--conn->refcount > 0)
1719 if (conn->destroying)
1722 conn->destroying = TRUE;
1724 smtp_client_connection_clear_password(conn);
1725 smtp_client_connection_disconnect(conn);
1728 timeout_remove(&conn->to_commands);
1730 smtp_client_connection_debug(conn, "Destroy");
1732 if (conn->reply_parser != NULL)
1733 smtp_reply_parser_deinit(&conn->reply_parser);
1735 connection_deinit(&conn->conn);
1737 i_free(conn->ips);
1738 i_free(conn->label);
1739 pool_unref(&conn->cap_pool);
1740 pool_unref(&conn->pool);
1745 struct smtp_client_connection *conn = *_conn;
1749 if (conn->closed)
1751 conn->closed = TRUE;
1753 smtp_client_connection_disconnect(conn);
1756 timeout_remove(&conn->to_commands);
1758 smtp_client_connection_unref(&conn);
1761 void smtp_client_connection_switch_ioloop(struct smtp_client_connection *conn)
1765 if (conn->to_connect != NULL)
1766 conn->to_connect = io_loop_move_timeout(&conn->to_connect);
1767 if (conn->to_trans != NULL)
1768 conn->to_trans = io_loop_move_timeout(&conn->to_trans);
1769 if (conn->to_commands != NULL)
1770 conn->to_commands = io_loop_move_timeout(&conn->to_commands);
1771 connection_switch_ioloop(&conn->conn);
1773 trans = conn->transactions_head;
1783 struct smtp_client_connection *conn ATTR_UNUSED)
1789 smtp_client_connection_reset(struct smtp_client_connection *conn)
1791 smtp_client_connection_debug(conn,
1794 conn->reset_needed = FALSE;
1796 (void)smtp_client_command_rset_submit(conn,
1798 smtp_client_connection_rset_dummy_cb, conn);
1802 smtp_client_connection_start_transaction(struct smtp_client_connection *conn)
1806 timeout_remove(&conn->to_trans);
1808 if (conn->transactions_head == NULL)
1810 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_READY)
1813 if (conn->reset_needed)
1814 smtp_client_connection_reset(conn);
1816 smtp_client_connection_set_state(conn,
1818 smtp_client_connection_debug(conn, "Start next transaction");
1822 conn->transactions_head, &reply);
1826 struct smtp_client_connection *conn,
1829 DLLIST2_APPEND(&conn->transactions_head,
1830 &conn->transactions_tail, trans);
1832 smtp_client_connection_connect(conn, NULL, NULL);
1834 if (conn->state == SMTP_CLIENT_CONNECTION_STATE_READY) {
1835 conn->to_trans = timeout_add_short(0,
1836 smtp_client_connection_start_transaction, conn);
1841 struct smtp_client_connection *conn,
1844 bool was_first = (trans == conn->transactions_head);
1846 DLLIST2_REMOVE(&conn->transactions_head,
1847 &conn->transactions_tail, trans);
1851 i_assert(conn->state != SMTP_CLIENT_CONNECTION_STATE_READY);
1852 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_TRANSACTION)
1857 conn->reset_needed = TRUE;
1859 smtp_client_connection_set_state(conn,
1861 conn->to_trans = timeout_add_short(0,
1862 smtp_client_connection_start_transaction, conn);
1866 struct smtp_client_connection *conn,
1869 i_assert(trans == conn->transactions_head);
1871 DLLIST2_REMOVE(&conn->transactions_head,
1872 &conn->transactions_tail, trans);
1874 i_assert(conn->state != SMTP_CLIENT_CONNECTION_STATE_READY);
1875 if (conn->state != SMTP_CLIENT_CONNECTION_STATE_TRANSACTION)
1878 smtp_client_connection_set_state(conn,
1880 conn->to_trans = timeout_add_short(0,
1881 smtp_client_connection_start_transaction, conn);