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