Merge branch 'master' into dane
[users/heiko/exim.git] / src / src / smtp_out.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2009 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* A number of functions for driving outgoing SMTP calls. */
9
10
11 #include "exim.h"
12
13
14
15 /*************************************************
16 *           Find an outgoing interface           *
17 *************************************************/
18
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.
22
23 Arguments:
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
31
32 Returns:     TRUE on success, FALSE on failure, with error message
33                set in addr and transport_return set to PANIC
34 */
35
36 BOOL
37 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
38   BOOL *changed, uschar **interface, uschar *msg)
39 {
40 uschar *expint;
41 uschar *iface;
42 int sep = 0;
43
44 if (istring == NULL) return TRUE;
45
46 expint = expand_string(istring);
47 if (expint == NULL)
48   {
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);
53   return FALSE;
54   }
55
56 if (changed != NULL) *changed = expint != istring;
57
58 while (isspace(*expint)) expint++;
59 if (*expint == 0) return TRUE;
60
61 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
62           big_buffer_size)) != NULL)
63   {
64   if (string_is_ip_address(iface, NULL) == 0)
65     {
66     addr->transport_return = PANIC;
67     addr->message = string_sprintf("\"%s\" is not a valid IP "
68       "address for the \"interface\" option for %s",
69       iface, msg);
70     return FALSE;
71     }
72
73   if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
74     break;
75   }
76
77 if (iface != NULL) *interface = string_copy(iface);
78 return TRUE;
79 }
80
81
82
83 /*************************************************
84 *           Find an outgoing port                *
85 *************************************************/
86
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.
90
91 Arguments:
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
96
97 Returns:      TRUE on success, FALSE on failure, with error message set
98                 in addr, and transport_return set to PANIC
99 */
100
101 BOOL
102 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
103 {
104 uschar *pstring = expand_string(rstring);
105
106 if (pstring == NULL)
107   {
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);
111   return FALSE;
112   }
113
114 if (isdigit(*pstring))
115   {
116   uschar *end;
117   *port = Ustrtol(pstring, &end, 0);
118   if (end != pstring + Ustrlen(pstring))
119     {
120     addr->transport_return = PANIC;
121     addr->message = string_sprintf("invalid port number for %s: %s", msg,
122       pstring);
123     return FALSE;
124     }
125   }
126
127 else
128   {
129   struct servent *smtp_service = getservbyname(CS pstring, "tcp");
130   if (smtp_service == NULL)
131     {
132     addr->transport_return = PANIC;
133     addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
134       pstring, msg);
135     return FALSE;
136     }
137   *port = ntohs(smtp_service->s_port);
138   }
139
140 return TRUE;
141 }
142
143
144
145
146 /*************************************************
147 *           Connect to remote host               *
148 *************************************************/
149
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.
154
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.
158
159 Arguments:
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
167   dscp        DSCP value to assign to socket
168   tpda_event  event expansion
169
170 Returns:      connected socket number, or -1 with errno set
171 */
172
173 int
174 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
175   int timeout, BOOL keepalive, const uschar *dscp
176 #ifdef EXPERIMENTAL_TPDA
177   , uschar * tpda_event
178 #endif
179   )
180 {
181 int on = 1;
182 int save_errno = 0;
183 int dscp_value;
184 int dscp_level;
185 int dscp_option;
186 int sock;
187
188 if (host->port != PORT_NONE)
189   {
190   HDEBUG(D_transport|D_acl|D_v)
191     debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
192       host->port);
193   port = host->port;
194   }
195 else host->port = port;    /* Set the port actually used */
196
197 HDEBUG(D_transport|D_acl|D_v)
198   {
199   if (interface == NULL)
200     debug_printf("Connecting to %s [%s]:%d ... ",host->name,host->address,port);
201   else
202     debug_printf("Connecting to %s [%s]:%d from %s ... ", host->name,
203       host->address, port, interface);
204   }
205
206 #ifdef EXPERIMENTAL_TPDA
207   /*XXX Called from both delivery and verify.  Is that status observable? */
208   deliver_host_address = host->address;
209   deliver_host_port = port;
210   if (tpda_raise_event(tpda_event, US"tcp:connect", NULL) == DEFER) return -1;
211 #endif
212
213 /* Create the socket */
214
215 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
216
217 /* Set TCP_NODELAY; Exim does its own buffering. */
218
219 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (uschar *)(&on), sizeof(on));
220
221 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
222 bomb out, just log it and continue in default traffic class. */
223
224 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
225   {
226   HDEBUG(D_transport|D_acl|D_v)
227     debug_printf("DSCP \"%s\"=%x ", dscp, dscp_value);
228   if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
229     HDEBUG(D_transport|D_acl|D_v)
230       debug_printf("failed to set DSCP: %s ", strerror(errno));
231   /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
232   option for both; ignore failures here */
233   if (host_af == AF_INET6 &&
234       dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
235     {
236     (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
237     }
238   }
239
240 /* Bind to a specific interface if requested. Caller must ensure the interface
241 is the same type (IPv4 or IPv6) as the outgoing address. */
242
243 if (interface != NULL && ip_bind(sock, host_af, interface, 0) < 0)
244   {
245   save_errno = errno;
246   HDEBUG(D_transport|D_acl|D_v)
247     debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
248     strerror(errno));
249   }
250
251 /* Connect to the remote host, and add keepalive to the socket before returning
252 it, if requested. */
253
254 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
255   save_errno = errno;
256
257 /* Either bind() or connect() failed */
258
259 if (save_errno != 0)
260   {
261   HDEBUG(D_transport|D_acl|D_v)
262     {
263     debug_printf("failed: %s", CUstrerror(save_errno));
264     if (save_errno == ETIMEDOUT)
265       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
266     debug_printf("\n");
267     }
268   (void)close(sock);
269   errno = save_errno;
270   return -1;
271   }
272
273 /* Both bind() and connect() succeeded */
274
275 else
276   {
277   union sockaddr_46 interface_sock;
278   EXIM_SOCKLEN_T size = sizeof(interface_sock);
279   HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
280   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
281     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
282   else
283     {
284     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
285       "getsockname() failed: %s", strerror(errno));
286     close(sock);
287     return -1;
288     }
289   if (keepalive) ip_keepalive(sock, host->address, TRUE);
290   return sock;
291   }
292 }
293
294
295 /*************************************************
296 *        Flush outgoing command buffer           *
297 *************************************************/
298
299 /* This function is called only from smtp_write_command() below. It flushes
300 the buffer of outgoing commands. There is more than one in the buffer only when
301 pipelining.
302
303 Argument:
304   outblock   the SMTP output block
305
306 Returns:     TRUE if OK, FALSE on error, with errno set
307 */
308
309 static BOOL
310 flush_buffer(smtp_outblock *outblock)
311 {
312 int rc;
313
314 #ifdef SUPPORT_TLS
315 if (tls_out.active == outblock->sock)
316   rc = tls_write(FALSE, outblock->buffer, outblock->ptr - outblock->buffer);
317 else
318 #endif
319
320 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
321 if (rc <= 0)
322   {
323   HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
324   return FALSE;
325   }
326
327 outblock->ptr = outblock->buffer;
328 outblock->cmd_count = 0;
329 return TRUE;
330 }
331
332
333
334 /*************************************************
335 *             Write SMTP command                 *
336 *************************************************/
337
338 /* The formatted command is left in big_buffer so that it can be reflected in
339 any error message.
340
341 Arguments:
342   outblock   contains buffer for pipelining, and socket
343   noflush    if TRUE, save the command in the output buffer, for pipelining
344   format     a format, starting with one of
345              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
346   ...        data for the format
347
348 Returns:     0 if command added to pipelining buffer, with nothing transmitted
349             +n if n commands transmitted (may still have buffered the new one)
350             -1 on error, with errno set
351 */
352
353 int
354 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
355 {
356 int count;
357 int rc = 0;
358 va_list ap;
359
360 va_start(ap, format);
361 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
362   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
363     "SMTP");
364 va_end(ap);
365 count = Ustrlen(big_buffer);
366
367 if (count > outblock->buffersize)
368   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
369     "SMTP");
370
371 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
372   {
373   rc = outblock->cmd_count;                 /* flush resets */
374   if (!flush_buffer(outblock)) return -1;
375   }
376
377 Ustrncpy(CS outblock->ptr, big_buffer, count);
378 outblock->ptr += count;
379 outblock->cmd_count++;
380 count -= 2;
381 big_buffer[count] = 0;     /* remove \r\n for error message */
382
383 /* We want to hide the actual data sent in AUTH transactions from reflections
384 and logs. While authenticating, a flag is set in the outblock to enable this.
385 The AUTH command itself gets any data flattened. Other lines are flattened
386 completely. */
387
388 if (outblock->authenticating)
389   {
390   uschar *p = big_buffer;
391   if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
392     {
393     p += 5;
394     while (isspace(*p)) p++;
395     while (!isspace(*p)) p++;
396     while (isspace(*p)) p++;
397     }
398   while (*p != 0) *p++ = '*';
399   }
400
401 HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> %s\n", big_buffer);
402
403 if (!noflush)
404   {
405   rc += outblock->cmd_count;                /* flush resets */
406   if (!flush_buffer(outblock)) return -1;
407   }
408
409 return rc;
410 }
411
412
413
414 /*************************************************
415 *          Read one line of SMTP response        *
416 *************************************************/
417
418 /* This function reads one line of SMTP response from the server host. This may
419 not be a complete response - it could be just part of a multiline response. We
420 have to use a buffer for incoming packets, because when pipelining or using
421 LMTP, there may well be more than one response in a single packet. This
422 function is called only from the one that follows.
423
424 Arguments:
425   inblock   the SMTP input block (contains holding buffer, socket, etc.)
426   buffer    where to put the line
427   size      space available for the line
428   timeout   the timeout to use when reading a packet
429
430 Returns:    length of a line that has been put in the buffer
431             -1 otherwise, with errno set
432 */
433
434 static int
435 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
436 {
437 uschar *p = buffer;
438 uschar *ptr = inblock->ptr;
439 uschar *ptrend = inblock->ptrend;
440 int sock = inblock->sock;
441
442 /* Loop for reading multiple packets or reading another packet after emptying
443 a previously-read one. */
444
445 for (;;)
446   {
447   int rc;
448
449   /* If there is data in the input buffer left over from last time, copy
450   characters from it until the end of a line, at which point we can return,
451   having removed any whitespace (which will include CR) at the end of the line.
452   The rules for SMTP say that lines end in CRLF, but there are have been cases
453   of hosts using just LF, and other MTAs are reported to handle this, so we
454   just look for LF. If we run out of characters before the end of a line,
455   carry on to read the next incoming packet. */
456
457   while (ptr < ptrend)
458     {
459     int c = *ptr++;
460     if (c == '\n')
461       {
462       while (p > buffer && isspace(p[-1])) p--;
463       *p = 0;
464       inblock->ptr = ptr;
465       return p - buffer;
466       }
467     *p++ = c;
468     if (--size < 4)
469       {
470       *p = 0;                     /* Leave malformed line for error message */
471       errno = ERRNO_SMTPFORMAT;
472       return -1;
473       }
474     }
475
476   /* Need to read a new input packet. */
477
478   rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
479   if (rc <= 0) break;
480
481   /* Another block of data has been successfully read. Set up the pointers
482   and let the loop continue. */
483
484   ptrend = inblock->ptrend = inblock->buffer + rc;
485   ptr = inblock->buffer;
486   DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
487   }
488
489 /* Get here if there has been some kind of recv() error; errno is set, but we
490 ensure that the result buffer is empty before returning. */
491
492 *buffer = 0;
493 return -1;
494 }
495
496
497
498
499
500 /*************************************************
501 *              Read SMTP response                *
502 *************************************************/
503
504 /* This function reads an SMTP response with a timeout, and returns the
505 response in the given buffer, as a string. A multiline response will contain
506 newline characters between the lines. The function also analyzes the first
507 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
508 also returned after a reading error. In this case buffer[0] will be zero, and
509 the error code will be in errno.
510
511 Arguments:
512   inblock   the SMTP input block (contains holding buffer, socket, etc.)
513   buffer    where to put the response
514   size      the size of the buffer
515   okdigit   the expected first digit of the response
516   timeout   the timeout to use
517
518 Returns:    TRUE if a valid, non-error response was received; else FALSE
519 */
520
521 BOOL
522 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
523    int timeout)
524 {
525 uschar *ptr = buffer;
526 int count;
527
528 errno = 0;  /* Ensure errno starts out zero */
529
530 /* This is a loop to read and concatentate the lines that make up a multi-line
531 response. */
532
533 for (;;)
534   {
535   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
536     return FALSE;
537
538   HDEBUG(D_transport|D_acl|D_v)
539     debug_printf("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
540
541   /* Check the format of the response: it must start with three digits; if
542   these are followed by a space or end of line, the response is complete. If
543   they are followed by '-' this is a multi-line response and we must look for
544   another line until the final line is reached. The only use made of multi-line
545   responses is to pass them back as error messages. We therefore just
546   concatenate them all within the buffer, which should be large enough to
547   accept any reasonable number of lines. */
548
549   if (count < 3 ||
550      !isdigit(ptr[0]) ||
551      !isdigit(ptr[1]) ||
552      !isdigit(ptr[2]) ||
553      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
554     {
555     errno = ERRNO_SMTPFORMAT;    /* format error */
556     return FALSE;
557     }
558
559   /* If the line we have just read is a terminal line, line, we are done.
560   Otherwise more data has to be read. */
561
562   if (ptr[3] != '-') break;
563
564   /* Move the reading pointer upwards in the buffer and insert \n between the
565   components of a multiline response. Space is left for this by read_response_
566   line(). */
567
568   ptr += count;
569   *ptr++ = '\n';
570   size -= count + 1;
571   }
572
573 /* Return a value that depends on the SMTP return code. On some systems a
574 non-zero value of errno has been seen at this point, so ensure it is zero,
575 because the caller of this function looks at errno when FALSE is returned, to
576 distinguish between an unexpected return code and other errors such as
577 timeouts, lost connections, etc. */
578
579 errno = 0;
580 return buffer[0] == okdigit;
581 }
582
583 /* End of smtp_out.c */