TFO: even in binary built for modern Linux, handle error returned by old Linux kernel...

[exim.git] / src / src / ip.c

diff --git a/src/src/ip.c b/src/src/ip.c
index 555dc2d84bee5bdb6c0109e94f4fdb146b6a82e8..4c543566dd55b0547548d1c732dd2af03eb87cbc 100644 (file)
--- a/src/src/ip.c
+++ b/src/src/ip.c
@@ -14,6 +14,12 @@ different places in the code where sockets are used. */
 #include "exim.h"
 
 
 #include "exim.h"
 
 

+#if defined(TCP_FASTOPEN)
+# if defined(MSG_FASTOPEN) || defined(EXIM_TFO_CONNECTX) || defined(EXIM_TFO_FREEBSD)
+#  define EXIM_SUPPORT_TFO
+# endif
+#endif
+

 /*************************************************
 *             Create a socket                    *
 *************************************************/
 /*************************************************
 *             Create a socket                    *
 *************************************************/


@@ -160,26 +166,6 @@ return bind(sock, (struct sockaddr *)&sin, s_len);
 
 
 
 
 
 

-/*************************************************
-*************************************************/
-
-#ifdef EXIM_TFO_PROBE
-void
-tfo_probe(void)
-{
-# ifdef TCP_FASTOPEN
-int sock, backlog = 5;
-
-if (  (sock = socket(SOCK_STREAM, AF_INET, 0)) < 0
-   && setsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN, &backlog, sizeof(backlog))
-   )
-  tcp_fastopen_ok = TRUE;
-close(sock);
-# endif
-}
-#endif
-
-

 /*************************************************
 *        Connect socket to remote host           *
 *************************************************/
 /*************************************************
 *        Connect socket to remote host           *
 *************************************************/


@@ -196,7 +182,7 @@ Arguments:
   port        the remote port
   timeout     a timeout (zero for indefinite timeout)
   fastopen_blob    non-null iff TCP_FASTOPEN can be used; may indicate early-data to
   port        the remote port
   timeout     a timeout (zero for indefinite timeout)
   fastopen_blob    non-null iff TCP_FASTOPEN can be used; may indicate early-data to

-               be sent in SYN segment
+               be sent in SYN segment.  Any such data must be idempotent.

 
 Returns:      0 on success; -1 on failure, with errno set
 */
 
 Returns:      0 on success; -1 on failure, with errno set
 */


@@ -243,57 +229,123 @@ timer, thereby allowing the inbuilt OS timeout to operate. */
 
 callout_address = string_sprintf("[%s]:%d", address, port);
 sigalrm_seen = FALSE;
 
 callout_address = string_sprintf("[%s]:%d", address, port);
 sigalrm_seen = FALSE;

-if (timeout > 0) alarm(timeout);
+if (timeout > 0) ALARM(timeout);

 
 

-#if defined(TCP_FASTOPEN) && defined(MSG_FASTOPEN)
+#ifdef EXIM_SUPPORT_TFO

 /* TCP Fast Open, if the system has a cookie from a previous call to
 this peer, can send data in the SYN packet.  The peer can send data
 before it gets our ACK of its SYN,ACK - the latter is useful for
 the SMTP banner.  Other (than SMTP) cases of TCP connections can
 /* TCP Fast Open, if the system has a cookie from a previous call to
 this peer, can send data in the SYN packet.  The peer can send data
 before it gets our ACK of its SYN,ACK - the latter is useful for
 the SMTP banner.  Other (than SMTP) cases of TCP connections can

-possibly use the data-on-syn, so support that too.  */
+possibly use the data-on-syn, so support that too. */

 
 

