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. */
11 #if defined(SUPPORT_DANE) && defined(DISABLE_TLS)
12 # error TLS is required for DANE
16 /* Options specific to the smtp transport. This transport also supports LMTP
17 over TCP/IP. The options must be in alphabetic order (note that "_" comes
18 before the lower case letters). Some live in the transport_instance block so as
19 to be publicly visible; these are flagged with opt_public. */
21 #define LOFF(field) OPT_OFF(smtp_transport_options_block, field)
23 optionlist smtp_transport_options
[] = {
24 { "*expand_multi_domain", opt_stringptr
| opt_hidden
| opt_public
,
25 OPT_OFF(transport_instance
, expand_multi_domain
) },
26 { "*expand_retry_include_ip_address", opt_stringptr
| opt_hidden
,
27 LOFF(expand_retry_include_ip_address
) },
29 { "address_retry_include_sender", opt_bool
,
30 LOFF(address_retry_include_sender
) },
31 { "allow_localhost", opt_bool
, LOFF(allow_localhost
) },
32 #ifdef EXPERIMENTAL_ARC
33 { "arc_sign", opt_stringptr
, LOFF(arc_sign
) },
35 { "authenticated_sender", opt_stringptr
, LOFF(authenticated_sender
) },
36 { "authenticated_sender_force", opt_bool
, LOFF(authenticated_sender_force
) },
37 { "command_timeout", opt_time
, LOFF(command_timeout
) },
38 { "connect_timeout", opt_time
, LOFF(connect_timeout
) },
39 { "connection_max_messages", opt_int
| opt_public
,
40 OPT_OFF(transport_instance
, connection_max_messages
) },
42 { "dane_require_tls_ciphers", opt_stringptr
, LOFF(dane_require_tls_ciphers
) },
44 { "data_timeout", opt_time
, LOFF(data_timeout
) },
45 { "delay_after_cutoff", opt_bool
, LOFF(delay_after_cutoff
) },
47 { "dkim_canon", opt_stringptr
, LOFF(dkim
.dkim_canon
) },
48 { "dkim_domain", opt_stringptr
, LOFF(dkim
.dkim_domain
) },
49 { "dkim_hash", opt_stringptr
, LOFF(dkim
.dkim_hash
) },
50 { "dkim_identity", opt_stringptr
, LOFF(dkim
.dkim_identity
) },
51 { "dkim_private_key", opt_stringptr
, LOFF(dkim
.dkim_private_key
) },
52 { "dkim_selector", opt_stringptr
, LOFF(dkim
.dkim_selector
) },
53 { "dkim_sign_headers", opt_stringptr
, LOFF(dkim
.dkim_sign_headers
) },
54 { "dkim_strict", opt_stringptr
, LOFF(dkim
.dkim_strict
) },
55 { "dkim_timestamps", opt_stringptr
, LOFF(dkim
.dkim_timestamps
) },
57 { "dns_qualify_single", opt_bool
, LOFF(dns_qualify_single
) },
58 { "dns_search_parents", opt_bool
, LOFF(dns_search_parents
) },
59 { "dnssec_request_domains", opt_stringptr
, LOFF(dnssec
.request
) },
60 { "dnssec_require_domains", opt_stringptr
, LOFF(dnssec
.require
) },
61 { "dscp", opt_stringptr
, LOFF(dscp
) },
62 { "fallback_hosts", opt_stringptr
, LOFF(fallback_hosts
) },
63 { "final_timeout", opt_time
, LOFF(final_timeout
) },
64 { "gethostbyname", opt_bool
, LOFF(gethostbyname
) },
65 { "helo_data", opt_stringptr
, LOFF(helo_data
) },
66 { "hosts", opt_stringptr
, LOFF(hosts
) },
67 { "hosts_avoid_esmtp", opt_stringptr
, LOFF(hosts_avoid_esmtp
) },
68 { "hosts_avoid_pipelining", opt_stringptr
, LOFF(hosts_avoid_pipelining
) },
70 { "hosts_avoid_tls", opt_stringptr
, LOFF(hosts_avoid_tls
) },
72 { "hosts_max_try", opt_int
, LOFF(hosts_max_try
) },
73 { "hosts_max_try_hardlimit", opt_int
, LOFF(hosts_max_try_hardlimit
) },
75 { "hosts_nopass_tls", opt_stringptr
, LOFF(hosts_nopass_tls
) },
76 { "hosts_noproxy_tls", opt_stringptr
, LOFF(hosts_noproxy_tls
) },
78 { "hosts_override", opt_bool
, LOFF(hosts_override
) },
79 #ifndef DISABLE_PIPE_CONNECT
80 { "hosts_pipe_connect", opt_stringptr
, LOFF(hosts_pipe_connect
) },
82 { "hosts_randomize", opt_bool
, LOFF(hosts_randomize
) },
83 #if !defined(DISABLE_TLS) && !defined(DISABLE_OCSP)
84 { "hosts_request_ocsp", opt_stringptr
, LOFF(hosts_request_ocsp
) },
86 { "hosts_require_auth", opt_stringptr
, LOFF(hosts_require_auth
) },
89 { "hosts_require_dane", opt_stringptr
, LOFF(hosts_require_dane
) },
92 { "hosts_require_ocsp", opt_stringptr
, LOFF(hosts_require_ocsp
) },
94 { "hosts_require_tls", opt_stringptr
, LOFF(hosts_require_tls
) },
96 { "hosts_try_auth", opt_stringptr
, LOFF(hosts_try_auth
) },
97 { "hosts_try_chunking", opt_stringptr
, LOFF(hosts_try_chunking
) },
99 { "hosts_try_dane", opt_stringptr
, LOFF(hosts_try_dane
) },
101 { "hosts_try_fastopen", opt_stringptr
, LOFF(hosts_try_fastopen
) },
103 { "hosts_try_prdr", opt_stringptr
, LOFF(hosts_try_prdr
) },
106 { "hosts_verify_avoid_tls", opt_stringptr
, LOFF(hosts_verify_avoid_tls
) },
108 { "interface", opt_stringptr
, LOFF(interface
) },
109 { "keepalive", opt_bool
, LOFF(keepalive
) },
110 { "lmtp_ignore_quota", opt_bool
, LOFF(lmtp_ignore_quota
) },
111 { "max_rcpt", opt_int
| opt_public
,
112 OPT_OFF(transport_instance
, max_addresses
) },
113 { "multi_domain", opt_expand_bool
| opt_public
,
114 OPT_OFF(transport_instance
, multi_domain
) },
115 { "port", opt_stringptr
, LOFF(port
) },
116 { "protocol", opt_stringptr
, LOFF(protocol
) },
117 { "retry_include_ip_address", opt_expand_bool
, LOFF(retry_include_ip_address
) },
118 { "serialize_hosts", opt_stringptr
, LOFF(serialize_hosts
) },
119 { "size_addition", opt_int
, LOFF(size_addition
) },
121 { "socks_proxy", opt_stringptr
, LOFF(socks_proxy
) },
124 { "tls_certificate", opt_stringptr
, LOFF(tls_certificate
) },
125 { "tls_crl", opt_stringptr
, LOFF(tls_crl
) },
126 { "tls_dh_min_bits", opt_int
, LOFF(tls_dh_min_bits
) },
127 { "tls_privatekey", opt_stringptr
, LOFF(tls_privatekey
) },
128 { "tls_require_ciphers", opt_stringptr
, LOFF(tls_require_ciphers
) },
129 # ifdef EXPERIMENTAL_TLS_RESUME
130 { "tls_resumption_hosts", opt_stringptr
, LOFF(tls_resumption_hosts
) },
132 { "tls_sni", opt_stringptr
, LOFF(tls_sni
) },
133 { "tls_tempfail_tryclear", opt_bool
, LOFF(tls_tempfail_tryclear
) },
134 { "tls_try_verify_hosts", opt_stringptr
, LOFF(tls_try_verify_hosts
) },
135 { "tls_verify_cert_hostnames", opt_stringptr
, LOFF(tls_verify_cert_hostnames
)},
136 { "tls_verify_certificates", opt_stringptr
, LOFF(tls_verify_certificates
) },
137 { "tls_verify_hosts", opt_stringptr
, LOFF(tls_verify_hosts
) },
140 { "utf8_downconvert", opt_stringptr
, LOFF(utf8_downconvert
) },
144 /* Size of the options list. An extern variable has to be used so that its
145 address can appear in the tables drtables.c. */
147 int smtp_transport_options_count
= nelem(smtp_transport_options
);
153 smtp_transport_options_block smtp_transport_option_defaults
= {0};
154 void smtp_transport_init(transport_instance
*tblock
) {}
155 BOOL
smtp_transport_entry(transport_instance
*tblock
, address_item
*addr
) {return FALSE
;}
156 void smtp_transport_closedown(transport_instance
*tblock
) {}
158 #else /*!MACRO_PREDEF*/
161 /* Default private options block for the smtp transport. */
163 smtp_transport_options_block smtp_transport_option_defaults
= {
165 .fallback_hosts
= NULL
,
167 .fallback_hostlist
= NULL
,
168 .helo_data
= US
"$primary_hostname",
171 .protocol
= US
"smtp",
173 .serialize_hosts
= NULL
,
174 .hosts_try_auth
= NULL
,
175 .hosts_require_auth
= NULL
,
176 .hosts_try_chunking
= US
"*",
178 .hosts_try_dane
= US
"*",
179 .hosts_require_dane
= NULL
,
180 .dane_require_tls_ciphers
= NULL
,
182 .hosts_try_fastopen
= US
"*",
184 .hosts_try_prdr
= US
"*",
187 .hosts_request_ocsp
= US
"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
188 .hosts_require_ocsp
= NULL
,
190 .hosts_require_tls
= NULL
,
191 .hosts_avoid_tls
= NULL
,
192 .hosts_verify_avoid_tls
= NULL
,
193 .hosts_avoid_pipelining
= NULL
,
194 #ifndef DISABLE_PIPE_CONNECT
195 .hosts_pipe_connect
= NULL
,
197 .hosts_avoid_esmtp
= NULL
,
199 .hosts_nopass_tls
= NULL
,
200 .hosts_noproxy_tls
= NULL
,
202 .command_timeout
= 5*60,
203 .connect_timeout
= 5*60,
204 .data_timeout
= 5*60,
205 .final_timeout
= 10*60,
206 .size_addition
= 1024,
208 .hosts_max_try_hardlimit
= 50,
209 .address_retry_include_sender
= TRUE
,
210 .allow_localhost
= FALSE
,
211 .authenticated_sender_force
= FALSE
,
212 .gethostbyname
= FALSE
,
213 .dns_qualify_single
= TRUE
,
214 .dns_search_parents
= FALSE
,
215 .dnssec
= { .request
= US
"*", .require
=NULL
},
216 .delay_after_cutoff
= TRUE
,
217 .hosts_override
= FALSE
,
218 .hosts_randomize
= FALSE
,
220 .lmtp_ignore_quota
= FALSE
,
221 .expand_retry_include_ip_address
= NULL
,
222 .retry_include_ip_address
= TRUE
,
227 .tls_certificate
= NULL
,
229 .tls_privatekey
= NULL
,
230 .tls_require_ciphers
= NULL
,
232 .tls_verify_certificates
= US
"system",
233 .tls_dh_min_bits
= EXIM_CLIENT_DH_DEFAULT_MIN_BITS
,
234 .tls_tempfail_tryclear
= TRUE
,
235 # ifdef EXPERIMENTAL_TLS_RESUME
236 .tls_resumption_hosts
= NULL
,
238 .tls_verify_hosts
= NULL
,
239 .tls_try_verify_hosts
= US
"*",
240 .tls_verify_cert_hostnames
= US
"*",
243 .utf8_downconvert
= NULL
,
247 {.dkim_domain
= NULL
,
248 .dkim_identity
= NULL
,
249 .dkim_private_key
= NULL
,
250 .dkim_selector
= NULL
,
252 .dkim_sign_headers
= NULL
,
254 .dkim_hash
= US
"sha256",
255 .dkim_timestamps
= NULL
,
256 .dot_stuffed
= FALSE
,
257 .force_bodyhash
= FALSE
,
258 # ifdef EXPERIMENTAL_ARC
259 .arc_signspec
= NULL
,
262 # ifdef EXPERIMENTAL_ARC
268 /* some DSN flags for use later */
270 static int rf_list
[] = {rf_notify_never
, rf_notify_success
,
271 rf_notify_failure
, rf_notify_delay
};
273 static uschar
*rf_names
[] = { US
"NEVER", US
"SUCCESS", US
"FAILURE", US
"DELAY" };
279 static uschar
*smtp_command
; /* Points to last cmd for error messages */
280 static uschar
*mail_command
; /* Points to MAIL cmd for error messages */
281 static uschar
*data_command
= US
""; /* Points to DATA cmd for error messages */
282 static BOOL update_waiting
; /* TRUE to update the "wait" database */
284 /*XXX move to smtp_context */
285 static BOOL pipelining_active
; /* current transaction is in pipe mode */
288 static unsigned ehlo_response(uschar
* buf
, unsigned checks
);
291 /******************************************************************************/
294 smtp_deliver_init(void)
296 if (!regex_PIPELINING
) regex_PIPELINING
=
297 regex_must_compile(US
"\\n250[\\s\\-]PIPELINING(\\s|\\n|$)", FALSE
, TRUE
);
299 if (!regex_SIZE
) regex_SIZE
=
300 regex_must_compile(US
"\\n250[\\s\\-]SIZE(\\s|\\n|$)", FALSE
, TRUE
);
302 if (!regex_AUTH
) regex_AUTH
=
303 regex_must_compile(AUTHS_REGEX
, FALSE
, TRUE
);
306 if (!regex_STARTTLS
) regex_STARTTLS
=
307 regex_must_compile(US
"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE
, TRUE
);
310 if (!regex_CHUNKING
) regex_CHUNKING
=
311 regex_must_compile(US
"\\n250[\\s\\-]CHUNKING(\\s|\\n|$)", FALSE
, TRUE
);
314 if (!regex_PRDR
) regex_PRDR
=
315 regex_must_compile(US
"\\n250[\\s\\-]PRDR(\\s|\\n|$)", FALSE
, TRUE
);
319 if (!regex_UTF8
) regex_UTF8
=
320 regex_must_compile(US
"\\n250[\\s\\-]SMTPUTF8(\\s|\\n|$)", FALSE
, TRUE
);
323 if (!regex_DSN
) regex_DSN
=
324 regex_must_compile(US
"\\n250[\\s\\-]DSN(\\s|\\n|$)", FALSE
, TRUE
);
326 if (!regex_IGNOREQUOTA
) regex_IGNOREQUOTA
=
327 regex_must_compile(US
"\\n250[\\s\\-]IGNOREQUOTA(\\s|\\n|$)", FALSE
, TRUE
);
329 #ifndef DISABLE_PIPE_CONNECT
330 if (!regex_EARLY_PIPE
) regex_EARLY_PIPE
=
331 regex_must_compile(US
"\\n250[\\s\\-]" EARLY_PIPE_FEATURE_NAME
"(\\s|\\n|$)", FALSE
, TRUE
);
336 /*************************************************
337 * Setup entry point *
338 *************************************************/
340 /* This function is called when the transport is about to be used,
341 but before running it in a sub-process. It is used for two things:
343 (1) To set the fallback host list in addresses, when delivering.
344 (2) To pass back the interface, port, protocol, and other options, for use
345 during callout verification.
348 tblock pointer to the transport instance block
349 addrlist list of addresses about to be transported
350 tf if not NULL, pointer to block in which to return options
351 uid the uid that will be set (not used)
352 gid the gid that will be set (not used)
353 errmsg place for error message (not used)
355 Returns: OK always (FAIL, DEFER not used)
359 smtp_transport_setup(transport_instance
*tblock
, address_item
*addrlist
,
360 transport_feedback
*tf
, uid_t uid
, gid_t gid
, uschar
**errmsg
)
362 smtp_transport_options_block
*ob
= SOB tblock
->options_block
;
364 errmsg
= errmsg
; /* Keep picky compilers happy */
368 /* Pass back options if required. This interface is getting very messy. */
372 tf
->interface
= ob
->interface
;
374 tf
->protocol
= ob
->protocol
;
375 tf
->hosts
= ob
->hosts
;
376 tf
->hosts_override
= ob
->hosts_override
;
377 tf
->hosts_randomize
= ob
->hosts_randomize
;
378 tf
->gethostbyname
= ob
->gethostbyname
;
379 tf
->qualify_single
= ob
->dns_qualify_single
;
380 tf
->search_parents
= ob
->dns_search_parents
;
381 tf
->helo_data
= ob
->helo_data
;
384 /* Set the fallback host list for all the addresses that don't have fallback
385 host lists, provided that the local host wasn't present in the original host
388 if (!testflag(addrlist
, af_local_host_removed
))
389 for (; addrlist
; addrlist
= addrlist
->next
)
390 if (!addrlist
->fallback_hosts
) addrlist
->fallback_hosts
= ob
->fallback_hostlist
;
397 /*************************************************
398 * Initialization entry point *
399 *************************************************/
401 /* Called for each instance, after its options have been read, to
402 enable consistency checks to be done, or anything else that needs
405 Argument: pointer to the transport instance block
410 smtp_transport_init(transport_instance
*tblock
)
412 smtp_transport_options_block
*ob
= SOB tblock
->options_block
;
414 /* Retry_use_local_part defaults FALSE if unset */
416 if (tblock
->retry_use_local_part
== TRUE_UNSET
)
417 tblock
->retry_use_local_part
= FALSE
;
419 /* Set the default port according to the protocol */
422 ob
->port
= strcmpic(ob
->protocol
, US
"lmtp") == 0
424 : strcmpic(ob
->protocol
, US
"smtps") == 0
425 ? US
"smtps" : US
"smtp";
427 /* Set up the setup entry point, to be called before subprocesses for this
430 tblock
->setup
= smtp_transport_setup
;
432 /* Complain if any of the timeouts are zero. */
434 if (ob
->command_timeout
<= 0 || ob
->data_timeout
<= 0 ||
435 ob
->final_timeout
<= 0)
436 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
437 "command, data, or final timeout value is zero for %s transport",
440 /* If hosts_override is set and there are local hosts, set the global
441 flag that stops verify from showing router hosts. */
443 if (ob
->hosts_override
&& ob
->hosts
!= NULL
) tblock
->overrides_hosts
= TRUE
;
445 /* If there are any fallback hosts listed, build a chain of host items
446 for them, but do not do any lookups at this time. */
448 host_build_hostlist(&(ob
->fallback_hostlist
), ob
->fallback_hosts
, FALSE
);
455 /*************************************************
456 * Set delivery info into all active addresses *
457 *************************************************/
459 /* Only addresses whose status is >= PENDING are relevant. A lesser
460 status means that an address is not currently being processed.
463 addrlist points to a chain of addresses
464 errno_value to put in each address's errno field
465 msg to put in each address's message field
466 rc to put in each address's transport_return field
467 pass_message if TRUE, set the "pass message" flag in the address
468 host if set, mark addrs as having used this host
469 smtp_greeting from peer
470 helo_response from peer
471 start points to timestamp of delivery start
473 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
474 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
475 this particular type of timeout.
481 set_errno(address_item
*addrlist
, int errno_value
, uschar
*msg
, int rc
,
482 BOOL pass_message
, host_item
* host
,
483 #ifdef EXPERIMENTAL_DSN_INFO
484 const uschar
* smtp_greeting
, const uschar
* helo_response
,
486 struct timeval
* start
490 struct timeval deliver_time
;
492 if (errno_value
== ERRNO_CONNECTTIMEOUT
)
494 errno_value
= ETIMEDOUT
;
495 orvalue
= RTEF_CTOUT
;
497 timesince(&deliver_time
, start
);
499 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
500 if (addr
->transport_return
>= PENDING
)
502 addr
->basic_errno
= errno_value
;
503 addr
->more_errno
|= orvalue
;
504 addr
->delivery_time
= deliver_time
;
508 if (pass_message
) setflag(addr
, af_pass_message
);
510 addr
->transport_return
= rc
;
513 addr
->host_used
= host
;
514 #ifdef EXPERIMENTAL_DSN_INFO
516 {uschar
* s
= Ustrchr(smtp_greeting
, '\n'); if (s
) *s
= '\0';}
517 addr
->smtp_greeting
= smtp_greeting
;
520 {uschar
* s
= Ustrchr(helo_response
, '\n'); if (s
) *s
= '\0';}
521 addr
->helo_response
= helo_response
;
528 set_errno_nohost(address_item
* addrlist
, int errno_value
, uschar
* msg
, int rc
,
529 BOOL pass_message
, struct timeval
* start
)
531 set_errno(addrlist
, errno_value
, msg
, rc
, pass_message
, NULL
,
532 #ifdef EXPERIMENTAL_DSN_INFO
539 /*************************************************
540 * Check an SMTP response *
541 *************************************************/
543 /* This function is given an errno code and the SMTP response buffer
544 to analyse, together with the host identification for generating messages. It
545 sets an appropriate message and puts the first digit of the response code into
546 the yield variable. If no response was actually read, a suitable digit is
550 host the current host, to get its name for messages
551 errno_value pointer to the errno value
552 more_errno from the top address for use with ERRNO_FILTER_FAIL
553 buffer the SMTP response buffer
554 yield where to put a one-digit SMTP response code
555 message where to put an error message
556 pass_message set TRUE if message is an SMTP response
558 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
562 check_response(host_item
*host
, int *errno_value
, int more_errno
,
563 uschar
*buffer
, int *yield
, uschar
**message
, BOOL
*pass_message
)
565 uschar
* pl
= pipelining_active ? US
"pipelined " : US
"";
568 *yield
= '4'; /* Default setting is to give a temporary error */
572 case ETIMEDOUT
: /* Handle response timeout */
573 *message
= US
string_sprintf("SMTP timeout after %s%s",
575 if (transport_count
> 0)
576 *message
= US
string_sprintf("%s (%d bytes written)", *message
,
580 case ERRNO_SMTPFORMAT
: /* Handle malformed SMTP response */
581 s
= string_printing(buffer
);
582 while (isspace(*s
)) s
++;
584 ?
string_sprintf("Malformed SMTP reply (an empty line) "
585 "in response to %s%s", pl
, smtp_command
)
586 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
587 pl
, smtp_command
, s
);
590 case ERRNO_TLSFAILURE
: /* Handle bad first read; can happen with
592 *message
= US
"bad first read from TLS conn";
595 case ERRNO_FILTER_FAIL
: /* Handle a failed filter process error;
596 can't send QUIT as we mustn't end the DATA. */
597 *message
= string_sprintf("transport filter process failed (%d)%s",
599 more_errno
== EX_EXECFAILED ?
": unable to execute command" : "");
602 case ERRNO_CHHEADER_FAIL
: /* Handle a failed add_headers expansion;
603 can't send QUIT as we mustn't end the DATA. */
605 string_sprintf("failed to expand headers_add or headers_remove: %s",
606 expand_string_message
);
609 case ERRNO_WRITEINCOMPLETE
: /* failure to write a complete data block */
610 *message
= US
"failed to write a data block";
614 case ERRNO_UTF8_FWD
: /* no advertised SMTPUTF8, for international message */
615 *message
= US
"utf8 support required but not offered for forwarding";
616 DEBUG(D_deliver
|D_transport
) debug_printf("%s\n", *message
);
621 /* Handle error responses from the remote mailer. */
625 *message
= string_sprintf("SMTP error from remote mail server after %s%s: "
626 "%s", pl
, smtp_command
, s
= string_printing(buffer
));
627 *pass_message
= TRUE
;
632 /* No data was read. If there is no errno, this must be the EOF (i.e.
633 connection closed) case, which causes deferral. An explicit connection reset
634 error has the same effect. Otherwise, put the host's identity in the message,
635 leaving the errno value to be interpreted as well. In all cases, we have to
636 assume the connection is now dead. */
638 if (*errno_value
== 0 || *errno_value
== ECONNRESET
)
640 *errno_value
= ERRNO_SMTPCLOSED
;
641 *message
= US
string_sprintf("Remote host closed connection "
642 "in response to %s%s", pl
, smtp_command
);
645 *message
= US
string_sprintf("%s [%s]", host
->name
, host
->address
);
652 /*************************************************
653 * Write error message to logs *
654 *************************************************/
656 /* This writes to the main log and to the message log.
659 host the current host
660 detail the current message (addr_item->message)
661 basic_errno the errno (addr_item->basic_errno)
667 write_logs(const host_item
*host
, const uschar
*suffix
, int basic_errno
)
669 gstring
* message
= LOGGING(outgoing_port
)
670 ?
string_fmt_append(NULL
, "H=%s [%s]:%d", host
->name
, host
->address
,
671 host
->port
== PORT_NONE ?
25 : host
->port
)
672 : string_fmt_append(NULL
, "H=%s [%s]", host
->name
, host
->address
);
676 message
= string_fmt_append(message
, ": %s", suffix
);
678 message
= string_fmt_append(message
, ": %s", strerror(basic_errno
));
681 message
= string_fmt_append(message
, " %s", exim_errstr(basic_errno
));
683 log_write(0, LOG_MAIN
, "%s", string_from_gstring(message
));
684 deliver_msglog("%s %s\n", tod_stamp(tod_log
), message
->s
);
688 msglog_line(host_item
* host
, uschar
* message
)
690 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log
),
691 host
->name
, host
->address
, message
);
696 #ifndef DISABLE_EVENT
697 /*************************************************
698 * Post-defer action *
699 *************************************************/
701 /* This expands an arbitrary per-transport string.
702 It might, for example, be used to write to the database log.
705 addr the address item containing error information
706 host the current host
713 deferred_event_raise(address_item
* addr
, host_item
* host
, uschar
* evstr
)
715 uschar
* action
= addr
->transport
->event_action
;
716 const uschar
* save_domain
;
722 save_domain
= deliver_domain
;
723 save_local
= deliver_localpart
;
725 /*XXX would ip & port already be set up? */
726 deliver_host_address
= string_copy(host
->address
);
727 deliver_host_port
= host
->port
== PORT_NONE ?
25 : host
->port
;
728 event_defer_errno
= addr
->basic_errno
;
730 router_name
= addr
->router
->name
;
731 transport_name
= addr
->transport
->name
;
732 deliver_domain
= addr
->domain
;
733 deliver_localpart
= addr
->local_part
;
735 (void) event_raise(action
, evstr
,
737 ? addr
->basic_errno
> 0
738 ?
string_sprintf("%s: %s", addr
->message
, strerror(addr
->basic_errno
))
739 : string_copy(addr
->message
)
740 : addr
->basic_errno
> 0
741 ?
string_copy(US
strerror(addr
->basic_errno
))
744 deliver_localpart
= save_local
;
745 deliver_domain
= save_domain
;
746 router_name
= transport_name
= NULL
;
750 /*************************************************
751 * Reap SMTP specific responses *
752 *************************************************/
754 smtp_discard_responses(smtp_context
* sx
, smtp_transport_options_block
* ob
,
757 uschar flushbuffer
[4096];
761 if (!smtp_read_response(sx
, flushbuffer
, sizeof(flushbuffer
),
762 '2', ob
->command_timeout
)
763 && (errno
!= 0 || flushbuffer
[0] == 0))
770 /* Return boolean success */
773 smtp_reap_banner(smtp_context
* sx
)
775 BOOL good_response
= smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
776 '2', (SOB sx
->conn_args
.ob
)->command_timeout
);
777 #ifdef EXPERIMENTAL_DSN_INFO
778 sx
->smtp_greeting
= string_copy(sx
->buffer
);
780 return good_response
;
784 smtp_reap_ehlo(smtp_context
* sx
)
786 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
787 (SOB sx
->conn_args
.ob
)->command_timeout
))
789 if (errno
!= 0 || sx
->buffer
[0] == 0 || sx
->lmtp
)
791 #ifdef EXPERIMENTAL_DSN_INFO
792 sx
->helo_response
= string_copy(sx
->buffer
);
798 #ifdef EXPERIMENTAL_DSN_INFO
799 sx
->helo_response
= string_copy(sx
->buffer
);
801 #ifndef DISABLE_EVENT
802 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
803 US
"smtp:ehlo", sx
->buffer
);
810 #ifndef DISABLE_PIPE_CONNECT
812 ehlo_cache_key(const smtp_context
* sx
)
814 host_item
* host
= sx
->conn_args
.host
;
815 return Ustrchr(host
->address
, ':')
816 ?
string_sprintf("[%s]:%d.EHLO", host
->address
,
817 host
->port
== PORT_NONE ? sx
->port
: host
->port
)
818 : string_sprintf("%s:%d.EHLO", host
->address
,
819 host
->port
== PORT_NONE ? sx
->port
: host
->port
);
823 write_ehlo_cache_entry(const smtp_context
* sx
)
825 open_db dbblock
, * dbm_file
;
827 if ((dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
829 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
830 dbdata_ehlo_resp er
= { .data
= sx
->ehlo_resp
};
832 HDEBUG(D_transport
) debug_printf("writing clr %04x/%04x cry %04x/%04x\n",
833 sx
->ehlo_resp
.cleartext_features
, sx
->ehlo_resp
.cleartext_auths
,
834 sx
->ehlo_resp
.crypted_features
, sx
->ehlo_resp
.crypted_auths
);
836 dbfn_write(dbm_file
, ehlo_resp_key
, &er
, (int)sizeof(er
));
837 dbfn_close(dbm_file
);
842 invalidate_ehlo_cache_entry(smtp_context
* sx
)
844 open_db dbblock
, * dbm_file
;
846 if ( sx
->early_pipe_active
847 && (dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
849 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
850 dbfn_delete(dbm_file
, ehlo_resp_key
);
851 dbfn_close(dbm_file
);
856 read_ehlo_cache_entry(smtp_context
* sx
)
861 if (!(dbm_file
= dbfn_open(US
"misc", O_RDONLY
, &dbblock
, FALSE
, TRUE
)))
862 { DEBUG(D_transport
) debug_printf("ehlo-cache: no misc DB\n"); }
865 uschar
* ehlo_resp_key
= ehlo_cache_key(sx
);
866 dbdata_ehlo_resp
* er
;
868 if (!(er
= dbfn_read(dbm_file
, ehlo_resp_key
)))
869 { DEBUG(D_transport
) debug_printf("no ehlo-resp record\n"); }
870 else if (time(NULL
) - er
->time_stamp
> retry_data_expire
)
872 DEBUG(D_transport
) debug_printf("ehlo-resp record too old\n");
873 dbfn_close(dbm_file
);
874 if ((dbm_file
= dbfn_open(US
"misc", O_RDWR
, &dbblock
, TRUE
, TRUE
)))
875 dbfn_delete(dbm_file
, ehlo_resp_key
);
879 sx
->ehlo_resp
= er
->data
;
880 dbfn_close(dbm_file
);
881 DEBUG(D_transport
) debug_printf(
882 "EHLO response bits from cache: cleartext 0x%04x/0x%04x crypted 0x%04x/0x%04x\n",
883 er
->data
.cleartext_features
, er
->data
.cleartext_auths
,
884 er
->data
.crypted_features
, er
->data
.crypted_auths
);
887 dbfn_close(dbm_file
);
894 /* Return an auths bitmap for the set of AUTH methods offered by the server
895 which match our authenticators. */
897 static unsigned short
898 study_ehlo_auths(smtp_context
* sx
)
903 unsigned short authbits
= 0;
905 if (!sx
->esmtp
) return 0;
906 if (!regex_AUTH
) regex_AUTH
= regex_must_compile(AUTHS_REGEX
, FALSE
, TRUE
);
907 if (!regex_match_and_setup(regex_AUTH
, sx
->buffer
, 0, -1)) return 0;
908 expand_nmax
= -1; /* reset */
909 names
= string_copyn(expand_nstring
[1], expand_nlength
[1]);
911 for (au
= auths
, authnum
= 0; au
; au
= au
->next
, authnum
++) if (au
->client
)
913 const uschar
* list
= names
;
917 while (string_nextinlist(&list
, &sep
, name
, sizeof(name
)))
918 if (strcmpic(au
->public_name
, name
) == 0)
919 { authbits
|= BIT(authnum
); break; }
923 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
924 tls_out
.active
.sock
>= 0 ?
"crypted" : "plaintext", names
, authbits
);
926 if (tls_out
.active
.sock
>= 0)
927 sx
->ehlo_resp
.crypted_auths
= authbits
;
929 sx
->ehlo_resp
.cleartext_auths
= authbits
;
936 /* Wait for and check responses for early-pipelining.
938 Called from the lower-level smtp_read_response() function
939 used for general code that assume synchronisation, if context
940 flags indicate outstanding early-pipelining commands. Also
941 called fom sync_responses() which handles pipelined commands.
944 sx smtp connection context
945 countp number of outstanding responses, adjusted on return
949 DEFER error on first read of TLS'd conn
950 FAIL SMTP error in response
953 smtp_reap_early_pipe(smtp_context
* sx
, int * countp
)
955 BOOL pending_BANNER
= sx
->pending_BANNER
;
956 BOOL pending_EHLO
= sx
->pending_EHLO
;
959 sx
->pending_BANNER
= FALSE
; /* clear early to avoid recursion */
960 sx
->pending_EHLO
= FALSE
;
964 DEBUG(D_transport
) debug_printf("%s expect banner\n", __FUNCTION__
);
966 if (!smtp_reap_banner(sx
))
968 DEBUG(D_transport
) debug_printf("bad banner\n");
969 if (tls_out
.active
.sock
>= 0) rc
= DEFER
;
976 unsigned peer_offered
;
977 unsigned short authbits
= 0, * ap
;
979 DEBUG(D_transport
) debug_printf("%s expect ehlo\n", __FUNCTION__
);
981 if (!smtp_reap_ehlo(sx
))
983 DEBUG(D_transport
) debug_printf("bad response for EHLO\n");
984 if (tls_out
.active
.sock
>= 0) rc
= DEFER
;
988 /* Compare the actual EHLO response to the cached value we assumed;
989 on difference, dump or rewrite the cache and arrange for a retry. */
991 ap
= tls_out
.active
.sock
< 0
992 ?
&sx
->ehlo_resp
.cleartext_auths
: &sx
->ehlo_resp
.crypted_auths
;
994 peer_offered
= ehlo_response(sx
->buffer
,
995 (tls_out
.active
.sock
< 0 ? OPTION_TLS
: 0)
996 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
997 | OPTION_UTF8
| OPTION_EARLY_PIPE
999 if ( peer_offered
!= sx
->peer_offered
1000 || (authbits
= study_ehlo_auths(sx
)) != *ap
)
1003 debug_printf("EHLO %s extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
1004 tls_out
.active
.sock
< 0 ?
"cleartext" : "crypted",
1005 sx
->peer_offered
, *ap
, peer_offered
, authbits
);
1006 *(tls_out
.active
.sock
< 0
1007 ?
&sx
->ehlo_resp
.cleartext_features
: &sx
->ehlo_resp
.crypted_features
) = peer_offered
;
1009 if (peer_offered
& OPTION_EARLY_PIPE
)
1010 write_ehlo_cache_entry(sx
);
1012 invalidate_ehlo_cache_entry(sx
);
1014 return OK
; /* just carry on */
1020 invalidate_ehlo_cache_entry(sx
);
1021 (void) smtp_discard_responses(sx
, sx
->conn_args
.ob
, *countp
);
1027 /*************************************************
1028 * Synchronize SMTP responses *
1029 *************************************************/
1031 /* This function is called from smtp_deliver() to receive SMTP responses from
1032 the server, and match them up with the commands to which they relate. When
1033 PIPELINING is not in use, this function is called after every command, and is
1034 therefore somewhat over-engineered, but it is simpler to use a single scheme
1035 that works both with and without PIPELINING instead of having two separate sets
1038 The set of commands that are buffered up with pipelining may start with MAIL
1039 and may end with DATA; in between are RCPT commands that correspond to the
1040 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1041 etc.) are never buffered.
1043 Errors after MAIL or DATA abort the whole process leaving the response in the
1044 buffer. After MAIL, pending responses are flushed, and the original command is
1045 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1046 permitted to reject some recipient addresses while accepting others. However
1047 certain errors clearly abort the whole process. Set the value in
1048 transport_return to PENDING_OK if the address is accepted. If there is a
1049 subsequent general error, it will get reset accordingly. If not, it will get
1050 converted to OK at the end.
1053 sx smtp connection context
1054 count the number of responses to read
1055 pending_DATA 0 if last command sent was not DATA
1056 +1 if previously had a good recipient
1057 -1 if not previously had a good recipient
1059 Returns: 3 if at least one address had 2xx and one had 5xx
1060 2 if at least one address had 5xx but none had 2xx
1061 1 if at least one host had a 2xx response, but none had 5xx
1062 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1063 -1 timeout while reading RCPT response
1064 -2 I/O or other non-response error for RCPT
1065 -3 DATA or MAIL failed - errno and buffer set
1066 -4 banner or EHLO failed (early-pipelining)
1067 -5 banner or EHLO failed (early-pipelining, TLS)
1071 sync_responses(smtp_context
* sx
, int count
, int pending_DATA
)
1073 address_item
* addr
= sx
->sync_addr
;
1074 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
;
1077 #ifndef DISABLE_PIPE_CONNECT
1079 if ((rc
= smtp_reap_early_pipe(sx
, &count
)) != OK
)
1080 return rc
== FAIL ?
-4 : -5;
1083 /* Handle the response for a MAIL command. On error, reinstate the original
1084 command in big_buffer for error message use, and flush any further pending
1085 responses before returning, except after I/O errors and timeouts. */
1087 if (sx
->pending_MAIL
)
1089 DEBUG(D_transport
) debug_printf("%s expect mail\n", __FUNCTION__
);
1091 sx
->pending_MAIL
= FALSE
;
1092 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1093 '2', ob
->command_timeout
))
1095 DEBUG(D_transport
) debug_printf("bad response for MAIL\n");
1096 Ustrcpy(big_buffer
, mail_command
); /* Fits, because it came from there! */
1097 if (errno
== ERRNO_TLSFAILURE
)
1099 if (errno
== 0 && sx
->buffer
[0] != 0)
1102 if (sx
->buffer
[0] == '4')
1104 save_errno
= ERRNO_MAIL4XX
;
1105 addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1107 count
= smtp_discard_responses(sx
, ob
, count
);
1111 if (pending_DATA
) count
--; /* Number of RCPT responses to come */
1112 while (count
-- > 0) /* Mark any pending addrs with the host used */
1114 while (addr
->transport_return
!= PENDING_DEFER
) addr
= addr
->next
;
1115 addr
->host_used
= sx
->conn_args
.host
;
1122 if (pending_DATA
) count
--; /* Number of RCPT responses to come */
1124 /* Read and handle the required number of RCPT responses, matching each one up
1125 with an address by scanning for the next address whose status is PENDING_DEFER.
1130 while (addr
->transport_return
!= PENDING_DEFER
)
1131 if (!(addr
= addr
->next
))
1134 /* The address was accepted */
1135 addr
->host_used
= sx
->conn_args
.host
;
1137 DEBUG(D_transport
) debug_printf("%s expect rcpt\n", __FUNCTION__
);
1138 if (smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1139 '2', ob
->command_timeout
))
1142 addr
->transport_return
= PENDING_OK
;
1144 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1145 ensure that any address-specific retry record is expunged. We do this both
1146 for the basic key and for the version that also includes the sender. */
1148 if (testflag(addr
, af_dr_retry_exists
))
1150 uschar
*altkey
= string_sprintf("%s:<%s>", addr
->address_retry_key
,
1152 retry_add_item(addr
, altkey
, rf_delete
);
1153 retry_add_item(addr
, addr
->address_retry_key
, rf_delete
);
1157 /* Error on first TLS read */
1159 else if (errno
== ERRNO_TLSFAILURE
)
1162 /* Timeout while reading the response */
1164 else if (errno
== ETIMEDOUT
)
1166 uschar
*message
= string_sprintf("SMTP timeout after RCPT TO:<%s>",
1167 transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
));
1168 set_errno_nohost(sx
->first_addr
, ETIMEDOUT
, message
, DEFER
, FALSE
, &sx
->delivery_start
);
1169 retry_add_item(addr
, addr
->address_retry_key
, 0);
1170 update_waiting
= FALSE
;
1174 /* Handle other errors in obtaining an SMTP response by returning -1. This
1175 will cause all the addresses to be deferred. Restore the SMTP command in
1176 big_buffer for which we are checking the response, so the error message
1179 else if (errno
!= 0 || sx
->buffer
[0] == 0)
1181 gstring gs
= { .size
= big_buffer_size
, .ptr
= 0, .s
= big_buffer
}, * g
= &gs
;
1183 /* Use taint-unchecked routines for writing into big_buffer, trusting
1184 that we'll never expand it. */
1186 g
= string_fmt_append_f(g
, SVFMT_TAINT_NOCHK
, "RCPT TO:<%s>",
1187 transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
));
1188 string_from_gstring(g
);
1192 /* Handle SMTP permanent and temporary response codes. */
1197 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1198 "%s", transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
),
1199 string_printing(sx
->buffer
));
1200 setflag(addr
, af_pass_message
);
1202 msglog_line(sx
->conn_args
.host
, addr
->message
);
1204 /* The response was 5xx */
1206 if (sx
->buffer
[0] == '5')
1208 addr
->transport_return
= FAIL
;
1212 /* The response was 4xx */
1216 addr
->transport_return
= DEFER
;
1217 addr
->basic_errno
= ERRNO_RCPT4XX
;
1218 addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1222 #ifndef DISABLE_EVENT
1223 event_defer_errno
= addr
->more_errno
;
1224 msg_event_raise(US
"msg:rcpt:host:defer", addr
);
1226 /* If a 452 and we've had at least one 2xx or 5xx, set next_addr to the
1227 start point for another MAIL command. */
1229 if (addr
->more_errno
>> 8 == 52 && yield
& 3)
1234 debug_printf("%s: seen first 452 too-many-rcpts\n", __FUNCTION__
);
1235 sx
->RCPT_452
= TRUE
;
1236 sx
->next_addr
= addr
;
1238 addr
->transport_return
= PENDING_DEFER
;
1239 addr
->basic_errno
= 0;
1243 /* Log temporary errors if there are more hosts to be tried.
1244 If not, log this last one in the == line. */
1246 if (sx
->conn_args
.host
->next
)
1247 if (LOGGING(outgoing_port
))
1248 log_write(0, LOG_MAIN
, "H=%s [%s]:%d %s", sx
->conn_args
.host
->name
,
1249 sx
->conn_args
.host
->address
,
1250 sx
->port
== PORT_NONE ?
25 : sx
->port
, addr
->message
);
1252 log_write(0, LOG_MAIN
, "H=%s [%s]: %s", sx
->conn_args
.host
->name
,
1253 sx
->conn_args
.host
->address
, addr
->message
);
1255 #ifndef DISABLE_EVENT
1257 msg_event_raise(US
"msg:rcpt:defer", addr
);
1260 /* Do not put this message on the list of those waiting for specific
1261 hosts, as otherwise it is likely to be tried too often. */
1263 update_waiting
= FALSE
;
1265 /* Add a retry item for the address so that it doesn't get tried again
1266 too soon. If address_retry_include_sender is true, add the sender address
1267 to the retry key. */
1269 retry_add_item(addr
,
1270 ob
->address_retry_include_sender
1271 ?
string_sprintf("%s:<%s>", addr
->address_retry_key
, sender_address
)
1272 : addr
->address_retry_key
,
1278 } /* Loop for next RCPT response */
1280 /* Update where to start at for the next block of responses, unless we
1281 have already handled all the addresses. */
1283 if (addr
) sx
->sync_addr
= addr
->next
;
1285 /* Handle a response to DATA. If we have not had any good recipients, either
1286 previously or in this block, the response is ignored. */
1288 if (pending_DATA
!= 0)
1290 DEBUG(D_transport
) debug_printf("%s expect data\n", __FUNCTION__
);
1291 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
),
1292 '3', ob
->command_timeout
))
1298 if (errno
== ERRNO_TLSFAILURE
) /* Error on first TLS read */
1301 if (pending_DATA
> 0 || (yield
& 1) != 0)
1303 if (errno
== 0 && sx
->buffer
[0] == '4')
1305 errno
= ERRNO_DATA4XX
;
1306 sx
->first_addr
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1310 (void)check_response(sx
->conn_args
.host
, &errno
, 0, sx
->buffer
, &code
, &msg
, &pass_message
);
1311 DEBUG(D_transport
) debug_printf("%s\nerror for DATA ignored: pipelining "
1312 "is in use and there were no good recipients\n", msg
);
1316 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1317 present) received 3xx. If any RCPTs were handled and yielded anything other
1318 than 4xx, yield will be set non-zero. */
1327 /* Try an authenticator's client entry */
1330 try_authenticator(smtp_context
* sx
, auth_instance
* au
)
1332 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
; /* transport options */
1333 host_item
* host
= sx
->conn_args
.host
; /* host to deliver to */
1336 sx
->outblock
.authenticating
= TRUE
;
1337 rc
= (au
->info
->clientcode
)(au
, sx
, ob
->command_timeout
,
1338 sx
->buffer
, sizeof(sx
->buffer
));
1339 sx
->outblock
.authenticating
= FALSE
;
1340 DEBUG(D_transport
) debug_printf("%s authenticator yielded %d\n", au
->name
, rc
);
1342 /* A temporary authentication failure must hold up delivery to
1343 this host. After a permanent authentication failure, we carry on
1344 to try other authentication methods. If all fail hard, try to
1345 deliver the message unauthenticated unless require_auth was set. */
1350 f
.smtp_authenticated
= TRUE
; /* stops the outer loop */
1351 client_authenticator
= au
->name
;
1352 if (au
->set_client_id
)
1353 client_authenticated_id
= expand_string(au
->set_client_id
);
1356 /* Failure after writing a command */
1361 /* Failure after reading a response */
1364 if (errno
!= 0 || sx
->buffer
[0] != '5') return FAIL
;
1365 log_write(0, LOG_MAIN
, "%s authenticator failed H=%s [%s] %s",
1366 au
->name
, host
->name
, host
->address
, sx
->buffer
);
1369 /* Failure by some other means. In effect, the authenticator
1370 decided it wasn't prepared to handle this case. Typically this
1371 is the result of "fail" in an expansion string. Do we need to
1372 log anything here? Feb 2006: a message is now put in the buffer
1373 if logging is required. */
1376 if (*sx
->buffer
!= 0)
1377 log_write(0, LOG_MAIN
, "%s authenticator cancelled "
1378 "authentication H=%s [%s] %s", au
->name
, host
->name
,
1379 host
->address
, sx
->buffer
);
1382 /* Internal problem, message in buffer. */
1385 set_errno_nohost(sx
->addrlist
, ERRNO_AUTHPROB
, string_copy(sx
->buffer
),
1386 DEFER
, FALSE
, &sx
->delivery_start
);
1395 /* Do the client side of smtp-level authentication.
1398 sx smtp connection context
1400 sx->buffer should have the EHLO response from server (gets overwritten)
1403 OK Success, or failed (but not required): global "smtp_authenticated" set
1404 DEFER Failed authentication (and was required)
1405 ERROR Internal problem
1407 FAIL_SEND Failed communications - transmit
1412 smtp_auth(smtp_context
* sx
)
1414 host_item
* host
= sx
->conn_args
.host
; /* host to deliver to */
1415 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
; /* transport options */
1416 int require_auth
= verify_check_given_host(CUSS
&ob
->hosts_require_auth
, host
);
1417 #ifndef DISABLE_PIPE_CONNECT
1418 unsigned short authbits
= tls_out
.active
.sock
>= 0
1419 ? sx
->ehlo_resp
.crypted_auths
: sx
->ehlo_resp
.cleartext_auths
;
1421 uschar
* fail_reason
= US
"server did not advertise AUTH support";
1423 f
.smtp_authenticated
= FALSE
;
1424 client_authenticator
= client_authenticated_id
= client_authenticated_sender
= NULL
;
1427 regex_AUTH
= regex_must_compile(AUTHS_REGEX
, FALSE
, TRUE
);
1429 /* Is the server offering AUTH? */
1433 #ifndef DISABLE_PIPE_CONNECT
1434 sx
->early_pipe_active ? authbits
1437 regex_match_and_setup(regex_AUTH
, sx
->buffer
, 0, -1)
1440 uschar
* names
= NULL
;
1441 expand_nmax
= -1; /* reset */
1443 #ifndef DISABLE_PIPE_CONNECT
1444 if (!sx
->early_pipe_active
)
1446 names
= string_copyn(expand_nstring
[1], expand_nlength
[1]);
1448 /* Must not do this check until after we have saved the result of the
1449 regex match above as the check could be another RE. */
1451 if ( require_auth
== OK
1452 || verify_check_given_host(CUSS
&ob
->hosts_try_auth
, host
) == OK
)
1454 DEBUG(D_transport
) debug_printf("scanning authentication mechanisms\n");
1455 fail_reason
= US
"no common mechanisms were found";
1457 #ifndef DISABLE_PIPE_CONNECT
1458 if (sx
->early_pipe_active
)
1460 /* Scan our authenticators (which support use by a client and were offered
1461 by the server (checked at cache-write time)), not suppressed by
1462 client_condition. If one is found, attempt to authenticate by calling its
1463 client function. We are limited to supporting up to 16 authenticator
1464 public-names by the number of bits in a short. */
1470 for (bitnum
= 0, au
= auths
;
1471 !f
.smtp_authenticated
&& au
&& bitnum
< 16;
1472 bitnum
++, au
= au
->next
) if (authbits
& BIT(bitnum
))
1474 if ( au
->client_condition
1475 && !expand_check_condition(au
->client_condition
, au
->name
,
1476 US
"client authenticator"))
1478 DEBUG(D_transport
) debug_printf("skipping %s authenticator: %s\n",
1479 au
->name
, "client_condition is false");
1483 /* Found data for a listed mechanism. Call its client entry. Set
1484 a flag in the outblock so that data is overwritten after sending so
1485 that reflections don't show it. */
1487 fail_reason
= US
"authentication attempt(s) failed";
1489 if ((rc
= try_authenticator(sx
, au
)) != OK
)
1496 /* Scan the configured authenticators looking for one which is configured
1497 for use as a client, which is not suppressed by client_condition, and
1498 whose name matches an authentication mechanism supported by the server.
1499 If one is found, attempt to authenticate by calling its client function.
1502 for (auth_instance
* au
= auths
; !f
.smtp_authenticated
&& au
; au
= au
->next
)
1507 || ( au
->client_condition
1508 && !expand_check_condition(au
->client_condition
, au
->name
,
1509 US
"client authenticator")))
1511 DEBUG(D_transport
) debug_printf("skipping %s authenticator: %s\n",
1513 (au
->client
)?
"client_condition is false" :
1514 "not configured as a client");
1518 /* Loop to scan supported server mechanisms */
1522 int len
= Ustrlen(au
->public_name
);
1525 while (isspace(*p
)) p
++;
1527 if (strncmpic(au
->public_name
, p
, len
) != 0 ||
1528 (p
[len
] != 0 && !isspace(p
[len
])))
1530 while (*p
!= 0 && !isspace(*p
)) p
++;
1534 /* Found data for a listed mechanism. Call its client entry. Set
1535 a flag in the outblock so that data is overwritten after sending so
1536 that reflections don't show it. */
1538 fail_reason
= US
"authentication attempt(s) failed";
1540 if ((rc
= try_authenticator(sx
, au
)) != OK
)
1543 break; /* If not authenticated, try next authenticator */
1544 } /* Loop for scanning supported server mechanisms */
1545 } /* Loop for further authenticators */
1549 /* If we haven't authenticated, but are required to, give up. */
1551 if (require_auth
== OK
&& !f
.smtp_authenticated
)
1553 set_errno_nohost(sx
->addrlist
, ERRNO_AUTHFAIL
,
1554 string_sprintf("authentication required but %s", fail_reason
), DEFER
,
1555 FALSE
, &sx
->delivery_start
);
1563 /* Construct AUTH appendix string for MAIL TO */
1566 sx context for smtp connection
1567 p point in sx->buffer to build string
1568 addrlist chain of potential addresses to deliver
1570 Globals f.smtp_authenticated
1571 client_authenticated_sender
1572 Return True on error, otherwise buffer has (possibly empty) terminated string
1576 smtp_mail_auth_str(smtp_context
* sx
, uschar
* p
, address_item
* addrlist
)
1578 smtp_transport_options_block
* ob
= sx
->conn_args
.ob
;
1579 uschar
* local_authenticated_sender
= authenticated_sender
;
1582 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n",
1583 authenticated_sender
, ob
->authenticated_sender
, f
.smtp_authenticated?
"Y":"N");
1586 if (ob
->authenticated_sender
)
1588 uschar
* new = expand_string(ob
->authenticated_sender
);
1591 if (!f
.expand_string_forcedfail
)
1593 uschar
*message
= string_sprintf("failed to expand "
1594 "authenticated_sender: %s", expand_string_message
);
1595 set_errno_nohost(addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
, &sx
->delivery_start
);
1600 local_authenticated_sender
= new;
1603 /* Add the authenticated sender address if present */
1605 if ( (f
.smtp_authenticated
|| ob
->authenticated_sender_force
)
1606 && local_authenticated_sender
)
1608 string_format_nt(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), " AUTH=%s",
1609 auth_xtextencode(local_authenticated_sender
,
1610 Ustrlen(local_authenticated_sender
)));
1611 client_authenticated_sender
= string_copy(local_authenticated_sender
);
1621 typedef struct smtp_compare_s
1623 uschar
*current_sender_address
;
1624 struct transport_instance
*tblock
;
1628 /* Create a unique string that identifies this message, it is based on
1629 sender_address, helo_data and tls_certificate if enabled.
1633 smtp_local_identity(uschar
* sender
, struct transport_instance
* tblock
)
1635 address_item
* addr1
;
1636 uschar
* if1
= US
"";
1637 uschar
* helo1
= US
"";
1639 uschar
* tlsc1
= US
"";
1641 uschar
* save_sender_address
= sender_address
;
1642 uschar
* local_identity
= NULL
;
1643 smtp_transport_options_block
* ob
= SOB tblock
->options_block
;
1645 sender_address
= sender
;
1647 addr1
= deliver_make_addr (sender
, TRUE
);
1648 deliver_set_expansions(addr1
);
1651 if1
= expand_string(ob
->interface
);
1654 helo1
= expand_string(ob
->helo_data
);
1657 if (ob
->tls_certificate
)
1658 tlsc1
= expand_string(ob
->tls_certificate
);
1659 local_identity
= string_sprintf ("%s^%s^%s", if1
, helo1
, tlsc1
);
1661 local_identity
= string_sprintf ("%s^%s", if1
, helo1
);
1664 deliver_set_expansions(NULL
);
1665 sender_address
= save_sender_address
;
1667 return local_identity
;
1672 /* This routine is a callback that is called from transport_check_waiting.
1673 This function will evaluate the incoming message versus the previous
1674 message. If the incoming message is using a different local identity then
1675 we will veto this new message. */
1678 smtp_are_same_identities(uschar
* message_id
, smtp_compare_t
* s_compare
)
1680 uschar
* message_local_identity
,
1681 * current_local_identity
,
1682 * new_sender_address
;
1684 current_local_identity
=
1685 smtp_local_identity(s_compare
->current_sender_address
, s_compare
->tblock
);
1687 if (!(new_sender_address
= deliver_get_sender_address(message_id
)))
1690 message_local_identity
=
1691 smtp_local_identity(new_sender_address
, s_compare
->tblock
);
1693 return Ustrcmp(current_local_identity
, message_local_identity
) == 0;
1699 ehlo_response(uschar
* buf
, unsigned checks
)
1701 size_t bsize
= Ustrlen(buf
);
1703 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1706 if ( checks
& OPTION_TLS
1707 && pcre_exec(regex_STARTTLS
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1709 checks
&= ~OPTION_TLS
;
1711 if ( checks
& OPTION_IGNQ
1712 && pcre_exec(regex_IGNOREQUOTA
, NULL
, CS buf
, bsize
, 0,
1713 PCRE_EOPT
, NULL
, 0) < 0)
1714 checks
&= ~OPTION_IGNQ
;
1716 if ( checks
& OPTION_CHUNKING
1717 && pcre_exec(regex_CHUNKING
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1718 checks
&= ~OPTION_CHUNKING
;
1720 #ifndef DISABLE_PRDR
1721 if ( checks
& OPTION_PRDR
1722 && pcre_exec(regex_PRDR
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1724 checks
&= ~OPTION_PRDR
;
1727 if ( checks
& OPTION_UTF8
1728 && pcre_exec(regex_UTF8
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1730 checks
&= ~OPTION_UTF8
;
1732 if ( checks
& OPTION_DSN
1733 && pcre_exec(regex_DSN
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1734 checks
&= ~OPTION_DSN
;
1736 if ( checks
& OPTION_PIPE
1737 && pcre_exec(regex_PIPELINING
, NULL
, CS buf
, bsize
, 0,
1738 PCRE_EOPT
, NULL
, 0) < 0)
1739 checks
&= ~OPTION_PIPE
;
1741 if ( checks
& OPTION_SIZE
1742 && pcre_exec(regex_SIZE
, NULL
, CS buf
, bsize
, 0, PCRE_EOPT
, NULL
, 0) < 0)
1743 checks
&= ~OPTION_SIZE
;
1745 #ifndef DISABLE_PIPE_CONNECT
1746 if ( checks
& OPTION_EARLY_PIPE
1747 && pcre_exec(regex_EARLY_PIPE
, NULL
, CS buf
, bsize
, 0,
1748 PCRE_EOPT
, NULL
, 0) < 0)
1750 checks
&= ~OPTION_EARLY_PIPE
;
1752 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1758 /* Callback for emitting a BDAT data chunk header.
1760 If given a nonzero size, first flush any buffered SMTP commands
1761 then emit the command.
1763 Reap previous SMTP command responses if requested, and always reap
1764 the response from a previous BDAT command.
1767 tctx transport context
1768 chunk_size value for SMTP BDAT command
1770 tc_chunk_last add LAST option to SMTP BDAT command
1771 tc_reap_prev reap response to previous SMTP commands
1775 DEFER TLS error on first read (EHLO-resp); errno set
1779 smtp_chunk_cmd_callback(transport_ctx
* tctx
, unsigned chunk_size
,
1782 smtp_transport_options_block
* ob
= SOB tctx
->tblock
->options_block
;
1783 smtp_context
* sx
= tctx
->smtp_context
;
1787 /* Write SMTP chunk header command. If not reaping responses, note that
1788 there may be more writes (like, the chunk data) done soon. */
1792 #ifndef DISABLE_PIPE_CONNECT
1793 BOOL new_conn
= !!(sx
->outblock
.conn_args
);
1795 if((cmd_count
= smtp_write_command(sx
,
1796 flags
& tc_reap_prev ? SCMD_FLUSH
: SCMD_MORE
,
1797 "BDAT %u%s\r\n", chunk_size
, flags
& tc_chunk_last ?
" LAST" : "")
1798 ) < 0) return ERROR
;
1799 if (flags
& tc_chunk_last
)
1800 data_command
= string_copy(big_buffer
); /* Save for later error message */
1801 #ifndef DISABLE_PIPE_CONNECT
1802 /* That command write could have been the one that made the connection.
1803 Copy the fd from the client conn ctx (smtp transport specific) to the
1804 generic transport ctx. */
1807 tctx
->u
.fd
= sx
->outblock
.cctx
->sock
;
1811 prev_cmd_count
= cmd_count
+= sx
->cmd_count
;
1813 /* Reap responses for any previous, but not one we just emitted */
1817 if (sx
->pending_BDAT
)
1820 if (flags
& tc_reap_prev
&& prev_cmd_count
> 0)
1822 DEBUG(D_transport
) debug_printf("look for %d responses"
1823 " for previous pipelined cmds\n", prev_cmd_count
);
1825 switch(sync_responses(sx
, prev_cmd_count
, 0))
1827 case 1: /* 2xx (only) => OK */
1828 case 3: sx
->good_RCPT
= TRUE
; /* 2xx & 5xx => OK & progress made */
1829 case 2: sx
->completed_addr
= TRUE
; /* 5xx (only) => progress made */
1830 case 0: break; /* No 2xx or 5xx, but no probs */
1832 case -5: errno
= ERRNO_TLSFAILURE
;
1834 #ifndef DISABLE_PIPE_CONNECT
1835 case -4: /* non-2xx for pipelined banner or EHLO */
1837 case -1: /* Timeout on RCPT */
1838 default: return ERROR
; /* I/O error, or any MAIL/DATA error */
1841 if (!sx
->pending_BDAT
)
1842 pipelining_active
= FALSE
;
1845 /* Reap response for an outstanding BDAT */
1847 if (sx
->pending_BDAT
)
1849 DEBUG(D_transport
) debug_printf("look for one response for BDAT\n");
1851 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
1852 ob
->command_timeout
))
1854 if (errno
== 0 && sx
->buffer
[0] == '4')
1856 errno
= ERRNO_DATA4XX
; /*XXX does this actually get used? */
1857 sx
->addrlist
->more_errno
|=
1858 ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
1863 sx
->pending_BDAT
= FALSE
;
1864 pipelining_active
= FALSE
;
1866 else if (chunk_size
> 0)
1867 sx
->pending_BDAT
= TRUE
;
1870 sx
->cmd_count
= cmd_count
;
1878 /*************************************************
1879 * Make connection for given message *
1880 *************************************************/
1884 ctx connection context
1885 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1886 a second attempt after TLS initialization fails
1888 Returns: OK - the connection was made and the delivery attempted;
1889 fd is set in the conn context, tls_out set up.
1890 DEFER - the connection could not be made, or something failed
1891 while setting up the SMTP session, or there was a
1892 non-message-specific error, such as a timeout.
1893 ERROR - helo_data or add_headers or authenticated_sender is
1894 specified for this transport, and the string failed
1898 smtp_setup_conn(smtp_context
* sx
, BOOL suppress_tls
)
1900 smtp_transport_options_block
* ob
= sx
->conn_args
.tblock
->options_block
;
1901 BOOL pass_message
= FALSE
;
1902 uschar
* message
= NULL
;
1905 uschar
* tls_errstr
;
1908 sx
->conn_args
.ob
= ob
;
1910 sx
->lmtp
= strcmpic(ob
->protocol
, US
"lmtp") == 0;
1911 sx
->smtps
= strcmpic(ob
->protocol
, US
"smtps") == 0;
1912 /* sx->ok = FALSE; */
1913 sx
->send_rset
= TRUE
;
1914 sx
->send_quit
= TRUE
;
1915 sx
->setting_up
= TRUE
;
1917 /* sx->esmtp_sent = FALSE; */
1919 /* sx->utf8_needed = FALSE; */
1921 sx
->dsn_all_lasthop
= TRUE
;
1923 /* sx->conn_args.dane = FALSE; */
1925 verify_check_given_host(CUSS
&ob
->hosts_require_dane
, sx
->conn_args
.host
) == OK
;
1927 #ifndef DISABLE_PIPE_CONNECT
1928 /* sx->early_pipe_active = sx->early_pipe_ok = FALSE; */
1929 /* sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0; */
1930 /* sx->pending_BANNER = sx->pending_EHLO = sx->pending_MAIL = FALSE; */
1933 if ((sx
->max_rcpt
= sx
->conn_args
.tblock
->max_addresses
) == 0) sx
->max_rcpt
= 999999;
1934 /* sx->peer_offered = 0; */
1935 /* sx->avoid_option = 0; */
1936 sx
->igquotstr
= US
"";
1937 if (!sx
->helo_data
) sx
->helo_data
= ob
->helo_data
;
1938 #ifdef EXPERIMENTAL_DSN_INFO
1939 /* sx->smtp_greeting = NULL; */
1940 /* sx->helo_response = NULL; */
1943 smtp_command
= US
"initial connection";
1944 /* sx->buffer[0] = '\0'; */
1946 /* Set up the buffer for reading SMTP response packets. */
1948 sx
->inblock
.buffer
= sx
->inbuffer
;
1949 sx
->inblock
.buffersize
= sizeof(sx
->inbuffer
);
1950 sx
->inblock
.ptr
= sx
->inbuffer
;
1951 sx
->inblock
.ptrend
= sx
->inbuffer
;
1953 /* Set up the buffer for holding SMTP commands while pipelining */
1955 sx
->outblock
.buffer
= sx
->outbuffer
;
1956 sx
->outblock
.buffersize
= sizeof(sx
->outbuffer
);
1957 sx
->outblock
.ptr
= sx
->outbuffer
;
1958 /* sx->outblock.cmd_count = 0; */
1959 /* sx->outblock.authenticating = FALSE; */
1960 /* sx->outblock.conn_args = NULL; */
1962 /* Reset the parameters of a TLS session. */
1965 tls_out
.cipher
= NULL
; /* the one we may use for this transport */
1966 tls_out
.ourcert
= NULL
;
1967 tls_out
.peercert
= NULL
;
1968 tls_out
.peerdn
= NULL
;
1972 tls_out
.ocsp
= OCSP_NOT_REQ
;
1973 #ifdef EXPERIMENTAL_TLS_RESUME
1974 tls_out
.resumption
= 0;
1978 /* Flip the legacy TLS-related variables over to the outbound set in case
1979 they're used in the context of the transport. Don't bother resetting
1980 afterward (when being used by a transport) as we're in a subprocess.
1981 For verify, unflipped once the callout is dealt with */
1983 tls_modify_variables(&tls_out
);
1988 set_errno_nohost(sx
->addrlist
, ERRNO_TLSFAILURE
, US
"TLS support not available",
1989 DEFER
, FALSE
, &sx
->delivery_start
);
1994 /* Make a connection to the host if this isn't a continued delivery, and handle
1995 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
1996 specially so they can be identified for retries. */
1998 if (!continue_hostname
)
2001 HDEBUG(D_verify
) debug_printf("interface=%s port=%d\n", sx
->conn_args
.interface
, sx
->port
);
2003 /* Get the actual port the connection will use, into sx->conn_args.host */
2005 smtp_port_for_connect(sx
->conn_args
.host
, sx
->port
);
2008 /* Do TLSA lookup for DANE */
2010 tls_out
.dane_verified
= FALSE
;
2011 tls_out
.tlsa_usage
= 0;
2013 if (sx
->conn_args
.host
->dnssec
== DS_YES
)
2016 if( sx
->dane_required
2017 || verify_check_given_host(CUSS
&ob
->hosts_try_dane
, sx
->conn_args
.host
) == OK
2019 switch (rc
= tlsa_lookup(sx
->conn_args
.host
, &sx
->conn_args
.tlsa_dnsa
, sx
->dane_required
))
2021 case OK
: sx
->conn_args
.dane
= TRUE
;
2022 ob
->tls_tempfail_tryclear
= FALSE
;
2024 case FAIL_FORCED
: break;
2025 default: set_errno_nohost(sx
->addrlist
, ERRNO_DNSDEFER
,
2026 string_sprintf("DANE error: tlsa lookup %s",
2028 rc
, FALSE
, &sx
->delivery_start
);
2029 # ifndef DISABLE_EVENT
2030 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2031 US
"dane:fail", sx
->dane_required
2032 ? US
"dane-required" : US
"dnssec-invalid");
2037 else if (sx
->dane_required
)
2039 set_errno_nohost(sx
->addrlist
, ERRNO_DNSDEFER
,
2040 string_sprintf("DANE error: %s lookup not DNSSEC", sx
->conn_args
.host
->name
),
2041 FAIL
, FALSE
, &sx
->delivery_start
);
2042 # ifndef DISABLE_EVENT
2043 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2044 US
"dane:fail", US
"dane-required");
2051 /* Make the TCP connection */
2053 sx
->cctx
.tls_ctx
= NULL
;
2054 sx
->inblock
.cctx
= sx
->outblock
.cctx
= &sx
->cctx
;
2055 sx
->avoid_option
= sx
->peer_offered
= smtp_peer_options
= 0;
2057 #ifndef DISABLE_PIPE_CONNECT
2058 if ( verify_check_given_host(CUSS
&ob
->hosts_pipe_connect
,
2059 sx
->conn_args
.host
) == OK
)
2061 /* We don't find out the local ip address until the connect, so if
2062 the helo string might use it avoid doing early-pipelining. */
2065 || !Ustrstr(sx
->helo_data
, "$sending_ip_address")
2066 || Ustrstr(sx
->helo_data
, "def:sending_ip_address")
2069 sx
->early_pipe_ok
= TRUE
;
2070 if ( read_ehlo_cache_entry(sx
)
2071 && sx
->ehlo_resp
.cleartext_features
& OPTION_EARLY_PIPE
)
2074 debug_printf("Using cached cleartext PIPE_CONNECT\n");
2075 sx
->early_pipe_active
= TRUE
;
2076 sx
->peer_offered
= sx
->ehlo_resp
.cleartext_features
;
2079 else DEBUG(D_transport
)
2080 debug_printf("helo needs $sending_ip_address\n");
2083 if (sx
->early_pipe_active
)
2084 sx
->outblock
.conn_args
= &sx
->conn_args
;
2088 if ((sx
->cctx
.sock
= smtp_connect(&sx
->conn_args
, NULL
)) < 0)
2090 set_errno_nohost(sx
->addrlist
,
2091 errno
== ETIMEDOUT ? ERRNO_CONNECTTIMEOUT
: errno
,
2092 sx
->verify ? US
strerror(errno
) : NULL
,
2093 DEFER
, FALSE
, &sx
->delivery_start
);
2094 sx
->send_quit
= FALSE
;
2098 /* Expand the greeting message while waiting for the initial response. (Makes
2099 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2100 delayed till here so that $sending_interface and $sending_port are set. */
2101 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2102 will be? Somehow I doubt it. */
2105 if (!(sx
->helo_data
= expand_string(sx
->helo_data
)))
2107 log_write(0, LOG_MAIN
|LOG_PANIC
,
2108 "<%s>: failed to expand transport's helo_data value for callout: %s",
2109 sx
->addrlist
->address
, expand_string_message
);
2114 expand_string_message
= NULL
;
2115 if ((sx
->helo_data
= string_domain_utf8_to_alabel(sx
->helo_data
,
2116 &expand_string_message
)),
2117 expand_string_message
)
2119 log_write(0, LOG_MAIN
|LOG_PANIC
,
2120 "<%s>: failed to expand transport's helo_data value for callout: %s",
2121 sx
->addrlist
->address
, expand_string_message
);
2123 sx
->helo_data
= NULL
;
2127 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2128 is nevertheless a reasonably clean way of programming this kind of logic,
2129 where you want to escape on any error. */
2133 #ifndef DISABLE_PIPE_CONNECT
2134 if (sx
->early_pipe_active
)
2136 sx
->pending_BANNER
= TRUE
; /* sync_responses() must eventually handle */
2137 sx
->outblock
.cmd_count
= 1;
2143 (void) setsockopt(sx
->cctx
.sock
, IPPROTO_TCP
, TCP_QUICKACK
, US
&off
,
2146 if (!smtp_reap_banner(sx
))
2147 goto RESPONSE_FAILED
;
2150 #ifndef DISABLE_EVENT
2153 lookup_dnssec_authenticated
= sx
->conn_args
.host
->dnssec
==DS_YES ? US
"yes"
2154 : sx
->conn_args
.host
->dnssec
==DS_NO ? US
"no" : NULL
;
2155 s
= event_raise(sx
->conn_args
.tblock
->event_action
, US
"smtp:connect", sx
->buffer
);
2158 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
,
2159 string_sprintf("deferred by smtp:connect event expansion: %s", s
),
2160 DEFER
, FALSE
, &sx
->delivery_start
);
2167 /* Now check if the helo_data expansion went well, and sign off cleanly if
2172 message
= string_sprintf("failed to expand helo_data: %s",
2173 expand_string_message
);
2174 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
, &sx
->delivery_start
);
2180 /** Debugging without sending a message
2181 sx->addrlist->transport_return = DEFER;
2185 /* Errors that occur after this point follow an SMTP command, which is
2186 left in big_buffer by smtp_write_command() for use in error messages. */
2188 smtp_command
= big_buffer
;
2190 /* Tell the remote who we are...
2192 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2193 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2194 greeting is of this form. The assumption was that the far end supports it
2195 properly... but experience shows that there are some that give 5xx responses,
2196 even though the banner includes "ESMTP" (there's a bloody-minded one that
2197 says "ESMTP not spoken here"). Cope with that case.
2199 September 2000: Time has passed, and it seems reasonable now to always send
2200 EHLO at the start. It is also convenient to make the change while installing
2203 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2204 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2205 would be no way to send out the mails, so there is now a host list
2206 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2207 PIPELINING problem as well. Maybe it can also be useful to cure other
2208 problems with broken servers.
2210 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2211 Then somebody tried it with a Microsoft mailer... It seems that all other
2212 mailers use upper case for some reason (the RFC is quite clear about case
2213 independence) so, for peace of mind, I gave in. */
2215 sx
->esmtp
= verify_check_given_host(CUSS
&ob
->hosts_avoid_esmtp
, sx
->conn_args
.host
) != OK
;
2217 /* Alas; be careful, since this goto is not an error-out, so conceivably
2218 we might set data between here and the target which we assume to exist
2219 and be usable. I can see this coming back to bite us. */
2223 smtp_peer_options
|= OPTION_TLS
;
2224 suppress_tls
= FALSE
;
2225 ob
->tls_tempfail_tryclear
= FALSE
;
2226 smtp_command
= US
"SSL-on-connect";
2233 if (smtp_write_command(sx
,
2234 #ifndef DISABLE_PIPE_CONNECT
2235 sx
->early_pipe_active ? SCMD_BUFFER
:
2238 "%s %s\r\n", sx
->lmtp ?
"LHLO" : "EHLO", sx
->helo_data
) < 0)
2240 sx
->esmtp_sent
= TRUE
;
2242 #ifndef DISABLE_PIPE_CONNECT
2243 if (sx
->early_pipe_active
)
2245 sx
->pending_EHLO
= TRUE
;
2247 /* If we have too many authenticators to handle and might need to AUTH
2248 for this transport, pipeline no further as we will need the
2249 list of auth methods offered. Reap the banner and EHLO. */
2251 if ( (ob
->hosts_require_auth
|| ob
->hosts_try_auth
)
2252 && f
.smtp_in_early_pipe_no_auth
)
2254 DEBUG(D_transport
) debug_printf("may need to auth, so pipeline no further\n");
2255 if (smtp_write_command(sx
, SCMD_FLUSH
, NULL
) < 0)
2257 if (sync_responses(sx
, 2, 0) != 0)
2260 debug_printf("failed reaping pipelined cmd responses\n");
2261 goto RESPONSE_FAILED
;
2263 sx
->early_pipe_active
= FALSE
;
2268 if (!smtp_reap_ehlo(sx
))
2269 goto RESPONSE_FAILED
;
2273 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2275 #ifndef DISABLE_PIPE_CONNECT
2276 if (!sx
->early_pipe_active
)
2281 int n
= sizeof(sx
->buffer
);
2282 uschar
* rsp
= sx
->buffer
;
2284 if (sx
->esmtp_sent
&& (n
= Ustrlen(sx
->buffer
)) < sizeof(sx
->buffer
)/2)
2285 { rsp
= sx
->buffer
+ n
+ 1; n
= sizeof(sx
->buffer
) - n
; }
2287 if (smtp_write_command(sx
, SCMD_FLUSH
, "HELO %s\r\n", sx
->helo_data
) < 0)
2289 good_response
= smtp_read_response(sx
, rsp
, n
, '2', ob
->command_timeout
);
2290 #ifdef EXPERIMENTAL_DSN_INFO
2291 sx
->helo_response
= string_copy(rsp
);
2295 /* Handle special logging for a closed connection after HELO
2296 when had previously sent EHLO */
2298 if (rsp
!= sx
->buffer
&& rsp
[0] == 0 && (errno
== 0 || errno
== ECONNRESET
))
2300 errno
= ERRNO_SMTPCLOSED
;
2301 goto EHLOHELO_FAILED
;
2303 memmove(sx
->buffer
, rsp
, Ustrlen(rsp
));
2304 goto RESPONSE_FAILED
;
2308 if (sx
->esmtp
|| sx
->lmtp
)
2310 #ifndef DISABLE_PIPE_CONNECT
2311 if (!sx
->early_pipe_active
)
2314 sx
->peer_offered
= ehlo_response(sx
->buffer
,
2315 OPTION_TLS
/* others checked later */
2316 #ifndef DISABLE_PIPE_CONNECT
2317 | (sx
->early_pipe_ok
2319 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
2328 #ifndef DISABLE_PIPE_CONNECT
2329 if (sx
->early_pipe_ok
)
2331 sx
->ehlo_resp
.cleartext_features
= sx
->peer_offered
;
2333 if ( (sx
->peer_offered
& (OPTION_PIPE
| OPTION_EARLY_PIPE
))
2334 == (OPTION_PIPE
| OPTION_EARLY_PIPE
))
2336 DEBUG(D_transport
) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2337 sx
->ehlo_resp
.cleartext_auths
= study_ehlo_auths(sx
);
2338 write_ehlo_cache_entry(sx
);
2344 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2347 smtp_peer_options
|= sx
->peer_offered
& OPTION_TLS
;
2352 /* For continuing deliveries down the same channel, having re-exec'd the socket
2353 is the standard input; for a socket held open from verify it is recorded
2354 in the cutthrough context block. Either way we don't need to redo EHLO here
2355 (but may need to do so for TLS - see below).
2356 Set up the pointer to where subsequent commands will be left, for
2357 error messages. Note that smtp_peer_options will have been
2358 set from the command line if they were set in the process that passed the
2361 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2362 as the continue goes via transport_pass_socket() and doublefork and exec.
2363 It does not wait. Unclear how we keep separate host's responses
2364 separate - we could match up by host ip+port as a bodge. */
2368 if (cutthrough
.cctx
.sock
>= 0 && cutthrough
.callout_hold_only
)
2370 sx
->cctx
= cutthrough
.cctx
;
2371 sx
->conn_args
.host
->port
= sx
->port
= cutthrough
.host
.port
;
2375 sx
->cctx
.sock
= 0; /* stdin */
2376 sx
->cctx
.tls_ctx
= NULL
;
2377 smtp_port_for_connect(sx
->conn_args
.host
, sx
->port
); /* Record the port that was used */
2379 sx
->inblock
.cctx
= sx
->outblock
.cctx
= &sx
->cctx
;
2380 smtp_command
= big_buffer
;
2381 sx
->peer_offered
= smtp_peer_options
;
2382 sx
->helo_data
= NULL
; /* ensure we re-expand ob->helo_data */
2384 /* For a continued connection with TLS being proxied for us, or a
2385 held-open verify connection with TLS, nothing more to do. */
2387 if ( continue_proxy_cipher
2388 || (cutthrough
.cctx
.sock
>= 0 && cutthrough
.callout_hold_only
2389 && cutthrough
.is_tls
)
2392 sx
->pipelining_used
= pipelining_active
= !!(smtp_peer_options
& OPTION_PIPE
);
2393 HDEBUG(D_transport
) debug_printf("continued connection, %s TLS\n",
2394 continue_proxy_cipher ?
"proxied" : "verify conn with");
2397 HDEBUG(D_transport
) debug_printf("continued connection, no TLS\n");
2400 /* If TLS is available on this connection, whether continued or not, attempt to
2401 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2402 send another EHLO - the server may give a different answer in secure mode. We
2403 use a separate buffer for reading the response to STARTTLS so that if it is
2404 negative, the original EHLO data is available for subsequent analysis, should
2405 the client not be required to use TLS. If the response is bad, copy the buffer
2406 for error analysis. */
2409 if ( smtp_peer_options
& OPTION_TLS
2411 && verify_check_given_host(CUSS
&ob
->hosts_avoid_tls
, sx
->conn_args
.host
) != OK
2413 || verify_check_given_host(CUSS
&ob
->hosts_verify_avoid_tls
, sx
->conn_args
.host
) != OK
2416 uschar buffer2
[4096];
2418 if (smtp_write_command(sx
, SCMD_FLUSH
, "STARTTLS\r\n") < 0)
2421 #ifndef DISABLE_PIPE_CONNECT
2422 /* If doing early-pipelining reap the banner and EHLO-response but leave
2423 the response for the STARTTLS we just sent alone. */
2425 if (sx
->early_pipe_active
&& sync_responses(sx
, 2, 0) != 0)
2428 debug_printf("failed reaping pipelined cmd responses\n");
2429 close(sx
->cctx
.sock
);
2431 sx
->early_pipe_active
= FALSE
;
2432 goto PIPE_CONNECT_RETRY
;
2436 /* If there is an I/O error, transmission of this message is deferred. If
2437 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2438 false, we also defer. However, if there is a temporary rejection of STARTTLS
2439 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2440 STARTTLS, we carry on. This means we will try to send the message in clear,
2441 unless the host is in hosts_require_tls (tested below). */
2443 if (!smtp_read_response(sx
, buffer2
, sizeof(buffer2
), '2', ob
->command_timeout
))
2447 || (buffer2
[0] == '4' && !ob
->tls_tempfail_tryclear
)
2450 Ustrncpy(sx
->buffer
, buffer2
, sizeof(sx
->buffer
));
2451 sx
->buffer
[sizeof(sx
->buffer
)-1] = '\0';
2452 goto RESPONSE_FAILED
;
2456 /* STARTTLS accepted: try to negotiate a TLS session. */
2461 if (!tls_client_start(&sx
->cctx
, &sx
->conn_args
, sx
->addrlist
, &tls_out
, &tls_errstr
))
2463 /* TLS negotiation failed; give an error. From outside, this function may
2464 be called again to try in clear on a new connection, if the options permit
2465 it for this host. */
2469 DEBUG(D_tls
) debug_printf("TLS session fail: %s\n", tls_errstr
);
2471 # ifdef SUPPORT_DANE
2472 if (sx
->conn_args
.dane
)
2474 log_write(0, LOG_MAIN
,
2475 "DANE attempt failed; TLS connection to %s [%s]: %s",
2476 sx
->conn_args
.host
->name
, sx
->conn_args
.host
->address
, tls_errstr
);
2477 # ifndef DISABLE_EVENT
2478 (void) event_raise(sx
->conn_args
.tblock
->event_action
,
2479 US
"dane:fail", US
"validation-failure"); /* could do with better detail */
2484 errno
= ERRNO_TLSFAILURE
;
2485 message
= string_sprintf("TLS session: %s", tls_errstr
);
2486 sx
->send_quit
= FALSE
;
2490 /* TLS session is set up */
2492 smtp_peer_options_wrap
= smtp_peer_options
;
2493 for (address_item
* addr
= sx
->addrlist
; addr
; addr
= addr
->next
)
2494 if (addr
->transport_return
== PENDING_DEFER
)
2496 addr
->cipher
= tls_out
.cipher
;
2497 addr
->ourcert
= tls_out
.ourcert
;
2498 addr
->peercert
= tls_out
.peercert
;
2499 addr
->peerdn
= tls_out
.peerdn
;
2500 addr
->ocsp
= tls_out
.ocsp
;
2501 addr
->tlsver
= tls_out
.ver
;
2506 /* if smtps, we'll have smtp_command set to something else; always safe to
2508 smtp_command
= big_buffer
;
2510 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2511 helo_data is null, we are dealing with a connection that was passed from
2512 another process, and so we won't have expanded helo_data above. We have to
2513 expand it here. $sending_ip_address and $sending_port are set up right at the
2514 start of the Exim process (in exim.c). */
2516 if (tls_out
.active
.sock
>= 0)
2518 uschar
* greeting_cmd
;
2520 if (!sx
->helo_data
&& !(sx
->helo_data
= expand_string(ob
->helo_data
)))
2522 uschar
*message
= string_sprintf("failed to expand helo_data: %s",
2523 expand_string_message
);
2524 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
, &sx
->delivery_start
);
2529 #ifndef DISABLE_PIPE_CONNECT
2530 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2531 We're unlikely to get the group sent and delivered before the server sends its
2532 banner, but it's still worth sending as a group.
2533 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2536 if (sx
->smtps ? sx
->early_pipe_ok
: sx
->early_pipe_active
)
2538 sx
->peer_offered
= sx
->ehlo_resp
.crypted_features
;
2539 if ((sx
->early_pipe_active
=
2540 !!(sx
->ehlo_resp
.crypted_features
& OPTION_EARLY_PIPE
)))
2541 DEBUG(D_transport
) debug_printf("Using cached crypted PIPE_CONNECT\n");
2545 /* For SMTPS we need to wait for the initial OK response. */
2547 #ifndef DISABLE_PIPE_CONNECT
2548 if (sx
->early_pipe_active
)
2550 sx
->pending_BANNER
= TRUE
;
2551 sx
->outblock
.cmd_count
= 1;
2555 if (!smtp_reap_banner(sx
))
2556 goto RESPONSE_FAILED
;
2559 greeting_cmd
= US
"LHLO";
2561 greeting_cmd
= US
"EHLO";
2564 greeting_cmd
= US
"HELO";
2566 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2569 if (smtp_write_command(sx
,
2570 #ifndef DISABLE_PIPE_CONNECT
2571 sx
->early_pipe_active ? SCMD_BUFFER
:
2574 "%s %s\r\n", greeting_cmd
, sx
->helo_data
) < 0)
2577 #ifndef DISABLE_PIPE_CONNECT
2578 if (sx
->early_pipe_active
)
2579 sx
->pending_EHLO
= TRUE
;
2583 if (!smtp_reap_ehlo(sx
))
2586 /* The GnuTLS layer in Exim only spots a server-rejection of a client
2587 cert late, under TLS1.3 - which means here; the first time we try to
2588 receive crypted data. Treat it as if it was a connect-time failure.
2589 See also the early-pipe equivalent... which will be hard; every call
2590 to sync_responses will need to check the result.
2591 It would be nicer to have GnuTLS check the cert during the handshake.
2592 Can it do that, with all the flexibility we need? */
2594 tls_errstr
= US
"error on first read";
2595 goto GNUTLS_CONN_FAILED
;
2598 goto RESPONSE_FAILED
;
2600 smtp_peer_options
= 0;
2604 /* If the host is required to use a secure channel, ensure that we
2608 # ifdef SUPPORT_DANE
2609 || sx
->conn_args
.dane
2611 || verify_check_given_host(CUSS
&ob
->hosts_require_tls
, sx
->conn_args
.host
) == OK
2614 errno
= ERRNO_TLSREQUIRED
;
2615 message
= string_sprintf("a TLS session is required, but %s",
2616 smtp_peer_options
& OPTION_TLS
2617 ?
"an attempt to start TLS failed" : "the server did not offer TLS support");
2618 # if defined(SUPPORT_DANE) && !defined(DISABLE_EVENT)
2619 if (sx
->conn_args
.dane
)
2620 (void) event_raise(sx
->conn_args
.tblock
->event_action
, US
"dane:fail",
2621 smtp_peer_options
& OPTION_TLS
2622 ? US
"validation-failure" /* could do with better detail */
2623 : US
"starttls-not-supported");
2627 #endif /*DISABLE_TLS*/
2629 /* If TLS is active, we have just started it up and re-done the EHLO command,
2630 so its response needs to be analyzed. If TLS is not active and this is a
2631 continued session down a previously-used socket, we haven't just done EHLO, so
2634 if (continue_hostname
== NULL
2636 || tls_out
.active
.sock
>= 0
2640 if (sx
->esmtp
|| sx
->lmtp
)
2642 #ifndef DISABLE_PIPE_CONNECT
2643 if (!sx
->early_pipe_active
)
2646 sx
->peer_offered
= ehlo_response(sx
->buffer
,
2648 #ifndef DISABLE_PIPE_CONNECT
2649 | (sx
->lmtp
&& ob
->lmtp_ignore_quota ? OPTION_IGNQ
: 0)
2650 | OPTION_DSN
| OPTION_PIPE
| OPTION_SIZE
2651 | OPTION_CHUNKING
| OPTION_PRDR
| OPTION_UTF8
2652 | (tls_out
.active
.sock
>= 0 ? OPTION_EARLY_PIPE
: 0) /* not for lmtp */
2656 | (sx
->lmtp
&& ob
->lmtp_ignore_quota ? OPTION_IGNQ
: 0)
2659 # ifdef SUPPORT_I18N
2660 | (sx
->addrlist
->prop
.utf8_msg ? OPTION_UTF8
: 0)
2661 /*XXX if we hand peercaps on to continued-conn processes,
2662 must not depend on this addr */
2666 | (ob
->size_addition
>= 0 ? OPTION_SIZE
: 0)
2669 #ifndef DISABLE_PIPE_CONNECT
2670 if (tls_out
.active
.sock
>= 0)
2671 sx
->ehlo_resp
.crypted_features
= sx
->peer_offered
;
2675 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2676 lmtp_ignore_quota option was set. */
2678 sx
->igquotstr
= sx
->peer_offered
& OPTION_IGNQ ? US
" IGNOREQUOTA" : US
"";
2680 /* If the response to EHLO specified support for the SIZE parameter, note
2681 this, provided size_addition is non-negative. */
2683 smtp_peer_options
|= sx
->peer_offered
& OPTION_SIZE
;
2685 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2686 the current host, esmtp will be false, so PIPELINING can never be used. If
2687 the current host matches hosts_avoid_pipelining, don't do it. */
2689 if ( sx
->peer_offered
& OPTION_PIPE
2690 && verify_check_given_host(CUSS
&ob
->hosts_avoid_pipelining
, sx
->conn_args
.host
) != OK
)
2691 smtp_peer_options
|= OPTION_PIPE
;
2693 DEBUG(D_transport
) debug_printf("%susing PIPELINING\n",
2694 smtp_peer_options
& OPTION_PIPE ?
"" : "not ");
2696 if ( sx
->peer_offered
& OPTION_CHUNKING
2697 && verify_check_given_host(CUSS
&ob
->hosts_try_chunking
, sx
->conn_args
.host
) != OK
)
2698 sx
->peer_offered
&= ~OPTION_CHUNKING
;
2700 if (sx
->peer_offered
& OPTION_CHUNKING
)
2701 DEBUG(D_transport
) debug_printf("CHUNKING usable\n");
2703 #ifndef DISABLE_PRDR
2704 if ( sx
->peer_offered
& OPTION_PRDR
2705 && verify_check_given_host(CUSS
&ob
->hosts_try_prdr
, sx
->conn_args
.host
) != OK
)
2706 sx
->peer_offered
&= ~OPTION_PRDR
;
2708 if (sx
->peer_offered
& OPTION_PRDR
)
2709 DEBUG(D_transport
) debug_printf("PRDR usable\n");
2712 /* Note if the server supports DSN */
2713 smtp_peer_options
|= sx
->peer_offered
& OPTION_DSN
;
2714 DEBUG(D_transport
) debug_printf("%susing DSN\n",
2715 sx
->peer_offered
& OPTION_DSN ?
"" : "not ");
2717 #ifndef DISABLE_PIPE_CONNECT
2718 if ( sx
->early_pipe_ok
2719 && !sx
->early_pipe_active
2720 && tls_out
.active
.sock
>= 0
2721 && smtp_peer_options
& OPTION_PIPE
2722 && ( sx
->ehlo_resp
.cleartext_features
| sx
->ehlo_resp
.crypted_features
)
2723 & OPTION_EARLY_PIPE
)
2725 DEBUG(D_transport
) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2726 sx
->ehlo_resp
.crypted_auths
= study_ehlo_auths(sx
);
2727 write_ehlo_cache_entry(sx
);
2731 /* Note if the response to EHLO specifies support for the AUTH extension.
2732 If it has, check that this host is one we want to authenticate to, and do
2733 the business. The host name and address must be available when the
2734 authenticator's client driver is running. */
2736 switch (yield
= smtp_auth(sx
))
2738 default: goto SEND_QUIT
;
2740 case FAIL_SEND
: goto SEND_FAILED
;
2741 case FAIL
: goto RESPONSE_FAILED
;
2745 sx
->pipelining_used
= pipelining_active
= !!(smtp_peer_options
& OPTION_PIPE
);
2747 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2748 message-specific. */
2750 sx
->setting_up
= FALSE
;
2753 if (sx
->addrlist
->prop
.utf8_msg
)
2757 /* If the transport sets a downconversion mode it overrides any set by ACL
2760 if ((s
= ob
->utf8_downconvert
))
2762 if (!(s
= expand_string(s
)))
2764 message
= string_sprintf("failed to expand utf8_downconvert: %s",
2765 expand_string_message
);
2766 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, message
, DEFER
, FALSE
, &sx
->delivery_start
);
2772 case '1': sx
->addrlist
->prop
.utf8_downcvt
= TRUE
;
2773 sx
->addrlist
->prop
.utf8_downcvt_maybe
= FALSE
;
2775 case '0': sx
->addrlist
->prop
.utf8_downcvt
= FALSE
;
2776 sx
->addrlist
->prop
.utf8_downcvt_maybe
= FALSE
;
2778 case '-': if (s
[1] == '1')
2780 sx
->addrlist
->prop
.utf8_downcvt
= FALSE
;
2781 sx
->addrlist
->prop
.utf8_downcvt_maybe
= TRUE
;
2787 sx
->utf8_needed
= !sx
->addrlist
->prop
.utf8_downcvt
2788 && !sx
->addrlist
->prop
.utf8_downcvt_maybe
;
2789 DEBUG(D_transport
) if (!sx
->utf8_needed
)
2790 debug_printf("utf8: %s downconvert\n",
2791 sx
->addrlist
->prop
.utf8_downcvt ?
"mandatory" : "optional");
2794 /* If this is an international message we need the host to speak SMTPUTF8 */
2795 if (sx
->utf8_needed
&& !(sx
->peer_offered
& OPTION_UTF8
))
2797 errno
= ERRNO_UTF8_FWD
;
2798 goto RESPONSE_FAILED
;
2800 #endif /*SUPPORT_I18N*/
2809 if (errno
== ECONNREFUSED
) /* first-read error on a TFO conn */
2811 /* There is a testing facility for simulating a connection timeout, as I
2812 can't think of any other way of doing this. It converts a connection
2813 refused into a timeout if the timeout is set to 999999. This is done for
2814 a 3whs connection in ip_connect(), but a TFO connection does not error
2815 there - instead it gets ECONNREFUSED on the first data read. Tracking
2816 that a TFO really was done is too hard, or we would set a
2817 sx->pending_conn_done bit and test that in smtp_reap_banner() and
2818 smtp_reap_ehlo(). That would let us also add the conn-timeout to the
2821 if (f
.running_in_test_harness
&& ob
->connect_timeout
== 999999)
2823 set_errno_nohost(sx
->addrlist
,
2824 errno
== ETIMEDOUT ? ERRNO_CONNECTTIMEOUT
: errno
,
2825 sx
->verify ? US
strerror(errno
) : NULL
,
2826 DEFER
, FALSE
, &sx
->delivery_start
);
2827 sx
->send_quit
= FALSE
;
2831 /* really an error on an SMTP read */
2833 sx
->send_quit
= check_response(sx
->conn_args
.host
, &errno
, sx
->addrlist
->more_errno
,
2834 sx
->buffer
, &code
, &message
, &pass_message
);
2840 message
= US
string_sprintf("send() to %s [%s] failed: %s",
2841 sx
->conn_args
.host
->name
, sx
->conn_args
.host
->address
, strerror(errno
));
2842 sx
->send_quit
= FALSE
;
2848 message
= string_sprintf("Remote host closed connection in response to %s"
2849 " (EHLO response was: %s)", smtp_command
, sx
->buffer
);
2850 sx
->send_quit
= FALSE
;
2854 /* This label is jumped to directly when a TLS negotiation has failed,
2855 or was not done for a host for which it is required. Values will be set
2856 in message and errno, and setting_up will always be true. Treat as
2857 a temporary error. */
2861 code
= '4', yield
= DEFER
;
2865 /* The failure happened while setting up the call; see if the failure was
2866 a 5xx response (this will either be on connection, or following HELO - a 5xx
2867 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2868 fail all addresses, as this host is never going to accept them. For other
2869 errors during setting up (timeouts or whatever), defer all addresses, and
2870 yield DEFER, so that the host is not tried again for a while.
2872 XXX This peeking for another host feels like a layering violation. We want
2873 to note the host as unusable, but down here we shouldn't know if this was
2874 the last host to try for the addr(list). Perhaps the upper layer should be
2875 the one to do set_errno() ? The problem is that currently the addr is where
2876 errno etc. are stashed, but until we run out of hosts to try the errors are
2877 host-specific. Maybe we should enhance the host_item definition? */
2880 sx
->ok
= FALSE
; /* For when reached by GOTO */
2881 set_errno(sx
->addrlist
, errno
, message
,
2882 sx
->conn_args
.host
->next
2886 || errno
== ERRNO_UTF8_FWD
2890 errno
== ECONNREFUSED ? NULL
: sx
->conn_args
.host
,
2891 #ifdef EXPERIMENTAL_DSN_INFO
2892 sx
->smtp_greeting
, sx
->helo_response
,
2894 &sx
->delivery_start
);
2901 (void)smtp_write_command(sx
, SCMD_FLUSH
, "QUIT\r\n");
2904 if (sx
->cctx
.tls_ctx
)
2906 tls_close(sx
->cctx
.tls_ctx
, TLS_SHUTDOWN_NOWAIT
);
2907 sx
->cctx
.tls_ctx
= NULL
;
2911 /* Close the socket, and return the appropriate value, first setting
2912 works because the NULL setting is passed back to the calling process, and
2913 remote_max_parallel is forced to 1 when delivering over an existing connection,
2916 HDEBUG(D_transport
|D_acl
|D_v
) debug_printf_indent(" SMTP(close)>>\n");
2919 shutdown(sx
->cctx
.sock
, SHUT_WR
);
2920 if (fcntl(sx
->cctx
.sock
, F_SETFL
, O_NONBLOCK
) == 0)
2921 for (int i
= 16; read(sx
->cctx
.sock
, sx
->inbuffer
, sizeof(sx
->inbuffer
)) > 0 && i
> 0;)
2922 i
--; /* drain socket */
2923 sx
->send_quit
= FALSE
;
2925 (void)close(sx
->cctx
.sock
);
2928 #ifndef DISABLE_EVENT
2929 (void) event_raise(sx
->conn_args
.tblock
->event_action
, US
"tcp:close", NULL
);
2932 continue_transport
= NULL
;
2933 continue_hostname
= NULL
;
2940 /* Create the string of options that will be appended to the MAIL FROM:
2941 in the connection context buffer */
2944 build_mailcmd_options(smtp_context
* sx
, address_item
* addrlist
)
2946 uschar
* p
= sx
->buffer
;
2947 address_item
* addr
;
2952 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2953 send it, adding something to the message size to allow for imprecision
2954 and things that get added en route. Exim keeps the number of lines
2955 in a message, so we can give an accurate value for the original message, but we
2956 need some additional to handle added headers. (Double "." characters don't get
2957 included in the count.) */
2959 if ( message_size
> 0
2960 && sx
->peer_offered
& OPTION_SIZE
&& !(sx
->avoid_option
& OPTION_SIZE
))
2962 /*XXX problem here under spool_files_wireformat?
2963 Or just forget about lines? Or inflate by a fixed proportion? */
2965 sprintf(CS p
, " SIZE=%d", message_size
+message_linecount
+(SOB sx
->conn_args
.ob
)->size_addition
);
2969 #ifndef DISABLE_PRDR
2970 /* If it supports Per-Recipient Data Responses, and we have more than one recipient,
2973 sx
->prdr_active
= FALSE
;
2974 if (sx
->peer_offered
& OPTION_PRDR
)
2975 for (address_item
* addr
= addrlist
; addr
; addr
= addr
->next
)
2976 if (addr
->transport_return
== PENDING_DEFER
)
2978 for (addr
= addr
->next
; addr
; addr
= addr
->next
)
2979 if (addr
->transport_return
== PENDING_DEFER
)
2980 { /* at least two recipients to send */
2981 sx
->prdr_active
= TRUE
;
2982 sprintf(CS p
, " PRDR"); p
+= 5;
2990 /* If it supports internationalised messages, and this meesage need that,
2993 if ( sx
->peer_offered
& OPTION_UTF8
2994 && addrlist
->prop
.utf8_msg
2995 && !addrlist
->prop
.utf8_downcvt
2997 Ustrcpy(p
, US
" SMTPUTF8"), p
+= 9;
3000 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3001 for (sx
->dsn_all_lasthop
= TRUE
, addr
= addrlist
, address_count
= 0;
3002 addr
&& address_count
< sx
->max_rcpt
;
3003 addr
= addr
->next
) if (addr
->transport_return
== PENDING_DEFER
)
3006 if (!(addr
->dsn_flags
& rf_dsnlasthop
))
3008 sx
->dsn_all_lasthop
= FALSE
;
3013 /* Add any DSN flags to the mail command */
3015 if (sx
->peer_offered
& OPTION_DSN
&& !sx
->dsn_all_lasthop
)
3017 if (dsn_ret
== dsn_ret_hdrs
)
3018 { Ustrcpy(p
, US
" RET=HDRS"); p
+= 9; }
3019 else if (dsn_ret
== dsn_ret_full
)
3020 { Ustrcpy(p
, US
" RET=FULL"); p
+= 9; }
3024 string_format(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), " ENVID=%s", dsn_envid
);
3029 /* If an authenticated_sender override has been specified for this transport
3030 instance, expand it. If the expansion is forced to fail, and there was already
3031 an authenticated_sender for this message, the original value will be used.
3032 Other expansion failures are serious. An empty result is ignored, but there is
3033 otherwise no check - this feature is expected to be used with LMTP and other
3034 cases where non-standard addresses (e.g. without domains) might be required. */
3036 return smtp_mail_auth_str(sx
, p
, addrlist
) ? ERROR
: OK
;
3041 build_rcptcmd_options(smtp_context
* sx
, const address_item
* addr
)
3043 uschar
* p
= sx
->buffer
;
3046 /* Add any DSN flags to the rcpt command */
3048 if (sx
->peer_offered
& OPTION_DSN
&& !(addr
->dsn_flags
& rf_dsnlasthop
))
3050 if (addr
->dsn_flags
& rf_dsnflags
)
3054 Ustrcpy(p
, US
" NOTIFY=");
3056 for (int i
= 0; i
< nelem(rf_list
); i
++) if (addr
->dsn_flags
& rf_list
[i
])
3058 if (!first
) *p
++ = ',';
3060 Ustrcpy(p
, rf_names
[i
]);
3065 if (addr
->dsn_orcpt
)
3067 string_format(p
, sizeof(sx
->buffer
) - (p
-sx
->buffer
), " ORCPT=%s",
3078 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3079 -1 MAIL response error
3080 -2 any non-MAIL read i/o error
3081 -3 non-MAIL response timeout
3082 -4 internal error; channel still usable
3087 smtp_write_mail_and_rcpt_cmds(smtp_context
* sx
, int * yield
)
3089 address_item
* addr
;
3090 int address_count
, pipe_limit
;
3093 if (build_mailcmd_options(sx
, sx
->first_addr
) != OK
)
3099 /* From here until we send the DATA command, we can make use of PIPELINING
3100 if the server host supports it. The code has to be able to check the responses
3101 at any point, for when the buffer fills up, so we write it totally generally.
3102 When PIPELINING is off, each command written reports that it has flushed the
3105 sx
->pending_MAIL
= TRUE
; /* The block starts with MAIL */
3108 uschar
* s
= sx
->from_addr
;
3110 uschar
* errstr
= NULL
;
3112 /* If we must downconvert, do the from-address here. Remember we had to
3113 for the to-addresses (done below), and also (ugly) for re-doing when building
3114 the delivery log line. */
3116 if ( sx
->addrlist
->prop
.utf8_msg
3117 && (sx
->addrlist
->prop
.utf8_downcvt
|| !(sx
->peer_offered
& OPTION_UTF8
))
3120 if (s
= string_address_utf8_to_alabel(s
, &errstr
), errstr
)
3122 set_errno_nohost(sx
->addrlist
, ERRNO_EXPANDFAIL
, errstr
, DEFER
, FALSE
, &sx
->delivery_start
);
3126 setflag(sx
->addrlist
, af_utf8_downcvt
);
3130 rc
= smtp_write_command(sx
, pipelining_active ? SCMD_BUFFER
: SCMD_FLUSH
,
3131 "MAIL FROM:<%s>%s\r\n", s
, sx
->buffer
);
3134 mail_command
= string_copy(big_buffer
); /* Save for later error message */
3138 case -1: /* Transmission error */
3141 case +1: /* Cmd was sent */
3142 if (!smtp_read_response(sx
, sx
->buffer
, sizeof(sx
->buffer
), '2',
3143 (SOB sx
->conn_args
.ob
)->command_timeout
))
3145 if (errno
== 0 && sx
->buffer
[0] == '4')
3147 errno
= ERRNO_MAIL4XX
;
3148 sx
->addrlist
->more_errno
|= ((sx
->buffer
[1] - '0')*10 + sx
->buffer
[2] - '0') << 8;
3152 sx
->pending_MAIL
= FALSE
;
3155 /* otherwise zero: command queued for pipeline */
3158 /* Pass over all the relevant recipient addresses for this host, which are the
3159 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3160 several before we have to read the responses for those seen so far. This
3161 checking is done by a subroutine because it also needs to be done at the end.
3162 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3163 the next one if not all are sent.
3165 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3166 last address because we want to abort if any recipients have any kind of
3167 problem, temporary or permanent. We know that all recipient addresses will have
3168 the PENDING_DEFER status, because only one attempt is ever made, and we know
3169 that max_rcpt will be large, so all addresses will be done at once.
3171 For verify we flush the pipeline after any (the only) rcpt address. */
3173 for (addr
= sx
->first_addr
, address_count
= 0, pipe_limit
= 100;
3174 addr
&& address_count
< sx
->max_rcpt
;
3175 addr
= addr
->next
) if (addr
->transport_return
== PENDING_DEFER
)
3181 addr
->dsn_aware
= sx
->peer_offered
& OPTION_DSN
3182 ? dsn_support_yes
: dsn_support_no
;
3185 if (pipe_limit
-- <= 0)
3186 { no_flush
= FALSE
; pipe_limit
= 100; }
3188 no_flush
= pipelining_active
&& !sx
->verify
3189 && (!mua_wrapper
|| addr
->next
&& address_count
< sx
->max_rcpt
);
3191 build_rcptcmd_options(sx
, addr
);
3193 /* Now send the RCPT command, and process outstanding responses when
3194 necessary. After a timeout on RCPT, we just end the function, leaving the
3195 yield as OK, because this error can often mean that there is a problem with
3196 just one address, so we don't want to delay the host. */
3198 rcpt_addr
= transport_rcpt_address(addr
, sx
->conn_args
.tblock
->rcpt_include_affixes
);
3201 if ( testflag(sx
->addrlist
, af_utf8_downcvt
)
3202 && !(rcpt_addr
= string_address_utf8_to_alabel(rcpt_addr
, NULL
))
3205 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3206 errno
= ERRNO_EXPANDFAIL
;
3207 return -5; /*XXX too harsh? */
3211 cmds_sent
= smtp_write_command(sx
, no_flush ? SCMD_BUFFER
: SCMD_FLUSH
,
3212 "RCPT TO:<%s>%s%s\r\n", rcpt_addr
, sx
->igquotstr
, sx
->buffer
);
3214 if (cmds_sent
< 0) return -5;
3217 switch(sync_responses(sx
, cmds_sent
, 0))
3219 case 3: sx
->ok
= TRUE
; /* 2xx & 5xx => OK & progress made */
3220 case 2: sx
->completed_addr
= TRUE
; /* 5xx (only) => progress made */
3223 case 1: sx
->ok
= TRUE
; /* 2xx (only) => OK, but if LMTP, */
3224 if (!sx
->lmtp
) /* can't tell about progress yet */
3225 sx
->completed_addr
= TRUE
;
3226 case 0: /* No 2xx or 5xx, but no probs */
3227 /* If any RCPT got a 452 response then next_addr has been updated
3228 for restarting with a new MAIL on the same connection. Send no more
3229 RCPTs for this MAIL. */
3233 DEBUG(D_transport
) debug_printf("seen 452 too-many-rcpts\n");
3234 sx
->RCPT_452
= FALSE
;
3235 /* sx->next_addr has been reset for fast_retry */
3240 case -1: return -3; /* Timeout on RCPT */
3241 case -2: return -2; /* non-MAIL read i/o error */
3242 default: return -1; /* any MAIL error */
3244 #ifndef DISABLE_PIPE_CONNECT
3245 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3246 case -5: return -1; /* TLS first-read error */
3250 } /* Loop for next address */
3252 sx
->next_addr
= addr
;
3258 /*****************************************************
3259 * Proxy TLS connection for another transport process *
3260 ******************************************************/
3262 Close the unused end of the pipe, fork once more, then use the given buffer
3263 as a staging area, and select on both the given fd and the TLS'd client-fd for
3264 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3265 Do blocking full-size writes, and reads under a timeout. Once both input
3266 channels are closed, exit the process.
3270 buf space to use for buffering
3271 bufsiz size of buffer
3272 pfd pipe filedescriptor array; [0] is comms to proxied process
3273 timeout per-read timeout, seconds
3279 smtp_proxy_tls(void * ct_ctx
, uschar
* buf
, size_t bsize
, int * pfd
,
3283 int max_fd
= MAX(pfd
[0], tls_out
.active
.sock
) + 1;
3287 if ((rc
= exim_fork(US
"tls-proxy")))
3288 _exit(rc
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
);