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