Add support for both Qtip and UDP traffic for Server Listeners.

src/core/connection.c

@@ -6754,6 +6754,26 @@
         break;
 #endif
 
+#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
+    case QUIC_PARAM_CONN_SEND_QTIP:
+        if (BufferLength != sizeof(BOOLEAN) || Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+        Connection->State.SendViaQtip = *(BOOLEAN*)Buffer;
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+
+    case QUIC_PARAM_CONN_RECV_QTIP:
+        if (BufferLength != sizeof(BOOLEAN) || Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+        Connection->State.RecvViaQtip = *(BOOLEAN*)Buffer;
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+#endif
+
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
         break;
@@ -7284,6 +7304,42 @@
         Status = QUIC_STATUS_SUCCESS;
         break;
 
+#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
+    case QUIC_PARAM_CONN_SEND_QTIP:
+        if (*BufferLength < sizeof(BOOLEAN)) {
+            *BufferLength = sizeof(BOOLEAN);
+            Status = QUIC_STATUS_BUFFER_TOO_SMALL;
+            break;
+        }
+
+        if (Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+
+        *BufferLength = sizeof(BOOLEAN);
+        *(BOOLEAN*)Buffer = Connection->State.SendViaQtip;
+
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+
+    case QUIC_PARAM_CONN_RECV_QTIP:
+        if (*BufferLength < sizeof(BOOLEAN)) {
+            *BufferLength = sizeof(BOOLEAN);
+            Status = QUIC_STATUS_BUFFER_TOO_SMALL;
+            break;
+        }
+
+        if (Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+        *BufferLength = sizeof(BOOLEAN);
+        *(BOOLEAN*)Buffer = Connection->State.RecvViaQtip;
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+#endif
+
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
         break;

src/core/connection.h

@@ -208,6 +208,18 @@ typedef union QUIC_CONNECTION_STATE {
         //
         BOOLEAN DisableVneTp : 1;
 #endif
+
+#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
+        //
+        // Whether to use QTIP on sends for this connection.
+        //
+        BOOLEAN SendViaQtip : 1;
+
+        //
+        // Whether to allow QTIP on receives for this connection.
+        //
+        BOOLEAN RecvViaQtip : 1;
+#endif
     };
 } QUIC_CONNECTION_STATE;
 

src/cs/lib/msquic_generated.cs

@@ -3450,6 +3450,12 @@ internal static unsafe partial class MsQuic
         [NativeTypeName("#define QUIC_PARAM_CONN_SEND_DSCP 0x05000019")]
         internal const uint QUIC_PARAM_CONN_SEND_DSCP = 0x05000019;
 
+        [NativeTypeName("#define QUIC_PARAM_CONN_SEND_QTIP 0x0500001A")]
+        internal const uint QUIC_PARAM_CONN_SEND_QTIP = 0x0500001A;
+
+        [NativeTypeName("#define QUIC_PARAM_CONN_RECV_QTIP 0x0500001B")]
+        internal const uint QUIC_PARAM_CONN_RECV_QTIP = 0x0500001B;
+
         [NativeTypeName("#define QUIC_PARAM_TLS_HANDSHAKE_INFO 0x06000000")]
         internal const uint QUIC_PARAM_TLS_HANDSHAKE_INFO = 0x06000000;
 

src/inc/msquic.h

@@ -925,6 +925,11 @@ typedef struct QUIC_SCHANNEL_CREDENTIAL_ATTRIBUTE_W {
 #define QUIC_PARAM_CONN_ORIG_DEST_CID                   0x05000018  // uint8_t[]
 #define QUIC_PARAM_CONN_SEND_DSCP                       0x05000019  // uint8_t
 
+#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
+#define QUIC_PARAM_CONN_SEND_QTIP                       0x0500001A  // uint8_t (BOOLEAN)
+#define QUIC_PARAM_CONN_RECV_QTIP                       0x0500001B  // uint8_t (BOOLEAN)
+#endif
+
 //
 // Parameters for TLS.
 //

src/platform/datapath_raw.c

@@ -234,7 +234,12 @@ CxPlatDpRawRxEthernet(
 
         if (Socket) {
             if (PacketChain->Reserved == L4_TYPE_UDP || PacketChain->Reserved == L4_TYPE_TCP) {
-                uint8_t SocketType = Socket->UseTcp ? L4_TYPE_TCP : L4_TYPE_UDP;
+                //
+                // If we have UseTcp enabled, we should still support UDP type of packets.
+                //
+                // uint8_t SocketType = (Socket->UseTcp && PacketChain->Reserved == L4_TYPE_TCP) ? L4_TYPE_TCP : L4_TYPE_UDP;
+
+                uint8_t SocketType = (Socket->UseTcp) ? L4_TYPE_TCP : L4_TYPE_UDP; // This is the old code
 
                 //
                 // Found a match. Chain and deliver contiguous packets with the same 4-tuple.

src/platform/datapath_winuser.c

@@ -1490,7 +1490,7 @@ SocketCreateUdp(
     Socket->HasFixedRemoteAddress = (Config->RemoteAddress != NULL);
     Socket->Type = CXPLAT_SOCKET_UDP;
     Socket->UseRio = Datapath->UseRio;
-    Socket->UseTcp = Datapath->UseTcp;
+    Socket->UseTcp = 0; // TODO: revert this back to Datapath->UseTcp
     if (Config->LocalAddress) {
         CxPlatConvertToMappedV6(Config->LocalAddress, &Socket->LocalAddress);
     } else {

src/test/MsQuicTests.h

@@ -407,7 +407,8 @@ QuicTestConnectAndPing(
     _In_ bool UseSendBuffer,
     _In_ bool UnidirectionalStreams,
     _In_ bool ServerInitiatedStreams,
-    _In_ bool FifoScheduling
+    _In_ bool FifoScheduling,
+    _In_ bool SendUdpToQtipListener
     );
 
 //
@@ -820,6 +821,7 @@ typedef struct {
     uint8_t UnidirectionalStreams;
     uint8_t ServerInitiatedStreams;
     uint8_t FifoScheduling;
+    uint8_t SendUdpToQtipListener;
 } QUIC_RUN_CONNECT_AND_PING_PARAMS;
 
 #pragma pack(pop)

src/test/bin/quic_gtest.cpp

@@ -1739,7 +1739,8 @@ TEST_P(WithSendArgs1, Send) {
             (uint8_t)GetParam().UseSendBuffer,
             (uint8_t)GetParam().UnidirectionalStreams,
             (uint8_t)GetParam().ServerInitiatedStreams,
-            0   // FifoScheduling
+            0,   // FifoScheduling
+            0,   // SendUdpToQtipListener
         };
         ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_CONNECT_AND_PING, Params));
     } else {
@@ -1757,7 +1758,24 @@ TEST_P(WithSendArgs1, Send) {
             GetParam().UseSendBuffer,
             GetParam().UnidirectionalStreams,
             GetParam().ServerInitiatedStreams,
-            false); // FifoScheduling
+            false,  // FifoScheduling
+            false); // SendUdpToQtipListener
+        QuicTestConnectAndPing(
+            GetParam().Family,
+            GetParam().Length,
+            GetParam().ConnectionCount,
+            GetParam().StreamCount,
+            1,      // StreamBurstCount
+            0,      // StreamBurstDelayMs
+            false,  // ServerStatelessRetry
+            false,  // ClientRebind
+            false,  // ClientZeroRtt
+            false,  // ServerRejectZeroRtt
+            GetParam().UseSendBuffer,
+            GetParam().UnidirectionalStreams,
+            GetParam().ServerInitiatedStreams,
+            false,  // FifoScheduling
+            true);  // SendUdpToQtipListener
     }
 }
 
@@ -1778,7 +1796,8 @@ TEST_P(WithSendArgs2, SendLarge) {
             (uint8_t)GetParam().UseSendBuffer,
             0,  // UnidirectionalStreams
             0,  // ServerInitiatedStreams
-            1   // FifoScheduling
+            1,  // FifoScheduling
+            0   // SendUdpToQtipListener
         };
         ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_CONNECT_AND_PING, Params));
     } else {
@@ -1796,7 +1815,8 @@ TEST_P(WithSendArgs2, SendLarge) {
             GetParam().UseSendBuffer,
             false,  // UnidirectionalStreams
             false,  // ServerInitiatedStreams
-            true);  // FifoScheduling
+            true,   // FifoScheduling
+            false); // SendUdpToQtipListener
     }
 }
 
