Performance timing measurements
[exim.git] / src / src / transports / smtp.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #include "../exim.h"
9 #include "smtp.h"
10
11 #if defined(SUPPORT_DANE) && defined(DISABLE_TLS)
12 # error TLS is required for DANE
13 #endif
14
15
16 /* Options specific to the smtp transport. This transport also supports LMTP
17 over TCP/IP. The options must be in alphabetic order (note that "_" comes
18 before the lower case letters). Some live in the transport_instance block so as
19 to be publicly visible; these are flagged with opt_public. */
20
21 optionlist smtp_transport_options[] = {
22 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
23 (void *)offsetof(transport_instance, expand_multi_domain) },
24 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
25 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
26
27 { "address_retry_include_sender", opt_bool,
28 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
29 { "allow_localhost", opt_bool,
30 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
31 #ifdef EXPERIMENTAL_ARC
32 { "arc_sign", opt_stringptr,
33 (void *)offsetof(smtp_transport_options_block, arc_sign) },
34 #endif
35 { "authenticated_sender", opt_stringptr,
36 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
37 { "authenticated_sender_force", opt_bool,
38 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
39 { "command_timeout", opt_time,
40 (void *)offsetof(smtp_transport_options_block, command_timeout) },
41 { "connect_timeout", opt_time,
42 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
43 { "connection_max_messages", opt_int | opt_public,
44 (void *)offsetof(transport_instance, connection_max_messages) },
45 # ifdef SUPPORT_DANE
46 { "dane_require_tls_ciphers", opt_stringptr,
47 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
48 # endif
49 { "data_timeout", opt_time,
50 (void *)offsetof(smtp_transport_options_block, data_timeout) },
51 { "delay_after_cutoff", opt_bool,
52 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
53 #ifndef DISABLE_DKIM
54 { "dkim_canon", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
56 { "dkim_domain", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
58 { "dkim_hash", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
60 { "dkim_identity", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
62 { "dkim_private_key", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
64 { "dkim_selector", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
66 { "dkim_sign_headers", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
68 { "dkim_strict", opt_stringptr,
69 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
70 { "dkim_timestamps", opt_stringptr,
71 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
72 #endif
73 { "dns_qualify_single", opt_bool,
74 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
75 { "dns_search_parents", opt_bool,
76 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
77 { "dnssec_request_domains", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
79 { "dnssec_require_domains", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
81 { "dscp", opt_stringptr,
82 (void *)offsetof(smtp_transport_options_block, dscp) },
83 { "fallback_hosts", opt_stringptr,
84 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
85 { "final_timeout", opt_time,
86 (void *)offsetof(smtp_transport_options_block, final_timeout) },
87 { "gethostbyname", opt_bool,
88 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
89 { "helo_data", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, helo_data) },
91 { "hosts", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts) },
93 { "hosts_avoid_esmtp", opt_stringptr,
94 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
95 { "hosts_avoid_pipelining", opt_stringptr,
96 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
97 #ifndef DISABLE_TLS
98 { "hosts_avoid_tls", opt_stringptr,
99 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
100 #endif
101 { "hosts_max_try", opt_int,
102 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
103 { "hosts_max_try_hardlimit", opt_int,
104 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
105 #ifndef DISABLE_TLS
106 { "hosts_nopass_tls", opt_stringptr,
107 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
108 { "hosts_noproxy_tls", opt_stringptr,
109 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
110 #endif
111 { "hosts_override", opt_bool,
112 (void *)offsetof(smtp_transport_options_block, hosts_override) },
113 #ifdef SUPPORT_PIPE_CONNECT
114 { "hosts_pipe_connect", opt_stringptr,
115 (void *)offsetof(smtp_transport_options_block, hosts_pipe_connect) },
116 #endif
117 { "hosts_randomize", opt_bool,
118 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
119 #if !defined(DISABLE_TLS) && !defined(DISABLE_OCSP)
120 { "hosts_request_ocsp", opt_stringptr,
121 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
122 #endif
123 { "hosts_require_auth", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
125 #ifndef DISABLE_TLS
126 # ifdef SUPPORT_DANE
127 { "hosts_require_dane", opt_stringptr,
128 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
129 # endif
130 # ifndef DISABLE_OCSP
131 { "hosts_require_ocsp", opt_stringptr,
132 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
133 # endif
134 { "hosts_require_tls", opt_stringptr,
135 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
136 #endif
137 { "hosts_try_auth", opt_stringptr,
138 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
139 { "hosts_try_chunking", opt_stringptr,
140 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
141 #ifdef SUPPORT_DANE
142 { "hosts_try_dane", opt_stringptr,
143 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
144 #endif
145 { "hosts_try_fastopen", opt_stringptr,
146 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
147 #ifndef DISABLE_PRDR
148 { "hosts_try_prdr", opt_stringptr,
149 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
150 #endif
151 #ifndef DISABLE_TLS
152 { "hosts_verify_avoid_tls", opt_stringptr,
153 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
154 #endif
155 { "interface", opt_stringptr,
156 (void *)offsetof(smtp_transport_options_block, interface) },
157 { "keepalive", opt_bool,
158 (void *)offsetof(smtp_transport_options_block, keepalive) },
159 { "lmtp_ignore_quota", opt_bool,
160 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
161 { "max_rcpt", opt_int | opt_public,
162 (void *)offsetof(transport_instance, max_addresses) },
163 { "multi_domain", opt_expand_bool | opt_public,
164 (void *)offsetof(transport_instance, multi_domain) },
165 { "port", opt_stringptr,
166 (void *)offsetof(smtp_transport_options_block, port) },
167 { "protocol", opt_stringptr,
168 (void *)offsetof(smtp_transport_options_block, protocol) },
169 { "retry_include_ip_address", opt_expand_bool,
170 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
171 { "serialize_hosts", opt_stringptr,
172 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
173 { "size_addition", opt_int,
174 (void *)offsetof(smtp_transport_options_block, size_addition) },
175 #ifdef SUPPORT_SOCKS
176 { "socks_proxy", opt_stringptr,
177 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
178 #endif
179 #ifndef DISABLE_TLS
180 { "tls_certificate", opt_stringptr,
181 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
182 { "tls_crl", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_crl) },
184 { "tls_dh_min_bits", opt_int,
185 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
186 { "tls_privatekey", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
188 { "tls_require_ciphers", opt_stringptr,
189 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
190 # ifdef EXPERIMENTAL_TLS_RESUME
191 { "tls_resumption_hosts", opt_stringptr,
192 (void *)offsetof(smtp_transport_options_block, tls_resumption_hosts) },
193 # endif
194 { "tls_sni", opt_stringptr,
195 (void *)offsetof(smtp_transport_options_block, tls_sni) },
196 { "tls_tempfail_tryclear", opt_bool,
197 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
198 { "tls_try_verify_hosts", opt_stringptr,
199 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
200 { "tls_verify_cert_hostnames", opt_stringptr,
201 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
202 { "tls_verify_certificates", opt_stringptr,
203 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
204 { "tls_verify_hosts", opt_stringptr,
205 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
206 #endif
207 #ifdef SUPPORT_I18N
208 { "utf8_downconvert", opt_stringptr,
209 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
210 #endif
211 };
212
213 /* Size of the options list. An extern variable has to be used so that its
214 address can appear in the tables drtables.c. */
215
216 int smtp_transport_options_count = nelem(smtp_transport_options);
217
218
219 #ifdef MACRO_PREDEF
220
221 /* Dummy values */
222 smtp_transport_options_block smtp_transport_option_defaults = {0};
223 void smtp_transport_init(transport_instance *tblock) {}
224 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
225 void smtp_transport_closedown(transport_instance *tblock) {}
226
227 #else /*!MACRO_PREDEF*/
228
229
230 /* Default private options block for the smtp transport. */
231
232 smtp_transport_options_block smtp_transport_option_defaults = {
233 .hosts = NULL,
234 .fallback_hosts = NULL,
235 .hostlist = NULL,
236 .fallback_hostlist = NULL,
237 .helo_data = US"$primary_hostname",
238 .interface = NULL,
239 .port = NULL,
240 .protocol = US"smtp",
241 .dscp = NULL,
242 .serialize_hosts = NULL,
243 .hosts_try_auth = NULL,
244 .hosts_require_auth = NULL,
245 .hosts_try_chunking = US"*",
246 #ifdef SUPPORT_DANE
247 .hosts_try_dane = US"*",
248 .hosts_require_dane = NULL,
249 .dane_require_tls_ciphers = NULL,
250 #endif
251 .hosts_try_fastopen = US"*",
252 #ifndef DISABLE_PRDR
253 .hosts_try_prdr = US"*",
254 #endif
255 #ifndef DISABLE_OCSP
256 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
257 .hosts_require_ocsp = NULL,
258 #endif
259 .hosts_require_tls = NULL,
260 .hosts_avoid_tls = NULL,
261 .hosts_verify_avoid_tls = NULL,
262 .hosts_avoid_pipelining = NULL,
263 #ifdef SUPPORT_PIPE_CONNECT
264 .hosts_pipe_connect = NULL,
265 #endif
266 .hosts_avoid_esmtp = NULL,
267 #ifndef DISABLE_TLS
268 .hosts_nopass_tls = NULL,
269 .hosts_noproxy_tls = NULL,
270 #endif
271 .command_timeout = 5*60,
272 .connect_timeout = 5*60,
273 .data_timeout = 5*60,
274 .final_timeout = 10*60,
275 .size_addition = 1024,
276 .hosts_max_try = 5,
277 .hosts_max_try_hardlimit = 50,
278 .address_retry_include_sender = TRUE,
279 .allow_localhost = FALSE,
280 .authenticated_sender_force = FALSE,
281 .gethostbyname = FALSE,
282 .dns_qualify_single = TRUE,
283 .dns_search_parents = FALSE,
284 .dnssec = { .request=NULL, .require=NULL },
285 .delay_after_cutoff = TRUE,
286 .hosts_override = FALSE,
287 .hosts_randomize = FALSE,
288 .keepalive = TRUE,
289 .lmtp_ignore_quota = FALSE,
290 .expand_retry_include_ip_address = NULL,
291 .retry_include_ip_address = TRUE,
292 #ifdef SUPPORT_SOCKS
293 .socks_proxy = NULL,
294 #endif
295 #ifndef DISABLE_TLS
296 .tls_certificate = NULL,
297 .tls_crl = NULL,
298 .tls_privatekey = NULL,
299 .tls_require_ciphers = NULL,
300 .tls_sni = NULL,
301 .tls_verify_certificates = US"system",
302 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
303 .tls_tempfail_tryclear = TRUE,
304 # ifdef EXPERIMENTAL_TLS_RESUME
305 .tls_resumption_hosts = NULL,
306 # endif
307 .tls_verify_hosts = NULL,
308 .tls_try_verify_hosts = US"*",
309 .tls_verify_cert_hostnames = US"*",
310 #endif
311 #ifdef SUPPORT_I18N
312 .utf8_downconvert = NULL,
313 #endif
314 #ifndef DISABLE_DKIM
315 .dkim =
316 {.dkim_domain = NULL,
317 .dkim_identity = NULL,
318 .dkim_private_key = NULL,
319 .dkim_selector = NULL,
320 .dkim_canon = NULL,
321 .dkim_sign_headers = NULL,
322 .dkim_strict = NULL,
323 .dkim_hash = US"sha256",
324 .dkim_timestamps = NULL,
325 .dot_stuffed = FALSE,
326 .force_bodyhash = FALSE,
327 # ifdef EXPERIMENTAL_ARC
328 .arc_signspec = NULL,
329 # endif
330 },
331 # ifdef EXPERIMENTAL_ARC
332 .arc_sign = NULL,
333 # endif
334 #endif
335 };
336
337 /* some DSN flags for use later */
338
339 static int rf_list[] = {rf_notify_never, rf_notify_success,
340 rf_notify_failure, rf_notify_delay };
341
342 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
343
344
345
346 /* Local statics */
347
348 static uschar *smtp_command; /* Points to last cmd for error messages */
349 static uschar *mail_command; /* Points to MAIL cmd for error messages */
350 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
351 static BOOL update_waiting; /* TRUE to update the "wait" database */
352
353 /*XXX move to smtp_context */
354 static BOOL pipelining_active; /* current transaction is in pipe mode */
355
356
357 static unsigned ehlo_response(uschar * buf, unsigned checks);
358
359
360 /*************************************************
361 * Setup entry point *
362 *************************************************/
363
364 /* This function is called when the transport is about to be used,
365 but before running it in a sub-process. It is used for two things:
366
367 (1) To set the fallback host list in addresses, when delivering.
368 (2) To pass back the interface, port, protocol, and other options, for use
369 during callout verification.
370
371 Arguments:
372 tblock pointer to the transport instance block
373 addrlist list of addresses about to be transported
374 tf if not NULL, pointer to block in which to return options
375 uid the uid that will be set (not used)
376 gid the gid that will be set (not used)
377 errmsg place for error message (not used)
378
379 Returns: OK always (FAIL, DEFER not used)
380 */
381
382 static int
383 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
384 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
385 {
386 smtp_transport_options_block *ob = SOB tblock->options_block;
387
388 errmsg = errmsg; /* Keep picky compilers happy */
389 uid = uid;
390 gid = gid;
391
392 /* Pass back options if required. This interface is getting very messy. */
393
394 if (tf)
395 {
396 tf->interface = ob->interface;
397 tf->port = ob->port;
398 tf->protocol = ob->protocol;
399 tf->hosts = ob->hosts;
400 tf->hosts_override = ob->hosts_override;
401 tf->hosts_randomize = ob->hosts_randomize;
402 tf->gethostbyname = ob->gethostbyname;
403 tf->qualify_single = ob->dns_qualify_single;
404 tf->search_parents = ob->dns_search_parents;
405 tf->helo_data = ob->helo_data;
406 }
407
408 /* Set the fallback host list for all the addresses that don't have fallback
409 host lists, provided that the local host wasn't present in the original host
410 list. */
411
412 if (!testflag(addrlist, af_local_host_removed))
413 for (; addrlist; addrlist = addrlist->next)
414 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
415
416 return OK;
417 }
418
419
420
421 /*************************************************
422 * Initialization entry point *
423 *************************************************/
424
425 /* Called for each instance, after its options have been read, to
426 enable consistency checks to be done, or anything else that needs
427 to be set up.
428
429 Argument: pointer to the transport instance block
430 Returns: nothing
431 */
432
433 void
434 smtp_transport_init(transport_instance *tblock)
435 {
436 smtp_transport_options_block *ob = SOB tblock->options_block;
437
438 /* Retry_use_local_part defaults FALSE if unset */
439
440 if (tblock->retry_use_local_part == TRUE_UNSET)
441 tblock->retry_use_local_part = FALSE;
442
443 /* Set the default port according to the protocol */
444
445 if (!ob->port)
446 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
447 ? US"lmtp"
448 : strcmpic(ob->protocol, US"smtps") == 0
449 ? US"smtps" : US"smtp";
450
451 /* Set up the setup entry point, to be called before subprocesses for this
452 transport. */
453
454 tblock->setup = smtp_transport_setup;
455
456 /* Complain if any of the timeouts are zero. */
457
458 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
459 ob->final_timeout <= 0)
460 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
461 "command, data, or final timeout value is zero for %s transport",
462 tblock->name);
463
464 /* If hosts_override is set and there are local hosts, set the global
465 flag that stops verify from showing router hosts. */
466
467 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
468
469 /* If there are any fallback hosts listed, build a chain of host items
470 for them, but do not do any lookups at this time. */
471
472 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
473 }
474
475
476
477
478
479 /*************************************************
480 * Set delivery info into all active addresses *
481 *************************************************/
482
483 /* Only addresses whose status is >= PENDING are relevant. A lesser
484 status means that an address is not currently being processed.
485
486 Arguments:
487 addrlist points to a chain of addresses
488 errno_value to put in each address's errno field
489 msg to put in each address's message field
490 rc to put in each address's transport_return field
491 pass_message if TRUE, set the "pass message" flag in the address
492 host if set, mark addrs as having used this host
493 smtp_greeting from peer
494 helo_response from peer
495
496 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
497 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
498 this particular type of timeout.
499
500 Returns: nothing
501 */
502
503 static void
504 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
505 BOOL pass_message, host_item * host
506 #ifdef EXPERIMENTAL_DSN_INFO
507 , const uschar * smtp_greeting, const uschar * helo_response
508 #endif
509 )
510 {
511 int orvalue = 0;
512 if (errno_value == ERRNO_CONNECTTIMEOUT)
513 {
514 errno_value = ETIMEDOUT;
515 orvalue = RTEF_CTOUT;
516 }
517 for (address_item * addr = addrlist; addr; addr = addr->next)
518 if (addr->transport_return >= PENDING)
519 {
520 addr->basic_errno = errno_value;
521 addr->more_errno |= orvalue;
522 if (msg)
523 {
524 addr->message = msg;
525 if (pass_message) setflag(addr, af_pass_message);
526 }
527 addr->transport_return = rc;
528 if (host)
529 {
530 addr->host_used = host;
531 #ifdef EXPERIMENTAL_DSN_INFO
532 if (smtp_greeting)
533 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
534 addr->smtp_greeting = smtp_greeting;
535
536 if (helo_response)
537 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
538 addr->helo_response = helo_response;
539 #endif
540 }
541 }
542 }
543
544 static void
545 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
546 BOOL pass_message)
547 {
548 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
549 #ifdef EXPERIMENTAL_DSN_INFO
550 , NULL, NULL
551 #endif
552 );
553 }
554
555
556 /*************************************************
557 * Check an SMTP response *
558 *************************************************/
559
560 /* This function is given an errno code and the SMTP response buffer
561 to analyse, together with the host identification for generating messages. It
562 sets an appropriate message and puts the first digit of the response code into
563 the yield variable. If no response was actually read, a suitable digit is
564 chosen.
565
566 Arguments:
567 host the current host, to get its name for messages
568 errno_value pointer to the errno value
569 more_errno from the top address for use with ERRNO_FILTER_FAIL
570 buffer the SMTP response buffer
571 yield where to put a one-digit SMTP response code
572 message where to put an error message
573 pass_message set TRUE if message is an SMTP response
574
575 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
576 */
577
578 static BOOL
579 check_response(host_item *host, int *errno_value, int more_errno,
580 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
581 {
582 uschar * pl = pipelining_active ? US"pipelined " : US"";
583 const uschar * s;
584
585 *yield = '4'; /* Default setting is to give a temporary error */
586
587 switch(*errno_value)
588 {
589 case ETIMEDOUT: /* Handle response timeout */
590 *message = US string_sprintf("SMTP timeout after %s%s",
591 pl, smtp_command);
592 if (transport_count > 0)
593 *message = US string_sprintf("%s (%d bytes written)", *message,
594 transport_count);
595 return FALSE;
596
597 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
598 s = string_printing(buffer);
599 while (isspace(*s)) s++;
600 *message = *s == 0
601 ? string_sprintf("Malformed SMTP reply (an empty line) "
602 "in response to %s%s", pl, smtp_command)
603 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
604 pl, smtp_command, s);
605 return FALSE;
606
607 case ERRNO_TLSFAILURE: /* Handle bad first read; can happen with
608 GnuTLS and TLS1.3 */
609 *message = US"bad first read from TLS conn";
610 return TRUE;
611
612 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
613 can't send QUIT as we mustn't end the DATA. */
614 *message = string_sprintf("transport filter process failed (%d)%s",
615 more_errno,
616 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
617 return FALSE;
618
619 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
620 can't send QUIT as we mustn't end the DATA. */
621 *message =
622 string_sprintf("failed to expand headers_add or headers_remove: %s",
623 expand_string_message);
624 return FALSE;
625
626 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
627 *message = US"failed to write a data block";
628 return FALSE;
629
630 #ifdef SUPPORT_I18N
631 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
632 *message = US"utf8 support required but not offered for forwarding";
633 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
634 return TRUE;
635 #endif
636 }
637
638 /* Handle error responses from the remote mailer. */
639
640 if (buffer[0] != 0)
641 {
642 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
643 "%s", pl, smtp_command, s = string_printing(buffer));
644 *pass_message = TRUE;
645 *yield = buffer[0];
646 return TRUE;
647 }
648
649 /* No data was read. If there is no errno, this must be the EOF (i.e.
650 connection closed) case, which causes deferral. An explicit connection reset
651 error has the same effect. Otherwise, put the host's identity in the message,
652 leaving the errno value to be interpreted as well. In all cases, we have to
653 assume the connection is now dead. */
654
655 if (*errno_value == 0 || *errno_value == ECONNRESET)
656 {
657 *errno_value = ERRNO_SMTPCLOSED;
658 *message = US string_sprintf("Remote host closed connection "
659 "in response to %s%s", pl, smtp_command);
660 }
661 else
662 *message = US string_sprintf("%s [%s]", host->name, host->address);
663
664 return FALSE;
665 }
666
667
668
669 /*************************************************
670 * Write error message to logs *
671 *************************************************/
672
673 /* This writes to the main log and to the message log.
674
675 Arguments:
676 host the current host
677 detail the current message (addr_item->message)
678 basic_errno the errno (addr_item->basic_errno)
679
680 Returns: nothing
681 */
682
683 static void
684 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
685 {
686 gstring * message = LOGGING(outgoing_port)
687 ? string_fmt_append(NULL, "H=%s [%s]:%d", host->name, host->address,
688 host->port == PORT_NONE ? 25 : host->port)
689 : string_fmt_append(NULL, "H=%s [%s]", host->name, host->address);
690
691 if (suffix)
692 {
693 message = string_fmt_append(message, ": %s", suffix);
694 if (basic_errno > 0)
695 message = string_fmt_append(message, ": %s", strerror(basic_errno));
696 }
697 else
698 message = string_fmt_append(message, " %s", exim_errstr(basic_errno));
699
700 log_write(0, LOG_MAIN, "%s", string_from_gstring(message));
701 deliver_msglog("%s %s\n", tod_stamp(tod_log), message->s);
702 }
703
704 static void
705 msglog_line(host_item * host, uschar * message)
706 {
707 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
708 host->name, host->address, message);
709 }
710
711
712
713 #ifndef DISABLE_EVENT
714 /*************************************************
715 * Post-defer action *
716 *************************************************/
717
718 /* This expands an arbitrary per-transport string.
719 It might, for example, be used to write to the database log.
720
721 Arguments:
722 addr the address item containing error information
723 host the current host
724
725 Returns: nothing
726 */
727
728 static void
729 deferred_event_raise(address_item *addr, host_item *host)
730 {
731 uschar * action = addr->transport->event_action;
732 const uschar * save_domain;
733 uschar * save_local;
734
735 if (!action)
736 return;
737
738 save_domain = deliver_domain;
739 save_local = deliver_localpart;
740
741 /*XXX would ip & port already be set up? */
742 deliver_host_address = string_copy(host->address);
743 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
744 event_defer_errno = addr->basic_errno;
745
746 router_name = addr->router->name;
747 transport_name = addr->transport->name;
748 deliver_domain = addr->domain;
749 deliver_localpart = addr->local_part;
750
751 (void) event_raise(action, US"msg:host:defer",
752 addr->message
753 ? addr->basic_errno > 0
754 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
755 : string_copy(addr->message)
756 : addr->basic_errno > 0
757 ? string_copy(US strerror(addr->basic_errno))
758 : NULL);
759
760 deliver_localpart = save_local;
761 deliver_domain = save_domain;
762 router_name = transport_name = NULL;
763 }
764 #endif
765
766 /*************************************************
767 * Reap SMTP specific responses *
768 *************************************************/
769 static int
770 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
771 int count)
772 {
773 uschar flushbuffer[4096];
774
775 while (count-- > 0)
776 {
777 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
778 '2', ob->command_timeout)
779 && (errno != 0 || flushbuffer[0] == 0))
780 break;
781 }
782 return count;
783 }
784
785
786 /* Return boolean success */
787
788 static BOOL
789 smtp_reap_banner(smtp_context * sx)
790 {
791 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
792 '2', (SOB sx->conn_args.ob)->command_timeout);
793 #ifdef EXPERIMENTAL_DSN_INFO
794 sx->smtp_greeting = string_copy(sx->buffer);
795 #endif
796 return good_response;
797 }
798
799 static BOOL
800 smtp_reap_ehlo(smtp_context * sx)
801 {
802 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
803 (SOB sx->conn_args.ob)->command_timeout))
804 {
805 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
806 {
807 #ifdef EXPERIMENTAL_DSN_INFO
808 sx->helo_response = string_copy(sx->buffer);
809 #endif
810 return FALSE;
811 }
812 sx->esmtp = FALSE;
813 }
814 #ifdef EXPERIMENTAL_DSN_INFO
815 sx->helo_response = string_copy(sx->buffer);
816 #endif
817 #ifndef DISABLE_EVENT
818 (void) event_raise(sx->conn_args.tblock->event_action,
819 US"smtp:ehlo", sx->buffer);
820 #endif
821 return TRUE;
822 }
823
824
825
826 #ifdef SUPPORT_PIPE_CONNECT
827 static uschar *
828 ehlo_cache_key(const smtp_context * sx)
829 {
830 host_item * host = sx->conn_args.host;
831 return Ustrchr(host->address, ':')
832 ? string_sprintf("[%s]:%d.EHLO", host->address,
833 host->port == PORT_NONE ? sx->port : host->port)
834 : string_sprintf("%s:%d.EHLO", host->address,
835 host->port == PORT_NONE ? sx->port : host->port);
836 }
837
838 static void
839 write_ehlo_cache_entry(const smtp_context * sx)
840 {
841 open_db dbblock, * dbm_file;
842
843 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
844 {
845 uschar * ehlo_resp_key = ehlo_cache_key(sx);
846 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
847
848 HDEBUG(D_transport) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
849 sx->ehlo_resp.cleartext_features, sx->ehlo_resp.cleartext_auths,
850 sx->ehlo_resp.crypted_features, sx->ehlo_resp.crypted_auths);
851
852 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
853 dbfn_close(dbm_file);
854 }
855 }
856
857 static void
858 invalidate_ehlo_cache_entry(smtp_context * sx)
859 {
860 open_db dbblock, * dbm_file;
861
862 if ( sx->early_pipe_active
863 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
864 {
865 uschar * ehlo_resp_key = ehlo_cache_key(sx);
866 dbfn_delete(dbm_file, ehlo_resp_key);
867 dbfn_close(dbm_file);
868 }
869 }
870
871 static BOOL
872 read_ehlo_cache_entry(smtp_context * sx)
873 {
874 open_db dbblock;
875 open_db * dbm_file;
876
877 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE, TRUE)))
878 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
879 else
880 {
881 uschar * ehlo_resp_key = ehlo_cache_key(sx);
882 dbdata_ehlo_resp * er;
883
884 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
885 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
886 else if (time(NULL) - er->time_stamp > retry_data_expire)
887 {
888 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
889 dbfn_close(dbm_file);
890 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE, TRUE)))
891 dbfn_delete(dbm_file, ehlo_resp_key);
892 }
893 else
894 {
895 sx->ehlo_resp = er->data;
896 dbfn_close(dbm_file);
897 DEBUG(D_transport) debug_printf(
898 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
899 er->data.cleartext_features, er->data.crypted_features);
900 return TRUE;
901 }
902 dbfn_close(dbm_file);
903 }
904 return FALSE;
905 }
906
907
908
909 /* Return an auths bitmap for the set of AUTH methods offered by the server
910 which match our authenticators. */
911
912 static unsigned short
913 study_ehlo_auths(smtp_context * sx)
914 {
915 uschar * names;
916 auth_instance * au;
917 uschar authnum;
918 unsigned short authbits = 0;
919
920 if (!sx->esmtp) return 0;
921 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
922 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
923 expand_nmax = -1; /* reset */
924 names = string_copyn(expand_nstring[1], expand_nlength[1]);
925
926 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
927 {
928 const uschar * list = names;
929 int sep = ' ';
930 uschar name[32];
931
932 while (string_nextinlist(&list, &sep, name, sizeof(name)))
933 if (strcmpic(au->public_name, name) == 0)
934 { authbits |= BIT(authnum); break; }
935 }
936
937 DEBUG(D_transport)
938 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
939 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
940
941 if (tls_out.active.sock >= 0)
942 sx->ehlo_resp.crypted_auths = authbits;
943 else
944 sx->ehlo_resp.cleartext_auths = authbits;
945 return authbits;
946 }
947
948
949
950
951 /* Wait for and check responses for early-pipelining.
952
953 Called from the lower-level smtp_read_response() function
954 used for general code that assume synchronisation, if context
955 flags indicate outstanding early-pipelining commands. Also
956 called fom sync_responses() which handles pipelined commands.
957
958 Arguments:
959 sx smtp connection context
960 countp number of outstanding responses, adjusted on return
961
962 Return:
963 OK all well
964 DEFER error on first read of TLS'd conn
965 FAIL SMTP error in response
966 */
967 int
968 smtp_reap_early_pipe(smtp_context * sx, int * countp)
969 {
970 BOOL pending_BANNER = sx->pending_BANNER;
971 BOOL pending_EHLO = sx->pending_EHLO;
972 int rc = FAIL;
973
974 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
975 sx->pending_EHLO = FALSE;
976
977 if (pending_BANNER)
978 {
979 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
980 (*countp)--;
981 if (!smtp_reap_banner(sx))
982 {
983 DEBUG(D_transport) debug_printf("bad banner\n");
984 if (tls_out.active.sock >= 0) rc = DEFER;
985 goto fail;
986 }
987 }
988
989 if (pending_EHLO)
990 {
991 unsigned peer_offered;
992 unsigned short authbits = 0, * ap;
993
994 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
995 (*countp)--;
996 if (!smtp_reap_ehlo(sx))
997 {
998 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
999 if (tls_out.active.sock >= 0) rc = DEFER;
1000 goto fail;
1001 }
1002
1003 /* Compare the actual EHLO response to the cached value we assumed;
1004 on difference, dump or rewrite the cache and arrange for a retry. */
1005
1006 ap = tls_out.active.sock < 0
1007 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
1008
1009 peer_offered = ehlo_response(sx->buffer,
1010 (tls_out.active.sock < 0 ? OPTION_TLS : 0)
1011 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
1012 | OPTION_UTF8 | OPTION_EARLY_PIPE
1013 );
1014 if ( peer_offered != sx->peer_offered
1015 || (authbits = study_ehlo_auths(sx)) != *ap)
1016 {
1017 HDEBUG(D_transport)
1018 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
1019 tls_out.active.sock < 0 ? "cleartext" : "crypted",
1020 sx->peer_offered, *ap, peer_offered, authbits);
1021 *(tls_out.active.sock < 0
1022 ? &sx->ehlo_resp.cleartext_features : &sx->ehlo_resp.crypted_features) = peer_offered;
1023 *ap = authbits;
1024 if (peer_offered & OPTION_EARLY_PIPE)
1025 write_ehlo_cache_entry(sx);
1026 else
1027 invalidate_ehlo_cache_entry(sx);
1028
1029 return OK; /* just carry on */
1030 }
1031 }
1032 return OK;
1033
1034 fail:
1035 invalidate_ehlo_cache_entry(sx);
1036 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1037 return rc;
1038 }
1039 #endif
1040
1041
1042 /*************************************************
1043 * Synchronize SMTP responses *
1044 *************************************************/
1045
1046 /* This function is called from smtp_deliver() to receive SMTP responses from
1047 the server, and match them up with the commands to which they relate. When
1048 PIPELINING is not in use, this function is called after every command, and is
1049 therefore somewhat over-engineered, but it is simpler to use a single scheme
1050 that works both with and without PIPELINING instead of having two separate sets
1051 of code.
1052
1053 The set of commands that are buffered up with pipelining may start with MAIL
1054 and may end with DATA; in between are RCPT commands that correspond to the
1055 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1056 etc.) are never buffered.
1057
1058 Errors after MAIL or DATA abort the whole process leaving the response in the
1059 buffer. After MAIL, pending responses are flushed, and the original command is
1060 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1061 permitted to reject some recipient addresses while accepting others. However
1062 certain errors clearly abort the whole process. Set the value in
1063 transport_return to PENDING_OK if the address is accepted. If there is a
1064 subsequent general error, it will get reset accordingly. If not, it will get
1065 converted to OK at the end.
1066
1067 Arguments:
1068 sx smtp connection context
1069 count the number of responses to read
1070 pending_DATA 0 if last command sent was not DATA
1071 +1 if previously had a good recipient
1072 -1 if not previously had a good recipient
1073
1074 Returns: 3 if at least one address had 2xx and one had 5xx
1075 2 if at least one address had 5xx but none had 2xx
1076 1 if at least one host had a 2xx response, but none had 5xx
1077 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1078 -1 timeout while reading RCPT response
1079 -2 I/O or other non-response error for RCPT
1080 -3 DATA or MAIL failed - errno and buffer set
1081 -4 banner or EHLO failed (early-pipelining)
1082 -5 banner or EHLO failed (early-pipelining, TLS)
1083 */
1084
1085 static int
1086 sync_responses(smtp_context * sx, int count, int pending_DATA)
1087 {
1088 address_item * addr = sx->sync_addr;
1089 smtp_transport_options_block * ob = sx->conn_args.ob;
1090 int yield = 0;
1091
1092 #ifdef SUPPORT_PIPE_CONNECT
1093 int rc;
1094 if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
1095 return rc == FAIL ? -4 : -5;
1096 #endif
1097
1098 /* Handle the response for a MAIL command. On error, reinstate the original
1099 command in big_buffer for error message use, and flush any further pending
1100 responses before returning, except after I/O errors and timeouts. */
1101
1102 if (sx->pending_MAIL)
1103 {
1104 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1105 count--;
1106 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1107 '2', ob->command_timeout))
1108 {
1109 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1110 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1111 if (errno == ERRNO_TLSFAILURE)
1112 return -5;
1113 if (errno == 0 && sx->buffer[0] != 0)
1114 {
1115 int save_errno = 0;
1116 if (sx->buffer[0] == '4')
1117 {
1118 save_errno = ERRNO_MAIL4XX;
1119 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1120 }
1121 count = smtp_discard_responses(sx, ob, count);
1122 errno = save_errno;
1123 }
1124
1125 if (pending_DATA) count--; /* Number of RCPT responses to come */
1126 while (count-- > 0) /* Mark any pending addrs with the host used */
1127 {
1128 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1129 addr->host_used = sx->conn_args.host;
1130 addr = addr->next;
1131 }
1132 return -3;
1133 }
1134 }
1135
1136 if (pending_DATA) count--; /* Number of RCPT responses to come */
1137
1138 /* Read and handle the required number of RCPT responses, matching each one up
1139 with an address by scanning for the next address whose status is PENDING_DEFER.
1140 */
1141
1142 while (count-- > 0)
1143 {
1144 while (addr->transport_return != PENDING_DEFER)
1145 if (!(addr = addr->next))
1146 return -2;
1147
1148 /* The address was accepted */
1149 addr->host_used = sx->conn_args.host;
1150
1151 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1152 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1153 '2', ob->command_timeout))
1154 {
1155 yield |= 1;
1156 addr->transport_return = PENDING_OK;
1157
1158 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1159 ensure that any address-specific retry record is expunged. We do this both
1160 for the basic key and for the version that also includes the sender. */
1161
1162 if (testflag(addr, af_dr_retry_exists))
1163 {
1164 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1165 sender_address);
1166 retry_add_item(addr, altkey, rf_delete);
1167 retry_add_item(addr, addr->address_retry_key, rf_delete);
1168 }
1169 }
1170
1171 /* Error on first TLS read */
1172
1173 else if (errno == ERRNO_TLSFAILURE)
1174 return -5;
1175
1176 /* Timeout while reading the response */
1177
1178 else if (errno == ETIMEDOUT)
1179 {
1180 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1181 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1182 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1183 retry_add_item(addr, addr->address_retry_key, 0);
1184 update_waiting = FALSE;
1185 return -1;
1186 }
1187
1188 /* Handle other errors in obtaining an SMTP response by returning -1. This
1189 will cause all the addresses to be deferred. Restore the SMTP command in
1190 big_buffer for which we are checking the response, so the error message
1191 makes sense. */
1192
1193 else if (errno != 0 || sx->buffer[0] == 0)
1194 {
1195 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer }, * g = &gs;
1196
1197 /* Use taint-unchecked routines for writing into big_buffer, trusting
1198 that we'll never expand it. */
1199
1200 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "RCPT TO:<%s>",
1201 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1202 string_from_gstring(g);
1203 return -2;
1204 }
1205
1206 /* Handle SMTP permanent and temporary response codes. */
1207
1208 else
1209 {
1210 addr->message =
1211 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1212 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1213 string_printing(sx->buffer));
1214 setflag(addr, af_pass_message);
1215 if (!sx->verify)
1216 msglog_line(sx->conn_args.host, addr->message);
1217
1218 /* The response was 5xx */
1219
1220 if (sx->buffer[0] == '5')
1221 {
1222 addr->transport_return = FAIL;
1223 yield |= 2;
1224 }
1225
1226 /* The response was 4xx */
1227
1228 else
1229 {
1230 addr->transport_return = DEFER;
1231 addr->basic_errno = ERRNO_RCPT4XX;
1232 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1233
1234 if (!sx->verify)
1235 {
1236 #ifndef DISABLE_EVENT
1237 event_defer_errno = addr->more_errno;
1238 msg_event_raise(US"msg:rcpt:host:defer", addr);
1239 #endif
1240
1241 /* Log temporary errors if there are more hosts to be tried.
1242 If not, log this last one in the == line. */
1243
1244 if (sx->conn_args.host->next)
1245 if (LOGGING(outgoing_port))
1246 log_write(0, LOG_MAIN, "H=%s [%s]:%d %s", sx->conn_args.host->name,
1247 sx->conn_args.host->address,
1248 sx->port == PORT_NONE ? 25 : sx->port, addr->message);
1249 else
1250 log_write(0, LOG_MAIN, "H=%s [%s]: %s", sx->conn_args.host->name,
1251 sx->conn_args.host->address, addr->message);
1252
1253 #ifndef DISABLE_EVENT
1254 else
1255 msg_event_raise(US"msg:rcpt:defer", addr);
1256 #endif
1257
1258 /* Do not put this message on the list of those waiting for specific
1259 hosts, as otherwise it is likely to be tried too often. */
1260
1261 update_waiting = FALSE;
1262
1263 /* Add a retry item for the address so that it doesn't get tried again
1264 too soon. If address_retry_include_sender is true, add the sender address
1265 to the retry key. */
1266
1267 retry_add_item(addr,
1268 ob->address_retry_include_sender
1269 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1270 : addr->address_retry_key,
1271 0);
1272 }
1273 }
1274 }
1275 } /* Loop for next RCPT response */
1276
1277 /* Update where to start at for the next block of responses, unless we
1278 have already handled all the addresses. */
1279
1280 if (addr) sx->sync_addr = addr->next;
1281
1282 /* Handle a response to DATA. If we have not had any good recipients, either
1283 previously or in this block, the response is ignored. */
1284
1285 if (pending_DATA != 0)
1286 {
1287 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1288 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1289 '3', ob->command_timeout))
1290 {
1291 int code;
1292 uschar *msg;
1293 BOOL pass_message;
1294
1295 if (errno == ERRNO_TLSFAILURE) /* Error on first TLS read */
1296 return -5;
1297
1298 if (pending_DATA > 0 || (yield & 1) != 0)
1299 {
1300 if (errno == 0 && sx->buffer[0] == '4')
1301 {
1302 errno = ERRNO_DATA4XX;
1303 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1304 }
1305 return -3;
1306 }
1307 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1308 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1309 "is in use and there were no good recipients\n", msg);
1310 }
1311 }
1312
1313 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1314 present) received 3xx. If any RCPTs were handled and yielded anything other
1315 than 4xx, yield will be set non-zero. */
1316
1317 return yield;
1318 }
1319
1320
1321
1322
1323
1324 /* Try an authenticator's client entry */
1325
1326 static int
1327 try_authenticator(smtp_context * sx, auth_instance * au)
1328 {
1329 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1330 host_item * host = sx->conn_args.host; /* host to deliver to */
1331 int rc;
1332
1333 sx->outblock.authenticating = TRUE;
1334 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1335 sx->buffer, sizeof(sx->buffer));
1336 sx->outblock.authenticating = FALSE;
1337 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1338
1339 /* A temporary authentication failure must hold up delivery to
1340 this host. After a permanent authentication failure, we carry on
1341 to try other authentication methods. If all fail hard, try to
1342 deliver the message unauthenticated unless require_auth was set. */
1343
1344 switch(rc)
1345 {
1346 case OK:
1347 f.smtp_authenticated = TRUE; /* stops the outer loop */
1348 client_authenticator = au->name;
1349 if (au->set_client_id)
1350 client_authenticated_id = expand_string(au->set_client_id);
1351 break;
1352
1353 /* Failure after writing a command */
1354
1355 case FAIL_SEND:
1356 return FAIL_SEND;
1357
1358 /* Failure after reading a response */
1359
1360 case FAIL:
1361 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1362 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1363 au->name, host->name, host->address, sx->buffer);
1364 break;
1365
1366 /* Failure by some other means. In effect, the authenticator
1367 decided it wasn't prepared to handle this case. Typically this
1368 is the result of "fail" in an expansion string. Do we need to
1369 log anything here? Feb 2006: a message is now put in the buffer
1370 if logging is required. */
1371
1372 case CANCELLED:
1373 if (*sx->buffer != 0)
1374 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1375 "authentication H=%s [%s] %s", au->name, host->name,
1376 host->address, sx->buffer);
1377 break;
1378
1379 /* Internal problem, message in buffer. */
1380
1381 case ERROR:
1382 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1383 DEFER, FALSE);
1384 return ERROR;
1385 }
1386 return OK;
1387 }
1388
1389
1390
1391
1392 /* Do the client side of smtp-level authentication.
1393
1394 Arguments:
1395 sx smtp connection context
1396
1397 sx->buffer should have the EHLO response from server (gets overwritten)
1398
1399 Returns:
1400 OK Success, or failed (but not required): global "smtp_authenticated" set
1401 DEFER Failed authentication (and was required)
1402 ERROR Internal problem
1403
1404 FAIL_SEND Failed communications - transmit
1405 FAIL - response
1406 */
1407
1408 static int
1409 smtp_auth(smtp_context * sx)
1410 {
1411 host_item * host = sx->conn_args.host; /* host to deliver to */
1412 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1413 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1414 #ifdef SUPPORT_PIPE_CONNECT
1415 unsigned short authbits = tls_out.active.sock >= 0
1416 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1417 #endif
1418 uschar * fail_reason = US"server did not advertise AUTH support";
1419
1420 f.smtp_authenticated = FALSE;
1421 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1422
1423 if (!regex_AUTH)
1424 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1425
1426 /* Is the server offering AUTH? */
1427
1428 if ( sx->esmtp
1429 &&
1430 #ifdef SUPPORT_PIPE_CONNECT
1431 sx->early_pipe_active ? authbits
1432 :
1433 #endif
1434 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1435 )
1436 {
1437 uschar * names = NULL;
1438 expand_nmax = -1; /* reset */
1439
1440 #ifdef SUPPORT_PIPE_CONNECT
1441 if (!sx->early_pipe_active)
1442 #endif
1443 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1444
1445 /* Must not do this check until after we have saved the result of the
1446 regex match above as the check could be another RE. */
1447
1448 if ( require_auth == OK
1449 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1450 {
1451 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1452 fail_reason = US"no common mechanisms were found";
1453
1454 #ifdef SUPPORT_PIPE_CONNECT
1455 if (sx->early_pipe_active)
1456 {
1457 /* Scan our authenticators (which support use by a client and were offered
1458 by the server (checked at cache-write time)), not suppressed by
1459 client_condition. If one is found, attempt to authenticate by calling its
1460 client function. We are limited to supporting up to 16 authenticator
1461 public-names by the number of bits in a short. */
1462
1463 auth_instance * au;
1464 uschar bitnum;
1465 int rc;
1466
1467 for (bitnum = 0, au = auths;
1468 !f.smtp_authenticated && au && bitnum < 16;
1469 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1470 {
1471 if ( au->client_condition
1472 && !expand_check_condition(au->client_condition, au->name,
1473 US"client authenticator"))
1474 {
1475 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1476 au->name, "client_condition is false");
1477 continue;
1478 }
1479
1480 /* Found data for a listed mechanism. Call its client entry. Set
1481 a flag in the outblock so that data is overwritten after sending so
1482 that reflections don't show it. */
1483
1484 fail_reason = US"authentication attempt(s) failed";
1485
1486 if ((rc = try_authenticator(sx, au)) != OK)
1487 return rc;
1488 }
1489 }
1490 else
1491 #endif
1492
1493 /* Scan the configured authenticators looking for one which is configured
1494 for use as a client, which is not suppressed by client_condition, and
1495 whose name matches an authentication mechanism supported by the server.
1496 If one is found, attempt to authenticate by calling its client function.
1497 */
1498
1499 for (auth_instance * au = auths; !f.smtp_authenticated && au; au = au->next)
1500 {
1501 uschar *p = names;
1502
1503 if ( !au->client
1504 || ( au->client_condition
1505 && !expand_check_condition(au->client_condition, au->name,
1506 US"client authenticator")))
1507 {
1508 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1509 au->name,
1510 (au->client)? "client_condition is false" :
1511 "not configured as a client");
1512 continue;
1513 }
1514
1515 /* Loop to scan supported server mechanisms */
1516
1517 while (*p)
1518 {
1519 int len = Ustrlen(au->public_name);
1520 int rc;
1521
1522 while (isspace(*p)) p++;
1523
1524 if (strncmpic(au->public_name, p, len) != 0 ||
1525 (p[len] != 0 && !isspace(p[len])))
1526 {
1527 while (*p != 0 && !isspace(*p)) p++;
1528 continue;
1529 }
1530
1531 /* Found data for a listed mechanism. Call its client entry. Set
1532 a flag in the outblock so that data is overwritten after sending so
1533 that reflections don't show it. */
1534
1535 fail_reason = US"authentication attempt(s) failed";
1536
1537 if ((rc = try_authenticator(sx, au)) != OK)
1538 return rc;
1539
1540 break; /* If not authenticated, try next authenticator */
1541 } /* Loop for scanning supported server mechanisms */
1542 } /* Loop for further authenticators */
1543 }
1544 }
1545
1546 /* If we haven't authenticated, but are required to, give up. */
1547
1548 if (require_auth == OK && !f.smtp_authenticated)
1549 {
1550 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1551 string_sprintf("authentication required but %s", fail_reason), DEFER,
1552 FALSE);
1553 return DEFER;
1554 }
1555
1556 return OK;
1557 }
1558
1559
1560 /* Construct AUTH appendix string for MAIL TO */
1561 /*
1562 Arguments
1563 buffer to build string
1564 addrlist chain of potential addresses to deliver
1565 ob transport options
1566
1567 Globals f.smtp_authenticated
1568 client_authenticated_sender
1569 Return True on error, otherwise buffer has (possibly empty) terminated string
1570 */
1571
1572 static BOOL
1573 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1574 smtp_transport_options_block *ob)
1575 {
1576 uschar * local_authenticated_sender = authenticated_sender;
1577
1578 #ifdef notdef
1579 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1580 #endif
1581
1582 if (ob->authenticated_sender)
1583 {
1584 uschar *new = expand_string(ob->authenticated_sender);
1585 if (!new)
1586 {
1587 if (!f.expand_string_forcedfail)
1588 {
1589 uschar *message = string_sprintf("failed to expand "
1590 "authenticated_sender: %s", expand_string_message);
1591 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1592 return TRUE;
1593 }
1594 }
1595 else if (*new) local_authenticated_sender = new;
1596 }
1597
1598 /* Add the authenticated sender address if present */
1599
1600 if ( (f.smtp_authenticated || ob->authenticated_sender_force)
1601 && local_authenticated_sender)
1602 {
1603 string_format_nt(buffer, bufsize, " AUTH=%s",
1604 auth_xtextencode(local_authenticated_sender,
1605 Ustrlen(local_authenticated_sender)));
1606 client_authenticated_sender = string_copy(local_authenticated_sender);
1607 }
1608 else
1609 *buffer= 0;
1610
1611 return FALSE;
1612 }
1613
1614
1615
1616 #ifdef SUPPORT_DANE
1617 /* Lookup TLSA record for host/port.
1618 Return: OK success with dnssec; DANE mode
1619 DEFER Do not use this host now, may retry later
1620 FAIL_FORCED No TLSA record; DANE not usable
1621 FAIL Do not use this connection
1622 */
1623
1624 int
1625 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1626 {
1627 /* move this out to host.c given the similarity to dns_lookup() ? */
1628 uschar buffer[300];
1629 const uschar * fullname = buffer;
1630 int rc;
1631 BOOL sec;
1632
1633 /* TLSA lookup string */
1634 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1635
1636 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1637 sec = dns_is_secure(dnsa);
1638 DEBUG(D_transport)
1639 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1640
1641 switch (rc)
1642 {
1643 case DNS_AGAIN:
1644 return DEFER; /* just defer this TLS'd conn */
1645
1646 case DNS_SUCCEED:
1647 if (sec)
1648 {
1649 DEBUG(D_transport)
1650 {
1651 dns_scan dnss;
1652 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1653 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1654 if (rr->type == T_TLSA && rr->size > 3)
1655 {
1656 uint16_t payload_length = rr->size - 3;
1657 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1658
1659 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1660 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1661 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1662 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1663 sp += sprintf(CS sp, "%02x", *p++);
1664
1665 debug_printf(" %s\n", s);
1666 }
1667 }
1668 return OK;
1669 }
1670 log_write(0, LOG_MAIN,
1671 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1672 /*FALLTRHOUGH*/
1673
1674 case DNS_NODATA: /* no TLSA RR for this lookup */
1675 case DNS_NOMATCH: /* no records at all for this lookup */
1676 return dane_required ? FAIL : FAIL_FORCED;
1677
1678 default:
1679 case DNS_FAIL:
1680 return dane_required ? FAIL : DEFER;
1681 }
1682 }
1683 #endif
1684
1685
1686
1687 typedef struct smtp_compare_s
1688 {
1689 uschar *current_sender_address;
1690 struct transport_instance *tblock;
1691 } smtp_compare_t;
1692
1693
1694 /* Create a unique string that identifies this message, it is based on
1695 sender_address, helo_data and tls_certificate if enabled.
1696 */
1697
1698 static uschar *
1699 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1700 {
1701 address_item * addr1;
1702 uschar * if1 = US"";
1703 uschar * helo1 = US"";
1704 #ifndef DISABLE_TLS
1705 uschar * tlsc1 = US"";
1706 #endif
1707 uschar * save_sender_address = sender_address;
1708 uschar * local_identity = NULL;
1709 smtp_transport_options_block * ob = SOB tblock->options_block;
1710
1711 sender_address = sender;
1712
1713 addr1 = deliver_make_addr (sender, TRUE);
1714 deliver_set_expansions(addr1);
1715
1716 if (ob->interface)
1717 if1 = expand_string(ob->interface);
1718
1719 if (ob->helo_data)
1720 helo1 = expand_string(ob->helo_data);
1721
1722 #ifndef DISABLE_TLS
1723 if (ob->tls_certificate)
1724 tlsc1 = expand_string(ob->tls_certificate);
1725 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1726 #else
1727 local_identity = string_sprintf ("%s^%s", if1, helo1);
1728 #endif
1729
1730 deliver_set_expansions(NULL);
1731 sender_address = save_sender_address;
1732
1733 return local_identity;
1734 }
1735
1736
1737
1738 /* This routine is a callback that is called from transport_check_waiting.
1739 This function will evaluate the incoming message versus the previous
1740 message. If the incoming message is using a different local identity then
1741 we will veto this new message. */
1742
1743 static BOOL
1744 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1745 {
1746 uschar * message_local_identity,
1747 * current_local_identity,
1748 * new_sender_address;
1749
1750 current_local_identity =
1751 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1752
1753 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1754 return 0;
1755
1756 message_local_identity =
1757 smtp_local_identity(new_sender_address, s_compare->tblock);
1758
1759 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1760 }
1761
1762
1763
1764 static unsigned
1765 ehlo_response(uschar * buf, unsigned checks)
1766 {
1767 size_t bsize = Ustrlen(buf);
1768
1769 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1770
1771 #ifndef DISABLE_TLS
1772 if ( checks & OPTION_TLS
1773 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1774 #endif
1775 checks &= ~OPTION_TLS;
1776
1777 if ( checks & OPTION_IGNQ
1778 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1779 PCRE_EOPT, NULL, 0) < 0)
1780 checks &= ~OPTION_IGNQ;
1781
1782 if ( checks & OPTION_CHUNKING
1783 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1784 checks &= ~OPTION_CHUNKING;
1785
1786 #ifndef DISABLE_PRDR
1787 if ( checks & OPTION_PRDR
1788 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1789 #endif
1790 checks &= ~OPTION_PRDR;
1791
1792 #ifdef SUPPORT_I18N
1793 if ( checks & OPTION_UTF8
1794 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1795 #endif
1796 checks &= ~OPTION_UTF8;
1797
1798 if ( checks & OPTION_DSN
1799 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1800 checks &= ~OPTION_DSN;
1801
1802 if ( checks & OPTION_PIPE
1803 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1804 PCRE_EOPT, NULL, 0) < 0)
1805 checks &= ~OPTION_PIPE;
1806
1807 if ( checks & OPTION_SIZE
1808 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1809 checks &= ~OPTION_SIZE;
1810
1811 #ifdef SUPPORT_PIPE_CONNECT
1812 if ( checks & OPTION_EARLY_PIPE
1813 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1814 PCRE_EOPT, NULL, 0) < 0)
1815 #endif
1816 checks &= ~OPTION_EARLY_PIPE;
1817
1818 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1819 return checks;
1820 }
1821
1822
1823
1824 /* Callback for emitting a BDAT data chunk header.
1825
1826 If given a nonzero size, first flush any buffered SMTP commands
1827 then emit the command.
1828
1829 Reap previous SMTP command responses if requested, and always reap
1830 the response from a previous BDAT command.
1831
1832 Args:
1833 tctx transport context
1834 chunk_size value for SMTP BDAT command
1835 flags
1836 tc_chunk_last add LAST option to SMTP BDAT command
1837 tc_reap_prev reap response to previous SMTP commands
1838
1839 Returns:
1840 OK or ERROR
1841 DEFER TLS error on first read (EHLO-resp); errno set
1842 */
1843
1844 static int
1845 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1846 unsigned flags)
1847 {
1848 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1849 smtp_context * sx = tctx->smtp_context;
1850 int cmd_count = 0;
1851 int prev_cmd_count;
1852
1853 /* Write SMTP chunk header command. If not reaping responses, note that
1854 there may be more writes (like, the chunk data) done soon. */
1855
1856 if (chunk_size > 0)
1857 {
1858 #ifdef SUPPORT_PIPE_CONNECT
1859 BOOL new_conn = !!(sx->outblock.conn_args);
1860 #endif
1861 if((cmd_count = smtp_write_command(sx,
1862 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1863 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1864 ) < 0) return ERROR;
1865 if (flags & tc_chunk_last)
1866 data_command = string_copy(big_buffer); /* Save for later error message */
1867 #ifdef SUPPORT_PIPE_CONNECT
1868 /* That command write could have been the one that made the connection.
1869 Copy the fd from the client conn ctx (smtp transport specific) to the
1870 generic transport ctx. */
1871
1872 if (new_conn)
1873 tctx->u.fd = sx->outblock.cctx->sock;
1874 #endif
1875 }
1876
1877 prev_cmd_count = cmd_count += sx->cmd_count;
1878
1879 /* Reap responses for any previous, but not one we just emitted */
1880
1881 if (chunk_size > 0)
1882 prev_cmd_count--;
1883 if (sx->pending_BDAT)
1884 prev_cmd_count--;
1885
1886 if (flags & tc_reap_prev && prev_cmd_count > 0)
1887 {
1888 DEBUG(D_transport) debug_printf("look for %d responses"
1889 " for previous pipelined cmds\n", prev_cmd_count);
1890
1891 switch(sync_responses(sx, prev_cmd_count, 0))
1892 {
1893 case 1: /* 2xx (only) => OK */
1894 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1895 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1896 case 0: break; /* No 2xx or 5xx, but no probs */
1897
1898 case -5: errno = ERRNO_TLSFAILURE;
1899 return DEFER;
1900 #ifdef SUPPORT_PIPE_CONNECT
1901 case -4: /* non-2xx for pipelined banner or EHLO */
1902 #endif
1903 case -1: /* Timeout on RCPT */
1904 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1905 }
1906 cmd_count = 1;
1907 if (!sx->pending_BDAT)
1908 pipelining_active = FALSE;
1909 }
1910
1911 /* Reap response for an outstanding BDAT */
1912
1913 if (sx->pending_BDAT)
1914 {
1915 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1916
1917 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1918 ob->command_timeout))
1919 {
1920 if (errno == 0 && sx->buffer[0] == '4')
1921 {
1922 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1923 sx->addrlist->more_errno |=
1924 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1925 }
1926 return ERROR;
1927 }
1928 cmd_count--;
1929 sx->pending_BDAT = FALSE;
1930 pipelining_active = FALSE;
1931 }
1932 else if (chunk_size > 0)
1933 sx->pending_BDAT = TRUE;
1934
1935
1936 sx->cmd_count = cmd_count;
1937 return OK;
1938 }
1939
1940
1941
1942
1943
1944 /*************************************************
1945 * Make connection for given message *
1946 *************************************************/
1947
1948 /*
1949 Arguments:
1950 ctx connection context
1951 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1952 a second attempt after TLS initialization fails
1953
1954 Returns: OK - the connection was made and the delivery attempted;
1955 fd is set in the conn context, tls_out set up.
1956 DEFER - the connection could not be made, or something failed
1957 while setting up the SMTP session, or there was a
1958 non-message-specific error, such as a timeout.
1959 ERROR - helo_data or add_headers or authenticated_sender is
1960 specified for this transport, and the string failed
1961 to expand
1962 */
1963 int
1964 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1965 {
1966 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1967 BOOL pass_message = FALSE;
1968 uschar * message = NULL;
1969 int yield = OK;
1970 #ifndef DISABLE_TLS
1971 uschar * tls_errstr;
1972 #endif
1973
1974 sx->conn_args.ob = ob;
1975
1976 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1977 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1978 sx->ok = FALSE;
1979 sx->send_rset = TRUE;
1980 sx->send_quit = TRUE;
1981 sx->setting_up = TRUE;
1982 sx->esmtp = TRUE;
1983 sx->esmtp_sent = FALSE;
1984 #ifdef SUPPORT_I18N
1985 sx->utf8_needed = FALSE;
1986 #endif
1987 sx->dsn_all_lasthop = TRUE;
1988 #ifdef SUPPORT_DANE
1989 sx->conn_args.dane = FALSE;
1990 sx->dane_required =
1991 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1992 #endif
1993 #ifdef SUPPORT_PIPE_CONNECT
1994 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1995 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1996 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1997 #endif
1998
1999 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
2000 sx->peer_offered = 0;
2001 sx->avoid_option = 0;
2002 sx->igquotstr = US"";
2003 if (!sx->helo_data) sx->helo_data = ob->helo_data;
2004 #ifdef EXPERIMENTAL_DSN_INFO
2005 sx->smtp_greeting = NULL;
2006 sx->helo_response = NULL;
2007 #endif
2008
2009 smtp_command = US"initial connection";
2010 sx->buffer[0] = '\0';
2011
2012 /* Set up the buffer for reading SMTP response packets. */
2013
2014 sx->inblock.buffer = sx->inbuffer;
2015 sx->inblock.buffersize = sizeof(sx->inbuffer);
2016 sx->inblock.ptr = sx->inbuffer;
2017 sx->inblock.ptrend = sx->inbuffer;
2018
2019 /* Set up the buffer for holding SMTP commands while pipelining */
2020
2021 sx->outblock.buffer = sx->outbuffer;
2022 sx->outblock.buffersize = sizeof(sx->outbuffer);
2023 sx->outblock.ptr = sx->outbuffer;
2024 sx->outblock.cmd_count = 0;
2025 sx->outblock.authenticating = FALSE;
2026 sx->outblock.conn_args = NULL;
2027
2028 /* Reset the parameters of a TLS session. */
2029
2030 tls_out.bits = 0;
2031 tls_out.cipher = NULL; /* the one we may use for this transport */
2032 tls_out.ourcert = NULL;
2033 tls_out.peercert = NULL;
2034 tls_out.peerdn = NULL;
2035 #ifdef USE_OPENSSL
2036 tls_out.sni = NULL;
2037 #endif
2038 tls_out.ocsp = OCSP_NOT_REQ;
2039 #ifdef EXPERIMENTAL_TLS_RESUME
2040 tls_out.resumption = 0;
2041 #endif
2042
2043 /* Flip the legacy TLS-related variables over to the outbound set in case
2044 they're used in the context of the transport. Don't bother resetting
2045 afterward (when being used by a transport) as we're in a subprocess.
2046 For verify, unflipped once the callout is dealt with */
2047
2048 tls_modify_variables(&tls_out);
2049
2050 #ifdef DISABLE_TLS
2051 if (sx->smtps)
2052 {
2053 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2054 DEFER, FALSE);
2055 return ERROR;
2056 }
2057 #endif
2058
2059 /* Make a connection to the host if this isn't a continued delivery, and handle
2060 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2061 specially so they can be identified for retries. */
2062
2063 if (!continue_hostname)
2064 {
2065 if (sx->verify)
2066 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2067
2068 /* Get the actual port the connection will use, into sx->conn_args.host */
2069
2070 smtp_port_for_connect(sx->conn_args.host, sx->port);
2071
2072 #ifdef SUPPORT_DANE
2073 /* Do TLSA lookup for DANE */
2074 {
2075 tls_out.dane_verified = FALSE;
2076 tls_out.tlsa_usage = 0;
2077
2078 if (sx->conn_args.host->dnssec == DS_YES)
2079 {
2080 int rc;
2081 if( sx->dane_required
2082 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2083 )
2084 switch (rc = tlsa_lookup(sx->conn_args.host, &sx->conn_args.tlsa_dnsa, sx->dane_required))
2085 {
2086 case OK: sx->conn_args.dane = TRUE;
2087 ob->tls_tempfail_tryclear = FALSE;
2088 break;
2089 case FAIL_FORCED: break;
2090 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2091 string_sprintf("DANE error: tlsa lookup %s",
2092 rc_to_string(rc)),
2093 rc, FALSE);
2094 # ifndef DISABLE_EVENT
2095 (void) event_raise(sx->conn_args.tblock->event_action,
2096 US"dane:fail", sx->dane_required
2097 ? US"dane-required" : US"dnssec-invalid");
2098 # endif
2099 return rc;
2100 }
2101 }
2102 else if (sx->dane_required)
2103 {
2104 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2105 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2106 FAIL, FALSE);
2107 # ifndef DISABLE_EVENT
2108 (void) event_raise(sx->conn_args.tblock->event_action,
2109 US"dane:fail", US"dane-required");
2110 # endif
2111 return FAIL;
2112 }
2113 }
2114 #endif /*DANE*/
2115
2116 /* Make the TCP connection */
2117
2118 sx->cctx.tls_ctx = NULL;
2119 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2120 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2121
2122 #ifdef SUPPORT_PIPE_CONNECT
2123 if ( verify_check_given_host(CUSS &ob->hosts_pipe_connect,
2124 sx->conn_args.host) == OK)
2125
2126 /* We don't find out the local ip address until the connect, so if
2127 the helo string might use it avoid doing early-pipelining. */
2128
2129 if ( !sx->helo_data
2130 || !Ustrstr(sx->helo_data, "$sending_ip_address")
2131 || Ustrstr(sx->helo_data, "def:sending_ip_address")
2132 )
2133 {
2134 sx->early_pipe_ok = TRUE;
2135 if ( read_ehlo_cache_entry(sx)
2136 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2137 {
2138 DEBUG(D_transport)
2139 debug_printf("Using cached cleartext PIPE_CONNECT\n");
2140 sx->early_pipe_active = TRUE;
2141 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2142 }
2143 }
2144 else DEBUG(D_transport)
2145 debug_printf("helo needs $sending_ip_address\n");
2146
2147 if (sx->early_pipe_active)
2148 sx->outblock.conn_args = &sx->conn_args;
2149 else
2150 #endif
2151 {
2152 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2153 {
2154 set_errno_nohost(sx->addrlist,
2155 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2156 sx->verify ? US strerror(errno) : NULL,
2157 DEFER, FALSE);
2158 sx->send_quit = FALSE;
2159 return DEFER;
2160 }
2161 }
2162 /* Expand the greeting message while waiting for the initial response. (Makes
2163 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2164 delayed till here so that $sending_interface and $sending_port are set. */
2165 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2166 will be? Somehow I doubt it. */
2167
2168 if (sx->helo_data)
2169 if (!(sx->helo_data = expand_string(sx->helo_data)))
2170 if (sx->verify)
2171 log_write(0, LOG_MAIN|LOG_PANIC,
2172 "<%s>: failed to expand transport's helo_data value for callout: %s",
2173 sx->addrlist->address, expand_string_message);
2174
2175 #ifdef SUPPORT_I18N
2176 if (sx->helo_data)
2177 {
2178 expand_string_message = NULL;
2179 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2180 &expand_string_message)),
2181 expand_string_message)
2182 if (sx->verify)
2183 log_write(0, LOG_MAIN|LOG_PANIC,
2184 "<%s>: failed to expand transport's helo_data value for callout: %s",
2185 sx->addrlist->address, expand_string_message);
2186 else
2187 sx->helo_data = NULL;
2188 }
2189 #endif
2190
2191 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2192 is nevertheless a reasonably clean way of programming this kind of logic,
2193 where you want to escape on any error. */
2194
2195 if (!sx->smtps)
2196 {
2197 #ifdef SUPPORT_PIPE_CONNECT
2198 if (sx->early_pipe_active)
2199 {
2200 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2201 sx->outblock.cmd_count = 1;
2202 }
2203 else
2204 #endif
2205 {
2206 #ifdef TCP_QUICKACK
2207 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2208 sizeof(off));
2209 #endif
2210 if (!smtp_reap_banner(sx))
2211 goto RESPONSE_FAILED;
2212 }
2213
2214 #ifndef DISABLE_EVENT
2215 {
2216 uschar * s;
2217 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2218 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2219 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2220 if (s)
2221 {
2222 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2223 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2224 DEFER, FALSE);
2225 yield = DEFER;
2226 goto SEND_QUIT;
2227 }
2228 }
2229 #endif
2230
2231 /* Now check if the helo_data expansion went well, and sign off cleanly if
2232 it didn't. */
2233
2234 if (!sx->helo_data)
2235 {
2236 message = string_sprintf("failed to expand helo_data: %s",
2237 expand_string_message);
2238 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2239 yield = DEFER;
2240 goto SEND_QUIT;
2241 }
2242 }
2243
2244 /** Debugging without sending a message
2245 sx->addrlist->transport_return = DEFER;
2246 goto SEND_QUIT;
2247 **/
2248
2249 /* Errors that occur after this point follow an SMTP command, which is
2250 left in big_buffer by smtp_write_command() for use in error messages. */
2251
2252 smtp_command = big_buffer;
2253
2254 /* Tell the remote who we are...
2255
2256 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2257 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2258 greeting is of this form. The assumption was that the far end supports it
2259 properly... but experience shows that there are some that give 5xx responses,
2260 even though the banner includes "ESMTP" (there's a bloody-minded one that
2261 says "ESMTP not spoken here"). Cope with that case.
2262
2263 September 2000: Time has passed, and it seems reasonable now to always send
2264 EHLO at the start. It is also convenient to make the change while installing
2265 the TLS stuff.
2266
2267 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2268 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2269 would be no way to send out the mails, so there is now a host list
2270 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2271 PIPELINING problem as well. Maybe it can also be useful to cure other
2272 problems with broken servers.
2273
2274 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2275 Then somebody tried it with a Microsoft mailer... It seems that all other
2276 mailers use upper case for some reason (the RFC is quite clear about case
2277 independence) so, for peace of mind, I gave in. */
2278
2279 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2280
2281 /* Alas; be careful, since this goto is not an error-out, so conceivably
2282 we might set data between here and the target which we assume to exist
2283 and be usable. I can see this coming back to bite us. */
2284 #ifndef DISABLE_TLS
2285 if (sx->smtps)
2286 {
2287 smtp_peer_options |= OPTION_TLS;
2288 suppress_tls = FALSE;
2289 ob->tls_tempfail_tryclear = FALSE;
2290 smtp_command = US"SSL-on-connect";
2291 goto TLS_NEGOTIATE;
2292 }
2293 #endif
2294
2295 if (sx->esmtp)
2296 {
2297 if (smtp_write_command(sx,
2298 #ifdef SUPPORT_PIPE_CONNECT
2299 sx->early_pipe_active ? SCMD_BUFFER :
2300 #endif
2301 SCMD_FLUSH,
2302 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2303 goto SEND_FAILED;
2304 sx->esmtp_sent = TRUE;
2305
2306 #ifdef SUPPORT_PIPE_CONNECT
2307 if (sx->early_pipe_active)
2308 {
2309 sx->pending_EHLO = TRUE;
2310
2311 /* If we have too many authenticators to handle and might need to AUTH
2312 for this transport, pipeline no further as we will need the
2313 list of auth methods offered. Reap the banner and EHLO. */
2314
2315 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2316 && f.smtp_in_early_pipe_no_auth)
2317 {
2318 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2319 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2320 goto SEND_FAILED;
2321 if (sync_responses(sx, 2, 0) != 0)
2322 {
2323 HDEBUG(D_transport)
2324 debug_printf("failed reaping pipelined cmd responses\n");
2325 goto RESPONSE_FAILED;
2326 }
2327 sx->early_pipe_active = FALSE;
2328 }
2329 }
2330 else
2331 #endif
2332 if (!smtp_reap_ehlo(sx))
2333 goto RESPONSE_FAILED;
2334 }
2335 else
2336 DEBUG(D_transport)
2337 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2338
2339 #ifdef SUPPORT_PIPE_CONNECT
2340 if (!sx->early_pipe_active)
2341 #endif
2342 if (!sx->esmtp)
2343 {
2344 BOOL good_response;
2345 int n = sizeof(sx->buffer);
2346 uschar * rsp = sx->buffer;
2347
2348 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2349 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2350
2351 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2352 goto SEND_FAILED;
2353 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2354 #ifdef EXPERIMENTAL_DSN_INFO
2355 sx->helo_response = string_copy(rsp);
2356 #endif
2357 if (!good_response)
2358 {
2359 /* Handle special logging for a closed connection after HELO
2360 when had previously sent EHLO */
2361
2362 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2363 {
2364 errno = ERRNO_SMTPCLOSED;
2365 goto EHLOHELO_FAILED;
2366 }
2367 memmove(sx->buffer, rsp, Ustrlen(rsp));
2368 goto RESPONSE_FAILED;
2369 }
2370 }
2371
2372 if (sx->esmtp || sx->lmtp)
2373 {
2374 #ifdef SUPPORT_PIPE_CONNECT
2375 if (!sx->early_pipe_active)
2376 #endif
2377 {
2378 sx->peer_offered = ehlo_response(sx->buffer,
2379 OPTION_TLS /* others checked later */
2380 #ifdef SUPPORT_PIPE_CONNECT
2381 | (sx->early_pipe_ok
2382 ? OPTION_IGNQ
2383 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2384 #ifdef SUPPORT_I18N
2385 | OPTION_UTF8
2386 #endif
2387 | OPTION_EARLY_PIPE
2388 : 0
2389 )
2390 #endif
2391 );
2392 #ifdef SUPPORT_PIPE_CONNECT
2393 if (sx->early_pipe_ok)
2394 {
2395 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2396
2397 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2398 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2399 {
2400 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2401 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2402 write_ehlo_cache_entry(sx);
2403 }
2404 }
2405 #endif
2406 }
2407
2408 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2409
2410 #ifndef DISABLE_TLS
2411 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2412 #endif
2413 }
2414 }
2415
2416 /* For continuing deliveries down the same channel, having re-exec'd the socket
2417 is the standard input; for a socket held open from verify it is recorded
2418 in the cutthrough context block. Either way we don't need to redo EHLO here
2419 (but may need to do so for TLS - see below).
2420 Set up the pointer to where subsequent commands will be left, for
2421 error messages. Note that smtp_peer_options will have been
2422 set from the command line if they were set in the process that passed the
2423 connection on. */
2424
2425 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2426 as the continue goes via transport_pass_socket() and doublefork and exec.
2427 It does not wait. Unclear how we keep separate host's responses
2428 separate - we could match up by host ip+port as a bodge. */
2429
2430 else
2431 {
2432 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2433 {
2434 sx->cctx = cutthrough.cctx;
2435 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2436 }
2437 else
2438 {
2439 sx->cctx.sock = 0; /* stdin */
2440 sx->cctx.tls_ctx = NULL;
2441 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2442 }
2443 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2444 smtp_command = big_buffer;
2445 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2446
2447 /* For a continued connection with TLS being proxied for us, or a
2448 held-open verify connection with TLS, nothing more to do. */
2449
2450 if ( continue_proxy_cipher
2451 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2452 && cutthrough.is_tls)
2453 )
2454 {
2455 sx->peer_offered = smtp_peer_options;
2456 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2457 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2458 continue_proxy_cipher ? "proxied" : "verify conn with");
2459 return OK;
2460 }
2461 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2462 }
2463
2464 /* If TLS is available on this connection, whether continued or not, attempt to
2465 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2466 send another EHLO - the server may give a different answer in secure mode. We
2467 use a separate buffer for reading the response to STARTTLS so that if it is
2468 negative, the original EHLO data is available for subsequent analysis, should
2469 the client not be required to use TLS. If the response is bad, copy the buffer
2470 for error analysis. */
2471
2472 #ifndef DISABLE_TLS
2473 if ( smtp_peer_options & OPTION_TLS
2474 && !suppress_tls
2475 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2476 && ( !sx->verify
2477 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2478 ) )
2479 {
2480 uschar buffer2[4096];
2481
2482 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2483 goto SEND_FAILED;
2484
2485 #ifdef SUPPORT_PIPE_CONNECT
2486 /* If doing early-pipelining reap the banner and EHLO-response but leave
2487 the response for the STARTTLS we just sent alone. */
2488
2489 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2490 {
2491 HDEBUG(D_transport)
2492 debug_printf("failed reaping pipelined cmd responses\n");
2493 goto RESPONSE_FAILED;
2494 }
2495 #endif
2496
2497 /* If there is an I/O error, transmission of this message is deferred. If
2498 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2499 false, we also defer. However, if there is a temporary rejection of STARTTLS
2500 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2501 STARTTLS, we carry on. This means we will try to send the message in clear,
2502 unless the host is in hosts_require_tls (tested below). */
2503
2504 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2505 {
2506 if ( errno != 0
2507 || buffer2[0] == 0
2508 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2509 )
2510 {
2511 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2512 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2513 goto RESPONSE_FAILED;
2514 }
2515 }
2516
2517 /* STARTTLS accepted: try to negotiate a TLS session. */
2518
2519 else
2520 TLS_NEGOTIATE:
2521 {
2522 if (!tls_client_start(&sx->cctx, &sx->conn_args, sx->addrlist, &tls_out, &tls_errstr))
2523 {
2524 /* TLS negotiation failed; give an error. From outside, this function may
2525 be called again to try in clear on a new connection, if the options permit
2526 it for this host. */
2527 #ifdef USE_GNUTLS
2528 GNUTLS_CONN_FAILED:
2529 #endif
2530 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", tls_errstr);
2531
2532 # ifdef SUPPORT_DANE
2533 if (sx->conn_args.dane)
2534 {
2535 log_write(0, LOG_MAIN,
2536 "DANE attempt failed; TLS connection to %s [%s]: %s",
2537 sx->conn_args.host->name, sx->conn_args.host->address, tls_errstr);
2538 # ifndef DISABLE_EVENT
2539 (void) event_raise(sx->conn_args.tblock->event_action,
2540 US"dane:fail", US"validation-failure"); /* could do with better detail */
2541 # endif
2542 }
2543 # endif
2544
2545 errno = ERRNO_TLSFAILURE;
2546 message = string_sprintf("TLS session: %s", tls_errstr);
2547 sx->send_quit = FALSE;
2548 goto TLS_FAILED;
2549 }
2550
2551 /* TLS session is set up */
2552
2553 smtp_peer_options_wrap = smtp_peer_options;
2554 for (address_item * addr = sx->addrlist; addr; addr = addr->next)
2555 if (addr->transport_return == PENDING_DEFER)
2556 {
2557 addr->cipher = tls_out.cipher;
2558 addr->ourcert = tls_out.ourcert;
2559 addr->peercert = tls_out.peercert;
2560 addr->peerdn = tls_out.peerdn;
2561 addr->ocsp = tls_out.ocsp;
2562 }
2563 }
2564 }
2565
2566 /* if smtps, we'll have smtp_command set to something else; always safe to
2567 reset it here. */
2568 smtp_command = big_buffer;
2569
2570 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2571 helo_data is null, we are dealing with a connection that was passed from
2572 another process, and so we won't have expanded helo_data above. We have to
2573 expand it here. $sending_ip_address and $sending_port are set up right at the
2574 start of the Exim process (in exim.c). */
2575
2576 if (tls_out.active.sock >= 0)
2577 {
2578 uschar * greeting_cmd;
2579
2580 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2581 {
2582 uschar *message = string_sprintf("failed to expand helo_data: %s",
2583 expand_string_message);
2584 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2585 yield = DEFER;
2586 goto SEND_QUIT;
2587 }
2588
2589 #ifdef SUPPORT_PIPE_CONNECT
2590 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2591 We're unlikely to get the group sent and delivered before the server sends its
2592 banner, but it's still worth sending as a group.
2593 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2594 the reverse. */
2595
2596 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2597 {
2598 sx->peer_offered = sx->ehlo_resp.crypted_features;
2599 if ((sx->early_pipe_active =
2600 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2601 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2602 }
2603 #endif
2604
2605 /* For SMTPS we need to wait for the initial OK response. */
2606 if (sx->smtps)
2607 #ifdef SUPPORT_PIPE_CONNECT
2608 if (sx->early_pipe_active)
2609 {
2610 sx->pending_BANNER = TRUE;
2611 sx->outblock.cmd_count = 1;
2612 }
2613 else
2614 #endif
2615 if (!smtp_reap_banner(sx))
2616 goto RESPONSE_FAILED;
2617
2618 if (sx->lmtp)
2619 greeting_cmd = US"LHLO";
2620 else if (sx->esmtp)
2621 greeting_cmd = US"EHLO";
2622 else
2623 {
2624 greeting_cmd = US"HELO";
2625 DEBUG(D_transport)
2626 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2627 }
2628
2629 if (smtp_write_command(sx,
2630 #ifdef SUPPORT_PIPE_CONNECT
2631 sx->early_pipe_active ? SCMD_BUFFER :
2632 #endif
2633 SCMD_FLUSH,
2634 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2635 goto SEND_FAILED;
2636
2637 #ifdef SUPPORT_PIPE_CONNECT
2638 if (sx->early_pipe_active)
2639 sx->pending_EHLO = TRUE;
2640 else
2641 #endif
2642 {
2643 if (!smtp_reap_ehlo(sx))
2644 #ifdef USE_GNUTLS
2645 {
2646 /* The GnuTLS layer in Exim only spots a server-rejection of a client
2647 cert late, under TLS1.3 - which means here; the first time we try to
2648 receive crypted data. Treat it as if it was a connect-time failure.
2649 See also the early-pipe equivalent... which will be hard; every call
2650 to sync_responses will need to check the result.
2651 It would be nicer to have GnuTLS check the cert during the handshake.
2652 Can it do that, with all the flexibility we need? */
2653
2654 tls_errstr = US"error on first read";
2655 goto GNUTLS_CONN_FAILED;
2656 }
2657 #else
2658 goto RESPONSE_FAILED;
2659 #endif
2660 smtp_peer_options = 0;
2661 }
2662 }
2663
2664 /* If the host is required to use a secure channel, ensure that we
2665 have one. */
2666
2667 else if ( sx->smtps
2668 # ifdef SUPPORT_DANE
2669 || sx->conn_args.dane
2670 # endif
2671 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2672 )
2673 {
2674 errno = ERRNO_TLSREQUIRED;
2675 message = string_sprintf("a TLS session is required, but %s",
2676 smtp_peer_options & OPTION_TLS
2677 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2678 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2679 if (sx->conn_args.dane)
2680 (void) event_raise(sx->conn_args.tblock->event_action, US"dane:fail",
2681 smtp_peer_options & OPTION_TLS
2682 ? US"validation-failure" /* could do with better detail */
2683 : US"starttls-not-supported");
2684 # endif
2685 goto TLS_FAILED;
2686 }
2687 #endif /*DISABLE_TLS*/
2688
2689 /* If TLS is active, we have just started it up and re-done the EHLO command,
2690 so its response needs to be analyzed. If TLS is not active and this is a
2691 continued session down a previously-used socket, we haven't just done EHLO, so
2692 we skip this. */
2693
2694 if (continue_hostname == NULL
2695 #ifndef DISABLE_TLS
2696 || tls_out.active.sock >= 0
2697 #endif
2698 )
2699 {
2700 if (sx->esmtp || sx->lmtp)
2701 {
2702 #ifdef SUPPORT_PIPE_CONNECT
2703 if (!sx->early_pipe_active)
2704 #endif
2705 {
2706 sx->peer_offered = ehlo_response(sx->buffer,
2707 0 /* no TLS */
2708 #ifdef SUPPORT_PIPE_CONNECT
2709 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2710 | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2711 | OPTION_CHUNKING | OPTION_PRDR | OPTION_UTF8
2712 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2713
2714 #else
2715
2716 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2717 | OPTION_CHUNKING
2718 | OPTION_PRDR
2719 # ifdef SUPPORT_I18N
2720 | (sx->addrlist->prop.utf8_msg ? OPTION_UTF8 : 0)
2721 /*XXX if we hand peercaps on to continued-conn processes,
2722 must not depend on this addr */
2723 # endif
2724 | OPTION_DSN
2725 | OPTION_PIPE
2726 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2727 #endif
2728 );
2729 #ifdef SUPPORT_PIPE_CONNECT
2730 if (tls_out.active.sock >= 0)
2731 sx->ehlo_resp.crypted_features = sx->peer_offered;
2732 #endif
2733 }
2734
2735 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2736 lmtp_ignore_quota option was set. */
2737
2738 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2739
2740 /* If the response to EHLO specified support for the SIZE parameter, note
2741 this, provided size_addition is non-negative. */
2742
2743 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2744
2745 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2746 the current host, esmtp will be false, so PIPELINING can never be used. If
2747 the current host matches hosts_avoid_pipelining, don't do it. */
2748
2749 if ( sx->peer_offered & OPTION_PIPE
2750 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2751 smtp_peer_options |= OPTION_PIPE;
2752
2753 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2754 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2755
2756 if ( sx->peer_offered & OPTION_CHUNKING
2757 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2758 sx->peer_offered &= ~OPTION_CHUNKING;
2759
2760 if (sx->peer_offered & OPTION_CHUNKING)
2761 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2762
2763 #ifndef DISABLE_PRDR
2764 if ( sx->peer_offered & OPTION_PRDR
2765 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2766 sx->peer_offered &= ~OPTION_PRDR;
2767
2768 if (sx->peer_offered & OPTION_PRDR)
2769 DEBUG(D_transport) debug_printf("PRDR usable\n");
2770 #endif
2771
2772 /* Note if the server supports DSN */
2773 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2774 DEBUG(D_transport) debug_printf("%susing DSN\n",
2775 sx->peer_offered & OPTION_DSN ? "" : "not ");
2776
2777 #ifdef SUPPORT_PIPE_CONNECT
2778 if ( sx->early_pipe_ok
2779 && !sx->early_pipe_active
2780 && tls_out.active.sock >= 0
2781 && smtp_peer_options & OPTION_PIPE
2782 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2783 & OPTION_EARLY_PIPE)
2784 {
2785 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2786 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2787 write_ehlo_cache_entry(sx);
2788 }
2789 #endif
2790
2791 /* Note if the response to EHLO specifies support for the AUTH extension.
2792 If it has, check that this host is one we want to authenticate to, and do
2793 the business. The host name and address must be available when the
2794 authenticator's client driver is running. */
2795
2796 switch (yield = smtp_auth(sx))
2797 {
2798 default: goto SEND_QUIT;
2799 case OK: break;
2800 case FAIL_SEND: goto SEND_FAILED;
2801 case FAIL: goto RESPONSE_FAILED;
2802 }
2803 }
2804 }
2805 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2806
2807 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2808 message-specific. */
2809
2810 sx->setting_up = FALSE;
2811
2812 #ifdef SUPPORT_I18N
2813 if (sx->addrlist->prop.utf8_msg)
2814 {
2815 uschar * s;
2816
2817 /* If the transport sets a downconversion mode it overrides any set by ACL
2818 for the message. */
2819
2820 if ((s = ob->utf8_downconvert))
2821 {
2822 if (!(s = expand_string(s)))
2823 {
2824 message = string_sprintf("failed to expand utf8_downconvert: %s",
2825 expand_string_message);
2826 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2827 yield = DEFER;
2828 goto SEND_QUIT;
2829 }
2830 switch (*s)
2831 {
2832 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2833 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2834 break;
2835 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2836 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2837 break;
2838 case '-': if (s[1] == '1')
2839 {
2840 sx->addrlist->prop.utf8_downcvt = FALSE;
2841 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2842 }
2843 break;
2844 }
2845 }
2846
2847 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2848 && !sx->addrlist->prop.utf8_downcvt_maybe;
2849 DEBUG(D_transport) if (!sx->utf8_needed)
2850 debug_printf("utf8: %s downconvert\n",
2851 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2852 }
2853
2854 /* If this is an international message we need the host to speak SMTPUTF8 */
2855 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2856 {
2857 errno = ERRNO_UTF8_FWD;
2858 goto RESPONSE_FAILED;
2859 }
2860 #endif /*SUPPORT_I18N*/
2861
2862 return OK;
2863
2864
2865 {
2866 int code;
2867
2868 RESPONSE_FAILED:
2869 if (errno == ECONNREFUSED) /* first-read error on a TFO conn */
2870 {
2871 /* There is a testing facility for simulating a connection timeout, as I
2872 can't think of any other way of doing this. It converts a connection
2873 refused into a timeout if the timeout is set to 999999. This is done for
2874 a 3whs connection in ip_connect(), but a TFO connection does not error
2875 there - instead it gets ECONNREFUSED on the first data read. Tracking
2876 that a TFO really was done is too hard, or we would set a
2877 sx->pending_conn_done bit and test that in smtp_reap_banner() and
2878 smtp_reap_ehlo(). That would let us also add the conn-timeout to the
2879 cmd-timeout. */
2880
2881 if (f.running_in_test_harness && ob->connect_timeout == 999999)
2882 errno = ETIMEDOUT;
2883 set_errno_nohost(sx->addrlist,
2884 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2885 sx->verify ? US strerror(errno) : NULL,
2886 DEFER, FALSE);
2887 sx->send_quit = FALSE;
2888 return DEFER;
2889 }
2890
2891 /* really an error on an SMTP read */
2892 message = NULL;
2893 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2894 sx->buffer, &code, &message, &pass_message);
2895 yield = DEFER;
2896 goto FAILED;
2897
2898 SEND_FAILED:
2899 code = '4';
2900 message = US string_sprintf("send() to %s [%s] failed: %s",
2901 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2902 sx->send_quit = FALSE;
2903 yield = DEFER;
2904 goto FAILED;
2905
2906 EHLOHELO_FAILED:
2907 code = '4';
2908 message = string_sprintf("Remote host closed connection in response to %s"
2909 " (EHLO response was: %s)", smtp_command, sx->buffer);
2910 sx->send_quit = FALSE;
2911 yield = DEFER;
2912 goto FAILED;
2913
2914 /* This label is jumped to directly when a TLS negotiation has failed,
2915 or was not done for a host for which it is required. Values will be set
2916 in message and errno, and setting_up will always be true. Treat as
2917 a temporary error. */
2918
2919 #ifndef DISABLE_TLS
2920 TLS_FAILED:
2921 code = '4', yield = DEFER;
2922 goto FAILED;
2923 #endif
2924
2925 /* The failure happened while setting up the call; see if the failure was
2926 a 5xx response (this will either be on connection, or following HELO - a 5xx
2927 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2928 fail all addresses, as this host is never going to accept them. For other
2929 errors during setting up (timeouts or whatever), defer all addresses, and
2930 yield DEFER, so that the host is not tried again for a while.
2931
2932 XXX This peeking for another host feels like a layering violation. We want
2933 to note the host as unusable, but down here we shouldn't know if this was
2934 the last host to try for the addr(list). Perhaps the upper layer should be
2935 the one to do set_errno() ? The problem is that currently the addr is where
2936 errno etc. are stashed, but until we run out of hosts to try the errors are
2937 host-specific. Maybe we should enhance the host_item definition? */
2938
2939 FAILED:
2940 sx->ok = FALSE; /* For when reached by GOTO */
2941 set_errno(sx->addrlist, errno, message,
2942 sx->conn_args.host->next
2943 ? DEFER
2944 : code == '5'
2945 #ifdef SUPPORT_I18N
2946 || errno == ERRNO_UTF8_FWD
2947 #endif
2948 ? FAIL : DEFER,
2949 pass_message,
2950 errno == ECONNREFUSED ? NULL : sx->conn_args.host
2951 #ifdef EXPERIMENTAL_DSN_INFO
2952 , sx->smtp_greeting, sx->helo_response
2953 #endif
2954 );
2955 }
2956
2957
2958 SEND_QUIT:
2959
2960 if (sx->send_quit)
2961 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2962
2963 #ifndef DISABLE_TLS
2964 if (sx->cctx.tls_ctx)
2965 {
2966 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2967 sx->cctx.tls_ctx = NULL;
2968 }
2969 #endif
2970
2971 /* Close the socket, and return the appropriate value, first setting
2972 works because the NULL setting is passed back to the calling process, and
2973 remote_max_parallel is forced to 1 when delivering over an existing connection,
2974 */
2975
2976 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2977 if (sx->send_quit)
2978 {
2979 shutdown(sx->cctx.sock, SHUT_WR);
2980 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2981 for (int i = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && i > 0;)
2982 i--; /* drain socket */
2983 sx->send_quit = FALSE;
2984 }
2985 (void)close(sx->cctx.sock);
2986 sx->cctx.sock = -1;
2987
2988 #ifndef DISABLE_EVENT
2989 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2990 #endif
2991
2992 continue_transport = NULL;
2993 continue_hostname = NULL;
2994 return yield;
2995 }
2996
2997
2998
2999
3000 /* Create the string of options that will be appended to the MAIL FROM:
3001 in the connection context buffer */
3002
3003 static int
3004 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
3005 {
3006 uschar * p = sx->buffer;
3007 address_item * addr;
3008 int address_count;
3009
3010 *p = 0;
3011
3012 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
3013 send it, adding something to the message size to allow for imprecision
3014 and things that get added en route. Exim keeps the number of lines
3015 in a message, so we can give an accurate value for the original message, but we
3016 need some additional to handle added headers. (Double "." characters don't get
3017 included in the count.) */
3018
3019 if ( message_size > 0
3020 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
3021 {
3022 /*XXX problem here under spool_files_wireformat?
3023 Or just forget about lines? Or inflate by a fixed proportion? */
3024
3025 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
3026 while (*p) p++;
3027 }
3028
3029 #ifndef DISABLE_PRDR
3030 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
3031 request that */
3032
3033 sx->prdr_active = FALSE;
3034 if (sx->peer_offered & OPTION_PRDR)
3035 for (address_item * addr = addrlist; addr; addr = addr->next)
3036 if (addr->transport_return == PENDING_DEFER)
3037 {
3038 for (addr = addr->next; addr; addr = addr->next)
3039 if (addr->transport_return == PENDING_DEFER)
3040 { /* at least two recipients to send */
3041 sx->prdr_active = TRUE;
3042 sprintf(CS p, " PRDR"); p += 5;
3043 break;
3044 }
3045 break;
3046 }
3047 #endif
3048
3049 #ifdef SUPPORT_I18N
3050 /* If it supports internationalised messages, and this meesage need that,
3051 request it */
3052
3053 if ( sx->peer_offered & OPTION_UTF8
3054 && addrlist->prop.utf8_msg
3055 && !addrlist->prop.utf8_downcvt
3056 )
3057 Ustrcpy(p, US" SMTPUTF8"), p += 9;
3058 #endif
3059
3060 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3061 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3062 addr && address_count < sx->max_rcpt;
3063 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3064 {
3065 address_count++;
3066 if (!(addr->dsn_flags & rf_dsnlasthop))
3067 {
3068 sx->dsn_all_lasthop = FALSE;
3069 break;
3070 }
3071 }
3072
3073 /* Add any DSN flags to the mail command */
3074
3075 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3076 {
3077 if (dsn_ret == dsn_ret_hdrs)
3078 { Ustrcpy(p, US" RET=HDRS"); p += 9; }
3079 else if (dsn_ret == dsn_ret_full)
3080 { Ustrcpy(p, US" RET=FULL"); p += 9; }
3081
3082 if (dsn_envid)
3083 {
3084 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3085 while (*p) p++;
3086 }
3087 }
3088
3089 /* If an authenticated_sender override has been specified for this transport
3090 instance, expand it. If the expansion is forced to fail, and there was already
3091 an authenticated_sender for this message, the original value will be used.
3092 Other expansion failures are serious. An empty result is ignored, but there is
3093 otherwise no check - this feature is expected to be used with LMTP and other
3094 cases where non-standard addresses (e.g. without domains) might be required. */
3095
3096 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3097 return ERROR;
3098
3099 return OK;
3100 }
3101
3102
3103 static void
3104 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3105 {
3106 uschar * p = sx->buffer;
3107 *p = 0;
3108
3109 /* Add any DSN flags to the rcpt command */
3110
3111 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3112 {
3113 if (addr->dsn_flags & rf_dsnflags)
3114 {
3115 BOOL first = TRUE;
3116
3117 Ustrcpy(p, US" NOTIFY=");
3118 while (*p) p++;
3119 for (int i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3120 {
3121 if (!first) *p++ = ',';
3122 first = FALSE;
3123 Ustrcpy(p, rf_names[i]);
3124 while (*p) p++;
3125 }
3126 }
3127
3128 if (addr->dsn_orcpt)
3129 {
3130 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3131 addr->dsn_orcpt);
3132 while (*p) p++;
3133 }
3134 }
3135 }
3136
3137
3138
3139 /*
3140 Return:
3141 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3142 -1 MAIL response error
3143 -2 any non-MAIL read i/o error
3144 -3 non-MAIL response timeout
3145 -4 internal error; channel still usable
3146 -5 transmit failed
3147 */
3148
3149 int
3150 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3151 {
3152 address_item * addr;
3153 int address_count;
3154 int rc;
3155
3156 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3157 {
3158 *yield = ERROR;
3159 return -4;
3160 }
3161
3162 /* From here until we send the DATA command, we can make use of PIPELINING
3163 if the server host supports it. The code has to be able to check the responses
3164 at any point, for when the buffer fills up, so we write it totally generally.
3165 When PIPELINING is off, each command written reports that it has flushed the
3166 buffer. */
3167
3168 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3169
3170 {
3171 uschar * s = sx->from_addr;
3172 #ifdef SUPPORT_I18N
3173 uschar * errstr = NULL;
3174
3175 /* If we must downconvert, do the from-address here. Remember we had to
3176 for the to-addresses (done below), and also (ugly) for re-doing when building
3177 the delivery log line. */
3178
3179 if ( sx->addrlist->prop.utf8_msg
3180 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3181 )
3182 {
3183 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3184 {
3185 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3186 *yield = ERROR;
3187 return -4;
3188 }
3189 setflag(sx->addrlist, af_utf8_downcvt);
3190 }
3191 #endif
3192
3193 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3194 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3195 }
3196
3197 mail_command = string_copy(big_buffer); /* Save for later error message */
3198
3199 switch(rc)
3200 {
3201 case -1: /* Transmission error */
3202 return -5;
3203
3204 case +1: /* Cmd was sent */
3205 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3206 (SOB sx->conn_args.ob)->command_timeout))
3207 {
3208 if (errno == 0 && sx->buffer[0] == '4')
3209 {
3210 errno = ERRNO_MAIL4XX;
3211 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3212 }
3213 return -1;
3214 }
3215 sx->pending_MAIL = FALSE;
3216 break;
3217
3218 /* otherwise zero: command queued for pipeline */
3219 }
3220
3221 /* Pass over all the relevant recipient addresses for this host, which are the
3222 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3223 several before we have to read the responses for those seen so far. This
3224 checking is done by a subroutine because it also needs to be done at the end.
3225 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3226 the next one if not all are sent.
3227
3228 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3229 last address because we want to abort if any recipients have any kind of
3230 problem, temporary or permanent. We know that all recipient addresses will have
3231 the PENDING_DEFER status, because only one attempt is ever made, and we know
3232 that max_rcpt will be large, so all addresses will be done at once.
3233
3234 For verify we flush the pipeline after any (the only) rcpt address. */
3235
3236 for (addr = sx->first_addr, address_count = 0;
3237 addr && address_count < sx->max_rcpt;
3238 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3239 {
3240 int count;
3241 BOOL no_flush;
3242 uschar * rcpt_addr;
3243
3244 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3245 ? dsn_support_yes : dsn_support_no;
3246
3247 address_count++;
3248 no_flush = pipelining_active && !sx->verify
3249 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3250
3251 build_rcptcmd_options(sx, addr);
3252
3253 /* Now send the RCPT command, and process outstanding responses when
3254 necessary. After a timeout on RCPT, we just end the function, leaving the
3255 yield as OK, because this error can often mean that there is a problem with
3256 just one address, so we don't want to delay the host. */
3257
3258 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3259
3260 #ifdef SUPPORT_I18N
3261 if ( testflag(sx->addrlist, af_utf8_downcvt)
3262 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3263 )
3264 {
3265 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3266 errno = ERRNO_EXPANDFAIL;
3267 return -5; /*XXX too harsh? */
3268 }
3269 #endif
3270
3271 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3272 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3273
3274 if (count < 0) return -5;
3275 if (count > 0)
3276 {
3277 switch(sync_responses(sx, count, 0))
3278 {
3279 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3280 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3281 break;
3282
3283 case 1: sx->ok = TRUE