TLS: do decent PIPELINING under TLS, at least with GnuTLS
[users/jgh/exim.git] / src / src / smtp_out.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
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 #include "transports/smtp.h"
13
14
15
16 /*************************************************
17 *           Find an outgoing interface           *
18 *************************************************/
19
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.
23
24 Arguments:
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
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   uschar **interface, uschar *msg)
39 {
40 const uschar * expint;
41 uschar *iface;
42 int sep = 0;
43
44 if (!istring) return TRUE;
45
46 if (!(expint = expand_string(istring)))
47   {
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);
52   return FALSE;
53   }
54
55 while (isspace(*expint)) expint++;
56 if (*expint == 0) return TRUE;
57
58 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
59           big_buffer_size)))
60   {
61   if (string_is_ip_address(iface, NULL) == 0)
62     {
63     addr->transport_return = PANIC;
64     addr->message = string_sprintf("\"%s\" is not a valid IP "
65       "address for the \"interface\" option for %s",
66       iface, msg);
67     return FALSE;
68     }
69
70   if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
71     break;
72   }
73
74 if (iface) *interface = string_copy(iface);
75 return TRUE;
76 }
77
78
79
80 /*************************************************
81 *           Find an outgoing port                *
82 *************************************************/
83
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.
87
88 Arguments:
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
93
94 Returns:      TRUE on success, FALSE on failure, with error message set
95                 in addr, and transport_return set to PANIC
96 */
97
98 BOOL
99 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
100 {
101 uschar *pstring = expand_string(rstring);
102
103 if (!pstring)
104   {
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);
108   return FALSE;
109   }
110
111 if (isdigit(*pstring))
112   {
113   uschar *end;
114   *port = Ustrtol(pstring, &end, 0);
115   if (end != pstring + Ustrlen(pstring))
116     {
117     addr->transport_return = PANIC;
118     addr->message = string_sprintf("invalid port number for %s: %s", msg,
119       pstring);
120     return FALSE;
121     }
122   }
123
124 else
125   {
126   struct servent *smtp_service = getservbyname(CS pstring, "tcp");
127   if (!smtp_service)
128     {
129     addr->transport_return = PANIC;
130     addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
131       pstring, msg);
132     return FALSE;
133     }
134   *port = ntohs(smtp_service->s_port);
135   }
136
137 return TRUE;
138 }
139
140
141
142
143 int
144 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
145   transport_instance * tb, int timeout)
146 {
147 smtp_transport_options_block * ob =
148   (smtp_transport_options_block *)tb->options_block;
149 const uschar * dscp = ob->dscp;
150 int dscp_value;
151 int dscp_level;
152 int dscp_option;
153 int sock;
154 int save_errno = 0;
155 BOOL fastopen = FALSE;
156
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;
161 #endif
162
163 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
164
165 /* Set TCP_NODELAY; Exim does its own buffering. */
166
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));
170
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. */
173
174 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
175   {
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));
186   }
187
188 #ifdef TCP_FASTOPEN
189 if (verify_check_given_host (&ob->hosts_try_fastopen, host) == OK) fastopen = TRUE;
190 #endif
191
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. */
194
195 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
196   {
197   save_errno = errno;
198   HDEBUG(D_transport|D_acl|D_v)
199     debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
200     strerror(errno));
201   }
202
203 /* Connect to the remote host, and add keepalive to the socket before returning
204 it, if requested. */
205
206 else if (ip_connect(sock, host_af, host->address, port, timeout, fastopen) < 0)
207   save_errno = errno;
208
209 /* Either bind() or connect() failed */
210
211 if (save_errno != 0)
212   {
213   HDEBUG(D_transport|D_acl|D_v)
214     {
215     debug_printf_indent("failed: %s", CUstrerror(save_errno));
216     if (save_errno == ETIMEDOUT)
217       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
218     debug_printf("\n");
219     }
220   (void)close(sock);
221   errno = save_errno;
222   return -1;
223   }
224
225 /* Both bind() and connect() succeeded */
226
227 else
228   {
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);
234   else
235     {
236     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
237       "getsockname() failed: %s", strerror(errno));
238     close(sock);
239     return -1;
240     }
241   if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
242   return sock;
243   }
244 }
245
246
247
248
249
250 void
251 smtp_port_for_connect(host_item * host, int port)
252 {
253 if (host->port != PORT_NONE)
254   {
255   HDEBUG(D_transport|D_acl|D_v)
256     debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
257       host->port);
258   port = host->port;
259   }
260 else host->port = port;    /* Set the port actually used */
261 }
262
263
264 /*************************************************
265 *           Connect to remote host               *
266 *************************************************/
267
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.
272
273 Arguments:
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
278   tb          transport
279
280 Returns:      connected socket number, or -1 with errno set
281 */
282
283 int
284 smtp_connect(host_item *host, int host_af, uschar *interface,
285   int timeout, transport_instance * tb)
286 {
287 int port = host->port;
288 #ifdef SUPPORT_SOCKS
289 smtp_transport_options_block * ob =
290   (smtp_transport_options_block *)tb->options_block;
291 #endif
292
293 callout_address = string_sprintf("[%s]:%d", host->address, port);
294
295 HDEBUG(D_transport|D_acl|D_v)
296   {
297   uschar * s = US" ";
298   if (interface) s = string_sprintf(" from %s ", interface);
299 #ifdef SUPPORT_SOCKS
300   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
301 #endif
302   debug_printf_indent("Connecting to %s %s%s... ", host->name, callout_address, s);
303   }
304
305 /* Create and connect the socket */
306
307 #ifdef SUPPORT_SOCKS
308 if (ob->socks_proxy)
309   return socks_sock_connect(host, host_af, port, interface, tb, timeout);
310 #endif
311
312 return smtp_sock_connect(host, host_af, port, interface, tb, timeout);
313 }
314
315
316 /*************************************************
317 *        Flush outgoing command buffer           *
318 *************************************************/
319
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
322 pipelining.
323
324 Argument:
325   outblock   the SMTP output block
326   mode       further data expected, or plain
327
328 Returns:     TRUE if OK, FALSE on error, with errno set
329 */
330
331 static BOOL
332 flush_buffer(smtp_outblock * outblock, int mode)
333 {
334 int rc;
335 int n = outblock->ptr - outblock->buffer;
336 BOOL more = mode == SCMD_MORE;
337
338 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
339   more ? " (more expected)" : "");
340
341 #ifdef SUPPORT_TLS
342 if (tls_out.active == outblock->sock)
343   rc = tls_write(FALSE, outblock->buffer, n, more);
344 else
345 #endif
346   rc = send(outblock->sock, outblock->buffer, n,
347 #ifdef MSG_MORE
348             more ? MSG_MORE : 0
349 #else
350             0
351 #endif
352            );
353
354 if (rc <= 0)
355   {
356   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
357   return FALSE;
358   }
359
360 outblock->ptr = outblock->buffer;
361 outblock->cmd_count = 0;
362 return TRUE;
363 }
364
365
366
367 /*************************************************
368 *             Write SMTP command                 *
369 *************************************************/
370
371 /* The formatted command is left in big_buffer so that it can be reflected in
372 any error message.
373
374 Arguments:
375   outblock   contains buffer for pipelining, and socket
376   mode       buffer, write-with-more-likely, write
377   format     a format, starting with one of
378              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
379              If NULL, flush pipeline buffer only.
380   ...        data for the format
381
382 Returns:     0 if command added to pipelining buffer, with nothing transmitted
383             +n if n commands transmitted (may still have buffered the new one)
384             -1 on error, with errno set
385 */
386
387 int
388 smtp_write_command(smtp_outblock * outblock, int mode, const char *format, ...)
389 {
390 int count;
391 int rc = 0;
392 va_list ap;
393
394 if (format)
395   {
396   va_start(ap, format);
397   if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
398     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
399       "SMTP");
400   va_end(ap);
401   count = Ustrlen(big_buffer);
402
403   if (count > outblock->buffersize)
404     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
405       "SMTP");
406
407   if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
408     {
409     rc = outblock->cmd_count;                 /* flush resets */
410     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
411     }
412
413   Ustrncpy(CS outblock->ptr, big_buffer, count);
414   outblock->ptr += count;
415   outblock->cmd_count++;
416   count -= 2;
417   big_buffer[count] = 0;     /* remove \r\n for error message */
418
419   /* We want to hide the actual data sent in AUTH transactions from reflections
420   and logs. While authenticating, a flag is set in the outblock to enable this.
421   The AUTH command itself gets any data flattened. Other lines are flattened
422   completely. */
423
424   if (outblock->authenticating)
425     {
426     uschar *p = big_buffer;
427     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
428       {
429       p += 5;
430       while (isspace(*p)) p++;
431       while (!isspace(*p)) p++;
432       while (isspace(*p)) p++;
433       }
434     while (*p != 0) *p++ = '*';
435     }
436
437   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> %s\n", big_buffer);
438   }
439
440 if (mode != SCMD_BUFFER)
441   {
442   rc += outblock->cmd_count;                /* flush resets */
443   if (!flush_buffer(outblock, mode)) return -1;
444   }
445
446 return rc;
447 }
448
449
450
451 /*************************************************
452 *          Read one line of SMTP response        *
453 *************************************************/
454
455 /* This function reads one line of SMTP response from the server host. This may
456 not be a complete response - it could be just part of a multiline response. We
457 have to use a buffer for incoming packets, because when pipelining or using
458 LMTP, there may well be more than one response in a single packet. This
459 function is called only from the one that follows.
460
461 Arguments:
462   inblock   the SMTP input block (contains holding buffer, socket, etc.)
463   buffer    where to put the line
464   size      space available for the line
465   timeout   the timeout to use when reading a packet
466
467 Returns:    length of a line that has been put in the buffer
468             -1 otherwise, with errno set
469 */
470
471 static int
472 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
473 {
474 uschar *p = buffer;
475 uschar *ptr = inblock->ptr;
476 uschar *ptrend = inblock->ptrend;
477 int sock = inblock->sock;
478
479 /* Loop for reading multiple packets or reading another packet after emptying
480 a previously-read one. */
481
482 for (;;)
483   {
484   int rc;
485
486   /* If there is data in the input buffer left over from last time, copy
487   characters from it until the end of a line, at which point we can return,
488   having removed any whitespace (which will include CR) at the end of the line.
489   The rules for SMTP say that lines end in CRLF, but there are have been cases
490   of hosts using just LF, and other MTAs are reported to handle this, so we
491   just look for LF. If we run out of characters before the end of a line,
492   carry on to read the next incoming packet. */
493
494   while (ptr < ptrend)
495     {
496     int c = *ptr++;
497     if (c == '\n')
498       {
499       while (p > buffer && isspace(p[-1])) p--;
500       *p = 0;
501       inblock->ptr = ptr;
502       return p - buffer;
503       }
504     *p++ = c;
505     if (--size < 4)
506       {
507       *p = 0;                     /* Leave malformed line for error message */
508       errno = ERRNO_SMTPFORMAT;
509       return -1;
510       }
511     }
512
513   /* Need to read a new input packet. */
514
515   if((rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout)) <= 0)
516     {
517     DEBUG(D_deliver|D_transport|D_acl)
518       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
519         strerror(errno));
520     break;
521     }
522
523   /* Another block of data has been successfully read. Set up the pointers
524   and let the loop continue. */
525
526   ptrend = inblock->ptrend = inblock->buffer + rc;
527   ptr = inblock->buffer;
528   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
529   }
530
531 /* Get here if there has been some kind of recv() error; errno is set, but we
532 ensure that the result buffer is empty before returning. */
533
534 *buffer = 0;
535 return -1;
536 }
537
538
539
540
541
542 /*************************************************
543 *              Read SMTP response                *
544 *************************************************/
545
546 /* This function reads an SMTP response with a timeout, and returns the
547 response in the given buffer, as a string. A multiline response will contain
548 newline characters between the lines. The function also analyzes the first
549 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
550 also returned after a reading error. In this case buffer[0] will be zero, and
551 the error code will be in errno.
552
553 Arguments:
554   inblock   the SMTP input block (contains holding buffer, socket, etc.)
555   buffer    where to put the response
556   size      the size of the buffer
557   okdigit   the expected first digit of the response
558   timeout   the timeout to use, in seconds
559
560 Returns:    TRUE if a valid, non-error response was received; else FALSE
561 */
562
563 BOOL
564 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
565    int timeout)
566 {
567 uschar *ptr = buffer;
568 int count;
569
570 errno = 0;  /* Ensure errno starts out zero */
571
572 /* This is a loop to read and concatenate the lines that make up a multi-line
573 response. */
574
575 for (;;)
576   {
577   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
578     return FALSE;
579
580   HDEBUG(D_transport|D_acl|D_v)
581     debug_printf_indent("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
582
583   /* Check the format of the response: it must start with three digits; if
584   these are followed by a space or end of line, the response is complete. If
585   they are followed by '-' this is a multi-line response and we must look for
586   another line until the final line is reached. The only use made of multi-line
587   responses is to pass them back as error messages. We therefore just
588   concatenate them all within the buffer, which should be large enough to
589   accept any reasonable number of lines. */
590
591   if (count < 3 ||
592      !isdigit(ptr[0]) ||
593      !isdigit(ptr[1]) ||
594      !isdigit(ptr[2]) ||
595      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
596     {
597     errno = ERRNO_SMTPFORMAT;    /* format error */
598     return FALSE;
599     }
600
601   /* If the line we have just read is a terminal line, line, we are done.
602   Otherwise more data has to be read. */
603
604   if (ptr[3] != '-') break;
605
606   /* Move the reading pointer upwards in the buffer and insert \n between the
607   components of a multiline response. Space is left for this by read_response_
608   line(). */
609
610   ptr += count;
611   *ptr++ = '\n';
612   size -= count + 1;
613   }
614
615 /* Return a value that depends on the SMTP return code. On some systems a
616 non-zero value of errno has been seen at this point, so ensure it is zero,
617 because the caller of this function looks at errno when FALSE is returned, to
618 distinguish between an unexpected return code and other errors such as
619 timeouts, lost connections, etc. */
620
621 errno = 0;
622 return buffer[0] == okdigit;
623 }
624
625 /* End of smtp_out.c */
626 /* vi: aw ai sw=2
627 */