agnosticdev/SpinBitVariance: Observe spin bit from the bridge protocol

Author: agnosticdev

Sources/SwiftNetwork/Protocols/BridgeProtocol.swift

@@ -142,6 +142,7 @@ public struct BridgeDatagramProtocol: NetworkProtocol {
 
         var linkDelay: NetworkDuration = .zero
         var datagramDrops: DatagramDrops? = nil
+        var observeFirstByte: ((UInt8) -> Void)? = nil
 
         private var timerSet = false
         func deliverInboundDataAvailableEvent() {
@@ -275,6 +276,14 @@ public struct BridgeDatagramProtocol: NetworkProtocol {
                 datagrams = remainingDatagrams
             }
             log.datapath("forwarding \(datagrams.count) datagrams to port: \(remotePort)")
+            if let observeFirstByte {
+                datagrams.iterateMutableFrames { frame in
+                    if let bytes = frame.bytes, bytes.byteCount > 0 {
+                        observeFirstByte(bytes[0])
+                    }
+                    return true
+                }
+            }
             remoteInstance.incomingFrames.add(frames: datagrams)
             remoteInstance.deliverInboundDataAvailableEvent()
         }

Sources/SwiftNetwork/QUIC/QUICConnection.swift

@@ -2322,9 +2322,6 @@ public final class QUICConnection: ManyToManyApplicationStreamProtocol,
                     // Reflect the spin bit.
                     let spinValue = packet.spinValue
                     path.spinValue = spinValue
-                    if spinValue {
-                        path.spinValueForTestingSeen = true
-                    }
                 } else {
                     // Spin it!
                     let spinValue = packet.spinValue

Sources/SwiftNetwork/QUIC/QUICPath.swift

@@ -188,7 +188,6 @@ public final class QUICPath: MultiplexingDatagramPath<QUICConnection>, Equatable
         static let isFlowControlled = Flags(rawValue: 1 << 9)
         static let l4sEnabled = Flags(rawValue: 1 << 10)
         static let reportedIdleEvent = Flags(rawValue: 1 << 11)
-        static let spinValueForTestingSeen = Flags(rawValue: 1 << 12)
     }
     private var flags = Flags()
 
@@ -242,10 +241,6 @@ public final class QUICPath: MultiplexingDatagramPath<QUICConnection>, Equatable
         get { flags.contains(.reportedIdleEvent) }
         set { if newValue { flags.insert(.reportedIdleEvent) } else { flags.remove(.reportedIdleEvent) } }
     }
