fix dns

Tun/Context/SDLContextActor.swift

@@ -40,7 +40,8 @@ actor SDLContextActor {
     // 加密算法相关
     nonisolated let rsaCipher: RSACipher
     
-    private var dnsService: DNSService?
+    private let dnsCloudService: DNSCloudService
+    private let dnsLocalService: DNSLocalService
     private let superService: SDLSuperService
     private let udpHoleService: SDLUDPHoleService
     private let udpHoleV6Service: SDLUDPHoleV6Service
@@ -48,7 +49,7 @@ actor SDLContextActor {
     private let packetInboundActor: PacketInboundActor
     private let tunNetworkManager: SDLTunNetworkManager
 
-    private let publicDnsServers = ["223.5.5.5", "119.29.29.29"]
+    private static let publicDnsServers = ["223.5.5.5", "119.29.29.29"]
 
     nonisolated private let puncherActor: SDLPuncherActor
     // 网络探测对象
@@ -85,6 +86,8 @@ actor SDLContextActor {
         let superService = SDLSuperService(serverEndpoint: config.serverEndpoint)
         let udpHoleService = SDLUDPHoleService(proberActor: proberActor)
         let udpHoleV6Service = SDLUDPHoleV6Service()
+        let dnsCloudService = DNSCloudService(serverIP: config.serverEndpoint.ip)
+        let dnsLocalService = DNSLocalService(publicDnsServers: Self.publicDnsServers)
         let tunNetworkManager = SDLTunNetworkManager(provider: provider)
         let ipv6AssistPair = AsyncStream.makeStream(of: Optional<SDLV6Info>.self, bufferingPolicy: .bufferingNewest(1))
         let packetOutboundActor = PacketOutboundActor(
@@ -98,6 +101,8 @@ actor SDLContextActor {
             superService: superService,
             udpHoleService: udpHoleService,
             udpHoleV6Service: udpHoleV6Service,
+            dnsCloudService: dnsCloudService,
+            dnsLocalService: dnsLocalService,
             flowTracer: flowTracer
         )
         let packetInboundActor = PacketInboundActor(
@@ -124,6 +129,8 @@ actor SDLContextActor {
 
         // 权限控制
         self.policyService = policyService
+        self.dnsCloudService = dnsCloudService
+        self.dnsLocalService = dnsLocalService
         self.superService = superService
         self.udpHoleService = udpHoleService
         self.udpHoleV6Service = udpHoleV6Service
@@ -183,15 +190,12 @@ actor SDLContextActor {
     private func runRootBody() async throws {
         self.prepareTunnelNotifier()
 
-        let dnsCloudService = DNSCloudService(serverIP: self.config.serverEndpoint.ip) { [weak self] event in
+        await self.dnsCloudService.updateEventHandler { [weak self] event in
             await self?.handleDNSEvent(event)
         }
-        let dnsLocalService = DNSLocalService(publicDnsServers: self.publicDnsServers) { [weak self] event in
+        await self.dnsLocalService.updateEventHandler { [weak self] event in
             await self?.handleDNSEvent(event)
         }
-        let dnsService = DNSService(cloudService: dnsCloudService, localService: dnsLocalService)
-        self.dnsService = dnsService
-        await self.packetOutboundActor.updateDNSService(dnsService)
 
         await self.superService.updateMessageHandler { [weak self] message in
             await self?.handleSuperMessage(message: message)
@@ -216,6 +220,8 @@ actor SDLContextActor {
         )
 
         let superService = self.superService
+        let dnsCloudService = self.dnsCloudService
+        let dnsLocalService = self.dnsLocalService
         let udpHoleService = self.udpHoleService
         let udpHoleV6Service = self.udpHoleV6Service
         let packetOutboundActor = self.packetOutboundActor
@@ -390,10 +396,8 @@ actor SDLContextActor {
         await self.udpHoleService.stop()
         await self.udpHoleV6Service.stop()
 
-        let dnsService = self.dnsService
+        await self.dnsCloudService.stop()
-        self.dnsService = nil
+        await self.dnsLocalService.stop()
-        await self.packetOutboundActor.updateDNSService(nil)
-        await dnsService?.stop()
 
         await self.superService.stop()
 
@@ -638,7 +642,7 @@ extension SDLContextActor {
 
 // MARK: DNS service events
 extension SDLContextActor {
-    private func handleDNSEvent(_ event: DNSService.Event) async {
+    private func handleDNSEvent(_ event: DNSEvent) async {
         switch event {
         case .packet(let packet):
             let nePacket = NEPacket(data: packet, protocolFamily: 2)

Tun/DNS/DNSCloudService.swift

@@ -2,13 +2,16 @@ import Foundation
 
 actor DNSCloudService {
     private let serverIP: String
-    private let onEvent: DNSService.EventHandler
+    private var onEvent: DNSEventHandler = { _ in }
 
     private var currentClient: DNSCloudClient?
     private var generation: UInt64 = 0
 
-    init(serverIP: String, onEvent: @escaping DNSService.EventHandler) {
+    init(serverIP: String) {
         self.serverIP = serverIP
+    }
+
+    func updateEventHandler(_ onEvent: @escaping DNSEventHandler) {
         self.onEvent = onEvent
     }
 

Tun/DNS/DNSEvent.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+enum DNSEvent {
+    case packet(Data)
+}
+
+typealias DNSEventHandler = @Sendable (DNSEvent) async -> Void

Tun/DNS/DNSLocalService.swift

@@ -2,13 +2,16 @@ import Foundation
 
 actor DNSLocalService {
     private let publicDnsServers: [String]
-    private let onEvent: DNSService.EventHandler
+    private var onEvent: DNSEventHandler = { _ in }
 
     private var currentClient: DNSLocalClient?
     private var generation: UInt64 = 0
 
-    init(publicDnsServers: [String], onEvent: @escaping DNSService.EventHandler) {
+    init(publicDnsServers: [String]) {
         self.publicDnsServers = publicDnsServers
+    }
+
+    func updateEventHandler(_ onEvent: @escaping DNSEventHandler) {
         self.onEvent = onEvent
     }
 

Tun/DNS/DNSService.swift

@@ -1,30 +0,0 @@
-import Foundation
-
-actor DNSService {
-    enum Event {
-        case packet(Data)
-    }
-
-    typealias EventHandler = @Sendable (Event) async -> Void
-
-    private let cloudService: DNSCloudService
-    private let localService: DNSLocalService
-
-    init(cloudService: DNSCloudService, localService: DNSLocalService) {
-        self.cloudService = cloudService
-        self.localService = localService
-    }
-
-    func stop() async {
-        await self.cloudService.stop()
-        await self.localService.stop()
-    }
-
-    func forward(ipPacketData: Data) async {
-        await self.cloudService.forward(ipPacketData: ipPacketData)
-    }
-
-    func queryLocal(tracker: DNSLocalClient.DNSTracker, dnsPayload: Data) async {
-        await self.localService.query(tracker: tracker, dnsPayload: dnsPayload)
-    }
-}

Tun/Outbound/PacketOutboundActor.swift

@@ -26,6 +26,8 @@ actor PacketOutboundActor {
     private let superService: SDLSuperService
     private let udpHoleService: SDLUDPHoleService
     private let udpHoleV6Service: SDLUDPHoleV6Service
+    private let dnsCloudService: DNSCloudService
+    private let dnsLocalService: DNSLocalService
     private let flowTracer: SDLFlowTracer
 
     private var networkAddress: SDLConfiguration.NetworkAddress
@@ -33,7 +35,6 @@ actor PacketOutboundActor {
     private var exitNode: SDLConfiguration.ExitNode?
     private var stunSocketAddress: SocketAddress
     private var dataCipher: CCDataCipher?
-    private var dnsService: DNSService?
 
     init(provider: NEPacketTunnelProvider,
          config: SDLConfiguration,
@@ -45,6 +46,8 @@ actor PacketOutboundActor {
          superService: SDLSuperService,
          udpHoleService: SDLUDPHoleService,
          udpHoleV6Service: SDLUDPHoleV6Service,
+         dnsCloudService: DNSCloudService,
+         dnsLocalService: DNSLocalService,
          flowTracer: SDLFlowTracer) {
         self.provider = provider
         self.networkAddress = config.networkAddress
@@ -59,6 +62,8 @@ actor PacketOutboundActor {
         self.superService = superService
         self.udpHoleService = udpHoleService
         self.udpHoleV6Service = udpHoleV6Service
+        self.dnsCloudService = dnsCloudService
+        self.dnsLocalService = dnsLocalService
         self.flowTracer = flowTracer
     }
 
@@ -70,10 +75,6 @@ actor PacketOutboundActor {
         self.dataCipher = dataCipher
     }
 
-    func updateDNSService(_ dnsService: DNSService?) {
-        self.dnsService = dnsService
-    }
-
     func runPacketReader() async throws {
         let provider = self.provider
 
@@ -106,10 +107,10 @@ actor PacketOutboundActor {
             self.provider.packetFlow.writePacketObjects([nePacket])
         case .cloudDNS(let name, let ipPacketData):
             SDLLogger.log("[PacketOutboundActor] get cloud dns request: \(name)")
-            await self.dnsService?.forward(ipPacketData: ipPacketData)
+            await self.dnsCloudService.forward(ipPacketData: ipPacketData)
         case .localDNS(let name, let payload, let tracker):
             SDLLogger.log("[PacketOutboundActor] get local dns request: \(name)")
-            await self.dnsService?.queryLocal(tracker: tracker, dnsPayload: payload)
+            await self.dnsLocalService.query(tracker: tracker, dnsPayload: payload)
         case .forwardToNextHop(let ip, let type, let data, let kind):
             await self.forwardPacketToNextHop(ip: ip, type: type, data: data, kind: kind, originalPacket: packet)
         case .drop(let reason):