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