Changeset 100171 in vbox

Timestamp:

Jun 13, 2023 9:07:56 PM (18 months ago)

Author:

vboxsync

Message:

IPRT: tcp.h+tcp.cpp,socket.h+socket.cpp: Add RTTcpSetKeepAlive() which
allows one to enable or disable sending periodic keep-alive messages on
a socket (SO_KEEPALIVE) as described in RFC 1122. RTTcpSetKeepAlive()
also allows one to adjust several keep-alive options on a per-socket
basis: the idle time before keep-alive probes are sent (TCP_KEEPIDLE
(TCP_KEEPALIVE on macOS)), the amount of time between keep-alive probes
(TCP_KEEPINTVL), and the number of keep-alive probes to send before
closing the connection (TCP_KEEPCNT).

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (1 diff)
• include/iprt/tcp.h (modified) (1 diff)
• src/VBox/Runtime/include/internal/socket.h (modified) (1 diff)
• src/VBox/Runtime/r3/socket.cpp (modified) (2 diffs)
• src/VBox/Runtime/r3/tcp.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/win/init-win.cpp (modified) (3 diffs)
• src/VBox/Runtime/r3/win/internal-r3-win.h (modified) (2 diffs)

trunk/include/iprt/mangling.h

@@ -2472 +2472 @@
 # define RTTcpServerListen2                             RT_MANGLER(RTTcpServerListen2)
 # define RTTcpServerShutdown                            RT_MANGLER(RTTcpServerShutdown)
+# define RTTcpSetBufferSize                             RT_MANGLER(RTTcpSetBufferSize)
+# define RTTcpSetKeepAlive                              RT_MANGLER(RTTcpSetKeepAlive)
 # define RTTcpSetSendCoalescing                         RT_MANGLER(RTTcpSetSendCoalescing)
-# define RTTcpSetBufferSize                             RT_MANGLER(RTTcpSetBufferSize)
 # define RTTcpSgWrite                                   RT_MANGLER(RTTcpSgWrite)
 # define RTTcpSgWriteL                                  RT_MANGLER(RTTcpSgWriteL)

trunk/include/iprt/tcp.h

@@ -310 +310 @@
 
 /**
+ * Enables or disables sending of periodic keep-alive messages on a socket.
+ * Also set values relating to TCP keep-alive messages on a socket.  The TCP
+ * keep-alive mechanism is described in RFC 1122 which states:
+ * "Keep-alive packets MUST only be sent when no data or acknowledgement
+ * packets have been received for the connection within an interval. This
+ * interval MUST be configurable and MUST default to no less than two hours."
+ * The following per-socket options allow fine-tuning the keep-alive interval,
+ * frequency, and timeout when SO_KEEPALIVE has been set for the socket.
+ *
+ * @returns iprt status code.
+ * @retval  VERR_NOT_SUPPORTED is returned if these keep-alive options aren't
+ *          supported by the OS.
+ *
+ * @param   hSocket                 Socket descriptor.
+ * @param   fEnable                 When set to true enables keep-alive messages.
+ * @param   cSecsIdle               The amount of time, in seconds, that the connection must be idle before
+ *                                  keep-alive probes are sent for this socket. (TCP_KEEPIDLE (TCP_KEEPALIVE on macOS))
+ *                                  If zero then the system default is used (the default value varies by OS
+ *                                  but is typically 2 hours (7200 seconds)).
+ * @param   cSecsInterval           The amount of time, in seconds, between each keep-alive probe sent to a
+ *                                  peer. (TCP_KEEPINTVL)
+ *                                  If zero then the system default is used (the default value varies by OS
+ *                                  but is typically 75 seconds).
+ * @param   cFailedPktsBeforeClose  The number of keep-alive probes to send which receive no response before
+ *                                  closing the connection. (TCP_KEEPCNT)
+ *                                  If zero then the system default is used (the default value varies by OS
+ *                                  but is typically 8 packets).
+ */
+RTR3DECL(int)  RTTcpSetKeepAlive(RTSOCKET hSocket, bool fEnable, uint32_t cSecsIdle, uint32_t cSecsInterval,
+                                 uint32_t cFailedPktsBeforeClose);
+
+/**
  * Socket I/O multiplexing.
  * Checks if the socket is ready for reading.

trunk/src/VBox/Runtime/include/internal/socket.h

@@ -79 +79 @@
 
 DECLHIDDEN(int)         rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative);
+DECLHIDDEN(int)         rtSocketSetKeepAlive(RTSOCKET hSocket, bool fEnable, uint32_t cSecsIdle, uint32_t cSecsInterval);
 DECLHIDDEN(uint32_t)    rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait);
 DECLHIDDEN(uint32_t)    rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents);

trunk/src/VBox/Runtime/r3/socket.cpp

@@ -42 +42 @@
 # include <iprt/win/winsock2.h>
 # include <iprt/win/ws2tcpip.h>
+# include <mstcpip.h>  /* for struct tcp_keepalive */
 #else /* !RT_OS_WINDOWS */
 # include <errno.h>
