6f7fb85c11a28da11d59de583d0b0ea1b546a43c
[exim.git] / src / src / smtp_out.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* A number of functions for driving outgoing SMTP calls. */
10
11
12 #include "exim.h"
13 #include "transports/smtp.h"
14
15
16
17 /*************************************************
18 * Find an outgoing interface *
19 *************************************************/
20
21 /* This function is called from the smtp transport and also from the callout
22 code in verify.c. Its job is to expand a string to get a list of interfaces,
23 and choose a suitable one (IPv4 or IPv6) for the outgoing address.
24
25 Arguments:
26 istring string interface setting, may be NULL, meaning "any", in
27 which case the function does nothing
28 host_af AF_INET or AF_INET6 for the outgoing IP address
29 addr the mail address being handled (for setting errors)
30 interface point this to the interface
31 msg to add to any error message
32
33 Returns: TRUE on success, FALSE on failure, with error message
34 set in addr and transport_return set to PANIC
35 */
36
37 BOOL
38 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
39 uschar **interface, uschar *msg)
40 {
41 const uschar * expint;
42 uschar *iface;
43 int sep = 0;
44
45 if (!istring) return TRUE;
46
47 if (!(expint = expand_string(istring)))
48 {
49 if (f.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 (is_tainted(expint))
57 {
58 log_write(0, LOG_MAIN|LOG_PANIC,
59 "attempt to use tainted value '%s' from '%s' for interface",
60 expint, istring);
61 addr->transport_return = PANIC;
62 addr->message = string_sprintf("failed to expand \"interface\" "
63 "option for %s: configuration error", msg);
64 return FALSE;
65 }
66
67 Uskip_whitespace(&expint);
68 if (!*expint) return TRUE;
69
70 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
71 big_buffer_size)))
72 {
73 if (string_is_ip_address(iface, NULL) == 0)
74 {
75 addr->transport_return = PANIC;
76 addr->message = string_sprintf("\"%s\" is not a valid IP "
77 "address for the \"interface\" option for %s",
78 iface, msg);
79 return FALSE;
80 }
81
82 if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
83 break;
84 }
85
86 if (iface) *interface = string_copy(iface);
87 return TRUE;
88 }
89
90
91
92 /*************************************************
93 * Find an outgoing port *
94 *************************************************/
95
96 /* This function is called from the smtp transport and also from the callout
97 code in verify.c. Its job is to find a port number. Note that getservbyname()
98 produces the number in network byte order.
99
100 Arguments:
101 rstring raw (unexpanded) string representation of the port
102 addr the mail address being handled (for setting errors)
103 port stick the port in here
104 msg for adding to error message
105
106 Returns: TRUE on success, FALSE on failure, with error message set
107 in addr, and transport_return set to PANIC
108 */
109
110 BOOL
111 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
112 {
113 uschar *pstring = expand_string(rstring);
114
115 if (!pstring)
116 {
117 addr->transport_return = PANIC;
118 addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
119 "for %s: %s", rstring, msg, expand_string_message);
120 return FALSE;
121 }
122
123 if (isdigit(*pstring))
124 {
125 uschar *end;
126 *port = Ustrtol(pstring, &end, 0);
127 if (end != pstring + Ustrlen(pstring))
128 {
129 addr->transport_return = PANIC;
130 addr->message = string_sprintf("invalid port number for %s: %s", msg,
131 pstring);
132 return FALSE;
133 }
134 }
135
136 else
137 {
138 struct servent *smtp_service = getservbyname(CS pstring, "tcp");
139 if (!smtp_service)
140 {
141 addr->transport_return = PANIC;
142 addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
143 pstring, msg);
144 return FALSE;
145 }
146 *port = ntohs(smtp_service->s_port);
147 }
148
149 return TRUE;
150 }
151
152
153
154
155 #ifdef TCP_FASTOPEN
156 static void
157 tfo_out_check(int sock)
158 {
159 # ifdef __FreeBSD__
160 struct tcp_info tinfo;
161 int val;
162 socklen_t len = sizeof(val);
163
164 /* The observability as of 12.1 is not useful as a client, only telling us that
165 a TFO option was used on SYN. It could have been a TFO-R, or ignored by the
166 server. */
167
168 /*
169 if (tcp_out_fastopen == TFO_ATTEMPTED_NODATA || tcp_out_fastopen == TFO_ATTEMPTED_DATA)
170 if (getsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN, &val, &len) == 0 && val != 0) {}
171 */
172 switch (tcp_out_fastopen)
173 {
174 case TFO_ATTEMPTED_NODATA: tcp_out_fastopen = TFO_USED_NODATA; break;
175 case TFO_ATTEMPTED_DATA: tcp_out_fastopen = TFO_USED_DATA; break;
176 default: break; /* compiler quietening */
177 }
178
179 # else /* Linux & Apple */
180 # if defined(TCP_INFO) && defined(EXIM_HAVE_TCPI_UNACKED)
181 struct tcp_info tinfo;
182 socklen_t len = sizeof(tinfo);
183
184 switch (tcp_out_fastopen)
185 {
186 /* This is a somewhat dubious detection method; totally undocumented so likely
187 to fail in future kernels. There seems to be no documented way. What we really
188 want to know is if the server sent smtp-banner data before our ACK of his SYN,ACK
189 hit him. What this (possibly?) detects is whether we sent a TFO cookie with our
190 SYN, as distinct from a TFO request. This gets a false-positive when the server
191 key is rotated; we send the old one (which this test sees) but the server returns
192 the new one and does not send its SMTP banner before we ACK his SYN,ACK.
193 To force that rotation case:
194 '# echo -n "00000000-00000000-00000000-0000000" >/proc/sys/net/ipv4/tcp_fastopen_key'
195 The kernel seems to be counting unack'd packets. */
196
197 case TFO_ATTEMPTED_NODATA:
198 if ( getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0
199 && tinfo.tcpi_state == TCP_SYN_SENT
200 && tinfo.tcpi_unacked > 1
201 )
202 {
203 DEBUG(D_transport|D_v)
204 debug_printf("TCP_FASTOPEN tcpi_unacked %d\n", tinfo.tcpi_unacked);
205 tcp_out_fastopen = TFO_USED_NODATA;
206 }
207 break;
208
209 /* When called after waiting for received data we should be able
210 to tell if data we sent was accepted. */
211
212 case TFO_ATTEMPTED_DATA:
213 if ( getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0
214 && tinfo.tcpi_state == TCP_ESTABLISHED
215 )
216 if (tinfo.tcpi_options & TCPI_OPT_SYN_DATA)
217 {
218 DEBUG(D_transport|D_v) debug_printf("TFO: data was acked\n");
219 tcp_out_fastopen = TFO_USED_DATA;
220 }
221 else
222 {
223 DEBUG(D_transport|D_v) debug_printf("TFO: had to retransmit\n");
224 tcp_out_fastopen = TFO_NOT_USED;
225 }
226 break;
227
228 default: break; /* compiler quietening */
229 }
230 # endif
231 # endif /* Linux & Apple */
232 }
233 #endif
234
235
236 /* Arguments as for smtp_connect(), plus
237 early_data if non-NULL, idenmpotent data to be sent -
238 preferably in the TCP SYN segment
239
240 Returns: connected socket number, or -1 with errno set
241 */
242
243 int
244 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
245 transport_instance * tb, int timeout, const blob * early_data)
246 {
247 smtp_transport_options_block * ob =
248 (smtp_transport_options_block *)tb->options_block;
249 const uschar * dscp = ob->dscp;
250 int dscp_value;
251 int dscp_level;
252 int dscp_option;
253 int sock;
254 int save_errno = 0;
255 const blob * fastopen_blob = NULL;
256
257
258 #ifndef DISABLE_EVENT
259 deliver_host_address = host->address;
260 deliver_host_port = port;
261 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
262 #endif
263
264 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
265
266 /* Set TCP_NODELAY; Exim does its own buffering. */
267
268 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
269 HDEBUG(D_transport|D_acl|D_v)
270 debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
271
272 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
273 bomb out, just log it and continue in default traffic class. */
274
275 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
276 {
277 HDEBUG(D_transport|D_acl|D_v)
278 debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
279 if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
280 HDEBUG(D_transport|D_acl|D_v)
281 debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
282 /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
283 option for both; ignore failures here */
284 if (host_af == AF_INET6 &&
285 dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
286 (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
287 }
288
289 /* Bind to a specific interface if requested. Caller must ensure the interface
290 is the same type (IPv4 or IPv6) as the outgoing address. */
291
292 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
293 {
294 save_errno = errno;
295 HDEBUG(D_transport|D_acl|D_v)
296 debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
297 strerror(errno));
298 }
299
300 /* Connect to the remote host, and add keepalive to the socket before returning
301 it, if requested. If the build supports TFO, request it - and if the caller
302 requested some early-data then include that in the TFO request. If there is
303 early-data but no TFO support, send it after connecting. */
304
305 else
306 {
307 #ifdef TCP_FASTOPEN
308 if (verify_check_given_host(CUSS &ob->hosts_try_fastopen, host) == OK)
309 fastopen_blob = early_data ? early_data : &tcp_fastopen_nodata;
310 #endif
311
312 if (ip_connect(sock, host_af, host->address, port, timeout, fastopen_blob) < 0)
313 save_errno = errno;
314 else if (early_data && !fastopen_blob && early_data->data && early_data->len)
315 {
316 HDEBUG(D_transport|D_acl|D_v)
317 debug_printf("sending %ld nonTFO early-data\n", (long)early_data->len);
318
319 #ifdef TCP_QUICKACK
320 (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
321 #endif
322 if (send(sock, early_data->data, early_data->len, 0) < 0)
323 save_errno = errno;
324 }
325 }
326
327 /* Either bind() or connect() failed */
328
329 if (save_errno != 0)
330 {
331 HDEBUG(D_transport|D_acl|D_v)
332 {
333 debug_printf_indent(" failed: %s", CUstrerror(save_errno));
334 if (save_errno == ETIMEDOUT)
335 debug_printf(" (timeout=%s)", readconf_printtime(timeout));
336 debug_printf("\n");
337 }
338 (void)close(sock);
339 errno = save_errno;
340 return -1;
341 }
342
343 /* Both bind() and connect() succeeded, and any early-data */
344
345 else
346 {
347 union sockaddr_46 interface_sock;
348 EXIM_SOCKLEN_T size = sizeof(interface_sock);
349
350 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" connected\n");
351 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
352 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
353 else
354 {
355 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
356 "getsockname() failed: %s", strerror(errno));
357 close(sock);
358 return -1;
359 }
360
361 if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
362 #ifdef TCP_FASTOPEN
363 tfo_out_check(sock);
364 #endif
365 return sock;
366 }
367 }
368
369
370
371
372
373 void
374 smtp_port_for_connect(host_item * host, int port)
375 {
376 if (host->port != PORT_NONE)
377 {
378 HDEBUG(D_transport|D_acl|D_v)
379 debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
380 host->port);
381 port = host->port;
382 }
383 else host->port = port; /* Set the port actually used */
384 }
385
386
387 /*************************************************
388 * Connect to remote host *
389 *************************************************/
390
391 /* Create a socket, and connect it to a remote host. IPv6 addresses are
392 detected by checking for a colon in the address. AF_INET6 is defined even on
393 non-IPv6 systems, to enable the code to be less messy. However, on such systems
394 host->address will always be an IPv4 address.
395
396 Arguments:
397 sc details for making connection: host, af, interface, transport
398 early_data if non-NULL, data to be sent - preferably in the TCP SYN segment
399
400 Returns: connected socket number, or -1 with errno set
401 */
402
403 int
404 smtp_connect(smtp_connect_args * sc, const blob * early_data)
405 {
406 int port = sc->host->port;
407 smtp_transport_options_block * ob = sc->ob;
408
409 callout_address = string_sprintf("[%s]:%d", sc->host->address, port);
410
411 HDEBUG(D_transport|D_acl|D_v)
412 {
413 uschar * s = US" ";
414 if (sc->interface) s = string_sprintf(" from %s ", sc->interface);
415 #ifdef SUPPORT_SOCKS
416 if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
417 #endif
418 debug_printf_indent("Connecting to %s %s%s... ", sc->host->name, callout_address, s);
419 }
420
421 /* Create and connect the socket */
422
423 #ifdef SUPPORT_SOCKS
424 if (ob->socks_proxy)
425 {
426 int sock = socks_sock_connect(sc->host, sc->host_af, port, sc->interface,
427 sc->tblock, ob->connect_timeout);
428
429 if (sock >= 0)
430 {
431 if (early_data && early_data->data && early_data->len)
432 if (send(sock, early_data->data, early_data->len, 0) < 0)
433 {
434 int save_errno = errno;
435 HDEBUG(D_transport|D_acl|D_v)
436 {
437 debug_printf_indent("failed: %s", CUstrerror(save_errno));
438 if (save_errno == ETIMEDOUT)
439 debug_printf(" (timeout=%s)", readconf_printtime(ob->connect_timeout));
440 debug_printf("\n");
441 }
442 (void)close(sock);
443 sock = -1;
444 errno = save_errno;
445 }
446 }
447 return sock;
448 }
449 #endif
450
451 return smtp_sock_connect(sc->host, sc->host_af, port, sc->interface,
452 sc->tblock, ob->connect_timeout, early_data);
453 }
454
455
456 /*************************************************
457 * Flush outgoing command buffer *
458 *************************************************/
459
460 /* This function is called only from smtp_write_command() below. It flushes
461 the buffer of outgoing commands. There is more than one in the buffer only when
462 pipelining.
463
464 Argument:
465 outblock the SMTP output block
466 mode further data expected, or plain
467
468 Returns: TRUE if OK, FALSE on error, with errno set
469 */
470
471 static BOOL
472 flush_buffer(smtp_outblock * outblock, int mode)
473 {
474 int rc;
475 int n = outblock->ptr - outblock->buffer;
476 BOOL more = mode == SCMD_MORE;
477
478 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
479 more ? " (more expected)" : "");
480
481 #ifndef DISABLE_TLS
482 if (outblock->cctx->tls_ctx)
483 rc = tls_write(outblock->cctx->tls_ctx, outblock->buffer, n, more);
484 else
485 #endif
486
487 {
488 if (outblock->conn_args)
489 {
490 blob early_data = { .data = outblock->buffer, .len = n };
491
492 /* We ignore the more-flag if we're doing a connect with early-data, which
493 means we won't get BDAT+data. A pity, but wise due to the idempotency
494 requirement: TFO with data can, in rare cases, replay the data to the
495 receiver. */
496
497 if ( (outblock->cctx->sock = smtp_connect(outblock->conn_args, &early_data))
498 < 0)
499 return FALSE;
500 outblock->conn_args = NULL;
501 rc = n;
502 }
503 else
504 {
505 rc = send(outblock->cctx->sock, outblock->buffer, n,
506 #ifdef MSG_MORE
507 more ? MSG_MORE : 0
508 #else
509 0
510 #endif
511 );
512 }
513 }
514
515 if (rc <= 0)
516 {
517 HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
518 return FALSE;
519 }
520
521 outblock->ptr = outblock->buffer;
522 outblock->cmd_count = 0;
523 return TRUE;
524 }
525
526
527
528 /*************************************************
529 * Write SMTP command *
530 *************************************************/
531
532 /* The formatted command is left in big_buffer so that it can be reflected in
533 any error message.
534
535 Arguments:
536 sx SMTP connection, contains buffer for pipelining, and socket
537 mode buffer, write-with-more-likely, write
538 format a format, starting with one of
539 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
540 If NULL, flush pipeline buffer only.
541 ... data for the format
542
543 Returns: 0 if command added to pipelining buffer, with nothing transmitted
544 +n if n commands transmitted (may still have buffered the new one)
545 -1 on error, with errno set
546 */
547
548 int
549 smtp_write_command(void * sx, int mode, const char *format, ...)
550 {
551 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
552 int rc = 0;
553
554 if (format)
555 {
556 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
557 va_list ap;
558
559 /* Use taint-unchecked routines for writing into big_buffer, trusting that
560 we'll never expand the results. Actually, the error-message use - leaving
561 the results in big_buffer for potential later use - is uncomfortably distant.
562 XXX Would be better to assume all smtp commands are short, use normal pool
563 alloc rather than big_buffer, and another global for the data-for-error. */
564
565 va_start(ap, format);
566 if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
567 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
568 "SMTP");
569 va_end(ap);
570 string_from_gstring(&gs);
571
572 if (gs.ptr > outblock->buffersize)
573 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
574 "SMTP");
575
576 if (gs.ptr > outblock->buffersize - (outblock->ptr - outblock->buffer))
577 {
578 rc = outblock->cmd_count; /* flush resets */
579 if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
580 }
581
582 Ustrncpy(outblock->ptr, gs.s, gs.ptr);
583 outblock->ptr += gs.ptr;
584 outblock->cmd_count++;
585 gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for error message */
586
587 /* We want to hide the actual data sent in AUTH transactions from reflections
588 and logs. While authenticating, a flag is set in the outblock to enable this.
589 The AUTH command itself gets any data flattened. Other lines are flattened
590 completely. */
591
592 if (outblock->authenticating)
593 {
594 uschar *p = big_buffer;
595 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
596 {
597 p += 5;
598 while (isspace(*p)) p++;
599 while (!isspace(*p)) p++;
600 while (isspace(*p)) p++;
601 }
602 while (*p != 0) *p++ = '*';
603 }
604
605 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" SMTP>> %s\n", big_buffer);
606 }
607
608 if (mode != SCMD_BUFFER)
609 {
610 rc += outblock->cmd_count; /* flush resets */
611 if (!flush_buffer(outblock, mode)) return -1;
612 }
613
614 return rc;
615 }
616
617
618
619 /*************************************************
620 * Read one line of SMTP response *
621 *************************************************/
622
623 /* This function reads one line of SMTP response from the server host. This may
624 not be a complete response - it could be just part of a multiline response. We
625 have to use a buffer for incoming packets, because when pipelining or using
626 LMTP, there may well be more than one response in a single packet. This
627 function is called only from the one that follows.
628
629 Arguments:
630 inblock the SMTP input block (contains holding buffer, socket, etc.)
631 buffer where to put the line
632 size space available for the line
633 timelimit deadline for reading the lime, seconds past epoch
634
635 Returns: length of a line that has been put in the buffer
636 -1 otherwise, with errno set
637 */
638
639 static int
640 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, time_t timelimit)
641 {
642 uschar *p = buffer;
643 uschar *ptr = inblock->ptr;
644 uschar *ptrend = inblock->ptrend;
645 client_conn_ctx * cctx = inblock->cctx;
646
647 /* Loop for reading multiple packets or reading another packet after emptying
648 a previously-read one. */
649
650 for (;;)
651 {
652 int rc;
653
654 /* If there is data in the input buffer left over from last time, copy
655 characters from it until the end of a line, at which point we can return,
656 having removed any whitespace (which will include CR) at the end of the line.
657 The rules for SMTP say that lines end in CRLF, but there are have been cases
658 of hosts using just LF, and other MTAs are reported to handle this, so we
659 just look for LF. If we run out of characters before the end of a line,
660 carry on to read the next incoming packet. */
661
662 while (ptr < ptrend)
663 {
664 int c = *ptr++;
665 if (c == '\n')
666 {
667 while (p > buffer && isspace(p[-1])) p--;
668 *p = 0;
669 inblock->ptr = ptr;
670 return p - buffer;
671 }
672 *p++ = c;
673 if (--size < 4)
674 {
675 *p = 0; /* Leave malformed line for error message */
676 errno = ERRNO_SMTPFORMAT;
677 return -1;
678 }
679 }
680
681 /* Need to read a new input packet. */
682
683 if((rc = ip_recv(cctx, inblock->buffer, inblock->buffersize, timelimit)) <= 0)
684 {
685 DEBUG(D_deliver|D_transport|D_acl|D_v)
686 debug_printf_indent(errno ? " SMTP(%s)<<\n" : " SMTP(closed)<<\n",
687 strerror(errno));
688 break;
689 }
690
691 /* Another block of data has been successfully read. Set up the pointers
692 and let the loop continue. */
693
694 ptrend = inblock->ptrend = inblock->buffer + rc;
695 ptr = inblock->buffer;
696 DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
697 }
698
699 /* Get here if there has been some kind of recv() error; errno is set, but we
700 ensure that the result buffer is empty before returning. */
701
702 *buffer = 0;
703 return -1;
704 }
705
706
707
708
709
710 /*************************************************
711 * Read SMTP response *
712 *************************************************/
713
714 /* This function reads an SMTP response with a timeout, and returns the
715 response in the given buffer, as a string. A multiline response will contain
716 newline characters between the lines. The function also analyzes the first
717 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
718 also returned after a reading error. In this case buffer[0] will be zero, and
719 the error code will be in errno.
720
721 Arguments:
722 sx the SMTP connection (contains input block with holding buffer,
723 socket, etc.)
724 buffer where to put the response
725 size the size of the buffer
726 okdigit the expected first digit of the response
727 timeout the timeout to use, in seconds
728
729 Returns: TRUE if a valid, non-error response was received; else FALSE
730 */
731 /*XXX could move to smtp transport; no other users */
732
733 BOOL
734 smtp_read_response(void * sx0, uschar * buffer, int size, int okdigit,
735 int timeout)
736 {
737 smtp_context * sx = sx0;
738 uschar * ptr = buffer;
739 int count = 0;
740 time_t timelimit = time(NULL) + timeout;
741
742 errno = 0; /* Ensure errno starts out zero */
743
744 #ifndef DISABLE_PIPE_CONNECT
745 if (sx->pending_BANNER || sx->pending_EHLO)
746 {
747 int rc;
748 if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
749 {
750 DEBUG(D_transport) debug_printf("failed reaping pipelined cmd responsess\n");
751 buffer[0] = '\0';
752 if (rc == DEFER) errno = ERRNO_TLSFAILURE;
753 return FALSE;
754 }
755 }
756 #endif
757
758 /* This is a loop to read and concatenate the lines that make up a multi-line
759 response. */
760
761 for (;;)
762 {
763 if ((count = read_response_line(&sx->inblock, ptr, size, timelimit)) < 0)
764 return FALSE;
765
766 HDEBUG(D_transport|D_acl|D_v)
767 debug_printf_indent(" %s %s\n", ptr == buffer ? "SMTP<<" : " ", ptr);
768
769 /* Check the format of the response: it must start with three digits; if
770 these are followed by a space or end of line, the response is complete. If
771 they are followed by '-' this is a multi-line response and we must look for
772 another line until the final line is reached. The only use made of multi-line
773 responses is to pass them back as error messages. We therefore just
774 concatenate them all within the buffer, which should be large enough to
775 accept any reasonable number of lines. */
776
777 if (count < 3 ||
778 !isdigit(ptr[0]) ||
779 !isdigit(ptr[1]) ||
780 !isdigit(ptr[2]) ||
781 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
782 {
783 errno = ERRNO_SMTPFORMAT; /* format error */
784 return FALSE;
785 }
786
787 /* If the line we have just read is a terminal line, line, we are done.
788 Otherwise more data has to be read. */
789
790 if (ptr[3] != '-') break;
791
792 /* Move the reading pointer upwards in the buffer and insert \n between the
793 components of a multiline response. Space is left for this by read_response_
794 line(). */
795
796 ptr += count;
797 *ptr++ = '\n';
798 size -= count + 1;
799 }
800
801 #ifdef TCP_FASTOPEN
802 tfo_out_check(sx->cctx.sock);
803 #endif
804
805 /* Return a value that depends on the SMTP return code. On some systems a
806 non-zero value of errno has been seen at this point, so ensure it is zero,
807 because the caller of this function looks at errno when FALSE is returned, to
808 distinguish between an unexpected return code and other errors such as
809 timeouts, lost connections, etc. */
810
811 errno = 0;
812 return buffer[0] == okdigit;
813 }
814
815 /* End of smtp_out.c */
816 /* vi: aw ai sw=2
817 */