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