Adds a new Socket Stream Protocol implementation that lets us use kernel TCP

Author: PayasR

Sources/SwiftNetwork/EndpointFlow/EndpointFlowExtension.swift

@@ -76,26 +76,49 @@ extension EndpointFlow {
 
                 switch transport {
                 case .tcp(let options):
-                    guard let reference = TCPProtocol().newProtocolInstance(context: context) else {
-                        throw NetworkError.posix(EINVAL)
+                    if case .custom(let linkOptions) = stack.link,
+                        linkOptions.identifier == BridgeDatagramProtocol.identifier
+                    {
+                        guard let reference = TCPProtocol().newProtocolInstance(context: context) else {
+                            throw NetworkError.posix(EINVAL)
+                        }
+                        options.setProtocolInstance(reference)
+                        let linkage = OutboundStreamLinkage(reference: reference)
+                        let flow = try StreamEndpointFlowProtocol(
+                            identifier: String(self.identifier),
+                            local: effectiveLocalEndpoint,
+                            remote: effectiveRemoteEndpoint,
+                            parameters: self.parameters,
+                            path: path,
+                            context: context,
+                            lowerStreamProtocol: linkage
+                        )
+                        self.flowProtocol = .stream(flow)
+                        options.setLogID(
+                            prefix: "C",
+                            parent: String(self.identifier),
+                            protocolLogIDNumber: Int(self.identifier)
+                        )
+                    } else {
+                        let socketReference = SocketStreamProtocol.instance(context: context)
+                        options.setProtocolInstance(socketReference)
+                        let linkage = OutboundStreamLinkage(reference: socketReference)
+                        let flow = try StreamEndpointFlowProtocol(
+                            identifier: String(self.identifier),
+                            local: effectiveLocalEndpoint,
+                            remote: effectiveRemoteEndpoint,
+                            parameters: self.parameters,
+                            path: path,
+                            context: context,
+                            lowerStreamProtocol: linkage
+                        )
+                        self.flowProtocol = .stream(flow)
+                        options.setLogID(
+                            prefix: "C",
+                            parent: String(self.identifier),
+                            protocolLogIDNumber: Int(self.identifier)
+                        )
                     }
-                    options.setProtocolInstance(reference)
-                    let linkage = OutboundStreamLinkage(reference: reference)
-                    let flow = try StreamEndpointFlowProtocol(
-                        identifier: String(self.identifier),
-                        local: effectiveLocalEndpoint,
-                        remote: effectiveRemoteEndpoint,
-                        parameters: self.parameters,
-                        path: path,
-                        context: context,
-                        lowerStreamProtocol: linkage
-                    )
-                    self.flowProtocol = .stream(flow)
-                    options.setLogID(
-                        prefix: "C",
-                        parent: String(self.identifier),
-                        protocolLogIDNumber: Int(self.identifier)
-                    )
                 case .udp(let options):
                     if case .custom(let linkOptions) = stack.link,
                         linkOptions.identifier == BridgeDatagramProtocol.identifier

Sources/SwiftNetwork/EndpointFlow/EndpointFlowProtocols.swift

@@ -165,9 +165,13 @@ class EndpointFlowProtocol<LinkageType: InboundDataLinkage>: ProtocolInstanceCon
 
     func handleInboundDataAvailableEvent(_ from: ProtocolInstanceReference) {
         log.debug("Received inbound data available event")
+        // Clear the slot before invoking: the completion may synchronously
+        // re-arm the waiter (when receiveStreamData returns nil because the
+        // requested minimum spans more than one segment). Clearing afterwards
+        // would clobber that re-registration and drop later notifications.
         if let inboundDataAvailableCompletion = self.completions.inboundDataAvailable {
-            inboundDataAvailableCompletion(true)
             self.completions.inboundDataAvailable = nil
+            inboundDataAvailableCompletion(true)
         }
     }