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