1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
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 changed if not NULL, set TRUE if expansion actually changed istring
30 interface point this to the interface
31 msg to add to any error message
33 Returns: TRUE on success, FALSE on failure, with error message
34 set in addr and transport_return set to PANIC
38 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
39 BOOL *changed, uschar **interface, uschar *msg)
41 const uschar * expint;
45 if (istring == NULL) return TRUE;
47 expint = expand_string(istring);
50 if (expand_string_forcedfail) return TRUE;
51 addr->transport_return = PANIC;
52 addr->message = string_sprintf("failed to expand \"interface\" "
53 "option for %s: %s", msg, expand_string_message);
57 if (changed != NULL) *changed = expint != istring;
59 while (isspace(*expint)) expint++;
60 if (*expint == 0) return TRUE;
62 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
63 big_buffer_size)) != NULL)
65 if (string_is_ip_address(iface, NULL) == 0)
67 addr->transport_return = PANIC;
68 addr->message = string_sprintf("\"%s\" is not a valid IP "
69 "address for the \"interface\" option for %s",
74 if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
78 if (iface != NULL) *interface = string_copy(iface);
84 /*************************************************
85 * Find an outgoing port *
86 *************************************************/
88 /* This function is called from the smtp transport and also from the callout
89 code in verify.c. Its job is to find a port number. Note that getservbyname()
90 produces the number in network byte order.
93 rstring raw (unexpanded) string representation of the port
94 addr the mail address being handled (for setting errors)
95 port stick the port in here
96 msg for adding to error message
98 Returns: TRUE on success, FALSE on failure, with error message set
99 in addr, and transport_return set to PANIC
103 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
105 uschar *pstring = expand_string(rstring);
109 addr->transport_return = PANIC;
110 addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
111 "for %s: %s", rstring, msg, expand_string_message);
115 if (isdigit(*pstring))
118 *port = Ustrtol(pstring, &end, 0);
119 if (end != pstring + Ustrlen(pstring))
121 addr->transport_return = PANIC;
122 addr->message = string_sprintf("invalid port number for %s: %s", msg,
130 struct servent *smtp_service = getservbyname(CS pstring, "tcp");
131 if (smtp_service == NULL)
133 addr->transport_return = PANIC;
134 addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
138 *port = ntohs(smtp_service->s_port);
148 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
149 transport_instance * tb, int timeout)
151 smtp_transport_options_block * ob =
152 (smtp_transport_options_block *)tb->options_block;
153 const uschar * dscp = ob->dscp;
161 #ifdef EXPERIMENTAL_EVENT
162 deliver_host_address = host->address;
163 deliver_host_port = port;
164 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
167 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
169 /* Set TCP_NODELAY; Exim does its own buffering. */
171 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (uschar *)(&on), sizeof(on));
173 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
174 bomb out, just log it and continue in default traffic class. */
176 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
178 HDEBUG(D_transport|D_acl|D_v)
179 debug_printf("DSCP \"%s\"=%x ", dscp, dscp_value);
180 if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
181 HDEBUG(D_transport|D_acl|D_v)
182 debug_printf("failed to set DSCP: %s ", strerror(errno));
183 /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
184 option for both; ignore failures here */
185 if (host_af == AF_INET6 &&
186 dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
187 (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
190 /* Bind to a specific interface if requested. Caller must ensure the interface
191 is the same type (IPv4 or IPv6) as the outgoing address. */
193 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
196 HDEBUG(D_transport|D_acl|D_v)
197 debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
201 /* Connect to the remote host, and add keepalive to the socket before returning
204 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
207 /* Either bind() or connect() failed */
211 HDEBUG(D_transport|D_acl|D_v)
213 debug_printf("failed: %s", CUstrerror(save_errno));
214 if (save_errno == ETIMEDOUT)
215 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
223 /* Both bind() and connect() succeeded */
227 union sockaddr_46 interface_sock;
228 EXIM_SOCKLEN_T size = sizeof(interface_sock);
229 HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
230 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
231 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
234 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
235 "getsockname() failed: %s", strerror(errno));
239 if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
244 /*************************************************
245 * Connect to remote host *
246 *************************************************/
248 /* Create a socket, and connect it to a remote host. IPv6 addresses are
249 detected by checking for a colon in the address. AF_INET6 is defined even on
250 non-IPv6 systems, to enable the code to be less messy. However, on such systems
251 host->address will always be an IPv4 address.
253 The port field in the host item is used if it is set (usually router from SRV
254 records or elsewhere). In other cases, the default passed as an argument is
255 used, and the host item is updated with its value.
258 host host item containing name and address (and sometimes port)
259 host_af AF_INET or AF_INET6
260 port default remote port to connect to, in host byte order, for those
261 hosts whose port setting is PORT_NONE
262 interface outgoing interface address or NULL
263 timeout timeout value or 0
266 Returns: connected socket number, or -1 with errno set
270 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
271 int timeout, transport_instance * tb)
273 #ifdef EXPERIMENTAL_SOCKS
274 smtp_transport_options_block * ob =
275 (smtp_transport_options_block *)tb->options_block;
278 if (host->port != PORT_NONE)
280 HDEBUG(D_transport|D_acl|D_v)
281 debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
285 else host->port = port; /* Set the port actually used */
287 callout_address = string_sprintf("[%s]:%d", host->address, port);
289 HDEBUG(D_transport|D_acl|D_v)
292 if (interface) s = string_sprintf(" from %s ", interface);
293 #ifdef EXPERIMENTAL_SOCKS
294 if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
296 debug_printf("Connecting to %s %s%s... ", host->name, callout_address, s);
299 /* Create and connect the socket */
301 #ifdef EXPERIMENTAL_SOCKS
303 return socks_sock_connect(host, host_af, port, interface, tb, timeout);
306 return smtp_sock_connect(host, host_af, port, interface, tb, timeout);
310 /*************************************************
311 * Flush outgoing command buffer *
312 *************************************************/
314 /* This function is called only from smtp_write_command() below. It flushes
315 the buffer of outgoing commands. There is more than one in the buffer only when
319 outblock the SMTP output block
321 Returns: TRUE if OK, FALSE on error, with errno set
325 flush_buffer(smtp_outblock *outblock)
330 if (tls_out.active == outblock->sock)
331 rc = tls_write(FALSE, outblock->buffer, outblock->ptr - outblock->buffer);
335 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
338 HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
342 outblock->ptr = outblock->buffer;
343 outblock->cmd_count = 0;
349 /*************************************************
350 * Write SMTP command *
351 *************************************************/
353 /* The formatted command is left in big_buffer so that it can be reflected in
357 outblock contains buffer for pipelining, and socket
358 noflush if TRUE, save the command in the output buffer, for pipelining
359 format a format, starting with one of
360 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
361 ... data for the format
363 Returns: 0 if command added to pipelining buffer, with nothing transmitted
364 +n if n commands transmitted (may still have buffered the new one)
365 -1 on error, with errno set
369 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
375 va_start(ap, format);
376 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
377 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
380 count = Ustrlen(big_buffer);
382 if (count > outblock->buffersize)
383 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
386 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
388 rc = outblock->cmd_count; /* flush resets */
389 if (!flush_buffer(outblock)) return -1;
392 Ustrncpy(CS outblock->ptr, big_buffer, count);
393 outblock->ptr += count;
394 outblock->cmd_count++;
396 big_buffer[count] = 0; /* remove \r\n for error message */
398 /* We want to hide the actual data sent in AUTH transactions from reflections
399 and logs. While authenticating, a flag is set in the outblock to enable this.
400 The AUTH command itself gets any data flattened. Other lines are flattened
403 if (outblock->authenticating)
405 uschar *p = big_buffer;
406 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
409 while (isspace(*p)) p++;
410 while (!isspace(*p)) p++;
411 while (isspace(*p)) p++;
413 while (*p != 0) *p++ = '*';
416 HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP>> %s\n", big_buffer);
420 rc += outblock->cmd_count; /* flush resets */
421 if (!flush_buffer(outblock)) return -1;
429 /*************************************************
430 * Read one line of SMTP response *
431 *************************************************/
433 /* This function reads one line of SMTP response from the server host. This may
434 not be a complete response - it could be just part of a multiline response. We
435 have to use a buffer for incoming packets, because when pipelining or using
436 LMTP, there may well be more than one response in a single packet. This
437 function is called only from the one that follows.
440 inblock the SMTP input block (contains holding buffer, socket, etc.)
441 buffer where to put the line
442 size space available for the line
443 timeout the timeout to use when reading a packet
445 Returns: length of a line that has been put in the buffer
446 -1 otherwise, with errno set
450 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
453 uschar *ptr = inblock->ptr;
454 uschar *ptrend = inblock->ptrend;
455 int sock = inblock->sock;
457 /* Loop for reading multiple packets or reading another packet after emptying
458 a previously-read one. */
464 /* If there is data in the input buffer left over from last time, copy
465 characters from it until the end of a line, at which point we can return,
466 having removed any whitespace (which will include CR) at the end of the line.
467 The rules for SMTP say that lines end in CRLF, but there are have been cases
468 of hosts using just LF, and other MTAs are reported to handle this, so we
469 just look for LF. If we run out of characters before the end of a line,
470 carry on to read the next incoming packet. */
477 while (p > buffer && isspace(p[-1])) p--;
485 *p = 0; /* Leave malformed line for error message */
486 errno = ERRNO_SMTPFORMAT;
491 /* Need to read a new input packet. */
493 rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
496 /* Another block of data has been successfully read. Set up the pointers
497 and let the loop continue. */
499 ptrend = inblock->ptrend = inblock->buffer + rc;
500 ptr = inblock->buffer;
501 DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
504 /* Get here if there has been some kind of recv() error; errno is set, but we
505 ensure that the result buffer is empty before returning. */
515 /*************************************************
516 * Read SMTP response *
517 *************************************************/
519 /* This function reads an SMTP response with a timeout, and returns the
520 response in the given buffer, as a string. A multiline response will contain
521 newline characters between the lines. The function also analyzes the first
522 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
523 also returned after a reading error. In this case buffer[0] will be zero, and
524 the error code will be in errno.
527 inblock the SMTP input block (contains holding buffer, socket, etc.)
528 buffer where to put the response
529 size the size of the buffer
530 okdigit the expected first digit of the response
531 timeout the timeout to use
533 Returns: TRUE if a valid, non-error response was received; else FALSE
537 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
540 uschar *ptr = buffer;
543 errno = 0; /* Ensure errno starts out zero */
545 /* This is a loop to read and concatentate the lines that make up a multi-line
550 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
553 HDEBUG(D_transport|D_acl|D_v)
554 debug_printf(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
556 /* Check the format of the response: it must start with three digits; if
557 these are followed by a space or end of line, the response is complete. If
558 they are followed by '-' this is a multi-line response and we must look for
559 another line until the final line is reached. The only use made of multi-line
560 responses is to pass them back as error messages. We therefore just
561 concatenate them all within the buffer, which should be large enough to
562 accept any reasonable number of lines. */
568 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
570 errno = ERRNO_SMTPFORMAT; /* format error */
574 /* If the line we have just read is a terminal line, line, we are done.
575 Otherwise more data has to be read. */
577 if (ptr[3] != '-') break;
579 /* Move the reading pointer upwards in the buffer and insert \n between the
580 components of a multiline response. Space is left for this by read_response_
588 /* Return a value that depends on the SMTP return code. On some systems a
589 non-zero value of errno has been seen at this point, so ensure it is zero,
590 because the caller of this function looks at errno when FALSE is returned, to
591 distinguish between an unexpected return code and other errors such as
592 timeouts, lost connections, etc. */
595 return buffer[0] == okdigit;
598 /* End of smtp_out.c */