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