@@ -2883 +2884 @@
 }
 
+
+DECLHIDDEN(int) rtSocketSetKeepAlive(RTSOCKET hSocket, bool fEnable, uint32_t cSecsIdle, uint32_t cSecsInterval)
+{
+    RTSOCKETINT *pThis = hSocket;
+    AssertPtrReturn(pThis, UINT32_MAX);
+    AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, UINT32_MAX);
+
+    if (!g_pfnWSAIoctl)
+        return VERR_NET_NOT_UNSUPPORTED;
+
+    struct tcp_keepalive keepAliveOptions;
+    DWORD dwBytesReturned;
+
+    keepAliveOptions.onoff = fEnable ? 1 : 0;
+    keepAliveOptions.keepalivetime = cSecsIdle * 1000;
+    keepAliveOptions.keepaliveinterval = cSecsInterval * 1000;
+
+    if (g_pfnWSAIoctl(pThis->hNative,
+                      SIO_KEEPALIVE_VALS,
+                      &keepAliveOptions, sizeof(keepAliveOptions),
+                      NULL, 0, &dwBytesReturned, NULL, NULL) == 0)
+        return VINF_SUCCESS;
+
+    int rc = rtSocketError();
+    AssertMsgFailed(("WSAIoctl(.., SIO_KEEPALIVE_VALS, ...) failed: rc=%Rrc\n", rc));
+    return rc;
+}
+
 #endif  /* RT_OS_WINDOWS */
 

trunk/src/VBox/Runtime/r3/tcp.cpp

