Add ToS field to ReceivedUdpPacket

Summary: Adds new field `tosValue` to  ReceivedUdpPacket so it is accessible in the rest of the read path.

Reviewed By: kvtsoy

Differential Revision: D54912161

fbshipit-source-id: ea4714fa2374d38e915fc850387e1094d1fb8adf

quic/api/QuicTransportBase.cpp

@@ -1877,6 +1877,7 @@ void QuicTransportBase::onNetworkData(
                 Builder()
                     .setPacketReceiveTime(packet.timings.receiveTimePoint)
                     .setPacketNumBytes(packet.buf.chainLength())
+                    .setPacketTos(packet.tosValue)
                     .build());
       }
 

quic/api/test/QuicTransportBaseTest.cpp

@@ -404,19 +404,19 @@ class TestQuicTransport
       folly::Optional<StreamGroupId> groupId = folly::none) {
     auto buf = encodeStreamBuffer(id, std::move(data), std::move(groupId));
     SocketAddress addr("127.0.0.1", 1000);
-    onNetworkData(addr, NetworkData(std::move(buf), Clock::now()));
+    onNetworkData(addr, NetworkData(std::move(buf), Clock::now(), 0));
   }
 
   void addCryptoData(StreamBuffer data) {
     auto buf = encodeCryptoBuffer(std::move(data));
     SocketAddress addr("127.0.0.1", 1000);
-    onNetworkData(addr, NetworkData(std::move(buf), Clock::now()));
+    onNetworkData(addr, NetworkData(std::move(buf), Clock::now(), 0));
   }
 
   void addMaxStreamsFrame(MaxStreamsFrame frame) {
     auto buf = encodeMaxStreamsFrame(frame);
     SocketAddress addr("127.0.0.1", 1000);
-    onNetworkData(addr, NetworkData(std::move(buf), Clock::now()));
+    onNetworkData(addr, NetworkData(std::move(buf), Clock::now(), 0));
   }
 
   void addStreamReadError(StreamId id, QuicErrorCode ex) {
@@ -432,7 +432,7 @@ class TestQuicTransport
   void addDatagram(Buf data, TimePoint recvTime = Clock::now()) {
     auto buf = encodeDatagramFrame(std::move(data));
     SocketAddress addr("127.0.0.1", 1000);
-    onNetworkData(addr, NetworkData(std::move(buf), recvTime));
+    onNetworkData(addr, NetworkData(std::move(buf), recvTime, 0));
   }
 
   void closeStream(StreamId id) {
@@ -477,7 +477,7 @@ class TestQuicTransport
     auto buf = encodeStreamBuffer(
         id,
         StreamBuffer(IOBuf::create(0), stream->maxOffsetObserved + 1, true));
-    auto networkData = NetworkData(std::move(buf), Clock::now());
+    auto networkData = NetworkData(std::move(buf), Clock::now(), 0);
     onNetworkData(addr, std::move(networkData));
   }
 

quic/api/test/QuicTransportTest.cpp

@@ -1440,7 +1440,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
   transport_->getConnectionState().streamManager->addClosed(id);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_CALL(*cb1, closeStarted(transport_.get(), _));
   EXPECT_CALL(*cb2, closeStarted(transport_.get(), _));
@@ -1484,7 +1484,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
   transport_->getConnectionState().streamManager->addClosed(id);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_CALL(*cb1, closeStarted(transport_.get(), _));
   EXPECT_CALL(*cb2, closeStarted(transport_.get(), _));
@@ -1528,7 +1528,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
   transport_->getConnectionState().streamManager->addClosed(id);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_CALL(*cb1, closeStarted(transport_.get(), _));
   EXPECT_CALL(*cb2, closeStarted(transport_.get(), _));
@@ -1571,7 +1571,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalRemoteOpenClose) {
   transport_->getConnectionState().streamManager->addClosed(id);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_CALL(*cb1, closeStarted(transport_.get(), _));
   EXPECT_CALL(*cb2, closeStarted(transport_.get(), _));
@@ -2804,7 +2804,7 @@ TEST_F(QuicTransportTest, NonWritableStreamAPI) {
   EXPECT_CALL(writeCallback_, onStreamWriteReady(streamState->id, _)).Times(0);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   // Check that write-side APIs return an error
   auto res2 = transport_->notifyPendingWriteOnStream(streamId, &writeCallback_);
@@ -3072,7 +3072,7 @@ TEST_F(QuicTransportTest, FlowControlCallbacks) {
       .WillOnce(Invoke([&](auto) { transport_->createBidirectionalStream(); }));
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_FALSE(conn.streamManager->popFlowControlUpdated().has_value());
 }
@@ -3985,7 +3985,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteConnAsync) {
   EXPECT_CALL(writeCallback_, onConnectionWriteReady(_));
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteConnBufferFreeUpSpace) {
@@ -4011,7 +4011,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteConnBufferFreeUpSpace) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NoPacingTimerNoPacing) {
@@ -4066,7 +4066,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteConnBufferUseTotalSpace) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteConnBufferOveruseSpace) {
@@ -4090,7 +4090,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteConnBufferOveruseSpace) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(
@@ -4125,7 +4125,7 @@ TEST_F(
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncConnBlocked) {
@@ -4143,7 +4143,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncConnBlocked) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   EXPECT_CALL(writeCallback_, onStreamWriteReady(stream->id, _));
 
@@ -4155,7 +4155,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncConnBlocked) {
       num);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteStreamWritableBytesBackpressure) {
@@ -4177,7 +4177,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamWritableBytesBackpressure) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   auto mockCongestionController =
       std::make_unique<NiceMock<MockCongestionController>>();
