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