Track Received ECN Counts

src/core/ack_tracker.c

@@ -48,11 +48,6 @@ QuicAckTrackerInitialize(
     _Inout_ QUIC_ACK_TRACKER* Tracker
     )
 {
-    Tracker->AckElicitingPacketsToAcknowledge = 0;
-    Tracker->LargestPacketNumberAcknowledged = 0;
-    Tracker->LargestPacketNumberRecvTime = 0;
-    Tracker->AlreadyWrittenAckFrame = FALSE;
-
     QuicRangeInitialize(
         QUIC_MAX_RANGE_DUPLICATE_PACKETS,
         &Tracker->PacketNumbersReceived);
@@ -82,6 +77,8 @@ QuicAckTrackerReset(
     Tracker->LargestPacketNumberAcknowledged = 0;
     Tracker->LargestPacketNumberRecvTime = 0;
     Tracker->AlreadyWrittenAckFrame = FALSE;
+    Tracker->NonZeroRecvECN = FALSE;
+    QuicZeroMemory(&Tracker->ReceivedECN, sizeof(Tracker->ReceivedECN));
     QuicRangeReset(&Tracker->PacketNumbersToAck);
     QuicRangeReset(&Tracker->PacketNumbersReceived);
 }
@@ -104,6 +101,7 @@ void
 QuicAckTrackerAckPacket(
     _Inout_ QUIC_ACK_TRACKER* Tracker,
     _In_ uint64_t PacketNumber,
+    _In_ QUIC_ECN_TYPE ECN,
     _In_ BOOLEAN AckElicitingPayload
     )
 {
@@ -132,16 +130,34 @@ QuicAckTrackerAckPacket(
 
     QuicTraceLogVerbose(
         PacketRxMarkedForAck,
-        "[%c][RX][%llu] Marked for ACK",
+        "[%c][RX][%llu] Marked for ACK (ECN=%hhu)",
         PtkConnPre(Connection),
-        PacketNumber);
+        PacketNumber,
+        ECN);
 
     BOOLEAN NewLargestPacketNumber =
         PacketNumber == QuicRangeGetMax(&Tracker->PacketNumbersToAck);
     if (NewLargestPacketNumber) {
         Tracker->LargestPacketNumberRecvTime = QuicTimeUs64();
     }
 
+    switch (ECN) {
+        case QUIC_ECN_ECT_0:
+            Tracker->NonZeroRecvECN = TRUE;
+            Tracker->ReceivedECN.ECT_0_Count++;
+            break;
+        case QUIC_ECN_ECT_1:
+            Tracker->NonZeroRecvECN = TRUE;
+            Tracker->ReceivedECN.ECT_1_Count++;
+            break;
+        case QUIC_ECN_CE:
+            Tracker->NonZeroRecvECN = TRUE;
+            Tracker->ReceivedECN.CE_Count++;
+            break;
+        default:
+            break;
+    }
+
     Tracker->AlreadyWrittenAckFrame = FALSE;
 
     if (!AckElicitingPayload) {
@@ -211,7 +227,9 @@ QuicAckTrackerAckFrameEncode(
     if (!QuicAckFrameEncode(
             &Tracker->PacketNumbersToAck,
             AckDelay,
-            NULL, // No ECN right now.
+            Tracker->NonZeroRecvECN ?
+                &Tracker->ReceivedECN :
+                NULL,
             &Builder->DatagramLength,
             (uint16_t)Builder->Datagram->Length - Builder->EncryptionOverhead,
             Builder->Datagram->Buffer)) {

src/core/ack_tracker.h

@@ -21,6 +21,11 @@ typedef struct QUIC_ACK_TRACKER {
     //
     QUIC_RANGE PacketNumbersToAck;
 
+    //
+    // The current count of recieved ECNs
+    //
+    QUIC_ACK_ECN_EX ReceivedECN;
+
     //
     // The largest packet number we have sent an ACK for.
     //
@@ -40,7 +45,12 @@ typedef struct QUIC_ACK_TRACKER {
     // Indicates an ACK frame has already been written for all the currently
     // queued packet numbers.
     //
-    BOOLEAN AlreadyWrittenAckFrame;
+    BOOLEAN AlreadyWrittenAckFrame : 1;
+
+    //
+    // Indicates that we have received a non-zero ECN type.
+    //
+    BOOLEAN NonZeroRecvECN : 1;
 
 } QUIC_ACK_TRACKER;
 
@@ -89,6 +99,7 @@ void
 QuicAckTrackerAckPacket(
     _Inout_ QUIC_ACK_TRACKER* Tracker,
     _In_ uint64_t PacketNumber,
+    _In_ QUIC_ECN_TYPE ECN,
     _In_ BOOLEAN AckElicitingPayload
     );
 

src/core/connection.c

@@ -3779,7 +3779,8 @@ BOOLEAN
 QuicConnRecvFrames(
     _In_ QUIC_CONNECTION* Connection,
     _In_ QUIC_PATH* Path,
-    _In_ QUIC_RECV_PACKET* Packet
+    _In_ QUIC_RECV_PACKET* Packet,
+    _In_ QUIC_ECN_TYPE ECN
     )
 {
     BOOLEAN AckPacketImmediately = FALSE; // Allows skipping delayed ACK timer.
@@ -4554,6 +4555,7 @@ QuicConnRecvFrames(
         QuicAckTrackerAckPacket(
             &Connection->Packets[EncryptLevel]->AckTracker,
             Packet->PacketNumber,
+            ECN,
             AckPacketImmediately);
     }
 
@@ -4743,11 +4745,12 @@ QuicConnRecvDatagramBatch(
 
     for (uint8_t i = 0; i < BatchCount; ++i) {
         QUIC_DBG_ASSERT(Datagrams[i]->Allocated);
+        QUIC_ECN_TYPE ECN = QUIC_ECN_FROM_TOS(Datagrams[i]->TypeOfService);
         Packet = QuicDataPathRecvDatagramToRecvPacket(Datagrams[i]);
         if (QuicConnRecvPrepareDecrypt(
                 Connection, Packet, HpMask + i * QUIC_HP_SAMPLE_LENGTH) &&
             QuicConnRecvDecryptAndAuthenticate(Connection, Path, Packet) &&
-            QuicConnRecvFrames(Connection, Path, Packet)) {
+            QuicConnRecvFrames(Connection, Path, Packet, ECN)) {
 
             QuicConnRecvPostProcessing(Connection, &Path, Packet);
             RecvState->ResetIdleTimeout |= Packet->CompletelyValid;

src/core/frame.c

@@ -130,7 +130,7 @@ QuicAckEcnEncode(
 {
     uint16_t RequiredLength =
         QuicVarIntSize(Ecn->ECT_0_Count) +
-        QuicVarIntSize(Ecn->ECT_0_Count) +
+        QuicVarIntSize(Ecn->ECT_1_Count) +
         QuicVarIntSize(Ecn->CE_Count);
 
     if (BufferLength < *Offset + RequiredLength) {
@@ -139,7 +139,7 @@ QuicAckEcnEncode(
 
     Buffer = Buffer + *Offset;
     Buffer = QuicVarIntEncode(Ecn->ECT_0_Count, Buffer);
-    Buffer = QuicVarIntEncode(Ecn->ECT_0_Count, Buffer);
+    Buffer = QuicVarIntEncode(Ecn->ECT_1_Count, Buffer);
     Buffer = QuicVarIntEncode(Ecn->CE_Count, Buffer);
     *Offset += RequiredLength;
 

src/inc/quic_datapath.h

@@ -41,6 +41,21 @@ extern "C" {
 //
 #define QUIC_UDP_HEADER_SIZE 8
 
+typedef enum QUIC_ECN_TYPE {
+
+    QUIC_ECN_NON_ECT = 0x0, // Non ECN-Capable Transport, Non-ECT
+    QUIC_ECN_ECT_0   = 0x1, // ECN Capable Transport, ECT(0)
+    QUIC_ECN_ECT_1   = 0x2, // ECN Capable Transport, ECT(1)
+    QUIC_ECN_CE      = 0x3  // Congestion Encountered, CE
+
+} QUIC_ECN_TYPE;
+
+//
+// Helper to get the ECN type from the Type of Service field of a recieved
+// datagram.
+//
+#define QUIC_ECN_FROM_TOS(ToS) (QUIC_ECN_TYPE)((ToS) & 0x3)
+
 //
 // The minimum allowed IP MTU for QUIC.
 //
@@ -159,6 +174,12 @@ typedef struct QUIC_RECV_DATAGRAM {
     //
     uint8_t PartitionIndex;
 
+    //
+    // The Type of Service (ToS) field of the IPv4 header or Traffic Class field
+    // of the IPv6 header.
+    //
+    uint8_t TypeOfService;
+
     //
     // Flags.
     //

src/manifest/clog.sidecar

@@ -19779,10 +19779,6 @@
   },
   "ModuleUniqueness": {
     "TraceInformation": [
-      {
-        "UniquenessHash": "e0cfb1a0-1258-6f19-06e3-1c55dc984679",
-        "TraceID": "PacketRxMarkedForAck"
-      },
       {
         "UniquenessHash": "92b1bb9f-afd4-62fa-3fb6-1021c09c5916",
         "TraceID": "ApiEnter"
@@ -21778,6 +21774,10 @@
       {
         "UniquenessHash": "43482b75-cdcb-d2cd-f082-c1928bc7864d",
         "TraceID": "PeerPreferredAddress"
+      },
+      {
+        "UniquenessHash": "bb7402a7-ba47-dbce-71f2-fbbd659eb0ff",
+        "TraceID": "PacketRxMarkedForAck"
       }
     ]
   }

src/platform/datapath_linux.c

@@ -1240,6 +1240,7 @@ QuicSocketContextRecvComplete(
     RecvPacket->BufferLength = BytesTransferred;
 
     RecvPacket->PartitionIndex = ProcContext->Index;
+    RecvPacket->TypeOfService = 0; // TODO - Support ToS/ECN
 
     QUIC_DBG_ASSERT(SocketContext->Binding->Datapath->RecvHandler);
     SocketContext->Binding->Datapath->RecvHandler(

src/platform/datapath_winkernel.c

@@ -2050,6 +2050,7 @@ QuicDataPathSocketReceive(
             QUIC_DBG_ASSERT(Datagram != NULL);
             Datagram->Next = NULL;
             Datagram->PartitionIndex = (uint8_t)CurProcNumber;
+            Datagram->TypeOfService = 0; // TODO - Support ToS/ECN
             Datagram->Allocated = TRUE;
             Datagram->QueuedOnConnection = FALSE;
 

src/platform/datapath_winuser.c

@@ -2016,6 +2016,7 @@ QuicDataPathRecvComplete(
             Datagram->BufferLength = MessageLength;
             Datagram->Tuple = &RecvContext->Tuple;
             Datagram->PartitionIndex = (uint8_t)ProcContext->Index;
+            Datagram->TypeOfService = 0; // TODO - Support ToS/ECN
             Datagram->Allocated = TRUE;
             Datagram->QueuedOnConnection = FALSE;