-if (fastopen_blob && tcp_fastopen_ok)
+if (fastopen_blob && f.tcp_fastopen_ok)

   {
   {

+# ifdef MSG_FASTOPEN
+  /* This is a Linux implementation. */
+

   if ((rc = sendto(sock, fastopen_blob->data, fastopen_blob->len,
                    MSG_FASTOPEN | MSG_DONTWAIT, s_ptr, s_len)) >= 0)
        /* seen for with-data, experimental TFO option, with-cookie case */
        /* seen for with-data, proper TFO opt, with-cookie case */
     {
     DEBUG(D_transport|D_v)
   if ((rc = sendto(sock, fastopen_blob->data, fastopen_blob->len,
                    MSG_FASTOPEN | MSG_DONTWAIT, s_ptr, s_len)) >= 0)
        /* seen for with-data, experimental TFO option, with-cookie case */
        /* seen for with-data, proper TFO opt, with-cookie case */
     {
     DEBUG(D_transport|D_v)

-      debug_printf("non-TFO mode connection attempt to %s, %lu data\n",
+      debug_printf(" TFO mode connection attempt to %s, %lu data\n",

        address, (unsigned long)fastopen_blob->len);
        address, (unsigned long)fastopen_blob->len);

-    tcp_out_fastopen = fastopen_blob->len > 0 ?  2 : 1;
+    /*XXX also seen on successful TFO, sigh */
+    tcp_out_fastopen = fastopen_blob->len > 0 ?  TFO_ATTEMPTED_DATA : TFO_ATTEMPTED_NODATA;

     }
     }

-  else if (errno == EINPROGRESS)       /* expected if we had no cookie for peer */
+  else switch (errno)
+    {
+    case EINPROGRESS:  /* expected if we had no cookie for peer */

        /* seen for no-data, proper TFO option, both cookie-request and with-cookie cases */
        /*  apparently no visibility of the diffference at this point */
        /* seen for with-data, proper TFO opt, cookie-req */
        /*   with netwk delay, post-conn tcp_info sees unacked 1 for R, 2 for C; code in smtp_out.c */
        /* ? older Experimental TFO option behaviour ? */
        /* seen for no-data, proper TFO option, both cookie-request and with-cookie cases */
        /*  apparently no visibility of the diffference at this point */
        /* seen for with-data, proper TFO opt, cookie-req */
        /*   with netwk delay, post-conn tcp_info sees unacked 1 for R, 2 for C; code in smtp_out.c */
        /* ? older Experimental TFO option behaviour ? */

-    {                                  /* queue unsent data */
-    DEBUG(D_transport|D_v) debug_printf("TFO mode sendto, %s data: EINPROGRESS\n",
+      DEBUG(D_transport|D_v) debug_printf(" TFO mode sendto, %s data: EINPROGRESS\n",
+       fastopen_blob->len > 0 ? "with"  : "no");
+      if (!fastopen_blob->data)
+       {
+       tcp_out_fastopen = TFO_ATTEMPTED_NODATA;                /* we tried; unknown if useful yet */
+       rc = 0;
+       }
+      else                                     /* queue unsent data */
+       rc = send(sock, fastopen_blob->data, fastopen_blob->len, 0);
+      break;
+
+    case EOPNOTSUPP:
+      DEBUG(D_transport)
+       debug_printf("Tried TCP Fast Open but apparently not enabled by sysctl\n");
+      goto legacy_connect;
+
+    case EPIPE:
+      DEBUG(D_transport)
+       debug_printf("Tried TCP Fast Open but kernel too old to support it\n");
+      goto legacy_connect;
+    }
+
+# elif defined(EXIM_TFO_FREEBSD)
+  /* Re: https://people.freebsd.org/~pkelsey/tfo-tools/tfo-client.c */
+
+  if (setsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN, &on, sizeof(on)) < 0)
+    {
+    DEBUG(D_transport)
+      debug_printf("Tried TCP Fast Open but apparently not enabled by sysctl\n");
+    goto legacy_connect;
+    }
+  if ((rc = sendto(sock, fastopen_blob->data, fastopen_blob->len, 0,
+                   s_ptr, s_len)) >= 0)
+    {
+    DEBUG(D_transport|D_v)
+      debug_printf(" TFO mode connection attempt to %s, %lu data\n",
+       address, (unsigned long)fastopen_blob->len);
+    tcp_out_fastopen = fastopen_blob->len > 0 ?  TFO_ATTEMPTED_DATA : TFO_ATTEMPTED_NODATA;
+    }
+
+# elif defined(EXIM_TFO_CONNECTX)
+  /* MacOS */
+  sa_endpoints_t ends = {
+    .sae_srcif = 0, .sae_srcaddr = NULL, .sae_srcaddrlen = 0,
+    .sae_dstaddr = s_ptr, .sae_dstaddrlen = s_len };
+  struct iovec iov = {
+    .iov_base = fastopen_blob->data, .iov_len = fastopen_blob->len };
+  size_t len;
+
+  if ((rc = connectx(sock, &ends, SAE_ASSOCID_ANY,
+            CONNECT_DATA_IDEMPOTENT, &iov, 1, &len, NULL)) == 0)
+    {
+    DEBUG(D_transport|D_v)
+      debug_printf(" TFO mode connection attempt to %s, %lu data\n",
+       address, (unsigned long)fastopen_blob->len);
+    tcp_out_fastopen = fastopen_blob->len > 0 ?  TFO_ATTEMPTED_DATA : TFO_ATTEMPTED_NODATA;
+
+    if (len != fastopen_blob->len)
+      DEBUG(D_transport|D_v)
+       debug_printf(" only queued %lu data!\n", (unsigned long)len);
+    }
+  else if (errno == EINPROGRESS)
+    {
+    DEBUG(D_transport|D_v) debug_printf(" TFO mode connectx, %s data: EINPROGRESS\n",

       fastopen_blob->len > 0 ? "with"  : "no");
     if (!fastopen_blob->data)
       {
       fastopen_blob->len > 0 ? "with"  : "no");
     if (!fastopen_blob->data)
       {

-      tcp_out_fastopen = 1;            /* we tried; unknown if useful yet */
+      tcp_out_fastopen = TFO_ATTEMPTED_NODATA;         /* we tried; unknown if useful yet */

       rc = 0;
       }
       rc = 0;
       }

-    else
+    else       /* assume that no data was queued; block in send */

       rc = send(sock, fastopen_blob->data, fastopen_blob->len, 0);
     }
       rc = send(sock, fastopen_blob->data, fastopen_blob->len, 0);
     }

-  else if(errno == EOPNOTSUPP)
-    {
-    DEBUG(D_transport)
-      debug_printf("Tried TCP Fast Open but apparently not enabled by sysctl\n");
-    goto legacy_connect;
-    }
+# endif

   }
 else
   }
 else

