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