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