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