projects / exim.git / blob
? search:


576b7c546c3a3443891f89d2cd480e0d09f7f719
[exim.git] / src / src / transports / smtp.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #include "../exim.h"
9 #include "smtp.h"
10
11
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
16
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
22
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
30 #endif
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
41 # ifdef SUPPORT_DANE
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
44 # endif
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
49 #ifndef DISABLE_DKIM
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
68 #endif
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
93 #ifdef SUPPORT_TLS
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
96 #endif
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
101 #ifdef SUPPORT_TLS
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
106 #endif
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 #ifdef EXPERIMENTAL_PIPE_CONNECT
110 { "hosts_pipe_connect", opt_stringptr,
111 (void *)offsetof(smtp_transport_options_block, hosts_pipe_connect) },
112 #endif
113 { "hosts_randomize", opt_bool,
114 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
115 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
116 { "hosts_request_ocsp", opt_stringptr,
117 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
118 #endif
119 { "hosts_require_auth", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
121 #ifdef SUPPORT_TLS
122 # ifdef SUPPORT_DANE
123 { "hosts_require_dane", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
125 # endif
126 # ifndef DISABLE_OCSP
127 { "hosts_require_ocsp", opt_stringptr,
128 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
129 # endif
130 { "hosts_require_tls", opt_stringptr,
131 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
132 #endif
133 { "hosts_try_auth", opt_stringptr,
134 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
135 { "hosts_try_chunking", opt_stringptr,
136 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
137 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
138 { "hosts_try_dane", opt_stringptr,
139 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
140 #endif
141 { "hosts_try_fastopen", opt_stringptr,
142 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
143 #ifndef DISABLE_PRDR
144 { "hosts_try_prdr", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
146 #endif
147 #ifdef SUPPORT_TLS
148 { "hosts_verify_avoid_tls", opt_stringptr,
149 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
150 #endif
151 { "interface", opt_stringptr,
152 (void *)offsetof(smtp_transport_options_block, interface) },
153 { "keepalive", opt_bool,
154 (void *)offsetof(smtp_transport_options_block, keepalive) },
155 { "lmtp_ignore_quota", opt_bool,
156 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
157 { "max_rcpt", opt_int | opt_public,
158 (void *)offsetof(transport_instance, max_addresses) },
159 { "multi_domain", opt_expand_bool | opt_public,
160 (void *)offsetof(transport_instance, multi_domain) },
161 { "port", opt_stringptr,
162 (void *)offsetof(smtp_transport_options_block, port) },
163 { "protocol", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, protocol) },
165 { "retry_include_ip_address", opt_expand_bool,
166 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
167 { "serialize_hosts", opt_stringptr,
168 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
169 { "size_addition", opt_int,
170 (void *)offsetof(smtp_transport_options_block, size_addition) },
171 #ifdef SUPPORT_SOCKS
172 { "socks_proxy", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
174 #endif
175 #ifdef SUPPORT_TLS
176 { "tls_certificate", opt_stringptr,
177 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
178 { "tls_crl", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_crl) },
180 { "tls_dh_min_bits", opt_int,
181 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
182 { "tls_privatekey", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
184 { "tls_require_ciphers", opt_stringptr,
185 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
186 { "tls_sni", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_sni) },
188 { "tls_tempfail_tryclear", opt_bool,
189 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
190 { "tls_try_verify_hosts", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
192 { "tls_verify_cert_hostnames", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
194 { "tls_verify_certificates", opt_stringptr,
195 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
196 { "tls_verify_hosts", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
198 #endif
199 #ifdef SUPPORT_I18N
200 { "utf8_downconvert", opt_stringptr,
201 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
202 #endif
203 };
204
205 /* Size of the options list. An extern variable has to be used so that its
206 address can appear in the tables drtables.c. */
207
208 int smtp_transport_options_count = nelem(smtp_transport_options);
209
210
211 #ifdef MACRO_PREDEF
212
213 /* Dummy values */
214 smtp_transport_options_block smtp_transport_option_defaults = {0};
215 void smtp_transport_init(transport_instance *tblock) {}
216 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
217 void smtp_transport_closedown(transport_instance *tblock) {}
218
219 #else /*!MACRO_PREDEF*/
220
221
222 /* Default private options block for the smtp transport. */
223
224 smtp_transport_options_block smtp_transport_option_defaults = {
225 .hosts = NULL,
226 .fallback_hosts = NULL,
227 .hostlist = NULL,
228 .fallback_hostlist = NULL,
229 .helo_data = US"$primary_hostname",
230 .interface = NULL,
231 .port = NULL,
232 .protocol = US"smtp",
233 .dscp = NULL,
234 .serialize_hosts = NULL,
235 .hosts_try_auth = NULL,
236 .hosts_require_auth = NULL,
237 .hosts_try_chunking = US"*",
238 #ifdef SUPPORT_DANE
239 .hosts_try_dane = NULL,
240 .hosts_require_dane = NULL,
241 .dane_require_tls_ciphers = NULL,
242 #endif
243 .hosts_try_fastopen = NULL,
244 #ifndef DISABLE_PRDR
245 .hosts_try_prdr = US"*",
246 #endif
247 #ifndef DISABLE_OCSP
248 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
249 .hosts_require_ocsp = NULL,
250 #endif
251 .hosts_require_tls = NULL,
252 .hosts_avoid_tls = NULL,
253 .hosts_verify_avoid_tls = NULL,
254 .hosts_avoid_pipelining = NULL,
255 #ifdef EXPERIMENTAL_PIPE_CONNECT
256 .hosts_pipe_connect = NULL,
257 #endif
258 .hosts_avoid_esmtp = NULL,
259 #ifdef SUPPORT_TLS
260 .hosts_nopass_tls = NULL,
261 .hosts_noproxy_tls = US"*",
262 #endif
263 .command_timeout = 5*60,
264 .connect_timeout = 5*60,
265 .data_timeout = 5*60,
266 .final_timeout = 10*60,
267 .size_addition = 1024,
268 .hosts_max_try = 5,
269 .hosts_max_try_hardlimit = 50,
270 .address_retry_include_sender = TRUE,
271 .allow_localhost = FALSE,
272 .authenticated_sender_force = FALSE,
273 .gethostbyname = FALSE,
274 .dns_qualify_single = TRUE,
275 .dns_search_parents = FALSE,
276 .dnssec = { .request=NULL, .require=NULL },
277 .delay_after_cutoff = TRUE,
278 .hosts_override = FALSE,
279 .hosts_randomize = FALSE,
280 .keepalive = TRUE,
281 .lmtp_ignore_quota = FALSE,
282 .expand_retry_include_ip_address = NULL,
283 .retry_include_ip_address = TRUE,
284 #ifdef SUPPORT_SOCKS
285 .socks_proxy = NULL,
286 #endif
287 #ifdef SUPPORT_TLS
288 .tls_certificate = NULL,
289 .tls_crl = NULL,
290 .tls_privatekey = NULL,
291 .tls_require_ciphers = NULL,
292 .tls_sni = NULL,
293 .tls_verify_certificates = US"system",
294 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
295 .tls_tempfail_tryclear = TRUE,
296 .tls_verify_hosts = NULL,
297 .tls_try_verify_hosts = US"*",
298 .tls_verify_cert_hostnames = US"*",
299 #endif
300 #ifdef SUPPORT_I18N
301 .utf8_downconvert = NULL,
302 #endif
303 #ifndef DISABLE_DKIM
304 .dkim =
305 {.dkim_domain = NULL,
306 .dkim_identity = NULL,
307 .dkim_private_key = NULL,
308 .dkim_selector = NULL,
309 .dkim_canon = NULL,
310 .dkim_sign_headers = NULL,
311 .dkim_strict = NULL,
312 .dkim_hash = US"sha256",
313 .dkim_timestamps = NULL,
314 .dot_stuffed = FALSE,
315 .force_bodyhash = FALSE,
316 # ifdef EXPERIMENTAL_ARC
317 .arc_signspec = NULL,
318 # endif
319 },
320 # ifdef EXPERIMENTAL_ARC
321 .arc_sign = NULL,
322 # endif
323 #endif
324 };
325
326 /* some DSN flags for use later */
327
328 static int rf_list[] = {rf_notify_never, rf_notify_success,
329 rf_notify_failure, rf_notify_delay };
330
331 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
332
333
334
335 /* Local statics */
336
337 static uschar *smtp_command; /* Points to last cmd for error messages */
338 static uschar *mail_command; /* Points to MAIL cmd for error messages */
339 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
340 static BOOL update_waiting; /* TRUE to update the "wait" database */
341
342 /*XXX move to smtp_context */
343 static BOOL pipelining_active; /* current transaction is in pipe mode */
344
345
346 static unsigned ehlo_response(uschar * buf, unsigned checks);
347
348
349 /*************************************************
350 * Setup entry point *
351 *************************************************/
352
353 /* This function is called when the transport is about to be used,
354 but before running it in a sub-process. It is used for two things:
355
356 (1) To set the fallback host list in addresses, when delivering.
357 (2) To pass back the interface, port, protocol, and other options, for use
358 during callout verification.
359
360 Arguments:
361 tblock pointer to the transport instance block
362 addrlist list of addresses about to be transported
363 tf if not NULL, pointer to block in which to return options
364 uid the uid that will be set (not used)
365 gid the gid that will be set (not used)
366 errmsg place for error message (not used)
367
368 Returns: OK always (FAIL, DEFER not used)
369 */
370
371 static int
372 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
373 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
374 {
375 smtp_transport_options_block *ob = SOB tblock->options_block;
376
377 errmsg = errmsg; /* Keep picky compilers happy */
378 uid = uid;
379 gid = gid;
380
381 /* Pass back options if required. This interface is getting very messy. */
382
383 if (tf)
384 {
385 tf->interface = ob->interface;
386 tf->port = ob->port;
387 tf->protocol = ob->protocol;
388 tf->hosts = ob->hosts;
389 tf->hosts_override = ob->hosts_override;
390 tf->hosts_randomize = ob->hosts_randomize;
391 tf->gethostbyname = ob->gethostbyname;
392 tf->qualify_single = ob->dns_qualify_single;
393 tf->search_parents = ob->dns_search_parents;
394 tf->helo_data = ob->helo_data;
395 }
396
397 /* Set the fallback host list for all the addresses that don't have fallback
398 host lists, provided that the local host wasn't present in the original host
399 list. */
400
401 if (!testflag(addrlist, af_local_host_removed))
402 for (; addrlist; addrlist = addrlist->next)
403 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
404
405 return OK;
406 }
407
408
409
410 /*************************************************
411 * Initialization entry point *
412 *************************************************/
413
414 /* Called for each instance, after its options have been read, to
415 enable consistency checks to be done, or anything else that needs
416 to be set up.
417
418 Argument: pointer to the transport instance block
419 Returns: nothing
420 */
421
422 void
423 smtp_transport_init(transport_instance *tblock)
424 {
425 smtp_transport_options_block *ob = SOB tblock->options_block;
426
427 /* Retry_use_local_part defaults FALSE if unset */
428
429 if (tblock->retry_use_local_part == TRUE_UNSET)
430 tblock->retry_use_local_part = FALSE;
431
432 /* Set the default port according to the protocol */
433
434 if (!ob->port)
435 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
436 ? US"lmtp"
437 : strcmpic(ob->protocol, US"smtps") == 0
438 ? US"smtps" : US"smtp";
439
440 /* Set up the setup entry point, to be called before subprocesses for this
441 transport. */
442
443 tblock->setup = smtp_transport_setup;
444
445 /* Complain if any of the timeouts are zero. */
446
447 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
448 ob->final_timeout <= 0)
449 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
450 "command, data, or final timeout value is zero for %s transport",
451 tblock->name);
452
453 /* If hosts_override is set and there are local hosts, set the global
454 flag that stops verify from showing router hosts. */
455
456 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
457
458 /* If there are any fallback hosts listed, build a chain of host items
459 for them, but do not do any lookups at this time. */
460
461 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
462 }
463
464
465
466
467
468 /*************************************************
469 * Set delivery info into all active addresses *
470 *************************************************/
471
472 /* Only addresses whose status is >= PENDING are relevant. A lesser
473 status means that an address is not currently being processed.
474
475 Arguments:
476 addrlist points to a chain of addresses
477 errno_value to put in each address's errno field
478 msg to put in each address's message field
479 rc to put in each address's transport_return field
480 pass_message if TRUE, set the "pass message" flag in the address
481 host if set, mark addrs as having used this host
482 smtp_greeting from peer
483 helo_response from peer
484
485 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
486 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
487 this particular type of timeout.
488
489 Returns: nothing
490 */
491
492 static void
493 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
494 BOOL pass_message, host_item * host
495 #ifdef EXPERIMENTAL_DSN_INFO
496 , const uschar * smtp_greeting, const uschar * helo_response
497 #endif
498 )
499 {
500 address_item *addr;
501 int orvalue = 0;
502 if (errno_value == ERRNO_CONNECTTIMEOUT)
503 {
504 errno_value = ETIMEDOUT;
505 orvalue = RTEF_CTOUT;
506 }
507 for (addr = addrlist; addr; addr = addr->next)
508 if (addr->transport_return >= PENDING)
509 {
510 addr->basic_errno = errno_value;
511 addr->more_errno |= orvalue;
512 if (msg)
513 {
514 addr->message = msg;
515 if (pass_message) setflag(addr, af_pass_message);
516 }
517 addr->transport_return = rc;
518 if (host)
519 {
520 addr->host_used = host;
521 #ifdef EXPERIMENTAL_DSN_INFO
522 if (smtp_greeting)
523 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
524 addr->smtp_greeting = smtp_greeting;
525
526 if (helo_response)
527 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
528 addr->helo_response = helo_response;
529 #endif
530 }
531 }
532 }
533
534 static void
535 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
536 BOOL pass_message)
537 {
538 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
539 #ifdef EXPERIMENTAL_DSN_INFO
540 , NULL, NULL
541 #endif
542 );
543 }
544
545
546 /*************************************************
547 * Check an SMTP response *
548 *************************************************/
549
550 /* This function is given an errno code and the SMTP response buffer
551 to analyse, together with the host identification for generating messages. It
552 sets an appropriate message and puts the first digit of the response code into
553 the yield variable. If no response was actually read, a suitable digit is
554 chosen.
555
556 Arguments:
557 host the current host, to get its name for messages
558 errno_value pointer to the errno value
559 more_errno from the top address for use with ERRNO_FILTER_FAIL
560 buffer the SMTP response buffer
561 yield where to put a one-digit SMTP response code
562 message where to put an error message
563 pass_message set TRUE if message is an SMTP response
564
565 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
566 */
567
568 static BOOL
569 check_response(host_item *host, int *errno_value, int more_errno,
570 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
571 {
572 uschar * pl = pipelining_active ? US"pipelined " : US"";
573 const uschar * s;
574
575 *yield = '4'; /* Default setting is to give a temporary error */
576
577 switch(*errno_value)
578 {
579 case ETIMEDOUT: /* Handle response timeout */
580 *message = US string_sprintf("SMTP timeout after %s%s",
581 pl, smtp_command);
582 if (transport_count > 0)
583 *message = US string_sprintf("%s (%d bytes written)", *message,
584 transport_count);
585 return FALSE;
586
587 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
588 s = string_printing(buffer);
589 while (isspace(*s)) s++;
590 *message = *s == 0
591 ? string_sprintf("Malformed SMTP reply (an empty line) "
592 "in response to %s%s", pl, smtp_command)
593 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
594 pl, smtp_command, s);
595 return FALSE;
596
597 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
598 can't send QUIT as we mustn't end the DATA. */
599 *message = string_sprintf("transport filter process failed (%d)%s",
600 more_errno,
601 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
602 return FALSE;
603
604 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
605 can't send QUIT as we mustn't end the DATA. */
606 *message =
607 string_sprintf("failed to expand headers_add or headers_remove: %s",
608 expand_string_message);
609 return FALSE;
610
611 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
612 *message = string_sprintf("failed to write a data block");
613 return FALSE;
614
615 #ifdef SUPPORT_I18N
616 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
617 *message = US"utf8 support required but not offered for forwarding";
618 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
619 return TRUE;
620 #endif
621 }
622
623 /* Handle error responses from the remote mailer. */
624
625 if (buffer[0] != 0)
626 {
627 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
628 "%s", pl, smtp_command, s = string_printing(buffer));
629 *pass_message = TRUE;
630 *yield = buffer[0];
631 return TRUE;
632 }
633
634 /* No data was read. If there is no errno, this must be the EOF (i.e.
635 connection closed) case, which causes deferral. An explicit connection reset
636 error has the same effect. Otherwise, put the host's identity in the message,
637 leaving the errno value to be interpreted as well. In all cases, we have to
638 assume the connection is now dead. */
639
640 if (*errno_value == 0 || *errno_value == ECONNRESET)
641 {
642 *errno_value = ERRNO_SMTPCLOSED;
643 *message = US string_sprintf("Remote host closed connection "
644 "in response to %s%s", pl, smtp_command);
645 }
646 else
647 *message = US string_sprintf("%s [%s]", host->name, host->address);
648
649 return FALSE;
650 }
651
652
653
654 /*************************************************
655 * Write error message to logs *
656 *************************************************/
657
658 /* This writes to the main log and to the message log.
659
660 Arguments:
661 host the current host
662 detail the current message (addr_item->message)
663 basic_errno the errno (addr_item->basic_errno)
664
665 Returns: nothing
666 */
667
668 static void
669 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
670 {
671 uschar *message = LOGGING(outgoing_port)
672 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
673 host->port == PORT_NONE ? 25 : host->port)
674 : string_sprintf("H=%s [%s]", host->name, host->address);
675
676 if (suffix)
677 {
678 message = string_sprintf("%s: %s", message, suffix);
679 if (basic_errno > 0)
680 message = string_sprintf("%s: %s", message, strerror(basic_errno));
681 }
682 else
683 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
684
685 log_write(0, LOG_MAIN, "%s", message);
686 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
687 }
688
689 static void
690 msglog_line(host_item * host, uschar * message)
691 {
692 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
693 host->name, host->address, message);
694 }
695
696
697
698 #ifndef DISABLE_EVENT
699 /*************************************************
700 * Post-defer action *
701 *************************************************/
702
703 /* This expands an arbitrary per-transport string.
704 It might, for example, be used to write to the database log.
705
706 Arguments:
707 addr the address item containing error information
708 host the current host
709
710 Returns: nothing
711 */
712
713 static void
714 deferred_event_raise(address_item *addr, host_item *host)
715 {
716 uschar * action = addr->transport->event_action;
717 const uschar * save_domain;
718 uschar * save_local;
719
720 if (!action)
721 return;
722
723 save_domain = deliver_domain;
724 save_local = deliver_localpart;
725
726 /*XXX would ip & port already be set up? */
727 deliver_host_address = string_copy(host->address);
728 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
729 event_defer_errno = addr->basic_errno;
730
731 router_name = addr->router->name;
732 transport_name = addr->transport->name;
733 deliver_domain = addr->domain;
734 deliver_localpart = addr->local_part;
735
736 (void) event_raise(action, US"msg:host:defer",
737 addr->message
738 ? addr->basic_errno > 0
739 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
740 : string_copy(addr->message)
741 : addr->basic_errno > 0
742 ? string_copy(US strerror(addr->basic_errno))
743 : NULL);
744
745 deliver_localpart = save_local;
746 deliver_domain = save_domain;
747 router_name = transport_name = NULL;
748 }
749 #endif
750
751 /*************************************************
752 * Reap SMTP specific responses *
753 *************************************************/
754 static int
755 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
756 int count)
757 {
758 uschar flushbuffer[4096];
759
760 while (count-- > 0)
761 {
762 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
763 '2', ob->command_timeout)
764 && (errno != 0 || flushbuffer[0] == 0))
765 break;
766 }
767 return count;
768 }
769
770
771 /* Return boolean success */
772
773 static BOOL
774 smtp_reap_banner(smtp_context * sx)
775 {
776 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
777 '2', (SOB sx->conn_args.ob)->command_timeout);
778 #ifdef EXPERIMENTAL_DSN_INFO
779 sx->smtp_greeting = string_copy(sx->buffer);
780 #endif
781 return good_response;
782 }
783
784 static BOOL
785 smtp_reap_ehlo(smtp_context * sx)
786 {
787 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
788 (SOB sx->conn_args.ob)->command_timeout))
789 {
790 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
791 {
792 #ifdef EXPERIMENTAL_DSN_INFO
793 sx->helo_response = string_copy(sx->buffer);
794 #endif
795 return FALSE;
796 }
797 sx->esmtp = FALSE;
798 }
799 #ifdef EXPERIMENTAL_DSN_INFO
800 sx->helo_response = string_copy(sx->buffer);
801 #endif
802 return TRUE;
803 }
804
805
806
807 #ifdef EXPERIMENTAL_PIPE_CONNECT
808 static uschar *
809 ehlo_cache_key(const smtp_context * sx)
810 {
811 host_item * host = sx->conn_args.host;
812 return Ustrchr(host->address, ':')
813 ? string_sprintf("[%s]:%d.EHLO", host->address,
814 host->port == PORT_NONE ? sx->port : host->port)
815 : string_sprintf("%s:%d.EHLO", host->address,
816 host->port == PORT_NONE ? sx->port : host->port);
817 }
818
819 static void
820 write_ehlo_cache_entry(const smtp_context * sx)
821 {
822 open_db dbblock, * dbm_file;
823
824 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
825 {
826 uschar * ehlo_resp_key = ehlo_cache_key(sx);
827 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
828
829 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
830 dbfn_close(dbm_file);
831 }
832 }
833
834 static void
835 invalidate_ehlo_cache_entry(smtp_context * sx)
836 {
837 open_db dbblock, * dbm_file;
838
839 if ( sx->early_pipe_active
840 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
841 {
842 uschar * ehlo_resp_key = ehlo_cache_key(sx);
843 dbfn_delete(dbm_file, ehlo_resp_key);
844 dbfn_close(dbm_file);
845 }
846 }
847
848 static BOOL
849 read_ehlo_cache_entry(smtp_context * sx)
850 {
851 open_db dbblock;
852 open_db * dbm_file;
853
854 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
855 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
856 else
857 {
858 uschar * ehlo_resp_key = ehlo_cache_key(sx);
859 dbdata_ehlo_resp * er;
860
861 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
862 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
863 else if (time(NULL) - er->time_stamp > retry_data_expire)
864 {
865 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
866 dbfn_close(dbm_file);
867 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
868 dbfn_delete(dbm_file, ehlo_resp_key);
869 }
870 else
871 {
872 sx->ehlo_resp = er->data;
873 dbfn_close(dbm_file);
874 DEBUG(D_transport) debug_printf(
875 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
876 er->data.cleartext_features, er->data.crypted_features);
877 return TRUE;
878 }
879 dbfn_close(dbm_file);
880 }
881 return FALSE;
882 }
883
884
885
886 /* Return an auths bitmap for the set of AUTH methods offered by the server
887 which match our authenticators. */
888
889 static unsigned short
890 study_ehlo_auths(smtp_context * sx)
891 {
892 uschar * names;
893 auth_instance * au;
894 uschar authnum;
895 unsigned short authbits = 0;
896
897 if (!sx->esmtp) return 0;
898 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
899 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
900 expand_nmax = -1; /* reset */
901 names = string_copyn(expand_nstring[1], expand_nlength[1]);
902
903 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
904 {
905 const uschar * list = names;
906 int sep = ' ';
907 uschar name[32];
908
909 while (string_nextinlist(&list, &sep, name, sizeof(name)))
910 if (strcmpic(au->public_name, name) == 0)
911 { authbits |= BIT(authnum); break; }
912 }
913
914 DEBUG(D_transport)
915 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
916 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
917
918 if (tls_out.active.sock >= 0)
919 sx->ehlo_resp.crypted_auths = authbits;
920 else
921 sx->ehlo_resp.cleartext_auths = authbits;
922 return authbits;
923 }
924
925
926
927
928 /* Wait for and check responses for early-pipelining.
929
930 Called from the lower-level smtp_read_response() function
931 used for general code that assume synchronisation, if context
932 flags indicate outstanding early-pipelining commands. Also
933 called fom sync_responses() which handles pipelined commands.
934
935 Arguments:
936 sx smtp connection context
937 countp number of outstanding responses, adjusted on return
938
939 Return:
940 OK all well
941 FAIL SMTP error in response
942 */
943 int
944 smtp_reap_early_pipe(smtp_context * sx, int * countp)
945 {
946 BOOL pending_BANNER = sx->pending_BANNER;
947 BOOL pending_EHLO = sx->pending_EHLO;
948
949 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
950 sx->pending_EHLO = FALSE;
951
952 if (pending_BANNER)
953 {
954 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
955 (*countp)--;
956 if (!smtp_reap_banner(sx))
957 {
958 DEBUG(D_transport) debug_printf("bad banner\n");
959 goto fail;
960 }
961 }
962
963 if (pending_EHLO)
964 {
965 unsigned peer_offered;
966 unsigned short authbits = 0, * ap;
967
968 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
969 (*countp)--;
970 if (!smtp_reap_ehlo(sx))
971 {
972 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
973 goto fail;
974 }
975
976 /* Compare the actual EHLO response to the cached value we assumed;
977 on difference, dump or rewrite the cache and arrange for a retry. */
978
979 ap = tls_out.active.sock < 0
980 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
981
982 peer_offered = ehlo_response(sx->buffer,
983 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
984 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
985 | OPTION_UTF8 | OPTION_EARLY_PIPE
986 );
987 if ( peer_offered != sx->peer_offered
988 || (authbits = study_ehlo_auths(sx)) != *ap)
989 {
990 HDEBUG(D_transport)
991 debug_printf("EHLO extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
992 sx->peer_offered, *ap, peer_offered, authbits);
993 *ap = authbits;
994 if (peer_offered & OPTION_EARLY_PIPE)
995 write_ehlo_cache_entry(sx);
996 else
997 invalidate_ehlo_cache_entry(sx);
998
999 return OK; /* just carry on */
1000 }
1001 }
1002 return OK;
1003
1004 fail:
1005 invalidate_ehlo_cache_entry(sx);
1006 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1007 return FAIL;
1008 }
1009 #endif
1010
1011
1012 /*************************************************
1013 * Synchronize SMTP responses *
1014 *************************************************/
1015
1016 /* This function is called from smtp_deliver() to receive SMTP responses from
1017 the server, and match them up with the commands to which they relate. When
1018 PIPELINING is not in use, this function is called after every command, and is
1019 therefore somewhat over-engineered, but it is simpler to use a single scheme
1020 that works both with and without PIPELINING instead of having two separate sets
1021 of code.
1022
1023 The set of commands that are buffered up with pipelining may start with MAIL
1024 and may end with DATA; in between are RCPT commands that correspond to the
1025 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1026 etc.) are never buffered.
1027
1028 Errors after MAIL or DATA abort the whole process leaving the response in the
1029 buffer. After MAIL, pending responses are flushed, and the original command is
1030 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1031 permitted to reject some recipient addresses while accepting others. However
1032 certain errors clearly abort the whole process. Set the value in
1033 transport_return to PENDING_OK if the address is accepted. If there is a
1034 subsequent general error, it will get reset accordingly. If not, it will get
1035 converted to OK at the end.
1036
1037 Arguments:
1038 sx smtp connection context
1039 count the number of responses to read
1040 pending_DATA 0 if last command sent was not DATA
1041 +1 if previously had a good recipient
1042 -1 if not previously had a good recipient
1043
1044 Returns: 3 if at least one address had 2xx and one had 5xx
1045 2 if at least one address had 5xx but none had 2xx
1046 1 if at least one host had a 2xx response, but none had 5xx
1047 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1048 -1 timeout while reading RCPT response
1049 -2 I/O or other non-response error for RCPT
1050 -3 DATA or MAIL failed - errno and buffer set
1051 -4 banner or EHLO failed (early-pipelining)
1052 */
1053
1054 static int
1055 sync_responses(smtp_context * sx, int count, int pending_DATA)
1056 {
1057 address_item * addr = sx->sync_addr;
1058 smtp_transport_options_block * ob = sx->conn_args.ob;
1059 int yield = 0;
1060
1061 #ifdef EXPERIMENTAL_PIPE_CONNECT
1062 if (smtp_reap_early_pipe(sx, &count) != OK)
1063 return -4;
1064 #endif
1065
1066 /* Handle the response for a MAIL command. On error, reinstate the original
1067 command in big_buffer for error message use, and flush any further pending
1068 responses before returning, except after I/O errors and timeouts. */
1069
1070 if (sx->pending_MAIL)
1071 {
1072 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1073 count--;
1074 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1075 '2', ob->command_timeout))
1076 {
1077 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1078 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1079 if (errno == 0 && sx->buffer[0] != 0)
1080 {
1081 int save_errno = 0;
1082 if (sx->buffer[0] == '4')
1083 {
1084 save_errno = ERRNO_MAIL4XX;
1085 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1086 }
1087 count = smtp_discard_responses(sx, ob, count);
1088 errno = save_errno;
1089 }
1090
1091 if (pending_DATA) count--; /* Number of RCPT responses to come */
1092 while (count-- > 0) /* Mark any pending addrs with the host used */
1093 {
1094 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1095 addr->host_used = sx->conn_args.host;
1096 addr = addr->next;
1097 }
1098 return -3;
1099 }
1100 }
1101
1102 if (pending_DATA) count--; /* Number of RCPT responses to come */
1103
1104 /* Read and handle the required number of RCPT responses, matching each one up
1105 with an address by scanning for the next address whose status is PENDING_DEFER.
1106 */
1107
1108 while (count-- > 0)
1109 {
1110 while (addr->transport_return != PENDING_DEFER)
1111 if (!(addr = addr->next))
1112 return -2;
1113
1114 /* The address was accepted */
1115 addr->host_used = sx->conn_args.host;
1116
1117 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1118 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1119 '2', ob->command_timeout))
1120 {
1121 yield |= 1;
1122 addr->transport_return = PENDING_OK;
1123
1124 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1125 ensure that any address-specific retry record is expunged. We do this both
1126 for the basic key and for the version that also includes the sender. */
1127
1128 if (testflag(addr, af_dr_retry_exists))
1129 {
1130 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1131 sender_address);
1132 retry_add_item(addr, altkey, rf_delete);
1133 retry_add_item(addr, addr->address_retry_key, rf_delete);
1134 }
1135 }
1136
1137 /* Timeout while reading the response */
1138
1139 else if (errno == ETIMEDOUT)
1140 {
1141 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1142 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1143 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1144 retry_add_item(addr, addr->address_retry_key, 0);
1145 update_waiting = FALSE;
1146 return -1;
1147 }
1148
1149 /* Handle other errors in obtaining an SMTP response by returning -1. This
1150 will cause all the addresses to be deferred. Restore the SMTP command in
1151 big_buffer for which we are checking the response, so the error message
1152 makes sense. */
1153
1154 else if (errno != 0 || sx->buffer[0] == 0)
1155 {
1156 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1157 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1158 return -2;
1159 }
1160
1161 /* Handle SMTP permanent and temporary response codes. */
1162
1163 else
1164 {
1165 addr->message =
1166 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1167 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1168 string_printing(sx->buffer));
1169 setflag(addr, af_pass_message);
1170 if (!sx->verify)
1171 msglog_line(sx->conn_args.host, addr->message);
1172
1173 /* The response was 5xx */
1174
1175 if (sx->buffer[0] == '5')
1176 {
1177 addr->transport_return = FAIL;
1178 yield |= 2;
1179 }
1180
1181 /* The response was 4xx */
1182
1183 else
1184 {
1185 addr->transport_return = DEFER;
1186 addr->basic_errno = ERRNO_RCPT4XX;
1187 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1188
1189 if (!sx->verify)
1190 {
1191 #ifndef DISABLE_EVENT
1192 event_defer_errno = addr->more_errno;
1193 msg_event_raise(US"msg:rcpt:host:defer", addr);
1194 #endif
1195
1196 /* Log temporary errors if there are more hosts to be tried.
1197 If not, log this last one in the == line. */
1198
1199 if (sx->conn_args.host->next)
1200 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
1201 sx->conn_args.host->name, sx->conn_args.host->address, addr->message);
1202
1203 #ifndef DISABLE_EVENT
1204 else
1205 msg_event_raise(US"msg:rcpt:defer", addr);
1206 #endif
1207
1208 /* Do not put this message on the list of those waiting for specific
1209 hosts, as otherwise it is likely to be tried too often. */
1210
1211 update_waiting = FALSE;
1212
1213 /* Add a retry item for the address so that it doesn't get tried again
1214 too soon. If address_retry_include_sender is true, add the sender address
1215 to the retry key. */
1216
1217 retry_add_item(addr,
1218 ob->address_retry_include_sender
1219 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1220 : addr->address_retry_key,
1221 0);
1222 }
1223 }
1224 }
1225 } /* Loop for next RCPT response */
1226
1227 /* Update where to start at for the next block of responses, unless we
1228 have already handled all the addresses. */
1229
1230 if (addr) sx->sync_addr = addr->next;
1231
1232 /* Handle a response to DATA. If we have not had any good recipients, either
1233 previously or in this block, the response is ignored. */
1234
1235 if (pending_DATA != 0)
1236 {
1237 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1238 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1239 '3', ob->command_timeout))
1240 {
1241 int code;
1242 uschar *msg;
1243 BOOL pass_message;
1244 if (pending_DATA > 0 || (yield & 1) != 0)
1245 {
1246 if (errno == 0 && sx->buffer[0] == '4')
1247 {
1248 errno = ERRNO_DATA4XX;
1249 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1250 }
1251 return -3;
1252 }
1253 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1254 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1255 "is in use and there were no good recipients\n", msg);
1256 }
1257 }
1258
1259 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1260 present) received 3xx. If any RCPTs were handled and yielded anything other
1261 than 4xx, yield will be set non-zero. */
1262
1263 return yield;
1264 }
1265
1266
1267
1268
1269
1270 /* Try an authenticator's client entry */
1271
1272 static int
1273 try_authenticator(smtp_context * sx, auth_instance * au)
1274 {
1275 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1276 host_item * host = sx->conn_args.host; /* host to deliver to */
1277 int rc;
1278
1279 sx->outblock.authenticating = TRUE;
1280 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1281 sx->buffer, sizeof(sx->buffer));
1282 sx->outblock.authenticating = FALSE;
1283 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1284
1285 /* A temporary authentication failure must hold up delivery to
1286 this host. After a permanent authentication failure, we carry on
1287 to try other authentication methods. If all fail hard, try to
1288 deliver the message unauthenticated unless require_auth was set. */
1289
1290 switch(rc)
1291 {
1292 case OK:
1293 f.smtp_authenticated = TRUE; /* stops the outer loop */
1294 client_authenticator = au->name;
1295 if (au->set_client_id)
1296 client_authenticated_id = expand_string(au->set_client_id);
1297 break;
1298
1299 /* Failure after writing a command */
1300
1301 case FAIL_SEND:
1302 return FAIL_SEND;
1303
1304 /* Failure after reading a response */
1305
1306 case FAIL:
1307 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1308 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1309 au->name, host->name, host->address, sx->buffer);
1310 break;
1311
1312 /* Failure by some other means. In effect, the authenticator
1313 decided it wasn't prepared to handle this case. Typically this
1314 is the result of "fail" in an expansion string. Do we need to
1315 log anything here? Feb 2006: a message is now put in the buffer
1316 if logging is required. */
1317
1318 case CANCELLED:
1319 if (*sx->buffer != 0)
1320 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1321 "authentication H=%s [%s] %s", au->name, host->name,
1322 host->address, sx->buffer);
1323 break;
1324
1325 /* Internal problem, message in buffer. */
1326
1327 case ERROR:
1328 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1329 DEFER, FALSE);
1330 return ERROR;
1331 }
1332 return OK;
1333 }
1334
1335
1336
1337
1338 /* Do the client side of smtp-level authentication.
1339
1340 Arguments:
1341 sx smtp connection context
1342
1343 sx->buffer should have the EHLO response from server (gets overwritten)
1344
1345 Returns:
1346 OK Success, or failed (but not required): global "smtp_authenticated" set
1347 DEFER Failed authentication (and was required)
1348 ERROR Internal problem
1349
1350 FAIL_SEND Failed communications - transmit
1351 FAIL - response
1352 */
1353
1354 static int
1355 smtp_auth(smtp_context * sx)
1356 {
1357 host_item * host = sx->conn_args.host; /* host to deliver to */
1358 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1359 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1360 #ifdef EXPERIMENTAL_PIPE_CONNECT
1361 unsigned short authbits = tls_out.active.sock >= 0
1362 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1363 #endif
1364 uschar * fail_reason = US"server did not advertise AUTH support";
1365
1366 f.smtp_authenticated = FALSE;
1367 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1368
1369 if (!regex_AUTH)
1370 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1371
1372 /* Is the server offering AUTH? */
1373
1374 if ( sx->esmtp
1375 &&
1376 #ifdef EXPERIMENTAL_PIPE_CONNECT
1377 sx->early_pipe_active ? authbits
1378 :
1379 #endif
1380 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1381 )
1382 {
1383 uschar * names = NULL;
1384 expand_nmax = -1; /* reset */
1385
1386 #ifdef EXPERIMENTAL_PIPE_CONNECT
1387 if (!sx->early_pipe_active)
1388 #endif
1389 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1390
1391 /* Must not do this check until after we have saved the result of the
1392 regex match above as the check could be another RE. */
1393
1394 if ( require_auth == OK
1395 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1396 {
1397 auth_instance * au;
1398
1399 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1400 fail_reason = US"no common mechanisms were found";
1401
1402 #ifdef EXPERIMENTAL_PIPE_CONNECT
1403 if (sx->early_pipe_active)
1404 {
1405 /* Scan our authenticators (which support use by a client and were offered
1406 by the server (checked at cache-write time)), not suppressed by
1407 client_condition. If one is found, attempt to authenticate by calling its
1408 client function. We are limited to supporting up to 16 authenticator
1409 public-names by the number of bits in a short. */
1410
1411 uschar bitnum;
1412 int rc;
1413
1414 for (bitnum = 0, au = auths;
1415 !f.smtp_authenticated && au && bitnum < 16;
1416 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1417 {
1418 if ( au->client_condition
1419 && !expand_check_condition(au->client_condition, au->name,
1420 US"client authenticator"))
1421 {
1422 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1423 au->name, "client_condition is false");
1424 continue;
1425 }
1426
1427 /* Found data for a listed mechanism. Call its client entry. Set
1428 a flag in the outblock so that data is overwritten after sending so
1429 that reflections don't show it. */
1430
1431 fail_reason = US"authentication attempt(s) failed";
1432
1433 if ((rc = try_authenticator(sx, au)) != OK)
1434 return rc;
1435 }
1436 }
1437 else
1438 #endif
1439
1440 /* Scan the configured authenticators looking for one which is configured
1441 for use as a client, which is not suppressed by client_condition, and
1442 whose name matches an authentication mechanism supported by the server.
1443 If one is found, attempt to authenticate by calling its client function.
1444 */
1445
1446 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1447 {
1448 uschar *p = names;
1449
1450 if ( !au->client
1451 || ( au->client_condition
1452 && !expand_check_condition(au->client_condition, au->name,
1453 US"client authenticator")))
1454 {
1455 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1456 au->name,
1457 (au->client)? "client_condition is false" :
1458 "not configured as a client");
1459 continue;
1460 }
1461
1462 /* Loop to scan supported server mechanisms */
1463
1464 while (*p)
1465 {
1466 int len = Ustrlen(au->public_name);
1467 int rc;
1468
1469 while (isspace(*p)) p++;
1470
1471 if (strncmpic(au->public_name, p, len) != 0 ||
1472 (p[len] != 0 && !isspace(p[len])))
1473 {
1474 while (*p != 0 && !isspace(*p)) p++;
1475 continue;
1476 }
1477
1478 /* Found data for a listed mechanism. Call its client entry. Set
1479 a flag in the outblock so that data is overwritten after sending so
1480 that reflections don't show it. */
1481
1482 fail_reason = US"authentication attempt(s) failed";
1483
1484 if ((rc = try_authenticator(sx, au)) != OK)
1485 return rc;
1486
1487 break; /* If not authenticated, try next authenticator */
1488 } /* Loop for scanning supported server mechanisms */
1489 } /* Loop for further authenticators */
1490 }
1491 }
1492
1493 /* If we haven't authenticated, but are required to, give up. */
1494
1495 if (require_auth == OK && !f.smtp_authenticated)
1496 {
1497 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1498 string_sprintf("authentication required but %s", fail_reason), DEFER,
1499 FALSE);
1500 return DEFER;
1501 }
1502
1503 return OK;
1504 }
1505
1506
1507 /* Construct AUTH appendix string for MAIL TO */
1508 /*
1509 Arguments
1510 buffer to build string
1511 addrlist chain of potential addresses to deliver
1512 ob transport options
1513
1514 Globals f.smtp_authenticated
1515 client_authenticated_sender
1516 Return True on error, otherwise buffer has (possibly empty) terminated string
1517 */
1518
1519 BOOL
1520 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1521 smtp_transport_options_block *ob)
1522 {
1523 uschar *local_authenticated_sender = authenticated_sender;
1524
1525 #ifdef notdef
1526 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1527 #endif
1528
1529 if (ob->authenticated_sender != NULL)
1530 {
1531 uschar *new = expand_string(ob->authenticated_sender);
1532 if (new == NULL)
1533 {
1534 if (!f.expand_string_forcedfail)
1535 {
1536 uschar *message = string_sprintf("failed to expand "
1537 "authenticated_sender: %s", expand_string_message);
1538 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1539 return TRUE;
1540 }
1541 }
1542 else if (new[0] != 0) local_authenticated_sender = new;
1543 }
1544
1545 /* Add the authenticated sender address if present */
1546
1547 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1548 local_authenticated_sender != NULL)
1549 {
1550 string_format(buffer, bufsize, " AUTH=%s",
1551 auth_xtextencode(local_authenticated_sender,
1552 Ustrlen(local_authenticated_sender)));
1553 client_authenticated_sender = string_copy(local_authenticated_sender);
1554 }
1555 else
1556 *buffer= 0;
1557
1558 return FALSE;
1559 }
1560
1561
1562
1563 #ifdef SUPPORT_DANE
1564 /* Lookup TLSA record for host/port.
1565 Return: OK success with dnssec; DANE mode
1566 DEFER Do not use this host now, may retry later
1567 FAIL_FORCED No TLSA record; DANE not usable
1568 FAIL Do not use this connection
1569 */
1570
1571 int
1572 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1573 {
1574 /* move this out to host.c given the similarity to dns_lookup() ? */
1575 uschar buffer[300];
1576 const uschar * fullname = buffer;
1577 int rc;
1578 BOOL sec;
1579
1580 /* TLSA lookup string */
1581 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1582
1583 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1584 sec = dns_is_secure(dnsa);
1585 DEBUG(D_transport)
1586 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1587
1588 switch (rc)
1589 {
1590 case DNS_AGAIN:
1591 return DEFER; /* just defer this TLS'd conn */
1592
1593 case DNS_SUCCEED:
1594 if (sec)
1595 {
1596 DEBUG(D_transport)
1597 {
1598 dns_scan dnss;
1599 dns_record * rr;
1600 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1601 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1602 if (rr->type == T_TLSA && rr->size > 3)
1603 {
1604 uint16_t payload_length = rr->size - 3;
1605 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1606
1607 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1608 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1609 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1610 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1611 sp += sprintf(CS sp, "%02x", *p++);
1612
1613 debug_printf(" %s\n", s);
1614 }
1615 }
1616 return OK;
1617 }
1618 log_write(0, LOG_MAIN,
1619 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1620 /*FALLTRHOUGH*/
1621
1622 case DNS_NODATA: /* no TLSA RR for this lookup */
1623 case DNS_NOMATCH: /* no records at all for this lookup */
1624 return dane_required ? FAIL : FAIL_FORCED;
1625
1626 default:
1627 case DNS_FAIL:
1628 return dane_required ? FAIL : DEFER;
1629 }
1630 }
1631 #endif
1632
1633
1634
1635 typedef struct smtp_compare_s
1636 {
1637 uschar *current_sender_address;
1638 struct transport_instance *tblock;
1639 } smtp_compare_t;
1640
1641
1642 /* Create a unique string that identifies this message, it is based on
1643 sender_address, helo_data and tls_certificate if enabled.
1644 */
1645
1646 static uschar *
1647 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1648 {
1649 address_item * addr1;
1650 uschar * if1 = US"";
1651 uschar * helo1 = US"";
1652 #ifdef SUPPORT_TLS
1653 uschar * tlsc1 = US"";
1654 #endif
1655 uschar * save_sender_address = sender_address;
1656 uschar * local_identity = NULL;
1657 smtp_transport_options_block * ob = SOB tblock->options_block;
1658
1659 sender_address = sender;
1660
1661 addr1 = deliver_make_addr (sender, TRUE);
1662 deliver_set_expansions(addr1);
1663
1664 if (ob->interface)
1665 if1 = expand_string(ob->interface);
1666
1667 if (ob->helo_data)
1668 helo1 = expand_string(ob->helo_data);
1669
1670 #ifdef SUPPORT_TLS
1671 if (ob->tls_certificate)
1672 tlsc1 = expand_string(ob->tls_certificate);
1673 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1674 #else
1675 local_identity = string_sprintf ("%s^%s", if1, helo1);
1676 #endif
1677
1678 deliver_set_expansions(NULL);
1679 sender_address = save_sender_address;
1680
1681 return local_identity;
1682 }
1683
1684
1685
1686 /* This routine is a callback that is called from transport_check_waiting.
1687 This function will evaluate the incoming message versus the previous
1688 message. If the incoming message is using a different local identity then
1689 we will veto this new message. */
1690
1691 static BOOL
1692 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1693 {
1694 uschar * message_local_identity,
1695 * current_local_identity,
1696 * new_sender_address;
1697
1698 current_local_identity =
1699 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1700
1701 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1702 return 0;
1703
1704 message_local_identity =
1705 smtp_local_identity(new_sender_address, s_compare->tblock);
1706
1707 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1708 }
1709
1710
1711
1712 static unsigned
1713 ehlo_response(uschar * buf, unsigned checks)
1714 {
1715 size_t bsize = Ustrlen(buf);
1716
1717 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1718
1719 #ifdef SUPPORT_TLS
1720 # ifdef EXPERIMENTAL_REQUIRETLS
1721 if ( checks & OPTION_REQUIRETLS
1722 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1723 # endif
1724 checks &= ~OPTION_REQUIRETLS;
1725
1726 if ( checks & OPTION_TLS
1727 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1728 #endif
1729 checks &= ~OPTION_TLS;
1730
1731 if ( checks & OPTION_IGNQ
1732 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1733 PCRE_EOPT, NULL, 0) < 0)
1734 checks &= ~OPTION_IGNQ;
1735
1736 if ( checks & OPTION_CHUNKING
1737 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1738 checks &= ~OPTION_CHUNKING;
1739
1740 #ifndef DISABLE_PRDR
1741 if ( checks & OPTION_PRDR
1742 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1743 #endif
1744 checks &= ~OPTION_PRDR;
1745
1746 #ifdef SUPPORT_I18N
1747 if ( checks & OPTION_UTF8
1748 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1749 #endif
1750 checks &= ~OPTION_UTF8;
1751
1752 if ( checks & OPTION_DSN
1753 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1754 checks &= ~OPTION_DSN;
1755
1756 if ( checks & OPTION_PIPE
1757 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1758 PCRE_EOPT, NULL, 0) < 0)
1759 checks &= ~OPTION_PIPE;
1760
1761 if ( checks & OPTION_SIZE
1762 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1763 checks &= ~OPTION_SIZE;
1764
1765 #ifdef EXPERIMENTAL_PIPE_CONNECT
1766 if ( checks & OPTION_EARLY_PIPE
1767 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1768 PCRE_EOPT, NULL, 0) < 0)
1769 #endif
1770 checks &= ~OPTION_EARLY_PIPE;
1771
1772 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1773 return checks;
1774 }
1775
1776
1777
1778 /* Callback for emitting a BDAT data chunk header.
1779
1780 If given a nonzero size, first flush any buffered SMTP commands
1781 then emit the command.
1782
1783 Reap previous SMTP command responses if requested, and always reap
1784 the response from a previous BDAT command.
1785
1786 Args:
1787 tctx transport context
1788 chunk_size value for SMTP BDAT command
1789 flags
1790 tc_chunk_last add LAST option to SMTP BDAT command
1791 tc_reap_prev reap response to previous SMTP commands
1792
1793 Returns: OK or ERROR
1794 */
1795
1796 static int
1797 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1798 unsigned flags)
1799 {
1800 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1801 smtp_context * sx = tctx->smtp_context;
1802 int cmd_count = 0;
1803 int prev_cmd_count;
1804
1805 /* Write SMTP chunk header command. If not reaping responses, note that
1806 there may be more writes (like, the chunk data) done soon. */
1807
1808 if (chunk_size > 0)
1809 {
1810 #ifdef EXPERIMENTAL_PIPE_CONNECT
1811 BOOL new_conn = !!(sx->outblock.conn_args);
1812 #endif
1813 if((cmd_count = smtp_write_command(sx,
1814 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1815 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1816 ) < 0) return ERROR;
1817 if (flags & tc_chunk_last)
1818 data_command = string_copy(big_buffer); /* Save for later error message */
1819 #ifdef EXPERIMENTAL_PIPE_CONNECT
1820 /* That command write could have been the one that made the connection.
1821 Copy the fd from the client conn ctx (smtp transport specific) to the
1822 generic transport ctx. */
1823
1824 if (new_conn)
1825 tctx->u.fd = sx->outblock.cctx->sock;
1826 #endif
1827 }
1828
1829 prev_cmd_count = cmd_count += sx->cmd_count;
1830
1831 /* Reap responses for any previous, but not one we just emitted */
1832
1833 if (chunk_size > 0)
1834 prev_cmd_count--;
1835 if (sx->pending_BDAT)
1836 prev_cmd_count--;
1837
1838 if (flags & tc_reap_prev && prev_cmd_count > 0)
1839 {
1840 DEBUG(D_transport) debug_printf("look for %d responses"
1841 " for previous pipelined cmds\n", prev_cmd_count);
1842
1843 switch(sync_responses(sx, prev_cmd_count, 0))
1844 {
1845 case 1: /* 2xx (only) => OK */
1846 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1847 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1848 case 0: break; /* No 2xx or 5xx, but no probs */
1849
1850 case -1: /* Timeout on RCPT */
1851 #ifdef EXPERIMENTAL_PIPE_CONNECT
1852 case -4: /* non-2xx for pipelined banner or EHLO */
1853 #endif
1854 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1855 }
1856 cmd_count = 1;
1857 if (!sx->pending_BDAT)
1858 pipelining_active = FALSE;
1859 }
1860
1861 /* Reap response for an outstanding BDAT */
1862
1863 if (sx->pending_BDAT)
1864 {
1865 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1866
1867 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1868 ob->command_timeout))
1869 {
1870 if (errno == 0 && sx->buffer[0] == '4')
1871 {
1872 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1873 sx->addrlist->more_errno |=
1874 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1875 }
1876 return ERROR;
1877 }
1878 cmd_count--;
1879 sx->pending_BDAT = FALSE;
1880 pipelining_active = FALSE;
1881 }
1882 else if (chunk_size > 0)
1883 sx->pending_BDAT = TRUE;
1884
1885
1886 sx->cmd_count = cmd_count;
1887 return OK;
1888 }
1889
1890
1891
1892
1893
1894 /*************************************************
1895 * Make connection for given message *
1896 *************************************************/
1897
1898 /*
1899 Arguments:
1900 ctx connection context
1901 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1902 a second attempt after TLS initialization fails
1903
1904 Returns: OK - the connection was made and the delivery attempted;
1905 fd is set in the conn context, tls_out set up.
1906 DEFER - the connection could not be made, or something failed
1907 while setting up the SMTP session, or there was a
1908 non-message-specific error, such as a timeout.
1909 ERROR - helo_data or add_headers or authenticated_sender is
1910 specified for this transport, and the string failed
1911 to expand
1912 */
1913 int
1914 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1915 {
1916 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1917 dns_answer tlsa_dnsa;
1918 #endif
1919 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1920 BOOL pass_message = FALSE;
1921 uschar * message = NULL;
1922 int yield = OK;
1923 int rc;
1924
1925 sx->conn_args.ob = ob;
1926
1927 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1928 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1929 sx->ok = FALSE;
1930 sx->send_rset = TRUE;
1931 sx->send_quit = TRUE;
1932 sx->setting_up = TRUE;
1933 sx->esmtp = TRUE;
1934 sx->esmtp_sent = FALSE;
1935 #ifdef SUPPORT_I18N
1936 sx->utf8_needed = FALSE;
1937 #endif
1938 sx->dsn_all_lasthop = TRUE;
1939 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1940 sx->dane = FALSE;
1941 sx->dane_required =
1942 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1943 #endif
1944 #ifdef EXPERIMENTAL_PIPE_CONNECT
1945 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1946 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1947 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1948 #endif
1949
1950 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1951 sx->peer_offered = 0;
1952 sx->avoid_option = 0;
1953 sx->igquotstr = US"";
1954 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1955 #ifdef EXPERIMENTAL_DSN_INFO
1956 sx->smtp_greeting = NULL;
1957 sx->helo_response = NULL;
1958 #endif
1959
1960 smtp_command = US"initial connection";
1961 sx->buffer[0] = '\0';
1962
1963 /* Set up the buffer for reading SMTP response packets. */
1964
1965 sx->inblock.buffer = sx->inbuffer;
1966 sx->inblock.buffersize = sizeof(sx->inbuffer);
1967 sx->inblock.ptr = sx->inbuffer;
1968 sx->inblock.ptrend = sx->inbuffer;
1969
1970 /* Set up the buffer for holding SMTP commands while pipelining */
1971
1972 sx->outblock.buffer = sx->outbuffer;
1973 sx->outblock.buffersize = sizeof(sx->outbuffer);
1974 sx->outblock.ptr = sx->outbuffer;
1975 sx->outblock.cmd_count = 0;
1976 sx->outblock.authenticating = FALSE;
1977 sx->outblock.conn_args = NULL;
1978
1979 /* Reset the parameters of a TLS session. */
1980
1981 tls_out.bits = 0;
1982 tls_out.cipher = NULL; /* the one we may use for this transport */
1983 tls_out.ourcert = NULL;
1984 tls_out.peercert = NULL;
1985 tls_out.peerdn = NULL;
1986 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1987 tls_out.sni = NULL;
1988 #endif
1989 tls_out.ocsp = OCSP_NOT_REQ;
1990
1991 /* Flip the legacy TLS-related variables over to the outbound set in case
1992 they're used in the context of the transport. Don't bother resetting
1993 afterward (when being used by a transport) as we're in a subprocess.
1994 For verify, unflipped once the callout is dealt with */
1995
1996 tls_modify_variables(&tls_out);
1997
1998 #ifndef SUPPORT_TLS
1999 if (sx->smtps)
2000 {
2001 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2002 DEFER, FALSE);
2003 return ERROR;
2004 }
2005 #endif
2006
2007 /* Make a connection to the host if this isn't a continued delivery, and handle
2008 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2009 specially so they can be identified for retries. */
2010
2011 if (!continue_hostname)
2012 {
2013 if (sx->verify)
2014 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2015
2016 /* Get the actual port the connection will use, into sx->conn_args.host */
2017
2018 smtp_port_for_connect(sx->conn_args.host, sx->port);
2019
2020 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2021 /* Do TLSA lookup for DANE */
2022 {
2023 tls_out.dane_verified = FALSE;
2024 tls_out.tlsa_usage = 0;
2025
2026 if (sx->conn_args.host->dnssec == DS_YES)
2027 {
2028 if( sx->dane_required
2029 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2030 )
2031 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2032 {
2033 case OK: sx->dane = TRUE;
2034 ob->tls_tempfail_tryclear = FALSE;
2035 break;
2036 case FAIL_FORCED: break;
2037 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2038 string_sprintf("DANE error: tlsa lookup %s",
2039 rc == DEFER ? "DEFER" : "FAIL"),
2040 rc, FALSE);
2041 # ifndef DISABLE_EVENT
2042 (void) event_raise(sx->conn_args.tblock->event_action,
2043 US"dane:fail", sx->dane_required
2044 ? US"dane-required" : US"dnssec-invalid");
2045 # endif
2046 return rc;
2047 }
2048 }
2049 else if (sx->dane_required)
2050 {
2051 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2052 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2053 FAIL, FALSE);
2054 # ifndef DISABLE_EVENT
2055 (void) event_raise(sx->conn_args.tblock->event_action,
2056 US"dane:fail", US"dane-required");
2057 # endif
2058 return FAIL;
2059 }
2060 }
2061 #endif /*DANE*/
2062
2063 /* Make the TCP connection */
2064
2065 sx->cctx.tls_ctx = NULL;
2066 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2067 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2068
2069 #ifdef EXPERIMENTAL_PIPE_CONNECT
2070 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2071 {
2072 sx->early_pipe_ok = TRUE;
2073 if ( read_ehlo_cache_entry(sx)
2074 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2075 {
2076 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2077 sx->early_pipe_active = TRUE;
2078 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2079 }
2080 }
2081
2082 if (sx->early_pipe_active)
2083 sx->outblock.conn_args = &sx->conn_args;
2084 else
2085 #endif
2086 {
2087 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2088 {
2089 uschar * msg = NULL;
2090 if (sx->verify)
2091 {
2092 msg = US strerror(errno);
2093 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2094 }
2095 set_errno_nohost(sx->addrlist,
2096 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2097 sx->verify ? string_sprintf("could not connect: %s", msg)
2098 : NULL,
2099 DEFER, FALSE);
2100 sx->send_quit = FALSE;
2101 return DEFER;
2102 }
2103 }
2104 /* Expand the greeting message while waiting for the initial response. (Makes
2105 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2106 delayed till here so that $sending_interface and $sending_port are set. */
2107 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2108 will be? Somehow I doubt it. */
2109
2110 if (sx->helo_data)
2111 if (!(sx->helo_data = expand_string(sx->helo_data)))
2112 if (sx->verify)
2113 log_write(0, LOG_MAIN|LOG_PANIC,
2114 "<%s>: failed to expand transport's helo_data value for callout: %s",
2115 sx->addrlist->address, expand_string_message);
2116
2117 #ifdef SUPPORT_I18N
2118 if (sx->helo_data)
2119 {
2120 expand_string_message = NULL;
2121 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2122 &expand_string_message)),
2123 expand_string_message)
2124 if (sx->verify)
2125 log_write(0, LOG_MAIN|LOG_PANIC,
2126 "<%s>: failed to expand transport's helo_data value for callout: %s",
2127 sx->addrlist->address, expand_string_message);
2128 else
2129 sx->helo_data = NULL;
2130 }
2131 #endif
2132
2133 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2134 is nevertheless a reasonably clean way of programming this kind of logic,
2135 where you want to escape on any error. */
2136
2137 if (!sx->smtps)
2138 {
2139 #ifdef EXPERIMENTAL_PIPE_CONNECT
2140 if (sx->early_pipe_active)
2141 {
2142 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2143 sx->outblock.cmd_count = 1;
2144 }
2145 else
2146 #endif
2147 {
2148 #ifdef TCP_QUICKACK
2149 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2150 sizeof(off));
2151 #endif
2152 if (!smtp_reap_banner(sx))
2153 goto RESPONSE_FAILED;
2154 }
2155
2156 #ifndef DISABLE_EVENT
2157 {
2158 uschar * s;
2159 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2160 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2161 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2162 if (s)
2163 {
2164 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2165 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2166 DEFER, FALSE);
2167 yield = DEFER;
2168 goto SEND_QUIT;
2169 }
2170 }
2171 #endif
2172
2173 /* Now check if the helo_data expansion went well, and sign off cleanly if
2174 it didn't. */
2175
2176 if (!sx->helo_data)
2177 {
2178 message = string_sprintf("failed to expand helo_data: %s",
2179 expand_string_message);
2180 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2181 yield = DEFER;
2182 goto SEND_QUIT;
2183 }
2184 }
2185
2186 /** Debugging without sending a message
2187 sx->addrlist->transport_return = DEFER;
2188 goto SEND_QUIT;
2189 **/
2190
2191 /* Errors that occur after this point follow an SMTP command, which is
2192 left in big_buffer by smtp_write_command() for use in error messages. */
2193
2194 smtp_command = big_buffer;
2195
2196 /* Tell the remote who we are...
2197
2198 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2199 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2200 greeting is of this form. The assumption was that the far end supports it
2201 properly... but experience shows that there are some that give 5xx responses,
2202 even though the banner includes "ESMTP" (there's a bloody-minded one that
2203 says "ESMTP not spoken here"). Cope with that case.
2204
2205 September 2000: Time has passed, and it seems reasonable now to always send
2206 EHLO at the start. It is also convenient to make the change while installing
2207 the TLS stuff.
2208
2209 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2210 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2211 would be no way to send out the mails, so there is now a host list
2212 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2213 PIPELINING problem as well. Maybe it can also be useful to cure other
2214 problems with broken servers.
2215
2216 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2217 Then somebody tried it with a Microsoft mailer... It seems that all other
2218 mailers use upper case for some reason (the RFC is quite clear about case
2219 independence) so, for peace of mind, I gave in. */
2220
2221 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2222
2223 /* Alas; be careful, since this goto is not an error-out, so conceivably
2224 we might set data between here and the target which we assume to exist
2225 and be usable. I can see this coming back to bite us. */
2226 #ifdef SUPPORT_TLS
2227 if (sx->smtps)
2228 {
2229 smtp_peer_options |= OPTION_TLS;
2230 suppress_tls = FALSE;
2231 ob->tls_tempfail_tryclear = FALSE;
2232 smtp_command = US"SSL-on-connect";
2233 goto TLS_NEGOTIATE;
2234 }
2235 #endif
2236
2237 if (sx->esmtp)
2238 {
2239 if (smtp_write_command(sx,
2240 #ifdef EXPERIMENTAL_PIPE_CONNECT
2241 sx->early_pipe_active ? SCMD_BUFFER :
2242 #endif
2243 SCMD_FLUSH,
2244 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2245 goto SEND_FAILED;
2246 sx->esmtp_sent = TRUE;
2247
2248 #ifdef EXPERIMENTAL_PIPE_CONNECT
2249 if (sx->early_pipe_active)
2250 {
2251 sx->pending_EHLO = TRUE;
2252
2253 /* If we have too many authenticators to handle and might need to AUTH
2254 for this transport, pipeline no further as we will need the
2255 list of auth methods offered. Reap the banner and EHLO. */
2256
2257 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2258 && f.smtp_in_early_pipe_no_auth)
2259 {
2260 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2261 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2262 goto SEND_FAILED;
2263 if (sync_responses(sx, 2, 0) != 0)
2264 {
2265 HDEBUG(D_transport)
2266 debug_printf("failed reaping pipelined cmd responses\n");
2267 goto RESPONSE_FAILED;
2268 }
2269 sx->early_pipe_active = FALSE;
2270 }
2271 }
2272 else
2273 #endif
2274 if (!smtp_reap_ehlo(sx))
2275 goto RESPONSE_FAILED;
2276 }
2277 else
2278 DEBUG(D_transport)
2279 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2280
2281 #ifdef EXPERIMENTAL_PIPE_CONNECT
2282 if (!sx->early_pipe_active)
2283 #endif
2284 if (!sx->esmtp)
2285 {
2286 BOOL good_response;
2287 int n = sizeof(sx->buffer);
2288 uschar * rsp = sx->buffer;
2289
2290 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2291 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2292
2293 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2294 goto SEND_FAILED;
2295 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2296 #ifdef EXPERIMENTAL_DSN_INFO
2297 sx->helo_response = string_copy(rsp);
2298 #endif
2299 if (!good_response)
2300 {
2301 /* Handle special logging for a closed connection after HELO
2302 when had previously sent EHLO */
2303
2304 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2305 {
2306 errno = ERRNO_SMTPCLOSED;
2307 goto EHLOHELO_FAILED;
2308 }
2309 memmove(sx->buffer, rsp, Ustrlen(rsp));
2310 goto RESPONSE_FAILED;
2311 }
2312 }
2313
2314 if (sx->esmtp || sx->lmtp)
2315 {
2316 #ifdef EXPERIMENTAL_PIPE_CONNECT
2317 if (!sx->early_pipe_active)
2318 #endif
2319 {
2320 sx->peer_offered = ehlo_response(sx->buffer,
2321 OPTION_TLS /* others checked later */
2322 #ifdef EXPERIMENTAL_PIPE_CONNECT
2323 | (sx->early_pipe_ok
2324 ? OPTION_IGNQ
2325 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2326 #ifdef SUPPORT_I18N
2327 | OPTION_UTF8
2328 #endif
2329 | OPTION_EARLY_PIPE
2330 : 0
2331 )
2332 #endif
2333 );
2334 #ifdef EXPERIMENTAL_PIPE_CONNECT
2335 if (sx->early_pipe_ok)
2336 {
2337 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2338
2339 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2340 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2341 {
2342 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2343 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2344 write_ehlo_cache_entry(sx);
2345 }
2346 }
2347 #endif
2348 }
2349
2350 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2351
2352 #ifdef SUPPORT_TLS
2353 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2354 #endif
2355 }
2356 }
2357
2358 /* For continuing deliveries down the same channel, having re-exec'd the socket
2359 is the standard input; for a socket held open from verify it is recorded
2360 in the cutthrough context block. Either way we don't need to redo EHLO here
2361 (but may need to do so for TLS - see below).
2362 Set up the pointer to where subsequent commands will be left, for
2363 error messages. Note that smtp_peer_options will have been
2364 set from the command line if they were set in the process that passed the
2365 connection on. */
2366
2367 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2368 as the continue goes via transport_pass_socket() and doublefork and exec.
2369 It does not wait. Unclear how we keep separate host's responses
2370 separate - we could match up by host ip+port as a bodge. */
2371
2372 else
2373 {
2374 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2375 {
2376 sx->cctx = cutthrough.cctx;
2377 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2378 }
2379 else
2380 {
2381 sx->cctx.sock = 0; /* stdin */
2382 sx->cctx.tls_ctx = NULL;
2383 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2384 }
2385 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2386 smtp_command = big_buffer;
2387 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2388
2389 /* For a continued connection with TLS being proxied for us, or a
2390 held-open verify connection with TLS, nothing more to do. */
2391
2392 if ( continue_proxy_cipher
2393 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2394 && cutthrough.is_tls)
2395 )
2396 {
2397 sx->peer_offered = smtp_peer_options;
2398 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2399 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2400 continue_proxy_cipher ? "proxied" : "verify conn with");
2401 return OK;
2402 }
2403 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2404 }
2405
2406 /* If TLS is available on this connection, whether continued or not, attempt to
2407 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2408 send another EHLO - the server may give a different answer in secure mode. We
2409 use a separate buffer for reading the response to STARTTLS so that if it is
2410 negative, the original EHLO data is available for subsequent analysis, should
2411 the client not be required to use TLS. If the response is bad, copy the buffer
2412 for error analysis. */
2413
2414 #ifdef SUPPORT_TLS
2415 if ( smtp_peer_options & OPTION_TLS
2416 && !suppress_tls
2417 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2418 && ( !sx->verify
2419 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2420 ) )
2421 {
2422 uschar buffer2[4096];
2423
2424 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2425 goto SEND_FAILED;
2426
2427 #ifdef EXPERIMENTAL_PIPE_CONNECT
2428 /* If doing early-pipelining reap the banner and EHLO-response but leave
2429 the response for the STARTTLS we just sent alone. */
2430
2431 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2432 {
2433 HDEBUG(D_transport)
2434 debug_printf("failed reaping pipelined cmd responses\n");
2435 goto RESPONSE_FAILED;
2436 }
2437 #endif
2438
2439 /* If there is an I/O error, transmission of this message is deferred. If
2440 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2441 false, we also defer. However, if there is a temporary rejection of STARTTLS
2442 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2443 STARTTLS, we carry on. This means we will try to send the message in clear,
2444 unless the host is in hosts_require_tls (tested below). */
2445
2446 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2447 {
2448 if ( errno != 0
2449 || buffer2[0] == 0
2450 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2451 )
2452 {
2453 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2454 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2455 goto RESPONSE_FAILED;
2456 }
2457 }
2458
2459 /* STARTTLS accepted: try to negotiate a TLS session. */
2460
2461 else
2462 TLS_NEGOTIATE:
2463 {
2464 address_item * addr;
2465 uschar * errstr;
2466 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2467 sx->addrlist, sx->conn_args.tblock,
2468 # ifdef SUPPORT_DANE
2469 sx->dane ? &tlsa_dnsa : NULL,
2470 # endif
2471 &tls_out, &errstr);
2472
2473 if (!sx->cctx.tls_ctx)
2474 {
2475 /* TLS negotiation failed; give an error. From outside, this function may
2476 be called again to try in clear on a new connection, if the options permit
2477 it for this host. */
2478 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2479
2480 # ifdef SUPPORT_DANE
2481 if (sx->dane)
2482 {
2483 log_write(0, LOG_MAIN,
2484 "DANE attempt failed; TLS connection to %s [%s]: %s",
2485 sx->conn_args.host->name, sx->conn_args.host->address, errstr);
2486 # ifndef DISABLE_EVENT
2487 (void) event_raise(sx->conn_args.tblock->event_action,
2488 US"dane:fail", US"validation-failure"); /* could do with better detail */
2489 # endif
2490 }
2491 # endif
2492
2493 errno = ERRNO_TLSFAILURE;
2494 message = string_sprintf("TLS session: %s", errstr);
2495 sx->send_quit = FALSE;
2496 goto TLS_FAILED;
2497 }
2498
2499 /* TLS session is set up */
2500
2501 smtp_peer_options_wrap = smtp_peer_options;
2502 for (addr = sx->addrlist; addr; addr = addr->next)
2503 if (addr->transport_return == PENDING_DEFER)
2504 {
2505 addr->cipher = tls_out.cipher;
2506 addr->ourcert = tls_out.ourcert;
2507 addr->peercert = tls_out.peercert;
2508 addr->peerdn = tls_out.peerdn;
2509 addr->ocsp = tls_out.ocsp;
2510 }
2511 }
2512 }
2513
2514 /* if smtps, we'll have smtp_command set to something else; always safe to
2515 reset it here. */
2516 smtp_command = big_buffer;
2517
2518 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2519 helo_data is null, we are dealing with a connection that was passed from
2520 another process, and so we won't have expanded helo_data above. We have to
2521 expand it here. $sending_ip_address and $sending_port are set up right at the
2522 start of the Exim process (in exim.c). */
2523
2524 if (tls_out.active.sock >= 0)
2525 {
2526 uschar * greeting_cmd;
2527
2528 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2529 {
2530 uschar *message = string_sprintf("failed to expand helo_data: %s",
2531 expand_string_message);
2532 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2533 yield = DEFER;
2534 goto SEND_QUIT;
2535 }
2536
2537 #ifdef EXPERIMENTAL_PIPE_CONNECT
2538 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2539 We're unlikely to get the group sent and delivered before the server sends its
2540 banner, but it's still worth sending as a group.
2541 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2542 the reverse. */
2543
2544 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2545 {
2546 sx->peer_offered = sx->ehlo_resp.crypted_features;
2547 if ((sx->early_pipe_active =
2548 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2549 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2550 }
2551 #endif
2552
2553 /* For SMTPS we need to wait for the initial OK response. */
2554 if (sx->smtps)
2555 #ifdef EXPERIMENTAL_PIPE_CONNECT
2556 if (sx->early_pipe_active)
2557 {
2558 sx->pending_BANNER = TRUE;
2559 sx->outblock.cmd_count = 1;
2560 }
2561 else
2562 #endif
2563 if (!smtp_reap_banner(sx))
2564 goto RESPONSE_FAILED;
2565
2566 if (sx->lmtp)
2567 greeting_cmd = US"LHLO";
2568 else if (sx->esmtp)
2569 greeting_cmd = US"EHLO";
2570 else
2571 {
2572 greeting_cmd = US"HELO";
2573 DEBUG(D_transport)
2574 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2575 }
2576
2577 if (smtp_write_command(sx,
2578 #ifdef EXPERIMENTAL_PIPE_CONNECT
2579 sx->early_pipe_active ? SCMD_BUFFER :
2580 #endif
2581 SCMD_FLUSH,
2582 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2583 goto SEND_FAILED;
2584
2585 #ifdef EXPERIMENTAL_PIPE_CONNECT
2586 if (sx->early_pipe_active)
2587 sx->pending_EHLO = TRUE;
2588 else
2589 #endif
2590 {
2591 if (!smtp_reap_ehlo(sx))
2592 goto RESPONSE_FAILED;
2593 smtp_peer_options = 0;
2594 }
2595 }
2596
2597 /* If the host is required to use a secure channel, ensure that we
2598 have one. */
2599
2600 else if ( sx->smtps
2601 # ifdef SUPPORT_DANE
2602 || sx->dane
2603 # endif
2604 # ifdef EXPERIMENTAL_REQUIRETLS
2605 || tls_requiretls & REQUIRETLS_MSG
2606 # endif
2607 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2608 )
2609 {
2610 errno =
2611 # ifdef EXPERIMENTAL_REQUIRETLS
2612 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2613 # endif
2614 ERRNO_TLSREQUIRED;
2615 message = string_sprintf("a TLS session is required, but %s",
2616 smtp_peer_options & OPTION_TLS
2617 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2618 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2619 if (sx->dane)
2620 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2621 smtp_peer_options & OPTION_TLS
2622 ? US"validation-failure" /* could do with better detail */
2623 : US"starttls-not-supported");
2624 # endif
2625 goto TLS_FAILED;
2626 }
2627 #endif /*SUPPORT_TLS*/
2628
2629 /* If TLS is active, we have just started it up and re-done the EHLO command,
2630 so its response needs to be analyzed. If TLS is not active and this is a
2631 continued session down a previously-used socket, we haven't just done EHLO, so
2632 we skip this. */
2633
2634 if (continue_hostname == NULL
2635 #ifdef SUPPORT_TLS
2636 || tls_out.active.sock >= 0
2637 #endif
2638 )
2639 {
2640 if (sx->esmtp || sx->lmtp)
2641 {
2642 #ifdef EXPERIMENTAL_PIPE_CONNECT
2643 if (!sx->early_pipe_active)
2644 #endif
2645 {
2646 sx->peer_offered = ehlo_response(sx->buffer,
2647 0 /* no TLS */
2648 #ifdef EXPERIMENTAL_PIPE_CONNECT
2649 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2650 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2651 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8 | OPTION_REQUIRETLS
2652 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2653
2654 #else
2655
2656 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2657 | OPTION_CHUNKING
2658 | OPTION_PRDR
2659 # ifdef SUPPORT_I18N
2660 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2661 /*XXX if we hand peercaps on to continued-conn processes,
2662 must not depend on this addr */
2663 # endif
2664 | OPTION_DSN
2665 | OPTION_PIPE
2666 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2667 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2668 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2669 # endif
2670 #endif
2671 );
2672 #ifdef EXPERIMENTAL_PIPE_CONNECT
2673 if (tls_out.active.sock >= 0)
2674 sx->ehlo_resp.crypted_features = sx->peer_offered;
2675 #endif
2676 }
2677
2678 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2679 lmtp_ignore_quota option was set. */
2680
2681 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2682
2683 /* If the response to EHLO specified support for the SIZE parameter, note
2684 this, provided size_addition is non-negative. */
2685
2686 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2687
2688 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2689 the current host, esmtp will be false, so PIPELINING can never be used. If
2690 the current host matches hosts_avoid_pipelining, don't do it. */
2691
2692 if ( sx->peer_offered & OPTION_PIPE
2693 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2694 smtp_peer_options |= OPTION_PIPE;
2695
2696 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2697 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2698
2699 if ( sx->peer_offered & OPTION_CHUNKING
2700 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2701 sx->peer_offered &= ~OPTION_CHUNKING;
2702
2703 if (sx->peer_offered & OPTION_CHUNKING)
2704 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2705
2706 #ifndef DISABLE_PRDR
2707 if ( sx->peer_offered & OPTION_PRDR
2708 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2709 sx->peer_offered &= ~OPTION_PRDR;
2710
2711 if (sx->peer_offered & OPTION_PRDR)
2712 DEBUG(D_transport) debug_printf("PRDR usable\n");
2713 #endif
2714
2715 /* Note if the server supports DSN */
2716 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2717 DEBUG(D_transport) debug_printf("%susing DSN\n",
2718 sx->peer_offered & OPTION_DSN ? "" : "not ");
2719
2720 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2721 if (sx->peer_offered & OPTION_REQUIRETLS)
2722 {
2723 smtp_peer_options |= OPTION_REQUIRETLS;
2724 DEBUG(D_transport) debug_printf(
2725 tls_requiretls & REQUIRETLS_MSG
2726 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2727 }
2728 #endif
2729
2730 #ifdef EXPERIMENTAL_PIPE_CONNECT
2731 if ( sx->early_pipe_ok
2732 && !sx->early_pipe_active
2733 && tls_out.active.sock >= 0
2734 && smtp_peer_options & OPTION_PIPE
2735 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2736 & OPTION_EARLY_PIPE)
2737 {
2738 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2739 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2740 write_ehlo_cache_entry(sx);
2741 }
2742 #endif
2743
2744 /* Note if the response to EHLO specifies support for the AUTH extension.
2745 If it has, check that this host is one we want to authenticate to, and do
2746 the business. The host name and address must be available when the
2747 authenticator's client driver is running. */
2748
2749 switch (yield = smtp_auth(sx))
2750 {
2751 default: goto SEND_QUIT;
2752 case OK: break;
2753 case FAIL_SEND: goto SEND_FAILED;
2754 case FAIL: goto RESPONSE_FAILED;
2755 }
2756 }
2757 }
2758 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2759
2760 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2761 message-specific. */
2762
2763 sx->setting_up = FALSE;
2764
2765 #ifdef SUPPORT_I18N
2766 if (sx->addrlist->prop.utf8_msg)
2767 {
2768 uschar * s;
2769
2770 /* If the transport sets a downconversion mode it overrides any set by ACL
2771 for the message. */
2772
2773 if ((s = ob->utf8_downconvert))
2774 {
2775 if (!(s = expand_string(s)))
2776 {
2777 message = string_sprintf("failed to expand utf8_downconvert: %s",
2778 expand_string_message);
2779 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2780 yield = DEFER;
2781 goto SEND_QUIT;
2782 }
2783 switch (*s)
2784 {
2785 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2786 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2787 break;
2788 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2789 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2790 break;
2791 case '-': if (s[1] == '1')
2792 {
2793 sx->addrlist->prop.utf8_downcvt = FALSE;
2794 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2795 }
2796 break;
2797 }
2798 }
2799
2800 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2801 && !sx->addrlist->prop.utf8_downcvt_maybe;
2802 DEBUG(D_transport) if (!sx->utf8_needed)
2803 debug_printf("utf8: %s downconvert\n",
2804 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2805 }
2806
2807 /* If this is an international message we need the host to speak SMTPUTF8 */
2808 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2809 {
2810 errno = ERRNO_UTF8_FWD;
2811 goto RESPONSE_FAILED;
2812 }
2813 #endif /*SUPPORT_I18N*/
2814
2815 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2816 /*XXX should tls_requiretls actually be per-addr? */
2817
2818 if ( tls_requiretls & REQUIRETLS_MSG
2819 && !(sx->peer_offered & OPTION_REQUIRETLS)
2820 )
2821 {
2822 sx->setting_up = TRUE;
2823 errno = ERRNO_REQUIRETLS;
2824 message = US"REQUIRETLS support is required from the server"
2825 " but it was not offered";
2826 DEBUG(D_transport) debug_printf("%s\n", message);
2827 goto TLS_FAILED;
2828 }
2829 #endif
2830
2831 return OK;
2832
2833
2834 {
2835 int code;
2836
2837 RESPONSE_FAILED:
2838 message = NULL;
2839 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2840 sx->buffer, &code, &message, &pass_message);
2841 yield = DEFER;
2842 goto FAILED;
2843
2844 SEND_FAILED:
2845 code = '4';
2846 message = US string_sprintf("send() to %s [%s] failed: %s",
2847 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2848 sx->send_quit = FALSE;
2849 yield = DEFER;
2850 goto FAILED;
2851
2852 EHLOHELO_FAILED:
2853 code = '4';
2854 message = string_sprintf("Remote host closed connection in response to %s"
2855 " (EHLO response was: %s)", smtp_command, sx->buffer);
2856 sx->send_quit = FALSE;
2857 yield = DEFER;
2858 goto FAILED;
2859
2860 /* This label is jumped to directly when a TLS negotiation has failed,
2861 or was not done for a host for which it is required. Values will be set
2862 in message and errno, and setting_up will always be true. Treat as
2863 a temporary error. */
2864
2865 #ifdef SUPPORT_TLS
2866 TLS_FAILED:
2867 # ifdef EXPERIMENTAL_REQUIRETLS
2868 if (errno == ERRNO_REQUIRETLS)
2869 code = '5', yield = FAIL;
2870 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2871 else
2872 # endif
2873 code = '4', yield = DEFER;
2874 goto FAILED;
2875 #endif
2876
2877 /* The failure happened while setting up the call; see if the failure was
2878 a 5xx response (this will either be on connection, or following HELO - a 5xx
2879 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2880 fail all addresses, as this host is never going to accept them. For other
2881 errors during setting up (timeouts or whatever), defer all addresses, and
2882 yield DEFER, so that the host is not tried again for a while.
2883
2884 XXX This peeking for another host feels like a layering violation. We want
2885 to note the host as unusable, but down here we shouldn't know if this was
2886 the last host to try for the addr(list). Perhaps the upper layer should be
2887 the one to do set_errno() ? The problem is that currently the addr is where
2888 errno etc. are stashed, but until we run out of hosts to try the errors are
2889 host-specific. Maybe we should enhance the host_item definition? */
2890
2891 FAILED:
2892 sx->ok = FALSE; /* For when reached by GOTO */
2893 set_errno(sx->addrlist, errno, message,
2894 sx->conn_args.host->next
2895 ? DEFER
2896 : code == '5'
2897 #ifdef SUPPORT_I18N
2898 || errno == ERRNO_UTF8_FWD
2899 #endif
2900 ? FAIL : DEFER,
2901 pass_message, sx->conn_args.host
2902 #ifdef EXPERIMENTAL_DSN_INFO
2903 , sx->smtp_greeting, sx->helo_response
2904 #endif
2905 );
2906 }
2907
2908
2909 SEND_QUIT:
2910
2911 if (sx->send_quit)
2912 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2913
2914 #ifdef SUPPORT_TLS
2915 if (sx->cctx.tls_ctx)
2916 {
2917 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2918 sx->cctx.tls_ctx = NULL;
2919 }
2920 #endif
2921
2922 /* Close the socket, and return the appropriate value, first setting
2923 works because the NULL setting is passed back to the calling process, and
2924 remote_max_parallel is forced to 1 when delivering over an existing connection,
2925 */
2926
2927 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2928 if (sx->send_quit)
2929 {
2930 shutdown(sx->cctx.sock, SHUT_WR);
2931 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2932 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2933 rc--; /* drain socket */
2934 sx->send_quit = FALSE;
2935 }
2936 (void)close(sx->cctx.sock);
2937 sx->cctx.sock = -1;
2938
2939 #ifndef DISABLE_EVENT
2940 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2941 #endif
2942
2943 continue_transport = NULL;
2944 continue_hostname = NULL;
2945 return yield;
2946 }
2947
2948
2949
2950
2951 /* Create the string of options that will be appended to the MAIL FROM:
2952 in the connection context buffer */
2953
2954 static int
2955 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2956 {
2957 uschar * p = sx->buffer;
2958 address_item * addr;
2959 int address_count;
2960
2961 *p = 0;
2962
2963 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2964 send it, adding something to the message size to allow for imprecision
2965 and things that get added en route. Exim keeps the number of lines
2966 in a message, so we can give an accurate value for the original message, but we
2967 need some additional to handle added headers. (Double "." characters don't get
2968 included in the count.) */
2969
2970 if ( message_size > 0
2971 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2972 {
2973 /*XXX problem here under spool_files_wireformat?
2974 Or just forget about lines? Or inflate by a fixed proportion? */
2975
2976 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2977 while (*p) p++;
2978 }
2979
2980 #ifndef DISABLE_PRDR
2981 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2982 request that */
2983
2984 sx->prdr_active = FALSE;
2985 if (sx->peer_offered & OPTION_PRDR)
2986 for (addr = addrlist; addr; addr = addr->next)
2987 if (addr->transport_return == PENDING_DEFER)
2988 {
2989 for (addr = addr->next; addr; addr = addr->next)
2990 if (addr->transport_return == PENDING_DEFER)
2991 { /* at least two recipients to send */
2992 sx->prdr_active = TRUE;
2993 sprintf(CS p, " PRDR"); p += 5;
2994 break;
2995 }
2996 break;
2997 }
2998 #endif
2999
3000 #ifdef SUPPORT_I18N
3001 /* If it supports internationalised messages, and this meesage need that,
3002 request it */
3003
3004 if ( sx->peer_offered & OPTION_UTF8
3005 && addrlist->prop.utf8_msg
3006 && !addrlist->prop.utf8_downcvt
3007 )
3008 Ustrcpy(p, " SMTPUTF8"), p += 9;
3009 #endif
3010
3011 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3012 if (tls_requiretls & REQUIRETLS_MSG)
3013 Ustrcpy(p, " REQUIRETLS") , p += 11;
3014 #endif
3015
3016 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3017 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3018 addr && address_count < sx->max_rcpt;
3019 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3020 {
3021 address_count++;
3022 if (!(addr->dsn_flags & rf_dsnlasthop))
3023 {
3024 sx->dsn_all_lasthop = FALSE;
3025 break;
3026 }
3027 }
3028
3029 /* Add any DSN flags to the mail command */
3030
3031 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3032 {
3033 if (dsn_ret == dsn_ret_hdrs)
3034 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3035 else if (dsn_ret == dsn_ret_full)
3036 { Ustrcpy(p, " RET=FULL"); p += 9; }
3037
3038 if (dsn_envid)
3039 {
3040 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3041 while (*p) p++;
3042 }
3043 }
3044
3045 /* If an authenticated_sender override has been specified for this transport
3046 instance, expand it. If the expansion is forced to fail, and there was already
3047 an authenticated_sender for this message, the original value will be used.
3048 Other expansion failures are serious. An empty result is ignored, but there is
3049 otherwise no check - this feature is expected to be used with LMTP and other
3050 cases where non-standard addresses (e.g. without domains) might be required. */
3051
3052 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3053 return ERROR;
3054
3055 return OK;
3056 }
3057
3058
3059 static void
3060 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3061 {
3062 uschar * p = sx->buffer;
3063 *p = 0;
3064
3065 /* Add any DSN flags to the rcpt command */
3066
3067 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3068 {
3069 if (addr->dsn_flags & rf_dsnflags)
3070 {
3071 int i;
3072 BOOL first = TRUE;
3073
3074 Ustrcpy(p, " NOTIFY=");
3075 while (*p) p++;
3076 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3077 {
3078 if (!first) *p++ = ',';
3079 first = FALSE;
3080 Ustrcpy(p, rf_names[i]);
3081 while (*p) p++;
3082 }
3083 }
3084
3085 if (addr->dsn_orcpt)
3086 {
3087 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3088 addr->dsn_orcpt);
3089 while (*p) p++;
3090 }
3091 }
3092 }
3093
3094
3095
3096 /*
3097 Return:
3098 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3099 -1 MAIL response error
3100 -2 any non-MAIL read i/o error
3101 -3 non-MAIL response timeout
3102 -4 internal error; channel still usable
3103 -5 transmit failed
3104 */
3105
3106 int
3107 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3108 {
3109 address_item * addr;
3110 int address_count;
3111 int rc;
3112
3113 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3114 {
3115 *yield = ERROR;
3116 return -4;
3117 }
3118
3119 /* From here until we send the DATA command, we can make use of PIPELINING
3120 if the server host supports it. The code has to be able to check the responses
3121 at any point, for when the buffer fills up, so we write it totally generally.
3122 When PIPELINING is off, each command written reports that it has flushed the
3123 buffer. */
3124
3125 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3126
3127 {
3128 uschar * s = sx->from_addr;
3129 #ifdef SUPPORT_I18N
3130 uschar * errstr = NULL;
3131
3132 /* If we must downconvert, do the from-address here. Remember we had to
3133 for the to-addresses (done below), and also (ugly) for re-doing when building
3134 the delivery log line. */
3135
3136 if ( sx->addrlist->prop.utf8_msg
3137 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3138 )
3139 {
3140 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3141 {
3142 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3143 *yield = ERROR;
3144 return -4;
3145 }
3146 setflag(sx->addrlist, af_utf8_downcvt);
3147 }
3148 #endif
3149
3150 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3151 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3152 }
3153
3154 mail_command = string_copy(big_buffer); /* Save for later error message */
3155
3156 switch(rc)
3157 {
3158 case -1: /* Transmission error */
3159 return -5;
3160
3161 case +1: /* Cmd was sent */
3162 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3163 (SOB sx->conn_args.ob)->command_timeout))
3164 {
3165 if (errno == 0 && sx->buffer[0] == '4')
3166 {
3167 errno = ERRNO_MAIL4XX;
3168 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3169 }
3170 return -1;
3171 }
3172 sx->pending_MAIL = FALSE;
3173 break;
3174
3175 /* otherwise zero: command queued for pipeline */
3176 }
3177
3178 /* Pass over all the relevant recipient addresses for this host, which are the
3179 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3180 several before we have to read the responses for those seen so far. This
3181 checking is done by a subroutine because it also needs to be done at the end.
3182 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3183 the next one if not all are sent.
3184
3185 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3186 last address because we want to abort if any recipients have any kind of
3187 problem, temporary or permanent. We know that all recipient addresses will have
3188 the PENDING_DEFER status, because only one attempt is ever made, and we know
3189 that max_rcpt will be large, so all addresses will be done at once.
3190
3191 For verify we flush the pipeline after any (the only) rcpt address. */
3192
3193 for (addr = sx->first_addr, address_count = 0;
3194 addr && address_count < sx->max_rcpt;
3195 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3196 {
3197 int count;
3198 BOOL no_flush;
3199 uschar * rcpt_addr;
3200
3201 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3202 ? dsn_support_yes : dsn_support_no;
3203
3204 address_count++;
3205 no_flush = pipelining_active && !sx->verify
3206 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3207
3208 build_rcptcmd_options(sx, addr);
3209
3210 /* Now send the RCPT command, and process outstanding responses when
3211 necessary. After a timeout on RCPT, we just end the function, leaving the
3212 yield as OK, because this error can often mean that there is a problem with
3213 just one address, so we don't want to delay the host. */
3214
3215 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3216
3217 #ifdef SUPPORT_I18N
3218 if ( testflag(sx->addrlist, af_utf8_downcvt)
3219 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3220 )
3221 {
3222 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3223 errno = ERRNO_EXPANDFAIL;
3224 return -5; /*XXX too harsh? */
3225 }
3226 #endif
3227
3228 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3229 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3230
3231 if (count < 0) return -5;
3232 if (count > 0)
3233 {
3234 switch(sync_responses(sx, count, 0))
3235 {
3236 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3237 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3238 break;
3239
3240 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3241 if (!sx->lmtp) /* can't tell about progress yet */
3242 sx->completed_addr = TRUE;
3243 case 0: /* No 2xx or 5xx, but no probs */
3244 break;
3245
3246 case -1: return -3; /* Timeout on RCPT */
3247 case -2: return -2; /* non-MAIL read i/o error */
3248 default: return -1; /* any MAIL error */
3249
3250 #ifdef EXPERIMENTAL_PIPE_CONNECT
3251 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3252 #endif
3253 }
3254 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3255 }
3256 } /* Loop for next address */
3257
3258 sx->next_addr = addr;
3259 return 0;
3260 }
3261
3262
3263 #ifdef SUPPORT_TLS
3264 /*****************************************************
3265 * Proxy TLS connection for another transport process *
3266 ******************************************************/
3267 /*
3268 Close the unused end of the pipe, fork once more, then use the given buffer
3269 as a staging area, and select on both the given fd and the TLS'd client-fd for
3270 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3271 Do blocking full-size writes, and reads under a timeout. Once both input
3272 channels are closed, exit the process.
3273
3274 Arguments:
3275 ct_ctx tls context
3276 buf space to use for buffering
3277 bufsiz size of buffer
3278 pfd pipe filedescriptor array; [0] is comms to proxied process
3279 timeout per-read timeout, seconds
3280 */
3281
3282 void
3283 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3284 int timeout)
3285 {
3286 fd_set rfds, efds;
3287 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3288 int rc, i, fd_bits, nbytes;
3289
3290 close(pfd[1]);
3291 if ((rc = fork()))
3292 {
3293 DEBUG(D_transport) debug_printf("proxy-proc final-pid %d\n", rc);
3294 _exit(rc < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3295 }
3296
3297 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
3298 set_process_info("proxying TLS connection for continued transport");
3299 FD_ZERO(&rfds);
3300 FD_SET(tls_out.active.sock, &rfds);
3301 FD_SET(pfd[0], &rfds);
3302
3303 for (fd_bits = 3; fd_bits; )
3304 {
3305 time_t time_left = timeout;
3306 time_t time_start = time(NULL);
3307
3308 /* wait for data */
3309 efds = rfds;
3310 do
3311 {
3312 struct timeval tv = { time_left, 0 };
3313
3314 rc = select(max_fd,
3315 (SELECT_ARG2_TYPE *)&rfds, NULL, (SELECT_ARG2_TYPE *)&efds, &tv);
3316
3317 if (rc < 0 && errno == EINTR)
3318 if ((time_left -= time(NULL) - time_start) > 0) continue;
3319
3320 if (rc <= 0)
3321 {
3322 DEBUG(D_transport) if (rc == 0) debug_printf("%s: timed out\n", __FUNCTION__);
3323 goto done;
3324 }
3325
3326 if (FD_ISSET(tls_out.active.sock, &efds) || FD_ISSET(pfd[0], &efds))
3327 {
3328 DEBUG(D_transport) debug_printf("select: exceptional cond on %s fd\n",
3329 FD_ISSET(pfd[0], &efds) ? "proxy" : "tls");
3330 goto done;
3331 }
3332 }
3333 while (rc < 0 || !(FD_ISSET(tls_out.active.sock, &rfds) || FD_ISSET(pfd[0], &rfds)));
3334
3335 /* handle inbound data */
3336 if (FD_ISSET(tls_out.active.sock, &rfds))
3337 if ((rc = tls_read(ct_ctx, buf, bsize)) <= 0)
3338 {
3339 fd_bits &= ~1;
3340 FD_CLR(tls_out.active.sock, &rfds);
3341 shutdown(pfd[0], SHUT_WR);
3342 timeout = 5;
3343 }
3344 else
3345 {
3346 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3347 if ((i = write(pfd[0], buf + nbytes, rc - nbytes)) < 0) goto done;
3348 }
3349 else if (fd_bits & 1)
3350 FD_SET(tls_out.active.sock, &rfds);
3351
3352 /* handle outbound data */
3353 if (FD_ISSET(pfd[0], &rfds))
3354 if ((rc = read(pfd[0], buf, bsize)) <= 0)
3355 {
3356 fd_bits = 0;
3357 tls_close(ct_ctx, TLS_SHUTDOWN_NOWAIT);
3358 ct_ctx = NULL;
3359 }
3360 else
3361 {
3362 for (nbytes = 0; rc - nbytes > 0; nbytes += i)
3363 if ((i = tls_write(ct_ctx, buf + nbytes, rc - nbytes, FALSE)) < 0)
3364 goto done;
3365 }
3366 else if (fd_bits & 2)
3367 FD_SET(pfd[0], &rfds);
3368 }
3369
3370 done:
3371 if (f.running_in_test_harness) millisleep(100); /* let logging complete */
3372 exim_exit(0, US"TLS proxy");
3373 }
3374 #endif
3375
3376
3377 /*************************************************
3378 * Deliver address list to given host *
3379 *************************************************/
3380
3381 /* If continue_hostname is not null, we get here only when continuing to
3382 deliver down an existing channel. The channel was passed as the standard
3383 input. TLS is never active on a passed channel; the previous process always
3384 closes it down before passing the connection on.
3385
3386 Otherwise, we have to make a connection to the remote host, and do the
3387 initial protocol exchange.
3388
3389 When running as an MUA wrapper, if the sender or any recipient is rejected,
3390 temporarily or permanently, we force failure for all recipients.
3391
3392 Arguments:
3393 addrlist chain of potential addresses to deliver; only those whose
3394 transport_return field is set to PENDING_DEFER are currently
3395 being processed; others should be skipped - they have either
3396 been delivered to an earlier host or IP address, or been
3397 failed by one of them.
3398 host host to deliver to
3399 host_af AF_INET or AF_INET6
3400 defport default TCP/IP port to use if host does not specify, in host
3401 byte order
3402 interface interface to bind to, or NULL
3403 tblock transport instance block
3404 message_defer set TRUE if yield is OK, but all addresses were deferred
3405 because of a non-recipient, non-host failure, that is, a
3406 4xx response to MAIL FROM, DATA, or ".". This is a defer
3407 that is specific to the message.
3408 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3409 a second attempt after TLS initialization fails
3410
3411 Returns: OK - the connection was made and the delivery attempted;
3412 the result for each address is in its data block.
3413 DEFER - the connection could not be made, or something failed
3414 while setting up the SMTP session, or there was a
3415 non-message-specific error, such as a timeout.
3416 ERROR - a filter command is specified for this transport,
3417 and there was a problem setting it up; OR helo_data
3418 or add_headers or authenticated_sender is specified
3419 for this transport, and the string failed to expand
3420 */
3421
3422 static int
3423 smtp_deliver(address_item *addrlist, host_item *host, int host_af, int defport,
3424 uschar *interface, transport_instance *tblock,
3425 BOOL *message_defer, BOOL suppress_tls)
3426 {
3427 address_item *addr;
3428 smtp_transport_options_block * ob = SOB tblock->options_block;
3429 int yield = OK;
3430 int save_errno;
3431 int rc;
3432 struct timeval start_delivery_time;
3433
3434 BOOL pass_message = FALSE;
3435 uschar *message = NULL;
3436 uschar new_message_id[MESSAGE_ID_LENGTH + 1];
3437
3438 smtp_context sx;
3439
3440 gettimeofday(&start_delivery_time, NULL);
3441 suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
3442 *message_defer = FALSE;
3443
3444 sx.addrlist = addrlist;
3445 sx.conn_args.host = host;
3446 sx.conn_args.host_af = host_af,
3447 sx.port = defport;
3448 sx.conn_args.interface = interface;
3449 sx.helo_data = NULL;
3450 sx.conn_args.tblock = tblock;
3451 sx.verify = FALSE;
3452 #ifdef EXPERIMENTAL_PIPE_CONNECT
3453 sx.sync_addr = sx.first_addr = addrlist;
3454 #endif
3455
3456 /* Get the channel set up ready for a message (MAIL FROM being the next
3457 SMTP command to send */
3458
3459 if ((rc = smtp_setup_conn(&sx, suppress_tls)) != OK)
3460 return rc;
3461
3462 /* If there is a filter command specified for this transport, we can now
3463 set it up. This cannot be done until the identify of the host is known. */
3464
3465 if (tblock->filter_command)
3466 {
3467 transport_filter_timeout = tblock->filter_timeout;
3468
3469 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3470 yield ERROR. */
3471
3472 if (!transport_set_up_command(&transport_filter_argv,
3473 tblock->filter_command, TRUE, DEFER, addrlist,
3474 string_sprintf("%.50s transport", tblock->name), NULL))
3475 {
3476 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
3477 FALSE);
3478 yield = ERROR;
3479 goto SEND_QUIT;
3480 }
3481
3482 if ( transport_filter_argv
3483 && *transport_filter_argv
3484 && **transport_filter_argv
3485 && sx.peer_offered & OPTION_CHUNKING
3486 )
3487 {
3488 sx.peer_offered &= ~OPTION_CHUNKING;
3489 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
3490 }
3491 }
3492
3493 /* For messages that have more than the maximum number of envelope recipients,
3494 we want to send several transactions down the same SMTP connection. (See
3495 comments in deliver.c as to how this reconciles, heuristically, with
3496 remote_max_parallel.) This optimization was added to Exim after the following
3497 code was already working. The simplest way to put it in without disturbing the
3498 code was to use a goto to jump back to this point when there is another
3499 transaction to handle. */
3500
3501 SEND_MESSAGE:
3502 sx.from_addr = return_path;
3503 sx.sync_addr = sx.first_addr;
3504 sx.ok = FALSE;
3505 sx.send_rset = TRUE;
3506 sx.completed_addr = FALSE;
3507
3508
3509 /* If we are a continued-connection-after-verify the MAIL and RCPT
3510 commands were already sent; do not re-send but do mark the addrs as
3511 having been accepted up to RCPT stage. A traditional cont-conn
3512 always has a sequence number greater than one. */
3513
3514 if (continue_hostname && continue_sequence == 1)
3515 {
3516 address_item * addr;
3517
3518 sx.peer_offered = smtp_peer_options;
3519 sx.pending_MAIL = FALSE;
3520 sx.ok = TRUE;
3521 sx.next_addr = NULL;
3522
3523 for (addr = addrlist; addr; addr = addr->next)
3524 addr->transport_return = PENDING_OK;
3525 }
3526 else
3527 {
3528 /* Initiate a message transfer. */
3529
3530 switch(smtp_write_mail_and_rcpt_cmds(&sx, &yield))
3531 {
3532 case 0: break;
3533 case -1: case -2: goto RESPONSE_FAILED;
3534 case -3: goto END_OFF;
3535 case -4: goto SEND_QUIT;
3536 default: goto SEND_FAILED;
3537 }
3538
3539 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3540 permanently or temporarily. We should have flushed and synced after the last
3541 RCPT. */
3542
3543 if (mua_wrapper)
3544 {
3545 address_item * a;
3546 unsigned cnt;
3547
3548 for (a = sx.first_addr, cnt = 0; a && cnt < sx.max_rcpt; a = a->next, cnt++)
3549 if (a->transport_return != PENDING_OK)
3550 {
3551 /*XXX could we find a better errno than 0 here? */
3552 set_errno_nohost(addrlist, 0, a->message, FAIL,
3553 testflag(a, af_pass_message));
3554 sx.ok = FALSE;
3555 break;
3556 }
3557 }
3558 }
3559
3560 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3561 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3562 have a good recipient buffered up if we are pipelining. We don't want to waste
3563 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3564 are pipelining. The responses are all handled by sync_responses().
3565 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3566 to send is. */
3567
3568 if ( !(sx.peer_offered & OPTION_CHUNKING)
3569 && (sx.ok || (pipelining_active && !mua_wrapper)))
3570 {
3571 int count = smtp_write_command(&sx, SCMD_FLUSH, "DATA\r\n");
3572
3573 if (count < 0) goto SEND_FAILED;
3574 switch(sync_responses(&sx, count, sx.ok ? +1 : -1))
3575 {
3576 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3577 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3578 break;
3579
3580 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3581 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3582 case 0: break; /* No 2xx or 5xx, but no probs */
3583
3584 case -1: goto END_OFF; /* Timeout on RCPT */
3585
3586 #ifdef EXPERIMENTAL_PIPE_CONNECT
3587 case -4: HDEBUG(D_transport)
3588 debug_printf("failed reaping pipelined cmd responses\n");
3589 #endif
3590 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3591 }
3592 pipelining_active = FALSE;
3593 data_command = string_copy(big_buffer); /* Save for later error message */
3594 }
3595
3596 /* If there were no good recipients (but otherwise there have been no
3597 problems), just set ok TRUE, since we have handled address-specific errors
3598 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3599 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3600 well as body. Set the appropriate timeout value to be used for each chunk.
3601 (Haven't been able to make it work using select() for writing yet.) */
3602
3603 if (!(sx.peer_offered & OPTION_CHUNKING) && !sx.ok)
3604 {
3605 /* Save the first address of the next batch. */
3606 sx.first_addr = sx.next_addr;
3607
3608 sx.ok = TRUE;
3609 }
3610 else
3611 {
3612 transport_ctx tctx = {
3613 .u = {.fd = sx.cctx.sock}, /*XXX will this need TLS info? */
3614 .tblock = tblock,
3615 .addr = addrlist,
3616 .check_string = US".",
3617 .escape_string = US"..", /* Escaping strings */
3618 .options =
3619 topt_use_crlf | topt_escape_headers
3620 | (tblock->body_only ? topt_no_headers : 0)
3621 | (tblock->headers_only ? topt_no_body : 0)
3622 | (tblock->return_path_add ? topt_add_return_path : 0)
3623 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
3624 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
3625 };
3626
3627 /* If using CHUNKING we need a callback from the generic transport
3628 support to us, for the sending of BDAT smtp commands and the reaping
3629 of responses. The callback needs a whole bunch of state so set up
3630 a transport-context structure to be passed around. */
3631
3632 if (sx.peer_offered & OPTION_CHUNKING)
3633 {
3634 tctx.check_string = tctx.escape_string = NULL;
3635 tctx.options |= topt_use_bdat;
3636 tctx.chunk_cb = smtp_chunk_cmd_callback;
3637 sx.pending_BDAT = FALSE;
3638 sx.good_RCPT = sx.ok;
3639 sx.cmd_count = 0;
3640 tctx.smtp_context = &sx;
3641 }
3642 else
3643 tctx.options |= topt_end_dot;
3644
3645 /* Save the first address of the next batch. */
3646 sx.first_addr = sx.next_addr;
3647
3648 /* Responses from CHUNKING commands go in buffer. Otherwise,
3649 there has not been a response. */
3650
3651 sx.buffer[0] = 0;
3652
3653 sigalrm_seen = FALSE;
3654 transport_write_timeout = ob->data_timeout;
3655 smtp_command = US"sending data block"; /* For error messages */
3656 DEBUG(D_transport|D_v)
3657 if (sx.peer_offered & OPTION_CHUNKING)
3658 debug_printf(" will write message using CHUNKING\n");
3659 else
3660 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3661 transport_count = 0;
3662
3663 #ifndef DISABLE_DKIM
3664 dkim_exim_sign_init();
3665 # ifdef EXPERIMENTAL_ARC
3666 {
3667 uschar * s = ob->arc_sign;
3668 if (s)
3669 {
3670 if (!(ob->dkim.arc_signspec = s = expand_string(s)))
3671 {
3672 if (!f.expand_string_forcedfail)
3673 {
3674 message = US"failed to expand arc_sign";
3675 sx.ok = FALSE;
3676 goto SEND_FAILED;
3677 }
3678 }
3679 else if (*s)
3680 {
3681 /* Ask dkim code to hash the body for ARC */
3682 (void) arc_ams_setup_sign_bodyhash();
3683 ob->dkim.force_bodyhash = TRUE;
3684 }
3685 }
3686 }
3687 # endif
3688 sx.ok = dkim_transport_write_message(&tctx, &ob->dkim, CUSS &message);
3689 #else
3690 sx.ok = transport_write_message(&tctx, 0);
3691 #endif
3692
3693 /* transport_write_message() uses write() because it is called from other
3694 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3695 it can exit with "Broken pipe" as its error. This really means that the
3696 socket got closed at the far end. */
3697
3698 transport_write_timeout = 0; /* for subsequent transports */
3699
3700 /* Failure can either be some kind of I/O disaster (including timeout),
3701 or the failure of a transport filter or the expansion of added headers.
3702 Or, when CHUNKING, it can be a protocol-detected failure. */
3703
3704 if (!sx.ok)
3705 if (message) goto SEND_FAILED;
3706 else goto RESPONSE_FAILED;
3707
3708 /* We used to send the terminating "." explicitly here, but because of
3709 buffering effects at both ends of TCP/IP connections, you don't gain
3710 anything by keeping it separate, so it might as well go in the final
3711 data buffer for efficiency. This is now done by setting the topt_end_dot
3712 flag above. */
3713
3714 smtp_command = US"end of data";
3715
3716 if (sx.peer_offered & OPTION_CHUNKING && sx.cmd_count > 1)
3717 {
3718 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3719 switch(sync_responses(&sx, sx.cmd_count-1, 0))
3720 {
3721 case 3: sx.ok = TRUE; /* 2xx & 5xx => OK & progress made */
3722 case 2: sx.completed_addr = TRUE; /* 5xx (only) => progress made */
3723 break;
3724
3725 case 1: sx.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3726 if (!sx.lmtp) sx.completed_addr = TRUE; /* can't tell about progress yet */
3727 case 0: break; /* No 2xx or 5xx, but no probs */
3728
3729 case -1: goto END_OFF; /* Timeout on RCPT */
3730
3731 #ifdef EXPERIMENTAL_PIPE_CONNECT
3732 case -4: HDEBUG(D_transport)
3733 debug_printf("failed reaping pipelined cmd responses\n");
3734 #endif
3735 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
3736 }
3737 }
3738
3739 #ifndef DISABLE_PRDR
3740 /* For PRDR we optionally get a partial-responses warning followed by the
3741 individual responses, before going on with the overall response. If we don't
3742 get the warning then deal with per non-PRDR. */
3743
3744 if(sx.prdr_active)
3745 {
3746 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '3', ob->final_timeout);
3747 if (!sx.ok && errno == 0) switch(sx.buffer[0])
3748 {
3749 case '2': sx.prdr_active = FALSE;
3750 sx.ok = TRUE;
3751 break;
3752 case '4': errno = ERRNO_DATA4XX;
3753 addrlist->more_errno |=
3754 ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3755 break;
3756 }
3757 }
3758 else
3759 #endif
3760
3761 /* For non-PRDR SMTP, we now read a single response that applies to the
3762 whole message. If it is OK, then all the addresses have been delivered. */
3763
3764 if (!sx.lmtp)
3765 {
3766 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3767 ob->final_timeout);
3768 if (!sx.ok && errno == 0 && sx.buffer[0] == '4')
3769 {
3770 errno = ERRNO_DATA4XX;
3771 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3772 }
3773 }
3774
3775 /* For LMTP, we get back a response for every RCPT command that we sent;
3776 some may be accepted and some rejected. For those that get a response, their
3777 status is fixed; any that are accepted have been handed over, even if later
3778 responses crash - at least, that's how I read RFC 2033.
3779
3780 If all went well, mark the recipient addresses as completed, record which
3781 host/IPaddress they were delivered to, and cut out RSET when sending another
3782 message down the same channel. Write the completed addresses to the journal
3783 now so that they are recorded in case there is a crash of hardware or
3784 software before the spool gets updated. Also record the final SMTP
3785 confirmation if needed (for SMTP only). */
3786
3787 if (sx.ok)
3788 {
3789 int flag = '=';
3790 struct timeval delivery_time;
3791 int len;
3792 uschar * conf = NULL;
3793
3794 timesince(&delivery_time, &start_delivery_time);
3795 sx.send_rset = FALSE;
3796 pipelining_active = FALSE;
3797
3798 /* Set up confirmation if needed - applies only to SMTP */
3799
3800 if (
3801 #ifdef DISABLE_EVENT
3802 LOGGING(smtp_confirmation) &&
3803 #endif
3804 !sx.lmtp
3805 )
3806 {
3807 const uschar *s = string_printing(sx.buffer);
3808 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3809 conf = (s == sx.buffer)? US string_copy(s) : US s;
3810 }
3811
3812 /* Process all transported addresses - for LMTP or PRDR, read a status for
3813 each one. */
3814
3815 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3816 {
3817 if (addr->transport_return != PENDING_OK) continue;
3818
3819 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3820 remaining addresses. Otherwise, it's a return code for just the one
3821 address. For temporary errors, add a retry item for the address so that
3822 it doesn't get tried again too soon. */
3823
3824 #ifndef DISABLE_PRDR
3825 if (sx.lmtp || sx.prdr_active)
3826 #else
3827 if (sx.lmtp)
3828 #endif
3829 {
3830 if (!smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3831 ob->final_timeout))
3832 {
3833 if (errno != 0 || sx.buffer[0] == 0) goto RESPONSE_FAILED;
3834 addr->message = string_sprintf(
3835 #ifndef DISABLE_PRDR
3836 "%s error after %s: %s", sx.prdr_active ? "PRDR":"LMTP",
3837 #else
3838 "LMTP error after %s: %s",
3839 #endif
3840 data_command, string_printing(sx.buffer));
3841 setflag(addr, af_pass_message); /* Allow message to go to user */
3842 if (sx.buffer[0] == '5')
3843 addr->transport_return = FAIL;
3844 else
3845 {
3846 errno = ERRNO_DATA4XX;
3847 addr->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3848 addr->transport_return = DEFER;
3849 #ifndef DISABLE_PRDR
3850 if (!sx.prdr_active)
3851 #endif
3852 retry_add_item(addr, addr->address_retry_key, 0);
3853 }
3854 continue;
3855 }
3856 sx.completed_addr = TRUE; /* NOW we can set this flag */
3857 if (LOGGING(smtp_confirmation))
3858 {
3859 const uschar *s = string_printing(sx.buffer);
3860 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3861 conf = (s == sx.buffer) ? US string_copy(s) : US s;
3862 }
3863 }
3864
3865 /* SMTP, or success return from LMTP for this address. Pass back the
3866 actual host that was used. */
3867
3868 addr->transport_return = OK;
3869 addr->more_errno = delivery_time.tv_sec;
3870 addr->delivery_usec = delivery_time.tv_usec;
3871 addr->host_used = host;
3872 addr->special_action = flag;
3873 addr->message = conf;
3874
3875 if (tcp_out_fastopen)
3876 {
3877 setflag(addr, af_tcp_fastopen_conn);
3878 if (tcp_out_fastopen >= TFO_USED_NODATA) setflag(addr, af_tcp_fastopen);
3879 if (tcp_out_fastopen >= TFO_USED_DATA) setflag(addr, af_tcp_fastopen_data);
3880 }
3881 if (sx.pipelining_used) setflag(addr, af_pipelining);
3882 #ifdef EXPERIMENTAL_PIPE_CONNECT
3883 if (sx.early_pipe_active) setflag(addr, af_early_pipe);
3884 #endif
3885 #ifndef DISABLE_PRDR
3886 if (sx.prdr_active) setflag(addr, af_prdr_used);
3887 #endif
3888 if (sx.peer_offered & OPTION_CHUNKING) setflag(addr, af_chunking_used);
3889 flag = '-';
3890
3891 #ifndef DISABLE_PRDR
3892 if (!sx.prdr_active)
3893 #endif
3894 {
3895 /* Update the journal. For homonymic addresses, use the base address plus
3896 the transport name. See lots of comments in deliver.c about the reasons
3897 for the complications when homonyms are involved. Just carry on after
3898 write error, as it may prove possible to update the spool file later. */
3899
3900 if (testflag(addr, af_homonym))
3901 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3902 else
3903 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3904
3905 DEBUG(D_deliver) debug_printf("S:journalling %s\n", sx.buffer);
3906 len = Ustrlen(CS sx.buffer);
3907 if (write(journal_fd, sx.buffer, len) != len)
3908 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3909 "%s: %s", sx.buffer, strerror(errno));
3910 }
3911 }
3912
3913 #ifndef DISABLE_PRDR
3914 if (sx.prdr_active)
3915 {
3916 const uschar * overall_message;
3917
3918 /* PRDR - get the final, overall response. For any non-success
3919 upgrade all the address statuses. */
3920
3921 sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer), '2',
3922 ob->final_timeout);
3923 if (!sx.ok)
3924 {
3925 if(errno == 0 && sx.buffer[0] == '4')
3926 {
3927 errno = ERRNO_DATA4XX;
3928 addrlist->more_errno |= ((sx.buffer[1] - '0')*10 + sx.buffer[2] - '0') << 8;
3929 }
3930 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3931 if (sx.buffer[0] == '5' || addr->transport_return == OK)
3932 addr->transport_return = PENDING_OK; /* allow set_errno action */
3933 goto RESPONSE_FAILED;
3934 }
3935
3936 /* Append the overall response to the individual PRDR response for logging
3937 and update the journal, or setup retry. */
3938
3939 overall_message = string_printing(sx.buffer);
3940 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3941 if (addr->transport_return == OK)
3942 addr->message = string_sprintf("%s\\n%s", addr->message, overall_message);
3943
3944 for (addr = addrlist; addr != sx.first_addr; addr = addr->next)
3945 if (addr->transport_return == OK)
3946 {
3947 if (testflag(addr, af_homonym))
3948 sprintf(CS sx.buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
3949 else
3950 sprintf(CS sx.buffer, "%.500s\n", addr->unique);
3951
3952 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", sx.buffer);
3953 len = Ustrlen(CS sx.buffer);
3954 if (write(journal_fd, sx.buffer, len) != len)
3955 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
3956 "%s: %s", sx.buffer, strerror(errno));
3957 }
3958 else if (addr->transport_return == DEFER)
3959 retry_add_item(addr, addr->address_retry_key, -2);
3960 }
3961 #endif
3962
3963 /* Ensure the journal file is pushed out to disk. */
3964
3965 if (EXIMfsync(journal_fd) < 0)
3966 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
3967 strerror(errno));
3968 }
3969 }
3970
3971
3972 /* Handle general (not specific to one address) failures here. The value of ok
3973 is used to skip over this code on the falling through case. A timeout causes a
3974 deferral. Other errors may defer or fail according to the response code, and
3975 may set up a special errno value, e.g. after connection chopped, which is
3976 assumed if errno == 0 and there is no text in the buffer. If control reaches
3977 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3978 the problem is not related to this specific message. */
3979
3980 if (!sx.ok)
3981 {
3982 int code, set_rc;
3983 uschar * set_message;
3984
3985 RESPONSE_FAILED:
3986 {
3987 save_errno = errno;
3988 message = NULL;
3989 sx.send_quit = check_response(host, &save_errno, addrlist->more_errno,
3990 sx.buffer, &code, &message, &pass_message);
3991 goto FAILED;
3992 }
3993
3994 SEND_FAILED:
3995 {
3996 save_errno = errno;
3997 code = '4';
3998 message = string_sprintf("send() to %s [%s] failed: %s",
3999 host->name, host->address, message ? message : US strerror(save_errno));
4000 sx.send_quit = FALSE;
4001 goto FAILED;
4002 }
4003
4004 FAILED:
4005 {
4006 BOOL message_error;
4007
4008 sx.ok = FALSE; /* For when reached by GOTO */
4009 set_message = message;
4010
4011 /* We want to handle timeouts after MAIL or "." and loss of connection after
4012 "." specially. They can indicate a problem with the sender address or with
4013 the contents of the message rather than a real error on the connection. These
4014 cases are treated in the same way as a 4xx response. This next bit of code
4015 does the classification. */
4016
4017 switch(save_errno)
4018 {
4019 case 0:
4020 case ERRNO_MAIL4XX:
4021 case ERRNO_DATA4XX:
4022 message_error = TRUE;
4023 break;
4024
4025 case ETIMEDOUT:
4026 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
4027 Ustrncmp(smtp_command,"end ",4) == 0;
4028 break;
4029
4030 case ERRNO_SMTPCLOSED:
4031 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
4032 break;
4033
4034 default:
4035 message_error = FALSE;
4036 break;
4037 }
4038
4039 /* Handle the cases that are treated as message errors. These are:
4040
4041 (a) negative response or timeout after MAIL
4042 (b) negative response after DATA
4043 (c) negative response or timeout or dropped connection after "."
4044 (d) utf8 support required and not offered
4045
4046 It won't be a negative response or timeout after RCPT, as that is dealt
4047 with separately above. The action in all cases is to set an appropriate
4048 error code for all the addresses, but to leave yield set to OK because the
4049 host itself has not failed. Of course, it might in practice have failed
4050 when we've had a timeout, but if so, we'll discover that at the next
4051 delivery attempt. For a temporary error, set the message_defer flag, and
4052 write to the logs for information if this is not the last host. The error
4053 for the last host will be logged as part of the address's log line. */
4054
4055 if (message_error)
4056 {
4057 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
4058
4059 /* If there's an errno, the message contains just the identity of
4060 the host. */
4061
4062 if (code == '5')
4063 set_rc = FAIL;
4064 else /* Anything other than 5 is treated as temporary */
4065 {
4066 set_rc = DEFER;
4067 if (save_errno > 0)
4068 message = US string_sprintf("%s: %s", message, strerror(save_errno));
4069
4070 write_logs(host, message, sx.first_addr ? sx.first_addr->basic_errno : 0);
4071
4072 *message_defer = TRUE;
4073 }
4074 }
4075
4076 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4077 ".", or some other transportation error. We defer all addresses and yield
4078 DEFER, except for the case of failed add_headers expansion, or a transport
4079 filter failure, when the yield should be ERROR, to stop it trying other
4080 hosts. */
4081
4082 else
4083 {
4084 #ifdef EXPERIMENTAL_PIPE_CONNECT
4085 /* If we were early-pipelinng and the actual EHLO response did not match
4086 the cached value we assumed, we could have detected it and passed a
4087 custom errno through to here. It would be nice to RSET and retry right
4088 away, but to reliably do that we eould need an extra synch point before
4089 we committed to data and that would discard half the gained roundrips.
4090 Or we could summarily drop the TCP connection. but that is also ugly.
4091 Instead, we ignore the possibility (having freshened the cache) and rely
4092 on the server telling us with a nonmessage error if we have tried to
4093 do something it no longer supports. */
4094 #endif
4095 set_rc = DEFER;
4096 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
4097 save_errno == ERRNO_FILTER_FAIL) ? ERROR : DEFER;
4098 }
4099 }
4100
4101 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
4102 #ifdef EXPERIMENTAL_DSN_INFO
4103 , sx.smtp_greeting, sx.helo_response
4104 #endif
4105 );
4106 }
4107
4108
4109 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4110 SMTP session tidily. However, if there were too many addresses to send in one
4111 message (indicated by first_addr being non-NULL) we want to carry on with the
4112 rest of them. Also, it is desirable to send more than one message down the SMTP
4113 connection if there are several waiting, provided we haven't already sent so
4114 many as to hit the configured limit. The function transport_check_waiting looks
4115 for a waiting message and returns its id. Then transport_pass_socket tries to
4116 set up a continued delivery by passing the socket on to another process. The
4117 variable send_rset is FALSE if a message has just been successfully transfered.
4118
4119 If we are already sending down a continued channel, there may be further
4120 addresses not yet delivered that are aimed at the same host, but which have not
4121 been passed in this run of the transport. In this case, continue_more will be
4122 true, and all we should do is send RSET if necessary, and return, leaving the
4123 channel open.
4124
4125 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4126 do not want to continue with other messages down the same channel, because that
4127 can lead to looping between two or more messages, all with the same,
4128 temporarily failing address(es). [The retry information isn't updated yet, so
4129 new processes keep on trying.] We probably also don't want to try more of this
4130 message's addresses either.
4131
4132 If we have started a TLS session, we have to end it before passing the
4133 connection to a new process. However, not all servers can handle this (Exim
4134 can), so we do not pass such a connection on if the host matches
4135 hosts_nopass_tls. */
4136
4137 DEBUG(D_transport)
4138 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4139 "yield=%d first_address is %sNULL\n", sx.ok, sx.send_quit,
4140 sx.send_rset, f.continue_more, yield, sx.first_addr ? "not " : "");
4141
4142 if (sx.completed_addr && sx.ok && sx.send_quit)
4143 {
4144 BOOL more;
4145 smtp_compare_t t_compare;
4146
4147 t_compare.tblock = tblock;
4148 t_compare.current_sender_address = sender_address;
4149
4150 if ( sx.first_addr != NULL
4151 || f.continue_more
4152 || (
4153 #ifdef SUPPORT_TLS
4154 ( tls_out.active.sock < 0 && !continue_proxy_cipher
4155 || verify_check_given_host(CUSS &ob->hosts_nopass_tls, host) != OK
4156 )
4157 &&
4158 #endif
4159 transport_check_waiting(tblock->name, host->name,
4160 tblock->connection_max_messages, new_message_id, &more,
4161 (oicf)smtp_are_same_identities, (void*)&t_compare)
4162 ) )
4163 {
4164 uschar *msg;
4165 BOOL pass_message;
4166
4167 if (sx.send_rset)
4168 if (! (sx.ok = smtp_write_command(&sx, SCMD_FLUSH, "RSET\r\n") >= 0))
4169 {
4170 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
4171 host->address, strerror(errno));
4172 sx.send_quit = FALSE;
4173 }
4174 else if (! (sx.ok = smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4175 '2', ob->command_timeout)))
4176 {
4177 int code;
4178 sx.send_quit = check_response(host, &errno, 0, sx.buffer, &code, &msg,
4179 &pass_message);
4180 if (!sx.send_quit)
4181 {
4182 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
4183 host->name, host->address, msg);
4184 }
4185 }
4186
4187 /* Either RSET was not needed, or it succeeded */
4188
4189 if (sx.ok)
4190 {
4191 #ifdef SUPPORT_TLS
4192 int pfd[2];
4193 #endif
4194 int socket_fd = sx.cctx.sock;
4195
4196
4197 if (sx.first_addr != NULL) /* More addresses still to be sent */
4198 { /* in this run of the transport */
4199 continue_sequence++; /* Causes * in logging */
4200 goto SEND_MESSAGE;
4201 }
4202
4203 /* Unless caller said it already has more messages listed for this host,
4204 pass the connection on to a new Exim process (below, the call to
4205 transport_pass_socket). If the caller has more ready, just return with
4206 the connection still open. */
4207
4208 #ifdef SUPPORT_TLS
4209 if (tls_out.active.sock >= 0)
4210 if ( f.continue_more
4211 || verify_check_given_host(CUSS &ob->hosts_noproxy_tls, host) == OK)
4212 {
4213 /* Before passing the socket on, or returning to caller with it still
4214 open, we must shut down TLS. Not all MTAs allow for the continuation
4215 of the SMTP session when TLS is shut down. We test for this by sending
4216 a new EHLO. If we don't get a good response, we don't attempt to pass
4217 the socket on. */
4218
4219 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_WAIT);
4220 sx.cctx.tls_ctx = NULL;
4221 smtp_peer_options = smtp_peer_options_wrap;
4222 sx.ok = !sx.smtps
4223 && smtp_write_command(&sx, SCMD_FLUSH, "EHLO %s\r\n", sx.helo_data)
4224 >= 0
4225 && smtp_read_response(&sx, sx.buffer, sizeof(sx.buffer),
4226 '2', ob->command_timeout);
4227
4228 if (sx.ok && f.continue_more)
4229 return yield; /* More addresses for another run */
4230 }
4231 else
4232 {
4233 /* Set up a pipe for proxying TLS for the new transport process */
4234
4235 smtp_peer_options |= OPTION_TLS;
4236 if (sx.ok = (socketpair(AF_UNIX, SOCK_STREAM, 0, pfd) == 0))
4237 socket_fd = pfd[1];
4238 else
4239 set_errno(sx.first_addr, errno, US"internal allocation problem",
4240 DEFER, FALSE, host
4241 # ifdef EXPERIMENTAL_DSN_INFO
4242 , sx.smtp_greeting, sx.helo_response
4243 # endif
4244 );
4245 }
4246 else
4247 #endif
4248 if (f.continue_more)
4249 return yield; /* More addresses for another run */
4250
4251 /* If the socket is successfully passed, we mustn't send QUIT (or
4252 indeed anything!) from here. */
4253
4254 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4255 propagate it from the initial
4256 */
4257 if (sx.ok && transport_pass_socket(tblock->name, host->name,
4258 host->address, new_message_id, socket_fd))
4259 {
4260 sx.send_quit = FALSE;
4261
4262 /* We have passed the client socket to a fresh transport process.
4263 If TLS is still active, we need to proxy it for the transport we
4264 just passed the baton to. Fork a child to to do it, and return to
4265 get logging done asap. Which way to place the work makes assumptions
4266 about post-fork prioritisation which may not hold on all platforms. */
4267 #ifdef SUPPORT_TLS
4268 if (tls_out.active.sock >= 0)
4269 {
4270 int pid = fork();
4271 if (pid == 0) /* child; fork again to disconnect totally */
4272 {
4273 if (f.running_in_test_harness) millisleep(100); /* let parent debug out */
4274 /* does not return */
4275 smtp_proxy_tls(sx.cctx.tls_ctx, sx.buffer, sizeof(sx.buffer), pfd,
4276 ob->command_timeout);
4277 }
4278
4279 if (pid > 0) /* parent */
4280 {
4281 DEBUG(D_transport) debug_printf("proxy-proc inter-pid %d\n", pid);
4282 close(pfd[0]);
4283 /* tidy the inter-proc to disconn the proxy proc */
4284 waitpid(pid, NULL, 0);
4285 tls_close(sx.cctx.tls_ctx, TLS_NO_SHUTDOWN);
4286 sx.cctx.tls_ctx = NULL;
4287 (void)close(sx.cctx.sock);
4288 sx.cctx.sock = -1;
4289 continue_transport = NULL;
4290 continue_hostname = NULL;
4291 return yield;
4292 }
4293 log_write(0, LOG_PANIC_DIE, "fork failed");
4294 }
4295 #endif
4296 }
4297 }
4298
4299 /* If RSET failed and there are addresses left, they get deferred. */
4300 else
4301 set_errno(sx.first_addr, errno, msg, DEFER, FALSE, host
4302 #ifdef EXPERIMENTAL_DSN_INFO
4303 , sx.smtp_greeting, sx.helo_response
4304 #endif
4305 );
4306 }
4307 }
4308
4309 /* End off tidily with QUIT unless the connection has died or the socket has
4310 been passed to another process. There has been discussion on the net about what
4311 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4312 to wait for a response, but on the other hand, there isn't anything one can do
4313 with an error response, other than log it. Exim used to do that. However,
4314 further discussion suggested that it is positively advantageous not to wait for
4315 the response, but to close the session immediately. This is supposed to move
4316 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4317 load from the server. (Hosts that are both servers and clients may not see much
4318 difference, of course.) Further discussion indicated that this was safe to do
4319 on Unix systems which have decent implementations of TCP/IP that leave the
4320 connection around for a while (TIME_WAIT) after the application has gone away.
4321 This enables the response sent by the server to be properly ACKed rather than
4322 timed out, as can happen on broken TCP/IP implementations on other OS.
4323
4324 This change is being made on 31-Jul-98. After over a year of trouble-free
4325 operation, the old commented-out code was removed on 17-Sep-99. */
4326
4327 SEND_QUIT:
4328 if (sx.send_quit) (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4329
4330 END_OFF:
4331
4332 #ifdef SUPPORT_TLS
4333 tls_close(sx.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
4334 sx.cctx.tls_ctx = NULL;
4335 #endif
4336
4337 /* Close the socket, and return the appropriate value, first setting
4338 works because the NULL setting is passed back to the calling process, and
4339 remote_max_parallel is forced to 1 when delivering over an existing connection,
4340
4341 If all went well and continue_more is set, we shouldn't actually get here if
4342 there are further addresses, as the return above will be taken. However,
4343 writing RSET might have failed, or there may be other addresses whose hosts are
4344 specified in the transports, and therefore not visible at top level, in which
4345 case continue_more won't get set. */
4346
4347 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
4348 if (sx.send_quit)
4349 {
4350 shutdown(sx.cctx.sock, SHUT_WR);
4351 millisleep(f.running_in_test_harness ? 200 : 20);
4352 if (fcntl(sx.cctx.sock, F_SETFL, O_NONBLOCK) == 0)
4353 for (rc = 16; read(sx.cctx.sock, sx.inbuffer, sizeof(sx.inbuffer)) > 0 && rc > 0;)
4354 rc--; /* drain socket */
4355 }
4356 (void)close(sx.cctx.sock);
4357
4358 #ifndef DISABLE_EVENT
4359 (void) event_raise(tblock->event_action, US"tcp:close", NULL);
4360 #endif
4361
4362 continue_transport = NULL;
4363 continue_hostname = NULL;
4364 return yield;
4365 }
4366
4367
4368
4369
4370 /*************************************************
4371 * Closedown entry point *
4372 *************************************************/
4373
4374 /* This function is called when exim is passed an open smtp channel
4375 from another incarnation, but the message which it has been asked
4376 to deliver no longer exists. The channel is on stdin.
4377
4378 We might do fancy things like looking for another message to send down
4379 the channel, but if the one we sought has gone, it has probably been
4380 delivered by some other process that itself will seek further messages,
4381 so just close down our connection.
4382
4383 Argument: pointer to the transport instance block
4384 Returns: nothing
4385 */
4386
4387 void
4388 smtp_transport_closedown(transport_instance *tblock)
4389 {
4390 smtp_transport_options_block * ob = SOB tblock->options_block;
4391 client_conn_ctx cctx;
4392 smtp_context sx;
4393 uschar buffer[256];
4394 uschar inbuffer[4096];
4395 uschar outbuffer[16];
4396
4397 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4398 cctx.sock = fileno(stdin);
4399 cctx.tls_ctx = cctx.sock == tls_out.active.sock ? tls_out.active.tls_ctx : NULL;
4400
4401 sx.inblock.cctx = &cctx;
4402 sx.inblock.buffer = inbuffer;
4403 sx.inblock.buffersize = sizeof(inbuffer);
4404 sx.inblock.ptr = inbuffer;
4405 sx.inblock.ptrend = inbuffer;
4406
4407 sx.outblock.cctx = &cctx;
4408 sx.outblock.buffersize = sizeof(outbuffer);
4409 sx.outblock.buffer = outbuffer;
4410 sx.outblock.ptr = outbuffer;
4411 sx.outblock.cmd_count = 0;
4412 sx.outblock.authenticating = FALSE;
4413
4414 (void)smtp_write_command(&sx, SCMD_FLUSH, "QUIT\r\n");
4415 (void)smtp_read_response(&sx, buffer, sizeof(buffer), '2', ob->command_timeout);
4416 (void)close(cctx.sock);
4417 }
4418
4419
4420
4421 /*************************************************
4422 * Prepare addresses for delivery *
4423 *************************************************/
4424
4425 /* This function is called to flush out error settings from previous delivery
4426 attempts to other hosts. It also records whether we got here via an MX record
4427 or not in the more_errno field of the address. We are interested only in
4428 addresses that are still marked DEFER - others may have got delivered to a
4429 previously considered IP address. Set their status to PENDING_DEFER to indicate
4430 which ones are relevant this time.
4431
4432 Arguments:
4433 addrlist the list of addresses
4434 host the host we are delivering to
4435
4436 Returns: the first address for this delivery
4437 */
4438
4439 static address_item *
4440 prepare_addresses(address_item *addrlist, host_item *host)
4441 {
4442 address_item *first_addr = NULL;
4443 address_item *addr;
4444 for (addr = addrlist; addr; addr = addr->next)
4445 if (addr->transport_return == DEFER)
4446 {
4447 if (!first_addr) first_addr = addr;
4448 addr->transport_return = PENDING_DEFER;
4449 addr->basic_errno = 0;
4450 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
4451 addr->message = NULL;
4452 #ifdef SUPPORT_TLS
4453 addr->cipher = NULL;
4454 addr->ourcert = NULL;
4455 addr->peercert = NULL;
4456 addr->peerdn = NULL;
4457 addr->ocsp = OCSP_NOT_REQ;
4458 #endif
4459 #ifdef EXPERIMENTAL_DSN_INFO
4460 addr->smtp_greeting = NULL;
4461 addr->helo_response = NULL;
4462 #endif
4463 }
4464 return first_addr;
4465 }
4466
4467
4468
4469 /*************************************************
4470 * Main entry point *
4471 *************************************************/
4472
4473 /* See local README for interface details. As this is a remote transport, it is
4474 given a chain of addresses to be delivered in one connection, if possible. It
4475 always returns TRUE, indicating that each address has its own independent
4476 status set, except if there is a setting up problem, in which case it returns
4477 FALSE. */
4478
4479 BOOL
4480 smtp_transport_entry(
4481 transport_instance *tblock, /* data for this instantiation */
4482 address_item *addrlist) /* addresses we are working on */
4483 {
4484 int cutoff_retry;
4485 int defport;
4486 int hosts_defer = 0;
4487 int hosts_fail = 0;
4488 int hosts_looked_up = 0;
4489 int hosts_retry = 0;
4490 int hosts_serial = 0;
4491 int hosts_total = 0;
4492 int total_hosts_tried = 0;
4493 address_item *addr;
4494 BOOL expired = TRUE;
4495 uschar *expanded_hosts = NULL;
4496 uschar *pistring;
4497 uschar *tid = string_sprintf("%s transport", tblock->name);
4498 smtp_transport_options_block *ob = SOB tblock->options_block;
4499 host_item *hostlist = addrlist->host_list;
4500 host_item *host;
4501
4502 DEBUG(D_transport)
4503 {
4504 debug_printf("%s transport entered\n", tblock->name);
4505 for (addr = addrlist; addr; addr = addr->next)
4506 debug_printf(" %s\n", addr->address);
4507 if (hostlist)
4508 {
4509 debug_printf("hostlist:\n");
4510 for (host = hostlist; host; host = host->next)
4511 debug_printf(" '%s' IP %s port %d\n", host->name, host->address, host->port);
4512 }
4513 if (continue_hostname)
4514 debug_printf("already connected to %s [%s] (on fd %d)\n",
4515 continue_hostname, continue_host_address,
4516 cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0);
4517 }
4518
4519 /* Set the flag requesting that these hosts be added to the waiting
4520 database if the delivery fails temporarily or if we are running with
4521 queue_smtp or a 2-stage queue run. This gets unset for certain
4522 kinds of error, typically those that are specific to the message. */
4523
4524 update_waiting = TRUE;
4525
4526 /* If a host list is not defined for the addresses - they must all have the
4527 same one in order to be passed to a single transport - or if the transport has
4528 a host list with hosts_override set, use the host list supplied with the
4529 transport. It is an error for this not to exist. */
4530
4531 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
4532 if (tls_requiretls & REQUIRETLS_MSG)
4533 ob->tls_tempfail_tryclear = FALSE; /*XXX surely we should have a local for this
4534 rather than modifying the transport? */
4535 #endif
4536
4537 if (!hostlist || (ob->hosts_override && ob->hosts))
4538 {
4539 if (!ob->hosts)
4540 {
4541 addrlist->message = string_sprintf("%s transport called with no hosts set",
4542 tblock->name);
4543 addrlist->transport_return = PANIC;
4544 return FALSE; /* Only top address has status */
4545 }
4546
4547 DEBUG(D_transport) debug_printf("using the transport's hosts: %s\n",
4548 ob->hosts);
4549
4550 /* If the transport's host list contains no '$' characters, and we are not
4551 randomizing, it is fixed and therefore a chain of hosts can be built once
4552 and for all, and remembered for subsequent use by other calls to this
4553 transport. If, on the other hand, the host list does contain '$', or we are
4554 randomizing its order, we have to rebuild it each time. In the fixed case,
4555 as the hosts string will never be used again, it doesn't matter that we
4556 replace all the : characters with zeros. */
4557
4558 if (!ob->hostlist)
4559 {
4560 uschar *s = ob->hosts;
4561
4562 if (Ustrchr(s, '$') != NULL)
4563 {
4564 if (!(expanded_hosts = expand_string(s)))
4565 {
4566 addrlist->message = string_sprintf("failed to expand list of hosts "
4567 "\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
4568 addrlist->transport_return = f.search_find_defer ? DEFER : PANIC;
4569 return FALSE; /* Only top address has status */
4570 }
4571 DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
4572 "\"%s\"\n", s, expanded_hosts);
4573 s = expanded_hosts;
4574 }
4575 else
4576 if (ob->hosts_randomize) s = expanded_hosts = string_copy(s);
4577
4578 host_build_hostlist(&hostlist, s, ob->hosts_randomize);
4579
4580 /* Check that the expansion yielded something useful. */
4581 if (!hostlist)
4582 {
4583 addrlist->message =
4584 string_sprintf("%s transport has empty hosts setting", tblock->name);
4585 addrlist->transport_return = PANIC;
4586 return FALSE; /* Only top address has status */
4587 }
4588
4589 /* If there was no expansion of hosts, save the host list for
4590 next time. */
4591
4592 if (!expanded_hosts) ob->hostlist = hostlist;
4593 }
4594
4595 /* This is not the first time this transport has been run in this delivery;
4596 the host list was built previously. */
4597
4598 else
4599 hostlist = ob->hostlist;
4600 }
4601
4602 /* The host list was supplied with the address. If hosts_randomize is set, we
4603 must sort it into a random order if it did not come from MX records and has not
4604 already been randomized (but don't bother if continuing down an existing
4605 connection). */
4606
4607 else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
4608 {
4609 host_item *newlist = NULL;
4610 while (hostlist)
4611 {
4612 host_item *h = hostlist;
4613 hostlist = hostlist->next;
4614
4615 h->sort_key = random_number(100);
4616
4617 if (!newlist)
4618 {
4619 h->next = NULL;
4620 newlist = h;
4621 }
4622 else if (h->sort_key < newlist->sort_key)
4623 {
4624 h->next = newlist;
4625 newlist = h;
4626 }
4627 else
4628 {
4629 host_item *hh = newlist;
4630 while (hh->next)
4631 {
4632 if (h->sort_key < hh->next->sort_key) break;
4633 hh = hh->next;
4634 }
4635 h->next = hh->next;
4636 hh->next = h;
4637 }
4638 }
4639
4640 hostlist = addrlist->host_list = newlist;
4641 }
4642
4643 /* Sort out the default port. */
4644
4645 if (!smtp_get_port(ob->port, addrlist, &defport, tid)) return FALSE;
4646
4647 /* For each host-plus-IP-address on the list:
4648
4649 . If this is a continued delivery and the host isn't the one with the
4650 current connection, skip.
4651
4652 . If the status is unusable (i.e. previously failed or retry checked), skip.
4653
4654 . If no IP address set, get the address, either by turning the name into
4655 an address, calling gethostbyname if gethostbyname is on, or by calling
4656 the DNS. The DNS may yield multiple addresses, in which case insert the
4657 extra ones into the list.
4658
4659 . Get the retry data if not previously obtained for this address and set the
4660 field which remembers the state of this address. Skip if the retry time is
4661 not reached. If not, remember whether retry data was found. The retry string
4662 contains both the name and the IP address.
4663
4664 . Scan the list of addresses and mark those whose status is DEFER as
4665 PENDING_DEFER. These are the only ones that will be processed in this cycle
4666 of the hosts loop.
4667
4668 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4669 Some addresses may be successfully delivered, others may fail, and yet
4670 others may get temporary errors and so get marked DEFER.
4671
4672 . The return from the delivery attempt is OK if a connection was made and a
4673 valid SMTP dialogue was completed. Otherwise it is DEFER.
4674
4675 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4676
4677 . If fail to connect, or other defer state, add a retry item.
4678
4679 . If there are any addresses whose status is still DEFER, carry on to the
4680 next host/IPaddress, unless we have tried the number of hosts given
4681 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4682 there is some fancy logic for hosts_max_try that means its limit can be
4683 overstepped in some circumstances.
4684
4685 If we get to the end of the list, all hosts have deferred at least one address,
4686 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4687 delivery attempt to those hosts whose last try was before the arrival time of
4688 the current message. To cope with this, we have to go round the loop a second
4689 time. After that, set the status and error data for any addresses that haven't
4690 had it set already. */
4691
4692 for (cutoff_retry = 0;
4693 expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
4694 cutoff_retry++)
4695 {
4696 host_item *nexthost = NULL;
4697 int unexpired_hosts_tried = 0;
4698 BOOL continue_host_tried = FALSE;
4699
4700 retry_non_continued:
4701 for (host = hostlist;
4702 host
4703 && unexpired_hosts_tried < ob->hosts_max_try
4704 && total_hosts_tried < ob->hosts_max_try_hardlimit;
4705 host = nexthost)
4706 {
4707 int rc;
4708 int host_af;
4709 uschar *rs;
4710 BOOL host_is_expired = FALSE;
4711 BOOL message_defer = FALSE;
4712 BOOL some_deferred = FALSE;
4713 address_item *first_addr = NULL;
4714 uschar *interface = NULL;
4715 uschar *retry_host_key = NULL;
4716 uschar *retry_message_key = NULL;
4717 uschar *serialize_key = NULL;
4718
4719 /* Default next host is next host. :-) But this can vary if the
4720 hosts_max_try limit is hit (see below). It may also be reset if a host
4721 address is looked up here (in case the host was multihomed). */
4722
4723 nexthost = host->next;
4724
4725 /* If the address hasn't yet been obtained from the host name, look it up
4726 now, unless the host is already marked as unusable. If it is marked as
4727 unusable, it means that the router was unable to find its IP address (in
4728 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4729 the lookup failed last time. We don't get this far if *all* MX records
4730 point to non-existent hosts; that is treated as a hard error.
4731
4732 We can just skip this host entirely. When the hosts came from the router,
4733 the address will timeout based on the other host(s); when the address is
4734 looked up below, there is an explicit retry record added.
4735
4736 Note that we mustn't skip unusable hosts if the address is not unset; they
4737 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4738
4739 if (!host->address)
4740 {
4741 int new_port, flags;
4742 host_item *hh;
4743
4744 if (host->status >= hstatus_unusable)
4745 {
4746 DEBUG(D_transport) debug_printf("%s has no address and is unusable - skipping\n",
4747 host->name);
4748 continue;
4749 }
4750
4751 DEBUG(D_transport) debug_printf("getting address for %s\n", host->name);
4752
4753 /* The host name is permitted to have an attached port. Find it, and
4754 strip it from the name. Just remember it for now. */
4755
4756 new_port = host_item_get_port(host);
4757
4758 /* Count hosts looked up */
4759
4760 hosts_looked_up++;
4761
4762 /* Find by name if so configured, or if it's an IP address. We don't
4763 just copy the IP address, because we need the test-for-local to happen. */
4764
4765 flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
4766 if (ob->dns_qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
4767 if (ob->dns_search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
4768
4769 if (ob->gethostbyname || string_is_ip_address(host->name, NULL) != 0)
4770 rc = host_find_byname(host, NULL, flags, NULL, TRUE);
4771 else
4772 rc = host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
4773 &ob->dnssec, /* domains for request/require */
4774 NULL, NULL);
4775
4776 /* Update the host (and any additional blocks, resulting from
4777 multihoming) with a host-specific port, if any. */
4778
4779 for (hh = host; hh != nexthost; hh = hh->next) hh->port = new_port;
4780
4781 /* Failure to find the host at this time (usually DNS temporary failure)
4782 is really a kind of routing failure rather than a transport failure.
4783 Therefore we add a retry item of the routing kind, not to stop us trying
4784 to look this name up here again, but to ensure the address gets timed
4785 out if the failures go on long enough. A complete failure at this point
4786 commonly points to a configuration error, but the best action is still
4787 to carry on for the next host. */
4788
4789 if (rc == HOST_FIND_AGAIN || rc == HOST_FIND_SECURITY || rc == HOST_FIND_FAILED)
4790 {
4791 retry_add_item(addrlist, string_sprintf("R:%s", host->name), 0);
4792 expired = FALSE;
4793 if (rc == HOST_FIND_AGAIN) hosts_defer++; else hosts_fail++;
4794 DEBUG(D_transport) debug_printf("rc = %s for %s\n", (rc == HOST_FIND_AGAIN)?
4795 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
4796 host->status = hstatus_unusable;
4797
4798 for (addr = addrlist; addr; addr = addr->next)
4799 {
4800 if (addr->transport_return != DEFER) continue;
4801 addr->basic_errno = ERRNO_UNKNOWNHOST;
4802 addr->message = string_sprintf(
4803 rc == HOST_FIND_SECURITY
4804 ? "lookup of IP address for %s was insecure"
4805 : "failed to lookup IP address for %s",
4806 host->name);
4807 }
4808 continue;
4809 }
4810
4811 /* If the host is actually the local host, we may have a problem, or
4812 there may be some cunning configuration going on. In the problem case,
4813 log things and give up. The default transport status is already DEFER. */
4814
4815 if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
4816 {
4817 for (addr = addrlist; addr; addr = addr->next)
4818 {
4819 addr->basic_errno = 0;
4820 addr->message = string_sprintf("%s transport found host %s to be "
4821 "local", tblock->name, host->name);
4822 }
4823 goto END_TRANSPORT;
4824 }
4825 } /* End of block for IP address lookup */
4826
4827 /* If this is a continued delivery, we are interested only in the host
4828 which matches the name of the existing open channel. The check is put
4829 here after the local host lookup, in case the name gets expanded as a
4830 result of the lookup. Set expired FALSE, to save the outer loop executing
4831 twice. */
4832
4833 if (continue_hostname)
4834 if ( Ustrcmp(continue_hostname, host->name) != 0
4835 || Ustrcmp(continue_host_address, host->address) != 0
4836 )
4837 {
4838 expired = FALSE;
4839 continue; /* With next host */
4840 }
4841 else
4842 continue_host_tried = TRUE;
4843
4844 /* Reset the default next host in case a multihomed host whose addresses
4845 are not looked up till just above added to the host list. */
4846
4847 nexthost = host->next;
4848
4849 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4850 domain is in queue_smtp_domains, we don't actually want to attempt any
4851 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4852 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4853 were not in it. We don't want to hold up all SMTP deliveries! Except when
4854 doing a two-stage queue run, don't do this if forcing. */
4855
4856 if ((!f.deliver_force || f.queue_2stage) && (f.queue_smtp ||
4857 match_isinlist(addrlist->domain,
4858 (const uschar **)&queue_smtp_domains, 0,
4859 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
4860 {
4861 expired = FALSE;
4862 for (addr = addrlist; addr; addr = addr->next)
4863 if (addr->transport_return == DEFER)
4864 addr->message = US"domain matches queue_smtp_domains, or -odqs set";
4865 continue; /* With next host */
4866 }
4867
4868 /* Count hosts being considered - purely for an intelligent comment
4869 if none are usable. */
4870
4871 hosts_total++;
4872
4873 /* Set $host and $host address now in case they are needed for the
4874 interface expansion or the serialize_hosts check; they remain set if an
4875 actual delivery happens. */
4876
4877 deliver_host = host->name;
4878 deliver_host_address = host->address;
4879 lookup_dnssec_authenticated = host->dnssec == DS_YES ? US"yes"
4880 : host->dnssec == DS_NO ? US"no"
4881 : US"";
4882
4883 /* Set up a string for adding to the retry key if the port number is not
4884 the standard SMTP port. A host may have its own port setting that overrides
4885 the default. */
4886
4887 pistring = string_sprintf(":%d", host->port == PORT_NONE
4888 ? defport : host->port);
4889 if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
4890
4891 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4892 string is set, even if constant (as different transports can have different
4893 constant settings), we must add it to the key that is used for retries,
4894 because connections to the same host from a different interface should be
4895 treated separately. */
4896
4897 host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
4898 if ((rs = ob->interface) && *rs)
4899 {
4900 if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
4901 return FALSE;
4902 pistring = string_sprintf("%s/%s", pistring, interface);
4903 }
4904
4905 /* The first time round the outer loop, check the status of the host by
4906 inspecting the retry data. The second time round, we are interested only
4907 in expired hosts that haven't been tried since this message arrived. */
4908
4909 if (cutoff_retry == 0)
4910 {
4911 BOOL incl_ip;
4912 /* Ensure the status of the address is set by checking retry data if
4913 necessary. There may be host-specific retry data (applicable to all
4914 messages) and also data for retries of a specific message at this host.
4915 If either of these retry records are actually read, the keys used are
4916 returned to save recomputing them later. */
4917
4918 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
4919 US"retry_include_ip_address", ob->retry_include_ip_address,
4920 ob->expand_retry_include_ip_address, &incl_ip) != OK)
4921 continue; /* with next host */
4922
4923 host_is_expired = retry_check_address(addrlist->domain, host, pistring,
4924 incl_ip, &retry_host_key, &retry_message_key);
4925
4926 DEBUG(D_transport) debug_printf("%s [%s]%s retry-status = %s\n", host->name,
4927 (host->address == NULL)? US"" : host->address, pistring,
4928 (host->status == hstatus_usable)? "usable" :
4929 (host->status == hstatus_unusable)? "unusable" :
4930 (host->status == hstatus_unusable_expired)? "unusable (expired)" : "?");
4931
4932 /* Skip this address if not usable at this time, noting if it wasn't
4933 actually expired, both locally and in the address. */
4934
4935 switch (host->status)
4936 {
4937 case hstatus_unusable:
4938 expired = FALSE;
4939 setflag(addrlist, af_retry_skipped);
4940 /* Fall through */
4941
4942 case hstatus_unusable_expired:
4943 switch (host->why)
4944 {
4945 case hwhy_retry: hosts_retry++; break;
4946 case hwhy_failed: hosts_fail++; break;
4947 case hwhy_insecure:
4948 case hwhy_deferred: hosts_defer++; break;
4949 }
4950
4951 /* If there was a retry message key, implying that previously there
4952 was a message-specific defer, we don't want to update the list of
4953 messages waiting for these hosts. */
4954
4955 if (retry_message_key) update_waiting = FALSE;
4956 continue; /* With the next host or IP address */
4957 }
4958 }
4959
4960 /* Second time round the loop: if the address is set but expired, and
4961 the message is newer than the last try, let it through. */
4962
4963 else
4964 {
4965 if ( !host->address
4966 || host->status != hstatus_unusable_expired
4967 || host->last_try > received_time.tv_sec)
4968 continue;
4969 DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
4970 host->name, host->address, pistring);
4971 host_is_expired = TRUE;
4972 }
4973
4974 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4975 it remains TRUE only if all hosts are expired and none are actually tried.
4976 */
4977
4978 expired = FALSE;
4979
4980 /* If this host is listed as one to which access must be serialized,
4981 see if another Exim process has a connection to it, and if so, skip
4982 this host. If not, update the database to record our connection to it
4983 and remember this for later deletion. Do not do any of this if we are
4984 sending the message down a pre-existing connection. */
4985
4986 if ( !continue_hostname
4987 && verify_check_given_host(CUSS &ob->serialize_hosts, host) == OK)
4988 {
4989 serialize_key = string_sprintf("host-serialize-%s", host->name);
4990 if (!enq_start(serialize_key, 1))
4991 {
4992 DEBUG(D_transport)
4993 debug_printf("skipping host %s because another Exim process "
4994 "is connected to it\n", host->name);
4995 hosts_serial++;
4996 continue;
4997 }
4998 }
4999
5000 /* OK, we have an IP address that is not waiting for its retry time to
5001 arrive (it might be expired) OR (second time round the loop) we have an
5002 expired host that hasn't been tried since the message arrived. Have a go
5003 at delivering the message to it. First prepare the addresses by flushing
5004 out the result of previous attempts, and finding the first address that
5005 is still to be delivered. */
5006
5007 first_addr = prepare_addresses(addrlist, host);
5008
5009 DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5010 message_id, host->name, host->address, addrlist->address,
5011 addrlist->next ? ", ..." : "");
5012
5013 set_process_info("delivering %s to %s [%s] (%s%s)",
5014 message_id, host->name, host->address, addrlist->address,
5015 addrlist->next ? ", ..." : "");
5016
5017 /* This is not for real; don't do the delivery. If there are
5018 any remaining hosts, list them. */
5019
5020 if (f.dont_deliver)
5021 {
5022 host_item *host2;
5023 set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
5024 for (addr = addrlist; addr; addr = addr->next)
5025 {
5026 addr->host_used = host;
5027 addr->special_action = '*';
5028 addr->message = US"delivery bypassed by -N option";
5029 }
5030 DEBUG(D_transport)
5031 {
5032 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5033 "*** host and remaining hosts:\n", tblock->name);
5034 for (host2 = host; host2; host2 = host2->next)
5035 debug_printf(" %s [%s]\n", host2->name,
5036 host2->address ? host2->address : US"unset");
5037 }
5038 rc = OK;
5039 }
5040
5041 /* This is for real. If the host is expired, we don't count it for
5042 hosts_max_retry. This ensures that all hosts must expire before an address
5043 is timed out, unless hosts_max_try_hardlimit (which protects against
5044 lunatic DNS configurations) is reached.
5045
5046 If the host is not expired and we are about to hit the hosts_max_retry
5047 limit, check to see if there is a subsequent hosts with a different MX
5048 value. If so, make that the next host, and don't count this one. This is a
5049 heuristic to make sure that different MXs do get tried. With a normal kind
5050 of retry rule, they would get tried anyway when the earlier hosts were
5051 delayed, but if the domain has a "retry every time" type of rule - as is
5052 often used for the the very large ISPs, that won't happen. */
5053
5054 else
5055 {
5056 host_item * thost;
5057 /* Make a copy of the host if it is local to this invocation
5058 of the transport. */
5059
5060 if (expanded_hosts)
5061 {
5062 thost = store_get(sizeof(host_item));
5063 *thost = *host;
5064 thost->name = string_copy(host->name);
5065 thost->address = string_copy(host->address);
5066 }
5067 else
5068 thost = host;
5069
5070 if (!host_is_expired && ++unexpired_hosts_tried >= ob->hosts_max_try)
5071 {
5072 host_item *h;
5073 DEBUG(D_transport)
5074 debug_printf("hosts_max_try limit reached with this host\n");
5075 for (h = host; h; h = h->next) if (h->mx != host->mx)
5076 {
5077 nexthost = h;
5078 unexpired_hosts_tried--;
5079 DEBUG(D_transport) debug_printf("however, a higher MX host exists "
5080 "and will be tried\n");
5081 break;
5082 }
5083 }
5084
5085 /* Attempt the delivery. */
5086
5087 total_hosts_tried++;
5088 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5089 &message_defer, FALSE);
5090
5091 /* Yield is one of:
5092 OK => connection made, each address contains its result;
5093 message_defer is set for message-specific defers (when all
5094 recipients are marked defer)
5095 DEFER => there was a non-message-specific delivery problem;
5096 ERROR => there was a problem setting up the arguments for a filter,
5097 or there was a problem with expanding added headers
5098 */
5099
5100 /* If the result is not OK, there was a non-message-specific problem.
5101 If the result is DEFER, we need to write to the logs saying what happened
5102 for this particular host, except in the case of authentication and TLS
5103 failures, where the log has already been written. If all hosts defer a
5104 general message is written at the end. */
5105
5106 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
5107 && first_addr->basic_errno != ERRNO_TLSFAILURE)
5108 write_logs(host, first_addr->message, first_addr->basic_errno);
5109
5110 #ifndef DISABLE_EVENT
5111 if (rc == DEFER)
5112 deferred_event_raise(first_addr, host);
5113 #endif
5114
5115 /* If STARTTLS was accepted, but there was a failure in setting up the
5116 TLS session (usually a certificate screwup), and the host is not in
5117 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5118 TLS forcibly turned off. We have to start from scratch with a new SMTP
5119 connection. That's why the retry is done from here, not from within
5120 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5121 session, so the in-clear transmission after those errors, if permitted,
5122 happens inside smtp_deliver().] */
5123
5124 #ifdef SUPPORT_TLS
5125 if ( rc == DEFER
5126 && first_addr->basic_errno == ERRNO_TLSFAILURE
5127 && ob->tls_tempfail_tryclear
5128 && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
5129 )
5130 {
5131 log_write(0, LOG_MAIN,
5132 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5133 first_addr->message, host->name, host->address);
5134 first_addr = prepare_addresses(addrlist, host);
5135 rc = smtp_deliver(addrlist, thost, host_af, defport, interface, tblock,
5136 &message_defer, TRUE);
5137 if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL)
5138 write_logs(host, first_addr->message, first_addr->basic_errno);
5139 # ifndef DISABLE_EVENT
5140 if (rc == DEFER)
5141 deferred_event_raise(first_addr, host);
5142 # endif
5143 }
5144 #endif /*SUPPORT_TLS*/
5145 }
5146
5147 /* Delivery attempt finished */
5148
5149 rs = rc == OK ? US"OK"
5150 : rc == DEFER ? US"DEFER"
5151 : rc == ERROR ? US"ERROR"
5152 : US"?";
5153
5154 set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
5155 message_id, host->name, host->address, addrlist->address,
5156 addrlist->next ? " (& others)" : "", rs);
5157
5158 /* Release serialization if set up */
5159
5160 if (serialize_key) enq_end(serialize_key);
5161
5162 /* If the result is DEFER, or if a host retry record is known to exist, we
5163 need to add an item to the retry chain for updating the retry database
5164 at the end of delivery. We only need to add the item to the top address,
5165 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5166 for any other delivery attempts using the same address. (It is copied into
5167 the unusable tree at the outer level, so even if different address blocks
5168 contain the same address, it still won't get tried again.) */
5169
5170 if (rc == DEFER || retry_host_key)
5171 {
5172 int delete_flag = rc != DEFER ? rf_delete : 0;
5173 if (!retry_host_key)
5174 {
5175 BOOL incl_ip;
5176 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5177 US"retry_include_ip_address", ob->retry_include_ip_address,
5178 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5179 incl_ip = TRUE; /* error; use most-specific retry record */
5180
5181 retry_host_key = incl_ip
5182 ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
5183 : string_sprintf("T:%S%s", host->name, pistring);
5184 }
5185
5186 /* If a delivery of another message over an existing SMTP connection
5187 yields DEFER, we do NOT set up retry data for the host. This covers the
5188 case when there are delays in routing the addresses in the second message
5189 that are so long that the server times out. This is alleviated by not
5190 routing addresses that previously had routing defers when handling an
5191 existing connection, but even so, this case may occur (e.g. if a
5192 previously happily routed address starts giving routing defers). If the
5193 host is genuinely down, another non-continued message delivery will
5194 notice it soon enough. */
5195
5196 if (delete_flag != 0 || !continue_hostname)
5197 retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
5198
5199 /* We may have tried an expired host, if its retry time has come; ensure
5200 the status reflects the expiry for the benefit of any other addresses. */
5201
5202 if (rc == DEFER)
5203 {
5204 host->status = host_is_expired
5205 ? hstatus_unusable_expired : hstatus_unusable;
5206 host->why = hwhy_deferred;
5207 }
5208 }
5209
5210 /* If message_defer is set (host was OK, but every recipient got deferred
5211 because of some message-specific problem), or if that had happened
5212 previously so that a message retry key exists, add an appropriate item
5213 to the retry chain. Note that if there was a message defer but now there is
5214 a host defer, the message defer record gets deleted. That seems perfectly
5215 reasonable. Also, stop the message from being remembered as waiting
5216 for specific hosts. */
5217
5218 if (message_defer || retry_message_key)
5219 {
5220 int delete_flag = message_defer ? 0 : rf_delete;
5221 if (!retry_message_key)
5222 {
5223 BOOL incl_ip;
5224 if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
5225 US"retry_include_ip_address", ob->retry_include_ip_address,
5226 ob->expand_retry_include_ip_address, &incl_ip) != OK)
5227 incl_ip = TRUE; /* error; use most-specific retry record */
5228
5229 retry_message_key = incl_ip
5230 ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
5231 message_id)
5232 : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
5233 }
5234 retry_add_item(addrlist, retry_message_key,
5235 rf_message | rf_host | delete_flag);
5236 update_waiting = FALSE;
5237 }
5238
5239 /* Any return other than DEFER (that is, OK or ERROR) means that the
5240 addresses have got their final statuses filled in for this host. In the OK
5241 case, see if any of them are deferred. */
5242
5243 if (rc == OK)
5244 for (addr = addrlist; addr; addr = addr->next)
5245 if (addr->transport_return == DEFER)
5246 {
5247 some_deferred = TRUE;
5248 break;
5249 }
5250
5251 /* If no addresses deferred or the result was ERROR, return. We do this for
5252 ERROR because a failing filter set-up or add_headers expansion is likely to
5253 fail for any host we try. */
5254
5255 if (rc == ERROR || (rc == OK && !some_deferred))
5256 {
5257 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5258 return TRUE; /* Each address has its status */
5259 }
5260
5261 /* If the result was DEFER or some individual addresses deferred, let
5262 the loop run to try other hosts with the deferred addresses, except for the
5263 case when we were trying to deliver down an existing channel and failed.
5264 Don't try any other hosts in this case. */
5265
5266 if (continue_hostname) break;
5267
5268 /* If the whole delivery, or some individual addresses, were deferred and
5269 there are more hosts that could be tried, do not count this host towards
5270 the hosts_max_try limit if the age of the message is greater than the
5271 maximum retry time for this host. This means we may try try all hosts,
5272 ignoring the limit, when messages have been around for some time. This is
5273 important because if we don't try all hosts, the address will never time
5274 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5275
5276 if ((rc == DEFER || some_deferred) && nexthost)
5277 {
5278 BOOL timedout;
5279 retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
5280
5281 if (retry && retry->rules)
5282 {
5283 retry_rule *last_rule;
5284 for (last_rule = retry->rules;
5285 last_rule->next;
5286 last_rule = last_rule->next);
5287 timedout = time(NULL) - received_time.tv_sec > last_rule->timeout;
5288 }
5289 else timedout = TRUE; /* No rule => timed out */
5290
5291 if (timedout)
5292 {
5293 unexpired_hosts_tried--;
5294 DEBUG(D_transport) debug_printf("temporary delivery error(s) override "
5295 "hosts_max_try (message older than host's retry time)\n");
5296 }
5297 }
5298 if (f.running_in_test_harness) millisleep(500); /* let server debug out */
5299 } /* End of loop for trying multiple hosts. */
5300
5301 /* If we failed to find a matching host in the list, for an already-open
5302 connection, just close it and start over with the list. This can happen
5303 for routing that changes from run to run, or big multi-IP sites with
5304 round-robin DNS. */
5305
5306 if (continue_hostname && !continue_host_tried)
5307 {
5308 int fd = cutthrough.cctx.sock >= 0 ? cutthrough.cctx.sock : 0;
5309
5310 DEBUG(D_transport) debug_printf("no hosts match already-open connection\n");
5311 #ifdef SUPPORT_TLS
5312 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5313 transport */
5314 /*XXX doublecheck that! */
5315
5316 if (cutthrough.cctx.sock >= 0 && cutthrough.is_tls)
5317 {
5318 (void) tls_write(cutthrough.cctx.tls_ctx, US"QUIT\r\n", 6, FALSE);
5319 tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
5320 cutthrough.cctx.tls_ctx = NULL;
5321 cutthrough.is_tls = FALSE;
5322 }
5323 else
5324 #else
5325 (void) write(fd, US"QUIT\r\n", 6);
5326 #endif
5327 (void) close(fd);
5328 cutthrough.cctx.sock = -1;
5329 continue_hostname = NULL;
5330 goto retry_non_continued;
5331 }
5332
5333 /* This is the end of the loop that repeats iff expired is TRUE and
5334 ob->delay_after_cutoff is FALSE. The second time round we will
5335 try those hosts that haven't been tried since the message arrived. */
5336
5337 DEBUG(D_transport)
5338 {
5339 debug_printf("all IP addresses skipped or deferred at least one address\n");
5340 if (expired && !ob->delay_after_cutoff && cutoff_retry == 0)
5341 debug_printf("retrying IP addresses not tried since message arrived\n");
5342 }
5343 }
5344
5345
5346 /* Get here if all IP addresses are skipped or defer at least one address. In
5347 MUA wrapper mode, this will happen only for connection or other non-message-
5348 specific failures. Force the delivery status for all addresses to FAIL. */
5349
5350 if (mua_wrapper)
5351 {
5352 for (addr = addrlist; addr; addr = addr->next)
5353 addr->transport_return = FAIL;
5354 goto END_TRANSPORT;
5355 }
5356
5357 /* In the normal, non-wrapper case, add a standard message to each deferred
5358 address if there hasn't been an error, that is, if it hasn't actually been
5359 tried this time. The variable "expired" will be FALSE if any deliveries were
5360 actually tried, or if there was at least one host that was not expired. That
5361 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5362 a delivery has been tried, an error code will be set, and the failing of the
5363 message is handled by the retry code later.
5364
5365 If queue_smtp is set, or this transport was called to send a subsequent message
5366 down an existing TCP/IP connection, and something caused the host not to be
5367 found, we end up here, but can detect these cases and handle them specially. */
5368
5369 for (addr = addrlist; addr; addr = addr->next)
5370 {
5371 /* If host is not NULL, it means that we stopped processing the host list
5372 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5373 means we need to behave as if some hosts were skipped because their retry
5374 time had not come. Specifically, this prevents the address from timing out.
5375 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5376 hosts were tried. */
5377
5378 if (host)
5379 if (total_hosts_tried >= ob->hosts_max_try_hardlimit)
5380 {
5381 DEBUG(D_transport)
5382 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5383 "hosts were tried\n");
5384 }
5385 else
5386 {
5387 DEBUG(D_transport)
5388 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5389 setflag(addr, af_retry_skipped);
5390 }
5391
5392 if (f.queue_smtp) /* no deliveries attempted */
5393 {
5394 addr->transport_return = DEFER;
5395 addr->basic_errno = 0;
5396 addr->message = US"SMTP delivery explicitly queued";
5397 }
5398
5399 else if ( addr->transport_return == DEFER
5400 && (addr->basic_errno == ERRNO_UNKNOWNERROR || addr->basic_errno == 0)
5401 && !addr->message
5402 )
5403 {
5404 addr->basic_errno = ERRNO_HRETRY;
5405 if (continue_hostname)
5406 addr->message = US"no host found for existing SMTP connection";
5407 else if (expired)
5408 {
5409 setflag(addr, af_pass_message); /* This is not a security risk */
5410 addr->message = string_sprintf(
5411 "all hosts%s have been failing for a long time %s",
5412 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"",
5413 ob->delay_after_cutoff
5414 ? US"(and retry time not reached)"
5415 : US"and were last tried after this message arrived");
5416
5417 /* If we are already using fallback hosts, or there are no fallback hosts
5418 defined, convert the result to FAIL to cause a bounce. */
5419
5420 if (addr->host_list == addr->fallback_hosts || !addr->fallback_hosts)
5421 addr->transport_return = FAIL;
5422 }
5423 else
5424 {
5425 const char * s;
5426 if (hosts_retry == hosts_total)
5427 s = "retry time not reached for any host%s";
5428 else if (hosts_fail == hosts_total)
5429 s = "all host address lookups%s failed permanently";
5430 else if (hosts_defer == hosts_total)
5431 s = "all host address lookups%s failed temporarily";
5432 else if (hosts_serial == hosts_total)
5433 s = "connection limit reached for all hosts%s";
5434 else if (hosts_fail+hosts_defer == hosts_total)
5435 s = "all host address lookups%s failed";
5436 else
5437 s = "some host address lookups failed and retry time "
5438 "not reached for other hosts or connection limit reached%s";
5439
5440 addr->message = string_sprintf(s,
5441 addr->domain ? string_sprintf(" for '%s'", addr->domain) : US"");
5442 }
5443 }
5444 }
5445
5446 /* Update the database which keeps information about which messages are waiting
5447 for which hosts to become available. For some message-specific errors, the
5448 update_waiting flag is turned off because we don't want follow-on deliveries in
5449 those cases. If this transport instance is explicitly limited to one message
5450 per connection then follow-on deliveries are not possible and there's no need
5451 to create/update the per-transport wait-<transport_name> database. */
5452
5453 if (update_waiting && tblock->connection_max_messages != 1)
5454 transport_update_waiting(hostlist, tblock->name);
5455
5456 END_TRANSPORT:
5457
5458 DEBUG(D_transport) debug_printf("Leaving %s transport\n", tblock->name);
5459
5460 return TRUE; /* Each address has its status */
5461 }
5462
5463 #endif /*!MACRO_PREDEF*/
5464 /* vi: aw ai sw=2
5465 */
5466 /* End of transport/smtp.c */
Unnamed repository; edit this file 'description' to name the repository.