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