fix udp

Tun/Context/SDLContextActor.swift

@@ -164,12 +164,17 @@ actor SDLContextActor {
         await self.packetOutboundActor.updateDNSService(dnsService)
         await dnsService.start()
 
-        await self.udpHoleServiceProxy.bindInbound(self.packetInboundActor) { [weak self] event in
+        let udpHoleEventHandler = await self.udpHoleServiceProxy.makeEventHandler { [weak self] event in
             await self?.handleUDPHoleControlEvent(event)
         }
-
+        let packetInboundActor = self.packetInboundActor
-        let udpHoleEventHandler = await self.udpHoleServiceProxy.makeEventHandler()
+        let udpHoleService = SDLUDPHoleService(
-        let udpHoleService = SDLUDPHoleService(proberActor: self.proberActor, onEvent: udpHoleEventHandler)
+            proberActor: self.proberActor,
+            onEvent: udpHoleEventHandler,
+            onData: { data in
+                await packetInboundActor.handleData(data)
+            }
+        )
         await self.udpHoleServiceProxy.replace(udpHoleService)
         await udpHoleService.start(includeV6: false)
 
@@ -469,9 +474,7 @@ extension SDLContextActor {
         }
     }
 
-    private func handleUDPHolePacket(remoteAddress: SocketAddress, message: SDLHoleMessage, source: SDLUDPHoleKind) async {
+    private func handleUDPHolePacket(remoteAddress: SocketAddress, message: SDLHoleControlMessage, source: SDLUDPHoleKind) async {
-        switch message {
-        case .control(let message):
         switch message {
         case .stunReply(_), .stunProbeReply(_):
             SDLLogger.log("[SDLContext] get a stun reply", for: .debug)
@@ -480,9 +483,6 @@ extension SDLContextActor {
         case .registerAck(let registerAck):
             await self.handleRegisterAck(remoteAddress: remoteAddress, registerAck: registerAck, source: source)
         }
-        case .data:
-            SDLLogger.log("[SDLContext] unexpected data packet in control path", for: .debug)
-        }
     }
     
     private func handleRegister(remoteAddress: SocketAddress, register: SDLRegister, source: SDLUDPHoleKind) async throws {

Tun/UDPHole/SDLUDPHoleService.swift

@@ -19,14 +19,16 @@ actor SDLUDPHoleService {
     enum Event {
         case ready(SocketAddress)
         case natType(SDLNATProberActor.NatType)
-        case packet(SocketAddress, SDLHoleMessage, source: SDLUDPHoleKind)
+        case packet(SocketAddress, SDLHoleControlMessage, source: SDLUDPHoleKind)
         case closed(Error)
     }
 
     typealias EventHandler = @Sendable (Event) async -> Void
+    typealias DataHandler = @Sendable (SDLData) async -> Void
 
     private let proberActor: SDLNATProberActor
     private let onEvent: EventHandler
+    private let onData: DataHandler
 
     private var udpHole: SDLUDPHole?
     private var udpHoleMonitorTask: Task<Void, Never>?
@@ -36,9 +38,14 @@ actor SDLUDPHoleService {
     private var udpHoleV6: SDLUDPHoleV6?
     private var udpHoleV6MonitorTask: Task<Void, Never>?
 
-    init(proberActor: SDLNATProberActor, onEvent: @escaping EventHandler) {
+    init(
+        proberActor: SDLNATProberActor,
+        onEvent: @escaping EventHandler,
+        onData: @escaping DataHandler
+    ) {
         self.proberActor = proberActor
         self.onEvent = onEvent
+        self.onData = onData
     }
 
     func start(includeV6: Bool = false) {
@@ -171,10 +178,10 @@ actor SDLUDPHoleService {
             case .stunProbeReply(let probeReply):
                 await self.proberActor.handleProbeReply(localAddress: self.localAddress, reply: probeReply)
             default:
-                await self.onEvent(.packet(remoteAddress, message, source: .v4))
+                await self.onEvent(.packet(remoteAddress, control, source: .v4))
             }
-        case .data:
+        case .data(let data):
-            await self.onEvent(.packet(remoteAddress, message, source: .v4))
+            await self.onData(data)
         }
     }
 
@@ -215,10 +222,16 @@ actor SDLUDPHoleService {
             }
 
             let onEvent = self.onEvent
+            let onData = self.onData
             group.addTask {
                 for await (remoteAddress, message) in udpHoleV6.messageStream {
                     try Task.checkCancellation()
-                    await onEvent(.packet(remoteAddress, message, source: .v6))
+                    switch message {
+                    case .control(let control):
+                        await onEvent(.packet(remoteAddress, control, source: .v6))
+                    case .data(let data):
+                        await onData(data)
+                    }
                 }
             }
 
@@ -243,21 +256,14 @@ actor SDLUDPHoleServiceProxy {
     typealias ControlEventHandler = @Sendable (SDLUDPHoleService.Event) async -> Void
 
     private var udpHoleService: SDLUDPHoleService?
-    private var packetInboundActor: PacketInboundActor?
-    private var onControlEvent: ControlEventHandler?
     private var generation: UInt64 = 0
 
-    func bindInbound(_ packetInboundActor: PacketInboundActor, onControlEvent: @escaping ControlEventHandler) {
+    func makeEventHandler(onControlEvent: @escaping ControlEventHandler) -> SDLUDPHoleService.EventHandler {
-        self.packetInboundActor = packetInboundActor
-        self.onControlEvent = onControlEvent
-    }
-
-    func makeEventHandler() -> SDLUDPHoleService.EventHandler {
         self.generation &+= 1
         let generation = self.generation
 
         return { [weak self] event in
-            await self?.handleEvent(event, generation: generation)
+            await self?.handleEvent(event, generation: generation, onControlEvent: onControlEvent)
         }
     }
 
@@ -283,21 +289,11 @@ actor SDLUDPHoleServiceProxy {
         await self.udpHoleService?.send(type: type, data: data, remoteAddress: remoteAddress)
     }
 
-    private func handleEvent(_ event: SDLUDPHoleService.Event, generation: UInt64) async {
+    private func handleEvent(_ event: SDLUDPHoleService.Event, generation: UInt64, onControlEvent: ControlEventHandler) async {
         guard generation == self.generation else {
             return
         }
 
-        switch event {
+        await onControlEvent(event)
-        case .packet(_, let message, _):
-            switch message {
-            case .data(let data):
-                await self.packetInboundActor?.handleData(data)
-            case .control:
-                await self.onControlEvent?(event)
-            }
-        case .ready, .natType, .closed:
-            await self.onControlEvent?(event)
-        }
     }
 }