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

src/core/connection.c

@@ -109,6 +109,8 @@
 #if DEBUG
     Connection->RefTypeCount[QUIC_CONN_REF_HANDLE_OWNER] = 1;
 #endif
+    Connection->State.UseQTIP = 0;
+    Connection->State.AppDidSetQTIP = 0;
     Connection->PartitionID = PartitionId;
     Connection->State.Allocated = TRUE;
     Connection->State.ShareBinding = IsServer;
@@ -6753,6 +6755,15 @@
         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;
+        Connection->State.AppDidSetQTIP = TRUE;
+        Status = QUIC_STATUS_SUCCESS;
+        break;
 
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;
@@ -7284,6 +7295,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,16 @@ typedef union QUIC_CONNECTION_STATE {
         //
         BOOLEAN DisableVneTp : 1;
 #endif
+
+        //
+        // Whether to use QTIP on sends for this connection.
+        //
+        BOOLEAN UseQTIP : 1;
+
+        //
+        // Whether or not the app explicitly set the UseQTIP flag.
+        //
+        BOOLEAN AppDidSetQTIP : 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,9 @@ QuicSendFlush(
     QUIC_CONNECTION* Connection = QuicSendGetConnection(Send);
     QUIC_PATH* Path = &Connection->Paths[0];
 
+    Path->Route.UseQTIP = Connection->State.UseQTIP;
+    Path->Route.AppDidSetQTIP = Connection->State.AppDidSetQTIP;
+
     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,8 @@ typedef struct CXPLAT_ROUTE {
     CXPLAT_ROUTE_STATE State;
     CXPLAT_RAW_TCP_STATE TcpState;
 
+    uint8_t UseQTIP : 1;         // TRUE if the route is using QTIP
+    uint8_t AppDidSetQTIP : 1;   // TRUE if the app explicitly set the UseQTIP flag
 } 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.