Squashed commit of PIPE_CONNECT
[exim.git] / src / src / transports / smtp.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #include "../exim.h"
9 #include "smtp.h"
10
11
12 /* Options specific to the smtp transport. This transport also supports LMTP
13 over TCP/IP. The options must be in alphabetic order (note that "_" comes
14 before the lower case letters). Some live in the transport_instance block so as
15 to be publicly visible; these are flagged with opt_public. */
16
17 optionlist smtp_transport_options[] = {
18 { "*expand_multi_domain", opt_stringptr | opt_hidden | opt_public,
19 (void *)offsetof(transport_instance, expand_multi_domain) },
20 { "*expand_retry_include_ip_address", opt_stringptr | opt_hidden,
21 (void *)(offsetof(smtp_transport_options_block, expand_retry_include_ip_address)) },
22
23 { "address_retry_include_sender", opt_bool,
24 (void *)offsetof(smtp_transport_options_block, address_retry_include_sender) },
25 { "allow_localhost", opt_bool,
26 (void *)offsetof(smtp_transport_options_block, allow_localhost) },
27 #ifdef EXPERIMENTAL_ARC
28 { "arc_sign", opt_stringptr,
29 (void *)offsetof(smtp_transport_options_block, arc_sign) },
30 #endif
31 { "authenticated_sender", opt_stringptr,
32 (void *)offsetof(smtp_transport_options_block, authenticated_sender) },
33 { "authenticated_sender_force", opt_bool,
34 (void *)offsetof(smtp_transport_options_block, authenticated_sender_force) },
35 { "command_timeout", opt_time,
36 (void *)offsetof(smtp_transport_options_block, command_timeout) },
37 { "connect_timeout", opt_time,
38 (void *)offsetof(smtp_transport_options_block, connect_timeout) },
39 { "connection_max_messages", opt_int | opt_public,
40 (void *)offsetof(transport_instance, connection_max_messages) },
41 # ifdef SUPPORT_DANE
42 { "dane_require_tls_ciphers", opt_stringptr,
43 (void *)offsetof(smtp_transport_options_block, dane_require_tls_ciphers) },
44 # endif
45 { "data_timeout", opt_time,
46 (void *)offsetof(smtp_transport_options_block, data_timeout) },
47 { "delay_after_cutoff", opt_bool,
48 (void *)offsetof(smtp_transport_options_block, delay_after_cutoff) },
49 #ifndef DISABLE_DKIM
50 { "dkim_canon", opt_stringptr,
51 (void *)offsetof(smtp_transport_options_block, dkim.dkim_canon) },
52 { "dkim_domain", opt_stringptr,
53 (void *)offsetof(smtp_transport_options_block, dkim.dkim_domain) },
54 { "dkim_hash", opt_stringptr,
55 (void *)offsetof(smtp_transport_options_block, dkim.dkim_hash) },
56 { "dkim_identity", opt_stringptr,
57 (void *)offsetof(smtp_transport_options_block, dkim.dkim_identity) },
58 { "dkim_private_key", opt_stringptr,
59 (void *)offsetof(smtp_transport_options_block, dkim.dkim_private_key) },
60 { "dkim_selector", opt_stringptr,
61 (void *)offsetof(smtp_transport_options_block, dkim.dkim_selector) },
62 { "dkim_sign_headers", opt_stringptr,
63 (void *)offsetof(smtp_transport_options_block, dkim.dkim_sign_headers) },
64 { "dkim_strict", opt_stringptr,
65 (void *)offsetof(smtp_transport_options_block, dkim.dkim_strict) },
66 { "dkim_timestamps", opt_stringptr,
67 (void *)offsetof(smtp_transport_options_block, dkim.dkim_timestamps) },
68 #endif
69 { "dns_qualify_single", opt_bool,
70 (void *)offsetof(smtp_transport_options_block, dns_qualify_single) },
71 { "dns_search_parents", opt_bool,
72 (void *)offsetof(smtp_transport_options_block, dns_search_parents) },
73 { "dnssec_request_domains", opt_stringptr,
74 (void *)offsetof(smtp_transport_options_block, dnssec.request) },
75 { "dnssec_require_domains", opt_stringptr,
76 (void *)offsetof(smtp_transport_options_block, dnssec.require) },
77 { "dscp", opt_stringptr,
78 (void *)offsetof(smtp_transport_options_block, dscp) },
79 { "fallback_hosts", opt_stringptr,
80 (void *)offsetof(smtp_transport_options_block, fallback_hosts) },
81 { "final_timeout", opt_time,
82 (void *)offsetof(smtp_transport_options_block, final_timeout) },
83 { "gethostbyname", opt_bool,
84 (void *)offsetof(smtp_transport_options_block, gethostbyname) },
85 { "helo_data", opt_stringptr,
86 (void *)offsetof(smtp_transport_options_block, helo_data) },
87 { "hosts", opt_stringptr,
88 (void *)offsetof(smtp_transport_options_block, hosts) },
89 { "hosts_avoid_esmtp", opt_stringptr,
90 (void *)offsetof(smtp_transport_options_block, hosts_avoid_esmtp) },
91 { "hosts_avoid_pipelining", opt_stringptr,
92 (void *)offsetof(smtp_transport_options_block, hosts_avoid_pipelining) },
93 #ifdef SUPPORT_TLS
94 { "hosts_avoid_tls", opt_stringptr,
95 (void *)offsetof(smtp_transport_options_block, hosts_avoid_tls) },
96 #endif
97 { "hosts_max_try", opt_int,
98 (void *)offsetof(smtp_transport_options_block, hosts_max_try) },
99 { "hosts_max_try_hardlimit", opt_int,
100 (void *)offsetof(smtp_transport_options_block, hosts_max_try_hardlimit) },
101 #ifdef SUPPORT_TLS
102 { "hosts_nopass_tls", opt_stringptr,
103 (void *)offsetof(smtp_transport_options_block, hosts_nopass_tls) },
104 { "hosts_noproxy_tls", opt_stringptr,
105 (void *)offsetof(smtp_transport_options_block, hosts_noproxy_tls) },
106 #endif
107 { "hosts_override", opt_bool,
108 (void *)offsetof(smtp_transport_options_block, hosts_override) },
109 #ifdef EXPERIMENTAL_PIPE_CONNECT
110 { "hosts_pipe_connect", opt_stringptr,
111 (void *)offsetof(smtp_transport_options_block, hosts_pipe_connect) },
112 #endif
113 { "hosts_randomize", opt_bool,
114 (void *)offsetof(smtp_transport_options_block, hosts_randomize) },
115 #if defined(SUPPORT_TLS) && !defined(DISABLE_OCSP)
116 { "hosts_request_ocsp", opt_stringptr,
117 (void *)offsetof(smtp_transport_options_block, hosts_request_ocsp) },
118 #endif
119 { "hosts_require_auth", opt_stringptr,
120 (void *)offsetof(smtp_transport_options_block, hosts_require_auth) },
121 #ifdef SUPPORT_TLS
122 # ifdef SUPPORT_DANE
123 { "hosts_require_dane", opt_stringptr,
124 (void *)offsetof(smtp_transport_options_block, hosts_require_dane) },
125 # endif
126 # ifndef DISABLE_OCSP
127 { "hosts_require_ocsp", opt_stringptr,
128 (void *)offsetof(smtp_transport_options_block, hosts_require_ocsp) },
129 # endif
130 { "hosts_require_tls", opt_stringptr,
131 (void *)offsetof(smtp_transport_options_block, hosts_require_tls) },
132 #endif
133 { "hosts_try_auth", opt_stringptr,
134 (void *)offsetof(smtp_transport_options_block, hosts_try_auth) },
135 { "hosts_try_chunking", opt_stringptr,
136 (void *)offsetof(smtp_transport_options_block, hosts_try_chunking) },
137 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
138 { "hosts_try_dane", opt_stringptr,
139 (void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
140 #endif
141 { "hosts_try_fastopen", opt_stringptr,
142 (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
143 #ifndef DISABLE_PRDR
144 { "hosts_try_prdr", opt_stringptr,
145 (void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
146 #endif
147 #ifdef SUPPORT_TLS
148 { "hosts_verify_avoid_tls", opt_stringptr,
149 (void *)offsetof(smtp_transport_options_block, hosts_verify_avoid_tls) },
150 #endif
151 { "interface", opt_stringptr,
152 (void *)offsetof(smtp_transport_options_block, interface) },
153 { "keepalive", opt_bool,
154 (void *)offsetof(smtp_transport_options_block, keepalive) },
155 { "lmtp_ignore_quota", opt_bool,
156 (void *)offsetof(smtp_transport_options_block, lmtp_ignore_quota) },
157 { "max_rcpt", opt_int | opt_public,
158 (void *)offsetof(transport_instance, max_addresses) },
159 { "multi_domain", opt_expand_bool | opt_public,
160 (void *)offsetof(transport_instance, multi_domain) },
161 { "port", opt_stringptr,
162 (void *)offsetof(smtp_transport_options_block, port) },
163 { "protocol", opt_stringptr,
164 (void *)offsetof(smtp_transport_options_block, protocol) },
165 { "retry_include_ip_address", opt_expand_bool,
166 (void *)offsetof(smtp_transport_options_block, retry_include_ip_address) },
167 { "serialize_hosts", opt_stringptr,
168 (void *)offsetof(smtp_transport_options_block, serialize_hosts) },
169 { "size_addition", opt_int,
170 (void *)offsetof(smtp_transport_options_block, size_addition) },
171 #ifdef SUPPORT_SOCKS
172 { "socks_proxy", opt_stringptr,
173 (void *)offsetof(smtp_transport_options_block, socks_proxy) },
174 #endif
175 #ifdef SUPPORT_TLS
176 { "tls_certificate", opt_stringptr,
177 (void *)offsetof(smtp_transport_options_block, tls_certificate) },
178 { "tls_crl", opt_stringptr,
179 (void *)offsetof(smtp_transport_options_block, tls_crl) },
180 { "tls_dh_min_bits", opt_int,
181 (void *)offsetof(smtp_transport_options_block, tls_dh_min_bits) },
182 { "tls_privatekey", opt_stringptr,
183 (void *)offsetof(smtp_transport_options_block, tls_privatekey) },
184 { "tls_require_ciphers", opt_stringptr,
185 (void *)offsetof(smtp_transport_options_block, tls_require_ciphers) },
186 { "tls_sni", opt_stringptr,
187 (void *)offsetof(smtp_transport_options_block, tls_sni) },
188 { "tls_tempfail_tryclear", opt_bool,
189 (void *)offsetof(smtp_transport_options_block, tls_tempfail_tryclear) },
190 { "tls_try_verify_hosts", opt_stringptr,
191 (void *)offsetof(smtp_transport_options_block, tls_try_verify_hosts) },
192 { "tls_verify_cert_hostnames", opt_stringptr,
193 (void *)offsetof(smtp_transport_options_block,tls_verify_cert_hostnames)},
194 { "tls_verify_certificates", opt_stringptr,
195 (void *)offsetof(smtp_transport_options_block, tls_verify_certificates) },
196 { "tls_verify_hosts", opt_stringptr,
197 (void *)offsetof(smtp_transport_options_block, tls_verify_hosts) },
198 #endif
199 #ifdef SUPPORT_I18N
200 { "utf8_downconvert", opt_stringptr,
201 (void *)offsetof(smtp_transport_options_block, utf8_downconvert) },
202 #endif
203 };
204
205 /* Size of the options list. An extern variable has to be used so that its
206 address can appear in the tables drtables.c. */
207
208 int smtp_transport_options_count = nelem(smtp_transport_options);
209
210
211 #ifdef MACRO_PREDEF
212
213 /* Dummy values */
214 smtp_transport_options_block smtp_transport_option_defaults = {0};
215 void smtp_transport_init(transport_instance *tblock) {}
216 BOOL smtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
217 void smtp_transport_closedown(transport_instance *tblock) {}
218
219 #else /*!MACRO_PREDEF*/
220
221
222 /* Default private options block for the smtp transport. */
223
224 smtp_transport_options_block smtp_transport_option_defaults = {
225 .hosts = NULL,
226 .fallback_hosts = NULL,
227 .hostlist = NULL,
228 .fallback_hostlist = NULL,
229 .helo_data = US"$primary_hostname",
230 .interface = NULL,
231 .port = NULL,
232 .protocol = US"smtp",
233 .dscp = NULL,
234 .serialize_hosts = NULL,
235 .hosts_try_auth = NULL,
236 .hosts_require_auth = NULL,
237 .hosts_try_chunking = US"*",
238 #ifdef SUPPORT_DANE
239 .hosts_try_dane = NULL,
240 .hosts_require_dane = NULL,
241 .dane_require_tls_ciphers = NULL,
242 #endif
243 .hosts_try_fastopen = NULL,
244 #ifndef DISABLE_PRDR
245 .hosts_try_prdr = US"*",
246 #endif
247 #ifndef DISABLE_OCSP
248 .hosts_request_ocsp = US"*", /* hosts_request_ocsp (except under DANE; tls_client_start()) */
249 .hosts_require_ocsp = NULL,
250 #endif
251 .hosts_require_tls = NULL,
252 .hosts_avoid_tls = NULL,
253 .hosts_verify_avoid_tls = NULL,
254 .hosts_avoid_pipelining = NULL,
255 #ifdef EXPERIMENTAL_PIPE_CONNECT
256 .hosts_pipe_connect = NULL,
257 #endif
258 .hosts_avoid_esmtp = NULL,
259 #ifdef SUPPORT_TLS
260 .hosts_nopass_tls = NULL,
261 .hosts_noproxy_tls = US"*",
262 #endif
263 .command_timeout = 5*60,
264 .connect_timeout = 5*60,
265 .data_timeout = 5*60,
266 .final_timeout = 10*60,
267 .size_addition = 1024,
268 .hosts_max_try = 5,
269 .hosts_max_try_hardlimit = 50,
270 .address_retry_include_sender = TRUE,
271 .allow_localhost = FALSE,
272 .authenticated_sender_force = FALSE,
273 .gethostbyname = FALSE,
274 .dns_qualify_single = TRUE,
275 .dns_search_parents = FALSE,
276 .dnssec = { .request=NULL, .require=NULL },
277 .delay_after_cutoff = TRUE,
278 .hosts_override = FALSE,
279 .hosts_randomize = FALSE,
280 .keepalive = TRUE,
281 .lmtp_ignore_quota = FALSE,
282 .expand_retry_include_ip_address = NULL,
283 .retry_include_ip_address = TRUE,
284 #ifdef SUPPORT_SOCKS
285 .socks_proxy = NULL,
286 #endif
287 #ifdef SUPPORT_TLS
288 .tls_certificate = NULL,
289 .tls_crl = NULL,
290 .tls_privatekey = NULL,
291 .tls_require_ciphers = NULL,
292 .tls_sni = NULL,
293 .tls_verify_certificates = US"system",
294 .tls_dh_min_bits = EXIM_CLIENT_DH_DEFAULT_MIN_BITS,
295 .tls_tempfail_tryclear = TRUE,
296 .tls_verify_hosts = NULL,
297 .tls_try_verify_hosts = US"*",
298 .tls_verify_cert_hostnames = US"*",
299 #endif
300 #ifdef SUPPORT_I18N
301 .utf8_downconvert = NULL,
302 #endif
303 #ifndef DISABLE_DKIM
304 .dkim =
305 {.dkim_domain = NULL,
306 .dkim_identity = NULL,
307 .dkim_private_key = NULL,
308 .dkim_selector = NULL,
309 .dkim_canon = NULL,
310 .dkim_sign_headers = NULL,
311 .dkim_strict = NULL,
312 .dkim_hash = US"sha256",
313 .dkim_timestamps = NULL,
314 .dot_stuffed = FALSE,
315 .force_bodyhash = FALSE,
316 # ifdef EXPERIMENTAL_ARC
317 .arc_signspec = NULL,
318 # endif
319 },
320 # ifdef EXPERIMENTAL_ARC
321 .arc_sign = NULL,
322 # endif
323 #endif
324 };
325
326 /* some DSN flags for use later */
327
328 static int rf_list[] = {rf_notify_never, rf_notify_success,
329 rf_notify_failure, rf_notify_delay };
330
331 static uschar *rf_names[] = { US"NEVER", US"SUCCESS", US"FAILURE", US"DELAY" };
332
333
334
335 /* Local statics */
336
337 static uschar *smtp_command; /* Points to last cmd for error messages */
338 static uschar *mail_command; /* Points to MAIL cmd for error messages */
339 static uschar *data_command = US""; /* Points to DATA cmd for error messages */
340 static BOOL update_waiting; /* TRUE to update the "wait" database */
341
342 /*XXX move to smtp_context */
343 static BOOL pipelining_active; /* current transaction is in pipe mode */
344
345
346 static unsigned ehlo_response(uschar * buf, unsigned checks);
347
348
349 /*************************************************
350 * Setup entry point *
351 *************************************************/
352
353 /* This function is called when the transport is about to be used,
354 but before running it in a sub-process. It is used for two things:
355
356 (1) To set the fallback host list in addresses, when delivering.
357 (2) To pass back the interface, port, protocol, and other options, for use
358 during callout verification.
359
360 Arguments:
361 tblock pointer to the transport instance block
362 addrlist list of addresses about to be transported
363 tf if not NULL, pointer to block in which to return options
364 uid the uid that will be set (not used)
365 gid the gid that will be set (not used)
366 errmsg place for error message (not used)
367
368 Returns: OK always (FAIL, DEFER not used)
369 */
370
371 static int
372 smtp_transport_setup(transport_instance *tblock, address_item *addrlist,
373 transport_feedback *tf, uid_t uid, gid_t gid, uschar **errmsg)
374 {
375 smtp_transport_options_block *ob = SOB tblock->options_block;
376
377 errmsg = errmsg; /* Keep picky compilers happy */
378 uid = uid;
379 gid = gid;
380
381 /* Pass back options if required. This interface is getting very messy. */
382
383 if (tf)
384 {
385 tf->interface = ob->interface;
386 tf->port = ob->port;
387 tf->protocol = ob->protocol;
388 tf->hosts = ob->hosts;
389 tf->hosts_override = ob->hosts_override;
390 tf->hosts_randomize = ob->hosts_randomize;
391 tf->gethostbyname = ob->gethostbyname;
392 tf->qualify_single = ob->dns_qualify_single;
393 tf->search_parents = ob->dns_search_parents;
394 tf->helo_data = ob->helo_data;
395 }
396
397 /* Set the fallback host list for all the addresses that don't have fallback
398 host lists, provided that the local host wasn't present in the original host
399 list. */
400
401 if (!testflag(addrlist, af_local_host_removed))
402 for (; addrlist; addrlist = addrlist->next)
403 if (!addrlist->fallback_hosts) addrlist->fallback_hosts = ob->fallback_hostlist;
404
405 return OK;
406 }
407
408
409
410 /*************************************************
411 * Initialization entry point *
412 *************************************************/
413
414 /* Called for each instance, after its options have been read, to
415 enable consistency checks to be done, or anything else that needs
416 to be set up.
417
418 Argument: pointer to the transport instance block
419 Returns: nothing
420 */
421
422 void
423 smtp_transport_init(transport_instance *tblock)
424 {
425 smtp_transport_options_block *ob = SOB tblock->options_block;
426
427 /* Retry_use_local_part defaults FALSE if unset */
428
429 if (tblock->retry_use_local_part == TRUE_UNSET)
430 tblock->retry_use_local_part = FALSE;
431
432 /* Set the default port according to the protocol */
433
434 if (!ob->port)
435 ob->port = strcmpic(ob->protocol, US"lmtp") == 0
436 ? US"lmtp"
437 : strcmpic(ob->protocol, US"smtps") == 0
438 ? US"smtps" : US"smtp";
439
440 /* Set up the setup entry point, to be called before subprocesses for this
441 transport. */
442
443 tblock->setup = smtp_transport_setup;
444
445 /* Complain if any of the timeouts are zero. */
446
447 if (ob->command_timeout <= 0 || ob->data_timeout <= 0 ||
448 ob->final_timeout <= 0)
449 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
450 "command, data, or final timeout value is zero for %s transport",
451 tblock->name);
452
453 /* If hosts_override is set and there are local hosts, set the global
454 flag that stops verify from showing router hosts. */
455
456 if (ob->hosts_override && ob->hosts != NULL) tblock->overrides_hosts = TRUE;
457
458 /* If there are any fallback hosts listed, build a chain of host items
459 for them, but do not do any lookups at this time. */
460
461 host_build_hostlist(&(ob->fallback_hostlist), ob->fallback_hosts, FALSE);
462 }
463
464
465
466
467
468 /*************************************************
469 * Set delivery info into all active addresses *
470 *************************************************/
471
472 /* Only addresses whose status is >= PENDING are relevant. A lesser
473 status means that an address is not currently being processed.
474
475 Arguments:
476 addrlist points to a chain of addresses
477 errno_value to put in each address's errno field
478 msg to put in each address's message field
479 rc to put in each address's transport_return field
480 pass_message if TRUE, set the "pass message" flag in the address
481 host if set, mark addrs as having used this host
482 smtp_greeting from peer
483 helo_response from peer
484
485 If errno_value has the special value ERRNO_CONNECTTIMEOUT, ETIMEDOUT is put in
486 the errno field, and RTEF_CTOUT is ORed into the more_errno field, to indicate
487 this particular type of timeout.
488
489 Returns: nothing
490 */
491
492 static void
493 set_errno(address_item *addrlist, int errno_value, uschar *msg, int rc,
494 BOOL pass_message, host_item * host
495 #ifdef EXPERIMENTAL_DSN_INFO
496 , const uschar * smtp_greeting, const uschar * helo_response
497 #endif
498 )
499 {
500 address_item *addr;
501 int orvalue = 0;
502 if (errno_value == ERRNO_CONNECTTIMEOUT)
503 {
504 errno_value = ETIMEDOUT;
505 orvalue = RTEF_CTOUT;
506 }
507 for (addr = addrlist; addr; addr = addr->next)
508 if (addr->transport_return >= PENDING)
509 {
510 addr->basic_errno = errno_value;
511 addr->more_errno |= orvalue;
512 if (msg)
513 {
514 addr->message = msg;
515 if (pass_message) setflag(addr, af_pass_message);
516 }
517 addr->transport_return = rc;
518 if (host)
519 {
520 addr->host_used = host;
521 #ifdef EXPERIMENTAL_DSN_INFO
522 if (smtp_greeting)
523 {uschar * s = Ustrchr(smtp_greeting, '\n'); if (s) *s = '\0';}
524 addr->smtp_greeting = smtp_greeting;
525
526 if (helo_response)
527 {uschar * s = Ustrchr(helo_response, '\n'); if (s) *s = '\0';}
528 addr->helo_response = helo_response;
529 #endif
530 }
531 }
532 }
533
534 static void
535 set_errno_nohost(address_item *addrlist, int errno_value, uschar *msg, int rc,
536 BOOL pass_message)
537 {
538 set_errno(addrlist, errno_value, msg, rc, pass_message, NULL
539 #ifdef EXPERIMENTAL_DSN_INFO
540 , NULL, NULL
541 #endif
542 );
543 }
544
545
546 /*************************************************
547 * Check an SMTP response *
548 *************************************************/
549
550 /* This function is given an errno code and the SMTP response buffer
551 to analyse, together with the host identification for generating messages. It
552 sets an appropriate message and puts the first digit of the response code into
553 the yield variable. If no response was actually read, a suitable digit is
554 chosen.
555
556 Arguments:
557 host the current host, to get its name for messages
558 errno_value pointer to the errno value
559 more_errno from the top address for use with ERRNO_FILTER_FAIL
560 buffer the SMTP response buffer
561 yield where to put a one-digit SMTP response code
562 message where to put an error message
563 pass_message set TRUE if message is an SMTP response
564
565 Returns: TRUE if an SMTP "QUIT" command should be sent, else FALSE
566 */
567
568 static BOOL
569 check_response(host_item *host, int *errno_value, int more_errno,
570 uschar *buffer, int *yield, uschar **message, BOOL *pass_message)
571 {
572 uschar * pl = pipelining_active ? US"pipelined " : US"";
573 const uschar * s;
574
575 *yield = '4'; /* Default setting is to give a temporary error */
576
577 switch(*errno_value)
578 {
579 case ETIMEDOUT: /* Handle response timeout */
580 *message = US string_sprintf("SMTP timeout after %s%s",
581 pl, smtp_command);
582 if (transport_count > 0)
583 *message = US string_sprintf("%s (%d bytes written)", *message,
584 transport_count);
585 return FALSE;
586
587 case ERRNO_SMTPFORMAT: /* Handle malformed SMTP response */
588 s = string_printing(buffer);
589 while (isspace(*s)) s++;
590 *message = *s == 0
591 ? string_sprintf("Malformed SMTP reply (an empty line) "
592 "in response to %s%s", pl, smtp_command)
593 : string_sprintf("Malformed SMTP reply in response to %s%s: %s",
594 pl, smtp_command, s);
595 return FALSE;
596
597 case ERRNO_FILTER_FAIL: /* Handle a failed filter process error;
598 can't send QUIT as we mustn't end the DATA. */
599 *message = string_sprintf("transport filter process failed (%d)%s",
600 more_errno,
601 more_errno == EX_EXECFAILED ? ": unable to execute command" : "");
602 return FALSE;
603
604 case ERRNO_CHHEADER_FAIL: /* Handle a failed add_headers expansion;
605 can't send QUIT as we mustn't end the DATA. */
606 *message =
607 string_sprintf("failed to expand headers_add or headers_remove: %s",
608 expand_string_message);
609 return FALSE;
610
611 case ERRNO_WRITEINCOMPLETE: /* failure to write a complete data block */
612 *message = string_sprintf("failed to write a data block");
613 return FALSE;
614
615 #ifdef SUPPORT_I18N
616 case ERRNO_UTF8_FWD: /* no advertised SMTPUTF8, for international message */
617 *message = US"utf8 support required but not offered for forwarding";
618 DEBUG(D_deliver|D_transport) debug_printf("%s\n", *message);
619 return TRUE;
620 #endif
621 }
622
623 /* Handle error responses from the remote mailer. */
624
625 if (buffer[0] != 0)
626 {
627 *message = string_sprintf("SMTP error from remote mail server after %s%s: "
628 "%s", pl, smtp_command, s = string_printing(buffer));
629 *pass_message = TRUE;
630 *yield = buffer[0];
631 return TRUE;
632 }
633
634 /* No data was read. If there is no errno, this must be the EOF (i.e.
635 connection closed) case, which causes deferral. An explicit connection reset
636 error has the same effect. Otherwise, put the host's identity in the message,
637 leaving the errno value to be interpreted as well. In all cases, we have to
638 assume the connection is now dead. */
639
640 if (*errno_value == 0 || *errno_value == ECONNRESET)
641 {
642 *errno_value = ERRNO_SMTPCLOSED;
643 *message = US string_sprintf("Remote host closed connection "
644 "in response to %s%s", pl, smtp_command);
645 }
646 else
647 *message = US string_sprintf("%s [%s]", host->name, host->address);
648
649 return FALSE;
650 }
651
652
653
654 /*************************************************
655 * Write error message to logs *
656 *************************************************/
657
658 /* This writes to the main log and to the message log.
659
660 Arguments:
661 host the current host
662 detail the current message (addr_item->message)
663 basic_errno the errno (addr_item->basic_errno)
664
665 Returns: nothing
666 */
667
668 static void
669 write_logs(const host_item *host, const uschar *suffix, int basic_errno)
670 {
671 uschar *message = LOGGING(outgoing_port)
672 ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
673 host->port == PORT_NONE ? 25 : host->port)
674 : string_sprintf("H=%s [%s]", host->name, host->address);
675
676 if (suffix)
677 {
678 message = string_sprintf("%s: %s", message, suffix);
679 if (basic_errno > 0)
680 message = string_sprintf("%s: %s", message, strerror(basic_errno));
681 }
682 else
683 message = string_sprintf("%s %s", message, exim_errstr(basic_errno));
684
685 log_write(0, LOG_MAIN, "%s", message);
686 deliver_msglog("%s %s\n", tod_stamp(tod_log), message);
687 }
688
689 static void
690 msglog_line(host_item * host, uschar * message)
691 {
692 deliver_msglog("%s H=%s [%s] %s\n", tod_stamp(tod_log),
693 host->name, host->address, message);
694 }
695
696
697
698 #ifndef DISABLE_EVENT
699 /*************************************************
700 * Post-defer action *
701 *************************************************/
702
703 /* This expands an arbitrary per-transport string.
704 It might, for example, be used to write to the database log.
705
706 Arguments:
707 addr the address item containing error information
708 host the current host
709
710 Returns: nothing
711 */
712
713 static void
714 deferred_event_raise(address_item *addr, host_item *host)
715 {
716 uschar * action = addr->transport->event_action;
717 const uschar * save_domain;
718 uschar * save_local;
719
720 if (!action)
721 return;
722
723 save_domain = deliver_domain;
724 save_local = deliver_localpart;
725
726 /*XXX would ip & port already be set up? */
727 deliver_host_address = string_copy(host->address);
728 deliver_host_port = host->port == PORT_NONE ? 25 : host->port;
729 event_defer_errno = addr->basic_errno;
730
731 router_name = addr->router->name;
732 transport_name = addr->transport->name;
733 deliver_domain = addr->domain;
734 deliver_localpart = addr->local_part;
735
736 (void) event_raise(action, US"msg:host:defer",
737 addr->message
738 ? addr->basic_errno > 0
739 ? string_sprintf("%s: %s", addr->message, strerror(addr->basic_errno))
740 : string_copy(addr->message)
741 : addr->basic_errno > 0
742 ? string_copy(US strerror(addr->basic_errno))
743 : NULL);
744
745 deliver_localpart = save_local;
746 deliver_domain = save_domain;
747 router_name = transport_name = NULL;
748 }
749 #endif
750
751 /*************************************************
752 * Reap SMTP specific responses *
753 *************************************************/
754 static int
755 smtp_discard_responses(smtp_context * sx, smtp_transport_options_block * ob,
756 int count)
757 {
758 uschar flushbuffer[4096];
759
760 while (count-- > 0)
761 {
762 if (!smtp_read_response(sx, flushbuffer, sizeof(flushbuffer),
763 '2', ob->command_timeout)
764 && (errno != 0 || flushbuffer[0] == 0))
765 break;
766 }
767 return count;
768 }
769
770
771 /* Return boolean success */
772
773 static BOOL
774 smtp_reap_banner(smtp_context * sx)
775 {
776 BOOL good_response = smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
777 '2', (SOB sx->conn_args.ob)->command_timeout);
778 #ifdef EXPERIMENTAL_DSN_INFO
779 sx->smtp_greeting = string_copy(sx->buffer);
780 #endif
781 return good_response;
782 }
783
784 static BOOL
785 smtp_reap_ehlo(smtp_context * sx)
786 {
787 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
788 (SOB sx->conn_args.ob)->command_timeout))
789 {
790 if (errno != 0 || sx->buffer[0] == 0 || sx->lmtp)
791 {
792 #ifdef EXPERIMENTAL_DSN_INFO
793 sx->helo_response = string_copy(sx->buffer);
794 #endif
795 return FALSE;
796 }
797 sx->esmtp = FALSE;
798 }
799 #ifdef EXPERIMENTAL_DSN_INFO
800 sx->helo_response = string_copy(sx->buffer);
801 #endif
802 return TRUE;
803 }
804
805
806
807 #ifdef EXPERIMENTAL_PIPE_CONNECT
808 static uschar *
809 ehlo_cache_key(const smtp_context * sx)
810 {
811 host_item * host = sx->conn_args.host;
812 return Ustrchr(host->address, ':')
813 ? string_sprintf("[%s]:%d.EHLO", host->address,
814 host->port == PORT_NONE ? sx->port : host->port)
815 : string_sprintf("%s:%d.EHLO", host->address,
816 host->port == PORT_NONE ? sx->port : host->port);
817 }
818
819 static void
820 write_ehlo_cache_entry(const smtp_context * sx)
821 {
822 open_db dbblock, * dbm_file;
823
824 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
825 {
826 uschar * ehlo_resp_key = ehlo_cache_key(sx);
827 dbdata_ehlo_resp er = { .data = sx->ehlo_resp };
828
829 dbfn_write(dbm_file, ehlo_resp_key, &er, (int)sizeof(er));
830 dbfn_close(dbm_file);
831 }
832 }
833
834 static void
835 invalidate_ehlo_cache_entry(smtp_context * sx)
836 {
837 open_db dbblock, * dbm_file;
838
839 if ( sx->early_pipe_active
840 && (dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
841 {
842 uschar * ehlo_resp_key = ehlo_cache_key(sx);
843 dbfn_delete(dbm_file, ehlo_resp_key);
844 dbfn_close(dbm_file);
845 }
846 }
847
848 static BOOL
849 read_ehlo_cache_entry(smtp_context * sx)
850 {
851 open_db dbblock;
852 open_db * dbm_file;
853
854 if (!(dbm_file = dbfn_open(US"misc", O_RDONLY, &dbblock, FALSE)))
855 { DEBUG(D_transport) debug_printf("ehlo-cache: no misc DB\n"); }
856 else
857 {
858 uschar * ehlo_resp_key = ehlo_cache_key(sx);
859 dbdata_ehlo_resp * er;
860
861 if (!(er = dbfn_read(dbm_file, ehlo_resp_key)))
862 { DEBUG(D_transport) debug_printf("no ehlo-resp record\n"); }
863 else if (time(NULL) - er->time_stamp > retry_data_expire)
864 {
865 DEBUG(D_transport) debug_printf("ehlo-resp record too old\n");
866 dbfn_close(dbm_file);
867 if ((dbm_file = dbfn_open(US"misc", O_RDWR, &dbblock, TRUE)))
868 dbfn_delete(dbm_file, ehlo_resp_key);
869 }
870 else
871 {
872 sx->ehlo_resp = er->data;
873 dbfn_close(dbm_file);
874 DEBUG(D_transport) debug_printf(
875 "EHLO response bits from cache: cleartext 0x%04x crypted 0x%04x\n",
876 er->data.cleartext_features, er->data.crypted_features);
877 return TRUE;
878 }
879 dbfn_close(dbm_file);
880 }
881 return FALSE;
882 }
883
884
885
886 /* Return an auths bitmap for the set of AUTH methods offered by the server
887 which match our authenticators. */
888
889 static unsigned short
890 study_ehlo_auths(smtp_context * sx)
891 {
892 uschar * names;
893 auth_instance * au;
894 uschar authnum;
895 unsigned short authbits = 0;
896
897 if (!sx->esmtp) return 0;
898 if (!regex_AUTH) regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
899 if (!regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)) return 0;
900 expand_nmax = -1; /* reset */
901 names = string_copyn(expand_nstring[1], expand_nlength[1]);
902
903 for (au = auths, authnum = 0; au; au = au->next, authnum++) if (au->client)
904 {
905 const uschar * list = names;
906 int sep = ' ';
907 uschar name[32];
908
909 while (string_nextinlist(&list, &sep, name, sizeof(name)))
910 if (strcmpic(au->public_name, name) == 0)
911 { authbits |= BIT(authnum); break; }
912 }
913
914 DEBUG(D_transport)
915 debug_printf("server offers %s AUTH, methods '%s', bitmap 0x%04x\n",
916 tls_out.active.sock >= 0 ? "crypted" : "plaintext", names, authbits);
917
918 if (tls_out.active.sock >= 0)
919 sx->ehlo_resp.crypted_auths = authbits;
920 else
921 sx->ehlo_resp.cleartext_auths = authbits;
922 return authbits;
923 }
924
925
926
927
928 /* Wait for and check responses for early-pipelining.
929
930 Called from the lower-level smtp_read_response() function
931 used for general code that assume synchronisation, if context
932 flags indicate outstanding early-pipelining commands. Also
933 called fom sync_responses() which handles pipelined commands.
934
935 Arguments:
936 sx smtp connection context
937 countp number of outstanding responses, adjusted on return
938
939 Return:
940 OK all well
941 FAIL SMTP error in response
942 */
943 int
944 smtp_reap_early_pipe(smtp_context * sx, int * countp)
945 {
946 BOOL pending_BANNER = sx->pending_BANNER;
947 BOOL pending_EHLO = sx->pending_EHLO;
948
949 sx->pending_BANNER = FALSE; /* clear early to avoid recursion */
950 sx->pending_EHLO = FALSE;
951
952 if (pending_BANNER)
953 {
954 DEBUG(D_transport) debug_printf("%s expect banner\n", __FUNCTION__);
955 (*countp)--;
956 if (!smtp_reap_banner(sx))
957 {
958 DEBUG(D_transport) debug_printf("bad banner\n");
959 goto fail;
960 }
961 }
962
963 if (pending_EHLO)
964 {
965 unsigned peer_offered;
966 unsigned short authbits = 0, * ap;
967
968 DEBUG(D_transport) debug_printf("%s expect ehlo\n", __FUNCTION__);
969 (*countp)--;
970 if (!smtp_reap_ehlo(sx))
971 {
972 DEBUG(D_transport) debug_printf("bad response for EHLO\n");
973 goto fail;
974 }
975
976 /* Compare the actual EHLO response to the cached value we assumed;
977 on difference, dump or rewrite the cache and arrange for a retry. */
978
979 ap = tls_out.active.sock < 0
980 ? &sx->ehlo_resp.cleartext_auths : &sx->ehlo_resp.crypted_auths;
981
982 peer_offered = ehlo_response(sx->buffer,
983 (tls_out.active.sock < 0 ? OPTION_TLS : OPTION_REQUIRETLS)
984 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
985 | OPTION_UTF8 | OPTION_EARLY_PIPE
986 );
987 if ( peer_offered != sx->peer_offered
988 || (authbits = study_ehlo_auths(sx)) != *ap)
989 {
990 HDEBUG(D_transport)
991 debug_printf("EHLO extensions changed, 0x%04x/0x%04x -> 0x%04x/0x%04x\n",
992 sx->peer_offered, *ap, peer_offered, authbits);
993 *ap = authbits;
994 if (peer_offered & OPTION_EARLY_PIPE)
995 write_ehlo_cache_entry(sx);
996 else
997 invalidate_ehlo_cache_entry(sx);
998
999 return OK; /* just carry on */
1000 }
1001 }
1002 return OK;
1003
1004 fail:
1005 invalidate_ehlo_cache_entry(sx);
1006 (void) smtp_discard_responses(sx, sx->conn_args.ob, *countp);
1007 return FAIL;
1008 }
1009 #endif
1010
1011
1012 /*************************************************
1013 * Synchronize SMTP responses *
1014 *************************************************/
1015
1016 /* This function is called from smtp_deliver() to receive SMTP responses from
1017 the server, and match them up with the commands to which they relate. When
1018 PIPELINING is not in use, this function is called after every command, and is
1019 therefore somewhat over-engineered, but it is simpler to use a single scheme
1020 that works both with and without PIPELINING instead of having two separate sets
1021 of code.
1022
1023 The set of commands that are buffered up with pipelining may start with MAIL
1024 and may end with DATA; in between are RCPT commands that correspond to the
1025 addresses whose status is PENDING_DEFER. All other commands (STARTTLS, AUTH,
1026 etc.) are never buffered.
1027
1028 Errors after MAIL or DATA abort the whole process leaving the response in the
1029 buffer. After MAIL, pending responses are flushed, and the original command is
1030 re-instated in big_buffer for error messages. For RCPT commands, the remote is
1031 permitted to reject some recipient addresses while accepting others. However
1032 certain errors clearly abort the whole process. Set the value in
1033 transport_return to PENDING_OK if the address is accepted. If there is a
1034 subsequent general error, it will get reset accordingly. If not, it will get
1035 converted to OK at the end.
1036
1037 Arguments:
1038 sx smtp connection context
1039 count the number of responses to read
1040 pending_DATA 0 if last command sent was not DATA
1041 +1 if previously had a good recipient
1042 -1 if not previously had a good recipient
1043
1044 Returns: 3 if at least one address had 2xx and one had 5xx
1045 2 if at least one address had 5xx but none had 2xx
1046 1 if at least one host had a 2xx response, but none had 5xx
1047 0 no address had 2xx or 5xx but no errors (all 4xx, or just DATA)
1048 -1 timeout while reading RCPT response
1049 -2 I/O or other non-response error for RCPT
1050 -3 DATA or MAIL failed - errno and buffer set
1051 -4 banner or EHLO failed (early-pipelining)
1052 */
1053
1054 static int
1055 sync_responses(smtp_context * sx, int count, int pending_DATA)
1056 {
1057 address_item * addr = sx->sync_addr;
1058 smtp_transport_options_block * ob = sx->conn_args.ob;
1059 int yield = 0;
1060
1061 #ifdef EXPERIMENTAL_PIPE_CONNECT
1062 if (smtp_reap_early_pipe(sx, &count) != OK)
1063 return -4;
1064 #endif
1065
1066 /* Handle the response for a MAIL command. On error, reinstate the original
1067 command in big_buffer for error message use, and flush any further pending
1068 responses before returning, except after I/O errors and timeouts. */
1069
1070 if (sx->pending_MAIL)
1071 {
1072 DEBUG(D_transport) debug_printf("%s expect mail\n", __FUNCTION__);
1073 count--;
1074 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1075 '2', ob->command_timeout))
1076 {
1077 DEBUG(D_transport) debug_printf("bad response for MAIL\n");
1078 Ustrcpy(big_buffer, mail_command); /* Fits, because it came from there! */
1079 if (errno == 0 && sx->buffer[0] != 0)
1080 {
1081 int save_errno = 0;
1082 if (sx->buffer[0] == '4')
1083 {
1084 save_errno = ERRNO_MAIL4XX;
1085 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1086 }
1087 count = smtp_discard_responses(sx, ob, count);
1088 errno = save_errno;
1089 }
1090
1091 if (pending_DATA) count--; /* Number of RCPT responses to come */
1092 while (count-- > 0) /* Mark any pending addrs with the host used */
1093 {
1094 while (addr->transport_return != PENDING_DEFER) addr = addr->next;
1095 addr->host_used = sx->conn_args.host;
1096 addr = addr->next;
1097 }
1098 return -3;
1099 }
1100 }
1101
1102 if (pending_DATA) count--; /* Number of RCPT responses to come */
1103
1104 /* Read and handle the required number of RCPT responses, matching each one up
1105 with an address by scanning for the next address whose status is PENDING_DEFER.
1106 */
1107
1108 while (count-- > 0)
1109 {
1110 while (addr->transport_return != PENDING_DEFER)
1111 if (!(addr = addr->next))
1112 return -2;
1113
1114 /* The address was accepted */
1115 addr->host_used = sx->conn_args.host;
1116
1117 DEBUG(D_transport) debug_printf("%s expect rcpt\n", __FUNCTION__);
1118 if (smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1119 '2', ob->command_timeout))
1120 {
1121 yield |= 1;
1122 addr->transport_return = PENDING_OK;
1123
1124 /* If af_dr_retry_exists is set, there was a routing delay on this address;
1125 ensure that any address-specific retry record is expunged. We do this both
1126 for the basic key and for the version that also includes the sender. */
1127
1128 if (testflag(addr, af_dr_retry_exists))
1129 {
1130 uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
1131 sender_address);
1132 retry_add_item(addr, altkey, rf_delete);
1133 retry_add_item(addr, addr->address_retry_key, rf_delete);
1134 }
1135 }
1136
1137 /* Timeout while reading the response */
1138
1139 else if (errno == ETIMEDOUT)
1140 {
1141 uschar *message = string_sprintf("SMTP timeout after RCPT TO:<%s>",
1142 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1143 set_errno_nohost(sx->first_addr, ETIMEDOUT, message, DEFER, FALSE);
1144 retry_add_item(addr, addr->address_retry_key, 0);
1145 update_waiting = FALSE;
1146 return -1;
1147 }
1148
1149 /* Handle other errors in obtaining an SMTP response by returning -1. This
1150 will cause all the addresses to be deferred. Restore the SMTP command in
1151 big_buffer for which we are checking the response, so the error message
1152 makes sense. */
1153
1154 else if (errno != 0 || sx->buffer[0] == 0)
1155 {
1156 string_format(big_buffer, big_buffer_size, "RCPT TO:<%s>",
1157 transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes));
1158 return -2;
1159 }
1160
1161 /* Handle SMTP permanent and temporary response codes. */
1162
1163 else
1164 {
1165 addr->message =
1166 string_sprintf("SMTP error from remote mail server after RCPT TO:<%s>: "
1167 "%s", transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes),
1168 string_printing(sx->buffer));
1169 setflag(addr, af_pass_message);
1170 if (!sx->verify)
1171 msglog_line(sx->conn_args.host, addr->message);
1172
1173 /* The response was 5xx */
1174
1175 if (sx->buffer[0] == '5')
1176 {
1177 addr->transport_return = FAIL;
1178 yield |= 2;
1179 }
1180
1181 /* The response was 4xx */
1182
1183 else
1184 {
1185 addr->transport_return = DEFER;
1186 addr->basic_errno = ERRNO_RCPT4XX;
1187 addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1188
1189 if (!sx->verify)
1190 {
1191 #ifndef DISABLE_EVENT
1192 event_defer_errno = addr->more_errno;
1193 msg_event_raise(US"msg:rcpt:host:defer", addr);
1194 #endif
1195
1196 /* Log temporary errors if there are more hosts to be tried.
1197 If not, log this last one in the == line. */
1198
1199 if (sx->conn_args.host->next)
1200 log_write(0, LOG_MAIN, "H=%s [%s]: %s",
1201 sx->conn_args.host->name, sx->conn_args.host->address, addr->message);
1202
1203 #ifndef DISABLE_EVENT
1204 else
1205 msg_event_raise(US"msg:rcpt:defer", addr);
1206 #endif
1207
1208 /* Do not put this message on the list of those waiting for specific
1209 hosts, as otherwise it is likely to be tried too often. */
1210
1211 update_waiting = FALSE;
1212
1213 /* Add a retry item for the address so that it doesn't get tried again
1214 too soon. If address_retry_include_sender is true, add the sender address
1215 to the retry key. */
1216
1217 retry_add_item(addr,
1218 ob->address_retry_include_sender
1219 ? string_sprintf("%s:<%s>", addr->address_retry_key, sender_address)
1220 : addr->address_retry_key,
1221 0);
1222 }
1223 }
1224 }
1225 } /* Loop for next RCPT response */
1226
1227 /* Update where to start at for the next block of responses, unless we
1228 have already handled all the addresses. */
1229
1230 if (addr) sx->sync_addr = addr->next;
1231
1232 /* Handle a response to DATA. If we have not had any good recipients, either
1233 previously or in this block, the response is ignored. */
1234
1235 if (pending_DATA != 0)
1236 {
1237 DEBUG(D_transport) debug_printf("%s expect data\n", __FUNCTION__);
1238 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer),
1239 '3', ob->command_timeout))
1240 {
1241 int code;
1242 uschar *msg;
1243 BOOL pass_message;
1244 if (pending_DATA > 0 || (yield & 1) != 0)
1245 {
1246 if (errno == 0 && sx->buffer[0] == '4')
1247 {
1248 errno = ERRNO_DATA4XX;
1249 sx->first_addr->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1250 }
1251 return -3;
1252 }
1253 (void)check_response(sx->conn_args.host, &errno, 0, sx->buffer, &code, &msg, &pass_message);
1254 DEBUG(D_transport) debug_printf("%s\nerror for DATA ignored: pipelining "
1255 "is in use and there were no good recipients\n", msg);
1256 }
1257 }
1258
1259 /* All responses read and handled; MAIL (if present) received 2xx and DATA (if
1260 present) received 3xx. If any RCPTs were handled and yielded anything other
1261 than 4xx, yield will be set non-zero. */
1262
1263 return yield;
1264 }
1265
1266
1267
1268
1269
1270 /* Try an authenticator's client entry */
1271
1272 static int
1273 try_authenticator(smtp_context * sx, auth_instance * au)
1274 {
1275 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1276 host_item * host = sx->conn_args.host; /* host to deliver to */
1277 int rc;
1278
1279 sx->outblock.authenticating = TRUE;
1280 rc = (au->info->clientcode)(au, sx, ob->command_timeout,
1281 sx->buffer, sizeof(sx->buffer));
1282 sx->outblock.authenticating = FALSE;
1283 DEBUG(D_transport) debug_printf("%s authenticator yielded %d\n", au->name, rc);
1284
1285 /* A temporary authentication failure must hold up delivery to
1286 this host. After a permanent authentication failure, we carry on
1287 to try other authentication methods. If all fail hard, try to
1288 deliver the message unauthenticated unless require_auth was set. */
1289
1290 switch(rc)
1291 {
1292 case OK:
1293 f.smtp_authenticated = TRUE; /* stops the outer loop */
1294 client_authenticator = au->name;
1295 if (au->set_client_id)
1296 client_authenticated_id = expand_string(au->set_client_id);
1297 break;
1298
1299 /* Failure after writing a command */
1300
1301 case FAIL_SEND:
1302 return FAIL_SEND;
1303
1304 /* Failure after reading a response */
1305
1306 case FAIL:
1307 if (errno != 0 || sx->buffer[0] != '5') return FAIL;
1308 log_write(0, LOG_MAIN, "%s authenticator failed H=%s [%s] %s",
1309 au->name, host->name, host->address, sx->buffer);
1310 break;
1311
1312 /* Failure by some other means. In effect, the authenticator
1313 decided it wasn't prepared to handle this case. Typically this
1314 is the result of "fail" in an expansion string. Do we need to
1315 log anything here? Feb 2006: a message is now put in the buffer
1316 if logging is required. */
1317
1318 case CANCELLED:
1319 if (*sx->buffer != 0)
1320 log_write(0, LOG_MAIN, "%s authenticator cancelled "
1321 "authentication H=%s [%s] %s", au->name, host->name,
1322 host->address, sx->buffer);
1323 break;
1324
1325 /* Internal problem, message in buffer. */
1326
1327 case ERROR:
1328 set_errno_nohost(sx->addrlist, ERRNO_AUTHPROB, string_copy(sx->buffer),
1329 DEFER, FALSE);
1330 return ERROR;
1331 }
1332 return OK;
1333 }
1334
1335
1336
1337
1338 /* Do the client side of smtp-level authentication.
1339
1340 Arguments:
1341 sx smtp connection context
1342
1343 sx->buffer should have the EHLO response from server (gets overwritten)
1344
1345 Returns:
1346 OK Success, or failed (but not required): global "smtp_authenticated" set
1347 DEFER Failed authentication (and was required)
1348 ERROR Internal problem
1349
1350 FAIL_SEND Failed communications - transmit
1351 FAIL - response
1352 */
1353
1354 static int
1355 smtp_auth(smtp_context * sx)
1356 {
1357 host_item * host = sx->conn_args.host; /* host to deliver to */
1358 smtp_transport_options_block * ob = sx->conn_args.ob; /* transport options */
1359 int require_auth = verify_check_given_host(CUSS &ob->hosts_require_auth, host);
1360 #ifdef EXPERIMENTAL_PIPE_CONNECT
1361 unsigned short authbits = tls_out.active.sock >= 0
1362 ? sx->ehlo_resp.crypted_auths : sx->ehlo_resp.cleartext_auths;
1363 #endif
1364 uschar * fail_reason = US"server did not advertise AUTH support";
1365
1366 f.smtp_authenticated = FALSE;
1367 client_authenticator = client_authenticated_id = client_authenticated_sender = NULL;
1368
1369 if (!regex_AUTH)
1370 regex_AUTH = regex_must_compile(AUTHS_REGEX, FALSE, TRUE);
1371
1372 /* Is the server offering AUTH? */
1373
1374 if ( sx->esmtp
1375 &&
1376 #ifdef EXPERIMENTAL_PIPE_CONNECT
1377 sx->early_pipe_active ? authbits
1378 :
1379 #endif
1380 regex_match_and_setup(regex_AUTH, sx->buffer, 0, -1)
1381 )
1382 {
1383 uschar * names = NULL;
1384 expand_nmax = -1; /* reset */
1385
1386 #ifdef EXPERIMENTAL_PIPE_CONNECT
1387 if (!sx->early_pipe_active)
1388 #endif
1389 names = string_copyn(expand_nstring[1], expand_nlength[1]);
1390
1391 /* Must not do this check until after we have saved the result of the
1392 regex match above as the check could be another RE. */
1393
1394 if ( require_auth == OK
1395 || verify_check_given_host(CUSS &ob->hosts_try_auth, host) == OK)
1396 {
1397 auth_instance * au;
1398
1399 DEBUG(D_transport) debug_printf("scanning authentication mechanisms\n");
1400 fail_reason = US"no common mechanisms were found";
1401
1402 #ifdef EXPERIMENTAL_PIPE_CONNECT
1403 if (sx->early_pipe_active)
1404 {
1405 /* Scan our authenticators (which support use by a client and were offered
1406 by the server (checked at cache-write time)), not suppressed by
1407 client_condition. If one is found, attempt to authenticate by calling its
1408 client function. We are limited to supporting up to 16 authenticator
1409 public-names by the number of bits in a short. */
1410
1411 uschar bitnum;
1412 int rc;
1413
1414 for (bitnum = 0, au = auths;
1415 !f.smtp_authenticated && au && bitnum < 16;
1416 bitnum++, au = au->next) if (authbits & BIT(bitnum))
1417 {
1418 if ( au->client_condition
1419 && !expand_check_condition(au->client_condition, au->name,
1420 US"client authenticator"))
1421 {
1422 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1423 au->name, "client_condition is false");
1424 continue;
1425 }
1426
1427 /* Found data for a listed mechanism. Call its client entry. Set
1428 a flag in the outblock so that data is overwritten after sending so
1429 that reflections don't show it. */
1430
1431 fail_reason = US"authentication attempt(s) failed";
1432
1433 if ((rc = try_authenticator(sx, au)) != OK)
1434 return rc;
1435 }
1436 }
1437 else
1438 #endif
1439
1440 /* Scan the configured authenticators looking for one which is configured
1441 for use as a client, which is not suppressed by client_condition, and
1442 whose name matches an authentication mechanism supported by the server.
1443 If one is found, attempt to authenticate by calling its client function.
1444 */
1445
1446 for (au = auths; !f.smtp_authenticated && au; au = au->next)
1447 {
1448 uschar *p = names;
1449
1450 if ( !au->client
1451 || ( au->client_condition
1452 && !expand_check_condition(au->client_condition, au->name,
1453 US"client authenticator")))
1454 {
1455 DEBUG(D_transport) debug_printf("skipping %s authenticator: %s\n",
1456 au->name,
1457 (au->client)? "client_condition is false" :
1458 "not configured as a client");
1459 continue;
1460 }
1461
1462 /* Loop to scan supported server mechanisms */
1463
1464 while (*p)
1465 {
1466 int len = Ustrlen(au->public_name);
1467 int rc;
1468
1469 while (isspace(*p)) p++;
1470
1471 if (strncmpic(au->public_name, p, len) != 0 ||
1472 (p[len] != 0 && !isspace(p[len])))
1473 {
1474 while (*p != 0 && !isspace(*p)) p++;
1475 continue;
1476 }
1477
1478 /* Found data for a listed mechanism. Call its client entry. Set
1479 a flag in the outblock so that data is overwritten after sending so
1480 that reflections don't show it. */
1481
1482 fail_reason = US"authentication attempt(s) failed";
1483
1484 if ((rc = try_authenticator(sx, au)) != OK)
1485 return rc;
1486
1487 break; /* If not authenticated, try next authenticator */
1488 } /* Loop for scanning supported server mechanisms */
1489 } /* Loop for further authenticators */
1490 }
1491 }
1492
1493 /* If we haven't authenticated, but are required to, give up. */
1494
1495 if (require_auth == OK && !f.smtp_authenticated)
1496 {
1497 set_errno_nohost(sx->addrlist, ERRNO_AUTHFAIL,
1498 string_sprintf("authentication required but %s", fail_reason), DEFER,
1499 FALSE);
1500 return DEFER;
1501 }
1502
1503 return OK;
1504 }
1505
1506
1507 /* Construct AUTH appendix string for MAIL TO */
1508 /*
1509 Arguments
1510 buffer to build string
1511 addrlist chain of potential addresses to deliver
1512 ob transport options
1513
1514 Globals f.smtp_authenticated
1515 client_authenticated_sender
1516 Return True on error, otherwise buffer has (possibly empty) terminated string
1517 */
1518
1519 BOOL
1520 smtp_mail_auth_str(uschar *buffer, unsigned bufsize, address_item *addrlist,
1521 smtp_transport_options_block *ob)
1522 {
1523 uschar *local_authenticated_sender = authenticated_sender;
1524
1525 #ifdef notdef
1526 debug_printf("smtp_mail_auth_str: as<%s> os<%s> SA<%s>\n", authenticated_sender, ob->authenticated_sender, f.smtp_authenticated?"Y":"N");
1527 #endif
1528
1529 if (ob->authenticated_sender != NULL)
1530 {
1531 uschar *new = expand_string(ob->authenticated_sender);
1532 if (new == NULL)
1533 {
1534 if (!f.expand_string_forcedfail)
1535 {
1536 uschar *message = string_sprintf("failed to expand "
1537 "authenticated_sender: %s", expand_string_message);
1538 set_errno_nohost(addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
1539 return TRUE;
1540 }
1541 }
1542 else if (new[0] != 0) local_authenticated_sender = new;
1543 }
1544
1545 /* Add the authenticated sender address if present */
1546
1547 if ((f.smtp_authenticated || ob->authenticated_sender_force) &&
1548 local_authenticated_sender != NULL)
1549 {
1550 string_format(buffer, bufsize, " AUTH=%s",
1551 auth_xtextencode(local_authenticated_sender,
1552 Ustrlen(local_authenticated_sender)));
1553 client_authenticated_sender = string_copy(local_authenticated_sender);
1554 }
1555 else
1556 *buffer= 0;
1557
1558 return FALSE;
1559 }
1560
1561
1562
1563 #ifdef SUPPORT_DANE
1564 /* Lookup TLSA record for host/port.
1565 Return: OK success with dnssec; DANE mode
1566 DEFER Do not use this host now, may retry later
1567 FAIL_FORCED No TLSA record; DANE not usable
1568 FAIL Do not use this connection
1569 */
1570
1571 int
1572 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
1573 {
1574 /* move this out to host.c given the similarity to dns_lookup() ? */
1575 uschar buffer[300];
1576 const uschar * fullname = buffer;
1577 int rc;
1578 BOOL sec;
1579
1580 /* TLSA lookup string */
1581 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
1582
1583 rc = dns_lookup(dnsa, buffer, T_TLSA, &fullname);
1584 sec = dns_is_secure(dnsa);
1585 DEBUG(D_transport)
1586 debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
1587
1588 switch (rc)
1589 {
1590 case DNS_AGAIN:
1591 return DEFER; /* just defer this TLS'd conn */
1592
1593 case DNS_SUCCEED:
1594 if (sec)
1595 {
1596 DEBUG(D_transport)
1597 {
1598 dns_scan dnss;
1599 dns_record * rr;
1600 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
1601 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
1602 if (rr->type == T_TLSA && rr->size > 3)
1603 {
1604 uint16_t payload_length = rr->size - 3;
1605 uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
1606
1607 sp += sprintf(CS sp, "%d ", *p++); /* usage */
1608 sp += sprintf(CS sp, "%d ", *p++); /* selector */
1609 sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
1610 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
1611 sp += sprintf(CS sp, "%02x", *p++);
1612
1613 debug_printf(" %s\n", s);
1614 }
1615 }
1616 return OK;
1617 }
1618 log_write(0, LOG_MAIN,
1619 "DANE error: TLSA lookup for %s not DNSSEC", host->name);
1620 /*FALLTRHOUGH*/
1621
1622 case DNS_NODATA: /* no TLSA RR for this lookup */
1623 case DNS_NOMATCH: /* no records at all for this lookup */
1624 return dane_required ? FAIL : FAIL_FORCED;
1625
1626 default:
1627 case DNS_FAIL:
1628 return dane_required ? FAIL : DEFER;
1629 }
1630 }
1631 #endif
1632
1633
1634
1635 typedef struct smtp_compare_s
1636 {
1637 uschar *current_sender_address;
1638 struct transport_instance *tblock;
1639 } smtp_compare_t;
1640
1641
1642 /* Create a unique string that identifies this message, it is based on
1643 sender_address, helo_data and tls_certificate if enabled.
1644 */
1645
1646 static uschar *
1647 smtp_local_identity(uschar * sender, struct transport_instance * tblock)
1648 {
1649 address_item * addr1;
1650 uschar * if1 = US"";
1651 uschar * helo1 = US"";
1652 #ifdef SUPPORT_TLS
1653 uschar * tlsc1 = US"";
1654 #endif
1655 uschar * save_sender_address = sender_address;
1656 uschar * local_identity = NULL;
1657 smtp_transport_options_block * ob = SOB tblock->options_block;
1658
1659 sender_address = sender;
1660
1661 addr1 = deliver_make_addr (sender, TRUE);
1662 deliver_set_expansions(addr1);
1663
1664 if (ob->interface)
1665 if1 = expand_string(ob->interface);
1666
1667 if (ob->helo_data)
1668 helo1 = expand_string(ob->helo_data);
1669
1670 #ifdef SUPPORT_TLS
1671 if (ob->tls_certificate)
1672 tlsc1 = expand_string(ob->tls_certificate);
1673 local_identity = string_sprintf ("%s^%s^%s", if1, helo1, tlsc1);
1674 #else
1675 local_identity = string_sprintf ("%s^%s", if1, helo1);
1676 #endif
1677
1678 deliver_set_expansions(NULL);
1679 sender_address = save_sender_address;
1680
1681 return local_identity;
1682 }
1683
1684
1685
1686 /* This routine is a callback that is called from transport_check_waiting.
1687 This function will evaluate the incoming message versus the previous
1688 message. If the incoming message is using a different local identity then
1689 we will veto this new message. */
1690
1691 static BOOL
1692 smtp_are_same_identities(uschar * message_id, smtp_compare_t * s_compare)
1693 {
1694 uschar * message_local_identity,
1695 * current_local_identity,
1696 * new_sender_address;
1697
1698 current_local_identity =
1699 smtp_local_identity(s_compare->current_sender_address, s_compare->tblock);
1700
1701 if (!(new_sender_address = deliver_get_sender_address(message_id)))
1702 return 0;
1703
1704 message_local_identity =
1705 smtp_local_identity(new_sender_address, s_compare->tblock);
1706
1707 return Ustrcmp(current_local_identity, message_local_identity) == 0;
1708 }
1709
1710
1711
1712 static unsigned
1713 ehlo_response(uschar * buf, unsigned checks)
1714 {
1715 size_t bsize = Ustrlen(buf);
1716
1717 /* debug_printf("%s: check for 0x%04x\n", __FUNCTION__, checks); */
1718
1719 #ifdef SUPPORT_TLS
1720 # ifdef EXPERIMENTAL_REQUIRETLS
1721 if ( checks & OPTION_REQUIRETLS
1722 && pcre_exec(regex_REQUIRETLS, NULL, CS buf,bsize, 0, PCRE_EOPT, NULL,0) < 0)
1723 # endif
1724 checks &= ~OPTION_REQUIRETLS;
1725
1726 if ( checks & OPTION_TLS
1727 && pcre_exec(regex_STARTTLS, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1728 #endif
1729 checks &= ~OPTION_TLS;
1730
1731 if ( checks & OPTION_IGNQ
1732 && pcre_exec(regex_IGNOREQUOTA, NULL, CS buf, bsize, 0,
1733 PCRE_EOPT, NULL, 0) < 0)
1734 checks &= ~OPTION_IGNQ;
1735
1736 if ( checks & OPTION_CHUNKING
1737 && pcre_exec(regex_CHUNKING, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1738 checks &= ~OPTION_CHUNKING;
1739
1740 #ifndef DISABLE_PRDR
1741 if ( checks & OPTION_PRDR
1742 && pcre_exec(regex_PRDR, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1743 #endif
1744 checks &= ~OPTION_PRDR;
1745
1746 #ifdef SUPPORT_I18N
1747 if ( checks & OPTION_UTF8
1748 && pcre_exec(regex_UTF8, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1749 #endif
1750 checks &= ~OPTION_UTF8;
1751
1752 if ( checks & OPTION_DSN
1753 && pcre_exec(regex_DSN, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1754 checks &= ~OPTION_DSN;
1755
1756 if ( checks & OPTION_PIPE
1757 && pcre_exec(regex_PIPELINING, NULL, CS buf, bsize, 0,
1758 PCRE_EOPT, NULL, 0) < 0)
1759 checks &= ~OPTION_PIPE;
1760
1761 if ( checks & OPTION_SIZE
1762 && pcre_exec(regex_SIZE, NULL, CS buf, bsize, 0, PCRE_EOPT, NULL, 0) < 0)
1763 checks &= ~OPTION_SIZE;
1764
1765 #ifdef EXPERIMENTAL_PIPE_CONNECT
1766 if ( checks & OPTION_EARLY_PIPE
1767 && pcre_exec(regex_EARLY_PIPE, NULL, CS buf, bsize, 0,
1768 PCRE_EOPT, NULL, 0) < 0)
1769 #endif
1770 checks &= ~OPTION_EARLY_PIPE;
1771
1772 /* debug_printf("%s: found 0x%04x\n", __FUNCTION__, checks); */
1773 return checks;
1774 }
1775
1776
1777
1778 /* Callback for emitting a BDAT data chunk header.
1779
1780 If given a nonzero size, first flush any buffered SMTP commands
1781 then emit the command.
1782
1783 Reap previous SMTP command responses if requested, and always reap
1784 the response from a previous BDAT command.
1785
1786 Args:
1787 tctx transport context
1788 chunk_size value for SMTP BDAT command
1789 flags
1790 tc_chunk_last add LAST option to SMTP BDAT command
1791 tc_reap_prev reap response to previous SMTP commands
1792
1793 Returns: OK or ERROR
1794 */
1795
1796 static int
1797 smtp_chunk_cmd_callback(transport_ctx * tctx, unsigned chunk_size,
1798 unsigned flags)
1799 {
1800 smtp_transport_options_block * ob = SOB tctx->tblock->options_block;
1801 smtp_context * sx = tctx->smtp_context;
1802 int cmd_count = 0;
1803 int prev_cmd_count;
1804
1805 /* Write SMTP chunk header command. If not reaping responses, note that
1806 there may be more writes (like, the chunk data) done soon. */
1807
1808 if (chunk_size > 0)
1809 {
1810 #ifdef EXPERIMENTAL_PIPE_CONNECT
1811 BOOL new_conn = !!(sx->outblock.conn_args);
1812 #endif
1813 if((cmd_count = smtp_write_command(sx,
1814 flags & tc_reap_prev ? SCMD_FLUSH : SCMD_MORE,
1815 "BDAT %u%s\r\n", chunk_size, flags & tc_chunk_last ? " LAST" : "")
1816 ) < 0) return ERROR;
1817 if (flags & tc_chunk_last)
1818 data_command = string_copy(big_buffer); /* Save for later error message */
1819 #ifdef EXPERIMENTAL_PIPE_CONNECT
1820 /* That command write could have been the one that made the connection.
1821 Copy the fd from the client conn ctx (smtp transport specific) to the
1822 generic transport ctx. */
1823
1824 if (new_conn)
1825 tctx->u.fd = sx->outblock.cctx->sock;
1826 #endif
1827 }
1828
1829 prev_cmd_count = cmd_count += sx->cmd_count;
1830
1831 /* Reap responses for any previous, but not one we just emitted */
1832
1833 if (chunk_size > 0)
1834 prev_cmd_count--;
1835 if (sx->pending_BDAT)
1836 prev_cmd_count--;
1837
1838 if (flags & tc_reap_prev && prev_cmd_count > 0)
1839 {
1840 DEBUG(D_transport) debug_printf("look for %d responses"
1841 " for previous pipelined cmds\n", prev_cmd_count);
1842
1843 switch(sync_responses(sx, prev_cmd_count, 0))
1844 {
1845 case 1: /* 2xx (only) => OK */
1846 case 3: sx->good_RCPT = TRUE; /* 2xx & 5xx => OK & progress made */
1847 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
1848 case 0: break; /* No 2xx or 5xx, but no probs */
1849
1850 case -1: /* Timeout on RCPT */
1851 #ifdef EXPERIMENTAL_PIPE_CONNECT
1852 case -4: /* non-2xx for pipelined banner or EHLO */
1853 #endif
1854 default: return ERROR; /* I/O error, or any MAIL/DATA error */
1855 }
1856 cmd_count = 1;
1857 if (!sx->pending_BDAT)
1858 pipelining_active = FALSE;
1859 }
1860
1861 /* Reap response for an outstanding BDAT */
1862
1863 if (sx->pending_BDAT)
1864 {
1865 DEBUG(D_transport) debug_printf("look for one response for BDAT\n");
1866
1867 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
1868 ob->command_timeout))
1869 {
1870 if (errno == 0 && sx->buffer[0] == '4')
1871 {
1872 errno = ERRNO_DATA4XX; /*XXX does this actually get used? */
1873 sx->addrlist->more_errno |=
1874 ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
1875 }
1876 return ERROR;
1877 }
1878 cmd_count--;
1879 sx->pending_BDAT = FALSE;
1880 pipelining_active = FALSE;
1881 }
1882 else if (chunk_size > 0)
1883 sx->pending_BDAT = TRUE;
1884
1885
1886 sx->cmd_count = cmd_count;
1887 return OK;
1888 }
1889
1890
1891
1892
1893
1894 /*************************************************
1895 * Make connection for given message *
1896 *************************************************/
1897
1898 /*
1899 Arguments:
1900 ctx connection context
1901 suppress_tls if TRUE, don't attempt a TLS connection - this is set for
1902 a second attempt after TLS initialization fails
1903
1904 Returns: OK - the connection was made and the delivery attempted;
1905 fd is set in the conn context, tls_out set up.
1906 DEFER - the connection could not be made, or something failed
1907 while setting up the SMTP session, or there was a
1908 non-message-specific error, such as a timeout.
1909 ERROR - helo_data or add_headers or authenticated_sender is
1910 specified for this transport, and the string failed
1911 to expand
1912 */
1913 int
1914 smtp_setup_conn(smtp_context * sx, BOOL suppress_tls)
1915 {
1916 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1917 dns_answer tlsa_dnsa;
1918 #endif
1919 smtp_transport_options_block * ob = sx->conn_args.tblock->options_block;
1920 BOOL pass_message = FALSE;
1921 uschar * message = NULL;
1922 int yield = OK;
1923 int rc;
1924
1925 sx->conn_args.ob = ob;
1926
1927 sx->lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
1928 sx->smtps = strcmpic(ob->protocol, US"smtps") == 0;
1929 sx->ok = FALSE;
1930 sx->send_rset = TRUE;
1931 sx->send_quit = TRUE;
1932 sx->setting_up = TRUE;
1933 sx->esmtp = TRUE;
1934 sx->esmtp_sent = FALSE;
1935 #ifdef SUPPORT_I18N
1936 sx->utf8_needed = FALSE;
1937 #endif
1938 sx->dsn_all_lasthop = TRUE;
1939 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
1940 sx->dane = FALSE;
1941 sx->dane_required =
1942 verify_check_given_host(CUSS &ob->hosts_require_dane, sx->conn_args.host) == OK;
1943 #endif
1944 #ifdef EXPERIMENTAL_PIPE_CONNECT
1945 sx->early_pipe_active = sx->early_pipe_ok = FALSE;
1946 sx->ehlo_resp.cleartext_features = sx->ehlo_resp.crypted_features = 0;
1947 sx->pending_BANNER = sx->pending_EHLO = FALSE;
1948 #endif
1949
1950 if ((sx->max_rcpt = sx->conn_args.tblock->max_addresses) == 0) sx->max_rcpt = 999999;
1951 sx->peer_offered = 0;
1952 sx->avoid_option = 0;
1953 sx->igquotstr = US"";
1954 if (!sx->helo_data) sx->helo_data = ob->helo_data;
1955 #ifdef EXPERIMENTAL_DSN_INFO
1956 sx->smtp_greeting = NULL;
1957 sx->helo_response = NULL;
1958 #endif
1959
1960 smtp_command = US"initial connection";
1961 sx->buffer[0] = '\0';
1962
1963 /* Set up the buffer for reading SMTP response packets. */
1964
1965 sx->inblock.buffer = sx->inbuffer;
1966 sx->inblock.buffersize = sizeof(sx->inbuffer);
1967 sx->inblock.ptr = sx->inbuffer;
1968 sx->inblock.ptrend = sx->inbuffer;
1969
1970 /* Set up the buffer for holding SMTP commands while pipelining */
1971
1972 sx->outblock.buffer = sx->outbuffer;
1973 sx->outblock.buffersize = sizeof(sx->outbuffer);
1974 sx->outblock.ptr = sx->outbuffer;
1975 sx->outblock.cmd_count = 0;
1976 sx->outblock.authenticating = FALSE;
1977 sx->outblock.conn_args = NULL;
1978
1979 /* Reset the parameters of a TLS session. */
1980
1981 tls_out.bits = 0;
1982 tls_out.cipher = NULL; /* the one we may use for this transport */
1983 tls_out.ourcert = NULL;
1984 tls_out.peercert = NULL;
1985 tls_out.peerdn = NULL;
1986 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
1987 tls_out.sni = NULL;
1988 #endif
1989 tls_out.ocsp = OCSP_NOT_REQ;
1990
1991 /* Flip the legacy TLS-related variables over to the outbound set in case
1992 they're used in the context of the transport. Don't bother resetting
1993 afterward (when being used by a transport) as we're in a subprocess.
1994 For verify, unflipped once the callout is dealt with */
1995
1996 tls_modify_variables(&tls_out);
1997
1998 #ifndef SUPPORT_TLS
1999 if (sx->smtps)
2000 {
2001 set_errno_nohost(sx->addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
2002 DEFER, FALSE);
2003 return ERROR;
2004 }
2005 #endif
2006
2007 /* Make a connection to the host if this isn't a continued delivery, and handle
2008 the initial interaction and HELO/EHLO/LHLO. Connect timeout errors are handled
2009 specially so they can be identified for retries. */
2010
2011 if (!continue_hostname)
2012 {
2013 if (sx->verify)
2014 HDEBUG(D_verify) debug_printf("interface=%s port=%d\n", sx->conn_args.interface, sx->port);
2015
2016 /* Get the actual port the connection will use, into sx->conn_args.host */
2017
2018 smtp_port_for_connect(sx->conn_args.host, sx->port);
2019
2020 #if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
2021 /* Do TLSA lookup for DANE */
2022 {
2023 tls_out.dane_verified = FALSE;
2024 tls_out.tlsa_usage = 0;
2025
2026 if (sx->conn_args.host->dnssec == DS_YES)
2027 {
2028 if( sx->dane_required
2029 || verify_check_given_host(CUSS &ob->hosts_try_dane, sx->conn_args.host) == OK
2030 )
2031 switch (rc = tlsa_lookup(sx->conn_args.host, &tlsa_dnsa, sx->dane_required))
2032 {
2033 case OK: sx->dane = TRUE;
2034 ob->tls_tempfail_tryclear = FALSE;
2035 break;
2036 case FAIL_FORCED: break;
2037 default: set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2038 string_sprintf("DANE error: tlsa lookup %s",
2039 rc == DEFER ? "DEFER" : "FAIL"),
2040 rc, FALSE);
2041 # ifndef DISABLE_EVENT
2042 (void) event_raise(sx->conn_args.tblock->event_action,
2043 US"dane:fail", sx->dane_required
2044 ? US"dane-required" : US"dnssec-invalid");
2045 # endif
2046 return rc;
2047 }
2048 }
2049 else if (sx->dane_required)
2050 {
2051 set_errno_nohost(sx->addrlist, ERRNO_DNSDEFER,
2052 string_sprintf("DANE error: %s lookup not DNSSEC", sx->conn_args.host->name),
2053 FAIL, FALSE);
2054 # ifndef DISABLE_EVENT
2055 (void) event_raise(sx->conn_args.tblock->event_action,
2056 US"dane:fail", US"dane-required");
2057 # endif
2058 return FAIL;
2059 }
2060 }
2061 #endif /*DANE*/
2062
2063 /* Make the TCP connection */
2064
2065 sx->cctx.tls_ctx = NULL;
2066 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2067 sx->avoid_option = sx->peer_offered = smtp_peer_options = 0;
2068
2069 #ifdef EXPERIMENTAL_PIPE_CONNECT
2070 if (verify_check_given_host(CUSS &ob->hosts_pipe_connect, sx->conn_args.host) == OK)
2071 {
2072 sx->early_pipe_ok = TRUE;
2073 if ( read_ehlo_cache_entry(sx)
2074 && sx->ehlo_resp.cleartext_features & OPTION_EARLY_PIPE)
2075 {
2076 DEBUG(D_transport) debug_printf("Using cached cleartext PIPE_CONNECT\n");
2077 sx->early_pipe_active = TRUE;
2078 sx->peer_offered = sx->ehlo_resp.cleartext_features;
2079 }
2080 }
2081
2082 if (sx->early_pipe_active)
2083 sx->outblock.conn_args = &sx->conn_args;
2084 else
2085 #endif
2086 {
2087 if ((sx->cctx.sock = smtp_connect(&sx->conn_args, NULL)) < 0)
2088 {
2089 uschar * msg = NULL;
2090 if (sx->verify)
2091 {
2092 msg = US strerror(errno);
2093 HDEBUG(D_verify) debug_printf("connect: %s\n", msg);
2094 }
2095 set_errno_nohost(sx->addrlist,
2096 errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
2097 sx->verify ? string_sprintf("could not connect: %s", msg)
2098 : NULL,
2099 DEFER, FALSE);
2100 sx->send_quit = FALSE;
2101 return DEFER;
2102 }
2103 }
2104 /* Expand the greeting message while waiting for the initial response. (Makes
2105 sense if helo_data contains ${lookup dnsdb ...} stuff). The expansion is
2106 delayed till here so that $sending_interface and $sending_port are set. */
2107 /*XXX early-pipe: they still will not be. Is there any way to find out what they
2108 will be? Somehow I doubt it. */
2109
2110 if (sx->helo_data)
2111 if (!(sx->helo_data = expand_string(sx->helo_data)))
2112 if (sx->verify)
2113 log_write(0, LOG_MAIN|LOG_PANIC,
2114 "<%s>: failed to expand transport's helo_data value for callout: %s",
2115 sx->addrlist->address, expand_string_message);
2116
2117 #ifdef SUPPORT_I18N
2118 if (sx->helo_data)
2119 {
2120 expand_string_message = NULL;
2121 if ((sx->helo_data = string_domain_utf8_to_alabel(sx->helo_data,
2122 &expand_string_message)),
2123 expand_string_message)
2124 if (sx->verify)
2125 log_write(0, LOG_MAIN|LOG_PANIC,
2126 "<%s>: failed to expand transport's helo_data value for callout: %s",
2127 sx->addrlist->address, expand_string_message);
2128 else
2129 sx->helo_data = NULL;
2130 }
2131 #endif
2132
2133 /* The first thing is to wait for an initial OK response. The dreaded "goto"
2134 is nevertheless a reasonably clean way of programming this kind of logic,
2135 where you want to escape on any error. */
2136
2137 if (!sx->smtps)
2138 {
2139 #ifdef EXPERIMENTAL_PIPE_CONNECT
2140 if (sx->early_pipe_active)
2141 {
2142 sx->pending_BANNER = TRUE; /* sync_responses() must eventually handle */
2143 sx->outblock.cmd_count = 1;
2144 }
2145 else
2146 #endif
2147 {
2148 #ifdef TCP_QUICKACK
2149 (void) setsockopt(sx->cctx.sock, IPPROTO_TCP, TCP_QUICKACK, US &off,
2150 sizeof(off));
2151 #endif
2152 if (!smtp_reap_banner(sx))
2153 goto RESPONSE_FAILED;
2154 }
2155
2156 #ifndef DISABLE_EVENT
2157 {
2158 uschar * s;
2159 lookup_dnssec_authenticated = sx->conn_args.host->dnssec==DS_YES ? US"yes"
2160 : sx->conn_args.host->dnssec==DS_NO ? US"no" : NULL;
2161 s = event_raise(sx->conn_args.tblock->event_action, US"smtp:connect", sx->buffer);
2162 if (s)
2163 {
2164 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL,
2165 string_sprintf("deferred by smtp:connect event expansion: %s", s),
2166 DEFER, FALSE);
2167 yield = DEFER;
2168 goto SEND_QUIT;
2169 }
2170 }
2171 #endif
2172
2173 /* Now check if the helo_data expansion went well, and sign off cleanly if
2174 it didn't. */
2175
2176 if (!sx->helo_data)
2177 {
2178 message = string_sprintf("failed to expand helo_data: %s",
2179 expand_string_message);
2180 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2181 yield = DEFER;
2182 goto SEND_QUIT;
2183 }
2184 }
2185
2186 /** Debugging without sending a message
2187 sx->addrlist->transport_return = DEFER;
2188 goto SEND_QUIT;
2189 **/
2190
2191 /* Errors that occur after this point follow an SMTP command, which is
2192 left in big_buffer by smtp_write_command() for use in error messages. */
2193
2194 smtp_command = big_buffer;
2195
2196 /* Tell the remote who we are...
2197
2198 February 1998: A convention has evolved that ESMTP-speaking MTAs include the
2199 string "ESMTP" in their greeting lines, so make Exim send EHLO if the
2200 greeting is of this form. The assumption was that the far end supports it
2201 properly... but experience shows that there are some that give 5xx responses,
2202 even though the banner includes "ESMTP" (there's a bloody-minded one that
2203 says "ESMTP not spoken here"). Cope with that case.
2204
2205 September 2000: Time has passed, and it seems reasonable now to always send
2206 EHLO at the start. It is also convenient to make the change while installing
2207 the TLS stuff.
2208
2209 July 2003: Joachim Wieland met a broken server that advertises "PIPELINING"
2210 but times out after sending MAIL FROM, RCPT TO and DATA all together. There
2211 would be no way to send out the mails, so there is now a host list
2212 "hosts_avoid_esmtp" that disables ESMTP for special hosts and solves the
2213 PIPELINING problem as well. Maybe it can also be useful to cure other
2214 problems with broken servers.
2215
2216 Exim originally sent "Helo" at this point and ran for nearly a year that way.
2217 Then somebody tried it with a Microsoft mailer... It seems that all other
2218 mailers use upper case for some reason (the RFC is quite clear about case
2219 independence) so, for peace of mind, I gave in. */
2220
2221 sx->esmtp = verify_check_given_host(CUSS &ob->hosts_avoid_esmtp, sx->conn_args.host) != OK;
2222
2223 /* Alas; be careful, since this goto is not an error-out, so conceivably
2224 we might set data between here and the target which we assume to exist
2225 and be usable. I can see this coming back to bite us. */
2226 #ifdef SUPPORT_TLS
2227 if (sx->smtps)
2228 {
2229 smtp_peer_options |= OPTION_TLS;
2230 suppress_tls = FALSE;
2231 ob->tls_tempfail_tryclear = FALSE;
2232 smtp_command = US"SSL-on-connect";
2233 goto TLS_NEGOTIATE;
2234 }
2235 #endif
2236
2237 if (sx->esmtp)
2238 {
2239 if (smtp_write_command(sx,
2240 #ifdef EXPERIMENTAL_PIPE_CONNECT
2241 sx->early_pipe_active ? SCMD_BUFFER :
2242 #endif
2243 SCMD_FLUSH,
2244 "%s %s\r\n", sx->lmtp ? "LHLO" : "EHLO", sx->helo_data) < 0)
2245 goto SEND_FAILED;
2246 sx->esmtp_sent = TRUE;
2247
2248 #ifdef EXPERIMENTAL_PIPE_CONNECT
2249 if (sx->early_pipe_active)
2250 {
2251 sx->pending_EHLO = TRUE;
2252
2253 /* If we have too many authenticators to handle and might need to AUTH
2254 for this transport, pipeline no further as we will need the
2255 list of auth methods offered. Reap the banner and EHLO. */
2256
2257 if ( (ob->hosts_require_auth || ob->hosts_try_auth)
2258 && f.smtp_in_early_pipe_no_auth)
2259 {
2260 DEBUG(D_transport) debug_printf("may need to auth, so pipeline no further\n");
2261 if (smtp_write_command(sx, SCMD_FLUSH, NULL) < 0)
2262 goto SEND_FAILED;
2263 if (sync_responses(sx, 2, 0) != 0)
2264 {
2265 HDEBUG(D_transport)
2266 debug_printf("failed reaping pipelined cmd responses\n");
2267 goto RESPONSE_FAILED;
2268 }
2269 sx->early_pipe_active = FALSE;
2270 }
2271 }
2272 else
2273 #endif
2274 if (!smtp_reap_ehlo(sx))
2275 goto RESPONSE_FAILED;
2276 }
2277 else
2278 DEBUG(D_transport)
2279 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2280
2281 #ifdef EXPERIMENTAL_PIPE_CONNECT
2282 if (!sx->early_pipe_active)
2283 #endif
2284 if (!sx->esmtp)
2285 {
2286 BOOL good_response;
2287 int n = sizeof(sx->buffer);
2288 uschar * rsp = sx->buffer;
2289
2290 if (sx->esmtp_sent && (n = Ustrlen(sx->buffer)) < sizeof(sx->buffer)/2)
2291 { rsp = sx->buffer + n + 1; n = sizeof(sx->buffer) - n; }
2292
2293 if (smtp_write_command(sx, SCMD_FLUSH, "HELO %s\r\n", sx->helo_data) < 0)
2294 goto SEND_FAILED;
2295 good_response = smtp_read_response(sx, rsp, n, '2', ob->command_timeout);
2296 #ifdef EXPERIMENTAL_DSN_INFO
2297 sx->helo_response = string_copy(rsp);
2298 #endif
2299 if (!good_response)
2300 {
2301 /* Handle special logging for a closed connection after HELO
2302 when had previously sent EHLO */
2303
2304 if (rsp != sx->buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
2305 {
2306 errno = ERRNO_SMTPCLOSED;
2307 goto EHLOHELO_FAILED;
2308 }
2309 memmove(sx->buffer, rsp, Ustrlen(rsp));
2310 goto RESPONSE_FAILED;
2311 }
2312 }
2313
2314 if (sx->esmtp || sx->lmtp)
2315 {
2316 #ifdef EXPERIMENTAL_PIPE_CONNECT
2317 if (!sx->early_pipe_active)
2318 #endif
2319 {
2320 sx->peer_offered = ehlo_response(sx->buffer,
2321 OPTION_TLS /* others checked later */
2322 #ifdef EXPERIMENTAL_PIPE_CONNECT
2323 | (sx->early_pipe_ok
2324 ? OPTION_IGNQ
2325 | OPTION_CHUNKING | OPTION_PRDR | OPTION_DSN | OPTION_PIPE | OPTION_SIZE
2326 #ifdef SUPPORT_I18N
2327 | OPTION_UTF8
2328 #endif
2329 | OPTION_EARLY_PIPE
2330 : 0
2331 )
2332 #endif
2333 );
2334 #ifdef EXPERIMENTAL_PIPE_CONNECT
2335 if (sx->early_pipe_ok)
2336 {
2337 sx->ehlo_resp.cleartext_features = sx->peer_offered;
2338
2339 if ( (sx->peer_offered & (OPTION_PIPE | OPTION_EARLY_PIPE))
2340 == (OPTION_PIPE | OPTION_EARLY_PIPE))
2341 {
2342 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2343 sx->ehlo_resp.cleartext_auths = study_ehlo_auths(sx);
2344 write_ehlo_cache_entry(sx);
2345 }
2346 }
2347 #endif
2348 }
2349
2350 /* Set tls_offered if the response to EHLO specifies support for STARTTLS. */
2351
2352 #ifdef SUPPORT_TLS
2353 smtp_peer_options |= sx->peer_offered & OPTION_TLS;
2354 #endif
2355 }
2356 }
2357
2358 /* For continuing deliveries down the same channel, having re-exec'd the socket
2359 is the standard input; for a socket held open from verify it is recorded
2360 in the cutthrough context block. Either way we don't need to redo EHLO here
2361 (but may need to do so for TLS - see below).
2362 Set up the pointer to where subsequent commands will be left, for
2363 error messages. Note that smtp_peer_options will have been
2364 set from the command line if they were set in the process that passed the
2365 connection on. */
2366
2367 /*XXX continue case needs to propagate DSN_INFO, prob. in deliver.c
2368 as the continue goes via transport_pass_socket() and doublefork and exec.
2369 It does not wait. Unclear how we keep separate host's responses
2370 separate - we could match up by host ip+port as a bodge. */
2371
2372 else
2373 {
2374 if (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only)
2375 {
2376 sx->cctx = cutthrough.cctx;
2377 sx->conn_args.host->port = sx->port = cutthrough.host.port;
2378 }
2379 else
2380 {
2381 sx->cctx.sock = 0; /* stdin */
2382 sx->cctx.tls_ctx = NULL;
2383 smtp_port_for_connect(sx->conn_args.host, sx->port); /* Record the port that was used */
2384 }
2385 sx->inblock.cctx = sx->outblock.cctx = &sx->cctx;
2386 smtp_command = big_buffer;
2387 sx->helo_data = NULL; /* ensure we re-expand ob->helo_data */
2388
2389 /* For a continued connection with TLS being proxied for us, or a
2390 held-open verify connection with TLS, nothing more to do. */
2391
2392 if ( continue_proxy_cipher
2393 || (cutthrough.cctx.sock >= 0 && cutthrough.callout_hold_only
2394 && cutthrough.is_tls)
2395 )
2396 {
2397 sx->peer_offered = smtp_peer_options;
2398 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2399 HDEBUG(D_transport) debug_printf("continued connection, %s TLS\n",
2400 continue_proxy_cipher ? "proxied" : "verify conn with");
2401 return OK;
2402 }
2403 HDEBUG(D_transport) debug_printf("continued connection, no TLS\n");
2404 }
2405
2406 /* If TLS is available on this connection, whether continued or not, attempt to
2407 start up a TLS session, unless the host is in hosts_avoid_tls. If successful,
2408 send another EHLO - the server may give a different answer in secure mode. We
2409 use a separate buffer for reading the response to STARTTLS so that if it is
2410 negative, the original EHLO data is available for subsequent analysis, should
2411 the client not be required to use TLS. If the response is bad, copy the buffer
2412 for error analysis. */
2413
2414 #ifdef SUPPORT_TLS
2415 if ( smtp_peer_options & OPTION_TLS
2416 && !suppress_tls
2417 && verify_check_given_host(CUSS &ob->hosts_avoid_tls, sx->conn_args.host) != OK
2418 && ( !sx->verify
2419 || verify_check_given_host(CUSS &ob->hosts_verify_avoid_tls, sx->conn_args.host) != OK
2420 ) )
2421 {
2422 uschar buffer2[4096];
2423
2424 if (smtp_write_command(sx, SCMD_FLUSH, "STARTTLS\r\n") < 0)
2425 goto SEND_FAILED;
2426
2427 #ifdef EXPERIMENTAL_PIPE_CONNECT
2428 /* If doing early-pipelining reap the banner and EHLO-response but leave
2429 the response for the STARTTLS we just sent alone. */
2430
2431 if (sx->early_pipe_active && sync_responses(sx, 2, 0) != 0)
2432 {
2433 HDEBUG(D_transport)
2434 debug_printf("failed reaping pipelined cmd responses\n");
2435 goto RESPONSE_FAILED;
2436 }
2437 #endif
2438
2439 /* If there is an I/O error, transmission of this message is deferred. If
2440 there is a temporary rejection of STARRTLS and tls_tempfail_tryclear is
2441 false, we also defer. However, if there is a temporary rejection of STARTTLS
2442 and tls_tempfail_tryclear is true, or if there is an outright rejection of
2443 STARTTLS, we carry on. This means we will try to send the message in clear,
2444 unless the host is in hosts_require_tls (tested below). */
2445
2446 if (!smtp_read_response(sx, buffer2, sizeof(buffer2), '2', ob->command_timeout))
2447 {
2448 if ( errno != 0
2449 || buffer2[0] == 0
2450 || (buffer2[0] == '4' && !ob->tls_tempfail_tryclear)
2451 )
2452 {
2453 Ustrncpy(sx->buffer, buffer2, sizeof(sx->buffer));
2454 sx->buffer[sizeof(sx->buffer)-1] = '\0';
2455 goto RESPONSE_FAILED;
2456 }
2457 }
2458
2459 /* STARTTLS accepted: try to negotiate a TLS session. */
2460
2461 else
2462 TLS_NEGOTIATE:
2463 {
2464 address_item * addr;
2465 uschar * errstr;
2466 sx->cctx.tls_ctx = tls_client_start(sx->cctx.sock, sx->conn_args.host,
2467 sx->addrlist, sx->conn_args.tblock,
2468 # ifdef SUPPORT_DANE
2469 sx->dane ? &tlsa_dnsa : NULL,
2470 # endif
2471 &tls_out, &errstr);
2472
2473 if (!sx->cctx.tls_ctx)
2474 {
2475 /* TLS negotiation failed; give an error. From outside, this function may
2476 be called again to try in clear on a new connection, if the options permit
2477 it for this host. */
2478 DEBUG(D_tls) debug_printf("TLS session fail: %s\n", errstr);
2479
2480 # ifdef SUPPORT_DANE
2481 if (sx->dane)
2482 {
2483 log_write(0, LOG_MAIN,
2484 "DANE attempt failed; TLS connection to %s [%s]: %s",
2485 sx->conn_args.host->name, sx->conn_args.host->address, errstr);
2486 # ifndef DISABLE_EVENT
2487 (void) event_raise(sx->conn_args.tblock->event_action,
2488 US"dane:fail", US"validation-failure"); /* could do with better detail */
2489 # endif
2490 }
2491 # endif
2492
2493 errno = ERRNO_TLSFAILURE;
2494 message = string_sprintf("TLS session: %s", errstr);
2495 sx->send_quit = FALSE;
2496 goto TLS_FAILED;
2497 }
2498
2499 /* TLS session is set up */
2500
2501 smtp_peer_options_wrap = smtp_peer_options;
2502 for (addr = sx->addrlist; addr; addr = addr->next)
2503 if (addr->transport_return == PENDING_DEFER)
2504 {
2505 addr->cipher = tls_out.cipher;
2506 addr->ourcert = tls_out.ourcert;
2507 addr->peercert = tls_out.peercert;
2508 addr->peerdn = tls_out.peerdn;
2509 addr->ocsp = tls_out.ocsp;
2510 }
2511 }
2512 }
2513
2514 /* if smtps, we'll have smtp_command set to something else; always safe to
2515 reset it here. */
2516 smtp_command = big_buffer;
2517
2518 /* If we started TLS, redo the EHLO/LHLO exchange over the secure channel. If
2519 helo_data is null, we are dealing with a connection that was passed from
2520 another process, and so we won't have expanded helo_data above. We have to
2521 expand it here. $sending_ip_address and $sending_port are set up right at the
2522 start of the Exim process (in exim.c). */
2523
2524 if (tls_out.active.sock >= 0)
2525 {
2526 uschar * greeting_cmd;
2527
2528 if (!sx->helo_data && !(sx->helo_data = expand_string(ob->helo_data)))
2529 {
2530 uschar *message = string_sprintf("failed to expand helo_data: %s",
2531 expand_string_message);
2532 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2533 yield = DEFER;
2534 goto SEND_QUIT;
2535 }
2536
2537 #ifdef EXPERIMENTAL_PIPE_CONNECT
2538 /* For SMTPS there is no cleartext early-pipe; use the crypted permission bit.
2539 We're unlikely to get the group sent and delivered before the server sends its
2540 banner, but it's still worth sending as a group.
2541 For STARTTLS allow for cleartext early-pipe but no crypted early-pipe, but not
2542 the reverse. */
2543
2544 if (sx->smtps ? sx->early_pipe_ok : sx->early_pipe_active)
2545 {
2546 sx->peer_offered = sx->ehlo_resp.crypted_features;
2547 if ((sx->early_pipe_active =
2548 !!(sx->ehlo_resp.crypted_features & OPTION_EARLY_PIPE)))
2549 DEBUG(D_transport) debug_printf("Using cached crypted PIPE_CONNECT\n");
2550 }
2551 #endif
2552
2553 /* For SMTPS we need to wait for the initial OK response. */
2554 if (sx->smtps)
2555 #ifdef EXPERIMENTAL_PIPE_CONNECT
2556 if (sx->early_pipe_active)
2557 {
2558 sx->pending_BANNER = TRUE;
2559 sx->outblock.cmd_count = 1;
2560 }
2561 else
2562 #endif
2563 if (!smtp_reap_banner(sx))
2564 goto RESPONSE_FAILED;
2565
2566 if (sx->lmtp)
2567 greeting_cmd = US"LHLO";
2568 else if (sx->esmtp)
2569 greeting_cmd = US"EHLO";
2570 else
2571 {
2572 greeting_cmd = US"HELO";
2573 DEBUG(D_transport)
2574 debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
2575 }
2576
2577 if (smtp_write_command(sx,
2578 #ifdef EXPERIMENTAL_PIPE_CONNECT
2579 sx->early_pipe_active ? SCMD_BUFFER :
2580 #endif
2581 SCMD_FLUSH,
2582 "%s %s\r\n", greeting_cmd, sx->helo_data) < 0)
2583 goto SEND_FAILED;
2584
2585 #ifdef EXPERIMENTAL_PIPE_CONNECT
2586 if (sx->early_pipe_active)
2587 sx->pending_EHLO = TRUE;
2588 else
2589 #endif
2590 {
2591 if (!smtp_reap_ehlo(sx))
2592 goto RESPONSE_FAILED;
2593 smtp_peer_options = 0;
2594 }
2595 }
2596
2597 /* If the host is required to use a secure channel, ensure that we
2598 have one. */
2599
2600 else if ( sx->smtps
2601 # ifdef SUPPORT_DANE
2602 || sx->dane
2603 # endif
2604 # ifdef EXPERIMENTAL_REQUIRETLS
2605 || tls_requiretls & REQUIRETLS_MSG
2606 # endif
2607 || verify_check_given_host(CUSS &ob->hosts_require_tls, sx->conn_args.host) == OK
2608 )
2609 {
2610 errno =
2611 # ifdef EXPERIMENTAL_REQUIRETLS
2612 tls_requiretls & REQUIRETLS_MSG ? ERRNO_REQUIRETLS :
2613 # endif
2614 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->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");
2624 # endif
2625 goto TLS_FAILED;
2626 }
2627 #endif /*SUPPORT_TLS*/
2628
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
2632 we skip this. */
2633
2634 if (continue_hostname == NULL
2635 #ifdef SUPPORT_TLS
2636 || tls_out.active.sock >= 0
2637 #endif
2638 )
2639 {
2640 if (sx->esmtp || sx->lmtp)
2641 {
2642 #ifdef EXPERIMENTAL_PIPE_CONNECT
2643 if (!sx->early_pipe_active)
2644 #endif
2645 {
2646 sx->peer_offered = ehlo_response(sx->buffer,
2647 0 /* no TLS */
2648 #ifdef EXPERIMENTAL_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 | OPTION_REQUIRETLS
2652 | (tls_out.active.sock >= 0 ? OPTION_EARLY_PIPE : 0) /* not for lmtp */
2653
2654 #else
2655
2656 | (sx->lmtp && ob->lmtp_ignore_quota ? OPTION_IGNQ : 0)
2657 | OPTION_CHUNKING
2658 | OPTION_PRDR
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 */
2663 # endif
2664 | OPTION_DSN
2665 | OPTION_PIPE
2666 | (ob->size_addition >= 0 ? OPTION_SIZE : 0)
2667 # if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2668 | (tls_requiretls & REQUIRETLS_MSG ? OPTION_REQUIRETLS : 0)
2669 # endif
2670 #endif
2671 );
2672 #ifdef EXPERIMENTAL_PIPE_CONNECT
2673 if (tls_out.active.sock >= 0)
2674 sx->ehlo_resp.crypted_features = sx->peer_offered;
2675 #endif
2676 }
2677
2678 /* Set for IGNOREQUOTA if the response to LHLO specifies support and the
2679 lmtp_ignore_quota option was set. */
2680
2681 sx->igquotstr = sx->peer_offered & OPTION_IGNQ ? US" IGNOREQUOTA" : US"";
2682
2683 /* If the response to EHLO specified support for the SIZE parameter, note
2684 this, provided size_addition is non-negative. */
2685
2686 smtp_peer_options |= sx->peer_offered & OPTION_SIZE;
2687
2688 /* Note whether the server supports PIPELINING. If hosts_avoid_esmtp matched
2689 the current host, esmtp will be false, so PIPELINING can never be used. If
2690 the current host matches hosts_avoid_pipelining, don't do it. */
2691
2692 if ( sx->peer_offered & OPTION_PIPE
2693 && verify_check_given_host(CUSS &ob->hosts_avoid_pipelining, sx->conn_args.host) != OK)
2694 smtp_peer_options |= OPTION_PIPE;
2695
2696 DEBUG(D_transport) debug_printf("%susing PIPELINING\n",
2697 smtp_peer_options & OPTION_PIPE ? "" : "not ");
2698
2699 if ( sx->peer_offered & OPTION_CHUNKING
2700 && verify_check_given_host(CUSS &ob->hosts_try_chunking, sx->conn_args.host) != OK)
2701 sx->peer_offered &= ~OPTION_CHUNKING;
2702
2703 if (sx->peer_offered & OPTION_CHUNKING)
2704 DEBUG(D_transport) debug_printf("CHUNKING usable\n");
2705
2706 #ifndef DISABLE_PRDR
2707 if ( sx->peer_offered & OPTION_PRDR
2708 && verify_check_given_host(CUSS &ob->hosts_try_prdr, sx->conn_args.host) != OK)
2709 sx->peer_offered &= ~OPTION_PRDR;
2710
2711 if (sx->peer_offered & OPTION_PRDR)
2712 DEBUG(D_transport) debug_printf("PRDR usable\n");
2713 #endif
2714
2715 /* Note if the server supports DSN */
2716 smtp_peer_options |= sx->peer_offered & OPTION_DSN;
2717 DEBUG(D_transport) debug_printf("%susing DSN\n",
2718 sx->peer_offered & OPTION_DSN ? "" : "not ");
2719
2720 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2721 if (sx->peer_offered & OPTION_REQUIRETLS)
2722 {
2723 smtp_peer_options |= OPTION_REQUIRETLS;
2724 DEBUG(D_transport) debug_printf(
2725 tls_requiretls & REQUIRETLS_MSG
2726 ? "using REQUIRETLS\n" : "REQUIRETLS offered\n");
2727 }
2728 #endif
2729
2730 #ifdef EXPERIMENTAL_PIPE_CONNECT
2731 if ( sx->early_pipe_ok
2732 && !sx->early_pipe_active
2733 && tls_out.active.sock >= 0
2734 && smtp_peer_options & OPTION_PIPE
2735 && ( sx->ehlo_resp.cleartext_features | sx->ehlo_resp.crypted_features)
2736 & OPTION_EARLY_PIPE)
2737 {
2738 DEBUG(D_transport) debug_printf("PIPE_CONNECT usable in future for this IP\n");
2739 sx->ehlo_resp.crypted_auths = study_ehlo_auths(sx);
2740 write_ehlo_cache_entry(sx);
2741 }
2742 #endif
2743
2744 /* Note if the response to EHLO specifies support for the AUTH extension.
2745 If it has, check that this host is one we want to authenticate to, and do
2746 the business. The host name and address must be available when the
2747 authenticator's client driver is running. */
2748
2749 switch (yield = smtp_auth(sx))
2750 {
2751 default: goto SEND_QUIT;
2752 case OK: break;
2753 case FAIL_SEND: goto SEND_FAILED;
2754 case FAIL: goto RESPONSE_FAILED;
2755 }
2756 }
2757 }
2758 sx->pipelining_used = pipelining_active = !!(smtp_peer_options & OPTION_PIPE);
2759
2760 /* The setting up of the SMTP call is now complete. Any subsequent errors are
2761 message-specific. */
2762
2763 sx->setting_up = FALSE;
2764
2765 #ifdef SUPPORT_I18N
2766 if (sx->addrlist->prop.utf8_msg)
2767 {
2768 uschar * s;
2769
2770 /* If the transport sets a downconversion mode it overrides any set by ACL
2771 for the message. */
2772
2773 if ((s = ob->utf8_downconvert))
2774 {
2775 if (!(s = expand_string(s)))
2776 {
2777 message = string_sprintf("failed to expand utf8_downconvert: %s",
2778 expand_string_message);
2779 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, message, DEFER, FALSE);
2780 yield = DEFER;
2781 goto SEND_QUIT;
2782 }
2783 switch (*s)
2784 {
2785 case '1': sx->addrlist->prop.utf8_downcvt = TRUE;
2786 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2787 break;
2788 case '0': sx->addrlist->prop.utf8_downcvt = FALSE;
2789 sx->addrlist->prop.utf8_downcvt_maybe = FALSE;
2790 break;
2791 case '-': if (s[1] == '1')
2792 {
2793 sx->addrlist->prop.utf8_downcvt = FALSE;
2794 sx->addrlist->prop.utf8_downcvt_maybe = TRUE;
2795 }
2796 break;
2797 }
2798 }
2799
2800 sx->utf8_needed = !sx->addrlist->prop.utf8_downcvt
2801 && !sx->addrlist->prop.utf8_downcvt_maybe;
2802 DEBUG(D_transport) if (!sx->utf8_needed)
2803 debug_printf("utf8: %s downconvert\n",
2804 sx->addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
2805 }
2806
2807 /* If this is an international message we need the host to speak SMTPUTF8 */
2808 if (sx->utf8_needed && !(sx->peer_offered & OPTION_UTF8))
2809 {
2810 errno = ERRNO_UTF8_FWD;
2811 goto RESPONSE_FAILED;
2812 }
2813 #endif /*SUPPORT_I18N*/
2814
2815 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
2816 /*XXX should tls_requiretls actually be per-addr? */
2817
2818 if ( tls_requiretls & REQUIRETLS_MSG
2819 && !(sx->peer_offered & OPTION_REQUIRETLS)
2820 )
2821 {
2822 sx->setting_up = TRUE;
2823 errno = ERRNO_REQUIRETLS;
2824 message = US"REQUIRETLS support is required from the server"
2825 " but it was not offered";
2826 DEBUG(D_transport) debug_printf("%s\n", message);
2827 goto TLS_FAILED;
2828 }
2829 #endif
2830
2831 return OK;
2832
2833
2834 {
2835 int code;
2836
2837 RESPONSE_FAILED:
2838 message = NULL;
2839 sx->send_quit = check_response(sx->conn_args.host, &errno, sx->addrlist->more_errno,
2840 sx->buffer, &code, &message, &pass_message);
2841 yield = DEFER;
2842 goto FAILED;
2843
2844 SEND_FAILED:
2845 code = '4';
2846 message = US string_sprintf("send() to %s [%s] failed: %s",
2847 sx->conn_args.host->name, sx->conn_args.host->address, strerror(errno));
2848 sx->send_quit = FALSE;
2849 yield = DEFER;
2850 goto FAILED;
2851
2852 EHLOHELO_FAILED:
2853 code = '4';
2854 message = string_sprintf("Remote host closed connection in response to %s"
2855 " (EHLO response was: %s)", smtp_command, sx->buffer);
2856 sx->send_quit = FALSE;
2857 yield = DEFER;
2858 goto FAILED;
2859
2860 /* This label is jumped to directly when a TLS negotiation has failed,
2861 or was not done for a host for which it is required. Values will be set
2862 in message and errno, and setting_up will always be true. Treat as
2863 a temporary error. */
2864
2865 #ifdef SUPPORT_TLS
2866 TLS_FAILED:
2867 # ifdef EXPERIMENTAL_REQUIRETLS
2868 if (errno == ERRNO_REQUIRETLS)
2869 code = '5', yield = FAIL;
2870 /*XXX DSN will be labelled 500; prefer 530 5.7.4 */
2871 else
2872 # endif
2873 code = '4', yield = DEFER;
2874 goto FAILED;
2875 #endif
2876
2877 /* The failure happened while setting up the call; see if the failure was
2878 a 5xx response (this will either be on connection, or following HELO - a 5xx
2879 after EHLO causes it to try HELO). If so, and there are no more hosts to try,
2880 fail all addresses, as this host is never going to accept them. For other
2881 errors during setting up (timeouts or whatever), defer all addresses, and
2882 yield DEFER, so that the host is not tried again for a while.
2883
2884 XXX This peeking for another host feels like a layering violation. We want
2885 to note the host as unusable, but down here we shouldn't know if this was
2886 the last host to try for the addr(list). Perhaps the upper layer should be
2887 the one to do set_errno() ? The problem is that currently the addr is where
2888 errno etc. are stashed, but until we run out of hosts to try the errors are
2889 host-specific. Maybe we should enhance the host_item definition? */
2890
2891 FAILED:
2892 sx->ok = FALSE; /* For when reached by GOTO */
2893 set_errno(sx->addrlist, errno, message,
2894 sx->conn_args.host->next
2895 ? DEFER
2896 : code == '5'
2897 #ifdef SUPPORT_I18N
2898 || errno == ERRNO_UTF8_FWD
2899 #endif
2900 ? FAIL : DEFER,
2901 pass_message, sx->conn_args.host
2902 #ifdef EXPERIMENTAL_DSN_INFO
2903 , sx->smtp_greeting, sx->helo_response
2904 #endif
2905 );
2906 }
2907
2908
2909 SEND_QUIT:
2910
2911 if (sx->send_quit)
2912 (void)smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n");
2913
2914 #ifdef SUPPORT_TLS
2915 if (sx->cctx.tls_ctx)
2916 {
2917 tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
2918 sx->cctx.tls_ctx = NULL;
2919 }
2920 #endif
2921
2922 /* Close the socket, and return the appropriate value, first setting
2923 works because the NULL setting is passed back to the calling process, and
2924 remote_max_parallel is forced to 1 when delivering over an existing connection,
2925 */
2926
2927 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP(close)>>\n");
2928 if (sx->send_quit)
2929 {
2930 shutdown(sx->cctx.sock, SHUT_WR);
2931 if (fcntl(sx->cctx.sock, F_SETFL, O_NONBLOCK) == 0)
2932 for (rc = 16; read(sx->cctx.sock, sx->inbuffer, sizeof(sx->inbuffer)) > 0 && rc > 0;)
2933 rc--; /* drain socket */
2934 sx->send_quit = FALSE;
2935 }
2936 (void)close(sx->cctx.sock);
2937 sx->cctx.sock = -1;
2938
2939 #ifndef DISABLE_EVENT
2940 (void) event_raise(sx->conn_args.tblock->event_action, US"tcp:close", NULL);
2941 #endif
2942
2943 continue_transport = NULL;
2944 continue_hostname = NULL;
2945 return yield;
2946 }
2947
2948
2949
2950
2951 /* Create the string of options that will be appended to the MAIL FROM:
2952 in the connection context buffer */
2953
2954 static int
2955 build_mailcmd_options(smtp_context * sx, address_item * addrlist)
2956 {
2957 uschar * p = sx->buffer;
2958 address_item * addr;
2959 int address_count;
2960
2961 *p = 0;
2962
2963 /* If we know the receiving MTA supports the SIZE qualification, and we know it,
2964 send it, adding something to the message size to allow for imprecision
2965 and things that get added en route. Exim keeps the number of lines
2966 in a message, so we can give an accurate value for the original message, but we
2967 need some additional to handle added headers. (Double "." characters don't get
2968 included in the count.) */
2969
2970 if ( message_size > 0
2971 && sx->peer_offered & OPTION_SIZE && !(sx->avoid_option & OPTION_SIZE))
2972 {
2973 /*XXX problem here under spool_files_wireformat?
2974 Or just forget about lines? Or inflate by a fixed proportion? */
2975
2976 sprintf(CS p, " SIZE=%d", message_size+message_linecount+(SOB sx->conn_args.ob)->size_addition);
2977 while (*p) p++;
2978 }
2979
2980 #ifndef DISABLE_PRDR
2981 /* If it supports Per-Recipient Data Reponses, and we have omre than one recipient,
2982 request that */
2983
2984 sx->prdr_active = FALSE;
2985 if (sx->peer_offered & OPTION_PRDR)
2986 for (addr = addrlist; addr; addr = addr->next)
2987 if (addr->transport_return == PENDING_DEFER)
2988 {
2989 for (addr = addr->next; addr; addr = addr->next)
2990 if (addr->transport_return == PENDING_DEFER)
2991 { /* at least two recipients to send */
2992 sx->prdr_active = TRUE;
2993 sprintf(CS p, " PRDR"); p += 5;
2994 break;
2995 }
2996 break;
2997 }
2998 #endif
2999
3000 #ifdef SUPPORT_I18N
3001 /* If it supports internationalised messages, and this meesage need that,
3002 request it */
3003
3004 if ( sx->peer_offered & OPTION_UTF8
3005 && addrlist->prop.utf8_msg
3006 && !addrlist->prop.utf8_downcvt
3007 )
3008 Ustrcpy(p, " SMTPUTF8"), p += 9;
3009 #endif
3010
3011 #if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
3012 if (tls_requiretls & REQUIRETLS_MSG)
3013 Ustrcpy(p, " REQUIRETLS") , p += 11;
3014 #endif
3015
3016 /* check if all addresses have DSN-lasthop flag; do not send RET and ENVID if so */
3017 for (sx->dsn_all_lasthop = TRUE, addr = addrlist, address_count = 0;
3018 addr && address_count < sx->max_rcpt;
3019 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3020 {
3021 address_count++;
3022 if (!(addr->dsn_flags & rf_dsnlasthop))
3023 {
3024 sx->dsn_all_lasthop = FALSE;
3025 break;
3026 }
3027 }
3028
3029 /* Add any DSN flags to the mail command */
3030
3031 if (sx->peer_offered & OPTION_DSN && !sx->dsn_all_lasthop)
3032 {
3033 if (dsn_ret == dsn_ret_hdrs)
3034 { Ustrcpy(p, " RET=HDRS"); p += 9; }
3035 else if (dsn_ret == dsn_ret_full)
3036 { Ustrcpy(p, " RET=FULL"); p += 9; }
3037
3038 if (dsn_envid)
3039 {
3040 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ENVID=%s", dsn_envid);
3041 while (*p) p++;
3042 }
3043 }
3044
3045 /* If an authenticated_sender override has been specified for this transport
3046 instance, expand it. If the expansion is forced to fail, and there was already
3047 an authenticated_sender for this message, the original value will be used.
3048 Other expansion failures are serious. An empty result is ignored, but there is
3049 otherwise no check - this feature is expected to be used with LMTP and other
3050 cases where non-standard addresses (e.g. without domains) might be required. */
3051
3052 if (smtp_mail_auth_str(p, sizeof(sx->buffer) - (p-sx->buffer), addrlist, sx->conn_args.ob))
3053 return ERROR;
3054
3055 return OK;
3056 }
3057
3058
3059 static void
3060 build_rcptcmd_options(smtp_context * sx, const address_item * addr)
3061 {
3062 uschar * p = sx->buffer;
3063 *p = 0;
3064
3065 /* Add any DSN flags to the rcpt command */
3066
3067 if (sx->peer_offered & OPTION_DSN && !(addr->dsn_flags & rf_dsnlasthop))
3068 {
3069 if (addr->dsn_flags & rf_dsnflags)
3070 {
3071 int i;
3072 BOOL first = TRUE;
3073
3074 Ustrcpy(p, " NOTIFY=");
3075 while (*p) p++;
3076 for (i = 0; i < nelem(rf_list); i++) if (addr->dsn_flags & rf_list[i])
3077 {
3078 if (!first) *p++ = ',';
3079 first = FALSE;
3080 Ustrcpy(p, rf_names[i]);
3081 while (*p) p++;
3082 }
3083 }
3084
3085 if (addr->dsn_orcpt)
3086 {
3087 string_format(p, sizeof(sx->buffer) - (p-sx->buffer), " ORCPT=%s",
3088 addr->dsn_orcpt);
3089 while (*p) p++;
3090 }
3091 }
3092 }
3093
3094
3095
3096 /*
3097 Return:
3098 0 good, rcpt results in addr->transport_return (PENDING_OK, DEFER, FAIL)
3099 -1 MAIL response error
3100 -2 any non-MAIL read i/o error
3101 -3 non-MAIL response timeout
3102 -4 internal error; channel still usable
3103 -5 transmit failed
3104 */
3105
3106 int
3107 smtp_write_mail_and_rcpt_cmds(smtp_context * sx, int * yield)
3108 {
3109 address_item * addr;
3110 int address_count;
3111 int rc;
3112
3113 if (build_mailcmd_options(sx, sx->first_addr) != OK)
3114 {
3115 *yield = ERROR;
3116 return -4;
3117 }
3118
3119 /* From here until we send the DATA command, we can make use of PIPELINING
3120 if the server host supports it. The code has to be able to check the responses
3121 at any point, for when the buffer fills up, so we write it totally generally.
3122 When PIPELINING is off, each command written reports that it has flushed the
3123 buffer. */
3124
3125 sx->pending_MAIL = TRUE; /* The block starts with MAIL */
3126
3127 {
3128 uschar * s = sx->from_addr;
3129 #ifdef SUPPORT_I18N
3130 uschar * errstr = NULL;
3131
3132 /* If we must downconvert, do the from-address here. Remember we had to
3133 for the to-addresses (done below), and also (ugly) for re-doing when building
3134 the delivery log line. */
3135
3136 if ( sx->addrlist->prop.utf8_msg
3137 && (sx->addrlist->prop.utf8_downcvt || !(sx->peer_offered & OPTION_UTF8))
3138 )
3139 {
3140 if (s = string_address_utf8_to_alabel(s, &errstr), errstr)
3141 {
3142 set_errno_nohost(sx->addrlist, ERRNO_EXPANDFAIL, errstr, DEFER, FALSE);
3143 *yield = ERROR;
3144 return -4;
3145 }
3146 setflag(sx->addrlist, af_utf8_downcvt);
3147 }
3148 #endif
3149
3150 rc = smtp_write_command(sx, pipelining_active ? SCMD_BUFFER : SCMD_FLUSH,
3151 "MAIL FROM:<%s>%s\r\n", s, sx->buffer);
3152 }
3153
3154 mail_command = string_copy(big_buffer); /* Save for later error message */
3155
3156 switch(rc)
3157 {
3158 case -1: /* Transmission error */
3159 return -5;
3160
3161 case +1: /* Cmd was sent */
3162 if (!smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2',
3163 (SOB sx->conn_args.ob)->command_timeout))
3164 {
3165 if (errno == 0 && sx->buffer[0] == '4')
3166 {
3167 errno = ERRNO_MAIL4XX;
3168 sx->addrlist->more_errno |= ((sx->buffer[1] - '0')*10 + sx->buffer[2] - '0') << 8;
3169 }
3170 return -1;
3171 }
3172 sx->pending_MAIL = FALSE;
3173 break;
3174
3175 /* otherwise zero: command queued for pipeline */
3176 }
3177
3178 /* Pass over all the relevant recipient addresses for this host, which are the
3179 ones that have status PENDING_DEFER. If we are using PIPELINING, we can send
3180 several before we have to read the responses for those seen so far. This
3181 checking is done by a subroutine because it also needs to be done at the end.
3182 Send only up to max_rcpt addresses at a time, leaving next_addr pointing to
3183 the next one if not all are sent.
3184
3185 In the MUA wrapper situation, we want to flush the PIPELINING buffer for the
3186 last address because we want to abort if any recipients have any kind of
3187 problem, temporary or permanent. We know that all recipient addresses will have
3188 the PENDING_DEFER status, because only one attempt is ever made, and we know
3189 that max_rcpt will be large, so all addresses will be done at once.
3190
3191 For verify we flush the pipeline after any (the only) rcpt address. */
3192
3193 for (addr = sx->first_addr, address_count = 0;
3194 addr && address_count < sx->max_rcpt;
3195 addr = addr->next) if (addr->transport_return == PENDING_DEFER)
3196 {
3197 int count;
3198 BOOL no_flush;
3199 uschar * rcpt_addr;
3200
3201 addr->dsn_aware = sx->peer_offered & OPTION_DSN
3202 ? dsn_support_yes : dsn_support_no;
3203
3204 address_count++;
3205 no_flush = pipelining_active && !sx->verify
3206 && (!mua_wrapper || addr->next && address_count < sx->max_rcpt);
3207
3208 build_rcptcmd_options(sx, addr);
3209
3210 /* Now send the RCPT command, and process outstanding responses when
3211 necessary. After a timeout on RCPT, we just end the function, leaving the
3212 yield as OK, because this error can often mean that there is a problem with
3213 just one address, so we don't want to delay the host. */
3214
3215 rcpt_addr = transport_rcpt_address(addr, sx->conn_args.tblock->rcpt_include_affixes);
3216
3217 #ifdef SUPPORT_I18N
3218 if ( testflag(sx->addrlist, af_utf8_downcvt)
3219 && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
3220 )
3221 {
3222 /*XXX could we use a per-address errstr here? Not fail the whole send? */
3223 errno = ERRNO_EXPANDFAIL;
3224 return -5; /*XXX too harsh? */
3225 }
3226 #endif
3227
3228 count = smtp_write_command(sx, no_flush ? SCMD_BUFFER : SCMD_FLUSH,
3229 "RCPT TO:<%s>%s%s\r\n", rcpt_addr, sx->igquotstr, sx->buffer);
3230
3231 if (count < 0) return -5;
3232 if (count > 0)
3233 {
3234 switch(sync_responses(sx, count, 0))
3235 {
3236 case 3: sx->ok = TRUE; /* 2xx & 5xx => OK & progress made */
3237 case 2: sx->completed_addr = TRUE; /* 5xx (only) => progress made */
3238 break;
3239
3240 case 1: sx->ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
3241 if (!sx->lmtp) /* can't tell about progress yet */
3242 sx->completed_addr = TRUE;
3243 case 0: /* No 2xx or 5xx, but no probs */
3244 break;
3245
3246 case -1: return -3; /* Timeout on RCPT */
3247 case -2: return -2; /* non-MAIL read i/o error */
3248 default: return -1; /* any MAIL error */
3249
3250 #ifdef EXPERIMENTAL_PIPE_CONNECT
3251 case -4: return -1; /* non-2xx for pipelined banner or EHLO */
3252 #endif
3253 }
3254 sx->pending_MAIL = FALSE; /* Dealt with MAIL */
3255 }
3256 } /* Loop for next address */
3257
3258 sx->next_addr = addr;
3259 return 0;
3260 }
3261
3262
3263 #ifdef SUPPORT_TLS
3264 /*****************************************************
3265 * Proxy TLS connection for another transport process *
3266 ******************************************************/
3267 /*
3268 Close the unused end of the pipe, fork once more, then use the given buffer
3269 as a staging area, and select on both the given fd and the TLS'd client-fd for
3270 data to read (per the coding in ip_recv() and fd_ready() this is legitimate).
3271 Do blocking full-size writes, and reads under a timeout. Once both input
3272 channels are closed, exit the process.
3273
3274 Arguments:
3275 ct_ctx tls context
3276 buf space to use for buffering
3277 bufsiz size of buffer
3278 pfd pipe filedescriptor array; [0] is comms to proxied process
3279 timeout per-read timeout, seconds
3280 */
3281
3282 void
3283 smtp_proxy_tls(void * ct_ctx, uschar * buf, size_t bsize, int * pfd,
3284 int timeout)
3285 {
3286 fd_set rfds, efds;
3287 int max_fd = MAX(pfd[0], tls_out.active.sock) + 1;
3288 int rc, i, fd_bits,<