Tun/Context/SDLContextActor.swift

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

Tun/UDPHole/SDLUDPHoleService.swift

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