@@ -1817,7 +1837,8 @@ TEST_P(WithSendArgs3, SendIntermittently) {
             (uint8_t)GetParam().UseSendBuffer,
             0,  // UnidirectionalStreams
             0,  // ServerInitiatedStreams
-            0   // FifoScheduling
+            0,  // FifoScheduling
+            0   // SendUdpToQtipListener
         };
         ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_CONNECT_AND_PING, Params));
     } else {
@@ -1835,7 +1856,8 @@ TEST_P(WithSendArgs3, SendIntermittently) {
             GetParam().UseSendBuffer,
             false,  // UnidirectionalStreams
             false,  // ServerInitiatedStreams
-            false); // FifoScheduling
+            false,  // FifoScheduling
+            false); // SendUdpToQtipListener
     }
 }
 
@@ -1868,7 +1890,8 @@ TEST_P(WithSend0RttArgs1, Send0Rtt) {
             (uint8_t)GetParam().UseSendBuffer,
             (uint8_t)GetParam().UnidirectionalStreams,
             0,  // ServerInitiatedStreams
-            0   // FifoScheduling
+            0,  // FifoScheduling
+            0   // SendUdpToQtipListener
         };
         ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_CONNECT_AND_PING, Params));
     } else {
@@ -1886,7 +1909,8 @@ TEST_P(WithSend0RttArgs1, Send0Rtt) {
             GetParam().UseSendBuffer,
             GetParam().UnidirectionalStreams,
             false,  // ServerInitiatedStreams
-            false); // FifoScheduling
+            false,  // FifoScheduling
+            false); // SendUdpToQtipListener
     }
 }
 
