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