1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* A number of functions for driving outgoing SMTP calls. */
12 #include "transports/smtp.h"
16 /*************************************************
17 * Find an outgoing interface *
18 *************************************************/
20 /* This function is called from the smtp transport and also from the callout
21 code in verify.c. Its job is to expand a string to get a list of interfaces,
22 and choose a suitable one (IPv4 or IPv6) for the outgoing address.
25 istring string interface setting, may be NULL, meaning "any", in
26 which case the function does nothing
27 host_af AF_INET or AF_INET6 for the outgoing IP address
28 addr the mail address being handled (for setting errors)
29 interface point this to the interface
30 msg to add to any error message
32 Returns: TRUE on success, FALSE on failure, with error message
33 set in addr and transport_return set to PANIC
37 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
38 uschar **interface, uschar *msg)
40 const uschar * expint;
44 if (!istring) return TRUE;
46 if (!(expint = expand_string(istring)))
48 if (expand_string_forcedfail) return TRUE;
49 addr->transport_return = PANIC;
50 addr->message = string_sprintf("failed to expand \"interface\" "
51 "option for %s: %s", msg, expand_string_message);
55 while (isspace(*expint)) expint++;
56 if (*expint == 0) return TRUE;
58 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
61 if (string_is_ip_address(iface, NULL) == 0)
63 addr->transport_return = PANIC;
64 addr->message = string_sprintf("\"%s\" is not a valid IP "
65 "address for the \"interface\" option for %s",
70 if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
74 if (iface) *interface = string_copy(iface);
80 /*************************************************
81 * Find an outgoing port *
82 *************************************************/
84 /* This function is called from the smtp transport and also from the callout
85 code in verify.c. Its job is to find a port number. Note that getservbyname()
86 produces the number in network byte order.
89 rstring raw (unexpanded) string representation of the port
90 addr the mail address being handled (for setting errors)
91 port stick the port in here
92 msg for adding to error message
94 Returns: TRUE on success, FALSE on failure, with error message set
95 in addr, and transport_return set to PANIC
99 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
101 uschar *pstring = expand_string(rstring);
105 addr->transport_return = PANIC;
106 addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
107 "for %s: %s", rstring, msg, expand_string_message);
111 if (isdigit(*pstring))
114 *port = Ustrtol(pstring, &end, 0);
115 if (end != pstring + Ustrlen(pstring))
117 addr->transport_return = PANIC;
118 addr->message = string_sprintf("invalid port number for %s: %s", msg,
126 struct servent *smtp_service = getservbyname(CS pstring, "tcp");
129 addr->transport_return = PANIC;
130 addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
134 *port = ntohs(smtp_service->s_port);
145 tfo_out_check(int sock)
147 # if defined(TCP_INFO) && defined(EXIM_HAVE_TCPI_UNACKED)
148 struct tcp_info tinfo;
149 socklen_t len = sizeof(tinfo);
151 if (getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0)
153 /* This is a somewhat dubious detection method; totally undocumented so likely
154 to fail in future kernels. There seems to be no documented way. */
156 if (tinfo.tcpi_unacked > 1)
158 DEBUG(D_transport|D_v) debug_printf("TCP_FASTOPEN mode connection\n");
159 tcp_out_fastopen = TRUE;
167 /* Arguments as for smtp_connect(), plus
168 early_data if non-NULL, data to be sent - preferably in the TCP SYN segment
170 Returns: connected socket number, or -1 with errno set
174 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
175 transport_instance * tb, int timeout, const blob * early_data)
177 smtp_transport_options_block * ob =
178 (smtp_transport_options_block *)tb->options_block;
179 const uschar * dscp = ob->dscp;
186 #ifndef DISABLE_EVENT
187 deliver_host_address = host->address;
188 deliver_host_port = port;
189 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
192 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
194 /* Set TCP_NODELAY; Exim does its own buffering. */
196 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
197 HDEBUG(D_transport|D_acl|D_v)
198 debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
200 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
201 bomb out, just log it and continue in default traffic class. */
203 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
205 HDEBUG(D_transport|D_acl|D_v)
206 debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
207 if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
208 HDEBUG(D_transport|D_acl|D_v)
209 debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
210 /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
211 option for both; ignore failures here */
212 if (host_af == AF_INET6 &&
213 dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
214 (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
217 /* Bind to a specific interface if requested. Caller must ensure the interface
218 is the same type (IPv4 or IPv6) as the outgoing address. */
220 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
223 HDEBUG(D_transport|D_acl|D_v)
224 debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
228 /* Connect to the remote host, and add keepalive to the socket before returning
229 it, if requested. If the build supports TFO, request it - and if the caller
230 requested some early-data then include that in the TFO request. */
234 const blob * fastopen = NULL;
237 if (verify_check_given_host(&ob->hosts_try_fastopen, host) == OK)
238 fastopen = early_data ? early_data : &tcp_fastopen_nodata;
241 if (ip_connect(sock, host_af, host->address, port, timeout, fastopen) < 0)
243 else if (early_data && !fastopen && early_data->data && early_data->len)
244 if (send(sock, early_data->data, early_data->len, 0) < 0)
248 /* Either bind() or connect() failed */
252 HDEBUG(D_transport|D_acl|D_v)
254 debug_printf_indent("failed: %s", CUstrerror(save_errno));
255 if (save_errno == ETIMEDOUT)
256 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
264 /* Both bind() and connect() succeeded */
268 union sockaddr_46 interface_sock;
269 EXIM_SOCKLEN_T size = sizeof(interface_sock);
270 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("connected\n");
271 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
272 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
275 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
276 "getsockname() failed: %s", strerror(errno));
280 if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
293 smtp_port_for_connect(host_item * host, int port)
295 if (host->port != PORT_NONE)
297 HDEBUG(D_transport|D_acl|D_v)
298 debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
302 else host->port = port; /* Set the port actually used */
306 /*************************************************
307 * Connect to remote host *
308 *************************************************/
310 /* Create a socket, and connect it to a remote host. IPv6 addresses are
311 detected by checking for a colon in the address. AF_INET6 is defined even on
312 non-IPv6 systems, to enable the code to be less messy. However, on such systems
313 host->address will always be an IPv4 address.
316 host host item containing name and address and port
317 host_af AF_INET or AF_INET6
318 interface outgoing interface address or NULL
319 timeout timeout value or 0
322 Returns: connected socket number, or -1 with errno set
326 smtp_connect(host_item *host, int host_af, uschar *interface,
327 int timeout, transport_instance * tb)
329 int port = host->port;
331 smtp_transport_options_block * ob =
332 (smtp_transport_options_block *)tb->options_block;
335 callout_address = string_sprintf("[%s]:%d", host->address, port);
337 HDEBUG(D_transport|D_acl|D_v)
340 if (interface) s = string_sprintf(" from %s ", interface);
342 if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
344 debug_printf_indent("Connecting to %s %s%s... ", host->name, callout_address, s);
347 /* Create and connect the socket */
351 return socks_sock_connect(host, host_af, port, interface, tb, timeout);
354 return smtp_sock_connect(host, host_af, port, interface, tb, timeout, NULL);
358 /*************************************************
359 * Flush outgoing command buffer *
360 *************************************************/
362 /* This function is called only from smtp_write_command() below. It flushes
363 the buffer of outgoing commands. There is more than one in the buffer only when
367 outblock the SMTP output block
368 mode further data expected, or plain
370 Returns: TRUE if OK, FALSE on error, with errno set
374 flush_buffer(smtp_outblock * outblock, int mode)
377 int n = outblock->ptr - outblock->buffer;
378 BOOL more = mode == SCMD_MORE;
380 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
381 more ? " (more expected)" : "");
384 if (tls_out.active == outblock->sock)
385 rc = tls_write(FALSE, outblock->buffer, n, more);
388 rc = send(outblock->sock, outblock->buffer, n,
398 HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
402 outblock->ptr = outblock->buffer;
403 outblock->cmd_count = 0;
409 /*************************************************
410 * Write SMTP command *
411 *************************************************/
413 /* The formatted command is left in big_buffer so that it can be reflected in
417 outblock contains buffer for pipelining, and socket
418 mode buffer, write-with-more-likely, write
419 format a format, starting with one of
420 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
421 If NULL, flush pipeline buffer only.
422 ... data for the format
424 Returns: 0 if command added to pipelining buffer, with nothing transmitted
425 +n if n commands transmitted (may still have buffered the new one)
426 -1 on error, with errno set
430 smtp_write_command(smtp_outblock * outblock, int mode, const char *format, ...)
438 va_start(ap, format);
439 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
440 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
443 count = Ustrlen(big_buffer);
445 if (count > outblock->buffersize)
446 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
449 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
451 rc = outblock->cmd_count; /* flush resets */
452 if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
455 Ustrncpy(CS outblock->ptr, big_buffer, count);
456 outblock->ptr += count;
457 outblock->cmd_count++;
459 big_buffer[count] = 0; /* remove \r\n for error message */
461 /* We want to hide the actual data sent in AUTH transactions from reflections
462 and logs. While authenticating, a flag is set in the outblock to enable this.
463 The AUTH command itself gets any data flattened. Other lines are flattened
466 if (outblock->authenticating)
468 uschar *p = big_buffer;
469 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
472 while (isspace(*p)) p++;
473 while (!isspace(*p)) p++;
474 while (isspace(*p)) p++;
476 while (*p != 0) *p++ = '*';
479 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP>> %s\n", big_buffer);
482 if (mode != SCMD_BUFFER)
484 rc += outblock->cmd_count; /* flush resets */
485 if (!flush_buffer(outblock, mode)) return -1;
493 /*************************************************
494 * Read one line of SMTP response *
495 *************************************************/
497 /* This function reads one line of SMTP response from the server host. This may
498 not be a complete response - it could be just part of a multiline response. We
499 have to use a buffer for incoming packets, because when pipelining or using
500 LMTP, there may well be more than one response in a single packet. This
501 function is called only from the one that follows.
504 inblock the SMTP input block (contains holding buffer, socket, etc.)
505 buffer where to put the line
506 size space available for the line
507 timeout the timeout to use when reading a packet
509 Returns: length of a line that has been put in the buffer
510 -1 otherwise, with errno set
514 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
517 uschar *ptr = inblock->ptr;
518 uschar *ptrend = inblock->ptrend;
519 int sock = inblock->sock;
521 /* Loop for reading multiple packets or reading another packet after emptying
522 a previously-read one. */
528 /* If there is data in the input buffer left over from last time, copy
529 characters from it until the end of a line, at which point we can return,
530 having removed any whitespace (which will include CR) at the end of the line.
531 The rules for SMTP say that lines end in CRLF, but there are have been cases
532 of hosts using just LF, and other MTAs are reported to handle this, so we
533 just look for LF. If we run out of characters before the end of a line,
534 carry on to read the next incoming packet. */
541 while (p > buffer && isspace(p[-1])) p--;
549 *p = 0; /* Leave malformed line for error message */
550 errno = ERRNO_SMTPFORMAT;
555 /* Need to read a new input packet. */
557 if((rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout)) <= 0)
559 DEBUG(D_deliver|D_transport|D_acl)
560 debug_printf_indent(errno ? " SMTP(%s)<<\n" : " SMTP(closed)<<\n",
565 /* Another block of data has been successfully read. Set up the pointers
566 and let the loop continue. */
568 ptrend = inblock->ptrend = inblock->buffer + rc;
569 ptr = inblock->buffer;
570 DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
573 /* Get here if there has been some kind of recv() error; errno is set, but we
574 ensure that the result buffer is empty before returning. */
584 /*************************************************
585 * Read SMTP response *
586 *************************************************/
588 /* This function reads an SMTP response with a timeout, and returns the
589 response in the given buffer, as a string. A multiline response will contain
590 newline characters between the lines. The function also analyzes the first
591 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
592 also returned after a reading error. In this case buffer[0] will be zero, and
593 the error code will be in errno.
596 inblock the SMTP input block (contains holding buffer, socket, etc.)
597 buffer where to put the response
598 size the size of the buffer
599 okdigit the expected first digit of the response
600 timeout the timeout to use, in seconds
602 Returns: TRUE if a valid, non-error response was received; else FALSE
606 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
609 uschar *ptr = buffer;
612 errno = 0; /* Ensure errno starts out zero */
614 /* This is a loop to read and concatenate the lines that make up a multi-line
619 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
622 HDEBUG(D_transport|D_acl|D_v)
623 debug_printf_indent(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
625 /* Check the format of the response: it must start with three digits; if
626 these are followed by a space or end of line, the response is complete. If
627 they are followed by '-' this is a multi-line response and we must look for
628 another line until the final line is reached. The only use made of multi-line
629 responses is to pass them back as error messages. We therefore just
630 concatenate them all within the buffer, which should be large enough to
631 accept any reasonable number of lines. */
637 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
639 errno = ERRNO_SMTPFORMAT; /* format error */
643 /* If the line we have just read is a terminal line, line, we are done.
644 Otherwise more data has to be read. */
646 if (ptr[3] != '-') break;
648 /* Move the reading pointer upwards in the buffer and insert \n between the
649 components of a multiline response. Space is left for this by read_response_
657 /* Return a value that depends on the SMTP return code. On some systems a
658 non-zero value of errno has been seen at this point, so ensure it is zero,
659 because the caller of this function looks at errno when FALSE is returned, to
660 distinguish between an unexpected return code and other errors such as
661 timeouts, lost connections, etc. */
664 return buffer[0] == okdigit;
667 /* End of smtp_out.c */