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