-#endif
+#endif /*EXIM_SUPPORT_TFO*/

   {
   {

+#if defined(EXIM_SUPPORT_TFO) && !defined(EXIM_TFO_CONNECTX)

 legacy_connect:
 legacy_connect:

+#endif
+

   DEBUG(D_transport|D_v) if (fastopen_blob)
   DEBUG(D_transport|D_v) if (fastopen_blob)

-    debug_printf("non-TFO mode connection attempt to %s, %lu data\n",
+    debug_printf(" non-TFO mode connection attempt to %s, %lu data\n",

       address, (unsigned long)fastopen_blob->len);
   if ((rc = connect(sock, s_ptr, s_len)) >= 0)
     if (  fastopen_blob && fastopen_blob->data && fastopen_blob->len
       address, (unsigned long)fastopen_blob->len);
   if ((rc = connect(sock, s_ptr, s_len)) >= 0)
     if (  fastopen_blob && fastopen_blob->data && fastopen_blob->len


@@ -302,13 +354,13 @@ legacy_connect:
   }
 
 save_errno = errno;
   }
 
 save_errno = errno;

-alarm(0);
+ALARM_CLR(0);

 
 /* There is a testing facility for simulating a connection timeout, as I
 can't think of any other way of doing this. It converts a connection refused
 into a timeout if the timeout is set to 999999. */
 
 
 /* There is a testing facility for simulating a connection timeout, as I
 can't think of any other way of doing this. It converts a connection refused
 into a timeout if the timeout is set to 999999. */
 

-if (running_in_test_harness  && save_errno == ECONNREFUSED && timeout == 999999)
+if (f.running_in_test_harness  && save_errno == ECONNREFUSED && timeout == 999999)

   {
   rc = -1;
   save_errno = EINTR;
   {
   rc = -1;
   save_errno = EINTR;


@@ -339,13 +391,13 @@ return -1;
 Arguments:
   type          SOCK_DGRAM or SOCK_STREAM
   af            AF_INET6 or AF_INET for the socket type
 Arguments:
   type          SOCK_DGRAM or SOCK_STREAM
   af            AF_INET6 or AF_INET for the socket type

-  address       the remote address, in text form
+  hostname     host name, or ip address (as text)

   portlo,porthi the remote port range
   timeout       a timeout
   connhost     if not NULL, host_item to be filled in with connection details
   errstr        pointer for allocated string on error
   fastopen_blob        with SOCK_STREAM, if non-null, request TCP Fast Open.
   portlo,porthi the remote port range
   timeout       a timeout
   connhost     if not NULL, host_item to be filled in with connection details
   errstr        pointer for allocated string on error
   fastopen_blob        with SOCK_STREAM, if non-null, request TCP Fast Open.

-               Additionally, optional early-data to send
+               Additionally, optional idempotent early-data to send

 
 Return:
   socket fd, or -1 on failure (having allocated an error string)
 
 Return:
   socket fd, or -1 on failure (having allocated an error string)


@@ -354,9 +406,8 @@ int
 ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
       int timeout, host_item * connhost, uschar ** errstr, const blob * fastopen_blob)
 {
 ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
       int timeout, host_item * connhost, uschar ** errstr, const blob * fastopen_blob)
 {

-int namelen, port;
+int namelen;

 host_item shost;
 host_item shost;

-host_item *h;

 int af = 0, fd, fd4 = -1, fd6 = -1;
 
 shost.next = NULL;
 int af = 0, fd, fd4 = -1, fd6 = -1;
 
 shost.next = NULL;


@@ -400,7 +451,7 @@ else
 
 /* Try to connect to the server - test each IP till one works */
 
 
 /* Try to connect to the server - test each IP till one works */
 

-for (h = &shost; h; h = h->next)
+for (host_item * h = &shost; h; h = h->next)

   {
   fd = Ustrchr(h->address, ':') != 0
     ? fd6 < 0 ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6
   {
   fd = Ustrchr(h->address, ':') != 0
     ? fd6 < 0 ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6


@@ -412,7 +463,7 @@ for (h = &shost; h; h = h->next)
     goto bad;
     }
 
     goto bad;
     }
 

-  for(port = portlo; port <= porthi; port++)
+  for (int port = portlo; port <= porthi; port++)

     if (ip_connect(fd, af, h->address, port, timeout, fastopen_blob) == 0)
       {
       if (fd != fd6) close(fd6);
     if (ip_connect(fd, af, h->address, port, timeout, fastopen_blob) == 0)
       {
       if (fd != fd6) close(fd6);


@@ -437,7 +488,8 @@ bad:
 
 /*XXX TFO? */
 int
 
 /*XXX TFO? */
 int

-ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
+ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo,
+  host_item * connhost)

 {
 int scan;
 uschar hostname[256];
 {
 int scan;
 uschar hostname[256];


@@ -456,7 +508,7 @@ if (scan != 3)
   }
 
 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
   }
 
 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,

-                         tmo, NULL, errstr, NULL);
+                         tmo, connhost, errstr, NULL);

 }
 
 int
 }
 
 int


@@ -473,7 +525,7 @@ if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
 
 callout_address = string_copy(path);
 server.sun_family = AF_UNIX;
 
 callout_address = string_copy(path);
 server.sun_family = AF_UNIX;

-Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
+Ustrncpy(US server.sun_path, path, sizeof(server.sun_path)-1);

 server.sun_path[sizeof(server.sun_path)-1] = '\0';
 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
   {
 server.sun_path[sizeof(server.sun_path)-1] = '\0';
 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
   {


@@ -486,11 +538,18 @@ if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
 return sock;
 }
 
 return sock;
 }
 

+/* spec is either an absolute path (with a leading /), or
+a host (name or IP) and port (whitespace-separated).
+The port can be a range, dash-separated, or a single number.
+
+For a TCP socket, optionally fill in a  host_item.
+*/

 int
 int

-ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
+ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo,
+  host_item * connhost)

 {
 return *spec == '/'
 {
 return *spec == '/'

-  ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
+  ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo, connhost);

 }
 
 /*************************************************
 }
 
 /*************************************************


@@ -526,16 +585,15 @@ if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
 /*
 Arguments:
   fd          the file descriptor
 /*
 Arguments:
   fd          the file descriptor

-  timeout     the timeout, seconds
+  timelimit   the timeout endpoint, seconds-since-epoch

 Returns:      TRUE => ready for i/o
               FALSE => timed out, or other error
 */
 BOOL
 Returns:      TRUE => ready for i/o
               FALSE => timed out, or other error
 */
 BOOL

