1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
17 optionlist smtp_transport_options
[] = {
18 { "*expand_multi_domain", opt_stringptr
| opt_hidden
| opt_public
,
19 (void *)offsetof(transport_instance
, expand_multi_domain
) },
20 { "*expand_retry_include_ip_address", opt_stringptr
| opt_hidden
,
21 (void *)(offsetof(smtp_transport_options_block
, expand_retry_include_ip_address
)) },
23 { "address_retry_include_sender", opt_bool
,
24 (void *)offsetof(smtp_transport_options_block
, address_retry_include_sender
) },
25 { "allow_localhost", opt_bool
,
26 (void *)offsetof(smtp_transport_options_block
, allow_localhost
) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr
,
29 (void *)offsetof(smtp_transport_options_block
, arc_sign
) },
31 { "authenticated_sender", opt_stringptr
,
32 (void *)offsetof(smtp_transport_options_block
, authenticated_sender
) },
33 { "authenticated_sender_force", opt_bool
,
34 (void *)offsetof(smtp_transport_options_block
, authenticated_sender_force
) },
35 { "command_timeout", opt_time
,
36 (void *)offsetof(smtp_transport_options_block
, command_timeout
) },
37 { "connect_timeout", opt_time
,
38 (void *)offsetof(smtp_transport_options_block
, connect_timeout
) },
39 { "connection_max_messages", opt_int
| opt_public
,
40 (void *)offsetof(transport_instance
, connection_max_messages
) },
42 { "dane_require_tls_ciphers", opt_stringptr
,
43 (void *)offsetof(smtp_transport_options_block
, dane_require_tls_ciphers
) },
45 { "data_timeout", opt_time
,
46 (void *)offsetof(smtp_transport_options_block
, data_timeout
) },
47 { "delay_after_cutoff", opt_bool
,
48 (void *)offsetof(smtp_transport_options_block
, delay_after_cutoff
) },
50 { "dkim_canon", opt_stringptr
,
51 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_canon
) },
52 { "dkim_domain", opt_stringptr
,
53 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_domain
) },
54 { "dkim_hash", opt_stringptr
,
55 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_hash
) },
56 { "dkim_identity", opt_stringptr
,
57 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_identity
) },
58 { "dkim_private_key", opt_stringptr
,
59 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_private_key
) },
60 { "dkim_selector", opt_stringptr
,
61 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_selector
) },
62 { "dkim_sign_headers", opt_stringptr
,
63 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_sign_headers
) },
64 { "dkim_strict", opt_stringptr
,
65 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_strict
) },
66 { "dkim_timestamps", opt_stringptr
,
67 (void *)offsetof(smtp_transport_options_block
, dkim
.dkim_timestamps
) },
69 { "dns_qualify_single", opt_bool
,
70 (void *)offsetof(smtp_transport_options_block
, dns_qualify_single
) },
71 { "dns_search_parents", opt_bool
,
72 (void *)offsetof(smtp_transport_options_block
, dns_search_parents
) },
73 { "dnssec_request_domains", opt_stringptr
,
74 (void *)offsetof(smtp_transport_options_block
, dnssec
.request
) },
75 { "dnssec_require_domains", opt_stringptr
,
76 (void *)offsetof(smtp_transport_options_block
, dnssec
.require
) },
77 { "dscp", opt_stringptr
,
78 (void *)offsetof(smtp_transport_options_block
, dscp
) },
79 { "fallback_hosts", opt_stringptr
,
80 (void *)offsetof(smtp_transport_options_block
, fallback_hosts
) },
81 { "final_timeout", opt_time
,
82 (void *)offsetof(smtp_transport_options_block
, final_timeout
) },
83 { "gethostbyname", opt_bool
,
84 (void *)offsetof(smtp_transport_options_block
, gethostbyname
) },
85 { "helo_data", opt_stringptr
,
86 (void *)offsetof(smtp_transport_options_block
, helo_data
) },
87 { "hosts", opt_stringptr
,
88 (void *)offsetof(smtp_transport_options_block
, hosts
) },
89 { "hosts_avoid_esmtp", opt_stringptr
,
90 (void *)offsetof(smtp_transport_options_block
, hosts_avoid_esmtp
) },
91 { "hosts_avoid_pipelining", opt_stringptr
,
92 (void *)offsetof(smtp_transport_options_block
, hosts_avoid_pipelining
) },
94 { "hosts_avoid_tls", opt_stringptr
,
95 (void *)offsetof(smtp_transport_options_block
, hosts_avoid_tls
) },
97 { "hosts_max_try", opt_int
,
98 (void *)offsetof(smtp_transport_options_block
, hosts_max_try
) },
99 { "hosts_max_try_hardlimit", opt_int
,
100 (void *)offsetof(smtp_transport_options_block
, hosts_max_try_hardlimit
) },
102 { "hosts_nopass_tls", opt_stringptr
,
103 (void *)offsetof(smtp_transport_options_block
, hosts_nopass_tls
) },
104 { "hosts_noproxy_tls", opt_stringptr
,
105 (void *)offsetof(smtp_transport_options_block
, hosts_noproxy_tls
) },
107 { "hosts_override", opt_bool
,
108 (void *)offsetof(smtp_transport_options_block
, hosts_override
) },
109 #ifdef EXPERIMENTAL_PIPE_CONNECT
110 { "hosts_pipe_connect", opt_stringptr
,
111 (void *)offsetof(smtp_transport_options_block
, hosts_pipe_connect
) },
113 { "hosts_randomize", opt_bool
,
114 (void *)offsetof(smtp_transport_options_block
, hosts_randomize
) },
115 #if !defined(DISABLE_TLS) && !defined(DISABLE_OCSP)
116 { "hosts_request_ocsp", opt_stringptr
,
117 (void *)offsetof(smtp_transport_options_block
, hosts_request_ocsp
) },
119 { "hosts_require_auth", opt_stringptr
,
120 (void *)offsetof(smtp_transport_options_block
, hosts_require_auth
) },
123 { "hosts_require_dane", opt_stringptr
,
124 (void *)offsetof(smtp_transport_options_block
, hosts_require_dane
) },
126 # ifndef DISABLE_OCSP
127 { "hosts_require_ocsp", opt_stringptr
,
128 (void *)offsetof(smtp_transport_options_block
, hosts_require_ocsp
) },
130 { "hosts_require_tls", opt_stringptr
,
131 (void *)offsetof(smtp_transport_options_block
, hosts_require_tls
) },
133 { "hosts_try_auth", opt_stringptr
,
134 (void *)offsetof(smtp_transport_options_block
, hosts_try_auth
) },
135 { "hosts_try_chunking", opt_stringptr
,
136 (void *)offsetof(smtp_transport_options_block
, hosts_try_chunking
) },
138 { "hosts_try_dane", opt_stringptr
,
139 (void *)offsetof(smtp_transport_options_block
, hosts_try_dane
) },
141 { "hosts_try_fastopen", opt_stringptr
,
142 (void *)offsetof(smtp_transport_options_block
, hosts_try_fastopen
) },
144 { "hosts_try_prdr", opt_stringptr
,
145 (void *)offsetof(smtp_transport_options_block
, hosts_try_prdr
) },
148 { "hosts_verify_avoid_tls", opt_stringptr
,
149 (void *)offsetof(smtp_transport_options_block
, hosts_verify_avoid_tls
) },
151 { "interface", opt_stringptr
,
152 (void *)offsetof(smtp_transport_options_block
, interface
) },
153 { "keepalive", opt_bool
,
154 (void *)offsetof(smtp_transport_options_block
, keepalive
) },
155 { "lmtp_ignore_quota", opt_bool
,
156 (void *)offsetof(smtp_transport_options_block
, lmtp_ignore_quota
) },
157 { "max_rcpt", opt_int
| opt_public
,
158 (void *)offsetof(transport_instance
, max_addresses
) },
159 { "multi_domain", opt_expand_bool
| opt_public
,
160 (void *)offsetof(transport_instance
, multi_domain
) },
161 { "port", opt_stringptr
,
162 (void *)offsetof(smtp_transport_options_block
, port
) },
163 { "protocol", opt_stringptr
,
164 (void *)offsetof(smtp_transport_options_block
, protocol
) },
165 { "retry_include_ip_address", opt_expand_bool
,
166 (void *)offsetof(smtp_transport_options_block
, retry_include_ip_address
) },
167 { "serialize_hosts", opt_stringptr
,
168 (void *)offsetof(smtp_transport_options_block
, serialize_hosts
) },
169 { "size_addition", opt_int
,
170 (void *)offsetof(smtp_transport_options_block
, size_addition
) },
172 { "socks_proxy", opt_stringptr
,
173 (void *)offsetof(smtp_transport_options_block
, socks_proxy
) },
176 { "tls_certificate", opt_stringptr
,
177 (void *)offsetof(smtp_transport_options_block
, tls_certificate
) },
178 { "tls_crl", opt_stringptr
,
179 (void *)offsetof(smtp_transport_options_block
, tls_crl
) },
180 { "tls_dh_min_bits", opt_int
,
181 (void *)offsetof(smtp_transport_options_block
, tls_dh_min_bits
) },
182 { "tls_privatekey", opt_stringptr
,
183 (void *)offsetof(smtp_transport_options_block
, tls_privatekey
) },
184 { "tls_require_ciphers", opt_stringptr
,
185 (void *)offsetof(smtp_transport_options_block
, tls_require_ciphers
) },
186 # ifdef EXPERIMENTAL_TLS_RESUME
187 { "tls_resumption_hosts", opt_stringptr
,
188 (void *)offsetof(smtp_transport_options_block
, tls_resumption_hosts
) },
190 { "tls_sni", opt_stringptr
,
191 (void *)offsetof(smtp_transport_options_block
, tls_sni
) },
192 { "tls_tempfail_tryclear", opt_bool
,
193 (void *)offsetof(smtp_transport_options_block
, tls_tempfail_tryclear
) },
194 { "tls_try_verify_hosts", opt_stringptr
,
195 (void *)offsetof(smtp_transport_options_block
, tls_try_verify_hosts
) },
196 { "tls_verify_cert_hostnames", opt_stringptr
,
197 (void *)offsetof(smtp_transport_options_block
,tls_verify_cert_hostnames
)},
198 { "tls_verify_certificates", opt_stringptr
,
199 (void *)offsetof(smtp_transport_options_block
, tls_verify_certificates
) },
200 { "tls_verify_hosts", opt_stringptr
,
201 (void *)offsetof(smtp_transport_options_block
, tls_verify_hosts
) },
204 { "utf8_downconvert", opt_stringptr
,
205 (void *)offsetof(smtp_transport_options_block
, utf8_downconvert
) },
209 /* Size of the options list. An extern variable has to be used so that its
210 address can appear in the tables drtables.c. */
212 int smtp_transport_options_count
= nelem(smtp_transport_options
);
218 smtp_transport_options_block smtp_transport_option_defaults
= {0};
219 void smtp_transport_init(transport_instance
*tblock
) {}
220 BOOL
smtp_transport_entry(transport_instance
*tblock
, address_item
*addr
) {return FALSE
;}
221 void smtp_transport_closedown(transport_instance
*tblock
) {}
223 #else /*!MACRO_PREDEF*/
226 /* Default private options block for the smtp transport. */
228 smtp_transport_options_block smtp_transport_option_defaults
= {
230 .fallback_hosts
= NULL
,
232 .fallback_hostlist
= NULL
,
233 .helo_data
= US
"$primary_hostname",
236 .protocol
= US
"smtp",
238 .serialize_hosts
= NULL
,
239 .hosts_try_auth
= NULL
,
240 .hosts_require_auth
= NULL
,
241 .hosts_try_chunking
= US
"*",
243 .hosts_try_dane
= US
"*",
244 .hosts_require_dane
= NULL
,
245 .dane_require_tls_ciphers
= NULL
,
247 .hosts_try_fastopen
= NULL
,
249 .hosts_try_prdr
= US
"*",
252 .hosts_request_ocsp
= US
"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
253 .hosts_require_ocsp
= NULL
,
255 .hosts_require_tls
= NULL
,
256 .hosts_avoid_tls
= NULL
,
257 .hosts_verify_avoid_tls
= NULL
,
258 .hosts_avoid_pipelining
= NULL
,
259 #ifdef EXPERIMENTAL_PIPE_CONNECT
260 .hosts_pipe_connect
= NULL
,
262 .hosts_avoid_esmtp
= NULL
,
264 .hosts_nopass_tls
= NULL
,
265 .hosts_noproxy_tls
= NULL
,
267 .command_timeout
= 5*60,
268 .connect_timeout
= 5*60,
269 .data_timeout
= 5*60,
270 .final_timeout
= 10*60,
271 .size_addition
= 1024,
273 .hosts_max_try_hardlimit
= 50,
274 .address_retry_include_sender
= TRUE
,
275 .allow_localhost
= FALSE
,
276 .authenticated_sender_force
= FALSE
,
277 .gethostbyname
= FALSE
,
278 .dns_qualify_single
= TRUE
,
279 .dns_search_parents
= FALSE
,
280 .dnssec
= { .request
=NULL
, .require
=NULL
},
281 .delay_after_cutoff
= TRUE
,
282 .hosts_override
= FALSE
,
283 .hosts_randomize
= FALSE
,
285 .lmtp_ignore_quota
= FALSE
,
286 .expand_retry_include_ip_address
= NULL
,
287 .retry_include_ip_address
= TRUE
,
292 .tls_certificate
= NULL
,
294 .tls_privatekey
= NULL
,
295 .tls_require_ciphers
= NULL
,
297 .tls_verify_certificates
= US
"system",
298 .tls_dh_min_bits
= EXIM_CLIENT_DH_DEFAULT_MIN_BITS
,
299 .tls_tempfail_tryclear
= TRUE
,
300 # ifdef EXPERIMENTAL_TLS_RESUME
301 .tls_resumption_hosts
= NULL
,
303 .tls_verify_hosts
= NULL
,
304 .tls_try_verify_hosts
= US
"*",
305 .tls_verify_cert_hostnames
= US
"*",
308 .utf8_downconvert
= NULL
,
312 {.dkim_domain
= NULL
,
313 .dkim_identity
= NULL
,
314 .dkim_private_key
= NULL
,
315 .dkim_selector
= NULL
,
317 .dkim_sign_headers
= NULL
,
319 .dkim_hash
= US
"sha256",
320 .dkim_timestamps
= NULL
,
321 .dot_stuffed
= FALSE
,
322 .force_bodyhash
= FALSE
,
323 # ifdef EXPERIMENTAL_ARC
324 .arc_signspec
= NULL
,
327 # ifdef EXPERIMENTAL_ARC
333 /* some DSN flags for use later */
335 static int rf_list
[] = {rf_notify_never
, rf_notify_success
,
336 rf_notify_failure
, rf_notify_delay
};
338 static uschar
*rf_names
[] = { US
"NEVER", US
"SUCCESS", US
"FAILURE", US
"DELAY" };
344 static uschar
*smtp_command
; /* Points to last cmd for error messages */
345 static uschar
*mail_command
; /* Points to MAIL cmd for error messages */
346 static uschar
*data_command
= US
""; /* Points to DATA cmd for error messages */
347 static BOOL update_waiting
; /* TRUE to update the "wait" database */
349 /*XXX move to smtp_context */
350 static BOOL pipelining_active
; /* current transaction is in pipe mode */
353 static unsigned ehlo_response(uschar
* buf
, unsigned checks
);
356 /*************************************************
357 * Setup entry point *
358 *************************************************/
360 /* This function is called when the transport is about to be used,
361 but before running it in a sub-process. It is used for two things:
363 (1) To set the fallback host list in addresses, when delivering.
364 (2) To pass back the interface, port, protocol, and other options, for use
365 during callout verification.
368 tblock pointer to the transport instance block
369 addrlist list of addresses about to be transported
370 tf if not NULL, pointer to block in which to return options
371 uid the uid that will be set (not used)
372 gid the gid that will be set (not used)
373 errmsg place for error message (not used)
375 Returns: OK always (FAIL, DEFER not used)
379 smtp_transport_setup(transport_instance
*tblock
, address_item
*addrlist
,
380 transport_feedback
*tf
, uid_t uid
, gid_t gid
, uschar
**errmsg
)
382 smtp_transport_options_block
*ob
= SOB tblock
->options_block
;
384 errmsg
= errmsg
; /* Keep picky compilers happy */
388 /* Pass back options if required. This interface is getting very messy. */
392 tf
->interface
= ob
->interface
;
394 tf
->protocol
= ob
->protocol
;
395 tf
->hosts
= ob
->hosts
;
396 tf
->hosts_override
= ob
->hosts_override
;
397 tf
->hosts_randomize
= ob
->hosts_randomize
;
398 tf
->gethostbyname
= ob
->gethostbyname
;
399 tf
->qualify_single
= ob
->dns_qualify_single
;
400 tf
->search_parents
= ob
->dns_search_parents
;
401 tf
->helo_data
= ob
->helo_data
;
404 /* Set the fallback host list for all the addresses that don't have fallback
405 host lists, provided that the local host wasn't present in the original host
408 if (!testflag(addrlist
, af_local_host_removed
))
409 for (; addrlist
; addrlist
= addrlist
->next
)
410 if (!addrlist
->fallback_hosts
) addrlist
->fallback_hosts
= ob
->fallback_hostlist
;
417 /*************************************************
418 * Initialization entry point *
419 *************************************************/
421 /* Called for each instance, after its options have been read, to
422 enable consistency checks to be done, or anything else that needs
425 Argument: pointer to the transport instance block
430 smtp_transport_init(transport_instance
*tblock
)
432 smtp_transport_options_block
*ob
= SOB tblock
->options_block
;
434 /* Retry_use_local_part defaults FALSE if unset */
436 if (tblock
->retry_use_local_part
== TRUE_UNSET
)
437 tblock
->retry_use_local_part
= FALSE
;
439 /* Set the default port according to the protocol */
442 ob
->port
= strcmpic(ob
->protocol
, US
"lmtp") == 0
444 : strcmpic(ob
->protocol
, US
"smtps") == 0
445 ? US
"smtps" : US
"smtp";
447 /* Set up the setup entry point, to be called before subprocesses for this
450 tblock
->setup
= smtp_transport_setup
;
452 /* Complain if any of the timeouts are zero. */
454 if (ob
->command_timeout
<= 0 || ob
->data_timeout
<= 0 ||
455 ob
->final_timeout
<= 0)
456 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
457 "command, data, or final timeout value is zero for %s transport",
460 /* If hosts_override is set and there are local hosts, set the global
461 flag that stops verify from showing router hosts. */
463 if (ob
->hosts_override
&& ob
->hosts
!= NULL
) tblock
->overrides_hosts
= TRUE
;
465 /* If there are any fallback hosts listed, build a chain of host items
466 for them, but do not do any lookups at this time. */
468 host_build_hostlist(&(ob
->fallback_hostlist
), ob
->fallback_hosts
, FALSE
);
475 /*************************************************
476 * Set delivery info into all active addresses *
477 *************************************************/
479 /* Only addresses whose status is >= PENDING are relevant. A lesser
480 status means that an address is not currently being processed.
483 addrlist points to a chain of addresses
484 errno_value to put in each address's errno field
485 msg to put in each address's message field
486 rc to put in each address's transport_return field
487 pass_message if TRUE, set the "pass message" flag in the address
488 host if set, mark addrs as having used this host
489 smtp_greeting from peer
490 helo_response from peer
492 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
493 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
494 this particular type of timeout.
500 set_errno(address_item
*addrlist
, int errno_value
, uschar
*msg
, int rc
,
501 BOOL pass_message
, host_item
* host
502 #ifdef EXPERIMENTAL_DSN_INFO
503 , const uschar
* smtp_greeting
, const uschar
* helo_response
508 if (errno_value
== ERRNO_CONNECTTIMEOUT
)
510 errno_value
= ETIMEDOUT
;
511 orvalue
= RTEF_CTOUT
;
513 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
514 if (addr
->transport_return
>= PENDING
)
516 addr
->basic_errno
= errno_value
;
517 addr
->more_errno
|= orvalue
;
521 if (pass_message
) setflag(addr
, af_pass_message
);
523 addr
->transport_return
= rc
;
526 addr
->host_used
= host
;
527 #ifdef EXPERIMENTAL_DSN_INFO
529 {uschar
* s
= Ustrchr(smtp_greeting
, '\n'); if (s
) *s
= '\0';}
530 addr
->smtp_greeting
= smtp_greeting
;
533 {uschar
* s
= Ustrchr(helo_response
, '\n'); if (s
) *s
= '\0';}
534 addr
->helo_response
= helo_response
;
541 set_errno_nohost(address_item
*addrlist
, int errno_value
, uschar
*msg
, int rc
,
544 set_errno(addrlist
, errno_value
, msg
, rc
, pass_message
, NULL
545 #ifdef EXPERIMENTAL_DSN_INFO
552 /*************************************************
553 * Check an SMTP response *
554 *************************************************/
556 /* This function is given an errno code and the SMTP response buffer
557 to analyse, together with the host identification for generating messages. It
558 sets an appropriate message and puts the first digit of the response code into
559 the yield variable. If no response was actually read, a suitable digit is
563 host the current host, to get its name for messages
564 errno_value pointer to the errno value
565 more_errno from the top address for use with ERRNO_FILTER_FAIL
566 buffer the SMTP response buffer
567 yield where to put a one-digit SMTP response code
568 message where to put an error message
569 pass_message set TRUE if message is an SMTP response
571 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
575 check_response(host_item
*host
, int *errno_value
, int more_errno
,
576 uschar
*buffer
, int *yield
, uschar
**message
, BOOL
*pass_message
)
578 uschar
* pl
= pipelining_active
? US
"pipelined " : US
"";
581 *yield
= '4'; /* Default setting is to give a temporary error */
585 case ETIMEDOUT
: /* Handle response timeout */
586 *message
= US
string_sprintf("SMTP timeout after %s%s",
588 if (transport_count
> 0)
589 *message
= US
string_sprintf("%s (%d bytes written)", *message
,
593 case ECONNREFUSED
: /* First-read error on a TFO conn */
594 if (verify_mode
) *message
= US
strerror(*errno_value
);
595 return FALSE
; /* nonverify, do not set message */
597 case ERRNO_SMTPFORMAT
: /* Handle malformed SMTP response */
598 s
= string_printing(buffer
);
599 while (isspace(*s
)) s
++;
601 ? string_sprintf("Malformed SMTP reply (an empty line) "
602 "in response to %s%s", pl
, smtp_command
)
603 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
604 pl
, smtp_command
, s
);
607 case ERRNO_TLSFAILURE
: /* Handle bad first read; can happen with
609 *message
= US
"bad first read from TLS conn";
612 case ERRNO_FILTER_FAIL
: /* Handle a failed filter process error;
613 can't send QUIT as we mustn't end the DATA. */
614 *message
= string_sprintf("transport filter process failed (%d)%s",
616 more_errno
== EX_EXECFAILED
? ": unable to execute command" : "");
619 case ERRNO_CHHEADER_FAIL
: /* Handle a failed add_headers expansion;
620 can't send QUIT as we mustn't end the DATA. */
622 string_sprintf("failed to expand headers_add or headers_remove: %s",
623 expand_string_message
);
626 case ERRNO_WRITEINCOMPLETE
: /* failure to write a complete data block */
627 *message
= string_sprintf("failed to write a data block");
631 case ERRNO_UTF8_FWD
: /* no advertised SMTPUTF8, for international message */
632 *message
= US
"utf8 support required but not offered for forwarding";
633 DEBUG(D_deliver
|D_transport
) debug_printf("%s\n", *message
);
638 /* Handle error responses from the remote mailer. */
642 *message
= string_sprintf("SMTP error from remote mail server after %s%s: "
643 "%s", pl
, smtp_command
, s
= string_printing(buffer
));
644 *pass_message
= TRUE
;
649 /* No data was read. If there is no errno, this must be the EOF (i.e.
650 connection closed) case, which causes deferral. An explicit connection reset
651 error has the same effect. Otherwise, put the host's identity in the message,
652 leaving the errno value to be interpreted as well. In all cases, we have to
653 assume the connection is now dead. */
655 if (*errno_value
== 0 || *errno_value
== ECONNRESET
)
657 *errno_value
= ERRNO_SMTPCLOSED
;
658 *message
= US
string_sprintf("Remote host closed connection "
659 "in response to %s%s", pl
, smtp_command
);
662 *message
= US
string_sprintf("%s [%s]", host
->name
, host
->address
);
669 /*************************************************
670 * Write error message to logs *
671 *************************************************/
673 /* This writes to the main log and to the message log.
676 host the current host
677 detail the current message (addr_item->message)
678 basic_errno the errno (addr_item->basic_errno)
684 write_logs(const host_item
*host
, const uschar
*suffix
, int basic_errno
)
686 gstring
* message
= LOGGING(outgoing_port
)
687 ? string_fmt_append(NULL
, "H=%s [%s]:%d", host
->name
, host
->address
,
688 host
->port
== PORT_NONE
? 25 : host
->port
)
689 : string_fmt_append(NULL
, "H=%s [%s]", host
->name
, host
->address
);
693 message
= string_fmt_append(message
, ": %s", suffix
);
695 message
= string_fmt_append(message
, ": %s", strerror(basic_errno
));
698 message
= string_fmt_append(message
, " %s", exim_errstr(basic_errno
));
700 log_write(0, LOG_MAIN
, "%s", string_from_gstring(message
));
701 deliver_msglog("%s %s\n", tod_stamp(tod_log
), message
->s
);
705 msglog_line(host_item
* host
, uschar
* message
)
707 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log
),
708 host
->name
, host
->address
, message
);
713 #ifndef DISABLE_EVENT
714 /*************************************************
715 * Post-defer action *
716 *************************************************/
718 /* This expands an arbitrary per-transport string.
719 It might, for example, be used to write to the database log.
722 addr the address item containing error information
723 host the current host
729 deferred_event_raise(address_item
*addr
, host_item
*host
)
731 uschar
* action
= addr
->transport
->event_action
;
732 const uschar
* save_domain
;
738 save_domain
= deliver_domain
;
739 save_local
= deliver_localpart
;
741 /*XXX would ip & port already be set up? */
742 deliver_host_address
= string_copy(host
->address
);
743 deliver_host_port
= host
->port
== PORT_NONE
? 25 : host
->port
;
744 event_defer_errno
= addr
->basic_errno
;
746 router_name
= addr
->router
->name
;
747 transport_name
= addr
->transport
->name
;
748 deliver_domain
= addr
->domain
;
749 deliver_localpart
= addr
->local_part
;
751 (void) event_raise(action
, US
"msg:host:defer",
753 ? addr
->basic_errno
> 0
754 ? string_sprintf("%s: %s", addr
->message
, strerror(addr
->basic_errno
))
755 : string_copy(addr
->message
)
756 : addr
->basic_errno
> 0
757 ? string_copy(US
strerror(addr
->basic_errno
))
760 deliver_localpart
= save_local
;
761 deliver_domain
= save_domain
;
762 router_name
= transport_name
= NULL
;
766 /*************************************************
767 * Reap SMTP specific responses *
768 *************************************************/
770 smtp_discard_responses(smtp_context
* sx
, smtp_transport_options_block
* ob
,
773 uschar flushbuffer
[4096];
777 if (!smtp_read_response(sx
, flushbuffer
, sizeof(flushbuffer
),
778 '2', ob
->command_timeout
)
779 && (errno
!= 0 || flushbuffer
[0] == 0))
786 /* Return boolean success */
789 smtp_reap_banner(smtp_context
* sx
)
791 BOOL good_response
= smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
792 '2', (SOB sx
->conn_args
.ob
)->command_timeout
);
793 #ifdef EXPERIMENTAL_DSN_INFO
794 sx
->smtp_greeting
= string_copy(sx
->buffer
);
796 return good_response
;
800 smtp_reap_ehlo(smtp_context
* sx
)
802 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
803 (SOB sx
->conn_args
.ob
)->command_timeout
))
805 if (errno
!= 0 || sx
->buffer
[0] == 0 || sx
->lmtp
)
807 #ifdef EXPERIMENTAL_DSN_INFO
808 sx
->helo_response
= string_copy(sx
->buffer
);
814 #ifdef EXPERIMENTAL_DSN_INFO
815 sx
->helo_response
= string_copy(sx
->buffer
);
822 #ifdef EXPERIMENTAL_PIPE_CONNECT
824 ehlo_cache_key(const smtp_context
* sx
)
826 host_item
* host
= sx
->conn_args
.host
;
827 return Ustrchr(host
->address
, ':')
828 ? string_sprintf("[%s]:%d.EHLO", host
->address
,
829 host
->port
== PORT_NONE
? sx
->port
: host
->port
)
830 : string_sprintf("%s:%d.EHLO", host
->address
,
831 host
->port
== PORT_NONE
? sx
->port
: host
->port
);
835 write_ehlo_cache_entry(const smtp_context
* sx
)
837 open_db dbblock
, * dbm_file
;
839 if ((dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
841 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
842 dbdata_ehlo_resp er
= { .data
= sx
->ehlo_resp
};
844 HDEBUG(D_transport
) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
845 sx
->ehlo_resp
.cleartext_features
, sx
->ehlo_resp
.cleartext_auths
,
846 sx
->ehlo_resp
.crypted_features
, sx
->ehlo_resp
.crypted_auths
);
848 dbfn_write(dbm_file
, ehlo_resp_key
, &er
, (int)sizeof(er
));
849 dbfn_close(dbm_file
);
854 invalidate_ehlo_cache_entry(smtp_context
* sx
)
856 open_db dbblock
, * dbm_file
;
858 if ( sx
->early_pipe_active
859 && (dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
861 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
862 dbfn_delete(dbm_file
, ehlo_resp_key
);
863 dbfn_close(dbm_file
);
868 read_ehlo_cache_entry(smtp_context
* sx
)
873 if (!(dbm_file
= dbfn_open(US
"misc", O_RDONLY
, &dbblock
, FALSE
, TRUE
)))
874 { DEBUG(D_transport
) debug_printf("ehlo-cache: no misc DB\n"); }
877 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
878 dbdata_ehlo_resp
* er
;
880 if (!(er
= dbfn_read(dbm_file
, ehlo_resp_key
)))
881 { DEBUG(D_transport
) debug_printf("no ehlo-resp record\n"); }
882 else if (time(NULL
) - er
->time_stamp
> retry_data_expire
)
884 DEBUG(D_transport
) debug_printf("ehlo-resp record too old\n");
885 dbfn_close(dbm_file
);
886 if ((dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
887 dbfn_delete(dbm_file
, ehlo_resp_key
);
891 sx
->ehlo_resp
= er
->data
;
892 dbfn_close(dbm_file
);
893 DEBUG(D_transport
) debug_printf(
894 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
895 er
->data
.cleartext_features
, er
->data
.crypted_features
);
898 dbfn_close(dbm_file
);
905 /* Return an auths bitmap for the set of AUTH methods offered by the server
906 which match our authenticators. */
908 static unsigned short
909 study_ehlo_auths(smtp_context
* sx
)
914 unsigned short authbits
= 0;
916 if (!sx
->esmtp
) return 0;
917 if (!regex_AUTH
) regex_AUTH
= regex_must_compile(AUTHS_REGEX
, FALSE
, TRUE
);
918 if (!regex_match_and_setup(regex_AUTH
, sx
->buffer
, 0, -1)) return 0;
919 expand_nmax
= -1; /* reset */
920 names
= string_copyn(expand_nstring
[1], expand_nlength
[1]);
922 for (au
= auths
, authnum
= 0; au
; au
= au
->next
, authnum
++) if (au
->client
)
924 const uschar
* list
= names
;
928 while (string_nextinlist(&list
, &sep
, name
, sizeof(name
)))
929 if (strcmpic(au
->public_name
, name
) == 0)
930 { authbits
|= BIT(authnum
); break; }
934 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
935 tls_out
.active
.sock
>= 0 ? "crypted" : "plaintext", names
, authbits
);
937 if (tls_out
.active
.sock
>= 0)
938 sx
->ehlo_resp
.crypted_auths
= authbits
;
940 sx
->ehlo_resp
.cleartext_auths
= authbits
;
947 /* Wait for and check responses for early-pipelining.
949 Called from the lower-level smtp_read_response() function
950 used for general code that assume synchronisation, if context
951 flags indicate outstanding early-pipelining commands. Also
952 called fom sync_responses() which handles pipelined commands.
955 sx smtp connection context
956 countp number of outstanding responses, adjusted on return
960 DEFER error on first read of TLS'd conn
961 FAIL SMTP error in response
964 smtp_reap_early_pipe(smtp_context
* sx
, int * countp
)
966 BOOL pending_BANNER
= sx
->pending_BANNER
;
967 BOOL pending_EHLO
= sx
->pending_EHLO
;
970 sx
->pending_BANNER
= FALSE
; /* clear early to avoid recursion */
971 sx
->pending_EHLO
= FALSE
;
975 DEBUG(D_transport
) debug_printf("%s expect banner\n", __FUNCTION__
);
977 if (!smtp_reap_banner(sx
))
979 DEBUG(D_transport
) debug_printf("bad banner\n");
980 if (tls_out
.active
.sock
>= 0) rc
= DEFER
;
987 unsigned peer_offered
;
988 unsigned short authbits
= 0, * ap
;
990 DEBUG(D_transport
) debug_printf("%s expect ehlo\n", __FUNCTION__
);
992 if (!smtp_reap_ehlo(sx
))
994 DEBUG(D_transport
) debug_printf("bad response for EHLO\n");
995 if (tls_out
.active
.sock
>= 0) rc
= DEFER
;
999 /* Compare the actual EHLO response to the cached value we assumed;
1000 on difference, dump or rewrite the cache and arrange for a retry. */
1002 ap
= tls_out
.active
.sock
< 0
1003 ? &sx
->ehlo_resp
.cleartext_auths
: &sx
->ehlo_resp
.crypted_auths
;
1005 peer_offered
= ehlo_response(sx
->buffer
,
1006 (tls_out
.active
.sock
< 0 ? OPTION_TLS
: 0)
1007 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
1008 | OPTION_UTF8
| OPTION_EARLY_PIPE
1010 if ( peer_offered
!= sx
->peer_offered
1011 || (authbits
= study_ehlo_auths(sx
)) != *ap
)
1014 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
1015 tls_out
.active
.sock
< 0 ? "cleartext" : "crypted",
1016 sx
->peer_offered
, *ap
, peer_offered
, authbits
);
1017 *(tls_out
.active
.sock
< 0
1018 ? &sx
->ehlo_resp
.cleartext_features
: &sx
->ehlo_resp
.crypted_features
) = peer_offered
;
1020 if (peer_offered
& OPTION_EARLY_PIPE
)
1021 write_ehlo_cache_entry(sx
);
1023 invalidate_ehlo_cache_entry(sx
);
1025 return OK
; /* just carry on */
1031 invalidate_ehlo_cache_entry(sx
);
1032 (void) smtp_discard_responses(sx
, sx
->conn_args
.ob
, *countp
);
1038 /*************************************************
1039 * Synchronize SMTP responses *
1040 *************************************************/
1042 /* This function is called from smtp_deliver() to receive SMTP responses from
1043 the server, and match them up with the commands to which they relate. When
1044 PIPELINING is not in use, this function is called after every command, and is
1045 therefore somewhat over-engineered, but it is simpler to use a single scheme
1046 that works both with and without PIPELINING instead of having two separate sets
1049 The set of commands that are buffered up with pipelining may start with MAIL
1050 and may end with DATA; in between are RCPT commands that correspond to the
1051 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1052 etc.) are never buffered.
1054 Errors after MAIL or DATA abort the whole process leaving the response in the
1055 buffer. After MAIL, pending responses are flushed, and the original command is
1056 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1057 permitted to reject some recipient addresses while accepting others. However
1058 certain errors clearly abort the whole process. Set the value in
1059 transport_return to PENDING_OK if the address is accepted. If there is a
1060 subsequent general error, it will get reset accordingly. If not, it will get
1061 converted to OK at the end.
1064 sx smtp connection context
1065 count the number of responses to read
1066 pending_DATA 0 if last command sent was not DATA
1067 +1 if previously had a good recipient
1068 -1 if not previously had a good recipient
1070 Returns: 3 if at least one address had 2xx and one had 5xx
1071 2 if at least one address had 5xx but none had 2xx
1072 1 if at least one host had a 2xx response, but none had 5xx
1073 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1074 -1 timeout while reading RCPT response
1075 -2 I/O or other non-response error for RCPT
1076 -3 DATA or MAIL failed - errno and buffer set
1077 -4 banner or EHLO failed (early-pipelining)
1078 -5 banner or EHLO failed (early-pipelining, TLS)
1082 sync_responses(smtp_context
* sx
, int count
, int pending_DATA
)
1084 address_item
* addr
= sx
->sync_addr
;
1085 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
;
1088 #ifdef EXPERIMENTAL_PIPE_CONNECT
1090 if ((rc
= smtp_reap_early_pipe(sx
, &count
)) != OK
)
1091 return rc
== FAIL
? -4 : -5;
1094 /* Handle the response for a MAIL command. On error, reinstate the original
1095 command in big_buffer for error message use, and flush any further pending
1096 responses before returning, except after I/O errors and timeouts. */
1098 if (sx
->pending_MAIL
)
1100 DEBUG(D_transport
) debug_printf("%s expect mail\n", __FUNCTION__
);
1102 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1103 '2', ob
->command_timeout
))
1105 DEBUG(D_transport
) debug_printf("bad response for MAIL\n");
1106 Ustrcpy(big_buffer
, mail_command
); /* Fits, because it came from there! */
1107 if (errno
== ERRNO_TLSFAILURE
)
1109 if (errno
== 0 && sx
->buffer
[0] != 0)
1112 if (sx
->buffer
[0] == '4')
1114 save_errno
= ERRNO_MAIL4XX
;
1115 addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1117 count
= smtp_discard_responses(sx
, ob
, count
);
1121 if (pending_DATA
) count
--; /* Number of RCPT responses to come */
1122 while (count
-- > 0) /* Mark any pending addrs with the host used */
1124 while (addr
->transport_return
!= PENDING_DEFER
) addr
= addr
->next
;
1125 addr
->host_used
= sx
->conn_args
.host
;
1132 if (pending_DATA
) count
--; /* Number of RCPT responses to come */
1134 /* Read and handle the required number of RCPT responses, matching each one up
1135 with an address by scanning for the next address whose status is PENDING_DEFER.
1140 while (addr
->transport_return
!= PENDING_DEFER
)
1141 if (!(addr
= addr
->next
))
1144 /* The address was accepted */
1145 addr
->host_used
= sx
->conn_args
.host
;
1147 DEBUG(D_transport
) debug_printf("%s expect rcpt\n", __FUNCTION__
);
1148 if (smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1149 '2', ob
->command_timeout
))
1152 addr
->transport_return
= PENDING_OK
;
1154 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1155 ensure that any address-specific retry record is expunged. We do this both
1156 for the basic key and for the version that also includes the sender. */
1158 if (testflag(addr
, af_dr_retry_exists
))
1160 uschar
*altkey
= string_sprintf("%s:<%s>", addr
->address_retry_key
,
1162 retry_add_item(addr
, altkey
, rf_delete
);
1163 retry_add_item(addr
, addr
->address_retry_key
, rf_delete
);
1167 /* Error on first TLS read */
1169 else if (errno
== ERRNO_TLSFAILURE
)
1172 /* Timeout while reading the response */
1174 else if (errno
== ETIMEDOUT
)
1176 uschar
*message
= string_sprintf("SMTP timeout after RCPT TO:<%s>",
1177 transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
));
1178 set_errno_nohost(sx
->first_addr
, ETIMEDOUT
, message
, DEFER
, FALSE
);
1179 retry_add_item(addr
, addr
->address_retry_key
, 0);
1180 update_waiting
= FALSE
;
1184 /* Handle other errors in obtaining an SMTP response by returning -1. This
1185 will cause all the addresses to be deferred. Restore the SMTP command in
1186 big_buffer for which we are checking the response, so the error message
1189 else if (errno
!= 0 || sx
->buffer
[0] == 0)
1191 string_format(big_buffer
, big_buffer_size
, "RCPT TO:<%s>",
1192 transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
));
1196 /* Handle SMTP permanent and temporary response codes. */
1201 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1202 "%s", transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
),
1203 string_printing(sx
->buffer
));
1204 setflag(addr
, af_pass_message
);
1206 msglog_line(sx
->conn_args
.host
, addr
->message
);
1208 /* The response was 5xx */
1210 if (sx
->buffer
[0] == '5')
1212 addr
->transport_return
= FAIL
;
1216 /* The response was 4xx */
1220 addr
->transport_return
= DEFER
;
1221 addr
->basic_errno
= ERRNO_RCPT4XX
;
1222 addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1226 #ifndef DISABLE_EVENT
1227 event_defer_errno
= addr
->more_errno
;
1228 msg_event_raise(US
"msg:rcpt:host:defer", addr
);
1231 /* Log temporary errors if there are more hosts to be tried.
1232 If not, log this last one in the == line. */
1234 if (sx
->conn_args
.host
->next
)
1235 if (LOGGING(outgoing_port
))
1236 log_write(0, LOG_MAIN
, "H=%s [%s]:%d %s", sx
->conn_args
.host
->name
,
1237 sx
->conn_args
.host
->address
,
1238 sx
->port
== PORT_NONE
? 25 : sx
->port
, addr
->message
);
1240 log_write(0, LOG_MAIN
, "H=%s [%s]: %s", sx
->conn_args
.host
->name
,
1241 sx
->conn_args
.host
->address
, addr
->message
);
1243 #ifndef DISABLE_EVENT
1245 msg_event_raise(US
"msg:rcpt:defer", addr
);
1248 /* Do not put this message on the list of those waiting for specific
1249 hosts, as otherwise it is likely to be tried too often. */
1251 update_waiting
= FALSE
;
1253 /* Add a retry item for the address so that it doesn't get tried again
1254 too soon. If address_retry_include_sender is true, add the sender address
1255 to the retry key. */
1257 retry_add_item(addr
,
1258 ob
->address_retry_include_sender
1259 ? string_sprintf("%s:<%s>", addr
->address_retry_key
, sender_address
)
1260 : addr
->address_retry_key
,
1265 } /* Loop for next RCPT response */
1267 /* Update where to start at for the next block of responses, unless we
1268 have already handled all the addresses. */
1270 if (addr
) sx
->sync_addr
= addr
->next
;
1272 /* Handle a response to DATA. If we have not had any good recipients, either
1273 previously or in this block, the response is ignored. */
1275 if (pending_DATA
!= 0)
1277 DEBUG(D_transport
) debug_printf("%s expect data\n", __FUNCTION__
);
1278 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1279 '3', ob
->command_timeout
))
1285 if (errno
== ERRNO_TLSFAILURE
) /* Error on first TLS read */
1288 if (pending_DATA
> 0 || (yield
& 1) != 0)
1290 if (errno
== 0 && sx
->buffer
[0] == '4')
1292 errno
= ERRNO_DATA4XX
;
1293 sx
->first_addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1297 (void)check_response(sx
->conn_args
.host
, &errno
, 0, sx
->buffer
, &code
, &msg
, &pass_message
);
1298 DEBUG(D_transport
) debug_printf("%s\nerror for DATA ignored: pipelining "
1299 "is in use and there were no good recipients\n", msg
);
1303 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1304 present) received 3xx. If any RCPTs were handled and yielded anything other
1305 than 4xx, yield will be set non-zero. */
1314 /* Try an authenticator's client entry */
1317 try_authenticator(smtp_context
* sx
, auth_instance
* au
)
1319 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
; /* transport options */
1320 host_item
* host
= sx
->conn_args
.host
; /* host to deliver to */
1323 sx
->outblock
.authenticating
= TRUE
;
1324 rc
= (au
->info
->clientcode
)(au
, sx
, ob
->command_timeout
,
1325 sx
->buffer
, sizeof(sx
->buffer
));
1326 sx
->outblock
.authenticating
= FALSE
;
1327 DEBUG(D_transport
) debug_printf("%s authenticator yielded %d\n", au
->name
, rc
);
1329 /* A temporary authentication failure must hold up delivery to
1330 this host. After a permanent authentication failure, we carry on
1331 to try other authentication methods. If all fail hard, try to
1332 deliver the message unauthenticated unless require_auth was set. */
1337 f
.smtp_authenticated
= TRUE
; /* stops the outer loop */
1338 client_authenticator
= au
->name
;
1339 if (au
->set_client_id
)
1340 client_authenticated_id
= expand_string(au
->set_client_id
);
1343 /* Failure after writing a command */
1348 /* Failure after reading a response */
1351 if (errno
!= 0 || sx
->buffer
[0] != '5') return FAIL
;
1352 log_write(0, LOG_MAIN
, "%s authenticator failed H=%s [%s] %s",
1353 au
->name
, host
->name
, host
->address
, sx
->buffer
);
1356 /* Failure by some other means. In effect, the authenticator
1357 decided it wasn't prepared to handle this case. Typically this
1358 is the result of "fail" in an expansion string. Do we need to
1359 log anything here? Feb 2006: a message is now put in the buffer
1360 if logging is required. */
1363 if (*sx
->buffer
!= 0)
1364 log_write(0, LOG_MAIN
, "%s authenticator cancelled "
1365 "authentication H=%s [%s] %s", au
->name
, host
->name
,
1366 host
->address
, sx
->buffer
);
1369 /* Internal problem, message in buffer. */
1372 set_errno_nohost(sx
->addrlist
, ERRNO_AUTHPROB
, string_copy(sx
->buffer
),
1382 /* Do the client side of smtp-level authentication.
1385 sx smtp connection context
1387 sx->buffer should have the EHLO response from server (gets overwritten)
1390 OK Success, or failed (but not required): global "smtp_authenticated" set
1391 DEFER Failed authentication (and was required)
1392 ERROR Internal problem
1394 FAIL_SEND Failed communications - transmit
1399 smtp_auth(smtp_context
* sx
)
1401 host_item
* host
= sx
->conn_args
.host
; /* host to deliver to */
1402 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
; /* transport options */
1403 int require_auth
= verify_check_given_host(CUSS
&ob
->hosts_require_auth
, host
);
1404 #ifdef EXPERIMENTAL_PIPE_CONNECT
1405 unsigned short authbits
= tls_out
.active
.sock
>= 0
1406 ? sx
->ehlo_resp
.crypted_auths
: sx
->ehlo_resp
.cleartext_auths
;
1408 uschar
* fail_reason
= US
"server did not advertise AUTH support";
1410 f
.smtp_authenticated
= FALSE
;
1411 client_authenticator
= client_authenticated_id
= client_authenticated_sender
= NULL
;
1414 regex_AUTH
= regex_must_compile(AUTHS_REGEX
, FALSE
, TRUE
);
1416 /* Is the server offering AUTH? */
1420 #ifdef EXPERIMENTAL_PIPE_CONNECT
1421 sx
->early_pipe_active
? authbits
1424 regex_match_and_setup(regex_AUTH
, sx
->buffer
, 0, -1)
1427 uschar
* names
= NULL
;
1428 expand_nmax
= -1; /* reset */
1430 #ifdef EXPERIMENTAL_PIPE_CONNECT
1431 if (!sx
->early_pipe_active
)
1433 names
= string_copyn(expand_nstring
[1], expand_nlength
[1]);
1435 /* Must not do this check until after we have saved the result of the
1436 regex match above as the check could be another RE. */
1438 if ( require_auth
== OK
1439 || verify_check_given_host(CUSS
&ob
->hosts_try_auth
, host
) == OK
)
1441 DEBUG(D_transport
) debug_printf("scanning authentication mechanisms\n");
1442 fail_reason
= US
"no common mechanisms were found";
1444 #ifdef EXPERIMENTAL_PIPE_CONNECT
1445 if (sx
->early_pipe_active
)
1447 /* Scan our authenticators (which support use by a client and were offered
1448 by the server (checked at cache-write time)), not suppressed by
1449 client_condition. If one is found, attempt to authenticate by calling its
1450 client function. We are limited to supporting up to 16 authenticator
1451 public-names by the number of bits in a short. */
1457 for (bitnum
= 0, au
= auths
;
1458 !f
.smtp_authenticated
&& au
&& bitnum
< 16;
1459 bitnum
++, au
= au
->next
) if (authbits
& BIT(bitnum
))
1461 if ( au
->client_condition
1462 && !expand_check_condition(au
->client_condition
, au
->name
,
1463 US
"client authenticator"))
1465 DEBUG(D_transport
) debug_printf("skipping %s authenticator: %s\n",
1466 au
->name
, "client_condition is false");
1470 /* Found data for a listed mechanism. Call its client entry. Set
1471 a flag in the outblock so that data is overwritten after sending so
1472 that reflections don't show it. */
1474 fail_reason
= US
"authentication attempt(s) failed";
1476 if ((rc
= try_authenticator(sx
, au
)) != OK
)
1483 /* Scan the configured authenticators looking for one which is configured
1484 for use as a client, which is not suppressed by client_condition, and
1485 whose name matches an authentication mechanism supported by the server.
1486 If one is found, attempt to authenticate by calling its client function.
1489 for (auth_instance
* au
= auths
; !f
.smtp_authenticated
&& au
; au
= au
->next
)
1494 || ( au
->client_condition
1495 && !expand_check_condition(au
->client_condition
, au
->name
,
1496 US
"client authenticator")))
1498 DEBUG(D_transport
) debug_printf("skipping %s authenticator: %s\n",
1500 (au
->client
)? "client_condition is false" :
1501 "not configured as a client");
1505 /* Loop to scan supported server mechanisms */
1509 int len
= Ustrlen(au
->public_name
);
1512 while (isspace(*p
)) p
++;
1514 if (strncmpic(au
->public_name
, p
, len
) != 0 ||
1515 (p
[len
] != 0 && !isspace(p
[len
])))
1517 while (*p
!= 0 && !isspace(*p
)) p
++;
1521 /* Found data for a listed mechanism. Call its client entry. Set
1522 a flag in the outblock so that data is overwritten after sending so
1523 that reflections don't show it. */
1525 fail_reason
= US
"authentication attempt(s) failed";
1527 if ((rc
= try_authenticator(sx
, au
)) != OK
)
1530 break; /* If not authenticated, try next authenticator */
1531 } /* Loop for scanning supported server mechanisms */
1532 } /* Loop for further authenticators */
1536 /* If we haven't authenticated, but are required to, give up. */
1538 if (require_auth
== OK
&& !f
.smtp_authenticated
)
1540 set_errno_nohost(sx
->addrlist
, ERRNO_AUTHFAIL
,
1541 string_sprintf("authentication required but %s", fail_reason
), DEFER
,
1550 /* Construct AUTH appendix string for MAIL TO */
1553 buffer to build string
1554 addrlist chain of potential addresses to deliver
1555 ob transport options
1557 Globals f.smtp_authenticated
1558 client_authenticated_sender
1559 Return True on error, otherwise buffer has (possibly empty) terminated string
1563 smtp_mail_auth_str(uschar
*buffer
, unsigned bufsize
, address_item
*addrlist
,
1564 smtp_transport_options_block
*ob
)
1566 uschar
*local_authenticated_sender
= authenticated_sender
;
1569 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender
, ob
->authenticated_sender
, f
.smtp_authenticated
?"Y":"N");
1572 if (ob
->authenticated_sender
!= NULL
)
1574 uschar
*new = expand_string(ob
->authenticated_sender
);
1577 if (!f
.expand_string_forcedfail
)
1579 uschar
*message
= string_sprintf("failed to expand "
1580 "authenticated_sender: %s", expand_string_message
);
1581 set_errno_nohost(addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
);
1585 else if (new[0] != 0) local_authenticated_sender
= new;
1588 /* Add the authenticated sender address if present */
1590 if ((f
.smtp_authenticated
|| ob
->authenticated_sender_force
) &&
1591 local_authenticated_sender
!= NULL
)
1593 string_format(buffer
, bufsize
, " AUTH=%s",
1594 auth_xtextencode(local_authenticated_sender
,
1595 Ustrlen(local_authenticated_sender
)));
1596 client_authenticated_sender
= string_copy(local_authenticated_sender
);
1607 /* Lookup TLSA record for host/port.
1608 Return: OK success with dnssec; DANE mode
1609 DEFER Do not use this host now, may retry later
1610 FAIL_FORCED No TLSA record; DANE not usable
1611 FAIL Do not use this connection
1615 tlsa_lookup(const host_item
* host
, dns_answer
* dnsa
, BOOL dane_required
)
1617 /* move this out to host.c given the similarity to dns_lookup() ? */
1619 const uschar
* fullname
= buffer
;
1623 /* TLSA lookup string */
1624 (void)sprintf(CS buffer
, "_%d._tcp.%.256s", host
->port
, host
->name
);
1626 rc
= dns_lookup(dnsa
, buffer
, T_TLSA
, &fullname
);
1627 sec
= dns_is_secure(dnsa
);
1629 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc
, sec
? "" : "not ");
1634 return DEFER
; /* just defer this TLS'd conn */
1642 for (dns_record
* rr
= dns_next_rr(dnsa
, &dnss
, RESET_ANSWERS
); rr
;
1643 rr
= dns_next_rr(dnsa
, &dnss
, RESET_NEXT
))
1644 if (rr
->type
== T_TLSA
&& rr
->size
> 3)
1646 uint16_t payload_length
= rr
->size
- 3;
1647 uschar s
[MAX_TLSA_EXPANDED_SIZE
], * sp
= s
, * p
= US rr
->data
;
1649 sp
+= sprintf(CS sp
, "%d ", *p
++); /* usage */
1650 sp
+= sprintf(CS sp
, "%d ", *p
++); /* selector */
1651 sp
+= sprintf(CS sp
, "%d ", *p
++); /* matchtype */
1652 while (payload_length
-- > 0 && sp
-s
< (MAX_TLSA_EXPANDED_SIZE
- 4))
1653 sp
+= sprintf(CS sp
, "%02x", *p
++);
1655 debug_printf(" %s\n", s
);
1660 log_write(0, LOG_MAIN
,
1661 "DANE error: TLSA lookup for %s not DNSSEC", host
->name
);
1664 case DNS_NODATA
: /* no TLSA RR for this lookup */
1665 case DNS_NOMATCH
: /* no records at all for this lookup */
1666 return dane_required
? FAIL
: FAIL_FORCED
;
1670 return dane_required
? FAIL
: DEFER
;
1677 typedef struct smtp_compare_s
1679 uschar
*current_sender_address
;
1680 struct transport_instance
*tblock
;
1684 /* Create a unique string that identifies this message, it is based on
1685 sender_address, helo_data and tls_certificate if enabled.
1689 smtp_local_identity(uschar
* sender
, struct transport_instance
* tblock
)
1691 address_item
* addr1
;
1692 uschar
* if1
= US
"";
1693 uschar
* helo1
= US
"";
1695 uschar
* tlsc1
= US
"";
1697 uschar
* save_sender_address
= sender_address
;
1698 uschar
* local_identity
= NULL
;
1699 smtp_transport_options_block
* ob
= SOB tblock
->options_block
;
1701 sender_address
= sender
;
1703 addr1
= deliver_make_addr (sender
, TRUE
);
1704 deliver_set_expansions(addr1
);
1707 if1
= expand_string(ob
->interface
);
1710 helo1
= expand_string(ob
->helo_data
);
1713 if (ob
->tls_certificate
)
1714 tlsc1
= expand_string(ob
->tls_certificate
);
1715 local_identity
= string_sprintf ("%s^%s^%s", if1
, helo1
, tlsc1
);
1717 local_identity
= string_sprintf ("%s^%s", if1
, helo1
);
1720 deliver_set_expansions(NULL
);
1721 sender_address
= save_sender_address
;
1723 return local_identity
;
1728 /* This routine is a callback that is called from transport_check_waiting.
1729 This function will evaluate the incoming message versus the previous
1730 message. If the incoming message is using a different local identity then
1731 we will veto this new message. */
1734 smtp_are_same_identities(uschar
* message_id
, smtp_compare_t
* s_compare
)
1736 uschar
* message_local_identity
,
1737 * current_local_identity
,
1738 * new_sender_address
;
1740 current_local_identity
=
1741 smtp_local_identity(s_compare
->current_sender_address
, s_compare
->tblock
);
1743 if (!(new_sender_address
= deliver_get_sender_address(message_id
)))
1746 message_local_identity
=
1747 smtp_local_identity(new_sender_address
, s_compare
->tblock
);
1749 return Ustrcmp(current_local_identity
, message_local_identity
) == 0;
1755 ehlo_response(uschar
* buf
, unsigned checks
)
1757 size_t bsize
= Ustrlen(buf
);
1759 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1762 if ( checks
& OPTION_TLS
1763 && pcre_exec(regex_STARTTLS
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1765 checks
&= ~OPTION_TLS
;
1767 if ( checks
& OPTION_IGNQ
1768 && pcre_exec(regex_IGNOREQUOTA
, NULL
, CS buf
, bsize
, 0,
1769 PCRE_EOPT
, NULL
, 0) < 0)
1770 checks
&= ~OPTION_IGNQ
;
1772 if ( checks
& OPTION_CHUNKING
1773 && pcre_exec(regex_CHUNKING
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1774 checks
&= ~OPTION_CHUNKING
;
1776 #ifndef DISABLE_PRDR
1777 if ( checks
& OPTION_PRDR
1778 && pcre_exec(regex_PRDR
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1780 checks
&= ~OPTION_PRDR
;
1783 if ( checks
& OPTION_UTF8
1784 && pcre_exec(regex_UTF8
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1786 checks
&= ~OPTION_UTF8
;
1788 if ( checks
& OPTION_DSN
1789 && pcre_exec(regex_DSN
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1790 checks
&= ~OPTION_DSN
;
1792 if ( checks
& OPTION_PIPE
1793 && pcre_exec(regex_PIPELINING
, NULL
, CS buf
, bsize
, 0,
1794 PCRE_EOPT
, NULL
, 0) < 0)
1795 checks
&= ~OPTION_PIPE
;
1797 if ( checks
& OPTION_SIZE
1798 && pcre_exec(regex_SIZE
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1799 checks
&= ~OPTION_SIZE
;
1801 #ifdef EXPERIMENTAL_PIPE_CONNECT
1802 if ( checks
& OPTION_EARLY_PIPE
1803 && pcre_exec(regex_EARLY_PIPE
, NULL
, CS buf
, bsize
, 0,
1804 PCRE_EOPT
, NULL
, 0) < 0)
1806 checks
&= ~OPTION_EARLY_PIPE
;
1808 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1814 /* Callback for emitting a BDAT data chunk header.
1816 If given a nonzero size, first flush any buffered SMTP commands
1817 then emit the command.
1819 Reap previous SMTP command responses if requested, and always reap
1820 the response from a previous BDAT command.
1823 tctx transport context
1824 chunk_size value for SMTP BDAT command
1826 tc_chunk_last add LAST option to SMTP BDAT command
1827 tc_reap_prev reap response to previous SMTP commands
1831 DEFER TLS error on first read (EHLO-resp); errno set
1835 smtp_chunk_cmd_callback(transport_ctx
* tctx
, unsigned chunk_size
,
1838 smtp_transport_options_block
* ob
= SOB tctx
->tblock
->options_block
;
1839 smtp_context
* sx
= tctx
->smtp_context
;
1843 /* Write SMTP chunk header command. If not reaping responses, note that
1844 there may be more writes (like, the chunk data) done soon. */
1848 #ifdef EXPERIMENTAL_PIPE_CONNECT
1849 BOOL new_conn
= !!(sx
->outblock
.conn_args
);
1851 if((cmd_count
= smtp_write_command(sx
,
1852 flags
& tc_reap_prev
? SCMD_FLUSH
: SCMD_MORE
,
1853 "BDAT %u%s\r\n", chunk_size
, flags
& tc_chunk_last
? " LAST" : "")
1854 ) < 0) return ERROR
;
1855 if (flags
& tc_chunk_last
)
1856 data_command
= string_copy(big_buffer
); /* Save for later error message */
1857 #ifdef EXPERIMENTAL_PIPE_CONNECT
1858 /* That command write could have been the one that made the connection.
1859 Copy the fd from the client conn ctx (smtp transport specific) to the
1860 generic transport ctx. */
1863 tctx
->u
.fd
= sx
->outblock
.cctx
->sock
;
1867 prev_cmd_count
= cmd_count
+= sx
->cmd_count
;
1869 /* Reap responses for any previous, but not one we just emitted */
1873 if (sx
->pending_BDAT
)
1876 if (flags
& tc_reap_prev
&& prev_cmd_count
> 0)
1878 DEBUG(D_transport
) debug_printf("look for %d responses"
1879 " for previous pipelined cmds\n", prev_cmd_count
);
1881 switch(sync_responses(sx
, prev_cmd_count
, 0))
1883 case 1: /* 2xx (only) => OK */
1884 case 3: sx
->good_RCPT
= TRUE
; /* 2xx & 5xx => OK & progress made */
1885 case 2: sx
->completed_addr
= TRUE
; /* 5xx (only) => progress made */
1886 case 0: break; /* No 2xx or 5xx, but no probs */
1888 case -5: errno
= ERRNO_TLSFAILURE
;
1890 #ifdef EXPERIMENTAL_PIPE_CONNECT
1891 case -4: /* non-2xx for pipelined banner or EHLO */
1893 case -1: /* Timeout on RCPT */
1894 default: return ERROR
; /* I/O error, or any MAIL/DATA error */
1897 if (!sx
->pending_BDAT
)
1898 pipelining_active
= FALSE
;
1901 /* Reap response for an outstanding BDAT */
1903 if (sx
->pending_BDAT
)
1905 DEBUG(D_transport
) debug_printf("look for one response for BDAT\n");
1907 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
1908 ob
->command_timeout
))
1910 if (errno
== 0 && sx
->buffer
[0] == '4')
1912 errno
= ERRNO_DATA4XX
; /*XXX does this actually get used? */
1913 sx
->addrlist
->more_errno
|=
1914 ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1919 sx
->pending_BDAT
= FALSE
;
1920 pipelining_active
= FALSE
;
1922 else if (chunk_size
> 0)
1923 sx
->pending_BDAT
= TRUE
;
1926 sx
->cmd_count
= cmd_count
;
1934 /*************************************************
1935 * Make connection for given message *
1936 *************************************************/
1940 ctx connection context
1941 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1942 a second attempt after TLS initialization fails
1944 Returns: OK - the connection was made and the delivery attempted;
1945 fd is set in the conn context, tls_out set up.
1946 DEFER - the connection could not be made, or something failed
1947 while setting up the SMTP session, or there was a
1948 non-message-specific error, such as a timeout.
1949 ERROR - helo_data or add_headers or authenticated_sender is
1950 specified for this transport, and the string failed
1954 smtp_setup_conn(smtp_context
* sx
, BOOL suppress_tls
)
1956 smtp_transport_options_block
* ob
= sx
->conn_args
.tblock
->options_block
;
1957 BOOL pass_message
= FALSE
;
1958 uschar
* message
= NULL
;
1962 uschar
* tls_errstr
;
1965 sx
->conn_args
.ob
= ob
;
1967 sx
->lmtp
= strcmpic(ob
->protocol
, US
"lmtp") == 0;
1968 sx
->smtps
= strcmpic(ob
->protocol
, US
"smtps") == 0;
1970 sx
->send_rset
= TRUE
;
1971 sx
->send_quit
= TRUE
;
1972 sx
->setting_up
= TRUE
;
1974 sx
->esmtp_sent
= FALSE
;
1976 sx
->utf8_needed
= FALSE
;
1978 sx
->dsn_all_lasthop
= TRUE
;
1980 sx
->conn_args
.dane
= FALSE
;
1982 verify_check_given_host(CUSS
&ob
->hosts_require_dane
, sx
->conn_args
.host
) == OK
;
1984 #ifdef EXPERIMENTAL_PIPE_CONNECT
1985 sx
->early_pipe_active
= sx
->early_pipe_ok
= FALSE
;
1986 sx
->ehlo_resp
.cleartext_features
= sx
->ehlo_resp
.crypted_features
= 0;
1987 sx
->pending_BANNER
= sx
->pending_EHLO
= FALSE
;
1990 if ((sx
->max_rcpt
= sx
->conn_args
.tblock
->max_addresses
) == 0) sx
->max_rcpt
= 999999;
1991 sx
->peer_offered
= 0;
1992 sx
->avoid_option
= 0;
1993 sx
->igquotstr
= US
"";
1994 if (!sx
->helo_data
) sx
->helo_data
= ob
->helo_data
;
1995 #ifdef EXPERIMENTAL_DSN_INFO
1996 sx
->smtp_greeting
= NULL
;
1997 sx
->helo_response
= NULL
;
2000 smtp_command
= US
"initial connection";
2001 sx
->buffer
[0] = '\0';
2003 /* Set up the buffer for reading SMTP response packets. */
2005 sx
->inblock
.buffer
= sx
->inbuffer
;
2006 sx
->inblock
.buffersize
= sizeof(sx
->inbuffer
);
2007 sx
->inblock
.ptr
= sx
->inbuffer
;
2008 sx
->inblock
.ptrend
= sx
->inbuffer
;
2010 /* Set up the buffer for holding SMTP commands while pipelining */
2012 sx
->outblock
.buffer
= sx
->outbuffer
;
2013 sx
->outblock
.buffersize
= sizeof(sx
->outbuffer
);
2014 sx
->outblock
.ptr
= sx
->outbuffer
;
2015 sx
->outblock
.cmd_count
= 0;
2016 sx
->outblock
.authenticating
= FALSE
;
2017 sx
->outblock
.conn_args
= NULL
;
2019 /* Reset the parameters of a TLS session. */
2022 tls_out
.cipher
= NULL
; /* the one we may use for this transport */
2023 tls_out
.ourcert
= NULL
;
2024 tls_out
.peercert
= NULL
;
2025 tls_out
.peerdn
= NULL
;
2029 tls_out
.ocsp
= OCSP_NOT_REQ
;
2030 #ifdef EXPERIMENTAL_TLS_RESUME
2031 tls_out
.resumption
= 0;
2034 /* Flip the legacy TLS-related variables over to the outbound set in case
2035 they're used in the context of the transport. Don't bother resetting
2036 afterward (when being used by a transport) as we're in a subprocess.
2037 For verify, unflipped once the callout is dealt with */
2039 tls_modify_variables(&tls_out
);
2044 set_errno_nohost(sx
->addrlist
, ERRNO_TLSFAILURE
, US
"TLS support not available",
2050 /* Make a connection to the host if this isn't a continued delivery, and handle
2051 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2052 specially so they can be identified for retries. */
2054 if (!continue_hostname
)
2057 HDEBUG(D_verify
) debug_printf("interface=%s port=%d\n", sx
->conn_args
.interface
, sx
->port
);
2059 /* Get the actual port the connection will use, into sx->conn_args.host */
2061 smtp_port_for_connect(sx
->conn_args
.host
, sx
->port
);
2064 /* Do TLSA lookup for DANE */
2066 tls_out
.dane_verified
= FALSE
;
2067 tls_out
.tlsa_usage
= 0;
2069 if (sx
->conn_args
.host
->dnssec
== DS_YES
)
2071 if( sx
->dane_required
2072 || verify_check_given_host(CUSS
&ob
->hosts_try_dane
, sx
->conn_args
.host
) == OK
2074 switch (rc
= tlsa_lookup(sx
->conn_args
.host
, &sx
->conn_args
.tlsa_dnsa
, sx
->dane_required
))
2076 case OK
: sx
->conn_args
.dane
= TRUE
;
2077 ob
->tls_tempfail_tryclear
= FALSE
;
2079 case FAIL_FORCED
: break;
2080 default: set_errno_nohost(sx
->addrlist
, ERRNO_DNSDEFER
,
2081 string_sprintf("DANE error: tlsa lookup %s",
2084 # ifndef DISABLE_EVENT
2085 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2086 US
"dane:fail", sx
->dane_required
2087 ? US
"dane-required" : US
"dnssec-invalid");
2092 else if (sx
->dane_required
)
2094 set_errno_nohost(sx
->addrlist
, ERRNO_DNSDEFER
,
2095 string_sprintf("DANE error: %s lookup not DNSSEC", sx
->conn_args
.host
->name
),
2097 # ifndef DISABLE_EVENT
2098 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2099 US
"dane:fail", US
"dane-required");
2106 /* Make the TCP connection */
2108 sx
->cctx
.tls_ctx
= NULL
;
2109 sx
->inblock
.cctx
= sx
->outblock
.cctx
= &sx
->cctx
;
2110 sx
->avoid_option
= sx
->peer_offered
= smtp_peer_options
= 0;
2112 #ifdef EXPERIMENTAL_PIPE_CONNECT
2113 if (verify_check_given_host(CUSS
&ob
->hosts_pipe_connect
, sx
->conn_args
.host
) == OK
)
2115 sx
->early_pipe_ok
= TRUE
;
2116 if ( read_ehlo_cache_entry(sx
)
2117 && sx
->ehlo_resp
.cleartext_features
& OPTION_EARLY_PIPE
)
2119 DEBUG(D_transport
) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2120 sx
->early_pipe_active
= TRUE
;
2121 sx
->peer_offered
= sx
->ehlo_resp
.cleartext_features
;
2125 if (sx
->early_pipe_active
)
2126 sx
->outblock
.conn_args
= &sx
->conn_args
;
2130 if ((sx
->cctx
.sock
= smtp_connect(&sx
->conn_args
, NULL
)) < 0)
2132 set_errno_nohost(sx
->addrlist
,
2133 errno
== ETIMEDOUT
? ERRNO_CONNECTTIMEOUT
: errno
,
2134 sx
->verify
? US
strerror(errno
) : NULL
,
2136 sx
->send_quit
= FALSE
;
2140 /* Expand the greeting message while waiting for the initial response. (Makes
2141 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2142 delayed till here so that $sending_interface and $sending_port are set. */
2143 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2144 will be? Somehow I doubt it. */
2147 if (!(sx
->helo_data
= expand_string(sx
->helo_data
)))
2149 log_write(0, LOG_MAIN
|LOG_PANIC
,
2150 "<%s>: failed to expand transport's helo_data value for callout: %s",
2151 sx
->addrlist
->address
, expand_string_message
);
2156 expand_string_message
= NULL
;
2157 if ((sx
->helo_data
= string_domain_utf8_to_alabel(sx
->helo_data
,
2158 &expand_string_message
)),
2159 expand_string_message
)
2161 log_write(0, LOG_MAIN
|LOG_PANIC
,
2162 "<%s>: failed to expand transport's helo_data value for callout: %s",
2163 sx
->addrlist
->address
, expand_string_message
);
2165 sx
->helo_data
= NULL
;
2169 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2170 is nevertheless a reasonably clean way of programming this kind of logic,
2171 where you want to escape on any error. */
2175 #ifdef EXPERIMENTAL_PIPE_CONNECT
2176 if (sx
->early_pipe_active
)
2178 sx
->pending_BANNER
= TRUE
; /* sync_responses() must eventually handle */
2179 sx
->outblock
.cmd_count
= 1;
2185 (void) setsockopt(sx
->cctx
.sock
, IPPROTO_TCP
, TCP_QUICKACK
, US
&off
,
2188 if (!smtp_reap_banner(sx
))
2189 goto RESPONSE_FAILED
;
2192 #ifndef DISABLE_EVENT
2195 lookup_dnssec_authenticated
= sx
->conn_args
.host
->dnssec
==DS_YES
? US
"yes"
2196 : sx
->conn_args
.host
->dnssec
==DS_NO
? US
"no" : NULL
;
2197 s
= event_raise(sx
->conn_args
.tblock
->event_action
, US
"smtp:connect", sx
->buffer
);
2200 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
,
2201 string_sprintf("deferred by smtp:connect event expansion: %s", s
),
2209 /* Now check if the helo_data expansion went well, and sign off cleanly if
2214 message
= string_sprintf("failed to expand helo_data: %s",
2215 expand_string_message
);
2216 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
);
2222 /** Debugging without sending a message
2223 sx->addrlist->transport_return = DEFER;
2227 /* Errors that occur after this point follow an SMTP command, which is
2228 left in big_buffer by smtp_write_command() for use in error messages. */
2230 smtp_command
= big_buffer
;
2232 /* Tell the remote who we are...
2234 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2235 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2236 greeting is of this form. The assumption was that the far end supports it
2237 properly... but experience shows that there are some that give 5xx responses,
2238 even though the banner includes "ESMTP" (there's a bloody-minded one that
2239 says "ESMTP not spoken here"). Cope with that case.
2241 September 2000: Time has passed, and it seems reasonable now to always send
2242 EHLO at the start. It is also convenient to make the change while installing
2245 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2246 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2247 would be no way to send out the mails, so there is now a host list
2248 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2249 PIPELINING problem as well. Maybe it can also be useful to cure other
2250 problems with broken servers.
2252 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2253 Then somebody tried it with a Microsoft mailer... It seems that all other
2254 mailers use upper case for some reason (the RFC is quite clear about case
2255 independence) so, for peace of mind, I gave in. */
2257 sx
->esmtp
= verify_check_given_host(CUSS
&ob
->hosts_avoid_esmtp
, sx
->conn_args
.host
) != OK
;
2259 /* Alas; be careful, since this goto is not an error-out, so conceivably
2260 we might set data between here and the target which we assume to exist
2261 and be usable. I can see this coming back to bite us. */
2265 smtp_peer_options
|= OPTION_TLS
;
2266 suppress_tls
= FALSE
;
2267 ob
->tls_tempfail_tryclear
= FALSE
;
2268 smtp_command
= US
"SSL-on-connect";
2275 if (smtp_write_command(sx
,
2276 #ifdef EXPERIMENTAL_PIPE_CONNECT
2277 sx
->early_pipe_active
? SCMD_BUFFER
:
2280 "%s %s\r\n", sx
->lmtp
? "LHLO" : "EHLO", sx
->helo_data
) < 0)
2282 sx
->esmtp_sent
= TRUE
;
2284 #ifdef EXPERIMENTAL_PIPE_CONNECT
2285 if (sx
->early_pipe_active
)
2287 sx
->pending_EHLO
= TRUE
;
2289 /* If we have too many authenticators to handle and might need to AUTH
2290 for this transport, pipeline no further as we will need the
2291 list of auth methods offered. Reap the banner and EHLO. */
2293 if ( (ob
->hosts_require_auth
|| ob
->hosts_try_auth
)
2294 && f
.smtp_in_early_pipe_no_auth
)
2296 DEBUG(D_transport
) debug_printf("may need to auth, so pipeline no further\n");
2297 if (smtp_write_command(sx
, SCMD_FLUSH
, NULL
) < 0)
2299 if (sync_responses(sx
, 2, 0) != 0)
2302 debug_printf("failed reaping pipelined cmd responses\n");
2303 goto RESPONSE_FAILED
;
2305 sx
->early_pipe_active
= FALSE
;
2310 if (!smtp_reap_ehlo(sx
))
2311 goto RESPONSE_FAILED
;
2315 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2317 #ifdef EXPERIMENTAL_PIPE_CONNECT
2318 if (!sx
->early_pipe_active
)
2323 int n
= sizeof(sx
->buffer
);
2324 uschar
* rsp
= sx
->buffer
;
2326 if (sx
->esmtp_sent
&& (n
= Ustrlen(sx
->buffer
)) < sizeof(sx
->buffer
)/2)
2327 { rsp
= sx
->buffer
+ n
+ 1; n
= sizeof(sx
->buffer
) - n
; }
2329 if (smtp_write_command(sx
, SCMD_FLUSH
, "HELO %s\r\n", sx
->helo_data
) < 0)
2331 good_response
= smtp_read_response(sx
, rsp
, n
, '2', ob
->command_timeout
);
2332 #ifdef EXPERIMENTAL_DSN_INFO
2333 sx
->helo_response
= string_copy(rsp
);
2337 /* Handle special logging for a closed connection after HELO
2338 when had previously sent EHLO */
2340 if (rsp
!= sx
->buffer
&& rsp
[0] == 0 && (errno
== 0 || errno
== ECONNRESET
))
2342 errno
= ERRNO_SMTPCLOSED
;
2343 goto EHLOHELO_FAILED
;
2345 memmove(sx
->buffer
, rsp
, Ustrlen(rsp
));
2346 goto RESPONSE_FAILED
;
2350 if (sx
->esmtp
|| sx
->lmtp
)
2352 #ifdef EXPERIMENTAL_PIPE_CONNECT
2353 if (!sx
->early_pipe_active
)
2356 sx
->peer_offered
= ehlo_response(sx
->buffer
,
2357 OPTION_TLS
/* others checked later */
2358 #ifdef EXPERIMENTAL_PIPE_CONNECT
2359 | (sx
->early_pipe_ok
2361 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
2370 #ifdef EXPERIMENTAL_PIPE_CONNECT
2371 if (sx
->early_pipe_ok
)
2373 sx
->ehlo_resp
.cleartext_features
= sx
->peer_offered
;
2375 if ( (sx
->peer_offered
& (OPTION_PIPE
| OPTION_EARLY_PIPE
))
2376 == (OPTION_PIPE
| OPTION_EARLY_PIPE
))
2378 DEBUG(D_transport
) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2379 sx
->ehlo_resp
.cleartext_auths
= study_ehlo_auths(sx
);
2380 write_ehlo_cache_entry(sx
);
2386 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2389 smtp_peer_options
|= sx
->peer_offered
& OPTION_TLS
;
2394 /* For continuing deliveries down the same channel, having re-exec'd the socket
2395 is the standard input; for a socket held open from verify it is recorded
2396 in the cutthrough context block. Either way we don't need to redo EHLO here
2397 (but may need to do so for TLS - see below).
2398 Set up the pointer to where subsequent commands will be left, for
2399 error messages. Note that smtp_peer_options will have been
2400 set from the command line if they were set in the process that passed the
2403 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2404 as the continue goes via transport_pass_socket() and doublefork and exec.
2405 It does not wait. Unclear how we keep separate host's responses
2406 separate - we could match up by host ip+port as a bodge. */
2410 if (cutthrough
.cctx
.sock
>= 0 && cutthrough
.callout_hold_only
)
2412 sx
->cctx
= cutthrough
.cctx
;
2413 sx
->conn_args
.host
->port
= sx
->port
= cutthrough
.host
.port
;
2417 sx
->cctx
.sock
= 0; /* stdin */
2418 sx
->cctx
.tls_ctx
= NULL
;
2419 smtp_port_for_connect(sx
->conn_args
.host
, sx
->port
); /* Record the port that was used */
2421 sx
->inblock
.cctx
= sx
->outblock
.cctx
= &sx
->cctx
;
2422 smtp_command
= big_buffer
;
2423 sx
->helo_data
= NULL
; /* ensure we re-expand ob->helo_data */
2425 /* For a continued connection with TLS being proxied for us, or a
2426 held-open verify connection with TLS, nothing more to do. */
2428 if ( continue_proxy_cipher
2429 || (cutthrough
.cctx
.sock
>= 0 && cutthrough
.callout_hold_only
2430 && cutthrough
.is_tls
)
2433 sx
->peer_offered
= smtp_peer_options
;
2434 sx
->pipelining_used
= pipelining_active
= !!(smtp_peer_options
& OPTION_PIPE
);
2435 HDEBUG(D_transport
) debug_printf("continued connection, %s TLS\n",
2436 continue_proxy_cipher
? "proxied" : "verify conn with");
2439 HDEBUG(D_transport
) debug_printf("continued connection, no TLS\n");
2442 /* If TLS is available on this connection, whether continued or not, attempt to
2443 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2444 send another EHLO - the server may give a different answer in secure mode. We
2445 use a separate buffer for reading the response to STARTTLS so that if it is
2446 negative, the original EHLO data is available for subsequent analysis, should
2447 the client not be required to use TLS. If the response is bad, copy the buffer
2448 for error analysis. */
2451 if ( smtp_peer_options
& OPTION_TLS
2453 && verify_check_given_host(CUSS
&ob
->hosts_avoid_tls
, sx
->conn_args
.host
) != OK
2455 || verify_check_given_host(CUSS
&ob
->hosts_verify_avoid_tls
, sx
->conn_args
.host
) != OK
2458 uschar buffer2
[4096];
2460 if (smtp_write_command(sx
, SCMD_FLUSH
, "STARTTLS\r\n") < 0)
2463 #ifdef EXPERIMENTAL_PIPE_CONNECT
2464 /* If doing early-pipelining reap the banner and EHLO-response but leave
2465 the response for the STARTTLS we just sent alone. */
2467 if (sx
->early_pipe_active
&& sync_responses(sx
, 2, 0) != 0)
2470 debug_printf("failed reaping pipelined cmd responses\n");
2471 goto RESPONSE_FAILED
;
2475 /* If there is an I/O error, transmission of this message is deferred. If
2476 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2477 false, we also defer. However, if there is a temporary rejection of STARTTLS
2478 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2479 STARTTLS, we carry on. This means we will try to send the message in clear,
2480 unless the host is in hosts_require_tls (tested below). */
2482 if (!smtp_read_response(sx
, buffer2
, sizeof(buffer2
), '2', ob
->command_timeout
))
2486 || (buffer2
[0] == '4' && !ob
->tls_tempfail_tryclear
)
2489 Ustrncpy(sx
->buffer
, buffer2
, sizeof(sx
->buffer
));
2490 sx
->buffer
[sizeof(sx
->buffer
)-1] = '\0';
2491 goto RESPONSE_FAILED
;
2495 /* STARTTLS accepted: try to negotiate a TLS session. */
2500 if (!tls_client_start(&sx
->cctx
, &sx
->conn_args
, sx
->addrlist
, &tls_out
, &tls_errstr
))
2502 /* TLS negotiation failed; give an error. From outside, this function may
2503 be called again to try in clear on a new connection, if the options permit
2504 it for this host. */
2508 DEBUG(D_tls
) debug_printf("TLS session fail: %s\n", tls_errstr
);
2510 # ifdef SUPPORT_DANE
2511 if (sx
->conn_args
.dane
)
2513 log_write(0, LOG_MAIN
,
2514 "DANE attempt failed; TLS connection to %s [%s]: %s",
2515 sx
->conn_args
.host
->name
, sx
->conn_args
.host
->address
, tls_errstr
);
2516 # ifndef DISABLE_EVENT
2517 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2518 US
"dane:fail", US
"validation-failure"); /* could do with better detail */
2523 errno
= ERRNO_TLSFAILURE
;
2524 message
= string_sprintf("TLS session: %s", tls_errstr
);
2525 sx
->send_quit
= FALSE
;
2529 /* TLS session is set up */
2531 smtp_peer_options_wrap
= smtp_peer_options
;
2532 for (address_item
* addr
= sx
->addrlist
; addr
; addr
= addr
->next
)
2533 if (addr
->transport_return
== PENDING_DEFER
)
2535 addr
->cipher
= tls_out
.cipher
;
2536 addr
->ourcert
= tls_out
.ourcert
;
2537 addr
->peercert
= tls_out
.peercert
;
2538 addr
->peerdn
= tls_out
.peerdn
;
2539 addr
->ocsp
= tls_out
.ocsp
;
2544 /* if smtps, we'll have smtp_command set to something else; always safe to
2546 smtp_command
= big_buffer
;
2548 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2549 helo_data is null, we are dealing with a connection that was passed from
2550 another process, and so we won't have expanded helo_data above. We have to
2551 expand it here. $sending_ip_address and $sending_port are set up right at the
2552 start of the Exim process (in exim.c). */
2554 if (tls_out
.active
.sock
>= 0)
2556 uschar
* greeting_cmd
;
2558 if (!sx
->helo_data
&& !(sx
->helo_data
= expand_string(ob
->helo_data
)))
2560 uschar
*message
= string_sprintf("failed to expand helo_data: %s",
2561 expand_string_message
);
2562 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
);
2567 #ifdef EXPERIMENTAL_PIPE_CONNECT
2568 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2569 We're unlikely to get the group sent and delivered before the server sends its
2570 banner, but it's still worth sending as a group.
2571 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2574 if (sx
->smtps
? sx
->early_pipe_ok
: sx
->early_pipe_active
)
2576 sx
->peer_offered
= sx
->ehlo_resp
.crypted_features
;
2577 if ((sx
->early_pipe_active
=
2578 !!(sx
->ehlo_resp
.crypted_features
& OPTION_EARLY_PIPE
)))
2579 DEBUG(D_transport
) debug_printf("Using cached crypted PIPE_CONNECT\n");
2583 /* For SMTPS we need to wait for the initial OK response. */
2585 #ifdef EXPERIMENTAL_PIPE_CONNECT
2586 if (sx
->early_pipe_active
)
2588 sx
->pending_BANNER
= TRUE
;
2589 sx
->outblock
.cmd_count
= 1;
2593 if (!smtp_reap_banner(sx
))
2594 goto RESPONSE_FAILED
;
2597 greeting_cmd
= US
"LHLO";
2599 greeting_cmd
= US
"EHLO";
2602 greeting_cmd
= US
"HELO";
2604 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2607 if (smtp_write_command(sx
,
2608 #ifdef EXPERIMENTAL_PIPE_CONNECT
2609 sx
->early_pipe_active
? SCMD_BUFFER
:
2612 "%s %s\r\n", greeting_cmd
, sx
->helo_data
) < 0)
2615 #ifdef EXPERIMENTAL_PIPE_CONNECT
2616 if (sx
->early_pipe_active
)
2617 sx
->pending_EHLO
= TRUE
;
2621 if (!smtp_reap_ehlo(sx
))
2624 /* The GnuTLS layer in Exim only spots a server-rejection of a client
2625 cert late, under TLS1.3 - which means here; the first time we try to
2626 receive crypted data. Treat it as if it was a connect-time failure.
2627 See also the early-pipe equivalent... which will be hard; every call
2628 to sync_responses will need to check the result.
2629 It would be nicer to have GnuTLS check the cert during the handshake.
2630 Can it do that, with all the flexibility we need? */
2632 tls_errstr
= US
"error on first read";
2633 goto GNUTLS_CONN_FAILED
;
2636 goto RESPONSE_FAILED
;
2638 smtp_peer_options
= 0;
2642 /* If the host is required to use a secure channel, ensure that we
2646 # ifdef SUPPORT_DANE
2647 || sx
->conn_args
.dane
2649 || verify_check_given_host(CUSS
&ob
->hosts_require_tls
, sx
->conn_args
.host
) == OK
2652 errno
= ERRNO_TLSREQUIRED
;
2653 message
= string_sprintf("a TLS session is required, but %s",
2654 smtp_peer_options
& OPTION_TLS
2655 ? "an attempt to start TLS failed" : "the server did not offer TLS support");
2656 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2657 if (sx
->conn_args
.dane
)
2658 (void) event_raise(sx
->conn_args
.tblock
->event_action
, US
"dane:fail",
2659 smtp_peer_options
& OPTION_TLS
2660 ? US
"validation-failure" /* could do with better detail */
2661 : US
"starttls-not-supported");
2665 #endif /*DISABLE_TLS*/
2667 /* If TLS is active, we have just started it up and re-done the EHLO command,
2668 so its response needs to be analyzed. If TLS is not active and this is a
2669 continued session down a previously-used socket, we haven't just done EHLO, so
2672 if (continue_hostname
== NULL
2674 || tls_out
.active
.sock
>= 0
2678 if (sx
->esmtp
|| sx
->lmtp
)
2680 #ifdef EXPERIMENTAL_PIPE_CONNECT
2681 if (!sx
->early_pipe_active
)
2684 sx
->peer_offered
= ehlo_response(sx
->buffer
,
2686 #ifdef EXPERIMENTAL_PIPE_CONNECT
2687 | (sx
->lmtp
&& ob
->lmtp_ignore_quota
? OPTION_IGNQ
: 0)
2688 | OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
2689 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_UTF8
2690 | (tls_out
.active
.sock
>= 0 ? OPTION_EARLY_PIPE
: 0) /* not for lmtp */
2694 | (sx
->lmtp
&& ob
->lmtp_ignore_quota
? OPTION_IGNQ
: 0)
2697 # ifdef SUPPORT_I18N
2698 | (sx
->addrlist
->prop
.utf8_msg
? OPTION_UTF8
: 0)
2699 /*XXX if we hand peercaps on to continued-conn processes,
2700 must not depend on this addr */
2704 | (ob
->size_addition
>= 0 ? OPTION_SIZE
: 0)
2707 #ifdef EXPERIMENTAL_PIPE_CONNECT
2708 if (tls_out
.active
.sock
>= 0)
2709 sx
->ehlo_resp
.crypted_features
= sx
->peer_offered
;
2713 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2714 lmtp_ignore_quota option was set. */
2716 sx
->igquotstr
= sx
->peer_offered
& OPTION_IGNQ
? US
" IGNOREQUOTA" : US
"";
2718 /* If the response to EHLO specified support for the SIZE parameter, note
2719 this, provided size_addition is non-negative. */
2721 smtp_peer_options
|= sx
->peer_offered
& OPTION_SIZE
;
2723 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2724 the current host, esmtp will be false, so PIPELINING can never be used. If
2725 the current host matches hosts_avoid_pipelining, don't do it. */
2727 if ( sx
->peer_offered
& OPTION_PIPE
2728 && verify_check_given_host(CUSS
&ob
->hosts_avoid_pipelining
, sx
->conn_args
.host
) != OK
)
2729 smtp_peer_options
|= OPTION_PIPE
;
2731 DEBUG(D_transport
) debug_printf("%susing PIPELINING\n",
2732 smtp_peer_options
& OPTION_PIPE
? "" : "not ");
2734 if ( sx
->peer_offered
& OPTION_CHUNKING
2735 && verify_check_given_host(CUSS
&ob
->hosts_try_chunking
, sx
->conn_args
.host
) != OK
)
2736 sx
->peer_offered
&= ~OPTION_CHUNKING
;
2738 if (sx
->peer_offered
& OPTION_CHUNKING
)
2739 DEBUG(D_transport
) debug_printf("CHUNKING usable\n");
2741 #ifndef DISABLE_PRDR
2742 if ( sx
->peer_offered
& OPTION_PRDR
2743 && verify_check_given_host(CUSS
&ob
->hosts_try_prdr
, sx
->conn_args
.host
) != OK
)
2744 sx
->peer_offered
&= ~OPTION_PRDR
;
2746 if (sx
->peer_offered
& OPTION_PRDR
)
2747 DEBUG(D_transport
) debug_printf("PRDR usable\n");
2750 /* Note if the server supports DSN */
2751 smtp_peer_options
|= sx
->peer_offered
& OPTION_DSN
;
2752 DEBUG(D_transport
) debug_printf("%susing DSN\n",
2753 sx
->peer_offered
& OPTION_DSN
? "" : "not ");
2755 #ifdef EXPERIMENTAL_PIPE_CONNECT
2756 if ( sx
->early_pipe_ok
2757 && !sx
->early_pipe_active
2758 && tls_out
.active
.sock
>= 0
2759 && smtp_peer_options
& OPTION_PIPE
2760 && ( sx
->ehlo_resp
.cleartext_features
| sx
->ehlo_resp
.crypted_features
)
2761 & OPTION_EARLY_PIPE
)
2763 DEBUG(D_transport
) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2764 sx
->ehlo_resp
.crypted_auths
= study_ehlo_auths(sx
);
2765 write_ehlo_cache_entry(sx
);
2769 /* Note if the response to EHLO specifies support for the AUTH extension.
2770 If it has, check that this host is one we want to authenticate to, and do
2771 the business. The host name and address must be available when the
2772 authenticator's client driver is running. */
2774 switch (yield
= smtp_auth(sx
))
2776 default: goto SEND_QUIT
;
2778 case FAIL_SEND
: goto SEND_FAILED
;
2779 case FAIL
: goto RESPONSE_FAILED
;
2783 sx
->pipelining_used
= pipelining_active
= !!(smtp_peer_options
& OPTION_PIPE
);
2785 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2786 message-specific. */
2788 sx
->setting_up
= FALSE
;
2791 if (sx
->addrlist
->prop
.utf8_msg
)
2795 /* If the transport sets a downconversion mode it overrides any set by ACL
2798 if ((s
= ob
->utf8_downconvert
))
2800 if (!(s
= expand_string(s
)))
2802 message
= string_sprintf("failed to expand utf8_downconvert: %s",
2803 expand_string_message
);
2804 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
);
2810 case '1': sx
->addrlist
->prop
.utf8_downcvt
= TRUE
;
2811 sx
->addrlist
->prop
.utf8_downcvt_maybe
= FALSE
;
2813 case '0': sx
->addrlist
->prop
.utf8_downcvt
= FALSE
;
2814 sx
->addrlist
->prop
.utf8_downcvt_maybe
= FALSE
;
2816 case '-': if (s
[1] == '1')
2818 sx
->addrlist
->prop
.utf8_downcvt
= FALSE
;
2819 sx
->addrlist
->prop
.utf8_downcvt_maybe
= TRUE
;
2825 sx
->utf8_needed
= !sx
->addrlist
->prop
.utf8_downcvt
2826 && !sx
->addrlist
->prop
.utf8_downcvt_maybe
;
2827 DEBUG(D_transport
) if (!sx
->utf8_needed
)
2828 debug_printf("utf8: %s downconvert\n",
2829 sx
->addrlist
->prop
.utf8_downcvt
? "mandatory" : "optional");
2832 /* If this is an international message we need the host to speak SMTPUTF8 */
2833 if (sx
->utf8_needed
&& !(sx
->peer_offered
& OPTION_UTF8
))
2835 errno
= ERRNO_UTF8_FWD
;
2836 goto RESPONSE_FAILED
;
2838 #endif /*SUPPORT_I18N*/
2848 sx
->send_quit
= check_response(sx
->conn_args
.host
, &errno
, sx
->addrlist
->more_errno
,
2849 sx
->buffer
, &code
, &message
, &pass_message
);
2855 message
= US
string_sprintf("send() to %s [%s] failed: %s",
2856 sx
->conn_args
.host
->name
, sx
->conn_args
.host
->address
, strerror(errno
));
2857 sx
->send_quit
= FALSE
;
2863 message
= string_sprintf("Remote host closed connection in response to %s"
2864 " (EHLO response was: %s)", smtp_command
, sx
->buffer
);
2865 sx
->send_quit
= FALSE
;
2869 /* This label is jumped to directly when a TLS negotiation has failed,
2870 or was not done for a host for which it is required. Values will be set
2871 in message and errno, and setting_up will always be true. Treat as
2872 a temporary error. */
2876 code
= '4', yield
= DEFER
;
2880 /* The failure happened while setting up the call; see if the failure was
2881 a 5xx response (this will either be on connection, or following HELO - a 5xx
2882 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2883 fail all addresses, as this host is never going to accept them. For other
2884 errors during setting up (timeouts or whatever), defer all addresses, and
2885 yield DEFER, so that the host is not tried again for a while.
2887 XXX This peeking for another host feels like a layering violation. We want
2888 to note the host as unusable, but down here we shouldn't know if this was
2889 the last host to try for the addr(list). Perhaps the upper layer should be
2890 the one to do set_errno() ? The problem is that currently the addr is where
2891 errno etc. are stashed, but until we run out of hosts to try the errors are
2892 host-specific. Maybe we should enhance the host_item definition? */
2895 sx
->ok
= FALSE
; /* For when reached by GOTO */
2896 set_errno(sx
->addrlist
, errno
, message
,
2897 sx
->conn_args
.host
->next
2901 || errno
== ERRNO_UTF8_FWD
2905 errno
== ECONNREFUSED
? NULL
: sx
->conn_args
.host
2906 #ifdef EXPERIMENTAL_DSN_INFO
2907 , sx
->smtp_greeting
, sx
->helo_response
2916 (void)smtp_write_command(sx
, SCMD_FLUSH
, "QUIT\r\n");
2919 if (sx
->cctx
.tls_ctx
)
2921 tls_close(sx
->cctx
.tls_ctx
, TLS_SHUTDOWN_NOWAIT
);
2922 sx
->cctx
.tls_ctx
= NULL
;
2926 /* Close the socket, and return the appropriate value, first setting
2927 works because the NULL setting is passed back to the calling process, and
2928 remote_max_parallel is forced to 1 when delivering over an existing connection,
2931 HDEBUG(D_transport
|D_acl
|D_v
) debug_printf_indent(" SMTP(close)>>\n");
2934 shutdown(sx
->cctx
.sock
, SHUT_WR
);
2935 if (fcntl(sx
->cctx
.sock
, F_SETFL
, O_NONBLOCK
) == 0)
2936 for (int i
= 16; read(sx
->cctx
.sock
, sx
->inbuffer
, sizeof(sx
->inbuffer
)) > 0 && i
> 0;)
2937 i
--; /* drain socket */
2938 sx
->send_quit
= FALSE
;
2940 (void)close(sx
->cctx
.sock
);
2943 #ifndef DISABLE_EVENT
2944 (void) event_raise(sx
->conn_args
.tblock
->event_action
, US
"tcp:close", NULL
);
2947 continue_transport
= NULL
;
2948 continue_hostname
= NULL
;
2955 /* Create the string of options that will be appended to the MAIL FROM:
2956 in the connection context buffer */
2959 build_mailcmd_options(smtp_context
* sx
, address_item
* addrlist
)
2961 uschar
* p
= sx
->buffer
;
2962 address_item
* addr
;
2967 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2968 send it, adding something to the message size to allow for imprecision
2969 and things that get added en route. Exim keeps the number of lines
2970 in a message, so we can give an accurate value for the original message, but we
2971 need some additional to handle added headers. (Double "." characters don't get
2972 included in the count.) */
2974 if ( message_size
> 0
2975 && sx
->peer_offered
& OPTION_SIZE
&& !(sx
->avoid_option
& OPTION_SIZE
))
2977 /*XXX problem here under spool_files_wireformat?
2978 Or just forget about lines? Or inflate by a fixed proportion? */
2980 sprintf(CS p
, " SIZE=%d", message_size
+message_linecount
+(SOB sx
->conn_args
.ob
)->size_addition
);
2984 #ifndef DISABLE_PRDR
2985 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
2988 sx
->prdr_active
= FALSE
;
2989 if (sx
->peer_offered
& OPTION_PRDR
)
2990 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
2991 if (addr
->transport_return
== PENDING_DEFER
)
2993 for (addr
= addr
->next
; addr
; addr
= addr
->next
)
2994 if (addr
->transport_return
== PENDING_DEFER
)
2995 { /* at least two recipients to send */
2996 sx
->prdr_active
= TRUE
;
2997 sprintf(CS p
, " PRDR"); p
+= 5;
3005 /* If it supports internationalised messages, and this meesage need that,
3008 if ( sx
->peer_offered
& OPTION_UTF8
3009 && addrlist
->prop
.utf8_msg
3010 && !addrlist
->prop
.utf8_downcvt
3012 Ustrcpy(p
, " SMTPUTF8"), p
+= 9;
3015 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3016 for (sx
->dsn_all_lasthop
= TRUE
, addr
= addrlist
, address_count
= 0;
3017 addr
&& address_count
< sx
->max_rcpt
;
3018 addr
= addr
->next
) if (addr
->transport_return
== PENDING_DEFER
)
3021 if (!(addr
->dsn_flags
& rf_dsnlasthop
))
3023 sx
->dsn_all_lasthop
= FALSE
;
3028 /* Add any DSN flags to the mail command */
3030 if (sx
->peer_offered
& OPTION_DSN
&& !sx
->dsn_all_lasthop
)
3032 if (dsn_ret
== dsn_ret_hdrs
)
3033 { Ustrcpy(p
, " RET=HDRS"); p
+= 9; }
3034 else if (dsn_ret
== dsn_ret_full
)
3035 { Ustrcpy(p
, " RET=FULL"); p
+= 9; }
3039 string_format(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), " ENVID=%s", dsn_envid
);
3044 /* If an authenticated_sender override has been specified for this transport
3045 instance, expand it. If the expansion is forced to fail, and there was already
3046 an authenticated_sender for this message, the original value will be used.
3047 Other expansion failures are serious. An empty result is ignored, but there is
3048 otherwise no check - this feature is expected to be used with LMTP and other
3049 cases where non-standard addresses (e.g. without domains) might be required. */
3051 if (smtp_mail_auth_str(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), addrlist
, sx
->conn_args
.ob
))
3059 build_rcptcmd_options(smtp_context
* sx
, const address_item
* addr
)
3061 uschar
* p
= sx
->buffer
;
3064 /* Add any DSN flags to the rcpt command */
3066 if (sx
->peer_offered
& OPTION_DSN
&& !(addr
->dsn_flags
& rf_dsnlasthop
))
3068 if (addr
->dsn_flags
& rf_dsnflags
)
3072 Ustrcpy(p
, " NOTIFY=");
3074 for (int i
= 0; i
< nelem(rf_list
); i
++) if (addr
->dsn_flags
& rf_list
[i
])
3076 if (!first
) *p
++ = ',';
3078 Ustrcpy(p
, rf_names
[i
]);
3083 if (addr
->dsn_orcpt
)
3085 string_format(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), " ORCPT=%s",
3096 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3097 -1 MAIL response error
3098 -2 any non-MAIL read i/o error
3099 -3 non-MAIL response timeout
3100 -4 internal error; channel still usable
3105 smtp_write_mail_and_rcpt_cmds(smtp_context
* sx
, int * yield
)
3107 address_item
* addr
;
3111 if (build_mailcmd_options(sx
, sx
->first_addr
) != OK
)
3117 /* From here until we send the DATA command, we can make use of PIPELINING
3118 if the server host supports it. The code has to be able to check the responses
3119 at any point, for when the buffer fills up, so we write it totally generally.
3120 When PIPELINING is off, each command written reports that it has flushed the
3123 sx
->pending_MAIL
= TRUE
; /* The block starts with MAIL */
3126 uschar
* s
= sx
->from_addr
;
3128 uschar
* errstr
= NULL
;
3130 /* If we must downconvert, do the from-address here. Remember we had to
3131 for the to-addresses (done below), and also (ugly) for re-doing when building
3132 the delivery log line. */
3134 if ( sx
->addrlist
->prop
.utf8_msg
3135 && (sx
->addrlist
->prop
.utf8_downcvt
|| !(sx
->peer_offered
& OPTION_UTF8
))
3138 if (s
= string_address_utf8_to_alabel(s
, &errstr
), errstr
)
3140 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, errstr
, DEFER
, FALSE
);
3144 setflag(sx
->addrlist
, af_utf8_downcvt
);
3148 rc
= smtp_write_command(sx
, pipelining_active
? SCMD_BUFFER
: SCMD_FLUSH
,
3149 "MAIL FROM:<%s>%s\r\n", s
, sx
->buffer
);
3152 mail_command
= string_copy(big_buffer
); /* Save for later error message */
3156 case -1: /* Transmission error */
3159 case +1: /* Cmd was sent */
3160 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
3161 (SOB sx
->conn_args
.ob
)->command_timeout
))
3163 if (errno
== 0 && sx
->buffer
[0] == '4')
3165 errno
= ERRNO_MAIL4XX
;
3166 sx
->addrlist
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
3170 sx
->pending_MAIL
= FALSE
;
3173 /* otherwise zero: command queued for pipeline */
3176 /* Pass over all the relevant recipient addresses for this host, which are the
3177 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3178 several before we have to read the responses for those seen so far. This
3179 checking is done by a subroutine because it also needs to be done at the end.
3180 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3181 the next one if not all are sent.
3183 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3184 last address because we want to abort if any recipients have any kind of
3185 problem, temporary or permanent. We know that all recipient addresses will have
3186 the PENDING_DEFER status, because only one attempt is ever made, and we know
3187 that max_rcpt will be large, so all addresses will be done at once.
3189 For verify we flush the pipeline after any (the only) rcpt address. */
3191 for (addr
= sx
->first_addr
, address_count
= 0;
3192 addr
&& address_count
< sx
->max_rcpt
;
3193 addr
= addr
->next
) if (addr
->transport_return
== PENDING_DEFER
)
3199 addr
->dsn_aware
= sx
->peer_offered
& OPTION_DSN
3200 ? dsn_support_yes
: dsn_support_no
;
3203 no_flush
= pipelining_active
&& !sx
->verify
3204 && (!mua_wrapper
|| addr
->next
&& address_count
< sx
->max_rcpt
);
3206 build_rcptcmd_options(sx
, addr
);
3208 /* Now send the RCPT command, and process outstanding responses when
3209 necessary. After a timeout on RCPT, we just end the function, leaving the
3210 yield as OK, because this error can often mean that there is a problem with
3211 just one address, so we don't want to delay the host. */
3213 rcpt_addr
= transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
);
3216 if ( testflag(sx
->addrlist
, af_utf8_downcvt
)
3217 && !(rcpt_addr
= string_address_utf8_to_alabel(rcpt_addr
, NULL
))
3220 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3221 errno
= ERRNO_EXPANDFAIL
;
3222 return -5; /*XXX too harsh? */
3226 count
= smtp_write_command(sx
, no_flush
? SCMD_BUFFER
: SCMD_FLUSH
,
3227 "RCPT TO:<%s>%s%s\r\n", rcpt_addr
, sx
->igquotstr
, sx
->buffer
);
3229 if (count
< 0) return -5;
3232 switch(sync_responses(sx
, count
, 0))
3234 case 3: sx
->ok
= TRUE
; /* 2xx & 5xx => OK & progress made */
3235 case 2: sx
->completed_addr
= TRUE
; /* 5xx (only) => progress made */
3238 case 1: sx
->ok
= TRUE
; /* 2xx (only) => OK, but if LMTP, */
3239 if (!sx
->lmtp
) /* can't tell about progress yet */
3240 sx
->completed_addr
= TRUE
;
3241 case 0: /* No 2xx or 5xx, but no probs */
3244 case -1: return -3; /* Timeout on RCPT */
3245 case -2: return -2; /* non-MAIL read i/o error */
3246 default: return -1; /* any MAIL error */
3248 #ifdef EXPERIMENTAL_PIPE_CONNECT
3249 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3250 case -5: return -1; /* TLS first-read error */
3253 sx
->pending_MAIL
= FALSE
; /* Dealt with MAIL */
3255 } /* Loop for next address */
3257 sx
->next_addr
= addr
;
3263 /*****************************************************
3264 * Proxy TLS connection for another transport process *
3265 ******************************************************/
3267 Close the unused end of the pipe, fork once more, then use the given buffer
3268 as a staging area, and select on both the given fd and the TLS'd client-fd for
3269 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3270 Do blocking full-size writes, and reads under a timeout. Once both input
3271 channels are closed, exit the process.
3275 buf space to use for buffering
3276 bufsiz size of buffer
3277 pfd pipe filedescriptor array; [0] is comms to proxied process
3278 timeout per-read timeout, seconds
3282 smtp_proxy_tls(void * ct_ctx
, uschar
* buf
, size_t bsize
, int * pfd
,
3286 int max_fd
= MAX(pfd
[0], tls_out
.active
.sock
) + 1;
3292 DEBUG(D_transport
) debug_printf("proxy-proc final-pid %d\n", rc
);
3293 _exit(rc
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
);
3296 if (f
.running_in_test_harness
) millisleep(100); /* let parent debug out */
3297 set_process_info("proxying TLS connection for continued transport");
3299 FD_SET(tls_out
.active
.sock
, &rfds
);
3300 FD_SET(pfd
[0], &rfds
);
3302 for (int fd_bits
= 3; fd_bits
; )
3304 time_t time_left
= timeout
;
3305 time_t time_start
= time(NULL
);
3311 struct timeval tv
= { time_left
, 0 };
3314 (SELECT_ARG2_TYPE
*)&rfds
, NULL
, (SELECT_ARG2_TYPE
*)&efds
, &tv
);
3316 if (rc
< 0 && errno
== EINTR
)
3317 if ((time_left
-= time(NULL
) - time_start
) > 0) continue;
3321 DEBUG(D_transport
) if (rc
== 0) debug_printf("%s: timed out\n", __FUNCTION__
);
3325 if (FD_ISSET(tls_out
.active
.sock
, &efds
) || FD_ISSET(pfd
[0], &efds
))
3327 DEBUG(D_transport
) debug_printf("select: exceptional cond on %s fd\n",
3328 FD_ISSET(pfd
[0], &efds
) ? "proxy" : "tls");
3332 while (rc
< 0 || !(FD_ISSET(tls_out
.active
.sock
, &rfds
) || FD_ISSET(pfd
[0], &rfds
)));
3334 /* handle inbound data */
3335 if (FD_ISSET(tls_out
.active
.sock
, &rfds
))
3336 if ((rc
= tls_read(ct_ctx
, buf
, bsize
)) <= 0)
3339 FD_CLR(tls_out
.active
.sock
, &rfds
);
3340 shutdown(pfd
[0], SHUT_WR
);
3345 for (int nbytes
= 0; rc
- nbytes
> 0; nbytes
+= i
)
3346 if ((i
= write(pfd
[0], buf
+ nbytes
, rc
- nbytes
)) < 0) goto done
;
3348 else if (fd_bits
& 1)
3349 FD_SET(tls_out
.active
.sock
, &rfds
);
3351 /* handle outbound data */
3352 if (FD_ISSET(pfd
[0], &rfds
))
3353 if ((rc
= read(pfd
[0], buf
, bsize
)) <= 0)
3356 tls_close(ct_ctx
, TLS_SHUTDOWN_NOWAIT
);
3361 for (int nbytes
= 0; rc
- nbytes
> 0; nbytes
+= i
)
3362 if ((i
= tls_write(ct_ctx
, buf
+ nbytes
, rc
- nbytes
, FALSE
)) < 0)
3365 else if (fd_bits
& 2)
3366 FD_SET(pfd
[0], &rfds
);
3370 if (f
.running_in_test_harness
) millisleep(100); /* let logging complete */
3371 exim_exit(0, US
"TLS proxy");
3376 /*************************************************
3377 * Deliver address list to given host *
3378 *************************************************/
3380 /* If continue_hostname is not null, we get here only when continuing to
3381 deliver down an existing channel. The channel was passed as the standard
3382 input. TLS is never active on a passed channel; the previous process always
3383 closes it down before passing the connection on.
3385 Otherwise, we have to make a connection to the remote host, and do the
3386 initial protocol exchange.
3388 When running as an MUA wrapper, if the sender or any recipient is rejected,
3389 temporarily or permanently, we force failure for all recipients.
3392 addrlist chain of potential addresses to deliver; only those whose
3393 transport_return field is set to PENDING_DEFER are currently
3394 being processed; others should be skipped - they have either
3395 been delivered to an earlier host or IP address, or been
3396 failed by one of them.
3397 host host to deliver to
3398 host_af AF_INET or AF_INET6
3399 defport default TCP/IP port to use if host does not specify, in host
3401 interface interface to bind to, or NULL
3402 tblock transport instance block
3403 message_defer set TRUE if yield is OK, but all addresses were deferred
3404 because of a non-recipient, non-host failure, that is, a
3405 4xx response to MAIL FROM, DATA, or ".". This is a defer
3406 that is specific to the message.
3407 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
3408 a second attempt after TLS initialization fails
3410 Returns: OK - the connection was made and the delivery attempted;
3411 the result for each address is in its data block.
3412 DEFER - the connection could not be made, or something failed
3413 while setting up the SMTP session, or there was a
3414 non-message-specific error, such as a timeout.
3415 ERROR - a filter command is specified for this transport,
3416 and there was a problem setting it up; OR helo_data
3417 or add_headers or authenticated_sender is specified
3418 for this transport, and the string failed to expand
3422 smtp_deliver(address_item
*addrlist
, host_item
*host
, int host_af
, int defport
,
3423 uschar
*interface
, transport_instance
*tblock
,
3424 BOOL
*message_defer
, BOOL suppress_tls
)
3426 smtp_transport_options_block
* ob
= SOB tblock
->options_block
;
3430 struct timeval start_delivery_time
;
3432 BOOL pass_message
= FALSE
;
3433 uschar
*message
= NULL
;
3434 uschar new_message_id
[MESSAGE_ID_LENGTH
+ 1];
3438 gettimeofday(&start_delivery_time
, NULL
);
3439 suppress_tls
= suppress_tls
; /* stop compiler warning when no TLS support */
3440 *message_defer
= FALSE
;
3442 sx
.addrlist
= addrlist
;
3443 sx
.conn_args
.host
= host
;
3444 sx
.conn_args
.host_af
= host_af
,
3446 sx
.conn_args
.interface
= interface
;
3447 sx
.helo_data
= NULL
;
3448 sx
.conn_args
.tblock
= tblock
;
3450 sx
.sync_addr
= sx
.first_addr
= addrlist
;
3452 /* Get the channel set up ready for a message (MAIL FROM being the next
3453 SMTP command to send */
3455 if ((rc
= smtp_setup_conn(&sx
, suppress_tls
)) != OK
)
3458 /* If there is a filter command specified for this transport, we can now
3459 set it up. This cannot be done until the identify of the host is known. */
3461 if (tblock
->filter_command
)
3463 transport_filter_timeout
= tblock
->filter_timeout
;
3465 /* On failure, copy the error to all addresses, abandon the SMTP call, and
3468 if (!transport_set_up_command(&transport_filter_argv
,
3469 tblock
->filter_command
, TRUE
, DEFER
, addrlist
,
3470 string_sprintf("%.50s transport", tblock
->name
), NULL
))
3472 set_errno_nohost(addrlist
->next
, addrlist
->basic_errno
, addrlist
->message
, DEFER
,
3478 if ( transport_filter_argv
3479 && *transport_filter_argv
3480 && **transport_filter_argv
3481 && sx
.peer_offered
& OPTION_CHUNKING
3484 sx
.peer_offered
&= ~OPTION_CHUNKING
;
3485 DEBUG(D_transport
) debug_printf("CHUNKING not usable due to transport filter\n");
3489 /* For messages that have more than the maximum number of envelope recipients,
3490 we want to send several transactions down the same SMTP connection. (See
3491 comments in deliver.c as to how this reconciles, heuristically, with
3492 remote_max_parallel.) This optimization was added to Exim after the following
3493 code was already working. The simplest way to put it in without disturbing the
3494 code was to use a goto to jump back to this point when there is another
3495 transaction to handle. */
3498 sx
.from_addr
= return_path
;
3499 sx
.sync_addr
= sx
.first_addr
;
3501 sx
.send_rset
= TRUE
;
3502 sx
.completed_addr
= FALSE
;
3505 /* If we are a continued-connection-after-verify the MAIL and RCPT
3506 commands were already sent; do not re-send but do mark the addrs as
3507 having been accepted up to RCPT stage. A traditional cont-conn
3508 always has a sequence number greater than one. */
3510 if (continue_hostname
&& continue_sequence
== 1)
3512 sx
.peer_offered
= smtp_peer_options
;
3513 sx
.pending_MAIL
= FALSE
;
3515 sx
.next_addr
= NULL
;
3517 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
3518 addr
->transport_return
= PENDING_OK
;
3522 /* Initiate a message transfer. */
3524 switch(smtp_write_mail_and_rcpt_cmds(&sx
, &yield
))
3527 case -1: case -2: goto RESPONSE_FAILED
;
3528 case -3: goto END_OFF
;
3529 case -4: goto SEND_QUIT
;
3530 default: goto SEND_FAILED
;
3533 /* If we are an MUA wrapper, abort if any RCPTs were rejected, either
3534 permanently or temporarily. We should have flushed and synced after the last
3542 for (a
= sx
.first_addr
, cnt
= 0; a
&& cnt
< sx
.max_rcpt
; a
= a
->next
, cnt
++)
3543 if (a
->transport_return
!= PENDING_OK
)
3545 /*XXX could we find a better errno than 0 here? */
3546 set_errno_nohost(addrlist
, 0, a
->message
, FAIL
,
3547 testflag(a
, af_pass_message
));
3554 /* If ok is TRUE, we know we have got at least one good recipient, and must now
3555 send DATA, but if it is FALSE (in the normal, non-wrapper case), we may still
3556 have a good recipient buffered up if we are pipelining. We don't want to waste
3557 time sending DATA needlessly, so we only send it if either ok is TRUE or if we
3558 are pipelining. The responses are all handled by sync_responses().
3559 If using CHUNKING, do not send a BDAT until we know how big a chunk we want
3562 if ( !(sx
.peer_offered
& OPTION_CHUNKING
)
3563 && (sx
.ok
|| (pipelining_active
&& !mua_wrapper
)))
3565 int count
= smtp_write_command(&sx
, SCMD_FLUSH
, "DATA\r\n");
3567 if (count
< 0) goto SEND_FAILED
;
3568 switch(sync_responses(&sx
, count
, sx
.ok
? +1 : -1))
3570 case 3: sx
.ok
= TRUE
; /* 2xx & 5xx => OK & progress made */
3571 case 2: sx
.completed_addr
= TRUE
; /* 5xx (only) => progress made */
3574 case 1: sx
.ok
= TRUE
; /* 2xx (only) => OK, but if LMTP, */
3575 if (!sx
.lmtp
) sx
.completed_addr
= TRUE
; /* can't tell about progress yet */
3576 case 0: break; /* No 2xx or 5xx, but no probs */
3578 case -1: goto END_OFF
; /* Timeout on RCPT */
3580 #ifdef EXPERIMENTAL_PIPE_CONNECT
3581 case -5: /* TLS first-read error */
3582 case -4: HDEBUG(D_transport
)
3583 debug_printf("failed reaping pipelined cmd responses\n");
3585 default: goto RESPONSE_FAILED
; /* I/O error, or any MAIL/DATA error */
3587 pipelining_active
= FALSE
;
3588 data_command
= string_copy(big_buffer
); /* Save for later error message */
3591 /* If there were no good recipients (but otherwise there have been no
3592 problems), just set ok TRUE, since we have handled address-specific errors
3593 already. Otherwise, it's OK to send the message. Use the check/escape mechanism
3594 for handling the SMTP dot-handling protocol, flagging to apply to headers as
3595 well as body. Set the appropriate timeout value to be used for each chunk.
3596 (Haven't been able to make it work using select() for writing yet.) */
3598 if (!(sx
.peer_offered
& OPTION_CHUNKING
) && !sx
.ok
)
3600 /* Save the first address of the next batch. */
3601 sx
.first_addr
= sx
.next_addr
;
3607 transport_ctx tctx
= {
3608 .u
= {.fd
= sx
.cctx
.sock
}, /*XXX will this need TLS info? */
3611 .check_string
= US
".",
3612 .escape_string
= US
"..", /* Escaping strings */
3614 topt_use_crlf
| topt_escape_headers
3615 | (tblock
->body_only
? topt_no_headers
: 0)
3616 | (tblock
->headers_only
? topt_no_body
: 0)
3617 | (tblock
->return_path_add
? topt_add_return_path
: 0)
3618 | (tblock
->delivery_date_add
? topt_add_delivery_date
: 0)
3619 | (tblock
->envelope_to_add
? topt_add_envelope_to
: 0)
3622 /* If using CHUNKING we need a callback from the generic transport
3623 support to us, for the sending of BDAT smtp commands and the reaping
3624 of responses. The callback needs a whole bunch of state so set up
3625 a transport-context structure to be passed around. */
3627 if (sx
.peer_offered
& OPTION_CHUNKING
)
3629 tctx
.check_string
= tctx
.escape_string
= NULL
;
3630 tctx
.options
|= topt_use_bdat
;
3631 tctx
.chunk_cb
= smtp_chunk_cmd_callback
;
3632 sx
.pending_BDAT
= FALSE
;
3633 sx
.good_RCPT
= sx
.ok
;
3635 tctx
.smtp_context
= &sx
;
3638 tctx
.options
|= topt_end_dot
;
3640 /* Save the first address of the next batch. */
3641 sx
.first_addr
= sx
.next_addr
;
3643 /* Responses from CHUNKING commands go in buffer. Otherwise,
3644 there has not been a response. */
3648 sigalrm_seen
= FALSE
;
3649 transport_write_timeout
= ob
->data_timeout
;
3650 smtp_command
= US
"sending data block"; /* For error messages */
3651 DEBUG(D_transport
|D_v
)
3652 if (sx
.peer_offered
& OPTION_CHUNKING
)
3653 debug_printf(" will write message using CHUNKING\n");
3655 debug_printf(" SMTP>> writing message and terminating \".\"\n");
3656 transport_count
= 0;
3658 #ifndef DISABLE_DKIM
3659 dkim_exim_sign_init();
3660 # ifdef EXPERIMENTAL_ARC
3662 uschar
* s
= ob
->arc_sign
;
3665 if (!(ob
->dkim
.arc_signspec
= s
= expand_string(s
)))
3667 if (!f
.expand_string_forcedfail
)
3669 message
= US
"failed to expand arc_sign";
3676 /* Ask dkim code to hash the body for ARC */
3677 (void) arc_ams_setup_sign_bodyhash();
3678 ob
->dkim
.force_bodyhash
= TRUE
;
3683 sx
.ok
= dkim_transport_write_message(&tctx
, &ob
->dkim
, CUSS
&message
);
3685 sx
.ok
= transport_write_message(&tctx
, 0);
3688 /* transport_write_message() uses write() because it is called from other
3689 places to write to non-sockets. This means that under some OS (e.g. Solaris)
3690 it can exit with "Broken pipe" as its error. This really means that the
3691 socket got closed at the far end. */
3693 transport_write_timeout
= 0; /* for subsequent transports */
3695 /* Failure can either be some kind of I/O disaster (including timeout),
3696 or the failure of a transport filter or the expansion of added headers.
3697 Or, when CHUNKING, it can be a protocol-detected failure. */
3700 if (message
) goto SEND_FAILED
;
3701 else goto RESPONSE_FAILED
;
3703 /* We used to send the terminating "." explicitly here, but because of
3704 buffering effects at both ends of TCP/IP connections, you don't gain
3705 anything by keeping it separate, so it might as well go in the final
3706 data buffer for efficiency. This is now done by setting the topt_end_dot
3709 smtp_command
= US
"end of data";
3711 if (sx
.peer_offered
& OPTION_CHUNKING
&& sx
.cmd_count
> 1)
3713 /* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
3714 switch(sync_responses(&sx
, sx
.cmd_count
-1, 0))
3716 case 3: sx
.ok
= TRUE
; /* 2xx & 5xx => OK & progress made */
3717 case 2: sx
.completed_addr
= TRUE
; /* 5xx (only) => progress made */
3720 case 1: sx
.ok
= TRUE
; /* 2xx (only) => OK, but if LMTP, */
3721 if (!sx
.lmtp
) sx
.completed_addr
= TRUE
; /* can't tell about progress yet */
3722 case 0: break; /* No 2xx or 5xx, but no probs */
3724 case -1: goto END_OFF
; /* Timeout on RCPT */
3726 #ifdef EXPERIMENTAL_PIPE_CONNECT
3727 case -5: /* TLS first-read error */
3728 case -4: HDEBUG(D_transport
)
3729 debug_printf("failed reaping pipelined cmd responses\n");
3731 default: goto RESPONSE_FAILED
; /* I/O error, or any MAIL/DATA error */
3735 #ifndef DISABLE_PRDR
3736 /* For PRDR we optionally get a partial-responses warning followed by the
3737 individual responses, before going on with the overall response. If we don't
3738 get the warning then deal with per non-PRDR. */
3742 sx
.ok
= smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
), '3', ob
->final_timeout
);
3743 if (!sx
.ok
&& errno
== 0) switch(sx
.buffer
[0])
3745 case '2': sx
.prdr_active
= FALSE
;
3748 case '4': errno
= ERRNO_DATA4XX
;
3749 addrlist
->more_errno
|=
3750 ((sx
.buffer
[1] - '0')*10 + sx
.buffer
[2] - '0') << 8;
3757 /* For non-PRDR SMTP, we now read a single response that applies to the
3758 whole message. If it is OK, then all the addresses have been delivered. */
3762 sx
.ok
= smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
), '2',
3764 if (!sx
.ok
&& errno
== 0 && sx
.buffer
[0] == '4')
3766 errno
= ERRNO_DATA4XX
;
3767 addrlist
->more_errno
|= ((sx
.buffer
[1] - '0')*10 + sx
.buffer
[2] - '0') << 8;
3771 /* For LMTP, we get back a response for every RCPT command that we sent;
3772 some may be accepted and some rejected. For those that get a response, their
3773 status is fixed; any that are accepted have been handed over, even if later
3774 responses crash - at least, that's how I read RFC 2033.
3776 If all went well, mark the recipient addresses as completed, record which
3777 host/IPaddress they were delivered to, and cut out RSET when sending another
3778 message down the same channel. Write the completed addresses to the journal
3779 now so that they are recorded in case there is a crash of hardware or
3780 software before the spool gets updated. Also record the final SMTP
3781 confirmation if needed (for SMTP only). */
3786 struct timeval delivery_time
;
3788 uschar
* conf
= NULL
;
3790 timesince(&delivery_time
, &start_delivery_time
);
3791 sx
.send_rset
= FALSE
;
3792 pipelining_active
= FALSE
;
3794 /* Set up confirmation if needed - applies only to SMTP */
3797 #ifdef DISABLE_EVENT
3798 LOGGING(smtp_confirmation
) &&
3803 const uschar
*s
= string_printing(sx
.buffer
);
3804 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3805 conf
= (s
== sx
.buffer
)? US
string_copy(s
) : US s
;
3808 /* Process all transported addresses - for LMTP or PRDR, read a status for
3811 for (address_item
* addr
= addrlist
; addr
!= sx
.first_addr
; addr
= addr
->next
)
3813 if (addr
->transport_return
!= PENDING_OK
) continue;
3815 /* LMTP - if the response fails badly (e.g. timeout), use it for all the
3816 remaining addresses. Otherwise, it's a return code for just the one
3817 address. For temporary errors, add a retry item for the address so that
3818 it doesn't get tried again too soon. */
3820 #ifndef DISABLE_PRDR
3821 if (sx
.lmtp
|| sx
.prdr_active
)
3826 if (!smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
), '2',
3829 if (errno
!= 0 || sx
.buffer
[0] == 0) goto RESPONSE_FAILED
;
3830 addr
->message
= string_sprintf(
3831 #ifndef DISABLE_PRDR
3832 "%s error after %s: %s", sx
.prdr_active
? "PRDR":"LMTP",
3834 "LMTP error after %s: %s",
3836 data_command
, string_printing(sx
.buffer
));
3837 setflag(addr
, af_pass_message
); /* Allow message to go to user */
3838 if (sx
.buffer
[0] == '5')
3839 addr
->transport_return
= FAIL
;
3842 errno
= ERRNO_DATA4XX
;
3843 addr
->more_errno
|= ((sx
.buffer
[1] - '0')*10 + sx
.buffer
[2] - '0') << 8;
3844 addr
->transport_return
= DEFER
;
3845 #ifndef DISABLE_PRDR
3846 if (!sx
.prdr_active
)
3848 retry_add_item(addr
, addr
->address_retry_key
, 0);
3852 sx
.completed_addr
= TRUE
; /* NOW we can set this flag */
3853 if (LOGGING(smtp_confirmation
))
3855 const uschar
*s
= string_printing(sx
.buffer
);
3856 /* deconst cast ok here as string_printing was checked to have alloc'n'copied */
3857 conf
= (s
== sx
.buffer
) ? US
string_copy(s
) : US s
;
3861 /* SMTP, or success return from LMTP for this address. Pass back the
3862 actual host that was used. */
3864 addr
->transport_return
= OK
;
3865 addr
->more_errno
= delivery_time
.tv_sec
;
3866 addr
->delivery_usec
= delivery_time
.tv_usec
;
3867 addr
->host_used
= host
;
3868 addr
->special_action
= flag
;
3869 addr
->message
= conf
;
3871 if (tcp_out_fastopen
)
3873 setflag(addr
, af_tcp_fastopen_conn
);
3874 if (tcp_out_fastopen
>= TFO_USED_NODATA
) setflag(addr
, af_tcp_fastopen
);
3875 if (tcp_out_fastopen
>= TFO_USED_DATA
) setflag(addr
, af_tcp_fastopen_data
);
3877 if (sx
.pipelining_used
) setflag(addr
, af_pipelining
);
3878 #ifdef EXPERIMENTAL_PIPE_CONNECT
3879 if (sx
.early_pipe_active
) setflag(addr
, af_early_pipe
);
3881 #ifndef DISABLE_PRDR
3882 if (sx
.prdr_active
) setflag(addr
, af_prdr_used
);
3884 if (sx
.peer_offered
& OPTION_CHUNKING
) setflag(addr
, af_chunking_used
);
3887 #ifndef DISABLE_PRDR
3888 if (!sx
.prdr_active
)
3891 /* Update the journal. For homonymic addresses, use the base address plus
3892 the transport name. See lots of comments in deliver.c about the reasons
3893 for the complications when homonyms are involved. Just carry on after
3894 write error, as it may prove possible to update the spool file later. */
3896 if (testflag(addr
, af_homonym
))
3897 sprintf(CS sx
.buffer
, "%.500s/%s\n", addr
->unique
+ 3, tblock
->name
);
3899 sprintf(CS sx
.buffer
, "%.500s\n", addr
->unique
);
3901 DEBUG(D_deliver
) debug_printf("S:journalling %s\n", sx
.buffer
);
3902 len
= Ustrlen(CS sx
.buffer
);
3903 if (write(journal_fd
, sx
.buffer
, len
) != len
)
3904 log_write(0, LOG_MAIN
|LOG_PANIC
, "failed to write journal for "
3905 "%s: %s", sx
.buffer
, strerror(errno
));
3909 #ifndef DISABLE_PRDR
3912 const uschar
* overall_message
;
3914 /* PRDR - get the final, overall response. For any non-success
3915 upgrade all the address statuses. */
3917 sx
.ok
= smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
), '2',
3921 if(errno
== 0 && sx
.buffer
[0] == '4')
3923 errno
= ERRNO_DATA4XX
;
3924 addrlist
->more_errno
|= ((sx
.buffer
[1] - '0')*10 + sx
.buffer
[2] - '0') << 8;
3926 for (address_item
* addr
= addrlist
; addr
!= sx
.first_addr
; addr
= addr
->next
)
3927 if (sx
.buffer
[0] == '5' || addr
->transport_return
== OK
)
3928 addr
->transport_return
= PENDING_OK
; /* allow set_errno action */
3929 goto RESPONSE_FAILED
;
3932 /* Append the overall response to the individual PRDR response for logging
3933 and update the journal, or setup retry. */
3935 overall_message
= string_printing(sx
.buffer
);
3936 for (address_item
* addr
= addrlist
; addr
!= sx
.first_addr
; addr
= addr
->next
)
3937 if (addr
->transport_return
== OK
)
3938 addr
->message
= string_sprintf("%s\\n%s", addr
->message
, overall_message
);
3940 for (address_item
* addr
= addrlist
; addr
!= sx
.first_addr
; addr
= addr
->next
)
3941 if (addr
->transport_return
== OK
)
3943 if (testflag(addr
, af_homonym
))
3944 sprintf(CS sx
.buffer
, "%.500s/%s\n", addr
->unique
+ 3, tblock
->name
);
3946 sprintf(CS sx
.buffer
, "%.500s\n", addr
->unique
);
3948 DEBUG(D_deliver
) debug_printf("journalling(PRDR) %s\n", sx
.buffer
);
3949 len
= Ustrlen(CS sx
.buffer
);
3950 if (write(journal_fd
, sx
.buffer
, len
) != len
)
3951 log_write(0, LOG_MAIN
|LOG_PANIC
, "failed to write journal for "
3952 "%s: %s", sx
.buffer
, strerror(errno
));
3954 else if (addr
->transport_return
== DEFER
)
3955 retry_add_item(addr
, addr
->address_retry_key
, -2);
3959 /* Ensure the journal file is pushed out to disk. */
3961 if (EXIMfsync(journal_fd
) < 0)
3962 log_write(0, LOG_MAIN
|LOG_PANIC
, "failed to fsync journal: %s",
3968 /* Handle general (not specific to one address) failures here. The value of ok
3969 is used to skip over this code on the falling through case. A timeout causes a
3970 deferral. Other errors may defer or fail according to the response code, and
3971 may set up a special errno value, e.g. after connection chopped, which is
3972 assumed if errno == 0 and there is no text in the buffer. If control reaches
3973 here during the setting up phase (i.e. before MAIL FROM) then always defer, as
3974 the problem is not related to this specific message. */
3979 uschar
* set_message
;
3985 sx
.send_quit
= check_response(host
, &save_errno
, addrlist
->more_errno
,
3986 sx
.buffer
, &code
, &message
, &pass_message
);
3994 message
= string_sprintf("send() to %s [%s] failed: %s",
3995 host
->name
, host
->address
, message
? message
: US
strerror(save_errno
));
3996 sx
.send_quit
= FALSE
;
4004 sx
.ok
= FALSE
; /* For when reached by GOTO */
4005 set_message
= message
;
4007 /* We want to handle timeouts after MAIL or "." and loss of connection after
4008 "." specially. They can indicate a problem with the sender address or with
4009 the contents of the message rather than a real error on the connection. These
4010 cases are treated in the same way as a 4xx response. This next bit of code
4011 does the classification. */
4018 message_error
= TRUE
;
4022 message_error
= Ustrncmp(smtp_command
,"MAIL",4) == 0 ||
4023 Ustrncmp(smtp_command
,"end ",4) == 0;
4026 case ERRNO_SMTPCLOSED
:
4027 message_error
= Ustrncmp(smtp_command
,"end ",4) == 0;
4031 message_error
= FALSE
;
4035 /* Handle the cases that are treated as message errors. These are:
4037 (a) negative response or timeout after MAIL
4038 (b) negative response after DATA
4039 (c) negative response or timeout or dropped connection after "."
4040 (d) utf8 support required and not offered
4042 It won't be a negative response or timeout after RCPT, as that is dealt
4043 with separately above. The action in all cases is to set an appropriate
4044 error code for all the addresses, but to leave yield set to OK because the
4045 host itself has not failed. Of course, it might in practice have failed
4046 when we've had a timeout, but if so, we'll discover that at the next
4047 delivery attempt. For a temporary error, set the message_defer flag, and
4048 write to the logs for information if this is not the last host. The error
4049 for the last host will be logged as part of the address's log line. */
4053 if (mua_wrapper
) code
= '5'; /* Force hard failure in wrapper mode */
4055 /* If there's an errno, the message contains just the identity of
4060 else /* Anything other than 5 is treated as temporary */
4064 message
= US
string_sprintf("%s: %s", message
, strerror(save_errno
));
4066 write_logs(host
, message
, sx
.first_addr
? sx
.first_addr
->basic_errno
: 0);
4068 *message_defer
= TRUE
;
4072 /* Otherwise, we have an I/O error or a timeout other than after MAIL or
4073 ".", or some other transportation error. We defer all addresses and yield
4074 DEFER, except for the case of failed add_headers expansion, or a transport
4075 filter failure, when the yield should be ERROR, to stop it trying other
4080 #ifdef EXPERIMENTAL_PIPE_CONNECT
4081 /* If we were early-pipelinng and the actual EHLO response did not match
4082 the cached value we assumed, we could have detected it and passed a
4083 custom errno through to here. It would be nice to RSET and retry right
4084 away, but to reliably do that we eould need an extra synch point before
4085 we committed to data and that would discard half the gained roundrips.
4086 Or we could summarily drop the TCP connection. but that is also ugly.
4087 Instead, we ignore the possibility (having freshened the cache) and rely
4088 on the server telling us with a nonmessage error if we have tried to
4089 do something it no longer supports. */
4092 yield
= (save_errno
== ERRNO_CHHEADER_FAIL
||
4093 save_errno
== ERRNO_FILTER_FAIL
) ? ERROR
: DEFER
;
4097 set_errno(addrlist
, save_errno
, set_message
, set_rc
, pass_message
, host
4098 #ifdef EXPERIMENTAL_DSN_INFO
4099 , sx
.smtp_greeting
, sx
.helo_response
4105 /* If all has gone well, send_quit will be set TRUE, implying we can end the
4106 SMTP session tidily. However, if there were too many addresses to send in one
4107 message (indicated by first_addr being non-NULL) we want to carry on with the
4108 rest of them. Also, it is desirable to send more than one message down the SMTP
4109 connection if there are several waiting, provided we haven't already sent so
4110 many as to hit the configured limit. The function transport_check_waiting looks
4111 for a waiting message and returns its id. Then transport_pass_socket tries to
4112 set up a continued delivery by passing the socket on to another process. The
4113 variable send_rset is FALSE if a message has just been successfully transferred.
4115 If we are already sending down a continued channel, there may be further
4116 addresses not yet delivered that are aimed at the same host, but which have not
4117 been passed in this run of the transport. In this case, continue_more will be
4118 true, and all we should do is send RSET if necessary, and return, leaving the
4121 However, if no address was disposed of, i.e. all addresses got 4xx errors, we
4122 do not want to continue with other messages down the same channel, because that
4123 can lead to looping between two or more messages, all with the same,
4124 temporarily failing address(es). [The retry information isn't updated yet, so
4125 new processes keep on trying.] We probably also don't want to try more of this
4126 message's addresses either.
4128 If we have started a TLS session, we have to end it before passing the
4129 connection to a new process. However, not all servers can handle this (Exim
4130 can), so we do not pass such a connection on if the host matches
4131 hosts_nopass_tls. */
4134 debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
4135 "yield=%d first_address is %sNULL\n", sx
.ok
, sx
.send_quit
,
4136 sx
.send_rset
, f
.continue_more
, yield
, sx
.first_addr
? "not " : "");
4138 if (sx
.completed_addr
&& sx
.ok
&& sx
.send_quit
)
4141 smtp_compare_t t_compare
;
4143 t_compare
.tblock
= tblock
;
4144 t_compare
.current_sender_address
= sender_address
;
4146 if ( sx
.first_addr
!= NULL
4150 ( tls_out
.active
.sock
< 0 && !continue_proxy_cipher
4151 || verify_check_given_host(CUSS
&ob
->hosts_nopass_tls
, host
) != OK
4155 transport_check_waiting(tblock
->name
, host
->name
,
4156 tblock
->connection_max_messages
, new_message_id
, &more
,
4157 (oicf
)smtp_are_same_identities
, (void*)&t_compare
)
4164 if (! (sx
.ok
= smtp_write_command(&sx
, SCMD_FLUSH
, "RSET\r\n") >= 0))
4166 msg
= US
string_sprintf("send() to %s [%s] failed: %s", host
->name
,
4167 host
->address
, strerror(errno
));
4168 sx
.send_quit
= FALSE
;
4170 else if (! (sx
.ok
= smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
),
4171 '2', ob
->command_timeout
)))
4174 sx
.send_quit
= check_response(host
, &errno
, 0, sx
.buffer
, &code
, &msg
,
4178 DEBUG(D_transport
) debug_printf("H=%s [%s] %s\n",
4179 host
->name
, host
->address
, msg
);
4183 /* Either RSET was not needed, or it succeeded */
4190 int socket_fd
= sx
.cctx
.sock
;
4193 if (sx
.first_addr
!= NULL
) /* More addresses still to be sent */
4194 { /* in this run of the transport */
4195 continue_sequence
++; /* Causes * in logging */
4199 /* Unless caller said it already has more messages listed for this host,
4200 pass the connection on to a new Exim process (below, the call to
4201 transport_pass_socket). If the caller has more ready, just return with
4202 the connection still open. */
4205 if (tls_out
.active
.sock
>= 0)
4206 if ( f
.continue_more
4207 || verify_check_given_host(CUSS
&ob
->hosts_noproxy_tls
, host
) == OK
)
4209 /* Before passing the socket on, or returning to caller with it still
4210 open, we must shut down TLS. Not all MTAs allow for the continuation
4211 of the SMTP session when TLS is shut down. We test for this by sending
4212 a new EHLO. If we don't get a good response, we don't attempt to pass
4215 tls_close(sx
.cctx
.tls_ctx
, TLS_SHUTDOWN_WAIT
);
4216 sx
.cctx
.tls_ctx
= NULL
;
4217 smtp_peer_options
= smtp_peer_options_wrap
;
4219 && smtp_write_command(&sx
, SCMD_FLUSH
, "EHLO %s\r\n", sx
.helo_data
)
4221 && smtp_read_response(&sx
, sx
.buffer
, sizeof(sx
.buffer
),
4222 '2', ob
->command_timeout
);
4224 if (sx
.ok
&& f
.continue_more
)
4225 return yield
; /* More addresses for another run */
4229 /* Set up a pipe for proxying TLS for the new transport process */
4231 smtp_peer_options
|= OPTION_TLS
;
4232 if (sx
.ok
= (socketpair(AF_UNIX
, SOCK_STREAM
, 0, pfd
) == 0))
4235 set_errno(sx
.first_addr
, errno
, US
"internal allocation problem",
4237 # ifdef EXPERIMENTAL_DSN_INFO
4238 , sx
.smtp_greeting
, sx
.helo_response
4244 if (f
.continue_more
)
4245 return yield
; /* More addresses for another run */
4247 /* If the socket is successfully passed, we mustn't send QUIT (or
4248 indeed anything!) from here. */
4250 /*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
4251 propagate it from the initial
4253 if (sx
.ok
&& transport_pass_socket(tblock
->name
, host
->name
,
4254 host
->address
, new_message_id
, socket_fd
))
4256 sx
.send_quit
= FALSE
;
4258 /* We have passed the client socket to a fresh transport process.
4259 If TLS is still active, we need to proxy it for the transport we
4260 just passed the baton to. Fork a child to to do it, and return to
4261 get logging done asap. Which way to place the work makes assumptions
4262 about post-fork prioritisation which may not hold on all platforms. */
4264 if (tls_out
.active
.sock
>= 0)
4267 if (pid
== 0) /* child; fork again to disconnect totally */
4269 if (f
.running_in_test_harness
) millisleep(100); /* let parent debug out */
4270 /* does not return */
4271 smtp_proxy_tls(sx
.cctx
.tls_ctx
, sx
.buffer
, sizeof(sx
.buffer
), pfd
,
4272 ob
->command_timeout
);
4275 if (pid
> 0) /* parent */
4277 DEBUG(D_transport
) debug_printf("proxy-proc inter-pid %d\n", pid
);
4279 /* tidy the inter-proc to disconn the proxy proc */
4280 waitpid(pid
, NULL
, 0);
4281 tls_close(sx
.cctx
.tls_ctx
, TLS_NO_SHUTDOWN
);
4282 sx
.cctx
.tls_ctx
= NULL
;
4283 (void)close(sx
.cctx
.sock
);
4285 continue_transport
= NULL
;
4286 continue_hostname
= NULL
;
4289 log_write(0, LOG_PANIC_DIE
, "fork failed");
4295 /* If RSET failed and there are addresses left, they get deferred. */
4297 set_errno(sx
.first_addr
, errno
, msg
, DEFER
, FALSE
, host
4298 #ifdef EXPERIMENTAL_DSN_INFO
4299 , sx
.smtp_greeting
, sx
.helo_response
4305 /* End off tidily with QUIT unless the connection has died or the socket has
4306 been passed to another process. There has been discussion on the net about what
4307 to do after sending QUIT. The wording of the RFC suggests that it is necessary
4308 to wait for a response, but on the other hand, there isn't anything one can do
4309 with an error response, other than log it. Exim used to do that. However,
4310 further discussion suggested that it is positively advantageous not to wait for
4311 the response, but to close the session immediately. This is supposed to move
4312 the TCP/IP TIME_WAIT state from the server to the client, thereby removing some
4313 load from the server. (Hosts that are both servers and clients may not see much
4314 difference, of course.) Further discussion indicated that this was safe to do
4315 on Unix systems which have decent implementations of TCP/IP that leave the
4316 connection around for a while (TIME_WAIT) after the application has gone away.
4317 This enables the response sent by the server to be properly ACKed rather than
4318 timed out, as can happen on broken TCP/IP implementations on other OS.
4320 This change is being made on 31-Jul-98. After over a year of trouble-free
4321 operation, the old commented-out code was removed on 17-Sep-99. */
4325 (void) setsockopt(sx
.cctx
.sock
, IPPROTO_TCP
, TCP_CORK
, US
&on
, sizeof(on
));
4327 if (sx
.send_quit
) (void)smtp_write_command(&sx
, SCMD_FLUSH
, "QUIT\r\n");
4332 tls_close(sx
.cctx
.tls_ctx
, TLS_SHUTDOWN_NOWAIT
);
4333 sx
.cctx
.tls_ctx
= NULL
;
4336 /* Close the socket, and return the appropriate value, first setting
4337 works because the NULL setting is passed back to the calling process, and
4338 remote_max_parallel is forced to 1 when delivering over an existing connection,
4340 If all went well and continue_more is set, we shouldn't actually get here if
4341 there are further addresses, as the return above will be taken. However,
4342 writing RSET might have failed, or there may be other addresses whose hosts are
4343 specified in the transports, and therefore not visible at top level, in which
4344 case continue_more won't get set. */
4346 HDEBUG(D_transport
|D_acl
|D_v
) debug_printf_indent(" SMTP(close)>>\n");
4349 shutdown(sx
.cctx
.sock
, SHUT_WR
);
4350 millisleep(f
.running_in_test_harness
? 200 : 20);
4351 if (fcntl(sx
.cctx
.sock
, F_SETFL
, O_NONBLOCK
) == 0)
4352 for (int i
= 16; read(sx
.cctx
.sock
, sx
.inbuffer
, sizeof(sx
.inbuffer
)) > 0 && i
> 0;)
4353 i
--; /* drain socket */
4355 (void)close(sx
.cctx
.sock
);
4357 #ifndef DISABLE_EVENT
4358 (void) event_raise(tblock
->event_action
, US
"tcp:close", NULL
);
4361 continue_transport
= NULL
;
4362 continue_hostname
= NULL
;
4369 /*************************************************
4370 * Closedown entry point *
4371 *************************************************/
4373 /* This function is called when exim is passed an open smtp channel
4374 from another incarnation, but the message which it has been asked
4375 to deliver no longer exists. The channel is on stdin.
4377 We might do fancy things like looking for another message to send down
4378 the channel, but if the one we sought has gone, it has probably been
4379 delivered by some other process that itself will seek further messages,
4380 so just close down our connection.
4382 Argument: pointer to the transport instance block
4387 smtp_transport_closedown(transport_instance
*tblock
)
4389 smtp_transport_options_block
* ob
= SOB tblock
->options_block
;
4390 client_conn_ctx cctx
;
4393 uschar inbuffer
[4096];
4394 uschar outbuffer
[16];
4396 /*XXX really we need an active-smtp-client ctx, rather than assuming stdout */
4397 cctx
.sock
= fileno(stdin
);
4398 cctx
.tls_ctx
= cctx
.sock
== tls_out
.active
.sock
? tls_out
.active
.tls_ctx
: NULL
;
4400 sx
.inblock
.cctx
= &cctx
;
4401 sx
.inblock
.buffer
= inbuffer
;
4402 sx
.inblock
.buffersize
= sizeof(inbuffer
);
4403 sx
.inblock
.ptr
= inbuffer
;
4404 sx
.inblock
.ptrend
= inbuffer
;
4406 sx
.outblock
.cctx
= &cctx
;
4407 sx
.outblock
.buffersize
= sizeof(outbuffer
);
4408 sx
.outblock
.buffer
= outbuffer
;
4409 sx
.outblock
.ptr
= outbuffer
;
4410 sx
.outblock
.cmd_count
= 0;
4411 sx
.outblock
.authenticating
= FALSE
;
4413 (void)smtp_write_command(&sx
, SCMD_FLUSH
, "QUIT\r\n");
4414 (void)smtp_read_response(&sx
, buffer
, sizeof(buffer
), '2', ob
->command_timeout
);
4415 (void)close(cctx
.sock
);
4420 /*************************************************
4421 * Prepare addresses for delivery *
4422 *************************************************/
4424 /* This function is called to flush out error settings from previous delivery
4425 attempts to other hosts. It also records whether we got here via an MX record
4426 or not in the more_errno field of the address. We are interested only in
4427 addresses that are still marked DEFER - others may have got delivered to a
4428 previously considered IP address. Set their status to PENDING_DEFER to indicate
4429 which ones are relevant this time.
4432 addrlist the list of addresses
4433 host the host we are delivering to
4435 Returns: the first address for this delivery
4438 static address_item
*
4439 prepare_addresses(address_item
*addrlist
, host_item
*host
)
4441 address_item
*first_addr
= NULL
;
4442 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
4443 if (addr
->transport_return
== DEFER
)
4445 if (!first_addr
) first_addr
= addr
;
4446 addr
->transport_return
= PENDING_DEFER
;
4447 addr
->basic_errno
= 0;
4448 addr
->more_errno
= (host
->mx
>= 0)? 'M' : 'A';
4449 addr
->message
= NULL
;
4451 addr
->cipher
= NULL
;
4452 addr
->ourcert
= NULL
;
4453 addr
->peercert
= NULL
;
4454 addr
->peerdn
= NULL
;
4455 addr
->ocsp
= OCSP_NOT_REQ
;
4457 #ifdef EXPERIMENTAL_DSN_INFO
4458 addr
->smtp_greeting
= NULL
;
4459 addr
->helo_response
= NULL
;
4467 /*************************************************
4468 * Main entry point *
4469 *************************************************/
4471 /* See local README for interface details. As this is a remote transport, it is
4472 given a chain of addresses to be delivered in one connection, if possible. It
4473 always returns TRUE, indicating that each address has its own independent
4474 status set, except if there is a setting up problem, in which case it returns
4478 smtp_transport_entry(
4479 transport_instance
*tblock
, /* data for this instantiation */
4480 address_item
*addrlist
) /* addresses we are working on */
4483 int hosts_defer
= 0;
4485 int hosts_looked_up
= 0;
4486 int hosts_retry
= 0;
4487 int hosts_serial
= 0;
4488 int hosts_total
= 0;
4489 int total_hosts_tried
= 0;
4490 BOOL expired
= TRUE
;
4491 uschar
*expanded_hosts
= NULL
;
4493 uschar
*tid
= string_sprintf("%s transport", tblock
->name
);
4494 smtp_transport_options_block
*ob
= SOB tblock
->options_block
;
4495 host_item
*hostlist
= addrlist
->host_list
;
4496 host_item
*host
= NULL
;
4500 debug_printf("%s transport entered\n", tblock
->name
);
4501 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
4502 debug_printf(" %s\n", addr
->address
);
4505 debug_printf("hostlist:\n");
4506 for (host_item
* host
= hostlist
; host
; host
= host
->next
)
4507 debug_printf(" '%s' IP %s port %d\n", host
->name
, host
->address
, host
->port
);
4509 if (continue_hostname
)
4510 debug_printf("already connected to %s [%s] (on fd %d)\n",
4511 continue_hostname
, continue_host_address
,
4512 cutthrough
.cctx
.sock
>= 0 ? cutthrough
.cctx
.sock
: 0);
4515 /* Set the flag requesting that these hosts be added to the waiting
4516 database if the delivery fails temporarily or if we are running with
4517 queue_smtp or a 2-stage queue run. This gets unset for certain
4518 kinds of error, typically those that are specific to the message. */
4520 update_waiting
= TRUE
;
4522 /* If a host list is not defined for the addresses - they must all have the
4523 same one in order to be passed to a single transport - or if the transport has
4524 a host list with hosts_override set, use the host list supplied with the
4525 transport. It is an error for this not to exist. */
4527 if (!hostlist
|| (ob
->hosts_override
&& ob
->hosts
))
4531 addrlist
->message
= string_sprintf("%s transport called with no hosts set",
4533 addrlist
->transport_return
= PANIC
;
4534 return FALSE
; /* Only top address has status */
4537 DEBUG(D_transport
) debug_printf("using the transport's hosts: %s\n",
4540 /* If the transport's host list contains no '$' characters, and we are not
4541 randomizing, it is fixed and therefore a chain of hosts can be built once
4542 and for all, and remembered for subsequent use by other calls to this
4543 transport. If, on the other hand, the host list does contain '$', or we are
4544 randomizing its order, we have to rebuild it each time. In the fixed case,
4545 as the hosts string will never be used again, it doesn't matter that we
4546 replace all the : characters with zeros. */
4550 uschar
*s
= ob
->hosts
;
4552 if (Ustrchr(s
, '$') != NULL
)
4554 if (!(expanded_hosts
= expand_string(s
)))
4556 addrlist
->message
= string_sprintf("failed to expand list of hosts "
4557 "\"%s\" in %s transport: %s", s
, tblock
->name
, expand_string_message
);
4558 addrlist
->transport_return
= f
.search_find_defer
? DEFER
: PANIC
;
4559 return FALSE
; /* Only top address has status */
4561 DEBUG(D_transport
) debug_printf("expanded list of hosts \"%s\" to "
4562 "\"%s\"\n", s
, expanded_hosts
);
4566 if (ob
->hosts_randomize
) s
= expanded_hosts
= string_copy(s
);
4568 host_build_hostlist(&hostlist
, s
, ob
->hosts_randomize
);
4570 /* Check that the expansion yielded something useful. */
4574 string_sprintf("%s transport has empty hosts setting", tblock
->name
);
4575 addrlist
->transport_return
= PANIC
;
4576 return FALSE
; /* Only top address has status */
4579 /* If there was no expansion of hosts, save the host list for
4582 if (!expanded_hosts
) ob
->hostlist
= hostlist
;
4585 /* This is not the first time this transport has been run in this delivery;
4586 the host list was built previously. */
4589 hostlist
= ob
->hostlist
;
4592 /* The host list was supplied with the address. If hosts_randomize is set, we
4593 must sort it into a random order if it did not come from MX records and has not
4594 already been randomized (but don't bother if continuing down an existing
4597 else if (ob
->hosts_randomize
&& hostlist
->mx
== MX_NONE
&& !continue_hostname
)
4599 host_item
*newlist
= NULL
;
4602 host_item
*h
= hostlist
;
4603 hostlist
= hostlist
->next
;
4605 h
->sort_key
= random_number(100);
4612 else if (h
->sort_key
< newlist
->sort_key
)
4619 host_item
*hh
= newlist
;
4622 if (h
->sort_key
< hh
->next
->sort_key
) break;
4630 hostlist
= addrlist
->host_list
= newlist
;
4633 /* Sort out the default port. */
4635 if (!smtp_get_port(ob
->port
, addrlist
, &defport
, tid
)) return FALSE
;
4637 /* For each host-plus-IP-address on the list:
4639 . If this is a continued delivery and the host isn't the one with the
4640 current connection, skip.
4642 . If the status is unusable (i.e. previously failed or retry checked), skip.
4644 . If no IP address set, get the address, either by turning the name into
4645 an address, calling gethostbyname if gethostbyname is on, or by calling
4646 the DNS. The DNS may yield multiple addresses, in which case insert the
4647 extra ones into the list.
4649 . Get the retry data if not previously obtained for this address and set the
4650 field which remembers the state of this address. Skip if the retry time is
4651 not reached. If not, remember whether retry data was found. The retry string
4652 contains both the name and the IP address.
4654 . Scan the list of addresses and mark those whose status is DEFER as
4655 PENDING_DEFER. These are the only ones that will be processed in this cycle
4658 . Make a delivery attempt - addresses marked PENDING_DEFER will be tried.
4659 Some addresses may be successfully delivered, others may fail, and yet
4660 others may get temporary errors and so get marked DEFER.
4662 . The return from the delivery attempt is OK if a connection was made and a
4663 valid SMTP dialogue was completed. Otherwise it is DEFER.
4665 . If OK, add a "remove" retry item for this host/IPaddress, if any.
4667 . If fail to connect, or other defer state, add a retry item.
4669 . If there are any addresses whose status is still DEFER, carry on to the
4670 next host/IPaddress, unless we have tried the number of hosts given
4671 by hosts_max_try or hosts_max_try_hardlimit; otherwise return. Note that
4672 there is some fancy logic for hosts_max_try that means its limit can be
4673 overstepped in some circumstances.
4675 If we get to the end of the list, all hosts have deferred at least one address,
4676 or not reached their retry times. If delay_after_cutoff is unset, it requests a
4677 delivery attempt to those hosts whose last try was before the arrival time of
4678 the current message. To cope with this, we have to go round the loop a second
4679 time. After that, set the status and error data for any addresses that haven't
4680 had it set already. */
4682 for (int cutoff_retry
= 0;
4683 expired
&& cutoff_retry
< (ob
->delay_after_cutoff
? 1 : 2);
4686 host_item
*nexthost
= NULL
;
4687 int unexpired_hosts_tried
= 0;
4688 BOOL continue_host_tried
= FALSE
;
4690 retry_non_continued
:
4691 for (host
= hostlist
;
4693 && unexpired_hosts_tried
< ob
->hosts_max_try
4694 && total_hosts_tried
< ob
->hosts_max_try_hardlimit
;
4699 BOOL host_is_expired
= FALSE
;
4700 BOOL message_defer
= FALSE
;
4701 BOOL some_deferred
= FALSE
;
4702 address_item
*first_addr
= NULL
;
4703 uschar
*interface
= NULL
;
4704 uschar
*retry_host_key
= NULL
;
4705 uschar
*retry_message_key
= NULL
;
4706 uschar
*serialize_key
= NULL
;
4708 /* Default next host is next host. :-) But this can vary if the
4709 hosts_max_try limit is hit (see below). It may also be reset if a host
4710 address is looked up here (in case the host was multihomed). */
4712 nexthost
= host
->next
;
4714 /* If the address hasn't yet been obtained from the host name, look it up
4715 now, unless the host is already marked as unusable. If it is marked as
4716 unusable, it means that the router was unable to find its IP address (in
4717 the DNS or wherever) OR we are in the 2nd time round the cutoff loop, and
4718 the lookup failed last time. We don't get this far if *all* MX records
4719 point to non-existent hosts; that is treated as a hard error.
4721 We can just skip this host entirely. When the hosts came from the router,
4722 the address will timeout based on the other host(s); when the address is
4723 looked up below, there is an explicit retry record added.
4725 Note that we mustn't skip unusable hosts if the address is not unset; they
4726 may be needed as expired hosts on the 2nd time round the cutoff loop. */
4730 int new_port
, flags
;
4732 if (host
->status
>= hstatus_unusable
)
4734 DEBUG(D_transport
) debug_printf("%s has no address and is unusable - skipping\n",
4739 DEBUG(D_transport
) debug_printf("getting address for %s\n", host
->name
);
4741 /* The host name is permitted to have an attached port. Find it, and
4742 strip it from the name. Just remember it for now. */
4744 new_port
= host_item_get_port(host
);
4746 /* Count hosts looked up */
4750 /* Find by name if so configured, or if it's an IP address. We don't
4751 just copy the IP address, because we need the test-for-local to happen. */
4753 flags
= HOST_FIND_BY_A
| HOST_FIND_BY_AAAA
;
4754 if (ob
->dns_qualify_single
) flags
|= HOST_FIND_QUALIFY_SINGLE
;
4755 if (ob
->dns_search_parents
) flags
|= HOST_FIND_SEARCH_PARENTS
;
4757 if (ob
->gethostbyname
|| string_is_ip_address(host
->name
, NULL
) != 0)
4758 rc
= host_find_byname(host
, NULL
, flags
, NULL
, TRUE
);
4760 rc
= host_find_bydns(host
, NULL
, flags
, NULL
, NULL
, NULL
,
4761 &ob
->dnssec
, /* domains for request/require */
4764 /* Update the host (and any additional blocks, resulting from
4765 multihoming) with a host-specific port, if any. */
4767 for (host_item
* hh
= host
; hh
!= nexthost
; hh
= hh
->next
) hh
->port
= new_port
;
4769 /* Failure to find the host at this time (usually DNS temporary failure)
4770 is really a kind of routing failure rather than a transport failure.
4771 Therefore we add a retry item of the routing kind, not to stop us trying
4772 to look this name up here again, but to ensure the address gets timed
4773 out if the failures go on long enough. A complete failure at this point
4774 commonly points to a configuration error, but the best action is still
4775 to carry on for the next host. */
4777 if (rc
== HOST_FIND_AGAIN
|| rc
== HOST_FIND_SECURITY
|| rc
== HOST_FIND_FAILED
)
4779 retry_add_item(addrlist
, string_sprintf("R:%s", host
->name
), 0);
4781 if (rc
== HOST_FIND_AGAIN
) hosts_defer
++; else hosts_fail
++;
4782 DEBUG(D_transport
) debug_printf("rc = %s for %s\n", (rc
== HOST_FIND_AGAIN
)?
4783 "HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host
->name
);
4784 host
->status
= hstatus_unusable
;
4786 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
4788 if (addr
->transport_return
!= DEFER
) continue;
4789 addr
->basic_errno
= ERRNO_UNKNOWNHOST
;
4790 addr
->message
= string_sprintf(
4791 rc
== HOST_FIND_SECURITY
4792 ? "lookup of IP address for %s was insecure"
4793 : "failed to lookup IP address for %s",
4799 /* If the host is actually the local host, we may have a problem, or
4800 there may be some cunning configuration going on. In the problem case,
4801 log things and give up. The default transport status is already DEFER. */
4803 if (rc
== HOST_FOUND_LOCAL
&& !ob
->allow_localhost
)
4805 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
4807 addr
->basic_errno
= 0;
4808 addr
->message
= string_sprintf("%s transport found host %s to be "
4809 "local", tblock
->name
, host
->name
);
4813 } /* End of block for IP address lookup */
4815 /* If this is a continued delivery, we are interested only in the host
4816 which matches the name of the existing open channel. The check is put
4817 here after the local host lookup, in case the name gets expanded as a
4818 result of the lookup. Set expired FALSE, to save the outer loop executing
4821 if (continue_hostname
)
4822 if ( Ustrcmp(continue_hostname
, host
->name
) != 0
4823 || Ustrcmp(continue_host_address
, host
->address
) != 0
4827 continue; /* With next host */
4830 continue_host_tried
= TRUE
;
4832 /* Reset the default next host in case a multihomed host whose addresses
4833 are not looked up till just above added to the host list. */
4835 nexthost
= host
->next
;
4837 /* If queue_smtp is set (-odqs or the first part of a 2-stage run), or the
4838 domain is in queue_smtp_domains, we don't actually want to attempt any
4839 deliveries. When doing a queue run, queue_smtp_domains is always unset. If
4840 there is a lookup defer in queue_smtp_domains, proceed as if the domain
4841 were not in it. We don't want to hold up all SMTP deliveries! Except when
4842 doing a two-stage queue run, don't do this if forcing. */
4844 if ((!f
.deliver_force
|| f
.queue_2stage
) && (f
.queue_smtp
||
4845 match_isinlist(addrlist
->domain
,
4846 (const uschar
**)&queue_smtp_domains
, 0,
4847 &domainlist_anchor
, NULL
, MCL_DOMAIN
, TRUE
, NULL
) == OK
))
4850 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
4851 if (addr
->transport_return
== DEFER
)
4852 addr
->message
= US
"domain matches queue_smtp_domains, or -odqs set";
4853 continue; /* With next host */
4856 /* Count hosts being considered - purely for an intelligent comment
4857 if none are usable. */
4861 /* Set $host and $host address now in case they are needed for the
4862 interface expansion or the serialize_hosts check; they remain set if an
4863 actual delivery happens. */
4865 deliver_host
= host
->name
;
4866 deliver_host_address
= host
->address
;
4867 lookup_dnssec_authenticated
= host
->dnssec
== DS_YES
? US
"yes"
4868 : host
->dnssec
== DS_NO
? US
"no"
4871 /* Set up a string for adding to the retry key if the port number is not
4872 the standard SMTP port. A host may have its own port setting that overrides
4875 pistring
= string_sprintf(":%d", host
->port
== PORT_NONE
4876 ? defport
: host
->port
);
4877 if (Ustrcmp(pistring
, ":25") == 0) pistring
= US
"";
4879 /* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
4880 string is set, even if constant (as different transports can have different
4881 constant settings), we must add it to the key that is used for retries,
4882 because connections to the same host from a different interface should be
4883 treated separately. */
4885 host_af
= Ustrchr(host
->address
, ':') == NULL
? AF_INET
: AF_INET6
;
4887 uschar
* s
= ob
->interface
;
4890 if (!smtp_get_interface(s
, host_af
, addrlist
, &interface
, tid
))
4892 pistring
= string_sprintf("%s/%s", pistring
, interface
);
4896 /* The first time round the outer loop, check the status of the host by
4897 inspecting the retry data. The second time round, we are interested only
4898 in expired hosts that haven't been tried since this message arrived. */
4900 if (cutoff_retry
== 0)
4903 /* Ensure the status of the address is set by checking retry data if
4904 necessary. There may be host-specific retry data (applicable to all
4905 messages) and also data for retries of a specific message at this host.
4906 If either of these retry records are actually read, the keys used are
4907 returned to save recomputing them later. */
4909 if (exp_bool(addrlist
, US
"transport", tblock
->name
, D_transport
,
4910 US
"retry_include_ip_address", ob
->retry_include_ip_address
,
4911 ob
->expand_retry_include_ip_address
, &incl_ip
) != OK
)
4912 continue; /* with next host */
4914 host_is_expired
= retry_check_address(addrlist
->domain
, host
, pistring
,
4915 incl_ip
, &retry_host_key
, &retry_message_key
);
4917 DEBUG(D_transport
) debug_printf("%s [%s]%s retry-status = %s\n", host
->name
,
4918 host
->address
? host
->address
: US
"", pistring
,
4919 host
->status
== hstatus_usable
? "usable"
4920 : host
->status
== hstatus_unusable
? "unusable"
4921 : host
->status
== hstatus_unusable_expired
? "unusable (expired)" : "?");
4923 /* Skip this address if not usable at this time, noting if it wasn't
4924 actually expired, both locally and in the address. */
4926 switch (host
->status
)
4928 case hstatus_unusable
:
4930 setflag(addrlist
, af_retry_skipped
);
4933 case hstatus_unusable_expired
:
4936 case hwhy_retry
: hosts_retry
++; break;
4937 case hwhy_failed
: hosts_fail
++; break;
4939 case hwhy_deferred
: hosts_defer
++; break;
4942 /* If there was a retry message key, implying that previously there
4943 was a message-specific defer, we don't want to update the list of
4944 messages waiting for these hosts. */
4946 if (retry_message_key
) update_waiting
= FALSE
;
4947 continue; /* With the next host or IP address */
4951 /* Second time round the loop: if the address is set but expired, and
4952 the message is newer than the last try, let it through. */
4957 || host
->status
!= hstatus_unusable_expired
4958 || host
->last_try
> received_time
.tv_sec
)
4960 DEBUG(D_transport
) debug_printf("trying expired host %s [%s]%s\n",
4961 host
->name
, host
->address
, pistring
);
4962 host_is_expired
= TRUE
;
4965 /* Setting "expired=FALSE" doesn't actually mean not all hosts are expired;
4966 it remains TRUE only if all hosts are expired and none are actually tried.
4971 /* If this host is listed as one to which access must be serialized,
4972 see if another Exim process has a connection to it, and if so, skip
4973 this host. If not, update the database to record our connection to it
4974 and remember this for later deletion. Do not do any of this if we are
4975 sending the message down a pre-existing connection. */
4977 if ( !continue_hostname
4978 && verify_check_given_host(CUSS
&ob
->serialize_hosts
, host
) == OK
)
4980 serialize_key
= string_sprintf("host-serialize-%s", host
->name
);
4981 if (!enq_start(serialize_key
, 1))
4984 debug_printf("skipping host %s because another Exim process "
4985 "is connected to it\n", host
->name
);
4991 /* OK, we have an IP address that is not waiting for its retry time to
4992 arrive (it might be expired) OR (second time round the loop) we have an
4993 expired host that hasn't been tried since the message arrived. Have a go
4994 at delivering the message to it. First prepare the addresses by flushing
4995 out the result of previous attempts, and finding the first address that
4996 is still to be delivered. */
4998 first_addr
= prepare_addresses(addrlist
, host
);
5000 DEBUG(D_transport
) debug_printf("delivering %s to %s [%s] (%s%s)\n",
5001 message_id
, host
->name
, host
->address
, addrlist
->address
,
5002 addrlist
->next
? ", ..." : "");
5004 set_process_info("delivering %s to %s [%s]%s (%s%s)",
5005 message_id
, host
->name
, host
->address
, pistring
, addrlist
->address
,
5006 addrlist
->next
? ", ..." : "");
5008 /* This is not for real; don't do the delivery. If there are
5009 any remaining hosts, list them. */
5013 set_errno_nohost(addrlist
, 0, NULL
, OK
, FALSE
);
5014 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
5016 addr
->host_used
= host
;
5017 addr
->special_action
= '*';
5018 addr
->message
= US
"delivery bypassed by -N option";
5022 debug_printf("*** delivery by %s transport bypassed by -N option\n"
5023 "*** host and remaining hosts:\n", tblock
->name
);
5024 for (host_item
* host2
= host
; host2
; host2
= host2
->next
)
5025 debug_printf(" %s [%s]\n", host2
->name
,
5026 host2
->address
? host2
->address
: US
"unset");
5031 /* This is for real. If the host is expired, we don't count it for
5032 hosts_max_retry. This ensures that all hosts must expire before an address
5033 is timed out, unless hosts_max_try_hardlimit (which protects against
5034 lunatic DNS configurations) is reached.
5036 If the host is not expired and we are about to hit the hosts_max_retry
5037 limit, check to see if there is a subsequent hosts with a different MX
5038 value. If so, make that the next host, and don't count this one. This is a
5039 heuristic to make sure that different MXs do get tried. With a normal kind
5040 of retry rule, they would get tried anyway when the earlier hosts were
5041 delayed, but if the domain has a "retry every time" type of rule - as is
5042 often used for the the very large ISPs, that won't happen. */
5047 /* Make a copy of the host if it is local to this invocation
5048 of the transport. */
5052 thost
= store_get(sizeof(host_item
));
5054 thost
->name
= string_copy(host
->name
);
5055 thost
->address
= string_copy(host
->address
);
5060 if (!host_is_expired
&& ++unexpired_hosts_tried
>= ob
->hosts_max_try
)
5063 debug_printf("hosts_max_try limit reached with this host\n");
5064 for (host_item
* h
= host
; h
; h
= h
->next
) if (h
->mx
!= host
->mx
)
5067 unexpired_hosts_tried
--;
5068 DEBUG(D_transport
) debug_printf("however, a higher MX host exists "
5069 "and will be tried\n");
5074 /* Attempt the delivery. */
5076 total_hosts_tried
++;
5077 rc
= smtp_deliver(addrlist
, thost
, host_af
, defport
, interface
, tblock
,
5078 &message_defer
, FALSE
);
5081 OK => connection made, each address contains its result;
5082 message_defer is set for message-specific defers (when all
5083 recipients are marked defer)
5084 DEFER => there was a non-message-specific delivery problem;
5085 ERROR => there was a problem setting up the arguments for a filter,
5086 or there was a problem with expanding added headers
5089 /* If the result is not OK, there was a non-message-specific problem.
5090 If the result is DEFER, we need to write to the logs saying what happened
5091 for this particular host, except in the case of authentication and TLS
5092 failures, where the log has already been written. If all hosts defer a
5093 general message is written at the end. */
5095 if (rc
== DEFER
&& first_addr
->basic_errno
!= ERRNO_AUTHFAIL
5096 && first_addr
->basic_errno
!= ERRNO_TLSFAILURE
)
5097 write_logs(host
, first_addr
->message
, first_addr
->basic_errno
);
5099 #ifndef DISABLE_EVENT
5101 deferred_event_raise(first_addr
, host
);
5104 /* If STARTTLS was accepted, but there was a failure in setting up the
5105 TLS session (usually a certificate screwup), and the host is not in
5106 hosts_require_tls, and tls_tempfail_tryclear is true, try again, with
5107 TLS forcibly turned off. We have to start from scratch with a new SMTP
5108 connection. That's why the retry is done from here, not from within
5109 smtp_deliver(). [Rejections of STARTTLS itself don't screw up the
5110 session, so the in-clear transmission after those errors, if permitted,
5111 happens inside smtp_deliver().] */
5115 && first_addr
->basic_errno
== ERRNO_TLSFAILURE
5116 && ob
->tls_tempfail_tryclear
5117 && verify_check_given_host(CUSS
&ob
->hosts_require_tls
, host
) != OK
5120 log_write(0, LOG_MAIN
,
5121 "%s: delivering unencrypted to H=%s [%s] (not in hosts_require_tls)",
5122 first_addr
->message
, host
->name
, host
->address
);
5123 first_addr
= prepare_addresses(addrlist
, host
);
5124 rc
= smtp_deliver(addrlist
, thost
, host_af
, defport
, interface
, tblock
,
5125 &message_defer
, TRUE
);
5126 if (rc
== DEFER
&& first_addr
->basic_errno
!= ERRNO_AUTHFAIL
)
5127 write_logs(host
, first_addr
->message
, first_addr
->basic_errno
);
5128 # ifndef DISABLE_EVENT
5130 deferred_event_raise(first_addr
, host
);
5133 #endif /*DISABLE_TLS*/
5136 /* Delivery attempt finished */
5138 set_process_info("delivering %s: just tried %s [%s]%s for %s%s: result %s",
5139 message_id
, host
->name
, host
->address
, pistring
, addrlist
->address
,
5140 addrlist
->next
? " (& others)" : "", rc_to_string(rc
));
5142 /* Release serialization if set up */
5144 if (serialize_key
) enq_end(serialize_key
);
5146 /* If the result is DEFER, or if a host retry record is known to exist, we
5147 need to add an item to the retry chain for updating the retry database
5148 at the end of delivery. We only need to add the item to the top address,
5149 of course. Also, if DEFER, we mark the IP address unusable so as to skip it
5150 for any other delivery attempts using the same address. (It is copied into
5151 the unusable tree at the outer level, so even if different address blocks
5152 contain the same address, it still won't get tried again.) */
5154 if (rc
== DEFER
|| retry_host_key
)
5156 int delete_flag
= rc
!= DEFER
? rf_delete
: 0;
5157 if (!retry_host_key
)
5160 if (exp_bool(addrlist
, US
"transport", tblock
->name
, D_transport
,
5161 US
"retry_include_ip_address", ob
->retry_include_ip_address
,
5162 ob
->expand_retry_include_ip_address
, &incl_ip
) != OK
)
5163 incl_ip
= TRUE
; /* error; use most-specific retry record */
5165 retry_host_key
= incl_ip
5166 ? string_sprintf("T:%S:%s%s", host
->name
, host
->address
, pistring
)
5167 : string_sprintf("T:%S%s", host
->name
, pistring
);
5170 /* If a delivery of another message over an existing SMTP connection
5171 yields DEFER, we do NOT set up retry data for the host. This covers the
5172 case when there are delays in routing the addresses in the second message
5173 that are so long that the server times out. This is alleviated by not
5174 routing addresses that previously had routing defers when handling an
5175 existing connection, but even so, this case may occur (e.g. if a
5176 previously happily routed address starts giving routing defers). If the
5177 host is genuinely down, another non-continued message delivery will
5178 notice it soon enough. */
5180 if (delete_flag
!= 0 || !continue_hostname
)
5181 retry_add_item(first_addr
, retry_host_key
, rf_host
| delete_flag
);
5183 /* We may have tried an expired host, if its retry time has come; ensure
5184 the status reflects the expiry for the benefit of any other addresses. */
5188 host
->status
= host_is_expired
5189 ? hstatus_unusable_expired
: hstatus_unusable
;
5190 host
->why
= hwhy_deferred
;
5194 /* If message_defer is set (host was OK, but every recipient got deferred
5195 because of some message-specific problem), or if that had happened
5196 previously so that a message retry key exists, add an appropriate item
5197 to the retry chain. Note that if there was a message defer but now there is
5198 a host defer, the message defer record gets deleted. That seems perfectly
5199 reasonable. Also, stop the message from being remembered as waiting
5200 for specific hosts. */
5202 if (message_defer
|| retry_message_key
)
5204 int delete_flag
= message_defer
? 0 : rf_delete
;
5205 if (!retry_message_key
)
5208 if (exp_bool(addrlist
, US
"transport", tblock
->name
, D_transport
,
5209 US
"retry_include_ip_address", ob
->retry_include_ip_address
,
5210 ob
->expand_retry_include_ip_address
, &incl_ip
) != OK
)
5211 incl_ip
= TRUE
; /* error; use most-specific retry record */
5213 retry_message_key
= incl_ip
5214 ? string_sprintf("T:%S:%s%s:%s", host
->name
, host
->address
, pistring
,
5216 : string_sprintf("T:%S%s:%s", host
->name
, pistring
, message_id
);
5218 retry_add_item(addrlist
, retry_message_key
,
5219 rf_message
| rf_host
| delete_flag
);
5220 update_waiting
= FALSE
;
5223 /* Any return other than DEFER (that is, OK or ERROR) means that the
5224 addresses have got their final statuses filled in for this host. In the OK
5225 case, see if any of them are deferred. */
5228 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
5229 if (addr
->transport_return
== DEFER
)
5231 some_deferred
= TRUE
;
5235 /* If no addresses deferred or the result was ERROR, return. We do this for
5236 ERROR because a failing filter set-up or add_headers expansion is likely to
5237 fail for any host we try. */
5239 if (rc
== ERROR
|| (rc
== OK
&& !some_deferred
))
5241 DEBUG(D_transport
) debug_printf("Leaving %s transport\n", tblock
->name
);
5242 return TRUE
; /* Each address has its status */
5245 /* If the result was DEFER or some individual addresses deferred, let
5246 the loop run to try other hosts with the deferred addresses, except for the
5247 case when we were trying to deliver down an existing channel and failed.
5248 Don't try any other hosts in this case. */
5250 if (continue_hostname
) break;
5252 /* If the whole delivery, or some individual addresses, were deferred and
5253 there are more hosts that could be tried, do not count this host towards
5254 the hosts_max_try limit if the age of the message is greater than the
5255 maximum retry time for this host. This means we may try try all hosts,
5256 ignoring the limit, when messages have been around for some time. This is
5257 important because if we don't try all hosts, the address will never time
5258 out. NOTE: this does not apply to hosts_max_try_hardlimit. */
5260 if ((rc
== DEFER
|| some_deferred
) && nexthost
)
5263 retry_config
*retry
= retry_find_config(host
->name
, NULL
, 0, 0);
5265 if (retry
&& retry
->rules
)
5267 retry_rule
*last_rule
;
5268 for (last_rule
= retry
->rules
;
5270 last_rule
= last_rule
->next
);
5271 timedout
= time(NULL
) - received_time
.tv_sec
> last_rule
->timeout
;
5273 else timedout
= TRUE
; /* No rule => timed out */
5277 unexpired_hosts_tried
--;
5278 DEBUG(D_transport
) debug_printf("temporary delivery error(s) override "
5279 "hosts_max_try (message older than host's retry time)\n");
5285 if (unexpired_hosts_tried
>= ob
->hosts_max_try
)
5286 debug_printf("reached transport hosts_max_try limit %d\n",
5288 if (total_hosts_tried
>= ob
->hosts_max_try_hardlimit
)
5289 debug_printf("reached transport hosts_max_try_hardlimit limit %d\n",
5290 ob
->hosts_max_try_hardlimit
);
5293 if (f
.running_in_test_harness
) millisleep(500); /* let server debug out */
5294 } /* End of loop for trying multiple hosts. */
5296 /* If we failed to find a matching host in the list, for an already-open
5297 connection, just close it and start over with the list. This can happen
5298 for routing that changes from run to run, or big multi-IP sites with
5301 if (continue_hostname
&& !continue_host_tried
)
5303 int fd
= cutthrough
.cctx
.sock
>= 0 ? cutthrough
.cctx
.sock
: 0;
5305 DEBUG(D_transport
) debug_printf("no hosts match already-open connection\n");
5307 /* A TLS conn could be open for a cutthrough, but not for a plain continued-
5309 /*XXX doublecheck that! */
5311 if (cutthrough
.cctx
.sock
>= 0 && cutthrough
.is_tls
)
5313 (void) tls_write(cutthrough
.cctx
.tls_ctx
, US
"QUIT\r\n", 6, FALSE
);
5314 tls_close(cutthrough
.cctx
.tls_ctx
, TLS_SHUTDOWN_NOWAIT
);
5315 cutthrough
.cctx
.tls_ctx
= NULL
;
5316 cutthrough
.is_tls
= FALSE
;
5320 (void) write(fd
, US
"QUIT\r\n", 6);
5323 cutthrough
.cctx
.sock
= -1;
5324 continue_hostname
= NULL
;
5325 goto retry_non_continued
;
5328 /* This is the end of the loop that repeats iff expired is TRUE and
5329 ob->delay_after_cutoff is FALSE. The second time round we will
5330 try those hosts that haven't been tried since the message arrived. */
5334 debug_printf("all IP addresses skipped or deferred at least one address\n");
5335 if (expired
&& !ob
->delay_after_cutoff
&& cutoff_retry
== 0)
5336 debug_printf("retrying IP addresses not tried since message arrived\n");
5341 /* Get here if all IP addresses are skipped or defer at least one address. In
5342 MUA wrapper mode, this will happen only for connection or other non-message-
5343 specific failures. Force the delivery status for all addresses to FAIL. */
5347 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
5348 addr
->transport_return
= FAIL
;
5352 /* In the normal, non-wrapper case, add a standard message to each deferred
5353 address if there hasn't been an error, that is, if it hasn't actually been
5354 tried this time. The variable "expired" will be FALSE if any deliveries were
5355 actually tried, or if there was at least one host that was not expired. That
5356 is, it is TRUE only if no deliveries were tried and all hosts were expired. If
5357 a delivery has been tried, an error code will be set, and the failing of the
5358 message is handled by the retry code later.
5360 If queue_smtp is set, or this transport was called to send a subsequent message
5361 down an existing TCP/IP connection, and something caused the host not to be
5362 found, we end up here, but can detect these cases and handle them specially. */
5364 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
5366 /* If host is not NULL, it means that we stopped processing the host list
5367 because of hosts_max_try or hosts_max_try_hardlimit. In the former case, this
5368 means we need to behave as if some hosts were skipped because their retry
5369 time had not come. Specifically, this prevents the address from timing out.
5370 However, if we have hit hosts_max_try_hardlimit, we want to behave as if all
5371 hosts were tried. */
5374 if (total_hosts_tried
>= ob
->hosts_max_try_hardlimit
)
5377 debug_printf("hosts_max_try_hardlimit reached: behave as if all "
5378 "hosts were tried\n");
5383 debug_printf("hosts_max_try limit caused some hosts to be skipped\n");
5384 setflag(addr
, af_retry_skipped
);
5387 if (f
.queue_smtp
) /* no deliveries attempted */
5389 addr
->transport_return
= DEFER
;
5390 addr
->basic_errno
= 0;
5391 addr
->message
= US
"SMTP delivery explicitly queued";
5394 else if ( addr
->transport_return
== DEFER
5395 && (addr
->basic_errno
== ERRNO_UNKNOWNERROR
|| addr
->basic_errno
== 0)
5399 addr
->basic_errno
= ERRNO_HRETRY
;
5400 if (continue_hostname
)
5401 addr
->message
= US
"no host found for existing SMTP connection";
5404 setflag(addr
, af_pass_message
); /* This is not a security risk */
5405 addr
->message
= string_sprintf(
5406 "all hosts%s have been failing for a long time %s",
5407 addr
->domain
? string_sprintf(" for '%s'", addr
->domain
) : US
"",
5408 ob
->delay_after_cutoff
5409 ? US
"(and retry time not reached)"
5410 : US
"and were last tried after this message arrived");
5412 /* If we are already using fallback hosts, or there are no fallback hosts
5413 defined, convert the result to FAIL to cause a bounce. */
5415 if (addr
->host_list
== addr
->fallback_hosts
|| !addr
->fallback_hosts
)
5416 addr
->transport_return
= FAIL
;
5421 if (hosts_retry
== hosts_total
)
5422 s
= "retry time not reached for any host%s";
5423 else if (hosts_fail
== hosts_total
)
5424 s
= "all host address lookups%s failed permanently";
5425 else if (hosts_defer
== hosts_total
)
5426 s
= "all host address lookups%s failed temporarily";
5427 else if (hosts_serial
== hosts_total
)
5428 s
= "connection limit reached for all hosts%s";
5429 else if (hosts_fail
+hosts_defer
== hosts_total
)
5430 s
= "all host address lookups%s failed";
5432 s
= "some host address lookups failed and retry time "
5433 "not reached for other hosts or connection limit reached%s";
5435 addr
->message
= string_sprintf(s
,
5436 addr
->domain
? string_sprintf(" for '%s'", addr
->domain
) : US
"");
5441 /* Update the database which keeps information about which messages are waiting
5442 for which hosts to become available. For some message-specific errors, the
5443 update_waiting flag is turned off because we don't want follow-on deliveries in
5444 those cases. If this transport instance is explicitly limited to one message
5445 per connection then follow-on deliveries are not possible and there's no need
5446 to create/update the per-transport wait-<transport_name> database. */
5448 if (update_waiting
&& tblock
->connection_max_messages
!= 1)
5449 transport_update_waiting(hostlist
, tblock
->name
);
5453 DEBUG(D_transport
) debug_printf("Leaving %s transport\n", tblock
->name
);
5455 return TRUE
; /* Each address has its status */
5458 #endif /*!MACRO_PREDEF*/
5461 /* End of transport/smtp.c */