1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2009 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* A number of functions for driving outgoing SMTP calls. */
15 /*************************************************
16 * Find an outgoing interface *
17 *************************************************/
19 /* This function is called from the smtp transport and also from the callout
20 code in verify.c. Its job is to expand a string to get a list of interfaces,
21 and choose a suitable one (IPv4 or IPv6) for the outgoing address.
24 istring string interface setting, may be NULL, meaning "any", in
25 which case the function does nothing
26 host_af AF_INET or AF_INET6 for the outgoing IP address
27 addr the mail address being handled (for setting errors)
28 changed if not NULL, set TRUE if expansion actually changed istring
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 BOOL *changed, uschar **interface, uschar *msg)
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 if (changed != NULL) *changed = expint != istring;
58 while (isspace(*expint)) expint++;
59 if (*expint == 0) return TRUE;
61 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
62 big_buffer_size)) != NULL)
64 if (string_is_ip_address(iface, NULL) == 0)
66 addr->transport_return = PANIC;
67 addr->message = string_sprintf("\"%s\" is not a valid IP "
68 "address for the \"interface\" option for %s",
73 if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
77 if (iface != NULL) *interface = string_copy(iface);
83 /*************************************************
84 * Find an outgoing port *
85 *************************************************/
87 /* This function is called from the smtp transport and also from the callout
88 code in verify.c. Its job is to find a port number. Note that getservbyname()
89 produces the number in network byte order.
92 rstring raw (unexpanded) string representation of the port
93 addr the mail address being handled (for setting errors)
94 port stick the port in here
95 msg for adding to error message
97 Returns: TRUE on success, FALSE on failure, with error message set
98 in addr, and transport_return set to PANIC
102 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
104 uschar *pstring = expand_string(rstring);
108 addr->transport_return = PANIC;
109 addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
110 "for %s: %s", rstring, msg, expand_string_message);
114 if (isdigit(*pstring))
117 *port = Ustrtol(pstring, &end, 0);
118 if (end != pstring + Ustrlen(pstring))
120 addr->transport_return = PANIC;
121 addr->message = string_sprintf("invalid port number for %s: %s", msg,
129 struct servent *smtp_service = getservbyname(CS pstring, "tcp");
130 if (smtp_service == NULL)
132 addr->transport_return = PANIC;
133 addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
137 *port = ntohs(smtp_service->s_port);
146 /*************************************************
147 * Connect to remote host *
148 *************************************************/
150 /* Create a socket, and connect it to a remote host. IPv6 addresses are
151 detected by checking for a colon in the address. AF_INET6 is defined even on
152 non-IPv6 systems, to enable the code to be less messy. However, on such systems
153 host->address will always be an IPv4 address.
155 The port field in the host item is used if it is set (usually router from SRV
156 records or elsewhere). In other cases, the default passed as an argument is
157 used, and the host item is updated with its value.
160 host host item containing name and address (and sometimes port)
161 host_af AF_INET or AF_INET6
162 port default remote port to connect to, in host byte order, for those
163 hosts whose port setting is PORT_NONE
164 interface outgoing interface address or NULL
165 timeout timeout value or 0
166 keepalive TRUE to use keepalive
168 Returns: connected socket number, or -1 with errno set
172 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
173 int timeout, BOOL keepalive)
179 if (host->port != PORT_NONE)
181 HDEBUG(D_transport|D_acl|D_v)
182 debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
186 else host->port = port; /* Set the port actually used */
188 HDEBUG(D_transport|D_acl|D_v)
190 if (interface == NULL)
191 debug_printf("Connecting to %s [%s]:%d ... ",host->name,host->address,port);
193 debug_printf("Connecting to %s [%s]:%d from %s ... ", host->name,
194 host->address, port, interface);
197 /* Create the socket */
199 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
201 /* Set TCP_NODELAY; Exim does its own buffering. */
203 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (uschar *)(&on), sizeof(on));
205 /* Bind to a specific interface if requested. Caller must ensure the interface
206 is the same type (IPv4 or IPv6) as the outgoing address. */
208 if (interface != NULL && ip_bind(sock, host_af, interface, 0) < 0)
211 HDEBUG(D_transport|D_acl|D_v)
212 debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
216 /* Connect to the remote host, and add keepalive to the socket before returning
219 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
222 /* Either bind() or connect() failed */
226 HDEBUG(D_transport|D_acl|D_v)
228 debug_printf("failed: %s", CUstrerror(save_errno));
229 if (save_errno == ETIMEDOUT)
230 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
238 /* Both bind() and connect() succeeded */
242 union sockaddr_46 interface_sock;
243 EXIM_SOCKLEN_T size = sizeof(interface_sock);
244 HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
245 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
246 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
249 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
250 "getsockname() failed: %s", strerror(errno));
254 if (keepalive) ip_keepalive(sock, host->address, TRUE);
260 /*************************************************
261 * Flush outgoing command buffer *
262 *************************************************/
264 /* This function is called only from smtp_write_command() below. It flushes
265 the buffer of outgoing commands. There is more than one in the buffer only when
269 outblock the SMTP output block
271 Returns: TRUE if OK, FALSE on error, with errno set
275 flush_buffer(smtp_outblock *outblock)
280 if (tls_active == outblock->sock)
281 rc = tls_write(outblock->buffer, outblock->ptr - outblock->buffer);
285 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
288 HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
292 outblock->ptr = outblock->buffer;
293 outblock->cmd_count = 0;
299 /*************************************************
300 * Write SMTP command *
301 *************************************************/
303 /* The formatted command is left in big_buffer so that it can be reflected in
307 outblock contains buffer for pipelining, and socket
308 noflush if TRUE, save the command in the output buffer, for pipelining
309 format a format, starting with one of
310 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
311 ... data for the format
313 Returns: 0 if command added to pipelining buffer, with nothing transmitted
314 +n if n commands transmitted (may still have buffered the new one)
315 -1 on error, with errno set
319 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
325 va_start(ap, format);
326 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
327 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
330 count = Ustrlen(big_buffer);
332 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
334 rc = outblock->cmd_count; /* flush resets */
335 if (!flush_buffer(outblock)) return -1;
338 Ustrncpy(CS outblock->ptr, big_buffer, count);
339 outblock->ptr += count;
340 outblock->cmd_count++;
342 big_buffer[count] = 0; /* remove \r\n for error message */
344 /* We want to hide the actual data sent in AUTH transactions from reflections
345 and logs. While authenticating, a flag is set in the outblock to enable this.
346 The AUTH command itself gets any data flattened. Other lines are flattened
349 if (outblock->authenticating)
351 uschar *p = big_buffer;
352 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
355 while (isspace(*p)) p++;
356 while (!isspace(*p)) p++;
357 while (isspace(*p)) p++;
359 while (*p != 0) *p++ = '*';
362 HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP>> %s\n", big_buffer);
366 rc += outblock->cmd_count; /* flush resets */
367 if (!flush_buffer(outblock)) return -1;
375 /*************************************************
376 * Read one line of SMTP response *
377 *************************************************/
379 /* This function reads one line of SMTP response from the server host. This may
380 not be a complete response - it could be just part of a multiline response. We
381 have to use a buffer for incoming packets, because when pipelining or using
382 LMTP, there may well be more than one response in a single packet. This
383 function is called only from the one that follows.
386 inblock the SMTP input block (contains holding buffer, socket, etc.)
387 buffer where to put the line
388 size space available for the line
389 timeout the timeout to use when reading a packet
391 Returns: length of a line that has been put in the buffer
392 -1 otherwise, with errno set
396 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
399 uschar *ptr = inblock->ptr;
400 uschar *ptrend = inblock->ptrend;
401 int sock = inblock->sock;
403 /* Loop for reading multiple packets or reading another packet after emptying
404 a previously-read one. */
410 /* If there is data in the input buffer left over from last time, copy
411 characters from it until the end of a line, at which point we can return,
412 having removed any whitespace (which will include CR) at the end of the line.
413 The rules for SMTP say that lines end in CRLF, but there are have been cases
414 of hosts using just LF, and other MTAs are reported to handle this, so we
415 just look for LF. If we run out of characters before the end of a line,
416 carry on to read the next incoming packet. */
423 while (p > buffer && isspace(p[-1])) p--;
431 *p = 0; /* Leave malformed line for error message */
432 errno = ERRNO_SMTPFORMAT;
437 /* Need to read a new input packet. */
439 rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
442 /* Another block of data has been successfully read. Set up the pointers
443 and let the loop continue. */
445 ptrend = inblock->ptrend = inblock->buffer + rc;
446 ptr = inblock->buffer;
447 DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
450 /* Get here if there has been some kind of recv() error; errno is set, but we
451 ensure that the result buffer is empty before returning. */
461 /*************************************************
462 * Read SMTP response *
463 *************************************************/
465 /* This function reads an SMTP response with a timeout, and returns the
466 response in the given buffer, as a string. A multiline response will contain
467 newline characters between the lines. The function also analyzes the first
468 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
469 also returned after a reading error. In this case buffer[0] will be zero, and
470 the error code will be in errno.
473 inblock the SMTP input block (contains holding buffer, socket, etc.)
474 buffer where to put the response
475 size the size of the buffer
476 okdigit the expected first digit of the response
477 timeout the timeout to use
479 Returns: TRUE if a valid, non-error response was received; else FALSE
483 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
486 uschar *ptr = buffer;
489 errno = 0; /* Ensure errno starts out zero */
491 /* This is a loop to read and concatentate the lines that make up a multi-line
496 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
499 HDEBUG(D_transport|D_acl|D_v)
500 debug_printf(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
502 /* Check the format of the response: it must start with three digits; if
503 these are followed by a space or end of line, the response is complete. If
504 they are followed by '-' this is a multi-line response and we must look for
505 another line until the final line is reached. The only use made of multi-line
506 responses is to pass them back as error messages. We therefore just
507 concatenate them all within the buffer, which should be large enough to
508 accept any reasonable number of lines. */
514 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
516 errno = ERRNO_SMTPFORMAT; /* format error */
520 /* If the line we have just read is a terminal line, line, we are done.
521 Otherwise more data has to be read. */
523 if (ptr[3] != '-') break;
525 /* Move the reading pointer upwards in the buffer and insert \n between the
526 components of a multiline response. Space is left for this by read_response_
534 /* Return a value that depends on the SMTP return code. On some systems a
535 non-zero value of errno has been seen at this point, so ensure it is zero,
536 because the caller of this function looks at errno when FALSE is returned, to
537 distinguish between an unexpected return code and other errors such as
538 timeouts, lost connections, etc. */
541 return buffer[0] == okdigit;
544 /* End of smtp_out.c */