a78b15fbd1f719ba81efe2a5a89ddb215de27484
[exim.git] / src / src / smtp_out.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
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   if (verify_check_given_host(CUSS &ob->hosts_try_fastopen, sc->host) == OK)
369     {
370     if (!early_data)
371       fastopen_blob = &tcp_fastopen_nodata;     /* TFO, with no data */
372     else if (early_data->data)
373       fastopen_blob = early_data;               /* TFO, with data */
374 # ifdef TCP_FASTOPEN_CONNECT
375     else
376       {                                         /* expecting client data */
377       DEBUG(D_transport|D_acl|D_v) debug_printf(" set up lazy-connect\n");
378       setsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN_CONNECT, US &on, sizeof(on));
379       /* fastopen_blob = NULL;           lazy TFO, triggered by data write */
380       }
381 # endif
382     }
383 #endif
384
385   if (ip_connect(sock, sc->host_af, sc->host->address, sc->host->port, timeout, fastopen_blob) < 0)
386     save_errno = errno;
387   else if (early_data && !fastopen_blob && early_data->data && early_data->len)
388     {
389     /* We had some early-data to send, but couldn't do TFO */
390     HDEBUG(D_transport|D_acl|D_v)
391       debug_printf("sending %ld nonTFO early-data\n", (long)early_data->len);
392
393 #ifdef TCP_QUICKACK_notdef
394     (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
395 #endif
396     if (send(sock, early_data->data, early_data->len, 0) < 0)
397       save_errno = errno;
398     }
399 #ifdef TCP_QUICKACK_notdef
400   /* Under TFO (with openssl & pipe-conn; testcase 4069, as of
401   5.10.8-100.fc32.x86_64) this seems to be inop.
402   Perhaps overwritten when we (client) go -> ESTABLISHED on seeing the 3rd-ACK?
403   For that case, added at smtp_reap_banner(). */
404   (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
405 #endif
406   }
407
408 if (!save_errno)
409   {
410   union sockaddr_46 interface_sock;
411   EXIM_SOCKLEN_T size = sizeof(interface_sock);
412
413   /* Both bind() and connect() succeeded, and any early-data */
414
415   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" connected\n");
416   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
417     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
418   else
419     {
420     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
421       "getsockname() failed: %s", strerror(errno));
422     close(sock);
423     return -1;
424     }
425
426   if (ob->keepalive) ip_keepalive(sock, sc->host->address, TRUE);
427 #ifdef TCP_FASTOPEN
428   tfo_out_check(sock);
429 #endif
430   return sock;
431   }
432
433 /* Either bind() or connect() failed */
434
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(timeout));
440   debug_printf("\n");
441   }
442 (void)close(sock);
443 errno = save_errno;
444 return -1;
445 }
446
447
448
449
450
451 void
452 smtp_port_for_connect(host_item * host, int port)
453 {
454 if (host->port != PORT_NONE)
455   {
456   HDEBUG(D_transport|D_acl|D_v) if (port != host->port)
457     debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
458       host->port);
459   port = host->port;
460   }
461 else host->port = port;    /* Set the port actually used */
462 }
463
464
465 /*************************************************
466 *           Connect to remote host               *
467 *************************************************/
468
469 /* Create a socket, and connect it to a remote host. IPv6 addresses are
470 detected by checking for a colon in the address. AF_INET6 is defined even on
471 non-IPv6 systems, to enable the code to be less messy. However, on such systems
472 host->address will always be an IPv4 address.
473
474 Arguments:
475   sc          details for making connection: host, af, interface, transport
476   early_data  if non-NULL, data to be sent - preferably in the TCP SYN segment
477               Special case: non-NULL but with NULL blob.data - caller is
478               client-data-first (eg. TLS-on-connect) and a lazy-TCP-connect is
479               acceptable.
480
481 Returns:      connected socket number, or -1 with errno set
482 */
483
484 int
485 smtp_connect(smtp_connect_args * sc, const blob * early_data)
486 {
487 int port = sc->host->port;
488 smtp_transport_options_block * ob = sc->ob;
489
490 callout_address = string_sprintf("[%s]:%d", sc->host->address, port);
491
492 HDEBUG(D_transport|D_acl|D_v)
493   {
494   uschar * s = US" ";
495   if (sc->interface) s = string_sprintf(" from %s ", sc->interface);
496 #ifdef SUPPORT_SOCKS
497   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
498 #endif
499   debug_printf_indent("Connecting to %s %s%s... ", sc->host->name, callout_address, s);
500   }
501
502 /* Create and connect the socket */
503
504 #ifdef SUPPORT_SOCKS
505 if (ob->socks_proxy)
506   {
507   int sock = socks_sock_connect(sc->host, sc->host_af, port, sc->interface,
508                                 sc->tblock, ob->connect_timeout);
509   
510   if (sock >= 0)
511     {
512     if (early_data && early_data->data && early_data->len)
513       if (send(sock, early_data->data, early_data->len, 0) < 0)
514         {
515         int save_errno = errno;
516         HDEBUG(D_transport|D_acl|D_v)
517           {
518           debug_printf_indent("failed: %s", CUstrerror(save_errno));
519           if (save_errno == ETIMEDOUT)
520             debug_printf(" (timeout=%s)", readconf_printtime(ob->connect_timeout));
521           debug_printf("\n");
522           }
523         (void)close(sock);
524         sock = -1;
525         errno = save_errno;
526         }
527     }
528   return sock;
529   }
530 #endif
531
532 return smtp_sock_connect(sc, ob->connect_timeout, early_data);
533 }
534
535
536 /*************************************************
537 *        Flush outgoing command buffer           *
538 *************************************************/
539
540 /* This function is called only from smtp_write_command() below. It flushes
541 the buffer of outgoing commands. There is more than one in the buffer only when
542 pipelining.
543
544 Argument:
545   outblock   the SMTP output block
546   mode       further data expected, or plain
547
548 Returns:     TRUE if OK, FALSE on error, with errno set
549 */
550
551 static BOOL
552 flush_buffer(smtp_outblock * outblock, int mode)
553 {
554 int rc;
555 int n = outblock->ptr - outblock->buffer;
556 BOOL more = mode == SCMD_MORE;
557 client_conn_ctx * cctx;
558
559 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
560   more ? " (more expected)" : "");
561
562 if (!(cctx = outblock->cctx))
563   {
564   log_write(0, LOG_MAIN|LOG_PANIC, "null conn-context pointer");
565   errno = 0;
566   return FALSE;
567   }
568
569 #ifndef DISABLE_TLS
570 if (cctx->tls_ctx)              /*XXX have seen a null cctx here, rvfy sending QUIT, hence check above */
571   rc = tls_write(cctx->tls_ctx, outblock->buffer, n, more);
572 else
573 #endif
574
575   {
576   if (outblock->conn_args)
577     {
578     blob early_data = { .data = outblock->buffer, .len = n };
579
580     /* We ignore the more-flag if we're doing a connect with early-data, which
581     means we won't get BDAT+data. A pity, but wise due to the idempotency
582     requirement: TFO with data can, in rare cases, replay the data to the
583     receiver. */
584
585     if (  (cctx->sock = smtp_connect(outblock->conn_args, &early_data))
586        < 0)
587       return FALSE;
588     outblock->conn_args = NULL;
589     rc = n;
590     }
591   else
592     {
593     rc = send(cctx->sock, outblock->buffer, n,
594 #ifdef MSG_MORE
595               more ? MSG_MORE : 0
596 #else
597               0
598 #endif
599              );
600
601 #if defined(__linux__)
602     /* This is a workaround for a current linux kernel bug: as of
603     5.6.8-200.fc31.x86_64  small (<MSS) writes get delayed by about 200ms,
604     This is despite NODELAY being active.
605     https://bugzilla.redhat.com/show_bug.cgi?id=1803806 */
606
607     if (!more)
608       setsockopt(cctx->sock, IPPROTO_TCP, TCP_CORK, &off, sizeof(off));
609 #endif
610     }
611   }
612
613 if (rc <= 0)
614   {
615   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
616   return FALSE;
617   }
618
619 outblock->ptr = outblock->buffer;
620 outblock->cmd_count = 0;
621 return TRUE;
622 }
623
624
625
626 /* This might be called both due to callout and then from delivery.
627 Use memory that will not be released between those phases.
628 */
629 static void
630 smtp_debug_resp(const uschar * buf)
631 {
632 #ifndef DISABLE_CLIENT_CMD_LOG
633 int old_pool = store_pool;
634 store_pool = POOL_PERM;
635 client_cmd_log = string_append_listele_n(client_cmd_log, ':', buf,
636   buf[3] == ' ' ? 3 : 4);
637 store_pool = old_pool;
638 #endif
639 }
640
641
642 /*************************************************
643 *             Write SMTP command                 *
644 *************************************************/
645
646 /* The formatted command is left in big_buffer so that it can be reflected in
647 any error message.
648
649 Arguments:
650   sx         SMTP connection, contains buffer for pipelining, and socket
651   mode       buffer, write-with-more-likely, write
652   format     a format, starting with one of
653              of HELO, MAIL FROM, RCPT TO, DATA, BDAT, ".", or QUIT.
654              If NULL, flush pipeline buffer only.
655   ...        data for the format
656
657 Returns:     0 if command added to pipelining buffer, with nothing transmitted
658             +n if n commands transmitted (may still have buffered the new one)
659             -1 on error, with errno set
660 */
661
662 int
663 smtp_write_command(void * sx, int mode, const char * format, ...)
664 {
665 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
666 int rc = 0;
667
668 if (format)
669   {
670   gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
671   va_list ap;
672
673   /* Use taint-unchecked routines for writing into big_buffer, trusting that
674   we'll never expand the results.  Actually, the error-message use - leaving
675   the results in big_buffer for potential later use - is uncomfortably distant.
676   XXX Would be better to assume all smtp commands are short, use normal pool
677   alloc rather than big_buffer, and another global for the data-for-error. */
678
679   va_start(ap, format);
680   if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
681     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
682       "SMTP");
683   va_end(ap);
684
685   if (gs.ptr > outblock->buffersize)
686     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
687       "SMTP");
688
689   if (gs.ptr > outblock->buffersize - (outblock->ptr - outblock->buffer))
690     {
691     rc = outblock->cmd_count;                 /* flush resets */
692     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
693     }
694
695   Ustrncpy(outblock->ptr, gs.s, gs.ptr);
696   outblock->ptr += gs.ptr;
697   outblock->cmd_count++;
698   gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for error message */
699
700   /* We want to hide the actual data sent in AUTH transactions from reflections
701   and logs. While authenticating, a flag is set in the outblock to enable this.
702   The AUTH command itself gets any data flattened. Other lines are flattened
703   completely. */
704
705   if (outblock->authenticating)
706     {
707     uschar * p = big_buffer;
708     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
709       {
710       p += 5;
711       Uskip_whitespace(&p);
712       Uskip_nonwhite(&p);
713       Uskip_whitespace(&p);
714       }
715     while (*p) *p++ = '*';
716     }
717
718   smtp_debug_cmd(big_buffer, mode);
719   }
720
721 if (mode != SCMD_BUFFER)
722   {
723   rc += outblock->cmd_count;                /* flush resets */
724   if (!flush_buffer(outblock, mode)) return -1;
725   }
726
727 return rc;
728 }
729
730
731
732 /*************************************************
733 *          Read one line of SMTP response        *
734 *************************************************/
735
736 /* This function reads one line of SMTP response from the server host. This may
737 not be a complete response - it could be just part of a multiline response. We
738 have to use a buffer for incoming packets, because when pipelining or using
739 LMTP, there may well be more than one response in a single packet. This
740 function is called only from the one that follows.
741
742 Arguments:
743   inblock   the SMTP input block (contains holding buffer, socket, etc.)
744   buffer    where to put the line
745   size      space available for the line
746   timelimit deadline for reading the lime, seconds past epoch
747
748 Returns:    length of a line that has been put in the buffer
749             -1 otherwise, with errno set, and inblock->ptr adjusted
750 */
751
752 static int
753 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, time_t timelimit)
754 {
755 uschar *p = buffer;
756 uschar *ptr = inblock->ptr;
757 uschar *ptrend = inblock->ptrend;
758 client_conn_ctx * cctx = inblock->cctx;
759
760 /* Loop for reading multiple packets or reading another packet after emptying
761 a previously-read one. */
762
763 for (;;)
764   {
765   int rc;
766
767   /* If there is data in the input buffer left over from last time, copy
768   characters from it until the end of a line, at which point we can return,
769   having removed any whitespace (which will include CR) at the end of the line.
770   The rules for SMTP say that lines end in CRLF, but there are have been cases
771   of hosts using just LF, and other MTAs are reported to handle this, so we
772   just look for LF. If we run out of characters before the end of a line,
773   carry on to read the next incoming packet. */
774
775   while (ptr < ptrend)
776     {
777     int c = *ptr++;
778     if (c == '\n')
779       {
780       while (p > buffer && isspace(p[-1])) p--;
781       *p = 0;
782       inblock->ptr = ptr;
783       return p - buffer;
784       }
785     *p++ = c;
786     if (--size < 4)
787       {
788       *p = 0;                     /* Leave malformed line for error message */
789       errno = ERRNO_SMTPFORMAT;
790       inblock->ptr = ptr;
791       return -1;
792       }
793     }
794
795   /* Need to read a new input packet. */
796
797   if((rc = ip_recv(cctx, inblock->buffer, inblock->buffersize, timelimit)) <= 0)
798     {
799     DEBUG(D_deliver|D_transport|D_acl|D_v)
800       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
801         strerror(errno));
802     break;
803     }
804
805   /* Another block of data has been successfully read. Set up the pointers
806   and let the loop continue. */
807
808   ptrend = inblock->ptrend = inblock->buffer + rc;
809   ptr = inblock->buffer;
810   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
811   }
812
813 /* Get here if there has been some kind of recv() error; errno is set, but we
814 ensure that the result buffer is empty before returning. */
815
816 inblock->ptr = inblock->ptrend = inblock->buffer;
817 *buffer = 0;
818 return -1;
819 }
820
821
822
823
824
825 /*************************************************
826 *              Read SMTP response                *
827 *************************************************/
828
829 /* This function reads an SMTP response with a timeout, and returns the
830 response in the given buffer, as a string. A multiline response will contain
831 newline characters between the lines. The function also analyzes the first
832 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
833 also returned after a reading error. In this case buffer[0] will be zero, and
834 the error code will be in errno.
835
836 Arguments:
837   sx        the SMTP connection (contains input block with holding buffer,
838                 socket, etc.)
839   buffer    where to put the response
840   size      the size of the buffer
841   okdigit   the expected first digit of the response
842   timeout   the timeout to use, in seconds
843
844 Returns:    TRUE if a valid, non-error response was received; else FALSE
845 */
846 /*XXX could move to smtp transport; no other users */
847
848 BOOL
849 smtp_read_response(void * sx0, uschar * buffer, int size, int okdigit,
850    int timeout)
851 {
852 smtp_context * sx = sx0;
853 uschar * ptr = buffer;
854 int count = 0;
855 time_t timelimit = time(NULL) + timeout;
856 BOOL yield = FALSE;
857
858 errno = 0;  /* Ensure errno starts out zero */
859 buffer[0] = '\0';
860
861 #ifndef DISABLE_PIPE_CONNECT
862 if (sx->pending_BANNER || sx->pending_EHLO)
863   {
864   int rc;
865   if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
866     {
867     DEBUG(D_transport) debug_printf("failed reaping pipelined cmd responsess\n");
868     if (rc == DEFER) errno = ERRNO_TLSFAILURE;
869     goto out;
870     }
871   }
872 #endif
873
874 /* This is a loop to read and concatenate the lines that make up a multi-line
875 response. */
876
877 for (;;)
878   {
879   if ((count = read_response_line(&sx->inblock, ptr, size, timelimit)) < 0)
880     return FALSE;
881
882   HDEBUG(D_transport|D_acl|D_v)
883     debug_printf_indent("  %s %s\n", ptr == buffer ? "SMTP<<" : "      ", ptr);
884
885   /* Check the format of the response: it must start with three digits; if
886   these are followed by a space or end of line, the response is complete. If
887   they are followed by '-' this is a multi-line response and we must look for
888   another line until the final line is reached. The only use made of multi-line
889   responses is to pass them back as error messages. We therefore just
890   concatenate them all within the buffer, which should be large enough to
891   accept any reasonable number of lines. */
892
893   if (count < 3 ||
894      !isdigit(ptr[0]) ||
895      !isdigit(ptr[1]) ||
896      !isdigit(ptr[2]) ||
897      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
898     {
899     errno = ERRNO_SMTPFORMAT;    /* format error */
900     goto out;
901     }
902
903   /* If the line we have just read is a terminal line, line, we are done.
904   Otherwise more data has to be read. */
905
906   if (ptr[3] != '-') break;
907
908   /* Move the reading pointer upwards in the buffer and insert \n between the
909   components of a multiline response. Space is left for this by read_response_
910   line(). */
911
912   ptr += count;
913   *ptr++ = '\n';
914   size -= count + 1;
915   }
916
917 #ifdef TCP_FASTOPEN
918 tfo_out_check(sx->cctx.sock);
919 #endif
920
921 /* Return a value that depends on the SMTP return code. On some systems a
922 non-zero value of errno has been seen at this point, so ensure it is zero,
923 because the caller of this function looks at errno when FALSE is returned, to
924 distinguish between an unexpected return code and other errors such as
925 timeouts, lost connections, etc. */
926
927 errno = 0;
928 yield = buffer[0] == okdigit;
929
930 out:
931   smtp_debug_resp(buffer);
932   return yield;
933 }
934
935 /* End of smtp_out.c */
936 /* vi: aw ai sw=2
937 */