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