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