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