-    var spinValueForTestingSeen: Bool {
-        get { flags.contains(.spinValueForTestingSeen) }
-        set { if newValue { flags.insert(.spinValueForTestingSeen) } else { flags.remove(.spinValueForTestingSeen) } }
-    }
 
     var log: LogPrefixer {
         parentProtocol.logPrefixer

Tests/SwiftNetworkTests/QUICTestHarness.swift

@@ -76,6 +76,9 @@ final class QUICTestHarness {
 
         let clientInstance: QUICProtocol.Instance
         let serverInstance: QUICProtocol.Instance
+
+        let clientBridge: BridgeDatagramProtocol.Instance
+        let serverBridge: BridgeDatagramProtocol.Instance
     }
     var state: QUICHarnessState? = nil
 
@@ -165,7 +168,8 @@ final class QUICTestHarness {
             clientOptions.setProtocolInstance(clientReference)
             clientParameters.defaultStack.transport = .quic(clientOptions)
 
-            let clientBridge = BridgeDatagramProtocol.instance(context: self.context)
+            let clientBridgeInstance = BridgeDatagramProtocol.Instance(context: self.context)
+            let clientBridge = clientBridgeInstance.reference
             let clientBridgeOptions = BridgeDatagramProtocol.options()
             clientBridgeOptions.setProtocolInstance(clientBridge)
             clientBridgeOptions.linkDelay = clientLinkDelay
@@ -192,7 +196,8 @@ final class QUICTestHarness {
             serverOptions.setProtocolInstance(serverReference)
             serverParameters.defaultStack.transport = .quic(serverOptions)
 
-            let serverBridge = BridgeDatagramProtocol.instance(context: self.context)
+            let serverBridgeInstance = BridgeDatagramProtocol.Instance(context: self.context)
+            let serverBridge = serverBridgeInstance.reference
             let serverBridgeOptions = BridgeDatagramProtocol.options()
             serverBridgeOptions.setProtocolInstance(serverBridge)
             serverBridgeOptions.linkDelay = serverLinkDelay
@@ -292,7 +297,9 @@ final class QUICTestHarness {
                 clientReference: clientReference,
                 serverReference: serverReference,
                 clientInstance: clientInstance,
-                serverInstance: serverInstance
+                serverInstance: serverInstance,
+                clientBridge: clientBridgeInstance,
+                serverBridge: serverBridgeInstance
             )
 
             clientHarness.waitForError { error in
@@ -543,6 +550,18 @@ final class QUICTestHarness {
         wait(for: [stopCompleteExpectation], timeout: 5.0)
     }
 
+    // Installs a callback on the client and server bridge that fires passing the raw first byte to the
+    // caller for a short header packet.  Used to detect a spin bit passing between the client and server.
+    func observeFirstByteForOutboundShortHeaderPacket(handler: @escaping (_ firstByte: UInt8) -> Void) {
+        guard let state else { return }
+        let observe: ((UInt8) -> Void) = { firstByte in
+            guard (firstByte & 0xC0) == 0x40 else { return }
+            handler(firstByte)
+        }
+        state.clientBridge.observeFirstByte = observe
+        state.serverBridge.observeFirstByte = observe
+    }
+
     func echoDataOnStream(
         dataGenerator: TestDataGenerator,
         streamIndex: Int,

Tests/SwiftNetworkTests/SwiftNetworkQUICSpinBitTests.swift

@@ -60,6 +60,7 @@ final class SwiftNetworkQUICSpinBitTests: NetTestCase {
         // it from the server.
 
         var hasSpinBit = true
+        var observedSpinBitValues: Set<Bool> = []
         QUICTestHarness().runQUICTest(
             dataBlock: Array("Hello World!".utf8),
             afterHandshake: { harness in
@@ -78,6 +79,11 @@ final class SwiftNetworkQUICSpinBitTests: NetTestCase {
                         hasSpinBit = false
                         return
                     }
+                    // If we have made it this far we should at least be able to detect at least one spin bit value going back and forth
+                    // Detect at least 1 outbound datagram sending a spin bit value
+                    harness.observeFirstByteForOutboundShortHeaderPacket { firstByte in
+                        observedSpinBitValues.insert((firstByte & 0x20) != 0)
+                    }
                 }
                 self.wait(for: [expectation], timeout: 5.0)
             },
@@ -89,14 +95,14 @@ final class SwiftNetworkQUICSpinBitTests: NetTestCase {
                 let expectation = XCTestExpectation(description: "Wait to validate spin bit")
                 harness.context.async {
                     defer { expectation.fulfill() }
-
-                    let clientSpinBit = harness.state?.clientInstance.currentPath?.spinValue ?? false
-                    // Note that spinValueForTestingSeen is checked here because it could be that by the time
-                    // this test checks the server spin bit value it has received the ACK from the client and the
-                    // spin bit value has already changed. This reliably make sure that the spin bit on the server was present.
-                    let serverSpinBit = harness.state?.serverInstance.currentPath?.spinValueForTestingSeen ?? false
-                    XCTAssertFalse(clientSpinBit, "Client should have the spin bit set to false")
-                    XCTAssertTrue(serverSpinBit, "Server should have the spin bit set to true")
+                    XCTAssertFalse(
+                        observedSpinBitValues.isEmpty,
+                        "BridgeDatagramProtocol should have observed short-header packets with spin bit values"
+                    )
+                    XCTAssertTrue(
+                        observedSpinBitValues.contains(true),
+                        "BridgeDatagramProtocol should have observed at least one packet with spin bit set"
+                    )
                 }
             }
         )