-fd_ready(int fd, int timeout)
+fd_ready(int fd, time_t timelimit)

 {
 fd_set select_inset;
 {
 fd_set select_inset;

-time_t start_recv = time(NULL);
-int time_left = timeout;
+int time_left = timelimit - time(NULL);

 int rc;
 
 if (time_left <= 0)
 int rc;
 
 if (time_left <= 0)


@@ -569,8 +627,7 @@ do
     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
 
     /* Watch out, 'continue' jumps to the condition, not to the loops top */
     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
 
     /* Watch out, 'continue' jumps to the condition, not to the loops top */

-    time_left = timeout - (time(NULL) - start_recv);
-    if (time_left > 0) continue;
+    if ((time_left = timelimit - time(NULL)) > 0) continue;

     }
 
   if (rc <= 0)
     }
 
   if (rc <= 0)


@@ -594,24 +651,24 @@ Arguments:
   cctx        the connection context (socket fd, possibly TLS context)
   buffer      to read into
   bufsize     the buffer size
   cctx        the connection context (socket fd, possibly TLS context)
   buffer      to read into
   bufsize     the buffer size

-  timeout     the timeout
+  timelimit   the timeout endpoint, seconds-since-epoch

 
 Returns:      > 0 => that much data read
               <= 0 on error or EOF; errno set - zero for EOF
 */
 
 int
 
 Returns:      > 0 => that much data read
               <= 0 on error or EOF; errno set - zero for EOF
 */
 
 int