@@ -1001 +1001 @@
 
 
+RTR3DECL(int)  RTTcpSetKeepAlive(RTSOCKET hSocket, bool fEnable, uint32_t cSecsIdle,
+                                 uint32_t cSecsInterval, uint32_t cFailedPktsBeforeClose)
+{
+#if !defined(RT_OS_WINDOWS)
+    int fFlag = fEnable ? 1 : 0;
+    int rc = rtSocketSetOpt(hSocket, SOL_SOCKET, SO_KEEPALIVE, &fFlag, sizeof(fFlag));
+    if (RT_FAILURE(rc))
+        return rc;
+
+# if defined(TCP_KEEPIDLE) || defined(TCP_KEEPALIVE)
+    rc = VINF_SUCCESS;
+
+    /* time in seconds that the connection must be idle before sending keep-alive probes */
+    if (cSecsIdle)
+    {
+#  if defined(TCP_KEEPALIVE) && !defined(TCP_KEEPIDLE)  /* macOS */
+#   define TCP_KEEPIDLE    TCP_KEEPALIVE
+#  endif
+        rc = rtSocketSetOpt(hSocket, IPPROTO_TCP, TCP_KEEPIDLE, &cSecsIdle, sizeof(cSecsIdle));
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /* time in seconds between each keep-alive probe */
+    if (cSecsInterval)
+    {
+        rc = rtSocketSetOpt(hSocket, IPPROTO_TCP, TCP_KEEPINTVL, &cSecsInterval, sizeof(cSecsInterval));
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /* count of keep-alive probes to send which don't receive a response before closing connection */
+    if (cFailedPktsBeforeClose)
+    {
+        rc = rtSocketSetOpt(hSocket, IPPROTO_TCP, TCP_KEEPCNT, &cFailedPktsBeforeClose, sizeof(cFailedPktsBeforeClose));
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return rc;
+# else
+    return VERR_NOT_SUPPORTED;
+# endif
+#else
+    NOREF(cFailedPktsBeforeClose);
+    return rtSocketSetKeepAlive(hSocket, fEnable, cSecsIdle, cSecsInterval);
+#endif
+}
+
+
 RTR3DECL(int)  RTTcpSelectOne(RTSOCKET Sock, RTMSINTERVAL cMillies)
 {

trunk/src/VBox/Runtime/r3/win/init-win.cpp

@@ -136 +136 @@
 /** WSASend */
 DECL_HIDDEN_DATA(PFNWSASEND)                    g_pfnWSASend = NULL;
+/** WSAIoctl */
+DECL_HIDDEN_DATA(PFNWSAIOCTL)                   g_pfnWSAIoctl = NULL;
 /** socket */
 DECL_HIDDEN_DATA(PFNWINSOCKSOCKET)              g_pfnsocket = NULL;
@@ -447 +449 @@
     g_pfnWSASocketW           = (decltype(g_pfnWSASocketW))         GetProcAddress(g_hModWinSock, "WSASocketW");
     g_pfnWSASend              = (decltype(g_pfnWSASend))            GetProcAddress(g_hModWinSock, "WSASend");
+    g_pfnWSAIoctl             = (decltype(g_pfnWSAIoctl))           GetProcAddress(g_hModWinSock, "WSAIoctl");
     g_pfnsocket               = (decltype(g_pfnsocket))             GetProcAddress(g_hModWinSock, "socket");
     g_pfnclosesocket          = (decltype(g_pfnclosesocket))        GetProcAddress(g_hModWinSock, "closesocket");
@@ -478 +481 @@
     Assert(g_pfnWSASocketW           || g_fOldWinSock);
     Assert(g_pfnWSASend              || g_fOldWinSock);
+    Assert(g_pfnWSAIoctl             || g_fOldWinSock);
     Assert(g_pfnsocket);
     Assert(g_pfnclosesocket);

trunk/src/VBox/Runtime/r3/win/internal-r3-win.h

@@ -167 +167 @@
 /** WSASend */
 typedef int             (WINAPI *PFNWSASEND)(UINT_PTR, struct _WSABUF *, DWORD, LPDWORD, DWORD dwFlags,
+                                             struct _OVERLAPPED *, uintptr_t /*LPWSAOVERLAPPED_COMPLETION_ROUTINE*/);
+/** WSAIoctl */
+typedef int             (WINAPI *PFNWSAIOCTL)(UINT_PTR, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD,
                                              struct _OVERLAPPED *, uintptr_t /*LPWSAOVERLAPPED_COMPLETION_ROUTINE*/);
 
@@ -219 +222 @@
 extern DECL_HIDDEN_DATA(PFNWSASOCKETW)                   g_pfnWSASocketW;
 extern DECL_HIDDEN_DATA(PFNWSASEND)                      g_pfnWSASend;
+extern DECL_HIDDEN_DATA(PFNWSAIOCTL)                     g_pfnWSAIoctl;
 extern DECL_HIDDEN_DATA(PFNWINSOCKSOCKET)                g_pfnsocket;
 extern DECL_HIDDEN_DATA(PFNWINSOCKCLOSESOCKET)           g_pfnclosesocket;