@@ -4200,7 +4200,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamWritableBytesBackpressure) {
       num);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncStreamBlocked) {
@@ -4217,7 +4217,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncStreamBlocked) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 
   PacketNum num = 10;
   handleStreamWindowUpdate(
@@ -4227,7 +4227,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamAsyncStreamBlocked) {
 
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteConnTwice) {
@@ -4297,7 +4297,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteConnDuringClose) {
       num);
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, NotifyPendingWriteStreamDuringClose) {
@@ -4326,7 +4326,7 @@ TEST_F(QuicTransportTest, NotifyPendingWriteStreamDuringClose) {
       .WillOnce(Invoke([&](auto, auto) { transport_->close(folly::none); }));
   transport_->onNetworkData(
       SocketAddress("::1", 10000),
-      NetworkData(IOBuf::copyBuffer("fake data"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
 }
 
 TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
@@ -4450,7 +4450,7 @@ TEST_F(QuicTransportTest, CancelAckTimeout) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = false;
   transport_->onNetworkData(
       SocketAddress("::1", 10128),
-      NetworkData(IOBuf::copyBuffer("MTA New York Service"), Clock::now()));
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
   EXPECT_FALSE(transport_->getAckTimeout()->isTimerCallbackScheduled());
 }
 
@@ -4461,8 +4461,7 @@ TEST_F(QuicTransportTest, ScheduleAckTimeout) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = true;
   transport_->onNetworkData(
       SocketAddress("::1", 10003),
-      NetworkData(
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
-          IOBuf::copyBuffer("Never on time, always timeout"), Clock::now()));
   EXPECT_TRUE(transport_->getAckTimeout()->isTimerCallbackScheduled());
   EXPECT_NEAR(
       transport_->getAckTimeout()->getTimerCallbackTimeRemaining().count(),
@@ -4476,8 +4475,7 @@ TEST_F(QuicTransportTest, ScheduleAckTimeoutSRTTFactor) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = true;
   transport_->onNetworkData(
       SocketAddress("::1", 10003),
-      NetworkData(
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
-          IOBuf::copyBuffer("Never on time, always timeout"), Clock::now()));
   EXPECT_TRUE(transport_->getAckTimeout()->isTimerCallbackScheduled());
   EXPECT_NEAR(
       transport_->getAckTimeout()->getTimerCallbackTimeRemaining().count(),
@@ -4495,8 +4493,7 @@ TEST_F(QuicTransportTest, ScheduleAckTimeoutAckFreq) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = true;
   transport_->onNetworkData(
       SocketAddress("::1", 10003),
-      NetworkData(
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
-          IOBuf::copyBuffer("Never on time, always timeout"), Clock::now()));
   EXPECT_TRUE(transport_->getAckTimeout()->isTimerCallbackScheduled());
   EXPECT_NEAR(
       transport_->getAckTimeout()->getTimerCallbackTimeRemaining().count(),
@@ -4512,8 +4509,7 @@ TEST_F(QuicTransportTest, ScheduleAckTimeoutFromMaxAckDelay) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = true;
   transport_->onNetworkData(
       SocketAddress("::1", 10003),
-      NetworkData(
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
-          IOBuf::copyBuffer("Never on time, always timeout"), Clock::now()));
   EXPECT_TRUE(transport_->getAckTimeout()->isTimerCallbackScheduled());
   EXPECT_NEAR(
       transport_->getAckTimeout()->getTimerCallbackTimeRemaining().count(),
@@ -4527,8 +4523,7 @@ TEST_F(QuicTransportTest, CloseTransportCancelsAckTimeout) {
   transport_->getConnectionState().pendingEvents.scheduleAckTimeout = true;
   transport_->onNetworkData(
       SocketAddress("::1", 10003),
-      NetworkData(
+      NetworkData(ReceivedUdpPacket(IOBuf::copyBuffer("fake data"))));
-          IOBuf::copyBuffer("Never on time, always timeout"), Clock::now()));
   EXPECT_TRUE(transport_->getAckTimeout()->isTimerCallbackScheduled());
   // We need to send some packets, otherwise loss timer won't be scheduled
   auto stream = transport_->createBidirectionalStream().value();

quic/api/test/QuicTypedTransportTest.cpp

@@ -1723,6 +1723,11 @@ struct ReceivedUdpPacketMatcherBuilder {
     maybeExpectedPacketNumBytes = expectedPacketNumBytes;
     return std::move(*this);
   }
+  Builder&& setExpectedTosValue(const uint8_t expectedTosValue) {
+    maybeExpectedTosValue = expectedTosValue;
+    return std::move(*this);
+  }
+
   auto build() && {
     CHECK(maybeExpectedPacketReceiveTime.has_value());
     const auto& packetReceiveTime = *maybeExpectedPacketReceiveTime;
@@ -1730,6 +1735,9 @@ struct ReceivedUdpPacketMatcherBuilder {
     CHECK(maybeExpectedPacketNumBytes.has_value());
     const auto& packetNumBytes = *maybeExpectedPacketNumBytes;
 
+    CHECK(maybeExpectedTosValue.has_value());
+    const auto& packetTosValue = *maybeExpectedTosValue;
+
     if constexpr (std::is_base_of_v<T, QuicClientTransportTestBase>) {
       return testing::AllOf(
           // client does not currently support socket RX timestamps, so we
@@ -1739,12 +1747,20 @@ struct ReceivedUdpPacketMatcherBuilder {
               testing::AnyOf(
                   testing::Eq(packetReceiveTime),
                   testing::Ge(TimePoint::clock::now()))),
-          testing::Field(&Obj::packetNumBytes, testing::Eq(packetNumBytes)));
+          testing::Field(&Obj::packetNumBytes, testing::Eq(packetNumBytes)),
+          testing::Field(&Obj::packetTos, testing::Eq(packetTosValue)));
     } else if constexpr (std::is_base_of_v<T, QuicServerTransportTestBase>) {
       return testing::AllOf(
           testing::Field(
-              &Obj::packetReceiveTime, testing::Eq(packetReceiveTime)),
+              "packetReceiveTime",
-          testing::Field(&Obj::packetNumBytes, testing::Eq(packetNumBytes)));
+              &Obj::packetReceiveTime,
+              testing::Eq(packetReceiveTime)),
+          testing::Field(
+              "packetNumBytes",
+              &Obj::packetNumBytes,
+              testing::Eq(packetNumBytes)),
+          testing::Field(
+              "packetTos", &Obj::packetTos, testing::Eq(packetTosValue)));
     } else {
       FAIL(); // unhandled typed test
     }
@@ -1753,6 +1769,7 @@ struct ReceivedUdpPacketMatcherBuilder {
 
   folly::Optional<TimePoint> maybeExpectedPacketReceiveTime;
   folly::Optional<uint64_t> maybeExpectedPacketNumBytes;
+  folly::Optional<uint8_t> maybeExpectedTosValue;
 };
 
 template <typename T>
@@ -4951,6 +4968,7 @@ TYPED_TEST(
       this->buildPeerPacketWithStreamData(streamId, buildRandomInputData(100));
   const auto pkt1RecvTime = TimePoint::clock::now();
   const auto pkt1NumBytes = pkt1->computeChainDataLength();
+  const uint8_t packetTosValue = kEcnECT0;
   {
     const auto matcher = testing::AllOf(
         testing::Field(
@@ -4963,13 +4981,14 @@ TYPED_TEST(
             testing::ElementsAre(ReceivedUdpPacketMatcherBuilder<TypeParam>()
                                      .setExpectedPacketReceiveTime(pkt1RecvTime)
                                      .setExpectedPacketNumBytes(pkt1NumBytes)
+                                     .setExpectedTosValue(packetTosValue)
                                      .build())));
 
     EXPECT_CALL(*obs1, packetsReceived(_, _)).Times(0);
     EXPECT_CALL(*obs2, packetsReceived(transport, matcher));
     EXPECT_CALL(*obs3, packetsReceived(transport, matcher));
   }
-  this->deliverPacket(std::move(pkt1), pkt1RecvTime);
+  this->deliverPacket(std::move(pkt1), pkt1RecvTime, packetTosValue);
 
   // deliver pkt2 with stream data from the remote
   auto pkt2 =
@@ -4989,13 +5008,14 @@ TYPED_TEST(
             testing::ElementsAre(ReceivedUdpPacketMatcherBuilder<TypeParam>()
                                      .setExpectedPacketReceiveTime(pkt2RecvTime)
                                      .setExpectedPacketNumBytes(pkt2NumBytes)
+                                     .setExpectedTosValue(packetTosValue)
                                      .build())));
 
     EXPECT_CALL(*obs1, packetsReceived(_, _)).Times(0);
     EXPECT_CALL(*obs2, packetsReceived(transport, matcher));
     EXPECT_CALL(*obs3, packetsReceived(transport, matcher));
   }
-  this->deliverPacket(std::move(pkt2), pkt2RecvTime);
+  this->deliverPacket(std::move(pkt2), pkt2RecvTime, packetTosValue);
 
   this->destroyTransport();
 }
@@ -5045,33 +5065,46 @@ TYPED_TEST(
   pktBatch1.emplace_back(std::move(pkt2));
   const auto pktBatch1RecvTime = TimePoint::clock::now();
   const auto pktBatch1NumBytes = pkt1NumBytes + pkt2NumBytes;
+
+  const uint8_t packetTosValue = kEcnECT1;
   {
     const auto matcher = testing::AllOf(
         testing::Field(
-            &Event::receiveLoopTime, testing::Ge(TimePoint::clock::now())),
+            "receiveLoopTime",
-        testing::Field(&Event::numPacketsReceived, testing::Eq(2)),
+            &Event::receiveLoopTime,
+            testing::Ge(TimePoint::clock::now())),
         testing::Field(
-            &Event::numBytesReceived, testing::Eq(pktBatch1NumBytes)),
+            "numPacketsReceived", &Event::numPacketsReceived, testing::Eq(2)),
-        testing::Field(&Event::receivedPackets, testing::SizeIs(2)),
         testing::Field(
+            "numBytesReceived",
+            &Event::numBytesReceived,
+            testing::Eq(pktBatch1NumBytes)),
+        testing::Field(
+            "receivedPacketsCount",
+            &Event::receivedPackets,
+            testing::SizeIs(2)),
+        testing::Field(
+            "receivedPacketsElements",
             &Event::receivedPackets,
             testing::ElementsAre(
                 // pkt1
                 ReceivedUdpPacketMatcherBuilder<TypeParam>()
                     .setExpectedPacketReceiveTime(pktBatch1RecvTime)
                     .setExpectedPacketNumBytes(pkt1NumBytes)
+                    .setExpectedTosValue(packetTosValue)
                     .build(),
                 // pkt2
                 ReceivedUdpPacketMatcherBuilder<TypeParam>()
                     .setExpectedPacketReceiveTime(pktBatch1RecvTime)
                     .setExpectedPacketNumBytes(pkt2NumBytes)
+                    .setExpectedTosValue(packetTosValue)
                     .build())));
 
     EXPECT_CALL(*obs1, packetsReceived(_, _)).Times(0);
     EXPECT_CALL(*obs2, packetsReceived(transport, matcher));
     EXPECT_CALL(*obs3, packetsReceived(transport, matcher));
   }
-  this->deliverPackets(std::move(pktBatch1), pktBatch1RecvTime);
+  this->deliverPackets(std::move(pktBatch1), pktBatch1RecvTime, packetTosValue);
 
   // deliver pkt3 and pkt4 at same time with stream data from the remote
   auto pkt3 =
@@ -5103,18 +5136,20 @@ TYPED_TEST(
                 ReceivedUdpPacketMatcherBuilder<TypeParam>()
                     .setExpectedPacketReceiveTime(pktBatch2RecvTime)
                     .setExpectedPacketNumBytes(pkt3NumBytes)
+                    .setExpectedTosValue(packetTosValue)
                     .build(),
                 // pkt2
                 ReceivedUdpPacketMatcherBuilder<TypeParam>()
                     .setExpectedPacketReceiveTime(pktBatch2RecvTime)
                     .setExpectedPacketNumBytes(pkt4NumBytes)
+                    .setExpectedTosValue(packetTosValue)
                     .build())));
 
     EXPECT_CALL(*obs1, packetsReceived(_, _)).Times(0);
     EXPECT_CALL(*obs2, packetsReceived(transport, matcher));
     EXPECT_CALL(*obs3, packetsReceived(transport, matcher));
   }
-  this->deliverPackets(std::move(pktBatch2), pktBatch2RecvTime);
+  this->deliverPackets(std::move(pktBatch2), pktBatch2RecvTime, packetTosValue);
 
   this->destroyTransport();
 }

