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