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);
144 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
145 transport_instance * tb, int timeout)
147 smtp_transport_options_block * ob =
148 (smtp_transport_options_block *)tb->options_block;
149 const uschar * dscp = ob->dscp;
155 BOOL fastopen = FALSE;
157 #ifndef DISABLE_EVENT
158 deliver_host_address = host->address;
159 deliver_host_port = port;
160 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
163 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
165 /* Set TCP_NODELAY; Exim does its own buffering. */
167 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
168 HDEBUG(D_transport|D_acl|D_v)
169 debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
171 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
172 bomb out, just log it and continue in default traffic class. */
174 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
176 HDEBUG(D_transport|D_acl|D_v)
177 debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
178 if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
179 HDEBUG(D_transport|D_acl|D_v)
180 debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
181 /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
182 option for both; ignore failures here */
183 if (host_af == AF_INET6 &&
184 dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
185 (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
189 if (verify_check_given_host (&ob->hosts_try_fastopen, host) == OK) fastopen = TRUE;
192 /* Bind to a specific interface if requested. Caller must ensure the interface
193 is the same type (IPv4 or IPv6) as the outgoing address. */
195 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
198 HDEBUG(D_transport|D_acl|D_v)
199 debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
203 /* Connect to the remote host, and add keepalive to the socket before returning
206 else if (ip_connect(sock, host_af, host->address, port, timeout, fastopen) < 0)
209 /* Either bind() or connect() failed */
213 HDEBUG(D_transport|D_acl|D_v)
215 debug_printf_indent("failed: %s", CUstrerror(save_errno));
216 if (save_errno == ETIMEDOUT)
217 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
225 /* Both bind() and connect() succeeded */
229 union sockaddr_46 interface_sock;
230 EXIM_SOCKLEN_T size = sizeof(interface_sock);
231 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("connected\n");
232 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
233 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
236 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
237 "getsockname() failed: %s", strerror(errno));
241 if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
251 smtp_port_for_connect(host_item * host, int port)
253 if (host->port != PORT_NONE)
255 HDEBUG(D_transport|D_acl|D_v)
256 debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
260 else host->port = port; /* Set the port actually used */
264 /*************************************************
265 * Connect to remote host *
266 *************************************************/
268 /* Create a socket, and connect it to a remote host. IPv6 addresses are
269 detected by checking for a colon in the address. AF_INET6 is defined even on
270 non-IPv6 systems, to enable the code to be less messy. However, on such systems
271 host->address will always be an IPv4 address.
274 host host item containing name and address and port
275 host_af AF_INET or AF_INET6
276 interface outgoing interface address or NULL
277 timeout timeout value or 0
280 Returns: connected socket number, or -1 with errno set
284 smtp_connect(host_item *host, int host_af, uschar *interface,
285 int timeout, transport_instance * tb)
287 int port = host->port;
289 smtp_transport_options_block * ob =
290 (smtp_transport_options_block *)tb->options_block;
293 callout_address = string_sprintf("[%s]:%d", host->address, port);
295 HDEBUG(D_transport|D_acl|D_v)
298 if (interface) s = string_sprintf(" from %s ", interface);
300 if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
302 debug_printf_indent("Connecting to %s %s%s... ", host->name, callout_address, s);
305 /* Create and connect the socket */
309 return socks_sock_connect(host, host_af, port, interface, tb, timeout);
312 return smtp_sock_connect(host, host_af, port, interface, tb, timeout);
316 /*************************************************
317 * Flush outgoing command buffer *
318 *************************************************/
320 /* This function is called only from smtp_write_command() below. It flushes
321 the buffer of outgoing commands. There is more than one in the buffer only when
325 outblock the SMTP output block
326 mode more-expected, or plain
328 Returns: TRUE if OK, FALSE on error, with errno set
332 flush_buffer(smtp_outblock * outblock, int mode)
335 int n = outblock->ptr - outblock->buffer;
337 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
338 mode == SCMD_MORE ? " (more expected)" : "");
341 if (tls_out.active == outblock->sock)
342 rc = tls_write(FALSE, outblock->buffer, n);
345 rc = send(outblock->sock, outblock->buffer, n,
347 mode == SCMD_MORE ? MSG_MORE : 0
355 HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
359 outblock->ptr = outblock->buffer;
360 outblock->cmd_count = 0;
366 /*************************************************
367 * Write SMTP command *
368 *************************************************/
370 /* The formatted command is left in big_buffer so that it can be reflected in
374 outblock contains buffer for pipelining, and socket
375 mode buffer, write-with-more-likely, write
376 format a format, starting with one of
377 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
378 If NULL, flush pipeline buffer only.
379 ... data for the format
381 Returns: 0 if command added to pipelining buffer, with nothing transmitted
382 +n if n commands transmitted (may still have buffered the new one)
383 -1 on error, with errno set
387 smtp_write_command(smtp_outblock * outblock, int mode, const char *format, ...)
395 va_start(ap, format);
396 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
397 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
400 count = Ustrlen(big_buffer);
402 if (count > outblock->buffersize)
403 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
406 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
408 rc = outblock->cmd_count; /* flush resets */
409 if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
412 Ustrncpy(CS outblock->ptr, big_buffer, count);
413 outblock->ptr += count;
414 outblock->cmd_count++;
416 big_buffer[count] = 0; /* remove \r\n for error message */
418 /* We want to hide the actual data sent in AUTH transactions from reflections
419 and logs. While authenticating, a flag is set in the outblock to enable this.
420 The AUTH command itself gets any data flattened. Other lines are flattened
423 if (outblock->authenticating)
425 uschar *p = big_buffer;
426 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
429 while (isspace(*p)) p++;
430 while (!isspace(*p)) p++;
431 while (isspace(*p)) p++;
433 while (*p != 0) *p++ = '*';
436 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP>> %s\n", big_buffer);
439 if (mode != SCMD_BUFFER)
441 rc += outblock->cmd_count; /* flush resets */
442 if (!flush_buffer(outblock, mode)) return -1;
450 /*************************************************
451 * Read one line of SMTP response *
452 *************************************************/
454 /* This function reads one line of SMTP response from the server host. This may
455 not be a complete response - it could be just part of a multiline response. We
456 have to use a buffer for incoming packets, because when pipelining or using
457 LMTP, there may well be more than one response in a single packet. This
458 function is called only from the one that follows.
461 inblock the SMTP input block (contains holding buffer, socket, etc.)
462 buffer where to put the line
463 size space available for the line
464 timeout the timeout to use when reading a packet
466 Returns: length of a line that has been put in the buffer
467 -1 otherwise, with errno set
471 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
474 uschar *ptr = inblock->ptr;
475 uschar *ptrend = inblock->ptrend;
476 int sock = inblock->sock;
478 /* Loop for reading multiple packets or reading another packet after emptying
479 a previously-read one. */
485 /* If there is data in the input buffer left over from last time, copy
486 characters from it until the end of a line, at which point we can return,
487 having removed any whitespace (which will include CR) at the end of the line.
488 The rules for SMTP say that lines end in CRLF, but there are have been cases
489 of hosts using just LF, and other MTAs are reported to handle this, so we
490 just look for LF. If we run out of characters before the end of a line,
491 carry on to read the next incoming packet. */
498 while (p > buffer && isspace(p[-1])) p--;
506 *p = 0; /* Leave malformed line for error message */
507 errno = ERRNO_SMTPFORMAT;
512 /* Need to read a new input packet. */
514 if((rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout)) <= 0)
516 DEBUG(D_deliver|D_transport|D_acl)
517 debug_printf_indent(errno ? " SMTP(%s)<<\n" : " SMTP(closed)<<\n",
522 /* Another block of data has been successfully read. Set up the pointers
523 and let the loop continue. */
525 ptrend = inblock->ptrend = inblock->buffer + rc;
526 ptr = inblock->buffer;
527 DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
530 /* Get here if there has been some kind of recv() error; errno is set, but we
531 ensure that the result buffer is empty before returning. */
541 /*************************************************
542 * Read SMTP response *
543 *************************************************/
545 /* This function reads an SMTP response with a timeout, and returns the
546 response in the given buffer, as a string. A multiline response will contain
547 newline characters between the lines. The function also analyzes the first
548 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
549 also returned after a reading error. In this case buffer[0] will be zero, and
550 the error code will be in errno.
553 inblock the SMTP input block (contains holding buffer, socket, etc.)
554 buffer where to put the response
555 size the size of the buffer
556 okdigit the expected first digit of the response
557 timeout the timeout to use, in seconds
559 Returns: TRUE if a valid, non-error response was received; else FALSE
563 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
566 uschar *ptr = buffer;
569 errno = 0; /* Ensure errno starts out zero */
571 /* This is a loop to read and concatenate the lines that make up a multi-line
576 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
579 HDEBUG(D_transport|D_acl|D_v)
580 debug_printf_indent(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
582 /* Check the format of the response: it must start with three digits; if
583 these are followed by a space or end of line, the response is complete. If
584 they are followed by '-' this is a multi-line response and we must look for
585 another line until the final line is reached. The only use made of multi-line
586 responses is to pass them back as error messages. We therefore just
587 concatenate them all within the buffer, which should be large enough to
588 accept any reasonable number of lines. */
594 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
596 errno = ERRNO_SMTPFORMAT; /* format error */
600 /* If the line we have just read is a terminal line, line, we are done.
601 Otherwise more data has to be read. */
603 if (ptr[3] != '-') break;
605 /* Move the reading pointer upwards in the buffer and insert \n between the
606 components of a multiline response. Space is left for this by read_response_
614 /* Return a value that depends on the SMTP return code. On some systems a
615 non-zero value of errno has been seen at this point, so ensure it is zero,
616 because the caller of this function looks at errno when FALSE is returned, to
617 distinguish between an unexpected return code and other errors such as
618 timeouts, lost connections, etc. */
621 return buffer[0] == okdigit;
624 /* End of smtp_out.c */