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