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