quic/api/test/QuicTypedTransportTestUtil.h

@@ -160,7 +160,8 @@ class QuicTypedTransportTestBase : protected QuicTransportTestClass {
                 pnSpace,
                 oldestOutstandingPkt->packet.header.getPacketSequenceNum(),
                 newestOutstandingPkt->packet.header.getPacketSequenceNum()),
-            recvTime),
+            recvTime,
+            0),
         false /* loopForWrites */);
   }
 
@@ -180,9 +181,10 @@ class QuicTypedTransportTestBase : protected QuicTransportTestClass {
   void deliverPacket(
       Buf&& buf,
       quic::TimePoint recvTime = TimePoint::clock::now(),
+      uint8_t tosValue = 0,
       bool loopForWrites = true) {
     QuicTransportTestClass::deliverData(
-        NetworkData(std::move(buf), recvTime), loopForWrites);
+        NetworkData(std::move(buf), recvTime, tosValue), loopForWrites);
   }
 
   /**
@@ -190,8 +192,10 @@ class QuicTypedTransportTestBase : protected QuicTransportTestClass {
    */
   void deliverPacketNoWrites(
       Buf&& buf,
-      quic::TimePoint recvTime = TimePoint::clock::now()) {
+      quic::TimePoint recvTime = TimePoint::clock::now(),
-    deliverPacket(std::move(buf), recvTime, false /* loopForWrites */);
+      uint8_t tosValue = 0) {
+    deliverPacket(
+        std::move(buf), recvTime, tosValue, false /* loopForWrites */);
   }
 
   /**
@@ -200,9 +204,20 @@ class QuicTypedTransportTestBase : protected QuicTransportTestClass {
   void deliverPackets(
       std::vector<Buf>&& bufs,
       quic::TimePoint recvTime = TimePoint::clock::now(),
+      uint8_t tosValue = 0,
       bool loopForWrites = true) {
-    QuicTransportTestClass::deliverData(
+    auto networkData = NetworkData();
-        NetworkData(std::move(bufs), recvTime), loopForWrites);
+    // This overrides the timing in added packets.
+    networkData.setReceiveTimePoint(recvTime);
+    for (auto& buf : bufs) {
+      auto udpPacket = ReceivedUdpPacket(
+          std::move(buf),
+          ReceivedUdpPacket::Timings{}, // NetworkData receiveTimePoint will
+                                        // override this
+          tosValue);
+      networkData.addPacket(std::move(udpPacket));
+    }
+    QuicTransportTestClass::deliverData(std::move(networkData), loopForWrites);
   }
 
   /**

quic/client/QuicClientTransport.cpp

@@ -268,7 +268,9 @@ void QuicClientTransport::processUdpPacketData(
         : clientConn_->pendingHandshakeData;
     pendingData.emplace_back(
         ReceivedUdpPacket(
-            std::move(cipherUnavailable->packet), udpPacket.timings),
+            std::move(cipherUnavailable->packet),
+            udpPacket.timings,
+            udpPacket.tosValue),
         peer);
     if (conn_->qLogger) {
       conn_->qLogger->addPacketBuffered(
@@ -1190,7 +1192,9 @@ void QuicClientTransport::recvMsg(
     msg.msg_iovlen = 1;
 #ifdef FOLLY_HAVE_MSG_ERRQUEUE
     bool useGRO = sock.getGRO() > 0;
-    bool checkCmsgs = useGRO || sock.getTimestamping() > 0 || sock.getRecvTos();
+    bool useTs = sock.getTimestamping() > 0;
+    bool recvTos = sock.getRecvTos();
+    bool checkCmsgs = useGRO || useTs || recvTos;
     char control
         [QuicAsyncUDPSocket::ReadCallback::OnDataAvailableParams::kCmsgSpace] =
             {};
@@ -1266,18 +1270,21 @@ void QuicClientTransport::recvMsg(
 
           offset += params.gro;
           remaining -= params.gro;
-          networkData.addPacket(ReceivedUdpPacket(std::move(tmp)));
+          networkData.addPacket(ReceivedUdpPacket(
+              std::move(tmp), ReceivedUdpPacket::Timings{}, params.tos));
         } else {
           // do not clone the last packet
           // start at offset, use all the remaining data
           readBuffer->trimStart(offset);
           DCHECK_EQ(readBuffer->length(), remaining);
           remaining = 0;
-          networkData.addPacket(ReceivedUdpPacket(std::move(readBuffer)));
+          networkData.addPacket(ReceivedUdpPacket(
+              std::move(readBuffer), ReceivedUdpPacket::Timings{}, params.tos));
         }
       }
     } else {
-      networkData.addPacket(ReceivedUdpPacket(std::move(readBuffer)));
+      networkData.addPacket(ReceivedUdpPacket(
+          std::move(readBuffer), ReceivedUdpPacket::Timings{}, params.tos));
     }
     maybeQlogDatagram(bytesRead);
   }
@@ -1296,7 +1303,9 @@ void QuicClientTransport::recvMmsg(
   int flags = 0;
 #ifdef FOLLY_HAVE_MSG_ERRQUEUE
   bool useGRO = sock.getGRO() > 0;
-  bool checkCmsgs = useGRO || sock.getTimestamping() > 0 || sock.getRecvTos();
+  bool useTs = sock.getTimestamping() > 0;
+  bool recvTos = sock.getRecvTos();
+  bool checkCmsgs = useGRO || useTs || recvTos;
   std::vector<std::array<
       char,
       QuicAsyncUDPSocket::ReadCallback::OnDataAvailableParams::kCmsgSpace>>
@@ -1411,18 +1420,21 @@ void QuicClientTransport::recvMmsg(
 
           offset += params.gro;
           remaining -= params.gro;
-          networkData.addPacket(ReceivedUdpPacket(std::move(tmp)));
+          networkData.addPacket(ReceivedUdpPacket(
+              std::move(tmp), ReceivedUdpPacket::Timings{}, params.tos));
         } else {
           // do not clone the last packet
           // start at offset, use all the remaining data
           readBuffer->trimStart(offset);
           DCHECK_EQ(readBuffer->length(), remaining);
           remaining = 0;
-          networkData.addPacket(ReceivedUdpPacket(std::move(readBuffer)));
+          networkData.addPacket(ReceivedUdpPacket(
+              std::move(readBuffer), ReceivedUdpPacket::Timings{}, params.tos));
         }
       }
     } else {
-      networkData.addPacket(ReceivedUdpPacket(std::move(readBuffer)));
+      networkData.addPacket(ReceivedUdpPacket(
+          std::move(readBuffer), ReceivedUdpPacket::Timings{}, params.tos));
     }
 
     maybeQlogDatagram(bytesRead);

quic/common/NetworkData.h

@@ -56,21 +56,30 @@ struct ReceivedUdpPacket {
 
   ReceivedUdpPacket() = default;
   explicit ReceivedUdpPacket(Buf&& bufIn) : buf(std::move(bufIn)) {}
-  ReceivedUdpPacket(Buf&& bufIn, Timings timingsIn)
+  ReceivedUdpPacket(Buf&& bufIn, Timings timingsIn, uint8_t tosValueIn)
-      : buf(std::move(bufIn)), timings(std::move(timingsIn)) {}
+      : buf(std::move(bufIn)),
+        timings(std::move(timingsIn)),
+        tosValue(tosValueIn) {}
 
   BufQueue buf;
   Timings timings;
+
+  // ToS / TClass value
+  uint8_t tosValue{0};
 };
 
 struct NetworkData {
   NetworkData() = default;
-  NetworkData(Buf&& buf, const TimePoint& receiveTimePointIn)
+  NetworkData(
+      Buf&& buf,
+      const TimePoint& receiveTimePointIn,
+      uint8_t tosValueIn)
       : receiveTimePoint_(receiveTimePointIn) {
     if (buf) {
       totalData_ = buf->computeChainDataLength();
       packets_.emplace_back(std::move(buf));
       packets_.back().timings.receiveTimePoint = receiveTimePointIn;
+      packets_.back().tosValue = tosValueIn;
     }
   }
 

quic/common/udpsocket/QuicAsyncUDPSocketImpl.cpp

@@ -167,7 +167,8 @@ QuicAsyncUDPSocket::RecvResult QuicAsyncUDPSocketImpl::recvmmsgNetworkData(
 
           offset += params.gro;
           remaining -= params.gro;
-          networkData.addPacket(ReceivedUdpPacket(std::move(tmp), timings));
+          networkData.addPacket(
+              ReceivedUdpPacket(std::move(tmp), timings, params.tos));
         } else {
           // do not clone the last packet
           // start at offset, use all the remaining data
@@ -175,11 +176,12 @@ QuicAsyncUDPSocket::RecvResult QuicAsyncUDPSocketImpl::recvmmsgNetworkData(
           DCHECK_EQ(readBuffer->length(), remaining);
           remaining = 0;
           networkData.addPacket(
-              ReceivedUdpPacket(std::move(readBuffer), timings));
+              ReceivedUdpPacket(std::move(readBuffer), timings, params.tos));
         }
       }
     } else {
-      networkData.addPacket(ReceivedUdpPacket(std::move(readBuffer), timings));
+      networkData.addPacket(
+          ReceivedUdpPacket(std::move(readBuffer), timings, params.tos));
     }
   }
 

quic/fizz/client/test/QuicClientTransportTestUtil.h

@@ -384,12 +384,22 @@ class QuicClientTransportTestBase : public virtual testing::Test {
   virtual ~QuicClientTransportTestBase() = default;
 
   struct TestReadData {
-    std::unique_ptr<folly::IOBuf> data;
+    ReceivedUdpPacket udpPacket;
     folly::SocketAddress addr;
     folly::Optional<int> err;
 
     TestReadData(folly::ByteRange dataIn, folly::SocketAddress addrIn)
-        : data(folly::IOBuf::copyBuffer(dataIn)), addr(std::move(addrIn)) {}
+        : udpPacket(folly::IOBuf::copyBuffer(dataIn)),
+          addr(std::move(addrIn)) {}
+
+    TestReadData(
+        const ReceivedUdpPacket&& udpPacketIn,
+        folly::SocketAddress addrIn)
+        : udpPacket(
+              udpPacketIn.buf.clone(),
+              udpPacketIn.timings,
+              udpPacketIn.tosValue),
+          addr(std::move(addrIn)) {}
 
     explicit TestReadData(int errIn) : err(errIn) {}
   };
@@ -441,8 +451,8 @@ class QuicClientTransportTestBase : public virtual testing::Test {
             errno = *socketReads[0].err;
             return -1;
           }
-          auto testData = std::move(socketReads[0].data);
+          auto& udpPacket = socketReads[0].udpPacket;
-          testData->coalesce();
+          auto testData = std::move(udpPacket.buf.front());
           size_t testDataLen = testData->length();
           memcpy(
               msg->msg_iov[0].iov_base, testData->data(), testData->length());
@@ -451,9 +461,18 @@ class QuicClientTransportTestBase : public virtual testing::Test {
                 static_cast<sockaddr_storage*>(msg->msg_name));
             msg->msg_namelen = msg_len;
           }
+#ifdef FOLLY_HAVE_MSG_ERRQUEUE
+          // Populate ToS control message as IPv6 TClass
+          auto cmsg = CMSG_FIRSTHDR(msg);
+          cmsg->cmsg_level = SOL_IPV6;
+          cmsg->cmsg_type = IPV6_TCLASS;
+          memcpy(
+              CMSG_DATA(cmsg), &udpPacket.tosValue, sizeof(udpPacket.tosValue));
+#endif
           socketReads.pop_front();
           return testDataLen;
         }));
+    ON_CALL(*sock, getRecvTos()).WillByDefault(testing::Return(true));
     EXPECT_EQ(client->getConn().selfConnectionIds.size(), 1);
     EXPECT_EQ(
         client->getConn().selfConnectionIds[0].connId,
@@ -769,15 +788,44 @@ class QuicClientTransportTestBase : public virtual testing::Test {
     deliverData(peer == nullptr ? serverAddr : *peer, data, writes);
   }
 
+  void deliverDataWithoutErrorCheck(
+      const folly::SocketAddress& addr,
+      const ReceivedUdpPacket&& udpPacket,
+      bool writes = true) {
+    ASSERT_TRUE(networkReadCallback);
+    socketReads.emplace_back(std::move(udpPacket), addr);
+    networkReadCallback->onNotifyDataAvailable(*sock);
+    if (writes) {
+      loopForWrites();
+    }
+  }
+
+  void deliverData(
+      const folly::SocketAddress& addr,
+      const ReceivedUdpPacket&& udpPacket,
+      bool writes = true) {
+    deliverDataWithoutErrorCheck(addr, std::move(udpPacket), writes);
+    if (client->getConn().localConnectionError) {
+      bool idleTimeout = false;
+      const LocalErrorCode* localError =
+          client->getConn().localConnectionError->code.asLocalErrorCode();
+      if (localError) {
+        idleTimeout = (*localError == LocalErrorCode::IDLE_TIMEOUT);
+      }
+      if (!idleTimeout) {
+        throw std::runtime_error(
+            toString(client->getConn().localConnectionError->code));
+      }
+    }
+  }
+
   void deliverData(
       NetworkData&& data,
       bool writes = true,
       folly::SocketAddress* peer = nullptr) {
     for (const auto& packet : data.getPackets()) {
       deliverData(
-          peer == nullptr ? serverAddr : *peer,
+          peer == nullptr ? serverAddr : *peer, std::move(packet), writes);
-          packet.buf.clone()->coalesce(),
-          writes);
     }
   }
 

quic/observer/SocketObserverInterface.cpp

@@ -315,6 +315,13 @@ SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket::Builder::
   return std::move(*this);
 }
 
+SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket::Builder&&
+SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket::Builder::
+    setPacketTos(const uint8_t tosIn) {
+  maybePacketTos = tosIn;
+  return std::move(*this);
+}
+
 SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket
 SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket::Builder::
     build() && {
@@ -327,7 +334,8 @@ SocketObserverInterface::PacketsReceivedEvent::ReceivedUdpPacket::
     : packetReceiveTime(
           *CHECK_NOTNULL(builderFields.maybePacketReceiveTime.get_pointer())),
       packetNumBytes(
-          *CHECK_NOTNULL(builderFields.maybePacketNumBytes.get_pointer())) {}
+          *CHECK_NOTNULL(builderFields.maybePacketNumBytes.get_pointer())),
+      packetTos(*CHECK_NOTNULL(builderFields.maybePacketTos.get_pointer())) {}
 
 SocketObserverInterface::PacketsReceivedEvent::Builder&&
 SocketObserverInterface::PacketsReceivedEvent::Builder::setReceiveLoopTime(

quic/observer/SocketObserverInterface.h

@@ -232,15 +232,20 @@ class SocketObserverInterface {
       // Number of bytes in the received packet.
       const uint64_t packetNumBytes;
 
+      // TOS value
+      const uint8_t packetTos;
+
       struct BuilderFields {
         folly::Optional<TimePoint> maybePacketReceiveTime;
         folly::Optional<uint64_t> maybePacketNumBytes;
+        folly::Optional<uint8_t> maybePacketTos;
         explicit BuilderFields() = default;
       };
 
       struct Builder : public BuilderFields {
         Builder&& setPacketReceiveTime(const TimePoint packetReceiveTimeIn);
         Builder&& setPacketNumBytes(const uint64_t packetNumBytesIn);
+        Builder&& setPacketTos(const uint8_t packettos);
         ReceivedUdpPacket build() &&;
         explicit Builder() = default;
       };

quic/samples/echo/EchoTransportServer.h

@@ -89,7 +89,9 @@ class UDPAcceptor : public folly::AsyncUDPSocket::ReadCallback {
       transport_->accept();
     }
 
-    quic::NetworkData networkData(std::move(readBuffer_), packetReceiveTime);
+    ReceivedUdpPacket packet(std::move(readBuffer_));
+    packet.timings.receiveTimePoint = packetReceiveTime;
+    quic::NetworkData networkData(std::move(packet));
 
     transport_->onNetworkData(client, std::move(networkData));
   }

quic/server/QuicServerWorker.cpp

@@ -346,6 +346,7 @@ void QuicServerWorker::onDataAvailable(
     QUIC_STATS(statsCallback_, onRead, len);
     ReceivedUdpPacket udpPacket(std::move(data));
     udpPacket.timings.receiveTimePoint = packetReceiveTime;
+    udpPacket.tosValue = params.tos;
     handleNetworkData(client, udpPacket);
   } else {
     // if we receive a truncated packet
@@ -369,6 +370,7 @@ void QuicServerWorker::onDataAvailable(
         DCHECK_EQ(data->length(), remaining);
         ReceivedUdpPacket udpPacket(std::move(data));
         udpPacket.timings.receiveTimePoint = packetReceiveTime;
+        udpPacket.tosValue = params.tos;
         handleNetworkData(client, udpPacket);
         break;
       }
@@ -383,6 +385,7 @@ void QuicServerWorker::onDataAvailable(
       remaining -= params.gro;
       ReceivedUdpPacket udpPacket(std::move(tmp));
       udpPacket.timings.receiveTimePoint = packetReceiveTime;
+      udpPacket.tosValue = params.tos;
       handleNetworkData(client, udpPacket);
     }
   }

quic/server/state/ServerStateMachine.cpp

@@ -707,7 +707,9 @@ static void handleCipherUnavailable(
     ServerEvents::ReadData pendingReadData;
     pendingReadData.peer = readData.peer;
     pendingReadData.udpPacket = ReceivedUdpPacket(
-        std::move(originalData->packet), readData.udpPacket.timings);
+        std::move(originalData->packet),
+        readData.udpPacket.timings,
+        readData.udpPacket.tosValue);
     pendingData->emplace_back(std::move(pendingReadData));
     VLOG(10) << "Adding pending data to "
              << toString(originalData->protectionType)

quic/server/test/QuicServerTest.cpp

@@ -288,7 +288,7 @@ void QuicServerWorkerTest::createQuicConnectionDuringShedding(
   worker_->dispatchPacketData(
       addr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       version);
 
   const auto& addrMap = worker_->getSrcToTransportMap();
@@ -315,7 +315,7 @@ void QuicServerWorkerTest::createQuicConnection(
   worker_->dispatchPacketData(
       addr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       version);
 
   const auto& addrMap = worker_->getSrcToTransportMap();
@@ -367,7 +367,7 @@ void QuicServerWorkerTest::testSendReset(
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(packet->clone(), Clock::now()),
+      NetworkData(packet->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 }
@@ -422,7 +422,7 @@ TEST_F(QuicServerWorkerTest, SmallPacketTestNoReset) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 }
@@ -457,7 +457,7 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       version);
 
   const auto& addrMap = worker_->getSrcToTransportMap();
@@ -489,7 +489,7 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
   worker_->dispatchPacketData(
       caddr2,
       std::move(routingData2),
-      NetworkData(data2->clone(), Clock::now()),
+      NetworkData(data2->clone(), Clock::now(), 0),
       version);
 
   EXPECT_EQ(addrMap.count(std::make_pair(caddr2, connId2)), 1);
@@ -506,7 +506,7 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
   worker_->dispatchPacketData(
       caddr3,
       std::move(routingData3),
-      NetworkData(data2->clone(), Clock::now()),
+      NetworkData(data2->clone(), Clock::now(), 0),
       version);
 
   EXPECT_EQ(addrMap.count(std::make_pair(caddr3, connId3)), 0);
@@ -543,7 +543,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       version);
 
   const auto& addrMap = worker_->getSrcToTransportMap();
@@ -575,7 +575,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   worker_->dispatchPacketData(
       caddr2,
       std::move(routingData2),
-      NetworkData(data2->clone(), Clock::now()),
+      NetworkData(data2->clone(), Clock::now(), 0),
       version);
 
   EXPECT_EQ(addrMap.count(std::make_pair(caddr2, connId2)), 1);
@@ -592,7 +592,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   worker_->dispatchPacketData(
       caddr3,
       std::move(routingData3),
-      NetworkData(data3->clone(), Clock::now()),
+      NetworkData(data3->clone(), Clock::now(), 0),
       version);
 
   EXPECT_EQ(addrMap.count(std::make_pair(caddr3, connId3)), 0);
@@ -626,7 +626,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   worker_->dispatchPacketData(
       caddr4,
       std::move(routingData4),
-      NetworkData(data4->clone(), Clock::now()),
+      NetworkData(data4->clone(), Clock::now(), 0),
       version);
 
   EXPECT_EQ(addrMap.count(std::make_pair(caddr4, connId4)), 1);
@@ -709,7 +709,7 @@ TEST_F(QuicServerWorkerTest, QuicServerMultipleConnIdsRouting) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData2),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 
@@ -727,7 +727,7 @@ TEST_F(QuicServerWorkerTest, QuicServerMultipleConnIdsRouting) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData3),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 
@@ -827,7 +827,7 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 
@@ -861,7 +861,7 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData2),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 
@@ -898,7 +898,7 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
   worker_->dispatchPacketData(
       clientAddr2,
       std::move(routingData3),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       folly::none);
   eventbase_.loopIgnoreKeepAlive();
 
@@ -944,7 +944,7 @@ TEST_F(QuicServerWorkerTest, InitialPacketTooSmall) {
   worker_->dispatchPacketData(
       kClientAddr,
       std::move(routingData),
-      NetworkData(data->clone(), Clock::now()),
+      NetworkData(data->clone(), Clock::now(), 0),
       version);
   eventbase_.loopIgnoreKeepAlive();
 }
@@ -1099,7 +1099,7 @@ TEST_F(QuicServerWorkerTest, FailToParseConnectionId) {
   // To force dropping path, set initial to false
   RoutingData routingData(
       HeaderForm::Long, false /* isInitial */, false, dstConnId, srcConnId);