@@ -1916,7 +1940,8 @@ TEST_P(WithSend0RttArgs2, Reject0Rtt) {
             0,  // UseSendBuffer
             0,  // UnidirectionalStreams
             0,  // ServerInitiatedStreams
-            0   // FifoScheduling
+            0,  // FifoScheduling
+            0   // SendUdpToQtipListener
         };
         ASSERT_TRUE(DriverClient.Run(IOCTL_QUIC_RUN_CONNECT_AND_PING, Params));
     } else {
@@ -1934,7 +1959,8 @@ TEST_P(WithSend0RttArgs2, Reject0Rtt) {
             false,  // UseSendBuffer
             false,  // UnidirectionalStreams
             false,  // ServerInitiatedStreams
-            false); // FifoScheduling
+            false,  // FifoScheduling
+            false); // SendUdpToQtipListener
     }
 }
 

src/test/bin/winkernel/control.cpp

@@ -812,7 +812,8 @@ QuicTestCtlEvtIoDeviceControl(
                 Params->Params2.UseSendBuffer != 0,
                 Params->Params2.UnidirectionalStreams != 0,
                 Params->Params2.ServerInitiatedStreams != 0,
-                Params->Params2.FifoScheduling != 0
+                Params->Params2.FifoScheduling != 0,
+                Params->Params2.SendUdpToQtipListener != 0
                 ));
         break;
 

src/test/lib/DataTest.cpp

