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 == NULL) return TRUE;
46 expint = expand_string(istring);
49 if (expand_string_forcedfail) return TRUE;
50 addr->transport_return = PANIC;
51 addr->message = string_sprintf("failed to expand \"interface\" "
52 "option for %s: %s", msg, expand_string_message);
56 while (isspace(*expint)) expint++;
57 if (*expint == 0) return TRUE;
59 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
60 big_buffer_size)) != NULL)
62 if (string_is_ip_address(iface, NULL) == 0)
64 addr->transport_return = PANIC;
65 addr->message = string_sprintf("\"%s\" is not a valid IP "
66 "address for the \"interface\" option for %s",
71 if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
75 if (iface != NULL) *interface = string_copy(iface);
81 /*************************************************
82 * Find an outgoing port *
83 *************************************************/
85 /* This function is called from the smtp transport and also from the callout
86 code in verify.c. Its job is to find a port number. Note that getservbyname()
87 produces the number in network byte order.
90 rstring raw (unexpanded) string representation of the port
91 addr the mail address being handled (for setting errors)
92 port stick the port in here
93 msg for adding to error message
95 Returns: TRUE on success, FALSE on failure, with error message set
96 in addr, and transport_return set to PANIC
100 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
102 uschar *pstring = expand_string(rstring);
106 addr->transport_return = PANIC;
107 addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
108 "for %s: %s", rstring, msg, expand_string_message);
112 if (isdigit(*pstring))
115 *port = Ustrtol(pstring, &end, 0);
116 if (end != pstring + Ustrlen(pstring))
118 addr->transport_return = PANIC;
119 addr->message = string_sprintf("invalid port number for %s: %s", msg,
127 struct servent *smtp_service = getservbyname(CS pstring, "tcp");
128 if (smtp_service == NULL)
130 addr->transport_return = PANIC;
131 addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
135 *port = ntohs(smtp_service->s_port);
145 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
146 transport_instance * tb, int timeout)
148 smtp_transport_options_block * ob =
149 (smtp_transport_options_block *)tb->options_block;
150 const uschar * dscp = ob->dscp;
158 #ifndef DISABLE_EVENT
159 deliver_host_address = host->address;
160 deliver_host_port = port;
161 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
164 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
166 /* Set TCP_NODELAY; Exim does its own buffering. */
168 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
169 HDEBUG(D_transport|D_acl|D_v)
170 debug_printf("failed to set NODELAY: %s ", strerror(errno));
172 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
173 bomb out, just log it and continue in default traffic class. */
175 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
177 HDEBUG(D_transport|D_acl|D_v)
178 debug_printf("DSCP \"%s\"=%x ", dscp, dscp_value);
179 if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
180 HDEBUG(D_transport|D_acl|D_v)
181 debug_printf("failed to set DSCP: %s ", strerror(errno));
182 /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
183 option for both; ignore failures here */
184 if (host_af == AF_INET6 &&
185 dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
186 (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
189 /* Bind to a specific interface if requested. Caller must ensure the interface
190 is the same type (IPv4 or IPv6) as the outgoing address. */
192 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
195 HDEBUG(D_transport|D_acl|D_v)
196 debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
200 /* Connect to the remote host, and add keepalive to the socket before returning
203 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
206 /* Either bind() or connect() failed */
210 HDEBUG(D_transport|D_acl|D_v)
212 debug_printf("failed: %s", CUstrerror(save_errno));
213 if (save_errno == ETIMEDOUT)
214 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
222 /* Both bind() and connect() succeeded */
226 union sockaddr_46 interface_sock;
227 EXIM_SOCKLEN_T size = sizeof(interface_sock);
228 HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
229 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
230 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
233 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
234 "getsockname() failed: %s", strerror(errno));
238 if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
243 /*************************************************
244 * Connect to remote host *
245 *************************************************/
247 /* Create a socket, and connect it to a remote host. IPv6 addresses are
248 detected by checking for a colon in the address. AF_INET6 is defined even on
249 non-IPv6 systems, to enable the code to be less messy. However, on such systems
250 host->address will always be an IPv4 address.
252 The port field in the host item is used if it is set (usually router from SRV
253 records or elsewhere). In other cases, the default passed as an argument is
254 used, and the host item is updated with its value.
257 host host item containing name and address (and sometimes port)
258 host_af AF_INET or AF_INET6
259 port default remote port to connect to, in host byte order, for those
260 hosts whose port setting is PORT_NONE
261 interface outgoing interface address or NULL
262 timeout timeout value or 0
265 Returns: connected socket number, or -1 with errno set
269 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
270 int timeout, transport_instance * tb)
273 smtp_transport_options_block * ob =
274 (smtp_transport_options_block *)tb->options_block;
277 if (host->port != PORT_NONE)
279 HDEBUG(D_transport|D_acl|D_v)
280 debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
284 else host->port = port; /* Set the port actually used */
286 callout_address = string_sprintf("[%s]:%d", host->address, port);
288 HDEBUG(D_transport|D_acl|D_v)
291 if (interface) s = string_sprintf(" from %s ", interface);
293 if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
295 debug_printf("Connecting to %s %s%s... ", host->name, callout_address, s);
298 /* Create and connect the socket */
302 return socks_sock_connect(host, host_af, port, interface, tb, timeout);
305 return smtp_sock_connect(host, host_af, port, interface, tb, timeout);
309 /*************************************************
310 * Flush outgoing command buffer *
311 *************************************************/
313 /* This function is called only from smtp_write_command() below. It flushes
314 the buffer of outgoing commands. There is more than one in the buffer only when
318 outblock the SMTP output block
320 Returns: TRUE if OK, FALSE on error, with errno set
324 flush_buffer(smtp_outblock *outblock)
327 int n = outblock->ptr - outblock->buffer;
329 HDEBUG(D_transport|D_acl) debug_printf("cmd buf flush %d bytes\n", n);
331 if (tls_out.active == outblock->sock)
332 rc = tls_write(FALSE, outblock->buffer, n);
335 rc = send(outblock->sock, outblock->buffer, n, 0);
339 HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
343 outblock->ptr = outblock->buffer;
344 outblock->cmd_count = 0;
350 /*************************************************
351 * Write SMTP command *
352 *************************************************/
354 /* The formatted command is left in big_buffer so that it can be reflected in
358 outblock contains buffer for pipelining, and socket
359 noflush if TRUE, save the command in the output buffer, for pipelining
360 format a format, starting with one of
361 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
362 If NULL, flush pipeline buffer only.
363 ... data for the format
365 Returns: 0 if command added to pipelining buffer, with nothing transmitted
366 +n if n commands transmitted (may still have buffered the new one)
367 -1 on error, with errno set
371 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
379 va_start(ap, format);
380 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
381 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
384 count = Ustrlen(big_buffer);
386 if (count > outblock->buffersize)
387 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
390 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
392 rc = outblock->cmd_count; /* flush resets */
393 if (!flush_buffer(outblock)) return -1;
396 Ustrncpy(CS outblock->ptr, big_buffer, count);
397 outblock->ptr += count;
398 outblock->cmd_count++;
400 big_buffer[count] = 0; /* remove \r\n for error message */
402 /* We want to hide the actual data sent in AUTH transactions from reflections
403 and logs. While authenticating, a flag is set in the outblock to enable this.
404 The AUTH command itself gets any data flattened. Other lines are flattened
407 if (outblock->authenticating)
409 uschar *p = big_buffer;
410 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
413 while (isspace(*p)) p++;
414 while (!isspace(*p)) p++;
415 while (isspace(*p)) p++;
417 while (*p != 0) *p++ = '*';
420 HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP>> %s\n", big_buffer);
425 rc += outblock->cmd_count; /* flush resets */
426 if (!flush_buffer(outblock)) return -1;
434 /*************************************************
435 * Read one line of SMTP response *
436 *************************************************/
438 /* This function reads one line of SMTP response from the server host. This may
439 not be a complete response - it could be just part of a multiline response. We
440 have to use a buffer for incoming packets, because when pipelining or using
441 LMTP, there may well be more than one response in a single packet. This
442 function is called only from the one that follows.
445 inblock the SMTP input block (contains holding buffer, socket, etc.)
446 buffer where to put the line
447 size space available for the line
448 timeout the timeout to use when reading a packet
450 Returns: length of a line that has been put in the buffer
451 -1 otherwise, with errno set
455 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
458 uschar *ptr = inblock->ptr;
459 uschar *ptrend = inblock->ptrend;
460 int sock = inblock->sock;
462 /* Loop for reading multiple packets or reading another packet after emptying
463 a previously-read one. */
469 /* If there is data in the input buffer left over from last time, copy
470 characters from it until the end of a line, at which point we can return,
471 having removed any whitespace (which will include CR) at the end of the line.
472 The rules for SMTP say that lines end in CRLF, but there are have been cases
473 of hosts using just LF, and other MTAs are reported to handle this, so we
474 just look for LF. If we run out of characters before the end of a line,
475 carry on to read the next incoming packet. */
482 while (p > buffer && isspace(p[-1])) p--;
490 *p = 0; /* Leave malformed line for error message */
491 errno = ERRNO_SMTPFORMAT;
496 /* Need to read a new input packet. */
498 rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
501 /* Another block of data has been successfully read. Set up the pointers
502 and let the loop continue. */
504 ptrend = inblock->ptrend = inblock->buffer + rc;
505 ptr = inblock->buffer;
506 DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
509 /* Get here if there has been some kind of recv() error; errno is set, but we
510 ensure that the result buffer is empty before returning. */
520 /*************************************************
521 * Read SMTP response *
522 *************************************************/
524 /* This function reads an SMTP response with a timeout, and returns the
525 response in the given buffer, as a string. A multiline response will contain
526 newline characters between the lines. The function also analyzes the first
527 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
528 also returned after a reading error. In this case buffer[0] will be zero, and
529 the error code will be in errno.
532 inblock the SMTP input block (contains holding buffer, socket, etc.)
533 buffer where to put the response
534 size the size of the buffer
535 okdigit the expected first digit of the response
536 timeout the timeout to use
538 Returns: TRUE if a valid, non-error response was received; else FALSE
542 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
545 uschar *ptr = buffer;
548 errno = 0; /* Ensure errno starts out zero */
550 /* This is a loop to read and concatentate the lines that make up a multi-line
555 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
558 HDEBUG(D_transport|D_acl|D_v)
559 debug_printf(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
561 /* Check the format of the response: it must start with three digits; if
562 these are followed by a space or end of line, the response is complete. If
563 they are followed by '-' this is a multi-line response and we must look for
564 another line until the final line is reached. The only use made of multi-line
565 responses is to pass them back as error messages. We therefore just
566 concatenate them all within the buffer, which should be large enough to
567 accept any reasonable number of lines. */
573 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
575 errno = ERRNO_SMTPFORMAT; /* format error */
579 /* If the line we have just read is a terminal line, line, we are done.
580 Otherwise more data has to be read. */
582 if (ptr[3] != '-') break;
584 /* Move the reading pointer upwards in the buffer and insert \n between the
585 components of a multiline response. Space is left for this by read_response_
593 /* Return a value that depends on the SMTP return code. On some systems a
594 non-zero value of errno has been seen at this point, so ensure it is zero,
595 because the caller of this function looks at errno when FALSE is returned, to
596 distinguish between an unexpected return code and other errors such as
597 timeouts, lost connections, etc. */
600 return buffer[0] == okdigit;
603 /* End of smtp_out.c */