CHUNKING: pipeline data right after the BDAT command
[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_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 * 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_indent("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_indent("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 mode more-expected, or plain
323
324 Returns: TRUE if OK, FALSE on error, with errno set
325 */
326
327 static BOOL
328 flush_buffer(smtp_outblock * outblock, int mode)
329 {
330 int rc;
331 int n = outblock->ptr - outblock->buffer;
332
333 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
334 mode == SCMD_MORE ? " (with MORE annotation)" : "");
335
336 #ifdef SUPPORT_TLS
337 if (tls_out.active == outblock->sock)
338 rc = tls_write(FALSE, outblock->buffer, n);
339 else
340 #endif
341 rc = send(outblock->sock, outblock->buffer, n,
342 #ifdef MSG_MORE
343 mode == SCMD_MORE ? MSG_MORE : 0
344 #else
345 0
346 #endif
347 );
348
349 if (rc <= 0)
350 {
351 HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
352 return FALSE;
353 }
354
355 outblock->ptr = outblock->buffer;
356 outblock->cmd_count = 0;
357 return TRUE;
358 }
359
360
361
362 /*************************************************
363 * Write SMTP command *
364 *************************************************/
365
366 /* The formatted command is left in big_buffer so that it can be reflected in
367 any error message.
368
369 Arguments:
370 outblock contains buffer for pipelining, and socket
371 mode buffer, write-with-more-likely, write
372 format a format, starting with one of
373 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
374 If NULL, flush pipeline buffer only.
375 ... data for the format
376
377 Returns: 0 if command added to pipelining buffer, with nothing transmitted
378 +n if n commands transmitted (may still have buffered the new one)
379 -1 on error, with errno set
380 */
381
382 int
383 smtp_write_command(smtp_outblock * outblock, int mode, const char *format, ...)
384 {
385 int count;
386 int rc = 0;
387 va_list ap;
388
389 if (format)
390 {
391 va_start(ap, format);
392 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
393 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
394 "SMTP");
395 va_end(ap);
396 count = Ustrlen(big_buffer);
397
398 if (count > outblock->buffersize)
399 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
400 "SMTP");
401
402 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
403 {
404 rc = outblock->cmd_count; /* flush resets */
405 if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
406 }
407
408 Ustrncpy(CS outblock->ptr, big_buffer, count);
409 outblock->ptr += count;
410 outblock->cmd_count++;
411 count -= 2;
412 big_buffer[count] = 0; /* remove \r\n for error message */
413
414 /* We want to hide the actual data sent in AUTH transactions from reflections
415 and logs. While authenticating, a flag is set in the outblock to enable this.
416 The AUTH command itself gets any data flattened. Other lines are flattened
417 completely. */
418
419 if (outblock->authenticating)
420 {
421 uschar *p = big_buffer;
422 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
423 {
424 p += 5;
425 while (isspace(*p)) p++;
426 while (!isspace(*p)) p++;
427 while (isspace(*p)) p++;
428 }
429 while (*p != 0) *p++ = '*';
430 }
431
432 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP>> %s\n", big_buffer);
433 }
434
435 if (mode != SCMD_BUFFER)
436 {
437 rc += outblock->cmd_count; /* flush resets */
438 if (!flush_buffer(outblock, mode)) return -1;
439 }
440
441 return rc;
442 }
443
444
445
446 /*************************************************
447 * Read one line of SMTP response *
448 *************************************************/
449
450 /* This function reads one line of SMTP response from the server host. This may
451 not be a complete response - it could be just part of a multiline response. We
452 have to use a buffer for incoming packets, because when pipelining or using
453 LMTP, there may well be more than one response in a single packet. This
454 function is called only from the one that follows.
455
456 Arguments:
457 inblock the SMTP input block (contains holding buffer, socket, etc.)
458 buffer where to put the line
459 size space available for the line
460 timeout the timeout to use when reading a packet
461
462 Returns: length of a line that has been put in the buffer
463 -1 otherwise, with errno set
464 */
465
466 static int
467 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
468 {
469 uschar *p = buffer;
470 uschar *ptr = inblock->ptr;
471 uschar *ptrend = inblock->ptrend;
472 int sock = inblock->sock;
473
474 /* Loop for reading multiple packets or reading another packet after emptying
475 a previously-read one. */
476
477 for (;;)
478 {
479 int rc;
480
481 /* If there is data in the input buffer left over from last time, copy
482 characters from it until the end of a line, at which point we can return,
483 having removed any whitespace (which will include CR) at the end of the line.
484 The rules for SMTP say that lines end in CRLF, but there are have been cases
485 of hosts using just LF, and other MTAs are reported to handle this, so we
486 just look for LF. If we run out of characters before the end of a line,
487 carry on to read the next incoming packet. */
488
489 while (ptr < ptrend)
490 {
491 int c = *ptr++;
492 if (c == '\n')
493 {
494 while (p > buffer && isspace(p[-1])) p--;
495 *p = 0;
496 inblock->ptr = ptr;
497 return p - buffer;
498 }
499 *p++ = c;
500 if (--size < 4)
501 {
502 *p = 0; /* Leave malformed line for error message */
503 errno = ERRNO_SMTPFORMAT;
504 return -1;
505 }
506 }
507
508 /* Need to read a new input packet. */
509
510 if((rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout)) <= 0)
511 {
512 DEBUG(D_deliver|D_transport|D_acl)
513 debug_printf_indent(errno ? " SMTP(%s)<<\n" : " SMTP(closed)<<\n",
514 strerror(errno));
515 break;
516 }
517
518 /* Another block of data has been successfully read. Set up the pointers
519 and let the loop continue. */
520
521 ptrend = inblock->ptrend = inblock->buffer + rc;
522 ptr = inblock->buffer;
523 DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
524 }
525
526 /* Get here if there has been some kind of recv() error; errno is set, but we
527 ensure that the result buffer is empty before returning. */
528
529 *buffer = 0;
530 return -1;
531 }
532
533
534
535
536
537 /*************************************************
538 * Read SMTP response *
539 *************************************************/
540
541 /* This function reads an SMTP response with a timeout, and returns the
542 response in the given buffer, as a string. A multiline response will contain
543 newline characters between the lines. The function also analyzes the first
544 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
545 also returned after a reading error. In this case buffer[0] will be zero, and
546 the error code will be in errno.
547
548 Arguments:
549 inblock the SMTP input block (contains holding buffer, socket, etc.)
550 buffer where to put the response
551 size the size of the buffer
552 okdigit the expected first digit of the response
553 timeout the timeout to use, in seconds
554
555 Returns: TRUE if a valid, non-error response was received; else FALSE
556 */
557
558 BOOL
559 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
560 int timeout)
561 {
562 uschar *ptr = buffer;
563 int count;
564
565 errno = 0; /* Ensure errno starts out zero */
566
567 /* This is a loop to read and concatenate the lines that make up a multi-line
568 response. */
569
570 for (;;)
571 {
572 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
573 return FALSE;
574
575 HDEBUG(D_transport|D_acl|D_v)
576 debug_printf_indent(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
577
578 /* Check the format of the response: it must start with three digits; if
579 these are followed by a space or end of line, the response is complete. If
580 they are followed by '-' this is a multi-line response and we must look for
581 another line until the final line is reached. The only use made of multi-line
582 responses is to pass them back as error messages. We therefore just
583 concatenate them all within the buffer, which should be large enough to
584 accept any reasonable number of lines. */
585
586 if (count < 3 ||
587 !isdigit(ptr[0]) ||
588 !isdigit(ptr[1]) ||
589 !isdigit(ptr[2]) ||
590 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
591 {
592 errno = ERRNO_SMTPFORMAT; /* format error */
593 return FALSE;
594 }
595
596 /* If the line we have just read is a terminal line, line, we are done.
597 Otherwise more data has to be read. */
598
599 if (ptr[3] != '-') break;
600
601 /* Move the reading pointer upwards in the buffer and insert \n between the
602 components of a multiline response. Space is left for this by read_response_
603 line(). */
604
605 ptr += count;
606 *ptr++ = '\n';
607 size -= count + 1;
608 }
609
610 /* Return a value that depends on the SMTP return code. On some systems a
611 non-zero value of errno has been seen at this point, so ensure it is zero,
612 because the caller of this function looks at errno when FALSE is returned, to
613 distinguish between an unexpected return code and other errors such as
614 timeouts, lost connections, etc. */
615
616 errno = 0;
617 return buffer[0] == okdigit;
618 }
619
620 /* End of smtp_out.c */
621 /* vi: aw ai sw=2
622 */