@@ -367,7 +367,8 @@ QuicTestConnectAndPing(
     _In_ bool UseSendBuffer,
     _In_ bool UnidirectionalStreams,
     _In_ bool ServerInitiatedStreams,
-    _In_ bool FifoScheduling
+    _In_ bool FifoScheduling,
+    _In_ bool SendUdpToQtipListener
     )
 {
     const uint32_t TimeoutMs = EstimateTimeoutMs(Length) * StreamBurstCount;
@@ -378,6 +379,7 @@ QuicTestConnectAndPing(
     PingStats ClientStats(Length, ConnectionCount, TotalStreamCount, FifoScheduling, UnidirectionalStreams, ServerInitiatedStreams, ClientZeroRtt && !ServerRejectZeroRtt);
 
     MsQuicRegistration Registration(NULL, QUIC_EXECUTION_PROFILE_TYPE_MAX_THROUGHPUT, true);
+
     TEST_TRUE(Registration.IsValid());
 
     if (ServerRejectZeroRtt) {
@@ -400,7 +402,6 @@ QuicTestConnectAndPing(
     }
 
     MsQuicAlpn Alpn("MsQuicTest");
-
     MsQuicSettings Settings;
     if (ClientZeroRtt) {
         Settings.SetServerResumptionLevel(QUIC_SERVER_RESUME_AND_ZERORTT);
@@ -410,7 +411,19 @@ QuicTestConnectAndPing(
         Settings.SetPeerUnidiStreamCount(TotalStreamCount);
     }
     Settings.SetSendBufferingEnabled(UseSendBuffer);
-
+    if (UseQTIP && SendUdpToQtipListener) {
+        // Do a sanity check to make sure we actually have QTIP enabled.
+        QUIC_EXECUTION_CONFIG Config = {QUIC_EXECUTION_CONFIG_FLAG_NONE, 0, 0, {0}};
+        // Get the current global execution config.
+        uint32_t Size = sizeof(Config);
+        TEST_TRUE(QUIC_SUCCEEDED(
+            MsQuic->GetParam(
+                nullptr,
+                QUIC_PARAM_GLOBAL_EXECUTION_CONFIG,
+                &Size,
+                &Config)));
+        TEST_TRUE((Config.Flags & QUIC_EXECUTION_CONFIG_FLAG_QTIP) != 0);
+    }
     MsQuicConfiguration ServerConfiguration(Registration, Alpn, Settings, ServerSelfSignedCredConfig);
     TEST_TRUE(ServerConfiguration.IsValid());
 
@@ -427,22 +440,6 @@ QuicTestConnectAndPing(
         TEST_QUIC_SUCCEEDED(ServerConfiguration.SetTicketKey(&GoodKey));
     }
 
-    MsQuicCredentialConfig ClientCredConfig;
-    MsQuicConfiguration ClientConfiguration(Registration, Alpn, ClientCredConfig);
-    TEST_TRUE(ClientConfiguration.IsValid());
-
-    if (ClientZeroRtt) {
-        QuicTestPrimeResumption(
-            QuicAddrFamily,
-            Registration,
-            ServerConfiguration,
-            ClientConfiguration,
-            &ClientStats.ResumptionTicket);
-        if (!ClientStats.ResumptionTicket) {
-            return;
-        }
-    }
-
     StatelessRetryHelper RetryHelper(ServerStatelessRetry);
 
     {
@@ -457,18 +454,29 @@ QuicTestConnectAndPing(
         TEST_TRUE(Listener.IsValid());
         TEST_QUIC_SUCCEEDED(Listener.Start(Alpn));
 
+        MsQuicCredentialConfig ClientCredConfig;
+        MsQuicConfiguration ClientConfiguration(Registration, Alpn, ClientCredConfig);
+        TEST_TRUE(ClientConfiguration.IsValid());
+        if (ClientZeroRtt) {
+            QuicTestPrimeResumption(
+                QuicAddrFamily,
+                Registration,
+                ServerConfiguration,
+                ClientConfiguration,
+                &ClientStats.ResumptionTicket);
+            if (!ClientStats.ResumptionTicket) {
+                return;
+            }
+        }
+
         QuicAddr ServerLocalAddr;
         TEST_QUIC_SUCCEEDED(Listener.GetLocalAddr(ServerLocalAddr));
-
         Listener.Context = &ServerStats;
-
         TestConnection** ConnAlloc = new(std::nothrow) TestConnection*[ConnectionCount];
         if (ConnAlloc == nullptr) {
             return;
         }
-
         UniquePtrArray<TestConnection*> Connections(ConnAlloc);
-
         for (uint32_t i = 0; i < ClientStats.ConnectionCount; ++i) {
             Connections.get()[i] =
                 NewPingConnection(
@@ -483,7 +491,6 @@ QuicTestConnectAndPing(
                     Connections.get()[i]->SetTlsSecrets(&ClientSecrets[i]));
             }
         }
-
         QuicAddr LocalAddr;
         for (uint32_t j = 0; j < StreamBurstCount; ++j) {
             if (j != 0) {