fix

Tun/Punchnet/Actors/SDLContextActor.swift

@@ -43,6 +43,10 @@ actor SDLContextActor {
     private var dnsClient: DNSCloudClient?
     private var dnsWorker: Task<Void, Never>?
     
+    // Localdns的client对象
+    private var dnsLocalClient: DNSLocalClient?
+    private var dnsLocalWorker: Task<Void, Never>?
+
     private var quicClient: SDLQUICClient?
     private var quicWorker: Task<Void, Never>?
     
@@ -104,6 +108,12 @@ actor SDLContextActor {
         // 启动arp的定时清理任务
         await self.arpServer.start()
         
+        await self.startDnsClient()
+        SDLLogger.shared.log("[SDLContext] dns started!!!!")
+        
+        await self.startDnsLocalClient()
+        SDLLogger.shared.log("[SDLContext] dns Local running!!!!")
+        
         await self.supervisor.addWorker(name: "quicClient") {
             SDLLogger.shared.log("[SDLContext] try start quicClient")
             let quicClient = try await self.startQUICClient()
@@ -119,13 +129,6 @@ actor SDLContextActor {
             SDLLogger.shared.log("[SDLContext] noticeClient closed!!!!")
         }
         
-        await self.supervisor.addWorker(name: "dnsClient") {
-            let dnsClient = try await self.startDnsClient()
-            SDLLogger.shared.log("[SDLContext] dns running!!!!")
-            try await dnsClient.waitClose()
-            SDLLogger.shared.log("[SDLContext] dns closed!!!!")
-        }
-        
         await self.supervisor.addWorker(name: "udpHole") {
             let udpHole = try await self.startUDPHole()
             SDLLogger.shared.log("[SDLContext] udp running!!!!")
@@ -225,7 +228,7 @@ actor SDLContextActor {
         }
     }
     
-    private func startDnsClient() async throws -> DNSCloudClient {
+    private func startDnsClient() async {
         self.dnsWorker?.cancel()
         self.dnsWorker = nil
         
@@ -244,8 +247,27 @@ actor SDLContextActor {
                 self.provider.packetFlow.writePacketObjects([nePacket])
             }
         }
+    }
     
-        return dnsClient
+    private func startDnsLocalClient() async {
+        self.dnsLocalWorker?.cancel()
+        self.dnsLocalWorker = nil
+        
+        // 启动dns服务
+        let dnsLocalClient = DNSLocalClient()
+        dnsLocalClient.start()
+        SDLLogger.shared.log("[SDLContext] dnsClient started")
+        self.dnsLocalClient = dnsLocalClient
+        self.dnsLocalWorker = Task.detached {
+            // 处理事件流
+            for await packet in dnsLocalClient.packetFlow {
+                if Task.isCancelled {
+                    break
+                }
+                let nePacket = NEPacket(data: packet, protocolFamily: 2)
+                self.provider.packetFlow.writePacketObjects([nePacket])
+            }
+        }
     }
     
     private func startUDPHole() async throws -> SDLUDPHole {
@@ -325,9 +347,14 @@ actor SDLContextActor {
         self.quicWorker?.cancel()
         self.quicWorker = nil
         
+        self.dnsClient?.stop()
         self.dnsWorker?.cancel()
         self.dnsWorker = nil
         
+        self.dnsLocalClient?.stop()
+        self.dnsLocalWorker?.cancel()
+        self.dnsLocalWorker = nil
+        
         self.monitorWorker?.cancel()
         self.monitorWorker = nil
         

Tun/Punchnet/DNS/DNSLocalClient.swift

@@ -1,21 +1,19 @@
 import Foundation
 import Network
 
-final class SDLLocalDNSClient {
+final class DNSLocalClient {
     private var connections: [NWConnection] = []
-    private let logger: SDLLogger
     
     // 准备多个公共 DNS
     private let dnsServers = ["114.114.114.114", "223.5.5.5", "8.8.8.8"]
     
-    public let payloadFlow: AsyncStream<Data>
+    public let packetFlow: AsyncStream<Data>
-    private let payloadContinuation: AsyncStream<Data>.Continuation
+    private let packetContinuation: AsyncStream<Data>.Continuation
 
-    init(logger: SDLLogger) {
+    init() {
-        self.logger = logger
         let (stream, continuation) = AsyncStream.makeStream(of: Data.self, bufferingPolicy: .unbounded)
-        self.payloadFlow = stream
+        self.packetFlow = stream
-        self.payloadContinuation = continuation
+        self.packetContinuation = continuation
     }
 
     func start() {
@@ -27,9 +25,19 @@ final class SDLLocalDNSClient {
             let conn = NWConnection(to: endpoint, using: parameters)
             
             conn.stateUpdateHandler = { [weak self] state in
-                if case .ready = state { self?.receiveLoop(for: conn) }
+                switch state {
+                case .ready:
+                    self?.receiveLoop(for: conn)
+                case .failed(let error):
+                    self?.stop()
+                case .cancelled:
+                    self?.packetContinuation.finish()
+                default:
+                    ()
+                }
             }
             conn.start(queue: .global())
+            
             connections.append(conn)
         }
     }
@@ -48,11 +56,20 @@ final class SDLLocalDNSClient {
                 // 谁先 yield，上层就先收到谁。
                 // 只要上层收到了第一个有效响应并回填给系统，
                 // 后面迟到的重复响应会被系统协议栈自动忽略（因为 Transaction ID 已失效）
-                self?.payloadContinuation.yield(data)
+                self?.packetContinuation.yield(data)
             }
+            
             if error == nil && conn.state == .ready {
                 self?.receiveLoop(for: conn)
             }
         }
     }
+    
+    func stop() {
+        connections.forEach { conn in
+            conn.cancel()
+        }
+        self.connections.removeAll()
+    }
+    
 }