-ip_recv(client_conn_ctx * cctx, uschar * buffer, int buffsize, int timeout)
+ip_recv(client_conn_ctx * cctx, uschar * buffer, int buffsize, time_t timelimit)

 {
 int rc;
 
 {
 int rc;
 

-if (!fd_ready(cctx->sock, timeout))
+if (!fd_ready(cctx->sock, timelimit))

   return -1;
 
 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
 close down of the connection), set errno to zero; otherwise leave it alone. */
 
   return -1;
 
 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
 close down of the connection), set errno to zero; otherwise leave it alone. */
 

-#ifdef SUPPORT_TLS
+#ifndef DISABLE_TLS

 if (cctx->tls_ctx)                                     /* client TLS */
   rc = tls_read(cctx->tls_ctx, buffer, buffsize);
 else if (tls_in.active.sock == cctx->sock)             /* server TLS */
 if (cctx->tls_ctx)                                     /* client TLS */
   rc = tls_read(cctx->tls_ctx, buffer, buffsize);
 else if (tls_in.active.sock == cctx->sock)             /* server TLS */


@@ -795,8 +852,7 @@ return FALSE;
 void
 dscp_list_to_stream(FILE *stream)
 {
 void
 dscp_list_to_stream(FILE *stream)
 {

-int i;
-for (i=0; i < dscp_table_size; ++i)
+for (int i = 0; i < dscp_table_size; ++i)

   fprintf(stream, "%s\n", dscp_table[i].name);
 }
 
   fprintf(stream, "%s\n", dscp_table[i].name);
 }