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