-  NetworkData networkData(std::move(packet), Clock::now());
+  NetworkData networkData(std::move(packet), Clock::now(), 0);
 
   EXPECT_CALL(*rawConnIdAlgo, canParseNonConst(_)).WillOnce(Return(true));
   EXPECT_CALL(*rawConnIdAlgo, parseConnectionId(dstConnId))
@@ -1136,7 +1136,7 @@ TEST_F(QuicServerWorkerTest, ConnectionIdTooShortDispatch) {
   }
   auto packet = packetToBuf(std::move(builder).buildPacket());
   RoutingData routingData(HeaderForm::Long, true, false, dstConnId, srcConnId);
-  NetworkData networkData(std::move(packet), Clock::now());
+  NetworkData networkData(std::move(packet), Clock::now(), 0);
   worker_->dispatchPacketData(
       kClientAddr, std::move(routingData), std::move(networkData), version);
   eventbase_.loopIgnoreKeepAlive();
@@ -1164,7 +1164,7 @@ TEST_F(QuicServerWorkerTest, ConnectionIdTooLargeDispatch) {
   }
   auto packet = packetToBuf(std::move(builder).buildPacket());
   RoutingData routingData(HeaderForm::Long, true, false, dstConnId, srcConnId);
-  NetworkData networkData(std::move(packet), Clock::now());
+  NetworkData networkData(std::move(packet), Clock::now(), 0);
   worker_->dispatchPacketData(
       kClientAddr, std::move(routingData), std::move(networkData), version);
   eventbase_.loopIgnoreKeepAlive();
