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

src/core/connection.c

@@ -109,6 +109,7 @@
 #if DEBUG
     Connection->RefTypeCount[QUIC_CONN_REF_HANDLE_OWNER] = 1;
 #endif
+    Connection->State.UseQTIP = 0;
     Connection->PartitionID = PartitionId;
     Connection->State.Allocated = TRUE;
     Connection->State.ShareBinding = IsServer;
@@ -6753,6 +6754,14 @@
         Status = QUIC_STATUS_SUCCESS;
         break;
 #endif
+    case QUIC_PARAM_CONN_QTIP:
+        if (BufferLength != sizeof(BOOLEAN) || Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+        Connection->State.UseQTIP = *(BOOLEAN*)Buffer;
+        Status = QUIC_STATUS_SUCCESS;
+        break;
 
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
@@ -7284,6 +7293,24 @@
         Status = QUIC_STATUS_SUCCESS;
         break;
 
+    case QUIC_PARAM_CONN_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.UseQTIP;
+
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
         break;

src/core/connection.h

@@ -208,6 +208,11 @@ typedef union QUIC_CONNECTION_STATE {
         //
         BOOLEAN DisableVneTp : 1;
 #endif
+
+        //
+        // Whether to use QTIP on sends for this connection.
+        //
+        BOOLEAN UseQTIP : 1;
     };
 } QUIC_CONNECTION_STATE;
 

src/core/listener.c

@@ -769,6 +769,17 @@
         return QUIC_STATUS_SUCCESS;
     }
 
+    if (Param == QUIC_PARAM_LISTENER_QTIP) {
+        if (BufferLength > sizeof(uint8_t)) {
+            return QUIC_STATUS_INVALID_PARAMETER;
+        }
+        if (Buffer == NULL) {
+            return QUIC_STATUS_INVALID_PARAMETER;
+        }
+        Listener->UseQTIP = *(uint8_t*)Buffer;
+        return QUIC_STATUS_SUCCESS;
+    }
+
     return QUIC_STATUS_INVALID_PARAMETER;
 }
 
@@ -855,6 +866,25 @@
         Status = QUIC_STATUS_SUCCESS;
         break;
 
+    case QUIC_PARAM_LISTENER_QTIP:
+
+        if (*BufferLength < sizeof(uint8_t)) {
+            *BufferLength = sizeof(uint8_t);
+            Status = QUIC_STATUS_BUFFER_TOO_SMALL;
+            break;
+        }
+
+        if (Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+
+        *BufferLength = sizeof(uint8_t);
+        *(uint8_t*)Buffer = Listener->UseQTIP;
+
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
         break;

src/core/listener.h

@@ -110,6 +110,11 @@ typedef struct QUIC_LISTENER {
     //
     uint8_t CibirId[2 + QUIC_MAX_CIBIR_LENGTH];
 
+    //
+    // Whether or not this listener accepts QTIP traffic (BOOLEAN)
+    //
+    uint8_t UseQTIP : 1;
+
 } QUIC_LISTENER;
 
 #ifdef QUIC_SILO

src/core/send.c

@@ -1190,6 +1190,8 @@ QuicSendFlush(
     QUIC_CONNECTION* Connection = QuicSendGetConnection(Send);
     QUIC_PATH* Path = &Connection->Paths[0];
 
+    Path->Route.UseQTIP = Connection->State.UseQTIP;
+
     CXPLAT_DBG_ASSERT(!Connection->State.HandleClosed);
 
     if (!CxPlatIsRouteReady(Connection, Path)) {

src/cs/lib/msquic_generated.cs

@@ -3372,6 +3372,9 @@ internal static unsafe partial class MsQuic
         [NativeTypeName("#define QUIC_PARAM_LISTENER_CIBIR_ID 0x04000002")]
         internal const uint QUIC_PARAM_LISTENER_CIBIR_ID = 0x04000002;
 
+        [NativeTypeName("#define QUIC_PARAM_LISTENER_QTIP 0x04000004")]
+        internal const uint QUIC_PARAM_LISTENER_QTIP = 0x04000004;
+
         [NativeTypeName("#define QUIC_PARAM_CONN_QUIC_VERSION 0x05000000")]
         internal const uint QUIC_PARAM_CONN_QUIC_VERSION = 0x05000000;
 
@@ -3450,6 +3453,9 @@ 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_QTIP 0x0500001A")]
+        internal const uint QUIC_PARAM_CONN_QTIP = 0x0500001A;
+
         [NativeTypeName("#define QUIC_PARAM_TLS_HANDSHAKE_INFO 0x06000000")]
         internal const uint QUIC_PARAM_TLS_HANDSHAKE_INFO = 0x06000000;
 

src/inc/msquic.h

@@ -889,6 +889,7 @@ typedef struct QUIC_SCHANNEL_CREDENTIAL_ATTRIBUTE_W {
 #define QUIC_PARAM_LISTENER_STATS                       0x04000001  // QUIC_LISTENER_STATISTICS
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
 #define QUIC_PARAM_LISTENER_CIBIR_ID                    0x04000002  // uint8_t[] {offset, id[]}
+#define QUIC_PARAM_LISTENER_QTIP                        0x04000004  // uint8_t (BOOLEAN)
 #endif
 
 //
@@ -925,6 +926,10 @@ 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_QTIP                            0x0500001A  // uint8_t (BOOLEAN)
+#endif
+
 //
 // Parameters for TLS.
 //

src/inc/quic_datapath.h

@@ -210,6 +210,7 @@ typedef struct CXPLAT_ROUTE {
     CXPLAT_ROUTE_STATE State;
     CXPLAT_RAW_TCP_STATE TcpState;
 
+    uint8_t UseQTIP : 1;         // TRUE if the route is using QTIP
 } CXPLAT_ROUTE;
 
 //

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 = Datapath->UseTcp; // TODO: We don't need this at all anymore. Remove once all instances of it are replaced with CXPLAT_ROUTE logic.
     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;