Fix DKIM verify operation in -bh test mode. Bug 2017
[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 {
f358d5e0 585 *message = US string_sprintf("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
1250/*
1251Create a unique string that identifies this message, it is based on
1252sender_address, helo_data and tls_certificate if enabled. */
1253
1254static uschar *
1255smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1256{
1257address_item * addr1;
1258uschar * if1 = US"";
1259uschar * helo1 = US"";
1260#ifdef SUPPORT_TLS
1261uschar * tlsc1 = US"";
1262#endif
1263uschar * save_sender_address = sender_address;
1264uschar * local_identity = NULL;
1265smtp_transport_options_block * ob =
1266 (smtp_transport_options_block *)tblock->options_block;
1267
1268sender_address = sender;
1269
1270addr1 = deliver_make_addr (sender, TRUE);
1271deliver_set_expansions(addr1);
1272
1273if (ob->interface)
1274 if1 = expand_string(ob->interface);
1275
1276if (ob->helo_data)
1277 helo1 = expand_string(ob->helo_data);
1278
1279#ifdef SUPPORT_TLS
1280if (ob->tls_certificate)
1281 tlsc1 = expand_string(ob->tls_certificate);
1282local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1283#else
1284local_identity = string_sprintf ("%s^%s", if1, helo1);
1285#endif
1286
1287deliver_set_expansions(NULL);
1288sender_address = save_sender_address;
1289
1290return local_identity;
1291}
1292
1293
1294
1295/* This routine is a callback that is called from transport_check_waiting.
1296This function will evaluate the incoming message versus the previous
1297message. If the incoming message is using a different local identity then
1298we will veto this new message. */
1299
1300static BOOL
1301smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1302{
dadff1d4
HSHR
1303uschar * message_local_identity,
1304 * current_local_identity,
1305 * new_sender_address;
1306
1307current_local_identity =
a39bd74d 1308 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
a39bd74d 1309
dadff1d4
HSHR
1310if (!(new_sender_address = deliver_get_sender_address(message_id)))
1311 return 0;
1312
1313message_local_identity =
1314 smtp_local_identity(new_sender_address, s_compare->tblock);
a39bd74d
JB
1315
1316return Ustrcmp(current_local_identity, message_local_identity) == 0;
1317}
1318
1319
1320
9094b84b
JH
1321uschar
1322ehlo_response(uschar * buf, size_t bsize, uschar checks)
1323{
1324#ifdef SUPPORT_TLS
ff5aac2b
JH
1325if ( checks & PEER_OFFERED_TLS
1326 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1327 checks &= ~PEER_OFFERED_TLS;
9094b84b
JH
1328#endif
1329
ff5aac2b
JH
1330if ( checks & PEER_OFFERED_IGNQ
1331 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1332 PCRE_EOPT, NULL, 0) < 0)
1333 checks &= ~PEER_OFFERED_IGNQ;
9094b84b 1334
f98442df
JH
1335if ( checks & PEER_OFFERED_CHUNKING
1336 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1337 checks &= ~PEER_OFFERED_CHUNKING;
1338
9094b84b 1339#ifndef DISABLE_PRDR
ff5aac2b
JH
1340if ( checks & PEER_OFFERED_PRDR
1341 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1342 checks &= ~PEER_OFFERED_PRDR;
9094b84b
JH
1343#endif
1344
1345#ifdef SUPPORT_I18N
ff5aac2b
JH
1346if ( checks & PEER_OFFERED_UTF8
1347 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1348 checks &= ~PEER_OFFERED_UTF8;
9094b84b
JH
1349#endif
1350
ff5aac2b
JH
1351if ( checks & PEER_OFFERED_DSN
1352 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1353 checks &= ~PEER_OFFERED_DSN;
9094b84b 1354
ff5aac2b
JH
1355if ( checks & PEER_OFFERED_PIPE
1356 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1357 PCRE_EOPT, NULL, 0) < 0)
1358 checks &= ~PEER_OFFERED_PIPE;
9094b84b 1359
ff5aac2b
JH
1360if ( checks & PEER_OFFERED_SIZE
1361 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1362 checks &= ~PEER_OFFERED_SIZE;
9094b84b
JH
1363
1364return checks;
1365}
1366
1367
6d5c916c
JH
1368
1369/* Callback for emitting a BDAT data chunk header.
6d5c916c 1370
e027f545
JH
1371If given a nonzero size, first flush any buffered SMTP commands
1372then emit the command.
1373
1374Reap previous SMTP command responses if requested.
1375Reap one SMTP command response if requested.
6d5c916c
JH
1376
1377Returns: OK or ERROR
1378*/
1379
1380static int
1381smtp_chunk_cmd_callback(int fd, transport_ctx * tctx,
e027f545 1382 unsigned chunk_size, unsigned flags)
6d5c916c
JH
1383{
1384smtp_transport_options_block * ob =
1385 (smtp_transport_options_block *)(tctx->tblock->options_block);
e027f545
JH
1386int cmd_count = 0;
1387int prev_cmd_count;
1388uschar * buffer = tctx->buffer;
6d5c916c 1389
6d5c916c 1390
e027f545 1391/* Write SMTP chunk header command */
6d5c916c 1392
e027f545 1393if (chunk_size > 0)
87cb4a16 1394 {
e027f545
JH
1395 if((cmd_count = smtp_write_command(tctx->outblock, FALSE, "BDAT %u%s\r\n",
1396 chunk_size,
1397 flags & tc_chunk_last ? " LAST" : "")
1398 ) < 0) return ERROR;
87cb4a16
JH
1399 if (flags & tc_chunk_last)
1400 data_command = string_copy(big_buffer); /* Save for later error message */
1401 }
e027f545
JH
1402
1403prev_cmd_count = cmd_count += tctx->cmd_count;
6d5c916c 1404
e027f545 1405/* Reap responses for any previous, but not one we just emitted */
6d5c916c 1406
e027f545
JH
1407if (chunk_size > 0)
1408 prev_cmd_count--;
1409if (tctx->pending_BDAT)
1410 prev_cmd_count--;
6d5c916c 1411
e027f545 1412if (flags & tc_reap_prev && prev_cmd_count > 0)
6d5c916c 1413 {
58fc5fb2
JH
1414 DEBUG(D_transport) debug_printf("look for %d responses"
1415 " for previous pipelined cmds\n", prev_cmd_count);
6d5c916c 1416
e027f545
JH
1417 switch(sync_responses(tctx->first_addr, tctx->tblock->rcpt_include_affixes,
1418 tctx->sync_addr, tctx->host, prev_cmd_count,
1419 ob->address_retry_include_sender,
1420 tctx->pending_MAIL, 0,
1421 tctx->inblock,
1422 ob->command_timeout,
2d14f397 1423 buffer, DELIVER_BUFFER_SIZE))
e027f545
JH
1424 {
1425 case 1: /* 2xx (only) => OK */
1426 case 3: tctx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1427 case 2: *tctx->completed_address = TRUE; /* 5xx (only) => progress made */
1428 case 0: break; /* No 2xx or 5xx, but no probs */
1429
1430 case -1: /* Timeout on RCPT */
1431 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1432 }
1433 cmd_count = 1;
1434 if (!tctx->pending_BDAT)
1435 pipelining_active = FALSE;
6d5c916c 1436 }
e027f545 1437
58fc5fb2 1438/* Reap response for an outstanding BDAT */
e027f545 1439
58fc5fb2 1440if (tctx->pending_BDAT)
e027f545 1441 {
58fc5fb2
JH
1442 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1443
2d14f397 1444 if (!smtp_read_response(tctx->inblock, buffer, DELIVER_BUFFER_SIZE, '2',
e027f545
JH
1445 ob->command_timeout))
1446 {
1447 if (errno == 0 && buffer[0] == '4')
1448 {
1449 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1450 tctx->first_addr->more_errno |=
1451 ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
1452 }
1453 return ERROR;
1454 }
1455 cmd_count--;
1456 tctx->pending_BDAT = FALSE;
1457 pipelining_active = FALSE;
1458 }
1459else if (chunk_size > 0)
1460 tctx->pending_BDAT = TRUE;
1461
1462
1463tctx->cmd_count = cmd_count;
1464return OK;
6d5c916c
JH
1465}
1466
1467
1468
0756eb3c
PH
1469/*************************************************
1470* Deliver address list to given host *
1471*************************************************/
1472
1473/* If continue_hostname is not null, we get here only when continuing to
1474deliver down an existing channel. The channel was passed as the standard
6c512171
PH
1475input. TLS is never active on a passed channel; the previous process always
1476closes it down before passing the connection on.
0756eb3c
PH
1477
1478Otherwise, we have to make a connection to the remote host, and do the
1479initial protocol exchange.
1480
1481When running as an MUA wrapper, if the sender or any recipient is rejected,
1482temporarily or permanently, we force failure for all recipients.
1483
1484Arguments:
1485 addrlist chain of potential addresses to deliver; only those whose
1486 transport_return field is set to PENDING_DEFER are currently
1487 being processed; others should be skipped - they have either
1488 been delivered to an earlier host or IP address, or been
1489 failed by one of them.
1490 host host to deliver to
1491 host_af AF_INET or AF_INET6
2d280592 1492 port default TCP/IP port to use, in host byte order
0756eb3c
PH
1493 interface interface to bind to, or NULL
1494 tblock transport instance block
0756eb3c
PH
1495 message_defer set TRUE if yield is OK, but all addresses were deferred
1496 because of a non-recipient, non-host failure, that is, a
1497 4xx response to MAIL FROM, DATA, or ".". This is a defer
1498 that is specific to the message.
1499 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1500 a second attempt after TLS initialization fails
1501
1502Returns: OK - the connection was made and the delivery attempted;
1503 the result for each address is in its data block.
1504 DEFER - the connection could not be made, or something failed
1505 while setting up the SMTP session, or there was a
1506 non-message-specific error, such as a timeout.
1507 ERROR - a filter command is specified for this transport,
1508 and there was a problem setting it up; OR helo_data
1509 or add_headers or authenticated_sender is specified
1510 for this transport, and the string failed to expand
1511*/
1512
1513static int
1514smtp_deliver(address_item *addrlist, host_item *host, int host_af, int port,
d427a7f9 1515 uschar *interface, transport_instance *tblock,
0756eb3c
PH
1516 BOOL *message_defer, BOOL suppress_tls)
1517{
1518address_item *addr;
1519address_item *sync_addr;
1520address_item *first_addr = addrlist;
1521int yield = OK;
1522int address_count;
1523int save_errno;
1524int rc;
1525time_t start_delivery_time = time(NULL);
1526smtp_transport_options_block *ob =
1527 (smtp_transport_options_block *)(tblock->options_block);
59a286ef
JH
1528struct lflags {
1529 BOOL lmtp:1;
1530 BOOL smtps:1;
1531 BOOL ok:1;
1532 BOOL send_rset:1;
1533 BOOL send_quit:1;
1534 BOOL setting_up:1;
1535 BOOL esmtp:1;
a57ce043 1536 BOOL esmtp_sent:1;
59a286ef 1537 BOOL pending_MAIL:1;
8ccd00b1 1538#ifndef DISABLE_PRDR
59a286ef 1539 BOOL prdr_active:1;
fd98a5c6 1540#endif
8c5d388a 1541#ifdef SUPPORT_I18N
59a286ef
JH
1542 BOOL utf8_needed:1;
1543#endif
1544 BOOL dsn_all_lasthop:1;
1545#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
1546 BOOL dane:1;
1547 BOOL dane_required:1;
7ade712c 1548#endif
59a286ef
JH
1549} lflags;
1550
1551BOOL pass_message = FALSE;
1552BOOL completed_address = FALSE;
1553uschar peer_offered = 0;
0e66b3b6 1554#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
0e66b3b6
JH
1555dns_answer tlsa_dnsa;
1556#endif
0756eb3c
PH
1557smtp_inblock inblock;
1558smtp_outblock outblock;
1559int max_rcpt = tblock->max_addresses;
f1513293 1560uschar *igquotstr = US"";
a39bd74d 1561
895fbaf2
JH
1562#ifdef EXPERIMENTAL_DSN_INFO
1563uschar *smtp_greeting = NULL;
1564uschar *helo_response = NULL;
1565#endif
41c7c167 1566uschar *helo_data = NULL;
a39bd74d 1567
0756eb3c
PH
1568uschar *message = NULL;
1569uschar new_message_id[MESSAGE_ID_LENGTH + 1];
1570uschar *p;
2d14f397 1571uschar buffer[DELIVER_BUFFER_SIZE];
0756eb3c 1572uschar inbuffer[4096];
98470202 1573uschar outbuffer[4096];
0756eb3c
PH
1574
1575suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
1576
59a286ef
JH
1577lflags.lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1578lflags.smtps = strcmpic(ob->protocol, US"smtps") == 0;
1579lflags.ok = FALSE;
1580lflags.send_rset = TRUE;
1581lflags.send_quit = TRUE;
1582lflags.setting_up = TRUE;
1583lflags.esmtp = TRUE;
a57ce043 1584lflags.esmtp_sent = FALSE;
59a286ef
JH
1585#ifdef SUPPORT_I18N
1586lflags.utf8_needed = FALSE;
1587#endif
1588lflags.dsn_all_lasthop = TRUE;
1589#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
1590lflags.dane = FALSE;
1591lflags.dane_required = verify_check_given_host(&ob->hosts_require_dane, host) == OK;
1592#endif
1593
0756eb3c
PH
1594*message_defer = FALSE;
1595smtp_command = US"initial connection";
76ac1b5b 1596buffer[0] = '\0';
0756eb3c
PH
1597if (max_rcpt == 0) max_rcpt = 999999;
1598
1599/* Set up the buffer for reading SMTP response packets. */
1600
1601inblock.buffer = inbuffer;
1602inblock.buffersize = sizeof(inbuffer);
1603inblock.ptr = inbuffer;
1604inblock.ptrend = inbuffer;
1605
1606/* Set up the buffer for holding SMTP commands while pipelining */
1607
1608outblock.buffer = outbuffer;
1609outblock.buffersize = sizeof(outbuffer);
1610outblock.ptr = outbuffer;
1611outblock.cmd_count = 0;
1612outblock.authenticating = FALSE;
1613
6c512171
PH
1614/* Reset the parameters of a TLS session. */
1615
817d9f57
JH
1616tls_out.bits = 0;
1617tls_out.cipher = NULL; /* the one we may use for this transport */
9d1c15ef
JH
1618tls_out.ourcert = NULL;
1619tls_out.peercert = NULL;
817d9f57
JH
1620tls_out.peerdn = NULL;
1621#if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1622tls_out.sni = NULL;
5b456975 1623#endif
018058b2 1624tls_out.ocsp = OCSP_NOT_REQ;
6c512171 1625
35aba663
JH
1626/* Flip the legacy TLS-related variables over to the outbound set in case
1627they're used in the context of the transport. Don't bother resetting
1628afterward as we're in a subprocess. */
1629
1630tls_modify_variables(&tls_out);
1631
061b7ebd 1632#ifndef SUPPORT_TLS
59a286ef 1633if (lflags.smtps)
061b7ebd 1634 {
895fbaf2
JH
1635 set_errno_nohost(addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
1636 DEFER, FALSE);
018058b2 1637 return ERROR;
061b7ebd
PP
1638 }
1639#endif
1640
0756eb3c
PH
1641/* Make a connection to the host if this isn't a continued delivery, and handle
1642the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
1643specially so they can be identified for retries. */
1644
1645if (continue_hostname == NULL)
1646 {
a7538db1 1647 /* This puts port into host->port */
0756eb3c 1648 inblock.sock = outblock.sock =
7eb6c37c 1649 smtp_connect(host, host_af, port, interface, ob->connect_timeout, tblock);
4311097e 1650
0756eb3c
PH
1651 if (inblock.sock < 0)
1652 {
59a286ef 1653 set_errno_nohost(addrlist, errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
895fbaf2 1654 NULL, DEFER, FALSE);
0756eb3c
PH
1655 return DEFER;
1656 }
1657
0e66b3b6
JH
1658#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
1659 {
0e66b3b6
JH
1660 tls_out.dane_verified = FALSE;
1661 tls_out.tlsa_usage = 0;
1662
0e66b3b6
JH
1663 if (host->dnssec == DS_YES)
1664 {
59a286ef 1665 if( lflags.dane_required
4b0fe319 1666 || verify_check_given_host(&ob->hosts_try_dane, host) == OK
0e66b3b6 1667 )
59a286ef 1668 switch (rc = tlsa_lookup(host, &tlsa_dnsa, lflags.dane_required))
4b0fe319 1669 {
59a286ef 1670 case OK: lflags.dane = TRUE; break;
2d5fdd53
JH
1671 case FAIL_FORCED: break;
1672 default: set_errno_nohost(addrlist, ERRNO_DNSDEFER,
1673 string_sprintf("DANE error: tlsa lookup %s",
1674 rc == DEFER ? "DEFER" : "FAIL"),
1675 rc, FALSE);
1676 return rc;
4b0fe319 1677 }
0e66b3b6 1678 }
59a286ef 1679 else if (lflags.dane_required)
0e66b3b6 1680 {
895fbaf2 1681 set_errno_nohost(addrlist, ERRNO_DNSDEFER,
4cea764f 1682 string_sprintf("DANE error: %s lookup not DNSSEC", host->name),
895fbaf2 1683 FAIL, FALSE);
4b0fe319 1684 return FAIL;
0e66b3b6
JH
1685 }
1686
59a286ef 1687 if (lflags.dane)
0e66b3b6
JH
1688 ob->tls_tempfail_tryclear = FALSE;
1689 }
1690#endif /*DANE*/
1691
41c7c167
PH
1692 /* Expand the greeting message while waiting for the initial response. (Makes
1693 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
1694 delayed till here so that $sending_interface and $sending_port are set. */
1695
1696 helo_data = expand_string(ob->helo_data);
8c5d388a 1697#ifdef SUPPORT_I18N
810d16ad
JH
1698 if (helo_data)
1699 {
1700 uschar * errstr = NULL;
1701 if ((helo_data = string_domain_utf8_to_alabel(helo_data, &errstr)), errstr)
1702 {
1703 errstr = string_sprintf("failed to expand helo_data: %s", errstr);
895fbaf2 1704 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
810d16ad
JH
1705 yield = DEFER;
1706 goto SEND_QUIT;
1707 }
1708 }
1709#endif
41c7c167 1710
0756eb3c
PH
1711 /* The first thing is to wait for an initial OK response. The dreaded "goto"
1712 is nevertheless a reasonably clean way of programming this kind of logic,
1713 where you want to escape on any error. */
1714
59a286ef 1715 if (!lflags.smtps)
061b7ebd 1716 {
8d330698
JH
1717 BOOL good_response;
1718
1719#ifdef TCP_QUICKACK
1720 (void) setsockopt(inblock.sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
1721#endif
1722 good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
895fbaf2
JH
1723 '2', ob->command_timeout);
1724#ifdef EXPERIMENTAL_DSN_INFO
1725 smtp_greeting = string_copy(buffer);
1726#endif
1727 if (!good_response) goto RESPONSE_FAILED;
0756eb3c 1728
0cbf2b82 1729#ifndef DISABLE_EVENT
b30275b8 1730 {
805c9d53
JH
1731 uschar * s;
1732 lookup_dnssec_authenticated = host->dnssec==DS_YES ? US"yes"
1733 : host->dnssec==DS_NO ? US"no" : NULL;
1734 s = event_raise(tblock->event_action, US"smtp:connect", buffer);
b30275b8 1735 if (s)
a7538db1 1736 {
895fbaf2 1737 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL,
b30275b8 1738 string_sprintf("deferred by smtp:connect event expansion: %s", s),
895fbaf2 1739 DEFER, FALSE);
a7538db1
JH
1740 yield = DEFER;
1741 goto SEND_QUIT;
1742 }
b30275b8 1743 }
a7538db1
JH
1744#endif
1745
061b7ebd
PP
1746 /* Now check if the helo_data expansion went well, and sign off cleanly if
1747 it didn't. */
41c7c167 1748
8d330698 1749 if (!helo_data)
061b7ebd
PP
1750 {
1751 uschar *message = string_sprintf("failed to expand helo_data: %s",
1752 expand_string_message);
895fbaf2 1753 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
061b7ebd
PP
1754 yield = DEFER;
1755 goto SEND_QUIT;
1756 }
41c7c167
PH
1757 }
1758
0756eb3c
PH
1759/** Debugging without sending a message
1760addrlist->transport_return = DEFER;
1761goto SEND_QUIT;
1762**/
1763
1764 /* Errors that occur after this point follow an SMTP command, which is
1765 left in big_buffer by smtp_write_command() for use in error messages. */
1766
1767 smtp_command = big_buffer;
1768
1769 /* Tell the remote who we are...
1770
1771 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
1772 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
1773 greeting is of this form. The assumption was that the far end supports it
1774 properly... but experience shows that there are some that give 5xx responses,
1775 even though the banner includes "ESMTP" (there's a bloody-minded one that
1776 says "ESMTP not spoken here"). Cope with that case.
1777
1778 September 2000: Time has passed, and it seems reasonable now to always send
1779 EHLO at the start. It is also convenient to make the change while installing
1780 the TLS stuff.
1781
1782 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
1783 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
1784 would be no way to send out the mails, so there is now a host list
1785 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
1786 PIPELINING problem as well. Maybe it can also be useful to cure other
1787 problems with broken servers.
1788
1789 Exim originally sent "Helo" at this point and ran for nearly a year that way.
1790 Then somebody tried it with a Microsoft mailer... It seems that all other
1791 mailers use upper case for some reason (the RFC is quite clear about case
1792 independence) so, for peace of mind, I gave in. */
1793
59a286ef 1794 lflags.esmtp = verify_check_given_host(&ob->hosts_avoid_esmtp, host) != OK;
0756eb3c 1795
061b7ebd
PP
1796 /* Alas; be careful, since this goto is not an error-out, so conceivably
1797 we might set data between here and the target which we assume to exist
1798 and be usable. I can see this coming back to bite us. */
a7538db1 1799#ifdef SUPPORT_TLS
59a286ef 1800 if (lflags.smtps)
061b7ebd 1801 {
2d14f397 1802 smtp_peer_options |= PEER_OFFERED_TLS;
061b7ebd
PP
1803 suppress_tls = FALSE;
1804 ob->tls_tempfail_tryclear = FALSE;
1805 smtp_command = US"SSL-on-connect";
1806 goto TLS_NEGOTIATE;
1807 }
a7538db1 1808#endif
061b7ebd 1809
59a286ef 1810 if (lflags.esmtp)
0756eb3c
PH
1811 {
1812 if (smtp_write_command(&outblock, FALSE, "%s %s\r\n",
59a286ef 1813 lflags.lmtp ? "LHLO" : "EHLO", helo_data) < 0)
0756eb3c 1814 goto SEND_FAILED;
a57ce043 1815 lflags.esmtp_sent = TRUE;
0756eb3c
PH
1816 if (!smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
1817 ob->command_timeout))
1818 {
59a286ef 1819 if (errno != 0 || buffer[0] == 0 || lflags.lmtp)
895fbaf2
JH
1820 {
1821#ifdef EXPERIMENTAL_DSN_INFO
1822 helo_response = string_copy(buffer);
1823#endif
1824 goto RESPONSE_FAILED;
1825 }
59a286ef 1826 lflags.esmtp = FALSE;
0756eb3c 1827 }
895fbaf2
JH
1828#ifdef EXPERIMENTAL_DSN_INFO
1829 helo_response = string_copy(buffer);
1830#endif
0756eb3c
PH
1831 }
1832 else
0756eb3c
PH
1833 DEBUG(D_transport)
1834 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
0756eb3c 1835
59a286ef 1836 if (!lflags.esmtp)
0756eb3c 1837 {
895fbaf2 1838 BOOL good_response;
a57ce043
JH
1839 int n = sizeof(buffer);
1840 uschar * rsp = buffer;
1841
1842 if (lflags.esmtp_sent && (n = Ustrlen(buffer)) < sizeof(buffer)/2)
1843 { rsp = buffer + n + 1; n = sizeof(buffer) - n; }
895fbaf2 1844
0756eb3c
PH
1845 if (smtp_write_command(&outblock, FALSE, "HELO %s\r\n", helo_data) < 0)
1846 goto SEND_FAILED;
a57ce043 1847 good_response = smtp_read_response(&inblock, rsp, n,
895fbaf2
JH
1848 '2', ob->command_timeout);
1849#ifdef EXPERIMENTAL_DSN_INFO
a57ce043 1850 helo_response = string_copy(rsp);
895fbaf2 1851#endif
a57ce043
JH
1852 if (!good_response)
1853 {
1854 /* Handle special logging for a closed connection after HELO
1855 when had previously sent EHLO */
1856
1857 if (rsp != buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
1858 {
1859 message = NULL;
1860 lflags.send_quit = FALSE;
1861 save_errno = ERRNO_SMTPCLOSED;
1862 message = string_sprintf("Remote host closed connection "
1863 "in response to %s (EHLO response was: %s)",
1864 smtp_command, buffer);
1865 goto FAILED;
1866 }
1867 Ustrncpy(buffer, rsp, sizeof(buffer)/2);
1868 goto RESPONSE_FAILED;
1869 }
0756eb3c
PH
1870 }
1871
2d14f397
JH
1872 peer_offered = smtp_peer_options = 0;
1873
59a286ef 1874 if (lflags.esmtp || lflags.lmtp)
2d14f397 1875 {
9094b84b 1876 peer_offered = ehlo_response(buffer, Ustrlen(buffer),
ff5aac2b 1877 PEER_OFFERED_TLS /* others checked later */
9094b84b 1878 );
f1513293 1879
0756eb3c
PH
1880 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
1881
a7538db1 1882#ifdef SUPPORT_TLS
2d14f397 1883 smtp_peer_options |= peer_offered & PEER_OFFERED_TLS;
7ade712c 1884#endif
2d14f397 1885 }
0756eb3c
PH
1886 }
1887
1888/* For continuing deliveries down the same channel, the socket is the standard
1889input, and we don't need to redo EHLO here (but may need to do so for TLS - see
1890below). Set up the pointer to where subsequent commands will be left, for
2d14f397 1891error messages. Note that smtp_peer_options will have been
0756eb3c
PH
1892set from the command line if they were set in the process that passed the
1893connection on. */
1894
895fbaf2 1895/*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
4c04137d 1896as the continue goes via transport_pass_socket() and doublefork and exec.
895fbaf2
JH
1897It does not wait. Unclear how we keep separate host's responses
1898separate - we could match up by host ip+port as a bodge. */
1899
0756eb3c
PH
1900else
1901 {
1902 inblock.sock = outblock.sock = fileno(stdin);
1903 smtp_command = big_buffer;
4311097e 1904 host->port = port; /* Record the port that was used */
0756eb3c
PH
1905 }
1906
1907/* If TLS is available on this connection, whether continued or not, attempt to
1908start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
1909send another EHLO - the server may give a different answer in secure mode. We
1910use a separate buffer for reading the response to STARTTLS so that if it is
1911negative, the original EHLO data is available for subsequent analysis, should
1912the client not be required to use TLS. If the response is bad, copy the buffer
1913for error analysis. */
1914
1915#ifdef SUPPORT_TLS
2d14f397 1916if ( smtp_peer_options & PEER_OFFERED_TLS
5130845b
JH
1917 && !suppress_tls
1918 && verify_check_given_host(&ob->hosts_avoid_tls, host) != OK)
0756eb3c
PH
1919 {
1920 uschar buffer2[4096];
1921 if (smtp_write_command(&outblock, FALSE, "STARTTLS\r\n") < 0)
1922 goto SEND_FAILED;
1923
1924 /* If there is an I/O error, transmission of this message is deferred. If
1925 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
1926 false, we also defer. However, if there is a temporary rejection of STARTTLS
1927 and tls_tempfail_tryclear is true, or if there is an outright rejection of
1928 STARTTLS, we carry on. This means we will try to send the message in clear,
1929 unless the host is in hosts_require_tls (tested below). */
1930
1931 if (!smtp_read_response(&inblock, buffer2, sizeof(buffer2), '2',
1932 ob->command_timeout))
1933 {
4b0fe319
JH
1934 if ( errno != 0
1935 || buffer2[0] == 0
1936 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
1937 )
0dda4340
TK
1938 {
1939 Ustrncpy(buffer, buffer2, sizeof(buffer));
0756eb3c 1940 goto RESPONSE_FAILED;
0dda4340 1941 }
0756eb3c
PH
1942 }
1943
1944 /* STARTTLS accepted: try to negotiate a TLS session. */
1945
1946 else
061b7ebd 1947 TLS_NEGOTIATE:
0756eb3c 1948 {
0e66b3b6
JH
1949 int rc = tls_client_start(inblock.sock, host, addrlist, tblock
1950# ifdef EXPERIMENTAL_DANE
59a286ef 1951 , lflags.dane ? &tlsa_dnsa : NULL
0e66b3b6
JH
1952# endif
1953 );
0756eb3c
PH
1954
1955 /* TLS negotiation failed; give an error. From outside, this function may
1956 be called again to try in clear on a new connection, if the options permit
1957 it for this host. */
1958
1959 if (rc != OK)
1960 {
6ebd79ec 1961# ifdef EXPERIMENTAL_DANE
ae5afa61 1962 if (lflags.dane) log_write(0, LOG_MAIN,
4b0fe319 1963 "DANE attempt failed; no TLS connection to %s [%s]",
6ebd79ec 1964 host->name, host->address);
6ebd79ec
JH
1965# endif
1966
0756eb3c
PH
1967 save_errno = ERRNO_TLSFAILURE;
1968 message = US"failure while setting up TLS session";
59a286ef 1969 lflags.send_quit = FALSE;
0756eb3c
PH
1970 goto TLS_FAILED;
1971 }
1972
1973 /* TLS session is set up */
1974
2d14f397 1975 smtp_peer_options_wrap = smtp_peer_options;
895fbaf2 1976 for (addr = addrlist; addr; addr = addr->next)
5ca2a9a1
PH
1977 if (addr->transport_return == PENDING_DEFER)
1978 {
817d9f57 1979 addr->cipher = tls_out.cipher;
9d1c15ef
JH
1980 addr->ourcert = tls_out.ourcert;
1981 addr->peercert = tls_out.peercert;
817d9f57 1982 addr->peerdn = tls_out.peerdn;
018058b2 1983 addr->ocsp = tls_out.ocsp;
5ca2a9a1 1984 }
0756eb3c
PH
1985 }
1986 }
1987
061b7ebd
PP
1988/* if smtps, we'll have smtp_command set to something else; always safe to
1989reset it here. */
1990smtp_command = big_buffer;
1991
41c7c167
PH
1992/* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
1993helo_data is null, we are dealing with a connection that was passed from
1994another process, and so we won't have expanded helo_data above. We have to
1995expand it here. $sending_ip_address and $sending_port are set up right at the
1996start of the Exim process (in exim.c). */
0756eb3c 1997
817d9f57 1998if (tls_out.active >= 0)
0756eb3c 1999 {
061b7ebd 2000 char *greeting_cmd;
895fbaf2
JH
2001 BOOL good_response;
2002
41c7c167
PH
2003 if (helo_data == NULL)
2004 {
2005 helo_data = expand_string(ob->helo_data);
2006 if (helo_data == NULL)
2007 {
2008 uschar *message = string_sprintf("failed to expand helo_data: %s",
2009 expand_string_message);
895fbaf2 2010 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
41c7c167
PH
2011 yield = DEFER;
2012 goto SEND_QUIT;
2013 }
2014 }
2015
0d0e4455 2016 /* For SMTPS we need to wait for the initial OK response. */
59a286ef 2017 if (lflags.smtps)
061b7ebd 2018 {
895fbaf2
JH
2019 good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
2020 '2', ob->command_timeout);
2021#ifdef EXPERIMENTAL_DSN_INFO
2022 smtp_greeting = string_copy(buffer);
2023#endif
2024 if (!good_response) goto RESPONSE_FAILED;
0d0e4455
PP
2025 }
2026
59a286ef 2027 if (lflags.esmtp)
0d0e4455
PP
2028 greeting_cmd = "EHLO";
2029 else
2030 {
2031 greeting_cmd = "HELO";
2032 DEBUG(D_transport)
2033 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
061b7ebd
PP
2034 }
2035
2036 if (smtp_write_command(&outblock, FALSE, "%s %s\r\n",
59a286ef 2037 lflags.lmtp ? "LHLO" : greeting_cmd, helo_data) < 0)
0756eb3c 2038 goto SEND_FAILED;
895fbaf2
JH
2039 good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
2040 '2', ob->command_timeout);
2041#ifdef EXPERIMENTAL_DSN_INFO
2042 helo_response = string_copy(buffer);
2043#endif
2044 if (!good_response) goto RESPONSE_FAILED;
2d14f397 2045 smtp_peer_options = 0;
0756eb3c
PH
2046 }
2047
2048/* If the host is required to use a secure channel, ensure that we
2049have one. */
2050
59a286ef 2051else if ( lflags.smtps
0e66b3b6 2052# ifdef EXPERIMENTAL_DANE
59a286ef 2053 || lflags.dane
0e66b3b6 2054# endif
b4b3528b 2055 || verify_check_given_host(&ob->hosts_require_tls, host) == OK
7a31d643 2056 )
0756eb3c
PH
2057 {
2058 save_errno = ERRNO_TLSREQUIRED;
c562fd30 2059 message = string_sprintf("a TLS session is required, but %s",
2d14f397
JH
2060 smtp_peer_options & PEER_OFFERED_TLS
2061 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
0756eb3c
PH
2062 goto TLS_FAILED;
2063 }
0e66b3b6 2064#endif /*SUPPORT_TLS*/
0756eb3c
PH
2065
2066/* If TLS is active, we have just started it up and re-done the EHLO command,
2067so its response needs to be analyzed. If TLS is not active and this is a
2068continued session down a previously-used socket, we haven't just done EHLO, so
2069we skip this. */
2070
2071if (continue_hostname == NULL
a7538db1 2072#ifdef SUPPORT_TLS
817d9f57 2073 || tls_out.active >= 0
a7538db1 2074#endif
0756eb3c
PH
2075 )
2076 {
59a286ef 2077 if (lflags.esmtp || lflags.lmtp)
2d14f397 2078 {
9094b84b
JH
2079 peer_offered = ehlo_response(buffer, Ustrlen(buffer),
2080 0 /* no TLS */
59a286ef 2081 | (lflags.lmtp && ob->lmtp_ignore_quota ? PEER_OFFERED_IGNQ : 0)
f98442df 2082 | PEER_OFFERED_CHUNKING
9094b84b
JH
2083 | PEER_OFFERED_PRDR
2084#ifdef SUPPORT_I18N
2085 | (addrlist->prop.utf8_msg ? PEER_OFFERED_UTF8 : 0)
2d14f397 2086 /*XXX if we hand peercaps on to continued-conn processes,
9094b84b
JH
2087 must not depend on this addr */
2088#endif
2089 | PEER_OFFERED_DSN
2090 | PEER_OFFERED_PIPE
2091 | (ob->size_addition >= 0 ? PEER_OFFERED_SIZE : 0)
2092 );
2093
2d14f397
JH
2094 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2095 lmtp_ignore_quota option was set. */
f1513293 2096
2d14f397 2097 igquotstr = peer_offered & PEER_OFFERED_IGNQ ? US" IGNOREQUOTA" : US"";
f1513293 2098
2d14f397
JH
2099 /* If the response to EHLO specified support for the SIZE parameter, note
2100 this, provided size_addition is non-negative. */
f1513293 2101
2d14f397 2102 smtp_peer_options |= peer_offered & PEER_OFFERED_SIZE;
0756eb3c 2103
2d14f397
JH
2104 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2105 the current host, esmtp will be false, so PIPELINING can never be used. If
2106 the current host matches hosts_avoid_pipelining, don't do it. */
0756eb3c 2107
2d14f397
JH
2108 if ( peer_offered & PEER_OFFERED_PIPE
2109 && verify_check_given_host(&ob->hosts_avoid_pipelining, host) != OK)
2110 smtp_peer_options |= PEER_OFFERED_PIPE;
0756eb3c 2111
2d14f397
JH
2112 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2113 smtp_peer_options & PEER_OFFERED_PIPE ? "" : "not ");
0756eb3c 2114
2d14f397
JH
2115 if ( peer_offered & PEER_OFFERED_CHUNKING
2116 && verify_check_given_host(&ob->hosts_try_chunking, host) != OK)
2117 peer_offered &= ~PEER_OFFERED_CHUNKING;
f98442df 2118
2d14f397
JH
2119 if (peer_offered & PEER_OFFERED_CHUNKING)
2120 {DEBUG(D_transport) debug_printf("CHUNKING usable\n");}
0756eb3c 2121
8ccd00b1 2122#ifndef DISABLE_PRDR
2d14f397
JH
2123 if ( peer_offered & PEER_OFFERED_PRDR
2124 && verify_check_given_host(&ob->hosts_try_prdr, host) != OK)
2125 peer_offered &= ~PEER_OFFERED_PRDR;
fd98a5c6 2126
2d14f397
JH
2127 if (peer_offered & PEER_OFFERED_PRDR)
2128 {DEBUG(D_transport) debug_printf("PRDR usable\n");}
fd98a5c6
JH
2129#endif
2130
2d14f397
JH
2131 /* Note if the server supports DSN */
2132 smtp_peer_options |= peer_offered & PEER_OFFERED_DSN;
2133 DEBUG(D_transport) debug_printf("%susing DSN\n",
2134 peer_offered & PEER_OFFERED_DSN ? "" : "not ");
6c1c3d1d 2135
2d14f397
JH
2136 /* Note if the response to EHLO specifies support for the AUTH extension.
2137 If it has, check that this host is one we want to authenticate to, and do
2138 the business. The host name and address must be available when the
2139 authenticator's client driver is running. */
0756eb3c 2140
2d14f397 2141 switch (yield = smtp_auth(buffer, sizeof(buffer), addrlist, host,
59a286ef 2142 ob, lflags.esmtp, &inblock, &outblock))
2d14f397
JH
2143 {
2144 default: goto SEND_QUIT;
2145 case OK: break;
2146 case FAIL_SEND: goto SEND_FAILED;
2147 case FAIL: goto RESPONSE_FAILED;
2148 }
0756eb3c
PH
2149 }
2150 }
2d14f397 2151pipelining_active = !!(smtp_peer_options & PEER_OFFERED_PIPE);
0756eb3c
PH
2152
2153/* The setting up of the SMTP call is now complete. Any subsequent errors are
2154message-specific. */
2155
59a286ef 2156lflags.setting_up = FALSE;
0756eb3c 2157
8c5d388a 2158#ifdef SUPPORT_I18N
9094b84b
JH
2159if (addrlist->prop.utf8_msg)
2160 {
59a286ef
JH
2161 lflags.utf8_needed = !addrlist->prop.utf8_downcvt
2162 && !addrlist->prop.utf8_downcvt_maybe;
2163 DEBUG(D_transport) if (!lflags.utf8_needed)
2164 debug_printf("utf8: %s downconvert\n",
2165 addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
9094b84b
JH
2166 }
2167
7ade712c 2168/* If this is an international message we need the host to speak SMTPUTF8 */
59a286ef 2169if (lflags.utf8_needed && !(peer_offered & PEER_OFFERED_UTF8))
7ade712c
JH
2170 {
2171 errno = ERRNO_UTF8_FWD;
2172 goto RESPONSE_FAILED;
2173 }
2174#endif
2175
0756eb3c
PH
2176/* If there is a filter command specified for this transport, we can now
2177set it up. This cannot be done until the identify of the host is known. */
2178
2179if (tblock->filter_command != NULL)
2180 {
2181 BOOL rc;
76ac1b5b
JH
2182 uschar fbuf[64];
2183 sprintf(CS fbuf, "%.50s transport", tblock->name);
0756eb3c 2184 rc = transport_set_up_command(&transport_filter_argv, tblock->filter_command,
76ac1b5b 2185 TRUE, DEFER, addrlist, fbuf, NULL);
9b989985 2186 transport_filter_timeout = tblock->filter_timeout;
0756eb3c
PH
2187
2188 /* On failure, copy the error to all addresses, abandon the SMTP call, and
2189 yield ERROR. */
2190
2191 if (!rc)
2192 {
895fbaf2
JH
2193 set_errno_nohost(addrlist->next, addrlist->basic_errno, addrlist->message, DEFER,
2194 FALSE);
0756eb3c
PH
2195 yield = ERROR;
2196 goto SEND_QUIT;
2197 }
48f1c853
JH
2198
2199 if ( transport_filter_argv
2200 && *transport_filter_argv
2201 && **transport_filter_argv
2202 && peer_offered & PEER_OFFERED_CHUNKING
2203 )
2204 {
2205 peer_offered &= ~PEER_OFFERED_CHUNKING;
2206 DEBUG(D_transport) debug_printf("CHUNKING not usable due to transport filter\n");
2207 }
0756eb3c
PH
2208 }
2209
2210
2211/* For messages that have more than the maximum number of envelope recipients,
2212we want to send several transactions down the same SMTP connection. (See
2213comments in deliver.c as to how this reconciles, heuristically, with
2214remote_max_parallel.) This optimization was added to Exim after the following
2215code was already working. The simplest way to put it in without disturbing the
2216code was to use a goto to jump back to this point when there is another
2217transaction to handle. */
2218
2219SEND_MESSAGE:
2220sync_addr = first_addr;
2221address_count = 0;
59a286ef
JH
2222lflags.ok = FALSE;
2223lflags.send_rset = TRUE;
0756eb3c
PH
2224completed_address = FALSE;
2225
2226
2227/* Initiate a message transfer. If we know the receiving MTA supports the SIZE
2228qualification, send it, adding something to the message size to allow for
2229imprecision and things that get added en route. Exim keeps the number of lines
2230in a message, so we can give an accurate value for the original message, but we
2231need some additional to handle added headers. (Double "." characters don't get
2232included in the count.) */
2233
2234p = buffer;
2235*p = 0;
2236
2d14f397 2237if (peer_offered & PEER_OFFERED_SIZE)
0756eb3c
PH
2238 {
2239 sprintf(CS p, " SIZE=%d", message_size+message_linecount+ob->size_addition);
2240 while (*p) p++;
2241 }
2242
8ccd00b1 2243#ifndef DISABLE_PRDR
59a286ef 2244lflags.prdr_active = FALSE;
9094b84b 2245if (peer_offered & PEER_OFFERED_PRDR)
fd98a5c6
JH
2246 for (addr = first_addr; addr; addr = addr->next)
2247 if (addr->transport_return == PENDING_DEFER)
2248 {
2249 for (addr = addr->next; addr; addr = addr->next)
2250 if (addr->transport_return == PENDING_DEFER)
2251 { /* at least two recipients to send */
59a286ef 2252 lflags.prdr_active = TRUE;
fd98a5c6 2253 sprintf(CS p, " PRDR"); p += 5;
a7538db1 2254 break;
fd98a5c6
JH
2255 }
2256 break;
2257 }
fd98a5c6
JH
2258#endif
2259
8c5d388a 2260#ifdef SUPPORT_I18N
9094b84b
JH
2261if ( addrlist->prop.utf8_msg
2262 && !addrlist->prop.utf8_downcvt
2263 && peer_offered & PEER_OFFERED_UTF8
2264 )
7ade712c
JH
2265 sprintf(CS p, " SMTPUTF8"), p += 9;
2266#endif
2267
6c1c3d1d
WB
2268/* check if all addresses have lasthop flag */
2269/* do not send RET and ENVID if true */
59a286ef 2270for (lflags.dsn_all_lasthop = TRUE, addr = first_addr;
6c1c3d1d
WB
2271 address_count < max_rcpt && addr != NULL;
2272 addr = addr->next)
2273 if ((addr->dsn_flags & rf_dsnlasthop) != 1)
7ade712c 2274 {
59a286ef 2275 lflags.dsn_all_lasthop = FALSE;
7ade712c
JH
2276 break;
2277 }
6c1c3d1d
WB
2278
2279/* Add any DSN flags to the mail command */
2280
59a286ef 2281if (peer_offered & PEER_OFFERED_DSN && !lflags.dsn_all_lasthop)
6c1c3d1d
WB
2282 {
2283 if (dsn_ret == dsn_ret_hdrs)
6d5c916c 2284 { Ustrcpy(p, " RET=HDRS"); p += 9; }
6c1c3d1d 2285 else if (dsn_ret == dsn_ret_full)
6d5c916c
JH
2286 { Ustrcpy(p, " RET=FULL"); p += 9; }
2287
2288 if (dsn_envid)
6c1c3d1d
WB
2289 {
2290 string_format(p, sizeof(buffer) - (p-buffer), " ENVID=%s", dsn_envid);
2291 while (*p) p++;
2292 }
2293 }
6c1c3d1d 2294
6b62e899
JH
2295/* If an authenticated_sender override has been specified for this transport
2296instance, expand it. If the expansion is forced to fail, and there was already
2297an authenticated_sender for this message, the original value will be used.
2298Other expansion failures are serious. An empty result is ignored, but there is
2299otherwise no check - this feature is expected to be used with LMTP and other
2300cases where non-standard addresses (e.g. without domains) might be required. */
2301
fcc8e047 2302if (smtp_mail_auth_str(p, sizeof(buffer) - (p-buffer), addrlist, ob))
a7538db1
JH
2303 {
2304 yield = ERROR;
2305 goto SEND_QUIT;
2306 }
0756eb3c
PH
2307
2308/* From here until we send the DATA command, we can make use of PIPELINING
2309if the server host supports it. The code has to be able to check the responses
2310at any point, for when the buffer fills up, so we write it totally generally.
2311When PIPELINING is off, each command written reports that it has flushed the
2312buffer. */
2313
59a286ef 2314lflags.pending_MAIL = TRUE; /* The block starts with MAIL */
0756eb3c 2315
3c8b3577
JH
2316 {
2317 uschar * s = return_path;
8c5d388a 2318#ifdef SUPPORT_I18N
3c8b3577
JH
2319 uschar * errstr = NULL;
2320
2321 /* If we must downconvert, do the from-address here. Remember we had to
2322 for the to-addresses (done below), and also (ugly) for re-doing when building
2323 the delivery log line. */
2324
9094b84b
JH
2325 if ( addrlist->prop.utf8_msg
2326 && (addrlist->prop.utf8_downcvt || !(peer_offered & PEER_OFFERED_UTF8))
2327 )
3c8b3577
JH
2328 {
2329 if (s = string_address_utf8_to_alabel(return_path, &errstr), errstr)
2330 {
895fbaf2 2331 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3c8b3577
JH
2332 yield = ERROR;
2333 goto SEND_QUIT;
2334 }
2335 setflag(addrlist, af_utf8_downcvt);
2336 }
2337#endif
2338
2d14f397 2339 rc = smtp_write_command(&outblock, pipelining_active,
3c8b3577
JH
2340 "MAIL FROM:<%s>%s\r\n", s, buffer);
2341 }
2342
0756eb3c
PH
2343mail_command = string_copy(big_buffer); /* Save for later error message */
2344
2345switch(rc)
2346 {
2347 case -1: /* Transmission error */
7ade712c 2348 goto SEND_FAILED;
0756eb3c
PH
2349
2350 case +1: /* Block was sent */
7ade712c 2351 if (!smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
e97957bc 2352 ob->command_timeout))
e97957bc 2353 {
7ade712c
JH
2354 if (errno == 0 && buffer[0] == '4')
2355 {
2356 errno = ERRNO_MAIL4XX;
2357 addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
2358 }
2359 goto RESPONSE_FAILED;
e97957bc 2360 }
59a286ef 2361 lflags.pending_MAIL = FALSE;
7ade712c 2362 break;
0756eb3c
PH
2363 }
2364
2365/* Pass over all the relevant recipient addresses for this host, which are the
2366ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
2367several before we have to read the responses for those seen so far. This
2368checking is done by a subroutine because it also needs to be done at the end.
2369Send only up to max_rcpt addresses at a time, leaving first_addr pointing to
2370the next one if not all are sent.
2371
2372In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
2373last address because we want to abort if any recipients have any kind of
2374problem, temporary or permanent. We know that all recipient addresses will have
2375the PENDING_DEFER status, because only one attempt is ever made, and we know
2376that max_rcpt will be large, so all addresses will be done at once. */
2377
2378for (addr = first_addr;
ff5aac2b 2379 addr && address_count < max_rcpt;
0756eb3c 2380 addr = addr->next)
7b4c8c1f 2381 if (addr->transport_return == PENDING_DEFER)
0756eb3c
PH
2382 {
2383 int count;
2384 BOOL no_flush;
3c8b3577 2385 uschar * rcpt_addr;
0756eb3c 2386
2d14f397
JH
2387 addr->dsn_aware = peer_offered & PEER_OFFERED_DSN
2388 ? dsn_support_yes : dsn_support_no;
6c1c3d1d 2389
0756eb3c 2390 address_count++;
2d14f397 2391 no_flush = pipelining_active && (!mua_wrapper || addr->next);
0756eb3c 2392
6c1c3d1d
WB
2393 /* Add any DSN flags to the rcpt command and add to the sent string */
2394
2395 p = buffer;
2396 *p = 0;
2397
2d14f397 2398 if (peer_offered & PEER_OFFERED_DSN && !(addr->dsn_flags & rf_dsnlasthop))
6c1c3d1d 2399 {
2d14f397 2400 if (addr->dsn_flags & rf_dsnflags)
6c1c3d1d
WB
2401 {
2402 int i;
2403 BOOL first = TRUE;
45500060 2404 Ustrcpy(p, " NOTIFY=");
6c1c3d1d
WB
2405 while (*p) p++;
2406 for (i = 0; i < 4; i++)
6c1c3d1d
WB
2407 if ((addr->dsn_flags & rf_list[i]) != 0)
2408 {
2409 if (!first) *p++ = ',';
2410 first = FALSE;
45500060 2411 Ustrcpy(p, rf_names[i]);
6c1c3d1d
WB
2412 while (*p) p++;
2413 }
6c1c3d1d
WB
2414 }
2415
ff5aac2b 2416 if (addr->dsn_orcpt)
a7538db1 2417 {
6c1c3d1d
WB
2418 string_format(p, sizeof(buffer) - (p-buffer), " ORCPT=%s",
2419 addr->dsn_orcpt);
2420 while (*p) p++;
2421 }
2422 }
6c1c3d1d 2423
0756eb3c
PH
2424 /* Now send the RCPT command, and process outstanding responses when
2425 necessary. After a timeout on RCPT, we just end the function, leaving the
2426 yield as OK, because this error can often mean that there is a problem with
2427 just one address, so we don't want to delay the host. */
2428
3c8b3577
JH
2429 rcpt_addr = transport_rcpt_address(addr, tblock->rcpt_include_affixes);
2430
8c5d388a 2431#ifdef SUPPORT_I18N
3c8b3577 2432 if ( testflag(addrlist, af_utf8_downcvt)
9427e879
JH
2433 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
2434 )
3c8b3577 2435 {
9427e879 2436 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3c8b3577
JH
2437 errno = ERRNO_EXPANDFAIL;
2438 goto SEND_FAILED;
2439 }
3c8b3577
JH
2440#endif
2441
6c1c3d1d 2442 count = smtp_write_command(&outblock, no_flush, "RCPT TO:<%s>%s%s\r\n",
3c8b3577 2443 rcpt_addr, igquotstr, buffer);
6c1c3d1d 2444
0756eb3c
PH
2445 if (count < 0) goto SEND_FAILED;
2446 if (count > 0)
2447 {
2448 switch(sync_responses(first_addr, tblock->rcpt_include_affixes,
48c7f9e2 2449 &sync_addr, host, count, ob->address_retry_include_sender,
59a286ef 2450 lflags.pending_MAIL, 0, &inblock, ob->command_timeout, buffer,
48c7f9e2 2451 sizeof(buffer)))
0756eb3c 2452 {
59a286ef 2453 case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
0756eb3c
PH
2454 case 2: completed_address = TRUE; /* 5xx (only) => progress made */
2455 break;
2456
59a286ef
JH
2457 case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
2458 if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
0756eb3c
PH
2459 case 0: /* No 2xx or 5xx, but no probs */
2460 break;
2461
2462 case -1: goto END_OFF; /* Timeout on RCPT */
2463 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL error */
2464 }
59a286ef 2465 lflags.pending_MAIL = FALSE; /* Dealt with MAIL */
0756eb3c
PH
2466 }
2467 } /* Loop for next address */
2468
2469/* If we are an MUA wrapper, abort if any RCPTs were rejected, either
2470permanently or temporarily. We should have flushed and synced after the last
2471RCPT. */
2472
2473if (mua_wrapper)
2474 {
2475 address_item *badaddr;
168dec3b
JH
2476 for (badaddr = first_addr; badaddr; badaddr = badaddr->next)
2477 if (badaddr->transport_return != PENDING_OK)
2478 {
2479 /*XXX could we find a better errno than 0 here? */
895fbaf2
JH
2480 set_errno_nohost(addrlist, 0, badaddr->message, FAIL,
2481 testflag(badaddr, af_pass_message));
59a286ef 2482 lflags.ok = FALSE;
168dec3b
JH
2483 break;
2484 }
0756eb3c
PH
2485 }
2486
2487/* If ok is TRUE, we know we have got at least one good recipient, and must now
2488send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
2489have a good recipient buffered up if we are pipelining. We don't want to waste
2490time sending DATA needlessly, so we only send it if either ok is TRUE or if we
6d5c916c
JH
2491are pipelining. The responses are all handled by sync_responses().
2492If using CHUNKING, do not send a BDAT until we know how big a chunk we want
2493to send is. */
0756eb3c 2494
6d5c916c 2495if ( !(peer_offered & PEER_OFFERED_CHUNKING)
59a286ef 2496 && (lflags.ok || (pipelining_active && !mua_wrapper)))
0756eb3c
PH
2497 {
2498 int count = smtp_write_command(&outblock, FALSE, "DATA\r\n");
6d5c916c 2499
0756eb3c
PH
2500 if (count < 0) goto SEND_FAILED;
2501 switch(sync_responses(first_addr, tblock->rcpt_include_affixes, &sync_addr,
59a286ef
JH
2502 host, count, ob->address_retry_include_sender, lflags.pending_MAIL,
2503 lflags.ok ? +1 : -1, &inblock, ob->command_timeout, buffer, sizeof(buffer)))
0756eb3c 2504 {
59a286ef 2505 case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
0756eb3c
PH
2506 case 2: completed_address = TRUE; /* 5xx (only) => progress made */
2507 break;
2508
59a286ef
JH
2509 case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
2510 if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
0756eb3c
PH
2511 case 0: break; /* No 2xx or 5xx, but no probs */
2512
2513 case -1: goto END_OFF; /* Timeout on RCPT */
2514 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
2515 }
0d9fa8c0 2516 pipelining_active = FALSE;
87cb4a16 2517 data_command = string_copy(big_buffer); /* Save for later error message */
0756eb3c
PH
2518 }
2519
0756eb3c
PH
2520/* If there were no good recipients (but otherwise there have been no
2521problems), just set ok TRUE, since we have handled address-specific errors
2522already. Otherwise, it's OK to send the message. Use the check/escape mechanism
2523for handling the SMTP dot-handling protocol, flagging to apply to headers as
2524well as body. Set the appropriate timeout value to be used for each chunk.
2525(Haven't been able to make it work using select() for writing yet.) */
2526
59a286ef 2527if (!(peer_offered & PEER_OFFERED_CHUNKING) && !lflags.ok)
6d5c916c
JH
2528 {
2529 /* Save the first address of the next batch. */
2530 first_addr = addr;
2531
59a286ef 2532 lflags.ok = TRUE;
6d5c916c 2533 }
ff5aac2b 2534else
0756eb3c 2535 {
6b46ecc6
JH
2536 transport_ctx tctx = {
2537 tblock,
2538 addrlist,
2539 US".", US"..", /* Escaping strings */
65de12cc 2540 topt_use_crlf | topt_escape_headers
6b46ecc6
JH
2541 | (tblock->body_only ? topt_no_headers : 0)
2542 | (tblock->headers_only ? topt_no_body : 0)
2543 | (tblock->return_path_add ? topt_add_return_path : 0)
2544 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
2545 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
2546 };
2547
6d5c916c
JH
2548 /* If using CHUNKING we need a callback from the generic transport
2549 support to us, for the sending of BDAT smtp commands and the reaping
2550 of responses. The callback needs a whole bunch of state so set up
2551 a transport-context structure to be passed around. */
2552
59932f7d
JH
2553 if (peer_offered & PEER_OFFERED_CHUNKING)
2554 {
65de12cc 2555 tctx.check_string = tctx.escape_string = NULL;
6d5c916c
JH
2556 tctx.options |= topt_use_bdat;
2557 tctx.chunk_cb = smtp_chunk_cmd_callback;
2558 tctx.inblock = &inblock;
2559 tctx.outblock = &outblock;
2560 tctx.host = host;
2561 tctx.first_addr = first_addr;
2562 tctx.sync_addr = &sync_addr;
59a286ef 2563 tctx.pending_MAIL = lflags.pending_MAIL;
e027f545 2564 tctx.pending_BDAT = FALSE;
59a286ef 2565 tctx.good_RCPT = lflags.ok;
6d5c916c 2566 tctx.completed_address = &completed_address;
e027f545
JH
2567 tctx.cmd_count = 0;
2568 tctx.buffer = buffer;
59932f7d
JH
2569 }
2570 else
65de12cc 2571 tctx.options |= topt_end_dot;
59932f7d 2572
6d5c916c
JH
2573 /* Save the first address of the next batch. */
2574 first_addr = addr;
2575
e027f545
JH
2576 /* Responses from CHUNKING commands go in buffer. Otherwise,
2577 there has not been a response. */
2578
2579 buffer[0] = 0;
2580
0756eb3c
PH
2581 sigalrm_seen = FALSE;
2582 transport_write_timeout = ob->data_timeout;
2583 smtp_command = US"sending data block"; /* For error messages */
2584 DEBUG(D_transport|D_v)
6d5c916c
JH
2585 if (peer_offered & PEER_OFFERED_CHUNKING)
2586 debug_printf(" will write message using CHUNKING\n");
2587 else
2588 debug_printf(" SMTP>> writing message and terminating \".\"\n");
0756eb3c 2589 transport_count = 0;
a7538db1 2590
80a47a2c 2591#ifndef DISABLE_DKIM
59a286ef 2592 lflags.ok = dkim_transport_write_message(inblock.sock, &tctx, &ob->dkim);
4cd12fe9 2593#else
59a286ef 2594 lflags.ok = transport_write_message(inblock.sock, &tctx, 0);
4cd12fe9 2595#endif
0756eb3c
PH
2596
2597 /* transport_write_message() uses write() because it is called from other
2598 places to write to non-sockets. This means that under some OS (e.g. Solaris)
2599 it can exit with "Broken pipe" as its error. This really means that the
2600 socket got closed at the far end. */
2601
2602 transport_write_timeout = 0; /* for subsequent transports */
2603
2604 /* Failure can either be some kind of I/O disaster (including timeout),
e027f545
JH
2605 or the failure of a transport filter or the expansion of added headers.
2606 Or, when CHUNKING, it can be a protocol-detected failure. */
0756eb3c 2607
59a286ef 2608 if (!lflags.ok)
0756eb3c 2609 goto RESPONSE_FAILED;
0756eb3c
PH
2610
2611 /* We used to send the terminating "." explicitly here, but because of
2612 buffering effects at both ends of TCP/IP connections, you don't gain
2613 anything by keeping it separate, so it might as well go in the final
2614 data buffer for efficiency. This is now done by setting the topt_end_dot
2615 flag above. */
2616
2617 smtp_command = US"end of data";
2618
6d5c916c
JH
2619 if (peer_offered & PEER_OFFERED_CHUNKING && tctx.cmd_count > 1)
2620 {
2621 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
2622 switch(sync_responses(first_addr, tblock->rcpt_include_affixes, &sync_addr,
2623 host, tctx.cmd_count-1, ob->address_retry_include_sender,
59a286ef 2624 lflags.pending_MAIL, 0,
6d5c916c
JH
2625 &inblock, ob->command_timeout, buffer, sizeof(buffer)))
2626 {
59a286ef 2627 case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
6d5c916c
JH
2628 case 2: completed_address = TRUE; /* 5xx (only) => progress made */
2629 break;
2630
59a286ef
JH
2631 case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
2632 if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
6d5c916c
JH
2633 case 0: break; /* No 2xx or 5xx, but no probs */
2634
2635 case -1: goto END_OFF; /* Timeout on RCPT */
2636 default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
2637 }
2638 }
2639
8ccd00b1 2640#ifndef DISABLE_PRDR
fd98a5c6
JH
2641 /* For PRDR we optionally get a partial-responses warning
2642 * followed by the individual responses, before going on with
2643 * the overall response. If we don't get the warning then deal
2644 * with per non-PRDR. */
59a286ef 2645 if(lflags.prdr_active)
fd98a5c6 2646 {
59a286ef 2647 lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '3',
fd98a5c6 2648 ob->final_timeout);
59a286ef 2649 if (!lflags.ok && errno == 0) switch(buffer[0])
e027f545 2650 {
59a286ef
JH
2651 case '2': lflags.prdr_active = FALSE;
2652 lflags.ok = TRUE;
e027f545
JH
2653 break;
2654 case '4': errno = ERRNO_DATA4XX;
2655 addrlist->more_errno |=
2656 ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
2657 break;
2658 }
fd98a5c6
JH
2659 }
2660 else
2661#endif
2662
2663 /* For non-PRDR SMTP, we now read a single response that applies to the
2664 whole message. If it is OK, then all the addresses have been delivered. */
0756eb3c 2665
59a286ef 2666 if (!lflags.lmtp)
e97957bc 2667 {
59a286ef 2668 lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
e97957bc 2669 ob->final_timeout);
59a286ef 2670 if (!lflags.ok && errno == 0 && buffer[0] == '4')
e97957bc
PH
2671 {
2672 errno = ERRNO_DATA4XX;
2673 addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
2674 }
2675 }
0756eb3c
PH
2676
2677 /* For LMTP, we get back a response for every RCPT command that we sent;
2678 some may be accepted and some rejected. For those that get a response, their
2679 status is fixed; any that are accepted have been handed over, even if later
2680 responses crash - at least, that's how I read RFC 2033.
2681
2682 If all went well, mark the recipient addresses as completed, record which
2683 host/IPaddress they were delivered to, and cut out RSET when sending another
2684 message down the same channel. Write the completed addresses to the journal
2685 now so that they are recorded in case there is a crash of hardware or
2686 software before the spool gets updated. Also record the final SMTP
2687 confirmation if needed (for SMTP only). */
2688
59a286ef 2689 if (lflags.ok)
0756eb3c
PH
2690 {
2691 int flag = '=';
2692 int delivery_time = (int)(time(NULL) - start_delivery_time);
2693 int len;
0756eb3c 2694 uschar *conf = NULL;
0d9fa8c0 2695
59a286ef 2696 lflags.send_rset = FALSE;
0d9fa8c0 2697 pipelining_active = FALSE;
0756eb3c 2698
0756eb3c
PH
2699 /* Set up confirmation if needed - applies only to SMTP */
2700
d68218c7 2701 if (
0cbf2b82 2702#ifdef DISABLE_EVENT
6c6d6e48 2703 LOGGING(smtp_confirmation) &&
a7538db1 2704#endif
59a286ef 2705 !lflags.lmtp
d68218c7 2706 )
0756eb3c 2707 {
55414b25
JH
2708 const uschar *s = string_printing(buffer);
2709 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
2710 conf = (s == buffer)? (uschar *)string_copy(s) : US s;
0756eb3c
PH
2711 }
2712
fd98a5c6 2713 /* Process all transported addresses - for LMTP or PRDR, read a status for
0756eb3c
PH
2714 each one. */
2715
2716 for (addr = addrlist; addr != first_addr; addr = addr->next)
2717 {
2718 if (addr->transport_return != PENDING_OK) continue;
2719
2720 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
2721 remaining addresses. Otherwise, it's a return code for just the one
75def545
PH
2722 address. For temporary errors, add a retry item for the address so that
2723 it doesn't get tried again too soon. */
0756eb3c 2724
8ccd00b1 2725#ifndef DISABLE_PRDR
59a286ef 2726 if (lflags.lmtp || lflags.prdr_active)
fd98a5c6 2727#else
59a286ef 2728 if (lflags.lmtp)
fd98a5c6 2729#endif
0756eb3c
PH
2730 {
2731 if (!smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
2732 ob->final_timeout))
2733 {
2734 if (errno != 0 || buffer[0] == 0) goto RESPONSE_FAILED;
fd98a5c6 2735 addr->message = string_sprintf(
8ccd00b1 2736#ifndef DISABLE_PRDR
59a286ef 2737 "%s error after %s: %s", lflags.prdr_active ? "PRDR":"LMTP",
fd98a5c6
JH
2738#else
2739 "LMTP error after %s: %s",
2740#endif
87cb4a16 2741 data_command, string_printing(buffer));
75def545
PH
2742 setflag(addr, af_pass_message); /* Allow message to go to user */
2743 if (buffer[0] == '5')
2744 addr->transport_return = FAIL;
2745 else
2746 {
e97957bc
PH
2747 errno = ERRNO_DATA4XX;
2748 addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
75def545 2749 addr->transport_return = DEFER;
8ccd00b1 2750#ifndef DISABLE_PRDR
59a286ef 2751 if (!lflags.prdr_active)
fd98a5c6
JH
2752#endif
2753 retry_add_item(addr, addr->address_retry_key, 0);
75def545 2754 }
0756eb3c
PH
2755 continue;
2756 }
2757 completed_address = TRUE; /* NOW we can set this flag */
6c6d6e48 2758 if (LOGGING(smtp_confirmation))
c0ea85ab 2759 {
55414b25
JH
2760 const uschar *s = string_printing(buffer);
2761 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
2762 conf = (s == buffer)? (uschar *)string_copy(s) : US s;
c0ea85ab 2763 }
0756eb3c
PH
2764 }
2765
2766 /* SMTP, or success return from LMTP for this address. Pass back the
2d280592 2767 actual host that was used. */
0756eb3c
PH
2768
2769 addr->transport_return = OK;
2770 addr->more_errno = delivery_time;
d427a7f9 2771 addr->host_used = host;
0756eb3c
PH
2772 addr->special_action = flag;
2773 addr->message = conf;
8ccd00b1 2774#ifndef DISABLE_PRDR
59a286ef 2775 if (lflags.prdr_active) addr->flags |= af_prdr_used;
fd98a5c6 2776#endif
e0cc6cda 2777 if (peer_offered & PEER_OFFERED_CHUNKING) addr->flags |= af_chunking_used;
0756eb3c
PH
2778 flag = '-';
2779
8ccd00b1 2780#ifndef DISABLE_PRDR
59a286ef 2781 if (!lflags.prdr_active)
fd98a5c6
JH
2782#endif
2783 {
2784 /* Update the journal. For homonymic addresses, use the base address plus
2785 the transport name. See lots of comments in deliver.c about the reasons
2786 for the complications when homonyms are involved. Just carry on after
2787 write error, as it may prove possible to update the spool file later. */
4d8d62b9 2788
fd98a5c6
JH
2789 if (testflag(addr, af_homonym))
2790 sprintf(CS buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
2791 else
2792 sprintf(CS buffer, "%.500s\n", addr->unique);
4d8d62b9 2793
895fbaf2 2794 DEBUG(D_deliver) debug_printf("journalling %s\n", buffer);
fd98a5c6
JH
2795 len = Ustrlen(CS buffer);
2796 if (write(journal_fd, buffer, len) != len)
2797 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
2798 "%s: %s", buffer, strerror(errno));
2799 }
0756eb3c
PH
2800 }
2801
8ccd00b1 2802#ifndef DISABLE_PRDR
59a286ef 2803 if (lflags.prdr_active)
fd98a5c6
JH
2804 {
2805 /* PRDR - get the final, overall response. For any non-success
2806 upgrade all the address statuses. */
59a286ef 2807 lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
fd98a5c6 2808 ob->final_timeout);
59a286ef 2809 if (!lflags.ok)
fd98a5c6
JH
2810 {
2811 if(errno == 0 && buffer[0] == '4')
2812 {
2813 errno = ERRNO_DATA4XX;
2814 addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
2815 }
2816 for (addr = addrlist; addr != first_addr; addr = addr->next)
2817 if (buffer[0] == '5' || addr->transport_return == OK)
2818 addr->transport_return = PENDING_OK; /* allow set_errno action */
2819 goto RESPONSE_FAILED;
2820 }
2821
2822 /* Update the journal, or setup retry. */
2823 for (addr = addrlist; addr != first_addr; addr = addr->next)
2824 if (addr->transport_return == OK)
2825 {
2826 if (testflag(addr, af_homonym))
2827 sprintf(CS buffer, "%.500s/%s\n", addr->unique + 3, tblock->name);
2828 else
2829 sprintf(CS buffer, "%.500s\n", addr->unique);
4d8d62b9 2830
895fbaf2 2831 DEBUG(D_deliver) debug_printf("journalling(PRDR) %s\n", buffer);
fd98a5c6
JH
2832 len = Ustrlen(CS buffer);
2833 if (write(journal_fd, buffer, len) != len)
2834 log_write(0, LOG_MAIN|LOG_PANIC, "failed to write journal for "
2835 "%s: %s", buffer, strerror(errno));
2836 }
2837 else if (addr->transport_return == DEFER)
2838 retry_add_item(addr, addr->address_retry_key, -2);
2839 }
2840#endif
2841
0756eb3c
PH
2842 /* Ensure the journal file is pushed out to disk. */
2843
54fc8428 2844 if (EXIMfsync(journal_fd) < 0)
0756eb3c
PH
2845 log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
2846 strerror(errno));
2847 }
2848 }
2849
2850
2851/* Handle general (not specific to one address) failures here. The value of ok
2852is used to skip over this code on the falling through case. A timeout causes a
2853deferral. Other errors may defer or fail according to the response code, and
2854may set up a special errno value, e.g. after connection chopped, which is
2855assumed if errno == 0 and there is no text in the buffer. If control reaches
2856here during the setting up phase (i.e. before MAIL FROM) then always defer, as
2857the problem is not related to this specific message. */
2858
59a286ef 2859if (!lflags.ok)
0756eb3c 2860 {
895fbaf2
JH
2861 int code, set_rc;
2862 uschar * set_message;
0756eb3c
PH
2863
2864 RESPONSE_FAILED:
895fbaf2
JH
2865 {
2866 save_errno = errno;
2867 message = NULL;
59a286ef 2868 lflags.send_quit = check_response(host, &save_errno, addrlist->more_errno,
895fbaf2
JH
2869 buffer, &code, &message, &pass_message);
2870 goto FAILED;
2871 }
0756eb3c
PH
2872
2873 SEND_FAILED:
895fbaf2
JH
2874 {
2875 save_errno = errno;
2876 code = '4';
2877 message = US string_sprintf("send() to %s [%s] failed: %s",
2878 host->name, host->address, strerror(save_errno));
59a286ef 2879 lflags.send_quit = FALSE;
895fbaf2
JH
2880 goto FAILED;
2881 }
0756eb3c
PH
2882
2883 /* This label is jumped to directly when a TLS negotiation has failed,
2884 or was not done for a host for which it is required. Values will be set
2885 in message and save_errno, and setting_up will always be true. Treat as
2886 a temporary error. */
2887
a7538db1 2888#ifdef SUPPORT_TLS
0756eb3c
PH
2889 TLS_FAILED:
2890 code = '4';
a7538db1 2891#endif
0756eb3c
PH
2892
2893 /* If the failure happened while setting up the call, see if the failure was
2894 a 5xx response (this will either be on connection, or following HELO - a 5xx
2895 after EHLO causes it to try HELO). If so, fail all addresses, as this host is
2896 never going to accept them. For other errors during setting up (timeouts or
2897 whatever), defer all addresses, and yield DEFER, so that the host is not
2898 tried again for a while. */
2899
2900 FAILED:
59a286ef 2901 lflags.ok = FALSE; /* For when reached by GOTO */
895fbaf2 2902 set_message = message;
0756eb3c 2903
59a286ef 2904 if (lflags.setting_up)
0756eb3c 2905 if (code == '5')
895fbaf2 2906 set_rc = FAIL;
0756eb3c 2907 else
895fbaf2 2908 yield = set_rc = DEFER;
0756eb3c 2909
e97957bc 2910 /* We want to handle timeouts after MAIL or "." and loss of connection after
0756eb3c 2911 "." specially. They can indicate a problem with the sender address or with
e97957bc
PH
2912 the contents of the message rather than a real error on the connection. These
2913 cases are treated in the same way as a 4xx response. This next bit of code
2914 does the classification. */
0756eb3c 2915
e97957bc 2916 else
0756eb3c 2917 {
e97957bc 2918 BOOL message_error;
0756eb3c 2919
e97957bc
PH
2920 switch(save_errno)
2921 {
8c5d388a 2922#ifdef SUPPORT_I18N
250b6871
JH
2923 case ERRNO_UTF8_FWD:
2924 code = '5';
2925 /*FALLTHROUGH*/
2926#endif
e97957bc
PH
2927 case 0:
2928 case ERRNO_MAIL4XX:
2929 case ERRNO_DATA4XX:
250b6871
JH
2930 message_error = TRUE;
2931 break;
0756eb3c 2932
e97957bc 2933 case ETIMEDOUT:
250b6871
JH
2934 message_error = Ustrncmp(smtp_command,"MAIL",4) == 0 ||
2935 Ustrncmp(smtp_command,"end ",4) == 0;
2936 break;
e97957bc
PH
2937
2938 case ERRNO_SMTPCLOSED:
250b6871
JH
2939 message_error = Ustrncmp(smtp_command,"end ",4) == 0;
2940 break;
e97957bc
PH
2941
2942 default:
250b6871
JH
2943 message_error = FALSE;
2944 break;
e97957bc 2945 }
0756eb3c 2946
e97957bc 2947 /* Handle the cases that are treated as message errors. These are:
0756eb3c 2948
e97957bc
PH
2949 (a) negative response or timeout after MAIL
2950 (b) negative response after DATA
2951 (c) negative response or timeout or dropped connection after "."
250b6871 2952 (d) utf8 support required and not offered
0756eb3c 2953
e97957bc
PH
2954 It won't be a negative response or timeout after RCPT, as that is dealt
2955 with separately above. The action in all cases is to set an appropriate
2956 error code for all the addresses, but to leave yield set to OK because the
2957 host itself has not failed. Of course, it might in practice have failed
2958 when we've had a timeout, but if so, we'll discover that at the next
2959 delivery attempt. For a temporary error, set the message_defer flag, and
2960 write to the logs for information if this is not the last host. The error
2961 for the last host will be logged as part of the address's log line. */
2962
2963 if (message_error)
0756eb3c 2964 {
e97957bc 2965 if (mua_wrapper) code = '5'; /* Force hard failure in wrapper mode */
e97957bc
PH
2966
2967 /* If there's an errno, the message contains just the identity of
2968 the host. */
2969
895fbaf2
JH
2970 if (code == '5')
2971 set_rc = FAIL;
2972 else /* Anything other than 5 is treated as temporary */
e97957bc 2973 {
895fbaf2 2974 set_rc = DEFER;
e97957bc
PH
2975 if (save_errno > 0)
2976 message = US string_sprintf("%s: %s", message, strerror(save_errno));
2977 if (host->next != NULL) log_write(0, LOG_MAIN, "%s", message);
c562fd30 2978 msglog_line(host, message);
e97957bc
PH
2979 *message_defer = TRUE;
2980 }
2981 }
2982
2983 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
2984 ".", or some other transportation error. We defer all addresses and yield
2985 DEFER, except for the case of failed add_headers expansion, or a transport
2986 filter failure, when the yield should be ERROR, to stop it trying other
2987 hosts. */
2988
2989 else
2990 {
895fbaf2 2991 set_rc = DEFER;
e97957bc
PH
2992 yield = (save_errno == ERRNO_CHHEADER_FAIL ||
2993 save_errno == ERRNO_FILTER_FAIL)? ERROR : DEFER;
0756eb3c
PH
2994 }
2995 }
895fbaf2
JH
2996
2997 set_errno(addrlist, save_errno, set_message, set_rc, pass_message, host
2998#ifdef EXPERIMENTAL_DSN_INFO
2999 , smtp_greeting, helo_response
3000#endif
3001 );
0756eb3c
PH
3002 }
3003
3004
3005/* If all has gone well, send_quit will be set TRUE, implying we can end the
3006SMTP session tidily. However, if there were too many addresses to send in one
3007message (indicated by first_addr being non-NULL) we want to carry on with the
3008rest of them. Also, it is desirable to send more than one message down the SMTP
3009connection if there are several waiting, provided we haven't already sent so
3010many as to hit the configured limit. The function transport_check_waiting looks
3011for a waiting message and returns its id. Then transport_pass_socket tries to
3012set up a continued delivery by passing the socket on to another process. The
3013variable send_rset is FALSE if a message has just been successfully transfered.
3014
3015If we are already sending down a continued channel, there may be further
3016addresses not yet delivered that are aimed at the same host, but which have not
3017been passed in this run of the transport. In this case, continue_more will be
3018true, and all we should do is send RSET if necessary, and return, leaving the
3019channel open.
3020
3021However, if no address was disposed of, i.e. all addresses got 4xx errors, we
3022do not want to continue with other messages down the same channel, because that
3023can lead to looping between two or more messages, all with the same,
3024temporarily failing address(es). [The retry information isn't updated yet, so
3025new processes keep on trying.] We probably also don't want to try more of this
3026message's addresses either.
3027
3028If we have started a TLS session, we have to end it before passing the
3029connection to a new process. However, not all servers can handle this (Exim
3030can), so we do not pass such a connection on if the host matches
3031hosts_nopass_tls. */
3032
3033DEBUG(D_transport)
3034 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
59a286ef
JH
3035 "yield=%d first_address is %sNULL\n", lflags.ok, lflags.send_quit,
3036 lflags.send_rset, continue_more, yield, first_addr ? "not " : "");
0756eb3c 3037
59a286ef 3038if (completed_address && lflags.ok && lflags.send_quit)
0756eb3c
PH
3039 {
3040 BOOL more;
a39bd74d
JB
3041 smtp_compare_t t_compare;
3042
3043 t_compare.tblock = tblock;
3044 t_compare.current_sender_address = sender_address;
3045
5130845b
JH
3046 if ( first_addr != NULL
3047 || continue_more
3048 || ( ( tls_out.active < 0
3049 || verify_check_given_host(&ob->hosts_nopass_tls, host) != OK
3050 )
0756eb3c
PH
3051 &&
3052 transport_check_waiting(tblock->name, host->name,
a39bd74d
JB
3053 tblock->connection_max_messages, new_message_id, &more,
3054 (oicf)smtp_are_same_identities, (void*)&t_compare)
5130845b 3055 ) )
0756eb3c
PH
3056 {
3057 uschar *msg;
447d236c 3058 BOOL pass_message;
0756eb3c 3059
59a286ef 3060 if (lflags.send_rset)
0756eb3c 3061 {
59a286ef 3062 if (! (lflags.ok = smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0))
0756eb3c
PH
3063 {
3064 msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
3065 host->address, strerror(save_errno));
59a286ef 3066 lflags.send_quit = FALSE;
0756eb3c 3067 }
59a286ef
JH
3068 else if (! (lflags.ok = smtp_read_response(&inblock, buffer,
3069 sizeof(buffer), '2', ob->command_timeout)))
0756eb3c
PH
3070 {
3071 int code;
59a286ef 3072 lflags.send_quit = check_response(host, &errno, 0, buffer, &code, &msg,
447d236c 3073 &pass_message);
59a286ef 3074 if (!lflags.send_quit)
0756eb3c 3075 {
c562fd30
JH
3076 DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
3077 host->name, host->address, msg);
0756eb3c
PH
3078 }
3079 }
3080 }
3081
3082 /* Either RSET was not needed, or it succeeded */
3083
59a286ef 3084 if (lflags.ok)
0756eb3c
PH
3085 {
3086 if (first_addr != NULL) /* More addresses still to be sent */
3087 { /* in this run of the transport */
3088 continue_sequence++; /* Causes * in logging */
3089 goto SEND_MESSAGE;
3090 }
3091 if (continue_more) return yield; /* More addresses for another run */
3092
3093 /* Pass the socket to a new Exim process. Before doing so, we must shut
3094 down TLS. Not all MTAs allow for the continuation of the SMTP session
3095 when TLS is shut down. We test for this by sending a new EHLO. If we
3096 don't get a good response, we don't attempt to pass the socket on. */
3097
a7538db1 3098#ifdef SUPPORT_TLS
817d9f57 3099 if (tls_out.active >= 0)
0756eb3c 3100 {
817d9f57 3101 tls_close(FALSE, TRUE);
2d14f397 3102 smtp_peer_options = smtp_peer_options_wrap;
59a286ef
JH
3103 if (lflags.smtps)
3104 lflags.ok = FALSE;
061b7ebd 3105 else
59a286ef 3106 lflags.ok = smtp_write_command(&outblock,FALSE,"EHLO %s\r\n",helo_data) >= 0 &&
061b7ebd
PP
3107 smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
3108 ob->command_timeout);
0756eb3c 3109 }
a7538db1 3110#endif
0756eb3c 3111
4c04137d 3112 /* If the socket is successfully passed, we mustn't send QUIT (or
0756eb3c
PH
3113 indeed anything!) from here. */
3114
895fbaf2
JH
3115/*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
3116propagate it from the initial
3117*/
59a286ef
JH
3118 if (lflags.ok && transport_pass_socket(tblock->name, host->name,
3119 host->address, new_message_id, inblock.sock))
3120 lflags.send_quit = FALSE;
0756eb3c
PH
3121 }
3122
3123 /* If RSET failed and there are addresses left, they get deferred. */
3124
895fbaf2
JH
3125 else set_errno(first_addr, errno, msg, DEFER, FALSE, host
3126#ifdef EXPERIMENTAL_DSN_INFO
3127 , smtp_greeting, helo_response
3128#endif
3129 );
0756eb3c
PH
3130 }
3131 }
3132
3133/* End off tidily with QUIT unless the connection has died or the socket has
3134been passed to another process. There has been discussion on the net about what
3135to do after sending QUIT. The wording of the RFC suggests that it is necessary
3136to wait for a response, but on the other hand, there isn't anything one can do
3137with an error response, other than log it. Exim used to do that. However,
3138further discussion suggested that it is positively advantageous not to wait for
3139the response, but to close the session immediately. This is supposed to move
3140the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
3141load from the server. (Hosts that are both servers and clients may not see much
3142difference, of course.) Further discussion indicated that this was safe to do
3143on Unix systems which have decent implementations of TCP/IP that leave the
3144connection around for a while (TIME_WAIT) after the application has gone away.
3145This enables the response sent by the server to be properly ACKed rather than
3146timed out, as can happen on broken TCP/IP implementations on other OS.
3147
3148This change is being made on 31-Jul-98. After over a year of trouble-free
3149operation, the old commented-out code was removed on 17-Sep-99. */
3150
3151SEND_QUIT:
59a286ef 3152if (lflags.send_quit) (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
0756eb3c
PH
3153
3154END_OFF:
3155
3156#ifdef SUPPORT_TLS
817d9f57 3157tls_close(FALSE, TRUE);
0756eb3c
PH
3158#endif
3159
3160/* Close the socket, and return the appropriate value, first setting
0756eb3c
PH
3161works because the NULL setting is passed back to the calling process, and
3162remote_max_parallel is forced to 1 when delivering over an existing connection,
3163
3164If all went well and continue_more is set, we shouldn't actually get here if
3165there are further addresses, as the return above will be taken. However,
3166writing RSET might have failed, or there may be other addresses whose hosts are
3167specified in the transports, and therefore not visible at top level, in which
3168case continue_more won't get set. */
3169
b9d9c5a2 3170HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP(close)>>\n");
60d10ce7
JH
3171if (lflags.send_quit)
3172 {
3173 shutdown(outblock.sock, SHUT_WR);
5ddc9771
JH
3174 if (fcntl(inblock.sock, F_SETFL, O_NONBLOCK) == 0)
3175 for (rc = 16; read(inblock.sock, inbuffer, sizeof(inbuffer)) > 0 && rc > 0;)
3176 rc--; /* drain socket */
60d10ce7 3177 }
f1e894f3 3178(void)close(inblock.sock);
a7538db1 3179
0cbf2b82 3180#ifndef DISABLE_EVENT
774ef2d7 3181(void) event_raise(tblock->event_action, US"tcp:close", NULL);
a7538db1
JH
3182#endif
3183
0756eb3c
PH
3184continue_transport = NULL;
3185continue_hostname = NULL;
3186return yield;
3187}
3188
3189
3190
3191
3192/*************************************************
3193* Closedown entry point *
3194*************************************************/
3195
3196/* This function is called when exim is passed an open smtp channel
3197from another incarnation, but the message which it has been asked
3198to deliver no longer exists. The channel is on stdin.
3199
3200We might do fancy things like looking for another message to send down
3201the channel, but if the one we sought has gone, it has probably been
3202delivered by some other process that itself will seek further messages,
3203so just close down our connection.
3204
3205Argument: pointer to the transport instance block
3206Returns: nothing
3207*/
3208
3209void
3210smtp_transport_closedown(transport_instance *tblock)
3211{
3212smtp_transport_options_block *ob =
3213 (smtp_transport_options_block *)(tblock->options_block);
3214smtp_inblock inblock;
3215smtp_outblock outblock;
3216uschar buffer[256];
3217uschar inbuffer[4096];
3218uschar outbuffer[16];
3219
3220inblock.sock = fileno(stdin);
3221inblock.buffer = inbuffer;
3222inblock.buffersize = sizeof(inbuffer);
3223inblock.ptr = inbuffer;
3224inblock.ptrend = inbuffer;
3225
3226outblock.sock = inblock.sock;
3227outblock.buffersize = sizeof(outbuffer);
3228outblock.buffer = outbuffer;
3229outblock.ptr = outbuffer;
3230outblock.cmd_count = 0;
3231outblock.authenticating = FALSE;
3232
3233(void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
3234(void)smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
3235 ob->command_timeout);
f1e894f3 3236(void)close(inblock.sock);
0756eb3c
PH
3237}
3238
3239
3240
3241/*************************************************
3242* Prepare addresses for delivery *
3243*************************************************/
3244
3245/* This function is called to flush out error settings from previous delivery
3246attempts to other hosts. It also records whether we got here via an MX record
3247or not in the more_errno field of the address. We are interested only in
3248addresses that are still marked DEFER - others may have got delivered to a
3249previously considered IP address. Set their status to PENDING_DEFER to indicate
3250which ones are relevant this time.
3251
3252Arguments:
3253 addrlist the list of addresses
3254 host the host we are delivering to
3255
3256Returns: the first address for this delivery
3257*/
3258
3259static address_item *
3260prepare_addresses(address_item *addrlist, host_item *host)
3261{
3262address_item *first_addr = NULL;
3263address_item *addr;
7b4c8c1f 3264for (addr = addrlist; addr; addr = addr->next)
168dec3b
JH
3265 if (addr->transport_return == DEFER)
3266 {
7b4c8c1f 3267 if (!first_addr) first_addr = addr;
168dec3b
JH
3268 addr->transport_return = PENDING_DEFER;
3269 addr->basic_errno = 0;
3270 addr->more_errno = (host->mx >= 0)? 'M' : 'A';
3271 addr->message = NULL;
a7538db1 3272#ifdef SUPPORT_TLS
168dec3b
JH
3273 addr->cipher = NULL;
3274 addr->ourcert = NULL;
3275 addr->peercert = NULL;
3276 addr->peerdn = NULL;
3277 addr->ocsp = OCSP_NOT_REQ;
a7538db1 3278#endif
895fbaf2
JH
3279#ifdef EXPERIMENTAL_DSN_INFO
3280 addr->smtp_greeting = NULL;
3281 addr->helo_response = NULL;
3282#endif
168dec3b 3283 }
0756eb3c
PH
3284return first_addr;
3285}