3154c97674d579b0548b188690095e92e8ef7670
[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 == NULL)
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 == NULL)
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("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("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("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("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("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("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 *           Connect to remote host               *
248 *************************************************/
249
250 /* Create a socket, and connect it to a remote host. IPv6 addresses are
251 detected by checking for a colon in the address. AF_INET6 is defined even on
252 non-IPv6 systems, to enable the code to be less messy. However, on such systems
253 host->address will always be an IPv4 address.
254
255 The port field in the host item is used if it is set (usually router from SRV
256 records or elsewhere). In other cases, the default passed as an argument is
257 used, and the host item is updated with its value.
258
259 Arguments:
260   host        host item containing name and address (and sometimes port)
261   host_af     AF_INET or AF_INET6
262   port        default remote port to connect to, in host byte order, for those
263                 hosts whose port setting is PORT_NONE
264   interface   outgoing interface address or NULL
265   timeout     timeout value or 0
266   tb          transport
267
268 Returns:      connected socket number, or -1 with errno set
269 */
270
271 int
272 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
273   int timeout, transport_instance * tb)
274 {
275 #ifdef SUPPORT_SOCKS
276 smtp_transport_options_block * ob =
277   (smtp_transport_options_block *)tb->options_block;
278 #endif
279
280 if (host->port != PORT_NONE)
281   {
282   HDEBUG(D_transport|D_acl|D_v)
283     debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
284       host->port);
285   port = host->port;
286   }
287 else host->port = port;    /* Set the port actually used */
288
289 callout_address = string_sprintf("[%s]:%d", host->address, port);
290
291 HDEBUG(D_transport|D_acl|D_v)
292   {
293   uschar * s = US" ";
294   if (interface) s = string_sprintf(" from %s ", interface);
295 #ifdef SUPPORT_SOCKS
296   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
297 #endif
298   debug_printf("Connecting to %s %s%s... ", host->name, callout_address, s);
299   }
300
301 /* Create and connect the socket */
302
303 #ifdef SUPPORT_SOCKS
304 if (ob->socks_proxy)
305   return socks_sock_connect(host, host_af, port, interface, tb, timeout);
306 #endif
307
308 return smtp_sock_connect(host, host_af, port, interface, tb, timeout);
309 }
310
311
312 /*************************************************
313 *        Flush outgoing command buffer           *
314 *************************************************/
315
316 /* This function is called only from smtp_write_command() below. It flushes
317 the buffer of outgoing commands. There is more than one in the buffer only when
318 pipelining.
319
320 Argument:
321   outblock   the SMTP output block
322
323 Returns:     TRUE if OK, FALSE on error, with errno set
324 */
325
326 static BOOL
327 flush_buffer(smtp_outblock *outblock)
328 {
329 int rc;
330 int n = outblock->ptr - outblock->buffer;
331
332 HDEBUG(D_transport|D_acl) debug_printf("cmd buf flush %d bytes\n", n);
333 #ifdef SUPPORT_TLS
334 if (tls_out.active == outblock->sock)
335   rc = tls_write(FALSE, outblock->buffer, n);
336 else
337 #endif
338   rc = send(outblock->sock, outblock->buffer, n, 0);
339
340 if (rc <= 0)
341   {
342   HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
343   return FALSE;
344   }
345
346 outblock->ptr = outblock->buffer;
347 outblock->cmd_count = 0;
348 return TRUE;
349 }
350
351
352
353 /*************************************************
354 *             Write SMTP command                 *
355 *************************************************/
356
357 /* The formatted command is left in big_buffer so that it can be reflected in
358 any error message.
359
360 Arguments:
361   outblock   contains buffer for pipelining, and socket
362   noflush    if TRUE, save the command in the output buffer, for pipelining
363   format     a format, starting with one of
364              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
365              If NULL, flush pipeline buffer only.
366   ...        data for the format
367
368 Returns:     0 if command added to pipelining buffer, with nothing transmitted
369             +n if n commands transmitted (may still have buffered the new one)
370             -1 on error, with errno set
371 */
372
373 int
374 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
375 {
376 int count;
377 int rc = 0;
378 va_list ap;
379
380 if (format)
381   {
382   va_start(ap, format);
383   if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
384     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
385       "SMTP");
386   va_end(ap);
387   count = Ustrlen(big_buffer);
388
389   if (count > outblock->buffersize)
390     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
391       "SMTP");
392
393   if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
394     {
395     rc = outblock->cmd_count;                 /* flush resets */
396     if (!flush_buffer(outblock)) return -1;
397     }
398
399   Ustrncpy(CS outblock->ptr, big_buffer, count);
400   outblock->ptr += count;
401   outblock->cmd_count++;
402   count -= 2;
403   big_buffer[count] = 0;     /* remove \r\n for error message */
404
405   /* We want to hide the actual data sent in AUTH transactions from reflections
406   and logs. While authenticating, a flag is set in the outblock to enable this.
407   The AUTH command itself gets any data flattened. Other lines are flattened
408   completely. */
409
410   if (outblock->authenticating)
411     {
412     uschar *p = big_buffer;
413     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
414       {
415       p += 5;
416       while (isspace(*p)) p++;
417       while (!isspace(*p)) p++;
418       while (isspace(*p)) p++;
419       }
420     while (*p != 0) *p++ = '*';
421     }
422
423   HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> %s\n", big_buffer);
424   }
425
426 if (!noflush)
427   {
428   rc += outblock->cmd_count;                /* flush resets */
429   if (!flush_buffer(outblock)) return -1;
430   }
431
432 return rc;
433 }
434
435
436
437 /*************************************************
438 *          Read one line of SMTP response        *
439 *************************************************/
440
441 /* This function reads one line of SMTP response from the server host. This may
442 not be a complete response - it could be just part of a multiline response. We
443 have to use a buffer for incoming packets, because when pipelining or using
444 LMTP, there may well be more than one response in a single packet. This
445 function is called only from the one that follows.
446
447 Arguments:
448   inblock   the SMTP input block (contains holding buffer, socket, etc.)
449   buffer    where to put the line
450   size      space available for the line
451   timeout   the timeout to use when reading a packet
452
453 Returns:    length of a line that has been put in the buffer
454             -1 otherwise, with errno set
455 */
456
457 static int
458 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
459 {
460 uschar *p = buffer;
461 uschar *ptr = inblock->ptr;
462 uschar *ptrend = inblock->ptrend;
463 int sock = inblock->sock;
464
465 /* Loop for reading multiple packets or reading another packet after emptying
466 a previously-read one. */
467
468 for (;;)
469   {
470   int rc;
471
472   /* If there is data in the input buffer left over from last time, copy
473   characters from it until the end of a line, at which point we can return,
474   having removed any whitespace (which will include CR) at the end of the line.
475   The rules for SMTP say that lines end in CRLF, but there are have been cases
476   of hosts using just LF, and other MTAs are reported to handle this, so we
477   just look for LF. If we run out of characters before the end of a line,
478   carry on to read the next incoming packet. */
479
480   while (ptr < ptrend)
481     {
482     int c = *ptr++;
483     if (c == '\n')
484       {
485       while (p > buffer && isspace(p[-1])) p--;
486       *p = 0;
487       inblock->ptr = ptr;
488       return p - buffer;
489       }
490     *p++ = c;
491     if (--size < 4)
492       {
493       *p = 0;                     /* Leave malformed line for error message */
494       errno = ERRNO_SMTPFORMAT;
495       return -1;
496       }
497     }
498
499   /* Need to read a new input packet. */
500
501   rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
502   if (rc <= 0) break;
503
504   /* Another block of data has been successfully read. Set up the pointers
505   and let the loop continue. */
506
507   ptrend = inblock->ptrend = inblock->buffer + rc;
508   ptr = inblock->buffer;
509   DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
510   }
511
512 /* Get here if there has been some kind of recv() error; errno is set, but we
513 ensure that the result buffer is empty before returning. */
514
515 *buffer = 0;
516 return -1;
517 }
518
519
520
521
522
523 /*************************************************
524 *              Read SMTP response                *
525 *************************************************/
526
527 /* This function reads an SMTP response with a timeout, and returns the
528 response in the given buffer, as a string. A multiline response will contain
529 newline characters between the lines. The function also analyzes the first
530 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
531 also returned after a reading error. In this case buffer[0] will be zero, and
532 the error code will be in errno.
533
534 Arguments:
535   inblock   the SMTP input block (contains holding buffer, socket, etc.)
536   buffer    where to put the response
537   size      the size of the buffer
538   okdigit   the expected first digit of the response
539   timeout   the timeout to use, in seconds
540
541 Returns:    TRUE if a valid, non-error response was received; else FALSE
542 */
543
544 BOOL
545 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
546    int timeout)
547 {
548 uschar *ptr = buffer;
549 int count;
550
551 errno = 0;  /* Ensure errno starts out zero */
552
553 /* This is a loop to read and concatentate the lines that make up a multi-line
554 response. */
555
556 for (;;)
557   {
558   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
559     return FALSE;
560
561   HDEBUG(D_transport|D_acl|D_v)
562     debug_printf("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
563
564   /* Check the format of the response: it must start with three digits; if
565   these are followed by a space or end of line, the response is complete. If
566   they are followed by '-' this is a multi-line response and we must look for
567   another line until the final line is reached. The only use made of multi-line
568   responses is to pass them back as error messages. We therefore just
569   concatenate them all within the buffer, which should be large enough to
570   accept any reasonable number of lines. */
571
572   if (count < 3 ||
573      !isdigit(ptr[0]) ||
574      !isdigit(ptr[1]) ||
575      !isdigit(ptr[2]) ||
576      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
577     {
578     errno = ERRNO_SMTPFORMAT;    /* format error */
579     return FALSE;
580     }
581
582   /* If the line we have just read is a terminal line, line, we are done.
583   Otherwise more data has to be read. */
584
585   if (ptr[3] != '-') break;
586
587   /* Move the reading pointer upwards in the buffer and insert \n between the
588   components of a multiline response. Space is left for this by read_response_
589   line(). */
590
591   ptr += count;
592   *ptr++ = '\n';
593   size -= count + 1;
594   }
595
596 /* Return a value that depends on the SMTP return code. On some systems a
597 non-zero value of errno has been seen at this point, so ensure it is zero,
598 because the caller of this function looks at errno when FALSE is returned, to
599 distinguish between an unexpected return code and other errors such as
600 timeouts, lost connections, etc. */
601
602 errno = 0;
603 return buffer[0] == okdigit;
604 }
605
606 /* End of smtp_out.c */
607 /* vi: aw ai sw=2
608 */