@@ -1510,7 +1510,7 @@ class QuicServerWorkerRetryTest : public QuicServerWorkerTest {
     worker_->dispatchPacketData(
         clientAddr,
         std::move(routingData),
-        NetworkData(initialPacket->clone(), Clock::now()),
+        NetworkData(initialPacket->clone(), Clock::now(), 0),
         version);
     eventbase_.loopIgnoreKeepAlive();
   }
@@ -2283,7 +2283,7 @@ TEST_F(QuicServerTest, DontRouteDataAfterShutdown) {
     EXPECT_CALL(
         *stats,
         onPacketDropped(PacketDropReason(PacketDropReason::SERVER_SHUTDOWN)));
-    NetworkData networkData(folly::IOBuf::copyBuffer("wat"), Clock::now());
+    NetworkData networkData(folly::IOBuf::copyBuffer("wat"), Clock::now(), 0);
     RoutingData routingData(
         HeaderForm::Long,
         true,
@@ -2336,7 +2336,7 @@ TEST_F(QuicServerTest, RouteDataFromDifferentThread) {
       folly::IOBuf::create(kMinInitialPacketSize));
   initialData->append(kMinInitialPacketSize);
   memset(initialData->writableData(), 'd', kMinInitialPacketSize);
-  NetworkData networkData(initialData->clone(), Clock::now());
+  NetworkData networkData(initialData->clone(), Clock::now(), 0);
   RoutingData routingData(
       HeaderForm::Long,
       true,

quic/server/test/QuicServerTransportTestUtil.h

@@ -490,7 +490,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
       folly::SocketAddress* peer = nullptr) {
     data->coalesce();
     deliverDataWithoutErrorCheck(
-        NetworkData(std::move(data), Clock::now()), writes, peer);
+        NetworkData(ReceivedUdpPacket(std::move(data))), writes, peer);
   }
 
   void deliverData(
@@ -517,7 +517,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
       bool writes = true,
       folly::SocketAddress* peer = nullptr) {
     data->coalesce();
-    deliverData(NetworkData(std::move(data), Clock::now()), writes, peer);
+    deliverData(NetworkData(ReceivedUdpPacket(std::move(data))), writes, peer);
   }
 
   void loopForWrites() {