merge actor_mst

.gitignore

@@ -0,0 +1 @@
+punchnet.xcodeproj/*

Tun/NetworkInterface.swift

@@ -1,3 +1,11 @@
+//
+//  NetworkInterface.swift
+//  punchnet
+//
+//  Created by 安礼成 on 2025/8/3.
+//
+
+
 //
 //  NetworkInterface.swift
 //  Tun
@@ -7,13 +15,13 @@
 
 import Foundation
 
-struct NetworkInterface {
-    let name: String
-    let ip: String
-    let netmask: String
+public struct NetworkInterface {
+    public let name: String
+    public let ip: String
+    public let netmask: String
 }
 
-struct NetworkInterfaceManager {
+public struct NetworkInterfaceManager {
     /**
     获取网卡信息, (let name: String let ip: String let netmask: String)
      */
@@ -44,6 +52,7 @@ struct NetworkInterfaceManager {
                         if (getnameinfo(&addr, socklen_t(addr.sa_len), &hostname, socklen_t(hostname.count),
                                         nil, socklen_t(0), NI_NUMERICHOST) == 0) {
                             let address = String(cString: hostname)
+
                             let name = ptr!.pointee.ifa_name!
                             let ifname = String(cString: name)
                             

Tun/PacketTunnelProvider.swift

@@ -1,3 +1,11 @@
+//
+//  PacketTunnelProvider.swift
+//  punchnet
+//
+//  Created by 安礼成 on 2025/8/3.
+//
+
+
 //
 //  PacketTunnelProvider.swift
 //  Tun
@@ -9,6 +17,7 @@ import NetworkExtension
 
 class PacketTunnelProvider: NEPacketTunnelProvider {
     var context: SDLContext?
+    private var rootTask: Task<Void, Error>?
     
     override func startTunnel(options: [String : NSObject]?, completionHandler: @escaping (Error?) -> Void) {
         // host: "192.168.0.101", port: 1265
@@ -16,38 +25,80 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
             return
         }
         
-        let token = options["token"] as! String
-        //let version = options["version"] as! Int
+        // 如果当前在运行状态，不允许重复请求
+        guard self.context == nil else {
+            return
+        }
+        
+        // let token = options["token"] as! String
         let installed_channel = options["installed_channel"] as! String
-        
         let superIp = options["super_ip"] as! String
-        Task {
-            SDLLogger.logLevel = .debug
-            do {
-                self.context = try SDLContext(provider: self, config: .init(
-                    version: 1,
+        let superPort = options["super_port"] as! Int
+        let stunServersStr = options["stun_servers"] as! String
+        let noticePort = options["notice_port"] as! Int
+        let token = options["token"] as! String
+        let networkCode = options["network_code"] as! String
+        let clientId = options["client_id"] as! String
+        let remoteDnsServer = options["remote_dns_server"] as! String
+        let hostname = options["hostname"] as! String
+
+        let stunServers = stunServersStr.split(separator: ";").compactMap { server -> SDLConfiguration.StunServer? in
+            let parts = server.split(separator: ":", maxSplits: 2)
+            guard parts.count == 2 else {
+                return nil
+            }
+            
+            let ports = parts[1].split(separator: ",", maxSplits: 2)
+            guard ports.count == 2, let port1 = Int(String(ports[0])), let port2 = Int(String(ports[1])) else {
+                return nil
+            }
+            
+            return .init(host: String(parts[0]), ports: [port1, port2])
+        }
+        
+        guard stunServers.count >= 2 else {
+            NSLog("stunServers配置错误")
+            return
+        }
+        
+        NSLog("[PacketTunnelProvider] client_id: \(clientId), token: \(token), network_code: \(networkCode)")
+
+        let config = SDLConfiguration(version: 1,
                                       installedChannel: installed_channel,
-                    //superHost: "118.178.229.213",
                                       superHost: superIp,
-                    superPort: 18083,
-                    stunServers: [.init(host: superIp, ports: [1265, 1266]), .init(host: "118.178.229.213", ports: [1265, 1266])],
-                    clientId: SDLContext.getUUID(),
-                    token: ""
-                    //token: token
-                ))
+                                      superPort: superPort,
+                                      stunServers: stunServers,
+                                      clientId: clientId,
+                                      noticePort: noticePort,
+                                      token: token,
+                                      networkCode: networkCode,
+                                      remoteDnsServer: remoteDnsServer,
+                                      hostname: hostname)
+        // 加密算法
+        let rsaCipher = try! CCRSACipher(keySize: 1024)
+        let aesChiper = CCAESChiper()
         
+        self.rootTask = Task {
+            do {
+                self.context = SDLContext(provider: self, config: config, rsaCipher: rsaCipher, aesCipher: aesChiper, logger: SDLLogger(level: .debug))
                 try await self.context?.start()
-                completionHandler(nil)
             } catch let err {
-                NSLog("SDLContext start get error: \(err)")
-                
-                completionHandler(err)
+                NSLog("[PacketTunnelProvider] exit with error: \(err)")
+                exit(-1)
             }
         }
+        completionHandler(nil)
     }
     
     override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
         // Add code here to start the process of stopping the tunnel.
+        self.rootTask?.cancel()
+        Task {
+            await self.context?.stop()
+        }
+        self.context = nil
+        self.rootTask = nil
+        
         completionHandler()
     }
     
@@ -78,4 +129,51 @@ extension PacketTunnelProvider {
         return interfaces.first {$0.name == "en0"}
     }()
     
+    struct CCRSACipher: RSACipher {
+        var pubKey: String
+        let privateKeyDER: Data
+        
+        init(keySize: Int) throws {
+            let (privateKey, publicKey) = try Self.loadKeys(keySize: keySize)
+            let privKeyStr = SwKeyConvert.PrivateKey.derToPKCS1PEM(privateKey)
+            
+            self.pubKey = SwKeyConvert.PublicKey.derToPKCS8PEM(publicKey)
+            self.privateKeyDER = try SwKeyConvert.PrivateKey.pemToPKCS1DER(privKeyStr)
+        }
+        
+        public func decode(data: Data) throws -> Data {
+            let tag = Data()
+            let (decryptedData, _) = try CC.RSA.decrypt(data, derKey: self.privateKeyDER, tag: tag, padding: .pkcs1, digest: .none)
+            
+            return decryptedData
+        }
+        
+        private static func loadKeys(keySize: Int) throws -> (Data, Data) {
+            if let privateKey = UserDefaults.standard.data(forKey: "privateKey"),
+               let publicKey = UserDefaults.standard.data(forKey: "publicKey") {
+                
+                return (privateKey, publicKey)
+            } else {
+                let (privateKey, publicKey) = try CC.RSA.generateKeyPair(keySize)
+                UserDefaults.standard.setValue(privateKey, forKey: "privateKey")
+                UserDefaults.standard.setValue(publicKey, forKey: "publicKey")
+                
+                return (privateKey, publicKey)
+            }
+        }
+    }
+    
+    struct CCAESChiper: AESCipher {
+        func decypt(aesKey: Data, data: Data) throws -> Data {
+            let ivData = Data(aesKey.prefix(16))
+            return try CC.crypt(.decrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
+        }
+        
+        func encrypt(aesKey: Data, data: Data) throws -> Data {
+            let ivData = Data(aesKey.prefix(16))
+            
+            return try CC.crypt(.encrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
+        }
+    }
+    
 }

Tun/Punchnet/AESCipher.swift

@@ -0,0 +1,13 @@
+//
+//  AESCipher.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/7/14.
+//
+import Foundation
+
+public protocol AESCipher {
+    func decypt(aesKey: Data, data: Data) throws -> Data
+    
+    func encrypt(aesKey: Data, data: Data) throws -> Data
+}

Tun/Punchnet/ARPPacket.swift

@@ -6,7 +6,16 @@
 //
 import Foundation
 
-struct ARPPacket {
+struct ARPPacket: CustomStringConvertible {
+    var description: String {
+        return """
+opcode: \(self.opcode), sender_ip: \(SDLUtil.int32ToIp(self.senderIP)), sender_mac: \(SDLUtil.formatMacAddress(mac: senderMAC)), 
+target_ip: \(SDLUtil.int32ToIp(self.targetIP)), target_mac: \(SDLUtil.formatMacAddress(mac: targetMAC))
+"""
+    }
+    
+    static let broadcastMac = Data([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
+    
     // ARP操作码
     enum Opcode: UInt16 {
         case request = 0x01
@@ -31,8 +40,15 @@ struct ARPPacket {
     var targetMAC: Data
     var targetIP: UInt32
     
-    init(hardwareType: UInt16, protocolType: UInt16, hardwareSize: UInt8, protocolSize: UInt8, opcode: Opcode, 
-         senderMAC: Data, senderIP: UInt32, targetMAC: Data, targetIP: UInt32) {
+    init(hardwareType: UInt16,
+         protocolType: UInt16,
+         hardwareSize: UInt8,
+         protocolSize: UInt8,
+         opcode: Opcode,
+         senderMAC: Data,
+         senderIP: UInt32,
+         targetMAC: Data,
+         targetIP: UInt32) {
         
         self.hardwareType = hardwareType
         self.protocolType = protocolType
@@ -47,7 +63,6 @@ struct ARPPacket {
 
     init?(data: Data) {
         guard data.count >= 28 else {
-            NSLog("length < 28: len: \(data.count)")
             return nil
         }
         
@@ -56,7 +71,6 @@ struct ARPPacket {
         self.hardwareSize = data[4]
         self.protocolSize = data[5]
         guard let opcode = Opcode(rawValue: UInt16(data[6]) << 8 | UInt16(data[7])) else {
-            NSLog("opcode error")
             return nil
         }
         
@@ -82,6 +96,10 @@ struct ARPPacket {
         return data
     }
     
+    static func isBroadcastMac(_ macAddress: Data) -> Bool {
+        return macAddress == broadcastMac
+    }
+    
 }
 
 extension ARPPacket {

Tun/Punchnet/Actors/SDLDNSClientActor.swift

@@ -0,0 +1,117 @@
+//
+//  DNSClient.swift
+//  Tun
+//
+//  Created by 安礼成 on 2025/12/10.
+//
+
+import Foundation
+import NIOCore
+import NIOPosix
+
+// 处理和sn-server服务器之间的通讯
+@available(macOS 14, *)
+actor SDLDNSClientActor {
+    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    private let asyncChannel: NIOAsyncChannel<AddressedEnvelope<ByteBuffer>, AddressedEnvelope<ByteBuffer>>
+    private let (writeStream, writeContinuation) = AsyncStream.makeStream(of: Data.self, bufferingPolicy: .unbounded)
+    
+    private let logger: SDLLogger
+    private let dnsServerAddress: SocketAddress
+    
+    public let packetFlow: AsyncStream<Data>
+    private let packetContinuation: AsyncStream<Data>.Continuation
+
+    // 启动函数
+    init(dnsServerAddress: SocketAddress, logger: SDLLogger) async throws {
+        self.dnsServerAddress = dnsServerAddress
+        self.logger = logger
+        
+        (self.packetFlow, self.packetContinuation) = AsyncStream.makeStream(of: Data.self, bufferingPolicy: .unbounded)
+        
+        let bootstrap = DatagramBootstrap(group: group)
+            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
+        
+        self.asyncChannel = try await bootstrap.bind(host: "0.0.0.0", port: 0)
+            .flatMapThrowing { channel in
+                return try NIOAsyncChannel(wrappingChannelSynchronously: channel, configuration: .init(
+                    inboundType: AddressedEnvelope<ByteBuffer>.self,
+                    outboundType: AddressedEnvelope<ByteBuffer>.self
+                ))
+            }
+            .get()
+    }
+    
+    func start() async throws {
+        try await withTaskCancellationHandler {
+            try await self.asyncChannel.executeThenClose {inbound, outbound in
+                try await withThrowingTaskGroup(of: Void.self) { group in
+                    group.addTask {
+                        defer {
+                            self.logger.log("[DNSClient] inbound closed", level: .warning)
+                        }
+                        
+                        for try await envelope in inbound {
+                            try Task.checkCancellation()
+                            var buffer = envelope.data
+                            let remoteAddress = envelope.remoteAddress
+                            self.logger.log("[DNSClient] read data: \(buffer), from: \(remoteAddress)", level: .debug)
+                            
+                            let len = buffer.readableBytes
+                            if let bytes = buffer.readBytes(length: len) {
+                                self.packetContinuation.yield(Data(bytes))
+                            }
+                        }
+                    }
+                    
+                    group.addTask {
+                        defer {
+                            self.logger.log("[DNSClient] outbound closed", level: .warning)
+                        }
+                        
+                        for await message in self.writeStream {
+                            try Task.checkCancellation()
+                            
+                            let buffer = self.asyncChannel.channel.allocator.buffer(bytes: message)
+                            let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: self.dnsServerAddress, data: buffer)
+                            try await outbound.write(envelope)
+                        }
+                    }
+                    
+                    if let _ = try await group.next() {
+                        group.cancelAll()
+                    }
+                }
+            }
+        } onCancel: {
+            self.writeContinuation.finish()
+            self.packetContinuation.finish()
+            self.logger.log("[DNSClient] withTaskCancellationHandler cancel")
+        }
+    }
+    
+    func forward(ipPacket: IPPacket) {
+        self.writeContinuation.yield(ipPacket.data)
+    }
+    
+    deinit {
+        try? self.group.syncShutdownGracefully()
+        self.writeContinuation.finish()
+    }
+    
+}
+
+extension SDLDNSClientActor {
+    
+    struct Helper {
+        static let dnsServer: String = "100.100.100.100"
+        // dns请求包的目标地址
+        static let dnsDestIpAddr: UInt32 = 1684300900
+        
+        // 判断是否是dns请求的数据包
+        static func isDnsRequestPacket(ipPacket: IPPacket) -> Bool {
+            return ipPacket.header.destination == dnsDestIpAddr
+        }
+    }
+    
+}

Tun/Punchnet/Actors/SDLPuncherActor.swift

@@ -0,0 +1,89 @@
+//
+//  SDLPuncherActor.swift
+//  Tun
+//
+//  Created by 安礼成 on 2026/1/7.
+//
+
+import Foundation
+
+actor SDLPuncherActor {
+    // dstMac
+    private var coolingDown: Set<Data> = []
+    private let cooldown: Duration = .seconds(5)
+    
+    private var superClientActor: SDLSuperClientActor?
+    private var udpHoleActor: SDLUDPHoleActor?
+    
+    // 处理holer
+    private var logger: SDLLogger
+    
+    struct RegisterRequest {
+        let srcMac: Data
+        let dstMac: Data
+        let networkId: UInt32
+    }
+    
+    init(logger: SDLLogger) {
+        self.logger = logger
+    }
+    
+    func setSuperClientActor(superClientActor: SDLSuperClientActor?) {
+        self.superClientActor = superClientActor
+    }
+    
+    func setUDPHoleActor(udpHoleActor: SDLUDPHoleActor?) {
+        self.udpHoleActor = udpHoleActor
+    }
+    
+    func submitRegisterRequest(request: RegisterRequest) {
+        let dstMac = request.dstMac
+        
+        guard !coolingDown.contains(dstMac) else {
+            return
+        }
+        
+        // 触发一次打洞
+        coolingDown.insert(dstMac)
+        
+        Task {
+            await self.tryHole(request: request)
+            // 启动冷却期
+            try? await Task.sleep(for: .seconds(5))
+            self.endCooldown(for: dstMac)
+        }
+    }
+    
+    private func endCooldown(for key: Data) {
+        self.coolingDown.remove(key)
+    }
+    
+    private func tryHole(request: RegisterRequest) async {
+        var queryInfo = SDLQueryInfo()
+        queryInfo.dstMac = request.dstMac
+        guard let message = try? await self.superClientActor?.request(type: .queryInfo, data: try queryInfo.serializedData()) else {
+            return
+        }
+        
+        switch message.packet {
+        case .empty:
+            self.logger.log("[SDLContext] hole query_info get empty: \(message)", level: .debug)
+        case .peerInfo(let peerInfo):
+            if let remoteAddress = peerInfo.v4Info.socketAddress() {
+                self.logger.log("[SDLContext] hole sock address: \(remoteAddress)", level: .debug)
+                // 发送register包
+                var register = SDLRegister()
+                register.networkID = request.networkId
+                register.srcMac = request.srcMac
+                register.dstMac = request.dstMac
+                
+                await self.udpHoleActor?.send(type: .register, data: try! register.serializedData(), remoteAddress: remoteAddress)
+            } else {
+                self.logger.log("[SDLContext] hole sock address is invalid: \(peerInfo.v4Info)", level: .warning)
+            }
+        default:
+            self.logger.log("[SDLContext] hole query_info is packet: \(message)", level: .warning)
+        }
+    }
+    
+}

Tun/Punchnet/Actors/SDLSuperClientActor.swift

@@ -0,0 +1,312 @@
+//
+//  SDLWebsocketClient.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/3/28.
+//
+
+import Foundation
+import NIOCore
+import NIOPosix
+
+// --MARK: 和SuperNode的客户端
+actor SDLSuperClientActor {
+    // 发送的消息格式
+    private typealias TcpMessage = (packetId: UInt32, type: SDLPacketType, data: Data)
+    
+    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    private let asyncChannel: NIOAsyncChannel<ByteBuffer,ByteBuffer>
+    private let (writeStream, writeContinuation) = AsyncStream.makeStream(of: TcpMessage.self, bufferingPolicy: .unbounded)
+    private var continuations: [UInt32:CheckedContinuation<SDLSuperInboundMessage, Error>] = [:]
+
+    public let eventFlow: AsyncStream<SuperEvent>
+    private let inboundContinuation: AsyncStream<SuperEvent>.Continuation
+    
+    // id生成器
+    var idGenerator = SDLIdGenerator(seed: 1)
+    
+    private let logger: SDLLogger
+    
+    // 定义事件类型
+    enum SuperEvent {
+        case ready
+        case event(SDLEvent)
+        case command(UInt32, SDLCommand)
+    }
+    
+    enum SuperClientError: Error {
+        case timeout
+        case connectionClosed
+        case cancelled
+    }
+    
+    init(host: String, port: Int, logger: SDLLogger) async throws {
+        self.logger = logger
+        
+        (self.eventFlow, self.inboundContinuation) = AsyncStream.makeStream(of: SuperEvent.self, bufferingPolicy: .unbounded)
+        let bootstrap = ClientBootstrap(group: self.group)
+            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
+            .channelInitializer { channel in
+                return channel.pipeline.addHandlers([
+                    ByteToMessageHandler(FixedHeaderDecoder()),
+                    MessageToByteHandler(FixedHeaderEncoder())
+                ])
+            }
+        
+        self.asyncChannel = try await bootstrap.connect(host: host, port: port)
+            .flatMapThrowing { channel in
+                return try NIOAsyncChannel(wrappingChannelSynchronously: channel, configuration: .init(
+                    inboundType: ByteBuffer.self,
+                    outboundType: ByteBuffer.self
+                ))
+            }
+            .get()
+    }
+    
+    func start() async throws {
+        try await withTaskCancellationHandler {
+            try await self.asyncChannel.executeThenClose { inbound, outbound in
+                self.inboundContinuation.yield(.ready)
+                
+                try await withThrowingTaskGroup(of: Void.self) { group in
+                    group.addTask {
+                        defer {
+                            self.logger.log("[SDLSuperClient] inbound closed", level: .warning)
+                        }
+                        
+                        for try await var packet in inbound {
+                            try Task.checkCancellation()
+                            
+                            if let message = SDLSuperClientDecoder.decode(buffer: &packet) {
+                                if !message.isPong() {
+                                    self.logger.log("[SDLSuperClient] read message: \(message)", level: .debug)
+                                }
+                                
+                                switch message.packet {
+                                case .event(let event):
+                                    self.inboundContinuation.yield(.event(event))
+                                case .command(let command):
+                                    self.inboundContinuation.yield(.command(message.msgId, command))
+                                default:
+                                    await self.fireCallback(message: message)
+                                }
+                            }
+                        }
+                    }
+                    
+                    group.addTask {
+                        defer {
+                            self.logger.log("[SDLSuperClient] outbound closed", level: .warning)
+                        }
+                        
+                        for await (packetId, type, data) in self.writeStream {
+                            try Task.checkCancellation()
+                            
+                            var buffer = self.asyncChannel.channel.allocator.buffer(capacity: data.count + 5)
+                            buffer.writeInteger(packetId, as: UInt32.self)
+                            buffer.writeBytes([type.rawValue])
+                            buffer.writeBytes(data)
+                            try await outbound.write(buffer)
+                        }
+                    }
+                    
+                    // --MARK: 心跳机制
+                    group.addTask {
+                        defer {
+                            self.logger.log("[SDLSuperClient] ping task closed", level: .warning)
+                        }
+                        
+                        while true {
+                            try Task.checkCancellation()
+                            await self.ping()
+                            try await Task.sleep(nanoseconds: 5 * 1_000_000_000)
+                        }
+                    }
+                    
+                    // 迭代等待所有任务的退出, 第一个异常会被抛出
+                    if let _ = try await group.next() {
+                        group.cancelAll()
+                    }
+                }
+            }
+        } onCancel: {
+            self.inboundContinuation.finish()
+            self.writeContinuation.finish()
+            self.logger.log("[SDLSuperClient] withTaskCancellationHandler cancel")
+            Task {
+                await self.failAllContinuations(SuperClientError.cancelled)
+            }
+        }
+    }
+    
+    // -- MARK: apis
+    func unregister() throws {
+        self.send(type: .unregisterSuper, packetId: 0, data: Data())
+    }
+    
+    private func ping() {
+        self.send(type: .ping, packetId: 0, data: Data())
+    }
+    
+    func request(type: SDLPacketType, data: Data, timeout: Duration = .seconds(5)) async throws -> SDLSuperInboundMessage {
+        let packetId = idGenerator.nextId()
+        
+        return try await withCheckedThrowingContinuation { cont in
+            self.continuations[packetId] = cont
+            self.writeContinuation.yield(TcpMessage(packetId: packetId, type: type, data: data))
+            Task {
+                try? await Task.sleep(for: timeout)
+                self.timeout(packetId: packetId)
+            }
+        }
+    }
+    
+    func send(type: SDLPacketType, packetId: UInt32, data: Data) {
+        self.writeContinuation.yield(TcpMessage(packetId: packetId, type: type, data: data))
+    }
+    
+    // 处理回调函数
+    private func fireCallback(message: SDLSuperInboundMessage) {
+        guard let cont = self.continuations.removeValue(forKey: message.msgId) else {
+            return
+        }
+        cont.resume(returning: message)
+    }
+    
+    private func failAllContinuations(_ error: Error) {
+        let all = continuations
+        continuations.removeAll()
+
+        for (_, cont) in all {
+            cont.resume(throwing: error)
+        }
+    }
+    
+    private func timeout(packetId: UInt32) {
+        guard let cont = self.continuations.removeValue(forKey: packetId) else {
+            return
+        }
+        cont.resume(throwing: SuperClientError.timeout)
+    }
+    
+    deinit {
+        try! group.syncShutdownGracefully()
+    }
+    
+}
+
+// --MARK: 编解码器
+private struct SDLSuperClientDecoder {
+    // 消息格式为: <<MsgId:32, Type:8, Body/binary>>
+    static func decode(buffer: inout ByteBuffer) -> SDLSuperInboundMessage? {
+        guard let msgId = buffer.readInteger(as: UInt32.self),
+              let type = buffer.readInteger(as: UInt8.self),
+              let messageType = SDLPacketType(rawValue: type) else {
+            return nil
+        }
+        
+        switch messageType {
+        case .empty:
+            return .init(msgId: msgId, packet: .empty)
+        case .registerSuperAck:
+            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+                  let registerSuperAck = try? SDLRegisterSuperAck(serializedBytes: bytes) else {
+                return nil
+            }
+            return .init(msgId: msgId, packet: .registerSuperAck(registerSuperAck))
+            
+        case .registerSuperNak:
+            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+                  let registerSuperNak = try? SDLRegisterSuperNak(serializedBytes: bytes) else {
+                return nil
+            }
+            return .init(msgId: msgId, packet: .registerSuperNak(registerSuperNak))
+            
+        case .peerInfo:
+            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+                  let peerInfo = try? SDLPeerInfo(serializedBytes: bytes) else {
+                return nil
+            }
+            
+            return .init(msgId: msgId, packet: .peerInfo(peerInfo))
+        case .pong:
+            return .init(msgId: msgId, packet: .pong)
+            
+        case .command:
+            guard let commandVal = buffer.readInteger(as: UInt8.self),
+                  let command = SDLCommandType(rawValue: commandVal),
+                  let bytes = buffer.readBytes(length: buffer.readableBytes) else {
+                return nil
+            }
+            
+            switch command {
+            case .changeNetwork:
+                guard let changeNetworkCommand = try? SDLChangeNetworkCommand(serializedBytes: bytes) else {
+                    return nil
+                }
+                
+                return .init(msgId: msgId, packet: .command(.changeNetwork(changeNetworkCommand)))
+            }
+            
+        case .event:
+            guard let eventVal = buffer.readInteger(as: UInt8.self),
+                  let event = SDLEventType(rawValue: eventVal),
+                  let bytes = buffer.readBytes(length: buffer.readableBytes) else {
+                return nil
+            }
+            
+            switch event {
+            case .natChanged:
+                guard let natChangedEvent = try? SDLNatChangedEvent(serializedBytes: bytes) else {
+                    return nil
+                }
+                return .init(msgId: msgId, packet: .event(.natChanged(natChangedEvent)))
+            case .sendRegister:
+                guard let sendRegisterEvent = try? SDLSendRegisterEvent(serializedBytes: bytes) else {
+                    return nil
+                }
+                return .init(msgId: msgId, packet: .event(.sendRegister(sendRegisterEvent)))
+            case .networkShutdown:
+                guard let networkShutdownEvent = try? SDLNetworkShutdownEvent(serializedBytes: bytes) else {
+                    return nil
+                }
+                return .init(msgId: msgId, packet: .event(.networkShutdown(networkShutdownEvent)))
+            }
+            
+        default:
+            return nil
+        }
+    }
+}
+
+private final class FixedHeaderEncoder: MessageToByteEncoder, @unchecked Sendable {
+    typealias InboundIn = ByteBuffer
+    typealias InboundOut = ByteBuffer
+    
+    func encode(data: ByteBuffer, out: inout ByteBuffer) throws {
+        let len = data.readableBytes
+        out.writeInteger(UInt16(len))
+        out.writeBytes(data.readableBytesView)
+    }
+}
+
+private final class FixedHeaderDecoder: ByteToMessageDecoder, @unchecked Sendable {
+    typealias InboundIn = ByteBuffer
+    typealias InboundOut = ByteBuffer
+    
+    func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
+        guard let len = buffer.getInteger(at: buffer.readerIndex, endianness: .big, as: UInt16.self) else {
+            return .needMoreData
+        }
+        
+        if buffer.readableBytes >= len + 2 {
+            buffer.moveReaderIndex(forwardBy: 2)
+            if let bytes = buffer.readBytes(length: Int(len)) {
+                context.fireChannelRead(self.wrapInboundOut(ByteBuffer(bytes: bytes)))
+            }
+            return .continue
+        } else {
+            return .needMoreData
+        }
+    }
+}

Tun/Punchnet/Actors/SDLTunnelProviderActor.swift

@@ -0,0 +1,89 @@
+//
+//  SDLContext.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/2/29.
+//
+
+import Foundation
+import NetworkExtension
+import NIOCore
+import Combine
+
+// 上下文环境变量，全局共享
+/*
+1. 处理rsa的加解密逻辑
+ */
+
+actor SDLTunnelProviderActor {
+    
+    // 路由信息
+    struct Route {
+        let dstAddress: String
+        let subnetMask: String
+        
+        var debugInfo: String {
+            return "\(dstAddress):\(subnetMask)"
+        }
+    }
+    
+    // 数据包读取任务
+    private var readTask: Task<(), Never>?
+    
+    let provider: NEPacketTunnelProvider
+    let logger: SDLLogger
+    
+    public init(provider: NEPacketTunnelProvider, logger: SDLLogger) {
+        self.logger = logger
+        self.provider = provider
+    }
+    
+    func writePackets(packets: [NEPacket]) {
+        //let packet = NEPacket(data: ipPacket.data, protocolFamily: 2)
+        self.provider.packetFlow.writePacketObjects(packets)
+    }
+    
+    // 网络改变时需要重新配置网络信息
+    func setNetworkSettings(devAddr: SDLDevAddr, dnsServer: String) async throws -> String {
+        let netAddress = SDLNetAddress(ip: devAddr.netAddr, maskLen: UInt8(devAddr.netBitLen))
+        let routes = [
+            Route(dstAddress: netAddress.networkAddress, subnetMask: netAddress.maskAddress),
+            Route(dstAddress: dnsServer, subnetMask: "255.255.255.255")
+        ]
+        
+        // Add code here to start the process of connecting the tunnel.
+        let networkSettings = NEPacketTunnelNetworkSettings(tunnelRemoteAddress: "8.8.8.8")
+        networkSettings.mtu = 1460
+        
+        // 设置网卡的DNS解析
+        
+        let networkDomain = devAddr.networkDomain
+        let dnsSettings = NEDNSSettings(servers: [dnsServer])
+        dnsSettings.searchDomains = [networkDomain]
+        dnsSettings.matchDomains = [networkDomain]
+        dnsSettings.matchDomainsNoSearch = false
+        networkSettings.dnsSettings = dnsSettings
+        self.logger.log("[SDLContext] Tun started at network ip: \(netAddress.ipAddress), mask: \(netAddress.maskAddress)", level: .info)
+        
+        let ipv4Settings = NEIPv4Settings(addresses: [netAddress.ipAddress], subnetMasks: [netAddress.maskAddress])
+        // 设置路由表
+        //NEIPv4Route.default()
+        ipv4Settings.includedRoutes = routes.map { route in
+            NEIPv4Route(destinationAddress: route.dstAddress, subnetMask: route.subnetMask)
+        }
+        networkSettings.ipv4Settings = ipv4Settings
+        // 网卡配置设置必须成功
+        try await self.provider.setTunnelNetworkSettings(networkSettings)
+        
+        return netAddress.ipAddress
+    }
+    
+    // 开始读取数据, 用单独的线程处理packetFlow
+    func readPackets() async -> [Data] {
+        let (packets, numbers) = await self.provider.packetFlow.readPackets()
+        return zip(packets, numbers).compactMap { (data, number) in
+            return number == 2 ? data : nil
+        }
+    }
+    
+}

Tun/Punchnet/Actors/SDLUDPHoleActor.swift

@@ -0,0 +1,210 @@
+//
+//  SDLanServer.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/1/31.
+//
+
+import Foundation
+import NIOCore
+import NIOPosix
+
+// 处理和sn-server服务器之间的通讯
+actor SDLUDPHoleActor {
+    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    private let asyncChannel: NIOAsyncChannel<AddressedEnvelope<ByteBuffer>, AddressedEnvelope<ByteBuffer>>
+    private let (writeStream, writeContinuation) = AsyncStream.makeStream(of: UDPMessage.self, bufferingPolicy: .unbounded)
+    
+    private var cookieGenerator = SDLIdGenerator(seed: 1)
+    private var promises: [UInt32:EventLoopPromise<SDLStunProbeReply>] = [:]
+    public var localAddress: SocketAddress?
+    
+    public let eventFlow: AsyncStream<UDPEvent>
+    private let eventContinuation: AsyncStream<UDPEvent>.Continuation
+    
+    private let logger: SDLLogger
+    
+    // 依赖的外表能力
+    struct Capabilities {
+        let logger: @Sendable (String) async -> Void
+        
+    }
+    
+    struct UDPMessage {
+        let remoteAddress: SocketAddress
+        let type: SDLPacketType
+        let data: Data
+    }
+
+    // 定义事件类型
+    enum UDPEvent {
+        case ready
+        case message(SocketAddress, SDLHoleInboundMessage)
+        case data(SDLData)
+    }
+    
+    // 启动函数
+    init(logger: SDLLogger) async throws {
+        self.logger = logger
+        
+        (self.eventFlow, self.eventContinuation) = AsyncStream.makeStream(of: UDPEvent.self, bufferingPolicy: .unbounded)
+        
+        let bootstrap = DatagramBootstrap(group: group)
+            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
+        
+        self.asyncChannel = try await bootstrap.bind(host: "0.0.0.0", port: 0)
+            .flatMapThrowing { channel in
+                return try NIOAsyncChannel(wrappingChannelSynchronously: channel, configuration: .init(
+                    inboundType: AddressedEnvelope<ByteBuffer>.self,
+                    outboundType: AddressedEnvelope<ByteBuffer>.self
+                ))
+            }
+            .get()
+        
+        self.localAddress = self.asyncChannel.channel.localAddress
+        self.logger.log("[UDPHole] started and listening on: \(self.localAddress!)", level: .debug)
+    }
+    
+    func start() async throws {
+        try await withTaskCancellationHandler {
+            try await self.asyncChannel.executeThenClose {inbound, outbound in
+                self.eventContinuation.yield(.ready)
+                try await withThrowingTaskGroup(of: Void.self) { group in
+                    group.addTask {
+                        defer {
+                            self.logger.log("[SDLUDPHole] inbound closed", level: .warning)
+                        }
+                        
+                        for try await envelope in inbound {
+                            try Task.checkCancellation()
+                            
+                            var buffer = envelope.data
+                            let remoteAddress = envelope.remoteAddress
+                            do {
+                                if let message = try Self.decode(buffer: &buffer) {
+                                    switch message {
+                                    case .data(let data):
+                                        self.logger.log("[SDLUDPHole] read data: \(data.format()), from: \(remoteAddress)", level: .debug)
+                                        self.eventContinuation.yield(.data(data))
+                                    case .stunProbeReply(let probeReply):
+                                        // 执行并移除回调
+                                        await self.trigger(probeReply: probeReply)
+                                    default:
+                                        self.eventContinuation.yield(.message(remoteAddress, message))
+                                    }
+                                } else {
+                                    self.logger.log("[SDLUDPHole] decode message, get null", level: .warning)
+                                }
+                            } catch let err {
+                                self.logger.log("[SDLUDPHole] decode message, get error: \(err)", level: .warning)
+                                throw err
+                            }
+                        }
+                    }
+                    
+                    group.addTask {
+                        defer {
+                            self.logger.log("[SDLUDPHole] outbound closed", level: .warning)
+                        }
+                        
+                        for await message in self.writeStream {
+                            try Task.checkCancellation()
+                            
+                            var buffer = self.asyncChannel.channel.allocator.buffer(capacity: message.data.count + 1)
+                            buffer.writeBytes([message.type.rawValue])
+                            buffer.writeBytes(message.data)
+                            
+                            let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: message.remoteAddress, data: buffer)
+                            try await outbound.write(envelope)
+                        }
+                    }
+                    
+                    if let _ = try await group.next() {
+                        group.cancelAll()
+                    }
+                }
+            }
+        } onCancel: {
+            self.writeContinuation.finish()
+            self.eventContinuation.finish()
+            self.logger.log("[SDLUDPHole] withTaskCancellationHandler cancel")
+        }
+    }
+    
+    func getCookieId() -> UInt32 {
+        return self.cookieGenerator.nextId()
+    }
+    
+    // 探测tun信息
+    func stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int = 5) async throws -> SDLStunProbeReply {
+        return try await self._stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: timeout).get()
+    }
+    
+    private func _stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int) -> EventLoopFuture<SDLStunProbeReply> {
+        let cookie = self.cookieGenerator.nextId()
+        var stunProbe = SDLStunProbe()
+        stunProbe.cookie = cookie
+        stunProbe.attr = UInt32(attr.rawValue)
+        self.send( type: .stunProbe, data: try! stunProbe.serializedData(), remoteAddress: remoteAddress)
+        self.logger.log("[SDLUDPHole] stunProbe: \(remoteAddress)", level: .debug)
+        
+        let promise = self.asyncChannel.channel.eventLoop.makePromise(of: SDLStunProbeReply.self)
+        self.promises[cookie] = promise
+        
+        return promise.futureResult
+    }
+    
+    private func trigger(probeReply: SDLStunProbeReply) {
+        let id = probeReply.cookie
+        // 执行并移除回调
+        if let promise = self.promises[id] {
+            self.asyncChannel.channel.eventLoop.execute {
+                promise.succeed(probeReply)
+            }
+            self.promises.removeValue(forKey: id)
+        }
+    }
+    
+    // MARK: client-client apis
+    // 处理写入逻辑
+    func send(type: SDLPacketType, data: Data, remoteAddress: SocketAddress) {
+        let message = UDPMessage(remoteAddress: remoteAddress, type: type, data: data)
+        self.writeContinuation.yield(message)
+    }
+    
+    //--MARK: 编解码器
+    private static func decode(buffer: inout ByteBuffer) throws -> SDLHoleInboundMessage? {
+        guard let type = buffer.readInteger(as: UInt8.self),
+              let packetType = SDLPacketType(rawValue: type),
+              let bytes = buffer.readBytes(length: buffer.readableBytes) else {
+            return nil
+        }
+        
+        switch packetType {
+        case .data:
+            let dataPacket = try SDLData(serializedBytes: bytes)
+            return .data(dataPacket)
+        case .register:
+            let registerPacket = try SDLRegister(serializedBytes: bytes)
+            return .register(registerPacket)
+        case .registerAck:
+            let registerAck = try SDLRegisterAck(serializedBytes: bytes)
+            return .registerAck(registerAck)
+        case .stunReply:
+            let stunReply = try SDLStunReply(serializedBytes: bytes)
+            return .stunReply(stunReply)
+        case .stunProbeReply:
+            let stunProbeReply = try SDLStunProbeReply(serializedBytes: bytes)
+            return .stunProbeReply(stunProbeReply)
+        default:
+            return nil
+        }
+    }
+    
+    deinit {
+        try? self.group.syncShutdownGracefully()
+        self.writeContinuation.finish()
+        self.eventContinuation.finish()
+    }
+    
+}

Tun/Punchnet/ArpServer.swift

@@ -0,0 +1,31 @@
+//
+//  ArpServer.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/7/14.
+//
+import Foundation
+
+actor ArpServer {
+    private var known_macs: [UInt32:Data] = [:]
+    
+    init(known_macs: [UInt32:Data]) {
+        self.known_macs = known_macs
+    }
+    
+    func query(ip: UInt32) -> Data? {
+        return self.known_macs[ip]
+    }
+    
+    func append(ip: UInt32, mac: Data) {
+        self.known_macs[ip] = mac
+    }
+    
+    func remove(ip: UInt32) {
+        self.known_macs.removeValue(forKey: ip)
+    }
+    
+    func clear() {
+        self.known_macs = [:]
+    }
+}

Tun/Punchnet/IPPacket.swift

@@ -54,7 +54,6 @@ enum TransportProtocol: UInt8 {
     case icmp = 1
     case tcp = 6
     case udp = 17
-    
 }
 
 struct IPPacket {
@@ -80,4 +79,8 @@ struct IPPacket {
         self.data = data
     }
     
+    // 获取负载部分
+    func getPayload() -> Data {
+        return data.subdata(in: 20..<data.count)
+    }
 }

Tun/Punchnet/LayerPacket.swift

@@ -19,7 +19,6 @@ struct LayerPacket {
     
     enum LayerPacketError: Error {
         case invalidLength
-        case crcError
         case invaldPacketType
     }
     
@@ -69,19 +68,6 @@ struct LayerPacket {
             throw LayerPacketError.invalidLength
         }
         
-        /*
-        let idx = layerData.count - 4
-        let playload = layerData.subdata(in: 0..<idx)
-        let crc = layerData.subdata(in: idx..<layerData.count)
-        
-        guard Self.crc32(data: playload) == UInt32(data: crc) else {
-            
-            NSLog("play crc32: \(Self.crc32(data: playload)), get: \(UInt32(data: crc))")
-            
-            throw LayerPacketError.crcError
-        }
-         */
-        
         self.dstMac = Data(playload[0..<6])
         self.srcMac = Data(playload[6..<12])
         guard let type = PacketType(rawValue: UInt16(bytes: (playload[12], playload[13]))) else {
@@ -99,10 +85,6 @@ struct LayerPacket {
         packet.append(self.type.rawValue.data())
         packet.append(self.data)
         
-        // 计算crc32的值
-        //let crc32 = data.crc32()
-        //packet.append(Data(uint32: Self.crc32(data: packet)))
-        
         return packet
     }
     

Tun/Punchnet/RSACipher.swift

@@ -0,0 +1,13 @@
+//
+//  RSACipher.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/7/14.
+//
+import Foundation
+
+public protocol RSACipher {
+    var pubKey: String {get set}
+    
+    func decode(data: Data) throws -> Data
+}

Tun/Punchnet/SDLConfiguration.swift

@@ -0,0 +1,72 @@
+//
+//  SDLConfiguration.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/7/14.
+//
+import Foundation
+import NIOCore
+
+// 配置项目
+public class SDLConfiguration {
+    
+    public struct StunServer {
+        public let host: String
+        public let ports: [Int]
+        
+        public init(host: String, ports: [Int]) {
+            self.host = host
+            self.ports = ports
+        }
+    }
+    
+    // 当前的客户端版本
+    let version: UInt8
+    
+    // 安装渠道
+    let installedChannel: String
+    
+    let superHost: String
+    let superPort: Int
+    
+    let stunServers: [StunServer]
+    
+    let remoteDnsServer: String
+    let hostname: String
+    
+    let noticePort: Int
+    
+    lazy var stunSocketAddress: SocketAddress = {
+        let stunServer = stunServers[0]
+        return try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0])
+    }()
+    
+    // 网络探测地址信息
+    lazy var stunProbeSocketAddressArray: [[SocketAddress]] = {
+        return stunServers.map { stunServer in
+            [
+                try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0]),
+                try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[1])
+            ]
+        }
+    }()
+    
+    let clientId: String
+    let token: String
+    let networkCode: String
+    
+    public init(version: UInt8, installedChannel: String, superHost: String, superPort: Int, stunServers: [StunServer], clientId: String, noticePort: Int, token: String, networkCode: String, remoteDnsServer: String, hostname: String) {
+        self.version = version
+        self.installedChannel = installedChannel
+        self.superHost = superHost
+        self.superPort = superPort
+        self.stunServers = stunServers
+        self.clientId = clientId
+        self.noticePort = noticePort
+        self.token = token
+        self.networkCode = networkCode
+        self.remoteDnsServer = remoteDnsServer
+        self.hostname = hostname
+    }
+    
+}

Tun/Punchnet/SDLContext.swift

@@ -0,0 +1,715 @@
+//
+//  SDLContext.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/2/29.
+//
+
+import Foundation
+import NetworkExtension
+import NIOCore
+import Combine
+
+// 上下文环境变量，全局共享
+/*
+1. 处理rsa的加解密逻辑
+ */
+
+@available(macOS 14, *)
+public class SDLContext {
+    
+    // 路由信息
+    struct Route {
+        let dstAddress: String
+        let subnetMask: String
+        
+        var debugInfo: String {
+            return "\(dstAddress):\(subnetMask)"
+        }
+    }
+    
+    let config: SDLConfiguration
+
+    // tun网络地址信息
+    var devAddr: SDLDevAddr
+    
+    // nat映射的相关信息, 暂时没有用处
+    //var natAddress: SDLNatAddress?
+    // nat的网络类型
+    var natType: NatType = .blocked
+    
+    // AES加密，授权通过后，对象才会被创建
+    var aesCipher: AESCipher
+    
+    // aes
+    var aesKey: Data = Data()
+    
+    // rsa的相关配置, public_key是本地生成的
+    let rsaCipher: RSACipher
+    
+    // 依赖的变量
+    var udpHoleActor: SDLUDPHoleActor?
+    var superClientActor: SDLSuperClientActor?
+    var providerActor: SDLTunnelProviderActor
+    var puncherActor: SDLPuncherActor
+    // dns的client对象
+    var dnsClientActor: SDLDNSClientActor?
+    
+    // 数据包读取任务
+    private var readTask: Task<(), Never>?
+    
+    private var sessionManager: SessionManager
+    private var arpServer: ArpServer
+    
+    // 记录最后发送的stunRequest的cookie
+    private var lastCookie: UInt32? = 0
+    
+    // 网络状态变化的健康
+    private var monitor: SDLNetworkMonitor?
+    
+    // 内部socket通讯
+    private var noticeClient: SDLNoticeClient?
+    
+    // 流量统计
+    private var flowTracer = SDLFlowTracerActor()
+    private var flowTracerCancel: AnyCancellable?
+    
+    private let logger: SDLLogger
+    private var rootTask: Task<Void, Error>?
+    
+    public init(provider: NEPacketTunnelProvider, config: SDLConfiguration, rsaCipher: RSACipher, aesCipher: AESCipher, logger: SDLLogger) {
+        self.logger = logger
+        
+        self.config = config
+        self.rsaCipher = rsaCipher
+        self.aesCipher = aesCipher
+        
+        // 生成mac地址
+        var devAddr = SDLDevAddr()
+        devAddr.mac = Self.getMacAddress()
+        self.devAddr = devAddr
+        
+        self.sessionManager = SessionManager()
+        self.arpServer = ArpServer(known_macs: [:])
+        self.providerActor = SDLTunnelProviderActor(provider: provider, logger: logger)
+        self.puncherActor = SDLPuncherActor(logger: logger)
+    }
+    
+    public func start() async throws {
+        self.rootTask = Task {
+            try await withThrowingTaskGroup(of: Void.self) { group in
+                group.addTask {
+                    while !Task.isCancelled {
+                        do {
+                            try await self.startDnsClient()
+                        } catch let err {
+                            self.logger.log("[SDLContext] UDPHole get err: \(err)", level: .warning)
+                            try await Task.sleep(for: .seconds(2))
+                        }
+                    }
+                }
+                
+                group.addTask {
+                    while !Task.isCancelled {
+                        do {
+                            try await self.startUDPHole()
+                        } catch let err {
+                            self.logger.log("[SDLContext] UDPHole get err: \(err)", level: .warning)
+                            try await Task.sleep(for: .seconds(2))
+                        }
+                    }
+                }
+                
+                group.addTask {
+                    while !Task.isCancelled {
+                        do {
+                            try await self.startSuperClient()
+                        } catch let err {
+                            self.logger.log("[SDLContext] SuperClient get error: \(err), will restart", level: .warning)
+                            await self.arpServer.clear()
+                            try await Task.sleep(for: .seconds(2))
+                        }
+                    }
+                }
+                
+                group.addTask {
+                    await self.startMonitor()
+                }
+                
+                group.addTask {
+                    while !Task.isCancelled {
+                        do {
+                            try await self.startNoticeClient()
+                        } catch let err {
+                            self.logger.log("[SDLContext] noticeClient get err: \(err)", level: .warning)
+                            try await Task.sleep(for: .seconds(2))
+                        }
+                    }
+                }
+                
+                try await group.waitForAll()
+            }
+        }
+        
+        try await self.rootTask?.value
+    }
+    
+    public func stop() async {
+        self.rootTask?.cancel()
+        self.superClientActor = nil
+        self.udpHoleActor = nil
+        self.noticeClient = nil
+
+        self.readTask?.cancel()
+    }
+    
+    private func startNoticeClient() async throws {
+        self.noticeClient = try await SDLNoticeClient(noticePort: self.config.noticePort, logger: self.logger)
+        try await self.noticeClient?.start()
+        self.logger.log("[SDLContext] notice_client task cancel", level: .warning)
+    }
+    
+    private func startUDPHole() async throws {
+        self.udpHoleActor = try await SDLUDPHoleActor(logger: self.logger)
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            group.addTask {
+                try await self.udpHoleActor?.start()
+            }
+            
+            group.addTask {
+                while !Task.isCancelled {
+                    try Task.checkCancellation()
+                    try await Task.sleep(nanoseconds: 5 * 1_000_000_000)
+                    try Task.checkCancellation()
+
+                    if let udpHoleActor = self.udpHoleActor {
+                        let cookie = await udpHoleActor.getCookieId()
+                        var stunRequest = SDLStunRequest()
+                        stunRequest.cookie = cookie
+                        stunRequest.clientID = self.config.clientId
+                        stunRequest.networkID = self.devAddr.networkID
+                        stunRequest.ip = self.devAddr.netAddr
+                        stunRequest.mac = self.devAddr.mac
+                        stunRequest.natType = UInt32(self.natType.rawValue)
+                        
+                        let remoteAddress = self.config.stunSocketAddress
+                        await udpHoleActor.send(type: .stunRequest, data: try stunRequest.serializedData(), remoteAddress: remoteAddress)
+                        self.lastCookie = cookie
+                    }
+                }
+            }
+            
+            group.addTask {
+                if let eventFlow = self.udpHoleActor?.eventFlow {
+                    for try await event in eventFlow {
+                        try Task.checkCancellation()
+                        try await self.handleUDPEvent(event: event)
+                    }
+                }
+            }
+            
+            if let _ = try await group.next() {
+                group.cancelAll()
+            }
+        }
+        
+    }
+    
+    private func startSuperClient() async throws {
+        self.superClientActor = try await SDLSuperClientActor(host: self.config.superHost, port: self.config.superPort, logger: self.logger)
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            defer {
+                self.logger.log("[SDLContext] super client task cancel", level: .warning)
+            }
+            
+            group.addTask {
+                try await self.superClientActor?.start()
+            }
+            
+            group.addTask {
+                if let eventFlow = self.superClientActor?.eventFlow {
+                    for try await event in eventFlow {
+                        try await self.handleSuperEvent(event: event)
+                    }
+                }
+            }
+            
+            if let _ = try await group.next() {
+                group.cancelAll()
+            }
+        }
+    }
+    
+    private func startMonitor() async {
+        self.monitor = SDLNetworkMonitor()
+        for await event in self.monitor!.eventStream {
+            switch event {
+            case .changed:
+                // 需要重新探测网络的nat类型
+                self.natType = await self.getNatType()
+                self.logger.log("didNetworkPathChanged, nat type is: \(self.natType)", level: .info)
+            case .unreachable:
+                self.logger.log("didNetworkPathUnreachable", level: .warning)
+            }
+        }
+    }
+    
+    private func startDnsClient() async throws {
+        let remoteDnsServer = config.remoteDnsServer
+        let dnsSocketAddress = try SocketAddress.makeAddressResolvingHost(remoteDnsServer, port: 15353)
+        self.dnsClientActor = try await SDLDNSClientActor(dnsServerAddress: dnsSocketAddress, logger: self.logger)
+        
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            defer {
+                self.logger.log("[SDLContext] dns client task cancel", level: .warning)
+            }
+            
+            group.addTask {
+                try await self.dnsClientActor?.start()
+            }
+            
+            group.addTask {
+                if let packetFlow = self.dnsClientActor?.packetFlow {
+                    for await packet in packetFlow {
+                        let nePacket = NEPacket(data: packet, protocolFamily: 2)
+                        await self.providerActor.writePackets(packets: [nePacket])
+                    }
+                }
+                
+            }
+            
+            if let _ = try await group.next() {
+                group.cancelAll()
+            }
+        }
+    }
+    
+    private func handleSuperEvent(event: SDLSuperClientActor.SuperEvent) async throws {
+        switch event {
+        case .ready:
+            await self.puncherActor.setSuperClientActor(superClientActor: self.superClientActor)
+            
+            self.logger.log("[SDLContext] get registerSuper, mac address: \(SDLUtil.formatMacAddress(mac: self.devAddr.mac))", level: .debug)
+            var registerSuper = SDLRegisterSuper()
+            registerSuper.version = UInt32(self.config.version)
+            registerSuper.clientID = self.config.clientId
+            registerSuper.devAddr = self.devAddr
+            registerSuper.pubKey = self.rsaCipher.pubKey
+            registerSuper.token = self.config.token
+            registerSuper.networkCode = self.config.networkCode
+            registerSuper.hostname = self.config.hostname
+            guard let message = try await self.superClientActor?.request(type: .registerSuper, data: try registerSuper.serializedData()) else {
+                return
+            }
+            
+            switch message.packet {
+            case .registerSuperAck(let registerSuperAck):
+                // 需要对数据通过rsa的私钥解码
+                let aesKey = try! self.rsaCipher.decode(data: Data(registerSuperAck.aesKey))
+                let upgradeType = SDLUpgradeType(rawValue: registerSuperAck.upgradeType)
+                
+                self.logger.log("[SDLContext] get registerSuperAck, aes_key len: \(aesKey.count), network_id:\(registerSuperAck.devAddr.networkID)", level: .info)
+                self.devAddr = registerSuperAck.devAddr
+                
+                if upgradeType == .force {
+                    let forceUpgrade = NoticeMessage.upgrade(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
+                    await self.noticeClient?.send(data: forceUpgrade)
+                    exit(-1)
+                }
+                
+                // 服务器分配的tun网卡信息
+                do {
+                    let ipAddress = try await self.providerActor.setNetworkSettings(devAddr: self.devAddr, dnsServer: SDLDNSClientActor.Helper.dnsServer)
+                    await self.noticeClient?.send(data: NoticeMessage.ipAdress(ip: ipAddress))
+                    
+                    self.startReader()
+                } catch let err {
+                    self.logger.log("[SDLContext] setTunnelNetworkSettings get error: \(err)", level: .error)
+                    exit(-1)
+                }
+                
+                self.aesKey = aesKey
+                if upgradeType == .normal {
+                    let normalUpgrade = NoticeMessage.upgrade(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
+                    await self.noticeClient?.send(data: normalUpgrade)
+                }
+                
+            case .registerSuperNak(let nakPacket):
+                let errorMessage = nakPacket.errorMessage
+                guard let errorCode = SDLNAKErrorCode(rawValue: UInt8(nakPacket.errorCode)) else {
+                    return
+                }
+                
+                switch errorCode {
+                case .invalidToken, .nodeDisabled:
+                    let alertNotice = NoticeMessage.alert(alert: errorMessage)
+                    await self.noticeClient?.send(data: alertNotice)
+                    exit(-1)
+                case .noIpAddress, .networkFault, .internalFault:
+                    let alertNotice = NoticeMessage.alert(alert: errorMessage)
+                    await self.noticeClient?.send(data: alertNotice)
+                }
+                self.logger.log("[SDLContext] Get a SuperNak message exit", level: .warning)
+            default:
+                ()
+            }
+            
+        case .event(let evt):
+            switch evt {
+            case .natChanged(let natChangedEvent):
+                let dstMac = natChangedEvent.mac
+                self.logger.log("[SDLContext] natChangedEvent, dstMac: \(dstMac)", level: .info)
+                await sessionManager.removeSession(dstMac: dstMac)
+            case .sendRegister(let sendRegisterEvent):
+                self.logger.log("[SDLContext] sendRegisterEvent, ip: \(sendRegisterEvent)", level: .debug)
+                let address = SDLUtil.int32ToIp(sendRegisterEvent.natIp)
+                if let remoteAddress = try? SocketAddress.makeAddressResolvingHost(address, port: Int(sendRegisterEvent.natPort)) {
+                    // 发送register包
+                    var register = SDLRegister()
+                    register.networkID = self.devAddr.networkID
+                    register.srcMac = self.devAddr.mac
+                    register.dstMac = sendRegisterEvent.dstMac
+                    await self.udpHoleActor?.send(type: .register, data: try register.serializedData(), remoteAddress: remoteAddress)
+                }
+                
+            case .networkShutdown(let shutdownEvent):
+                let alertNotice = NoticeMessage.alert(alert: shutdownEvent.message)
+                await self.noticeClient?.send(data: alertNotice)
+                exit(-1)
+            }
+        case .command(let packetId, let command):
+            switch command {
+            case .changeNetwork(let changeNetworkCommand):
+                // 需要对数据通过rsa的私钥解码
+                let aesKey = try! self.rsaCipher.decode(data: Data(changeNetworkCommand.aesKey))
+                self.logger.log("[SDLContext] change network command get aes_key len: \(aesKey.count)", level: .info)
+                self.devAddr = changeNetworkCommand.devAddr
+                
+                // 服务器分配的tun网卡信息
+                do {
+                    let ipAddress = try await self.providerActor.setNetworkSettings(devAddr: self.devAddr, dnsServer: SDLDNSClientActor.Helper.dnsServer)
+                    await self.noticeClient?.send(data: NoticeMessage.ipAdress(ip: ipAddress))
+                    
+                    self.startReader()
+                } catch let err {
+                    self.logger.log("[SDLContext] setTunnelNetworkSettings get error: \(err)", level: .error)
+                    exit(-1)
+                }
+                
+                self.aesKey = aesKey
+                
+                var commandAck = SDLCommandAck()
+                commandAck.status = true
+                await self.superClientActor?.send(type: .commandAck, packetId: packetId, data: try commandAck.serializedData())
+            }
+        }
+        
+    }
+
+    private func handleUDPEvent(event: SDLUDPHoleActor.UDPEvent) async throws {
+        switch event {
+        case .ready:
+            await self.puncherActor.setUDPHoleActor(udpHoleActor: self.udpHoleActor)
+            // 获取当前网络的类型
+            self.natType = await getNatType()
+            self.logger.log("[SDLContext] broadcast is: \(self.natType)", level: .debug)
+            
+        case .message(let remoteAddress, let message):
+            switch message {
+            case .register(let register):
+                self.logger.log("register packet: \(register), dev_addr: \(self.devAddr)", level: .debug)
+                // 判断目标地址是否是tun的网卡地址, 并且是在同一个网络下
+                if register.dstMac == self.devAddr.mac && register.networkID == self.devAddr.networkID {
+                    // 回复ack包
+                    var registerAck = SDLRegisterAck()
+                    registerAck.networkID = self.devAddr.networkID
+                    registerAck.srcMac = self.devAddr.mac
+                    registerAck.dstMac = register.srcMac
+                    
+                    await self.udpHoleActor?.send(type: .registerAck, data: try registerAck.serializedData(), remoteAddress: remoteAddress)
+                    // 这里需要建立到来源的会话, 在复杂网络下，通过super-node查询到的nat地址不一定靠谱，需要通过udp包的来源地址作为nat地址
+                    let session = Session(dstMac: register.srcMac, natAddress: remoteAddress)
+                    await self.sessionManager.addSession(session: session)
+                } else {
+                    self.logger.log("SDLContext didReadRegister get a invalid packet, because dst_ip not matched: \(register.dstMac)", level: .warning)
+                }
+            case .registerAck(let registerAck):
+                // 判断目标地址是否是tun的网卡地址, 并且是在同一个网络下
+                if registerAck.dstMac == self.devAddr.mac && registerAck.networkID == self.devAddr.networkID {
+                    let session = Session(dstMac: registerAck.srcMac, natAddress: remoteAddress)
+                    await self.sessionManager.addSession(session: session)
+                } else {
+                    self.logger.log("SDLContext didReadRegisterAck get a invalid packet, because dst_mac not matched: \(registerAck.dstMac)", level: .warning)
+                }
+            case .stunReply(let stunReply):
+                let cookie = stunReply.cookie
+                if cookie == self.lastCookie {
+                    // 记录下当前在nat上的映射信息，暂时没有用；后续会用来判断网络类型
+                    //self.natAddress = stunReply.natAddress
+                    self.logger.log("[SDLContext] get a stunReply: \(try! stunReply.jsonString())", level: .debug)
+                }
+            default:
+                ()
+            }
+            
+        case .data(let data):
+            let mac = LayerPacket.MacAddress(data: data.dstMac)
+            guard (data.dstMac == self.devAddr.mac || mac.isBroadcast() || mac.isMulticast()) else {
+                return
+            }
+            
+            guard let decyptedData = try? self.aesCipher.decypt(aesKey: self.aesKey, data: Data(data.data)) else {
+                return
+            }
+            
+            do {
+                let layerPacket = try LayerPacket(layerData: decyptedData)
+                
+                await self.flowTracer.inc(num: decyptedData.count, type: .inbound)
+                // 处理arp请求
+                switch layerPacket.type {
+                case .arp:
+                    // 判断如果收到的是arp请求
+                    if let arpPacket = ARPPacket(data: layerPacket.data)  {
+                        if arpPacket.targetIP == self.devAddr.netAddr {
+                            switch arpPacket.opcode {
+                            case .request:
+                                self.logger.log("[SDLContext] get arp request packet", level: .debug)
+                                let response = ARPPacket.arpResponse(for: arpPacket, mac: self.devAddr.mac, ip: self.devAddr.netAddr)
+                                await self.routeLayerPacket(dstMac: arpPacket.senderMAC, type: .arp, data: response.marshal())
+                            case .response:
+                                self.logger.log("[SDLContext] get arp response packet", level: .debug)
+                                await self.arpServer.append(ip: arpPacket.senderIP, mac: arpPacket.senderMAC)
+                            }
+                        } else {
+                            self.logger.log("[SDLContext] get invalid arp packet: \(arpPacket), target_ip: \(SDLUtil.int32ToIp(arpPacket.targetIP)), net ip: \(SDLUtil.int32ToIp(self.devAddr.netAddr))", level: .debug)
+                        }
+                    } else {
+                        self.logger.log("[SDLContext] get invalid arp packet", level: .debug)
+                    }
+                case .ipv4:
+                    guard let ipPacket = IPPacket(layerPacket.data), ipPacket.header.destination == self.devAddr.netAddr else {
+                        return
+                    }
+                    let packet = NEPacket(data: ipPacket.data, protocolFamily: 2)
+                    await self.providerActor.writePackets(packets: [packet])
+                default:
+                    self.logger.log("[SDLContext] get invalid packet", level: .debug)
+                }
+            } catch let err {
+                self.logger.log("[SDLContext] didReadData err: \(err)", level: .warning)
+            }
+        }
+        
+    }
+    
+    // 流量统计
+//    public func flowReportTask() {
+//        Task {
+//            // 每分钟汇报一次
+//            self.flowTracerCancel = Timer.publish(every: 60.0, on: .main, in: .common).autoconnect()
+//                .sink { _ in
+//                    Task {
+//                        let (forwardNum, p2pNum, inboundNum) = await self.flowTracer.reset()
+//                        await self.superClient?.flowReport(forwardNum: forwardNum, p2pNum: p2pNum, inboundNum: inboundNum)
+//                    }
+//                }
+//        }
+//    }
+    
+    // 开始读取数据, 用单独的线程处理packetFlow
+    private func startReader() {
+        //  停止之前的任务
+        self.readTask?.cancel()
+        
+        // 开启新的任务
+        self.readTask = Task(priority: .high) {
+            repeat {
+                let packets = await self.providerActor.readPackets()
+                for packet in packets {
+                    await self.dealPacket(data: packet)
+                }
+            } while true
+        }
+    }
+    
+    // 处理读取的每个数据包
+    private func dealPacket(data: Data) async {
+        guard let packet = IPPacket(data) else {
+            return
+        }
+        
+        if SDLDNSClientActor.Helper.isDnsRequestPacket(ipPacket: packet) {
+            let destIp = packet.header.destination_ip
+            self.logger.log("[DNSQuery] destIp: \(destIp), int: \(packet.header.destination.asIpAddress())", level: .debug)
+            await self.dnsClientActor?.forward(ipPacket: packet)
+        }
+        else {
+            Task.detached {
+                let dstIp = packet.header.destination
+                // 本地通讯, 目标地址是本地服务器的ip地址
+                if dstIp == self.devAddr.netAddr {
+                    let nePacket = NEPacket(data: packet.data, protocolFamily: 2)
+                    await self.providerActor.writePackets(packets: [nePacket])
+                    return
+                }
+                
+                // 查找arp缓存中是否有目标mac地址
+                if let dstMac = await self.arpServer.query(ip: dstIp) {
+                    await self.routeLayerPacket(dstMac: dstMac, type: .ipv4, data: packet.data)
+                }
+                else {
+                    self.logger.log("[SDLContext] dstIp: \(dstIp.asIpAddress()) arp query not found, broadcast", level: .debug)
+                    // 构造arp广播
+                    let arpReqeust = ARPPacket.arpRequest(senderIP: self.devAddr.netAddr, senderMAC: self.devAddr.mac, targetIP: dstIp)
+                    await self.routeLayerPacket(dstMac: ARPPacket.broadcastMac , type: .arp, data: arpReqeust.marshal())
+                }
+            }
+        }
+    }
+    
+    private func routeLayerPacket(dstMac: Data, type: LayerPacket.PacketType, data: Data) async {
+        // 将数据封装层2层的数据包
+        let layerPacket = LayerPacket(dstMac: dstMac, srcMac: self.devAddr.mac, type: type, data: data)
+        guard let encodedPacket = try? self.aesCipher.encrypt(aesKey: self.aesKey, data: layerPacket.marshal()) else {
+            return
+        }
+        
+        // 构造数据包
+        var dataPacket = SDLData()
+        dataPacket.networkID = self.devAddr.networkID
+        dataPacket.srcMac = self.devAddr.mac
+        dataPacket.dstMac = dstMac
+        dataPacket.ttl = 255
+        dataPacket.data = encodedPacket
+        
+        let data = try! dataPacket.serializedData()
+        // 广播地址不要去尝试打洞
+        if ARPPacket.isBroadcastMac(dstMac) {
+            // 通过super_node进行转发
+            await self.udpHoleActor?.send(type: .data, data: data, remoteAddress: self.config.stunSocketAddress)
+        }
+        else {
+            // 通过session发送到对端
+            if let session = await self.sessionManager.getSession(toAddress: dstMac) {
+                self.logger.log("[SDLContext] send packet by session: \(session)", level: .debug)
+                await self.udpHoleActor?.send(type: .data, data: data, remoteAddress: session.natAddress)
+                await self.flowTracer.inc(num: data.count, type: .p2p)
+            }
+            else {
+                // 通过super_node进行转发
+                await self.udpHoleActor?.send(type: .data, data: data, remoteAddress: self.config.stunSocketAddress)
+                // 流量统计
+                await self.flowTracer.inc(num: data.count, type: .forward)
+                // 尝试打洞
+                await self.puncherActor.submitRegisterRequest(request: .init(srcMac: self.devAddr.mac, dstMac: dstMac, networkId: self.devAddr.networkID))
+            }
+        }
+    }
+    
+    deinit {
+        self.rootTask?.cancel()
+        self.udpHoleActor = nil
+        self.superClientActor = nil
+        self.dnsClientActor = nil
+    }
+    
+    // 获取mac地址
+    public static func getMacAddress() -> Data {
+        let key = "gMacAddress2"
+        
+        let userDefaults = UserDefaults.standard
+        if let mac = userDefaults.value(forKey: key) as? Data {
+            return mac
+        }
+        else {
+            let mac = generateMacAddress()
+            userDefaults.setValue(mac, forKey: key)
+            
+            return mac
+        }
+    }
+    
+    // 随机生成mac地址
+    private static func generateMacAddress() -> Data {
+        var macAddress = [UInt8](repeating: 0, count: 6)
+        for i in 0..<6 {
+            macAddress[i] = UInt8.random(in: 0...255)
+        }
+        
+        return Data(macAddress)
+    }
+    
+}
+
+// 网络类型探测
+extension SDLContext {
+    // 定义nat类型
+    enum NatType: UInt8, Encodable {
+        case blocked = 0
+        case noNat = 1
+        case fullCone = 2
+        case portRestricted = 3
+        case coneRestricted = 4
+        case symmetric = 5
+    }
+    
+    // 获取当前所处的网络的nat类型
+    func getNatType() async -> NatType {
+        guard let udpHole = self.udpHoleActor else {
+            return .blocked
+        }
+        
+        let addressArray = config.stunProbeSocketAddressArray
+        // step1: ip1:port1 <---- ip1:port1
+        guard let natAddress1 = await getNatAddress(udpHole, remoteAddress: addressArray[0][0], attr: .none) else {
+            return .blocked
+        }
+        
+        // 网络没有在nat下
+        if await natAddress1 == udpHole.localAddress {
+            return .noNat
+        }
+        
+        // step2: ip2:port2 <---- ip2:port2
+        guard let natAddress2 = await getNatAddress(udpHole, remoteAddress: addressArray[1][1], attr: .none) else {
+            return .blocked
+        }
+        
+        // 如果natAddress2 的IP地址与上次回来的IP是不一样的，它就是对称型NAT; 这次的包也一定能发成功并收到
+        // 如果ip地址变了，这说明{dstIp, dstPort, srcIp, srcPort}, 其中有一个变了；则用新的ip地址
+        logger.log("[SDLNatProber] nat_address1: \(natAddress1), nat_address2: \(natAddress2)", level: .debug)
+        if let ipAddress1 = natAddress1.ipAddress, let ipAddress2 = natAddress2.ipAddress, ipAddress1 != ipAddress2 {
+            return .symmetric
+        }
+        
+        // step3: ip1:port1 <---- ip2:port2 (ip地址和port都变的情况)
+        // 如果能收到的，说明是完全锥形 说明是IP地址限制锥型NAT，如果不能收到说明是端口限制锥型。
+        if let natAddress3 = await getNatAddress(udpHole, remoteAddress: addressArray[0][0], attr: .peer) {
+            logger.log("[SDLNatProber] nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address3: \(natAddress3)", level: .debug)
+            return .fullCone
+        }
+        
+        // step3: ip1:port1 <---- ip1:port2 (port改变情况)
+        // 如果能收到的说明是IP地址限制锥型NAT，如果不能收到说明是端口限制锥型。
+        if let natAddress4 = await getNatAddress(udpHole, remoteAddress: addressArray[0][0], attr: .port) {
+            logger.log("[SDLNatProber] nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address4: \(natAddress4)", level: .debug)
+            return .coneRestricted
+        } else {
+            return .portRestricted
+        }
+    }
+    
+    private func getNatAddress(_ udpHole: SDLUDPHoleActor, remoteAddress: SocketAddress, attr: SDLProbeAttr) async -> SocketAddress? {
+        let stunProbeReply = try? await udpHole.stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: 5)
+        return stunProbeReply?.socketAddress()
+    }
+   
+}
+
+private extension UInt32 {
+    // 转换成ip地址
+    func asIpAddress() -> String {
+        return SDLUtil.int32ToIp(self)
+    }
+}

Tun/Punchnet/SDLError.swift

@@ -0,0 +1,11 @@
+//
+//  SDLError.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/8/2.
+//
+
+enum SDLError: Error {
+    case socketClosed
+    case socketError
+}

Tun/Punchnet/SDLLogger.swift

@@ -0,0 +1,46 @@
+//
+//  SDLLogger.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/3/13.
+//
+import Foundation
+import os.log
+
+public class SDLLogger: @unchecked Sendable {
+    public enum Level: Int8, CustomStringConvertible {
+        case debug = 0
+        case info = 1
+        case warning = 2
+        case error = 3
+        
+        public var description: String {
+            switch self {
+            case .debug:
+                return "Debug"
+            case .info:
+                return "Info"
+            case .warning:
+                return "Warning"
+            case .error:
+                return "Error"
+            }
+        }
+    }
+    
+    private let level: Level
+    private let log: OSLog
+    
+    public init(level: Level) {
+        self.level = level
+        self.log = OSLog(subsystem: "com.jihe.punchnet", category: "punchnet")
+    }
+    
+    public func log(_ message: String, level: Level = .debug) {
+        if self.level.rawValue <= level.rawValue {
+            //os_log("%{public}@: %{public}@", log: self.log, type: .debug, level.description, message)
+            NSLog("\(level.description): \(message)")
+        }
+    }
+    
+}

Tun/Punchnet/SDLMessage.pb.swift

@@ -1,5 +1,6 @@
 // DO NOT EDIT.
 // swift-format-ignore-file
+// swiftlint:disable all
 //
 // Generated by the Swift generator plugin for the protocol buffer compiler.
 // Source: sdlan_pb.proto
@@ -20,7 +21,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
   typealias Version = _2
 }
 
-struct SDLV4Info {
+struct SDLV4Info: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -36,7 +37,7 @@ struct SDLV4Info {
   init() {}
 }
 
-struct SDLV6Info {
+struct SDLV6Info: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -51,7 +52,7 @@ struct SDLV6Info {
 }
 
 /// 设备网络地址信息
-struct SDLDevAddr {
+struct SDLDevAddr: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -64,13 +65,15 @@ struct SDLDevAddr {
 
   var netBitLen: UInt32 = 0
 
+  var networkDomain: String = String()
+
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
 }
 
 /// tcp通讯消息
-struct SDLEmpty {
+struct SDLEmpty: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -80,7 +83,7 @@ struct SDLEmpty {
   init() {}
 }
 
-struct SDLRegisterSuper {
+struct SDLRegisterSuper: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -104,6 +107,10 @@ struct SDLRegisterSuper {
 
   var token: String = String()
 
+  var networkCode: String = String()
+
+  var hostname: String = String()
+
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
@@ -111,7 +118,7 @@ struct SDLRegisterSuper {
   fileprivate var _devAddr: SDLDevAddr? = nil
 }
 
-struct SDLRegisterSuperAck {
+struct SDLRegisterSuperAck: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -156,7 +163,7 @@ struct SDLRegisterSuperAck {
   fileprivate var _upgradeAddress: String? = nil
 }
 
-struct SDLRegisterSuperNak {
+struct SDLRegisterSuperNak: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -170,7 +177,7 @@ struct SDLRegisterSuperNak {
   init() {}
 }
 
-struct SDLQueryInfo {
+struct SDLQueryInfo: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -182,7 +189,7 @@ struct SDLQueryInfo {
   init() {}
 }
 
-struct SDLPeerInfo {
+struct SDLPeerInfo: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -198,8 +205,6 @@ struct SDLPeerInfo {
   /// Clears the value of `v4Info`. Subsequent reads from it will return its default value.
   mutating func clearV4Info() {self._v4Info = nil}
 
-  var natType: UInt32 = 0
-
   var v6Info: SDLV6Info {
     get {return _v6Info ?? SDLV6Info()}
     set {_v6Info = newValue}
@@ -217,7 +222,7 @@ struct SDLPeerInfo {
   fileprivate var _v6Info: SDLV6Info? = nil
 }
 
-struct SDLNatChangedEvent {
+struct SDLNatChangedEvent: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -231,7 +236,7 @@ struct SDLNatChangedEvent {
   init() {}
 }
 
-struct SDLSendRegisterEvent {
+struct SDLSendRegisterEvent: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -242,6 +247,8 @@ struct SDLSendRegisterEvent {
 
   var natPort: UInt32 = 0
 
+  var natType: UInt32 = 0
+
   var v6Info: SDLV6Info {
     get {return _v6Info ?? SDLV6Info()}
     set {_v6Info = newValue}
@@ -258,7 +265,7 @@ struct SDLSendRegisterEvent {
   fileprivate var _v6Info: SDLV6Info? = nil
 }
 
-struct SDLNetworkShutdownEvent {
+struct SDLNetworkShutdownEvent: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -270,7 +277,7 @@ struct SDLNetworkShutdownEvent {
   init() {}
 }
 
-struct SDLChangeNetworkCommand {
+struct SDLChangeNetworkCommand: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -293,7 +300,7 @@ struct SDLChangeNetworkCommand {
   fileprivate var _devAddr: SDLDevAddr? = nil
 }
 
-struct SDLCommandAck {
+struct SDLCommandAck: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -317,7 +324,7 @@ struct SDLCommandAck {
   fileprivate var _message: String? = nil
 }
 
-struct SDLFlows {
+struct SDLFlows: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -336,7 +343,7 @@ struct SDLFlows {
   init() {}
 }
 
-struct SDLStunRequest {
+struct SDLStunRequest: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -369,7 +376,7 @@ struct SDLStunRequest {
   fileprivate var _v6Info: SDLV6Info? = nil
 }
 
-struct SDLStunReply {
+struct SDLStunReply: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -381,7 +388,7 @@ struct SDLStunReply {
   init() {}
 }
 
-struct SDLData {
+struct SDLData: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -403,7 +410,7 @@ struct SDLData {
   init() {}
 }
 
-struct SDLRegister {
+struct SDLRegister: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -419,7 +426,7 @@ struct SDLRegister {
   init() {}
 }
 
-struct SDLRegisterAck {
+struct SDLRegisterAck: @unchecked Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -435,7 +442,7 @@ struct SDLRegisterAck {
   init() {}
 }
 
-struct SDLStunProbe {
+struct SDLStunProbe: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -449,7 +456,7 @@ struct SDLStunProbe {
   init() {}
 }
 
-struct SDLStunProbeReply {
+struct SDLStunProbeReply: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
@@ -465,31 +472,6 @@ struct SDLStunProbeReply {
   init() {}
 }
 
-#if swift(>=5.5) && canImport(_Concurrency)
-extension SDLV4Info: @unchecked Sendable {}
-extension SDLV6Info: @unchecked Sendable {}
-extension SDLDevAddr: @unchecked Sendable {}
-extension SDLEmpty: @unchecked Sendable {}
-extension SDLRegisterSuper: @unchecked Sendable {}
-extension SDLRegisterSuperAck: @unchecked Sendable {}
-extension SDLRegisterSuperNak: @unchecked Sendable {}
-extension SDLQueryInfo: @unchecked Sendable {}
-extension SDLPeerInfo: @unchecked Sendable {}
-extension SDLNatChangedEvent: @unchecked Sendable {}
-extension SDLSendRegisterEvent: @unchecked Sendable {}
-extension SDLNetworkShutdownEvent: @unchecked Sendable {}
-extension SDLChangeNetworkCommand: @unchecked Sendable {}
-extension SDLCommandAck: @unchecked Sendable {}
-extension SDLFlows: @unchecked Sendable {}
-extension SDLStunRequest: @unchecked Sendable {}
-extension SDLStunReply: @unchecked Sendable {}
-extension SDLData: @unchecked Sendable {}
-extension SDLRegister: @unchecked Sendable {}
-extension SDLRegisterAck: @unchecked Sendable {}
-extension SDLStunProbe: @unchecked Sendable {}
-extension SDLStunProbeReply: @unchecked Sendable {}
-#endif  // swift(>=5.5) && canImport(_Concurrency)
-
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 extension SDLV4Info: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
@@ -581,6 +563,7 @@ extension SDLDevAddr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
     2: .same(proto: "mac"),
     3: .standard(proto: "net_addr"),
     4: .standard(proto: "net_bit_len"),
+    5: .standard(proto: "network_domain"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -593,6 +576,7 @@ extension SDLDevAddr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
       case 2: try { try decoder.decodeSingularBytesField(value: &self.mac) }()
       case 3: try { try decoder.decodeSingularUInt32Field(value: &self.netAddr) }()
       case 4: try { try decoder.decodeSingularUInt32Field(value: &self.netBitLen) }()
+      case 5: try { try decoder.decodeSingularStringField(value: &self.networkDomain) }()
       default: break
       }
     }
@@ -611,6 +595,9 @@ extension SDLDevAddr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
     if self.netBitLen != 0 {
       try visitor.visitSingularUInt32Field(value: self.netBitLen, fieldNumber: 4)
     }
+    if !self.networkDomain.isEmpty {
+      try visitor.visitSingularStringField(value: self.networkDomain, fieldNumber: 5)
+    }
     try unknownFields.traverse(visitor: &visitor)
   }
 
@@ -619,6 +606,7 @@ extension SDLDevAddr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
     if lhs.mac != rhs.mac {return false}
     if lhs.netAddr != rhs.netAddr {return false}
     if lhs.netBitLen != rhs.netBitLen {return false}
+    if lhs.networkDomain != rhs.networkDomain {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
@@ -629,8 +617,8 @@ extension SDLEmpty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB
   static let _protobuf_nameMap = SwiftProtobuf._NameMap()
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
-    while let _ = try decoder.nextFieldNumber() {
-    }
+    // Load everything into unknown fields
+    while try decoder.nextFieldNumber() != nil {}
   }
 
   func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
@@ -652,6 +640,8 @@ extension SDLRegisterSuper: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
     4: .standard(proto: "dev_addr"),
     5: .standard(proto: "pub_key"),
     6: .same(proto: "token"),
+    7: .standard(proto: "network_code"),
+    8: .same(proto: "hostname"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -666,6 +656,8 @@ extension SDLRegisterSuper: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
       case 4: try { try decoder.decodeSingularMessageField(value: &self._devAddr) }()
       case 5: try { try decoder.decodeSingularStringField(value: &self.pubKey) }()
       case 6: try { try decoder.decodeSingularStringField(value: &self.token) }()
+      case 7: try { try decoder.decodeSingularStringField(value: &self.networkCode) }()
+      case 8: try { try decoder.decodeSingularStringField(value: &self.hostname) }()
       default: break
       }
     }
@@ -694,6 +686,12 @@ extension SDLRegisterSuper: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
     if !self.token.isEmpty {
       try visitor.visitSingularStringField(value: self.token, fieldNumber: 6)
     }
+    if !self.networkCode.isEmpty {
+      try visitor.visitSingularStringField(value: self.networkCode, fieldNumber: 7)
+    }
+    if !self.hostname.isEmpty {
+      try visitor.visitSingularStringField(value: self.hostname, fieldNumber: 8)
+    }
     try unknownFields.traverse(visitor: &visitor)
   }
 
@@ -704,6 +702,8 @@ extension SDLRegisterSuper: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
     if lhs._devAddr != rhs._devAddr {return false}
     if lhs.pubKey != rhs.pubKey {return false}
     if lhs.token != rhs.token {return false}
+    if lhs.networkCode != rhs.networkCode {return false}
+    if lhs.hostname != rhs.hostname {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
@@ -844,8 +844,7 @@ extension SDLPeerInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     1: .standard(proto: "dst_mac"),
     2: .standard(proto: "v4_info"),
-    3: .standard(proto: "nat_type"),
-    4: .standard(proto: "v6_info"),
+    3: .standard(proto: "v6_info"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -856,8 +855,7 @@ extension SDLPeerInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
       switch fieldNumber {
       case 1: try { try decoder.decodeSingularBytesField(value: &self.dstMac) }()
       case 2: try { try decoder.decodeSingularMessageField(value: &self._v4Info) }()
-      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.natType) }()
-      case 4: try { try decoder.decodeSingularMessageField(value: &self._v6Info) }()
+      case 3: try { try decoder.decodeSingularMessageField(value: &self._v6Info) }()
       default: break
       }
     }
@@ -874,11 +872,8 @@ extension SDLPeerInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
     try { if let v = self._v4Info {
       try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
     } }()
-    if self.natType != 0 {
-      try visitor.visitSingularUInt32Field(value: self.natType, fieldNumber: 3)
-    }
     try { if let v = self._v6Info {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
     } }()
     try unknownFields.traverse(visitor: &visitor)
   }
@@ -886,7 +881,6 @@ extension SDLPeerInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
   static func ==(lhs: SDLPeerInfo, rhs: SDLPeerInfo) -> Bool {
     if lhs.dstMac != rhs.dstMac {return false}
     if lhs._v4Info != rhs._v4Info {return false}
-    if lhs.natType != rhs.natType {return false}
     if lhs._v6Info != rhs._v6Info {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
@@ -937,7 +931,8 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
     1: .standard(proto: "dst_mac"),
     2: .standard(proto: "nat_ip"),
     3: .standard(proto: "nat_port"),
-    4: .standard(proto: "v6_info"),
+    4: .standard(proto: "nat_type"),
+    5: .standard(proto: "v6_info"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -949,7 +944,8 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
       case 1: try { try decoder.decodeSingularBytesField(value: &self.dstMac) }()
       case 2: try { try decoder.decodeSingularUInt32Field(value: &self.natIp) }()
       case 3: try { try decoder.decodeSingularUInt32Field(value: &self.natPort) }()
-      case 4: try { try decoder.decodeSingularMessageField(value: &self._v6Info) }()
+      case 4: try { try decoder.decodeSingularUInt32Field(value: &self.natType) }()
+      case 5: try { try decoder.decodeSingularMessageField(value: &self._v6Info) }()
       default: break
       }
     }
@@ -969,8 +965,11 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
     if self.natPort != 0 {
       try visitor.visitSingularUInt32Field(value: self.natPort, fieldNumber: 3)
     }
+    if self.natType != 0 {
+      try visitor.visitSingularUInt32Field(value: self.natType, fieldNumber: 4)
+    }
     try { if let v = self._v6Info {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
     } }()
     try unknownFields.traverse(visitor: &visitor)
   }
@@ -979,6 +978,7 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
     if lhs.dstMac != rhs.dstMac {return false}
     if lhs.natIp != rhs.natIp {return false}
     if lhs.natPort != rhs.natPort {return false}
+    if lhs.natType != rhs.natType {return false}
     if lhs._v6Info != rhs._v6Info {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true

Tun/Punchnet/SDLMessage.swift

@@ -54,7 +54,7 @@ enum SDLUpgradeType: UInt32 {
 }
 
 // Id生成器
-struct SDLIdGenerator {
+struct SDLIdGenerator: Sendable {
     // 消息体id
     private var packetId: UInt32
     
@@ -153,4 +153,14 @@ struct SDLSuperInboundMessage {
         case event(SDLEvent)
         case command(SDLCommand)
     }
+    
+    func isPong() -> Bool {
+        switch self.packet {
+        case .pong:
+            return true
+        default:
+            return false
+        }
+    }
+    
 }

Tun/Punchnet/SDLNetworkMonitor.swift

@@ -10,14 +10,14 @@ import Network
 import Combine
 
 // 监控网络的变化
-class SDLNetworkMonitor {
+class SDLNetworkMonitor: @unchecked Sendable {
     private var monitor: NWPathMonitor
     private var interfaceType: NWInterface.InterfaceType?
     private let publisher = PassthroughSubject<NWInterface.InterfaceType, Never>()
     private var cancel: AnyCancellable?
-    private let queue = DispatchQueue(label: "networkMonitorQueue")
     
-    public let eventFlow = PassthroughSubject<MonitorEvent, Never>()
+    public let eventStream: AsyncStream<MonitorEvent>
+    private let eventContinuation: AsyncStream<MonitorEvent>.Continuation
     
     enum MonitorEvent {
         case changed
@@ -26,6 +26,7 @@ class SDLNetworkMonitor {
     
     init() {
         self.monitor = NWPathMonitor()
+        (self.eventStream , self.eventContinuation) = AsyncStream.makeStream(of: MonitorEvent.self, bufferingPolicy: .unbounded)
     }
     
     func start() {
@@ -39,16 +40,16 @@ class SDLNetworkMonitor {
                     self.publisher.send(.wiredEthernet)
                 }
             } else {
-                self.eventFlow.send(.unreachable)
+                self.eventContinuation.yield(.unreachable)
                 self.interfaceType = nil
             }
         }
-        self.monitor.start(queue: self.queue)
+        self.monitor.start(queue: DispatchQueue.global())
         
-        self.cancel = publisher.throttle(for: 5.0, scheduler: self.queue, latest: true)
+        self.cancel = publisher.throttle(for: 5.0, scheduler: DispatchQueue.global(), latest: true)
             .sink { type in
                 if self.interfaceType != nil && self.interfaceType != type {
-                    self.eventFlow.send(.changed)
+                    self.eventContinuation.yield(.changed)
                 }
                 self.interfaceType = type
             }
@@ -57,6 +58,7 @@ class SDLNetworkMonitor {
     deinit {
         self.monitor.cancel()
         self.cancel?.cancel()
+        self.eventContinuation.finish()
     }
     
 }

Tun/Punchnet/SDLNoticeClient.swift

@@ -0,0 +1,88 @@
+//
+//  SDLNoticeClient.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/5/20.
+//
+
+import Foundation
+
+//
+//  SDLanServer.swift
+//  Tun
+//
+//  Created by 安礼成 on 2024/1/31.
+//
+
+import Foundation
+import NIOCore
+import NIOPosix
+
+// 处理和sn-server服务器之间的通讯
+actor SDLNoticeClient {
+    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    private let asyncChannel: NIOAsyncChannel<AddressedEnvelope<ByteBuffer>, AddressedEnvelope<ByteBuffer>>
+    private let remoteAddress: SocketAddress
+    private let (writeStream, writeContinuation) = AsyncStream.makeStream(of: Data.self, bufferingPolicy: .unbounded)
+    
+    private let logger: SDLLogger
+    
+    // 启动函数
+    init(noticePort: Int, logger: SDLLogger) async throws {
+        self.logger = logger
+        
+        self.remoteAddress = try! SocketAddress(ipAddress: "127.0.0.1", port: noticePort)
+        
+        let bootstrap = DatagramBootstrap(group: self.group)
+            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
+        
+        self.asyncChannel = try await bootstrap.bind(host: "0.0.0.0", port: 0)
+            .flatMapThrowing {channel in
+                return try NIOAsyncChannel(wrappingChannelSynchronously: channel, configuration: .init(
+                    inboundType: AddressedEnvelope<ByteBuffer>.self,
+                    outboundType: AddressedEnvelope<ByteBuffer>.self
+                ))
+            }
+            .get()
+        
+        self.logger.log("[SDLNoticeClient] started and listening on: \(self.asyncChannel.channel.localAddress!)", level: .debug)
+    }
+    
+    func start() async throws {
+        try await self.asyncChannel.executeThenClose { inbound, outbound in
+            try await withThrowingTaskGroup(of: Void.self) { group in
+                group.addTask {
+                    try await self.asyncChannel.channel.closeFuture.get()
+                    throw SDLError.socketClosed
+                }
+                
+                group.addTask {
+                    defer {
+                        self.writeContinuation.finish()
+                    }
+                    
+                    for try await message in self.writeStream {
+                        let buf = self.asyncChannel.channel.allocator.buffer(bytes: message)
+                        let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: self.remoteAddress, data: buf)
+                        
+                        try await outbound.write(envelope)
+                    }
+                }
+                
+                for try await _ in group {
+                    
+                }
+            }
+        }
+    }
+    
+    // 处理写入逻辑
+    func send(data: Data) {
+        self.writeContinuation.yield(data)
+    }
+    
+    deinit {
+        try? self.group.syncShutdownGracefully()
+        self.writeContinuation.finish()
+    }
+}

Tun/Punchnet/SDLQPSCounter.swift

@@ -8,25 +8,25 @@
 import Foundation
 
 // 计数器，用来统计qps
-class SDLQPSCounter {
+class SDLQPSCounter: @unchecked Sendable {
     private var count = 0
     private let timer: DispatchSourceTimer
     private let label: String
+    private let queue = DispatchQueue(label: "com.punchnet.qps")
     
     init(label: String) {
         self.label = label
-        timer = DispatchSource.makeTimerSource(queue: DispatchQueue(label: "com.yourapp.qps"))
+        timer = DispatchSource.makeTimerSource(queue: queue)
         timer.schedule(deadline: .now(), repeating: .seconds(1), leeway: .milliseconds(100))
         timer.setEventHandler { [weak self] in
             guard let self = self else { return }
-            NSLog("[\(self.label)] QPS: \(self.count)")
             self.count = 0
         }
         timer.resume()
     }
     
     func increment(num: Int = 1) {
-        DispatchQueue(label: "com.yourapp.qps").async {
+        queue.async {
             self.count += num
         }
     }

Tun/Punchnet/SDLUtil.swift

@@ -43,4 +43,10 @@ struct SDLUtil {
         return ip & mask == compareIp & mask
     }
     
+    public static func formatMacAddress(mac: Data) -> String {
+        let bytes = [UInt8](mac)
+        
+        return bytes.map { String(format: "%02X", $0) }.joined(separator: ":").lowercased()
+    }
+
 }

Tun/Punchnet/SessionManager.swift

@@ -0,0 +1,57 @@
+//
+//  Session.swift
+//  sdlan
+//
+//  Created by 安礼成 on 2025/7/14.
+//
+import Foundation
+import NIOCore
+
+struct Session {
+    // 在内部的通讯的ip地址, 整数格式
+    let dstMac: Data
+    // 对端的主机在nat上映射的端口信息
+    let natAddress: SocketAddress
+    
+    // 最后使用时间
+    var lastTimestamp: Int32
+    
+    init(dstMac: Data, natAddress: SocketAddress) {
+        self.dstMac = dstMac
+        self.natAddress = natAddress
+        self.lastTimestamp = Int32(Date().timeIntervalSince1970)
+    }
+    
+    mutating func updateLastTimestamp(_ lastTimestamp: Int32) {
+        self.lastTimestamp = lastTimestamp
+    }
+}
+
+actor SessionManager {
+    private var sessions: [Data:Session] = [:]
+    
+    // session的有效时间
+    private let ttl: Int32 = 10
+    
+    func getSession(toAddress: Data) -> Session? {
+        let timestamp = Int32(Date().timeIntervalSince1970)
+        if let session = self.sessions[toAddress] {
+            if session.lastTimestamp >= timestamp + ttl {
+                self.sessions[toAddress]?.updateLastTimestamp(timestamp)
+                return session
+            } else {
+                self.sessions.removeValue(forKey: toAddress)
+            }
+        }
+        return nil
+    }
+    
+    func addSession(session: Session) {
+        self.sessions[session.dstMac] = session
+    }
+    
+    func removeSession(dstMac: Data) {
+        self.sessions.removeValue(forKey: dstMac)
+    }
+    
+}

Tun/Punchnet/UDPPacket.swift

@@ -0,0 +1,38 @@
+//
+//  UDPPacket.swift
+//  Tun
+//
+//  Created by 安礼成 on 2025/12/13.
+//
+
+import Foundation
+
+struct UDPHeader {
+    let sourcePort: UInt16
+    let destinationPort: UInt16
+    let length: UInt16
+    let checksum: UInt16
+}
+
+struct UDPPacket {
+    let header: UDPHeader
+    let payload: Data
+    
+    init?(_ data: Data) {
+        // UDP header 至少 8 字节
+        guard data.count >= 8 else {
+            return nil
+        }
+        
+        let header = UDPHeader(sourcePort: UInt16(bytes: (data[0], data[1])),
+                               destinationPort: UInt16(bytes: (data[2], data[3])),
+                               length: UInt16(bytes: (data[4], data[5])),
+                               checksum: UInt16(bytes: (data[6], data[7]))
+        )
+        // UDP payload = length - 8
+        let payloadLength = Int(header.length) - 8
+        
+        self.header = header
+        self.payload = data.subdata(in: 8..<(8 + payloadLength))
+    }
+}

Tun/SDLContext.swift

@@ -1,833 +0,0 @@
-//
-//  SDLContext.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/2/29.
-//
-
-import Foundation
-import NetworkExtension
-import NIOCore
-import Combine
-
-// 上下文环境变量，全局共享
-/*
-1. 处理rsa的加解密逻辑
- */
-
-class SDLContext {
-    
-    // 路由信息
-    struct Route {
-        let dstAddress: String
-        let subnetMask: String
-        
-        var debugInfo: String {
-            return "\(dstAddress):\(subnetMask)"
-        }
-    }
-    
-    // 配置项目
-    final class Configuration {
-        
-        struct StunServer {
-            let host: String
-            let ports: [Int]
-        }
-        
-        // 当前的客户端版本
-        let version: UInt8
-        
-        // 安装渠道
-        let installedChannel: String
-        
-        let superHost: String
-        let superPort: Int
-        
-        let stunServers: [StunServer]
-        
-        lazy var stunSocketAddress: SocketAddress = {
-            let stunServer = stunServers[0]
-            return try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0])
-        }()
-        
-        // 网络探测地址信息
-        lazy var stunProbeSocketAddressArray: [[SocketAddress]] = {
-            return stunServers.map { stunServer in
-                [
-                    try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0]),
-                    try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[1])
-                ]
-            }
-        }()
-        
-        let clientId: String
-        let token: String
-        
-        init(version: UInt8, installedChannel: String, superHost: String, superPort: Int, stunServers: [StunServer], clientId: String, token: String) {
-            self.version = version
-            self.installedChannel = installedChannel
-            self.superHost = superHost
-            self.superPort = superPort
-            self.stunServers = stunServers
-            self.clientId = clientId
-            self.token = token
-        }
-       
-    }
-    
-    let config: Configuration
-
-    // tun网络地址信息
-    var devAddr: SDLDevAddr
-    
-    // nat映射的相关信息, 暂时没有用处
-    //var natAddress: SDLNatAddress?
-    // nat的网络类型
-    var natType: NatType = .blocked
-    
-    // AES加密，授权通过后，对象才会被创建
-    var aesCipher: AESCipher?
-    // rsa的相关配置, public_key是本地生成的
-    let rsaCipher: RSACipher
-    
-    // 依赖的变量
-    var udpHole: SDLUDPHole?
-    private var udpCancel: AnyCancellable?
-    
-    var superClient: SDLSuperClient?
-    private var superCancel: AnyCancellable?
-
-    // 数据包读取任务
-    private var readTask: Task<(), Never>?
-    
-    let provider: PacketTunnelProvider
-    
-    private var sessionManager: SessionManager
-    private var holerManager: HolerManager
-    private var arpServer: ArpServer
-    
-    // 记录最后发送的stunRequest的cookie
-    private var lastCookie: UInt32? = 0
-    
-    // 定时器
-    private var stunCancel: AnyCancellable?
-    
-    // 网络状态变化的健康
-    private var monitor = SDLNetworkMonitor()
-    private var monitorCancel: AnyCancellable?
-    
-    // 内部socket通讯
-    private var noticeClient: SDLNoticeClient
-    
-    // 流量统计
-    private var flowTracer = SDLFlowTracerActor()
-    private var flowTracerCancel: AnyCancellable?
-    
-    init(provider: PacketTunnelProvider, config: Configuration) throws {
-        self.config = config
-        self.rsaCipher = try RSACipher(keySize: 1024)
-        
-        // 生成mac地址
-        var devAddr = SDLDevAddr()
-        devAddr.mac = Self.getMacAddress()
-        self.devAddr = devAddr
-        
-        self.provider = provider
-        self.sessionManager = SessionManager()
-        self.holerManager = HolerManager()
-        self.arpServer = ArpServer(known_macs: [:])
-        self.noticeClient = SDLNoticeClient()
-    }
-    
-    func start() async throws {
-        try await self.startSuperClient()
-        try await self.startUDPHole()
-        self.noticeClient.start()
-        
-        // 启动网络监控
-        self.monitorCancel = self.monitor.eventFlow.sink { event in
-            switch event {
-            case .changed:
-                // 需要重新探测网络的nat类型
-                Task {
-                    self.natType = await self.getNatType()
-                    NSLog("didNetworkPathChanged, nat type is: \(self.natType)")
-                }
-            case .unreachable:
-                NSLog("didNetworkPathUnreachable")
-            }
-        }
-        self.monitor.start()
-    }
-    
-    private func startSuperClient() async throws {
-        self.superClient = SDLSuperClient(host: config.superHost, port: config.superPort)
-        // 建立super的绑定关系
-        self.superCancel?.cancel()
-        self.superCancel = self.superClient?.eventFlow.sink { event in
-            Task.detached {
-                await self.handleSuperEvent(event: event)
-            }
-        }
-        try await self.superClient?.start()
-    }
-    
-    private func handleSuperEvent(event: SDLSuperClient.SuperEvent) async {
-        switch event {
-        case .ready:
-            NSLog("[SDLContext] get registerSuper, mac address: \(Self.formatMacAddress(mac: self.devAddr.mac))")
-            guard let message = await self.superClient?.registerSuper(context: self) else {
-                return
-            }
-            
-            switch message.packet {
-            case .registerSuperAck(let registerSuperAck):
-                // 需要对数据通过rsa的私钥解码
-                let aesKey = try! self.rsaCipher.decode(data: Data(registerSuperAck.aesKey))
-                let upgradeType = SDLUpgradeType(rawValue: registerSuperAck.upgradeType)
-                
-                NSLog("[SDLContext] get registerSuperAck, aes_key len: \(aesKey.count)")
-                self.devAddr = registerSuperAck.devAddr
-                
-                if upgradeType == .force {
-                    let forceUpgrade = NoticeMessage.UpgradeMessage(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
-                    self.noticeClient.send(data: forceUpgrade.binaryData)
-                    
-                    exit(-1)
-                }
-                
-                // 服务器分配的tun网卡信息
-                await self.didNetworkConfigChanged(devAddr: self.devAddr)
-                self.aesCipher = AESCipher(aesKey: aesKey)
-                if upgradeType == .normal {
-                    let normalUpgrade = NoticeMessage.UpgradeMessage(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
-                    self.noticeClient.send(data: normalUpgrade.binaryData)
-                }
-                
-            case .registerSuperNak(let nakPacket):
-                let errorMessage = nakPacket.errorMessage
-                guard let errorCode = SDLNAKErrorCode(rawValue: UInt8(nakPacket.errorCode)) else {
-                    return
-                }
-                
-                switch errorCode {
-                case .invalidToken, .nodeDisabled:
-                    let alertNotice = NoticeMessage.AlertMessage(alert: errorMessage)
-                    self.noticeClient.send(data: alertNotice.binaryData)
-                    exit(-1)
-                case .noIpAddress, .networkFault, .internalFault:
-                    let alertNotice = NoticeMessage.AlertMessage(alert: errorMessage)
-                    self.noticeClient.send(data: alertNotice.binaryData)
-                }
-                SDLLogger.log("Get a SuperNak message exit", level: .error)
-            default:
-                ()
-            }
-            
-        case .closed:
-            SDLLogger.log("[SDLContext] super client closed", level: .debug)
-            await self.arpServer.clear()
-            DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
-                Task {
-                    try await self.startSuperClient()
-                }
-            }
-        case .event(let evt):
-            switch evt {
-            case .natChanged(let natChangedEvent):
-                let dstMac = natChangedEvent.mac
-                NSLog("natChangedEvent, dstMac: \(dstMac)")
-                await sessionManager.removeSession(dstMac: dstMac)
-            case .sendRegister(let sendRegisterEvent):
-                NSLog("sendRegisterEvent, ip: \(sendRegisterEvent)")
-                let address = SDLUtil.int32ToIp(sendRegisterEvent.natIp)
-                if let remoteAddress = try? SocketAddress.makeAddressResolvingHost(address, port: Int(sendRegisterEvent.natPort)) {
-                    // 发送register包
-                    self.udpHole?.sendRegister(context: self, remoteAddress: remoteAddress, dst_mac: sendRegisterEvent.dstMac)
-                }
-                
-            case .networkShutdown(let shutdownEvent):
-                let alertNotice = NoticeMessage.AlertMessage(alert: shutdownEvent.message)
-                self.noticeClient.send(data: alertNotice.binaryData)
-                exit(-1)
-            }
-        case .command(let packetId, let command):
-            switch command {
-            case .changeNetwork(let changeNetworkCommand):
-                // 需要对数据通过rsa的私钥解码
-                let aesKey = try! self.rsaCipher.decode(data: Data(changeNetworkCommand.aesKey))
-                NSLog("[SDLContext] change network command get aes_key len: \(aesKey.count)")
-                self.devAddr = changeNetworkCommand.devAddr
-                
-                // 服务器分配的tun网卡信息
-                await self.didNetworkConfigChanged(devAddr: self.devAddr)
-                self.aesCipher = AESCipher(aesKey: aesKey)
-                
-                var commandAck = SDLCommandAck()
-                commandAck.status = true
-                
-                self.superClient?.commandAck(packetId: packetId, ack: commandAck)
-            }
-        }
-        
-    }
-
-    private func startUDPHole() async throws {
-        self.udpHole = SDLUDPHole()
-        
-        self.udpCancel?.cancel()
-        self.udpCancel = self.udpHole?.eventFlow.sink { event in
-            Task.detached {
-                await self.handleUDPEvent(event: event)
-            }
-        }
-        
-        try await self.udpHole?.start()
-    }
-    
-    private func handleUDPEvent(event: SDLUDPHole.UDPEvent) async {
-        switch event {
-        case .ready:
-            // 获取当前网络的类型
-            self.natType = await self.getNatType()
-            SDLLogger.log("[SDLContext] nat type is: \(self.natType)", level: .debug)
-            
-            let timer = Timer.publish(every: 5.0, on: .main, in: .common).autoconnect()
-            self.stunCancel = Just(Date()).merge(with: timer).sink { _ in
-                self.lastCookie = self.udpHole?.stunRequest(context: self)
-            }
-            
-        case .closed:
-            DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
-                Task {
-                    try await self.startUDPHole()
-                }
-            }
-            
-        case .message(let remoteAddress, let message):
-            switch message {
-            case .register(let register):
-                NSLog("register packet: \(register), dev_addr: \(self.devAddr)")
-                // 判断目标地址是否是tun的网卡地址, 并且是在同一个网络下
-                if register.dstMac == self.devAddr.mac && register.networkID == self.devAddr.networkID {
-                    // 回复ack包
-                    self.udpHole?.sendRegisterAck(context: self, remoteAddress: remoteAddress, dst_mac: register.srcMac)
-                    // 这里需要建立到来源的会话, 在复杂网络下，通过super-node查询到的nat地址不一定靠谱，需要通过udp包的来源地址作为nat地址
-                    let session = Session(dstMac: register.srcMac, natAddress: remoteAddress)
-                    await self.sessionManager.addSession(session: session)
-                } else {
-                    SDLLogger.log("SDLContext didReadRegister get a invalid packet, because dst_ip not matched: \(register.dstMac)", level: .warning)
-                }
-            case .registerAck(let registerAck):
-                // 判断目标地址是否是tun的网卡地址, 并且是在同一个网络下
-                if registerAck.dstMac == self.devAddr.mac && registerAck.networkID == self.devAddr.networkID {
-                    let session = Session(dstMac: registerAck.srcMac, natAddress: remoteAddress)
-                    await self.sessionManager.addSession(session: session)
-                } else {
-                    SDLLogger.log("SDLContext didReadRegisterAck get a invalid packet, because dst_mac not matched: \(registerAck.dstMac)", level: .warning)
-                }
-            case .stunReply(let stunReply):
-                let cookie = stunReply.cookie
-                if cookie == self.lastCookie {
-                    // 记录下当前在nat上的映射信息，暂时没有用；后续会用来判断网络类型
-                    //self.natAddress = stunReply.natAddress
-                    SDLLogger.log("[SDLContext] get a stunReply: \(try! stunReply.jsonString())")
-                }
-            default:
-                ()
-            }
-            
-        case .data(let data):
-            let mac = LayerPacket.MacAddress(data: data.dstMac)
-            guard (data.dstMac == self.devAddr.mac || mac.isBroadcast() || mac.isMulticast()) else {
-                NSLog("[SDLContext] didReadData 1")
-                return
-            }
-            
-            guard let decyptedData = try? self.aesCipher?.decypt(data: Data(data.data)) else {
-                NSLog("[SDLContext] didReadData 2")
-                return
-            }
-            
-            do {
-                let layerPacket = try LayerPacket(layerData: decyptedData)
-                
-                await self.flowTracer.inc(num: decyptedData.count, type: .inbound)
-                // 处理arp请求
-                switch layerPacket.type {
-                case .arp:
-                    // 判断如果收到的是arp请求
-                    if let arpPacket = ARPPacket(data: layerPacket.data)  {
-                        if arpPacket.targetIP == self.devAddr.netAddr {
-                            switch arpPacket.opcode {
-                            case .request:
-                                NSLog("[SDLContext] get arp request packet")
-                                let response = ARPPacket.arpResponse(for: arpPacket, mac: self.devAddr.mac, ip: self.devAddr.netAddr)
-                                await self.routeLayerPacket(dstMac: arpPacket.senderMAC, type: .arp, data: response.marshal())
-                            case .response:
-                                NSLog("[SDLContext] get arp response packet")
-                                await self.arpServer.append(ip: arpPacket.senderIP, mac: arpPacket.senderMAC)
-                            }
-                        } else {
-                            NSLog("[SDLContext] get invalid arp packet, target_ip: \(arpPacket)")
-                        }
-                    } else {
-                        NSLog("[SDLContext] get invalid arp packet")
-                    }
-                case .ipv4:
-                    NSLog("[SDLContext] get ipv4 packet")
-                    guard let ipPacket = IPPacket(layerPacket.data), ipPacket.header.destination == self.devAddr.netAddr else {
-                        return
-                    }
-                    
-                    let packet = NEPacket(data: ipPacket.data, protocolFamily: 2)
-                    self.provider.packetFlow.writePacketObjects([packet])
-                default:
-                    NSLog("[SDLContext] get invalid packet")
-                }
-            } catch let err {
-                NSLog("[SDLContext] didReadData err: \(err)")
-            }
-        }
-        
-    }
-    
-    // 流量统计
-    func flowReportTask() {
-        Task {
-            // 每分钟汇报一次
-            self.flowTracerCancel = Timer.publish(every: 60.0, on: .main, in: .common).autoconnect()
-                .sink { _ in
-                    Task {
-                        let (forwardNum, p2pNum, inboundNum) = await self.flowTracer.reset()
-                        self.superClient?.flowReport(forwardNum: forwardNum, p2pNum: p2pNum, inboundNum: inboundNum)
-                    }
-                }
-        }
-    }
-    
-    // 网络改变时需要重新配置网络信息
-    private func didNetworkConfigChanged(devAddr: SDLDevAddr, dnsServers: [String]? = nil) async {
-        let netAddress = SDLNetAddress(ip: devAddr.netAddr, maskLen: UInt8(devAddr.netBitLen))
-        let routes = [Route(dstAddress: netAddress.networkAddress, subnetMask: netAddress.maskAddress)]
-        
-        // Add code here to start the process of connecting the tunnel.
-        let networkSettings = NEPacketTunnelNetworkSettings(tunnelRemoteAddress: "8.8.8.8")
-        networkSettings.mtu = 1460
-        
-        // 设置网卡的DNS解析
-        if let dnsServers {
-            networkSettings.dnsSettings = NEDNSSettings(servers: dnsServers)
-        } else {
-            networkSettings.dnsSettings = NEDNSSettings(servers: ["8.8.8.8", "114.114.114.114"])
-        }
-        
-        let ipv4Settings = NEIPv4Settings(addresses: [netAddress.ipAddress], subnetMasks: [netAddress.maskAddress])
-        // 设置路由表
-        //NEIPv4Route.default()
-        ipv4Settings.includedRoutes = routes.map { route in
-            NEIPv4Route(destinationAddress: route.dstAddress, subnetMask: route.subnetMask)
-        }
-        networkSettings.ipv4Settings = ipv4Settings
-        // 网卡配置设置必须成功
-        do {
-            try await self.provider.setTunnelNetworkSettings(networkSettings)
-            
-            await self.holerManager.cleanup()
-            
-            self.startReader()
-        } catch let err {
-            SDLLogger.log("[SDLContext] setTunnelNetworkSettings get error: \(err)", level: .error)
-            exit(-1)
-        }
-    }
-    
-    // 开始读取数据, 用单独的线程处理packetFlow
-    private func startReader() {
-        //  停止之前的任务
-        self.readTask?.cancel()
-        
-        // 开启新的任务
-        self.readTask = Task(priority: .high) {
-            repeat {
-                if Task.isCancelled {
-                    break
-                }
-                
-                let (packets, numbers) = await self.provider.packetFlow.readPackets()
-                for (data, number) in zip(packets, numbers) where number == 2 {
-                    if let packet = IPPacket(data) {
-                        Task.detached {
-                            let dstIp = packet.header.destination
-                            // 本地通讯, 目标地址是本地服务器的ip地址
-                            if dstIp == self.devAddr.netAddr {
-                                let nePacket = NEPacket(data: packet.data, protocolFamily: 2)
-                                self.provider.packetFlow.writePacketObjects([nePacket])
-                                return
-                            }
-                            
-                            // 查找arp缓存中是否有目标mac地址
-                            if let dstMac = await self.arpServer.query(ip: dstIp) {
-                                await self.routeLayerPacket(dstMac: dstMac, type: .ipv4, data: packet.data)
-                            }
-                            else {
-                                // 构造arp请求
-                                let broadcastMac = Data([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
-                                let arpReqeust: ARPPacket = ARPPacket.arpRequest(senderIP: self.devAddr.netAddr, senderMAC: self.devAddr.mac, targetIP: dstIp)
-                                await self.routeLayerPacket(dstMac: broadcastMac, type: .arp, data: arpReqeust.marshal())
-                                
-                                NSLog("[SDLContext] dstIp: \(dstIp) arp query not found")
-                            }
-                        }
-                    }
-                }
-                
-            } while true
-        }
-        
-    }
-    
-    private func routeLayerPacket(dstMac: Data, type: LayerPacket.PacketType, data: Data) async {
-        // 将数据封装层2层的数据包
-        let layerPacket = LayerPacket(dstMac: dstMac, srcMac: self.devAddr.mac, type: type, data: data)
-        guard let encodedPacket = try? self.aesCipher?.encrypt(data: layerPacket.marshal()) else {
-            return
-        }
-        
-        // 通过session发送到对端
-        if let session = await self.sessionManager.getSession(toAddress: dstMac) {
-            NSLog("[SDLContext] send packet by session: \(session)")
-            self.udpHole?.sendPacket(context: self, session: session, data: encodedPacket)
-            
-            await self.flowTracer.inc(num: data.count, type: .p2p)
-        } else {
-            // 通过super_node进行转发
-            self.udpHole?.forwardPacket(context: self, dst_mac: dstMac, data: encodedPacket)
-            // 流量统计
-            await self.flowTracer.inc(num: data.count, type: .forward)
-            
-            // 尝试打洞
-            await self.holerManager.addHoler(dstMac: dstMac) {
-                self.holerTask(dstMac: dstMac)
-            }
-        }
-    }
-    
-    deinit {
-        self.stunCancel?.cancel()
-        self.udpHole = nil
-        self.superClient = nil
-    }
-    
-}
-
-//--MARK: 处理RSA加密算法
-extension SDLContext {
-    
-    struct RSACipher {
-        let pubKey: String
-        let privateKeyDER: Data
-        
-        init(keySize: Int) throws {
-            let (privateKey, publicKey) = try Self.loadKeys(keySize: keySize)
-            let privKeyStr = SwKeyConvert.PrivateKey.derToPKCS1PEM(privateKey)
-            
-            self.pubKey = SwKeyConvert.PublicKey.derToPKCS8PEM(publicKey)
-            self.privateKeyDER = try SwKeyConvert.PrivateKey.pemToPKCS1DER(privKeyStr)
-        }
-        
-        public func decode(data: Data) throws -> Data {
-            let tag = Data()
-            let (decryptedData, _) = try CC.RSA.decrypt(data, derKey: self.privateKeyDER, tag: tag, padding: .pkcs1, digest: .none)
-            
-            return decryptedData
-        }
-        
-        private static func loadKeys(keySize: Int) throws -> (Data, Data) {
-            if let privateKey = UserDefaults.standard.data(forKey: "privateKey"),
-               let publicKey = UserDefaults.standard.data(forKey: "publicKey") {
-                
-                return (privateKey, publicKey)
-            } else {
-                let (privateKey, publicKey) = try CC.RSA.generateKeyPair(keySize)
-                UserDefaults.standard.setValue(privateKey, forKey: "privateKey")
-                UserDefaults.standard.setValue(publicKey, forKey: "publicKey")
-                
-                return (privateKey, publicKey)
-            }
-        }
-        
-    }
-}
-
-// --MARK: 处理AES加密, AES256
-extension SDLContext {
-    
-    struct AESCipher {
-        let aesKey: Data
-        let ivData: Data
-        
-        init(aesKey: Data) {
-            self.aesKey = aesKey
-            self.ivData = Data(aesKey.prefix(16))
-        }
-        
-        func decypt(data: Data) throws -> Data {
-            return try CC.crypt(.decrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
-        }
-        
-        func encrypt(data: Data) throws -> Data {
-            return try CC.crypt(.encrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
-        }
-    }
-    
-}
-
-// --MARK: session管理, session的有效时间为10s，没次使用后更新最后使用时间
-extension SDLContext {
-    
-    struct Session {
-        // 在内部的通讯的ip地址, 整数格式
-        let dstMac: Data
-        // 对端的主机在nat上映射的端口信息
-        let natAddress: SocketAddress
-        
-        // 最后使用时间
-        var lastTimestamp: Int32
-        
-        init(dstMac: Data, natAddress: SocketAddress) {
-            self.dstMac = dstMac
-            self.natAddress = natAddress
-            self.lastTimestamp = Int32(Date().timeIntervalSince1970)
-        }
-        
-        mutating func updateLastTimestamp(_ lastTimestamp: Int32) {
-            self.lastTimestamp = lastTimestamp
-        }
-    }
-    
-    actor SessionManager {
-        private var sessions: [Data:Session] = [:]
-        
-        // session的有效时间
-        private let ttl: Int32 = 10
-        
-        func getSession(toAddress: Data) -> Session? {
-            let timestamp = Int32(Date().timeIntervalSince1970)
-            if let session = self.sessions[toAddress] {
-                if session.lastTimestamp >= timestamp + ttl {
-                    self.sessions[toAddress]?.updateLastTimestamp(timestamp)
-                    return session
-                } else {
-                    self.sessions.removeValue(forKey: toAddress)
-                }
-            }
-            return nil
-        }
-        
-        func addSession(session: Session) {
-            self.sessions[session.dstMac] = session
-        }
-        
-        func removeSession(dstMac: Data) {
-            self.sessions.removeValue(forKey: dstMac)
-        }
-        
-    }
-    
-}
-
-// --MARK: known_ips管理
-extension SDLContext {
-    
-    actor ArpServer {
-        private var known_macs: [UInt32:Data] = [:]
-        
-        init(known_macs: [UInt32:Data]) {
-            self.known_macs = known_macs
-        }
-        
-        func query(ip: UInt32) -> Data? {
-            return self.known_macs[ip]
-        }
-        
-        func append(ip: UInt32, mac: Data) {
-            self.known_macs[ip] = mac
-        }
-        
-        func remove(ip: UInt32) {
-            self.known_macs.removeValue(forKey: ip)
-        }
-        
-        func clear() {
-            self.known_macs = [:]
-        }
-    }
-    
-}
-
-// --MARK: 打洞流程管理
-extension SDLContext {
-    
-    actor HolerManager {
-        private var holers: [Data:Task<(), Never>] = [:]
-        
-        func addHoler(dstMac: Data, creator: @escaping () -> Task<(), Never>) {
-            if let task = self.holers[dstMac] {
-                if task.isCancelled {
-                    self.holers[dstMac] = creator()
-                }
-            } else {
-                self.holers[dstMac] = creator()
-            }
-        }
-        
-        func cleanup() {
-            for holer in holers.values {
-                holer.cancel()
-            }
-            self.holers.removeAll()
-        }
-        
-    }
-    
-    func holerTask(dstMac: Data) -> Task<(), Never> {
-        return Task {
-            guard let message = try? await self.superClient?.queryInfo(context: self, dst_mac: dstMac) else {
-                return
-            }
-            
-            switch message.packet {
-            case .empty:
-                SDLLogger.log("[SDLContext] hole query_info get empty: \(message)", level: .debug)
-            case .peerInfo(let peerInfo):
-                if let remoteAddress = peerInfo.v4Info.socketAddress() {
-                    SDLLogger.log("[SDLContext] hole sock address: \(remoteAddress)", level: .warning)
-                    // 发送register包
-                    self.udpHole?.sendRegister(context: self, remoteAddress: remoteAddress, dst_mac: dstMac)
-                } else {
-                    SDLLogger.log("[SDLContext] hole sock address is invalid: \(peerInfo.v4Info)", level: .warning)
-                }
-            default:
-                SDLLogger.log("[SDLContext] hole query_info is packet: \(message)", level: .warning)
-            }
-        }
-    }
-    
-}
-
-//--MARK: 网络类型探测
-extension SDLContext {
-    
-    // 定义nat类型
-    enum NatType: UInt8, Encodable {
-        case blocked = 0
-        case noNat = 1
-        case fullCone = 2
-        case portRestricted = 3
-        case coneRestricted = 4
-        case symmetric = 5
-    }
-    
-    private func getNatAddress(remoteAddress: SocketAddress, attr: SDLProbeAttr) async -> SocketAddress? {
-        let stunProbeReply = await self.udpHole?.stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: 5)
-        
-        return stunProbeReply?.socketAddress()
-    }
-    
-    // 获取当前所处的网络的nat类型
-    func getNatType() async -> NatType {
-        let addressArray = config.stunProbeSocketAddressArray
-        // step1: ip1:port1 <---- ip1:port1
-        guard let natAddress1 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .none) else {
-            return .blocked
-        }
-        
-        // 网络没有在nat下
-        if natAddress1 == self.udpHole?.localAddress {
-            return .noNat
-        }
-        
-        // step2: ip2:port2 <---- ip2:port2
-        guard let natAddress2 = await getNatAddress(remoteAddress: addressArray[1][1], attr: .none) else {
-            return .blocked
-        }
-        
-        // 如果natAddress2 的IP地址与上次回来的IP是不一样的，它就是对称型NAT; 这次的包也一定能发成功并收到
-        // 如果ip地址变了，这说明{dstIp, dstPort, srcIp, srcPort}, 其中有一个变了；则用新的ip地址
-        NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2)")
-        if let ipAddress1 = natAddress1.ipAddress, let ipAddress2 = natAddress2.ipAddress, ipAddress1 != ipAddress2 {
-            return .symmetric
-        }
-        
-        // step3: ip1:port1 <---- ip2:port2 (ip地址和port都变的情况)
-        // 如果能收到的，说明是完全锥形 说明是IP地址限制锥型NAT，如果不能收到说明是端口限制锥型。
-        if let natAddress3 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .peer) {
-            NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address3: \(natAddress3)")
-            return .fullCone
-        }
-        
-        // step3: ip1:port1 <---- ip1:port2 (port改变情况)
-        // 如果能收到的说明是IP地址限制锥型NAT，如果不能收到说明是端口限制锥型。
-        if let natAddress4 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .port) {
-            NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address4: \(natAddress4)")
-            return .coneRestricted
-        } else {
-            return .portRestricted
-        }
-    }
-        
-}
-
-
-//--MARK: 获取设备的UUID
-
-extension SDLContext {
-    
-    static func getUUID() -> String {
-        let userDefaults = UserDefaults.standard
-        if let uuid = userDefaults.value(forKey: "gClientId") as? String {
-            return uuid
-        } else {
-            let uuid = UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased()
-            userDefaults.setValue(uuid, forKey: "gClientId")
-           
-            return uuid
-        }
-    }
-    
-    // 获取mac地址
-    static func getMacAddress() -> Data {
-        let key = "gMacAddress2"
-        
-        let userDefaults = UserDefaults.standard
-        if let mac = userDefaults.value(forKey: key) as? Data {
-            return mac
-        }
-        else {
-            let mac = generateMacAddress()
-            userDefaults.setValue(mac, forKey: key)
-            
-            return mac
-        }
-    }
-    
-    // 随机生成mac地址
-    private static func generateMacAddress() -> Data {
-        var macAddress = [UInt8](repeating: 0, count: 6)
-        for i in 0..<6 {
-            macAddress[i] = UInt8.random(in: 0...255)
-        }
-        
-        return Data(macAddress)
-    }
-    
-    // 将mac地址转换成字符串
-    private static func formatMacAddress(mac: Data) -> String {
-        let bytes = [UInt8](mac)
-        
-        return bytes.map { String(format: "%02X", $0) }.joined(separator: ":").lowercased()
-    }
-    
-}

Tun/SDLHoler.swift

@@ -1,11 +0,0 @@
-//
-//  SDLHoler.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/3/12.
-//
-
-import Foundation
-import Combine
-
-

Tun/SDLLogger.swift

@@ -1,39 +0,0 @@
-//
-//  SDLLogger.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/3/13.
-//
-
-import Foundation
-
-struct SDLLogger {
-    enum Level {
-        case debug
-        case info
-        case warning
-        case error
-    }
-    
-    static var logLevel: Level = .debug
-    
-    static func log(_ message: String, level: Level = .debug) {
-        switch logLevel {
-        case .debug:
-            NSLog(message)
-        case .info:
-            if level == .info || level == .warning || level == .error {
-                NSLog(message)
-            }
-        case .warning:
-            if level == .warning || level == .error {
-                NSLog(message)
-            }
-        case .error:
-            if level == .error {
-                NSLog(message)
-            }
-        }
-    }
-    
-}

Tun/SDLNoticeClient.swift

@@ -1,95 +0,0 @@
-//
-//  SDLNoticeClient.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/5/20.
-//
-
-import Foundation
-
-//
-//  SDLanServer.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/1/31.
-//
-
-import Foundation
-import NIOCore
-import NIOPosix
-
-// 处理和sn-server服务器之间的通讯
-class SDLNoticeClient: ChannelInboundHandler {
-    public typealias InboundIn = AddressedEnvelope<ByteBuffer>
-    public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
-    
-    private var thread: Thread?
-    var context: ChannelHandlerContext?
-    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-    private let remoteAddress: SocketAddress
-    
-    init() {
-        self.remoteAddress = try! SocketAddress(ipAddress: "127.0.0.1", port: 50195)
-    }
-    
-    // 启动函数
-    func start() {
-        self.thread = Thread {
-            let bootstrap = DatagramBootstrap(group: self.group)
-                .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
-                .channelInitializer { channel in
-                    // 接收缓冲区
-                    channel.pipeline.addHandler(self)
-                }
-            
-            let channel = try! bootstrap.bind(host: "0.0.0.0", port: 0).wait()
-            SDLLogger.log("[SDLNoticeClient] started and listening on: \(channel.localAddress!)", level: .debug)
-            
-            // This will never unblock as we don't close the channel
-            try! channel.closeFuture.wait()
-        }
-        self.thread?.start()
-    }
-    
-    // -- MARK: ChannelInboundHandler Methods
-    
-    public func channelActive(context: ChannelHandlerContext) {
-        self.context = context
-    }
-    
-    // 接收到的消息, 消息需要根据类型分流
-    public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
-        context.fireChannelRead(data)
-    }
-    
-    public func errorCaught(context: ChannelHandlerContext, error: Error) {
-        // As we are not really interested getting notified on success or failure we just pass nil as promise to
-        // reduce allocations.
-        context.close(promise: nil)
-        self.context = nil
-    }
-    
-    public func channelInactive(context: ChannelHandlerContext) {
-        self.context = nil
-        context.close(promise: nil)
-    }
-    
-    // 处理写入逻辑
-    func send(data: Data) {
-        guard let context = self.context else {
-            return
-        }
-        
-        context.eventLoop.execute {
-            let buffer = context.channel.allocator.buffer(bytes: data)
-            
-            let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: self.remoteAddress, data: buffer)
-            context.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
-        }
-    }
-    
-    deinit {
-        self.thread?.cancel()
-        try? self.group.syncShutdownGracefully()
-    }
-}

Tun/SDLSuperClient.swift

@@ -1,373 +0,0 @@
-//
-//  SDLWebsocketClient.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/3/28.
-//
-
-import Foundation
-import NIOCore
-import NIOPosix
-import Combine
-
-// --MARK: 和SuperNode的客户端
-class SDLSuperClient: ChannelInboundHandler {
-    public typealias InboundIn = ByteBuffer
-    public typealias OutboundOut = ByteBuffer
-    
-    public typealias CallbackFun = (SDLSuperInboundMessage?) -> Void
-    
-    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-    private var channel: Channel?
-    
-    // id生成器
-    var idGenerator = SDLIdGenerator(seed: 1)
-    private let callbackManager = SuperCallbackManager()
-    
-    let host: String
-    let port: Int
-    
-    private var pingCancel: AnyCancellable?
-    
-    public var eventFlow = PassthroughSubject<SuperEvent, Never>()
-    
-    // 定义事件类型
-    enum SuperEvent {
-        case ready
-        case closed
-        case event(SDLEvent)
-        case command(UInt32, SDLCommand)
-    }
-    
-    init(host: String, port: Int) {
-        self.host = host
-        self.port = port
-    }
-    
-    func start() async throws {
-        let bootstrap = ClientBootstrap(group: self.group)
-            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
-            .channelInitializer { channel in
-                return channel.pipeline.addHandlers([
-                    ByteToMessageHandler(FixedHeaderDelimiterCoder()),
-                    MessageToByteHandler(FixedHeaderDelimiterCoder()),
-                    self
-                ])
-            }
-        
-        do {
-            NSLog("super client connect: \(self.host):\(self.port)")
-            self.channel = try await bootstrap.connect(host: self.host, port: self.port).get()
-        } catch let err {
-            NSLog("super client get error: \(err)")
-            self.eventFlow.send(.closed)
-        }
-    }
-    
-    // -- MARK: apis
-    
-    func commandAck(packetId: UInt32, ack: SDLCommandAck) {
-        guard let data = try? ack.serializedData() else {
-            return
-        }
-        
-        self.send(type: .commandAck, packetId: packetId, data: data)
-    }
-    
-    func registerSuper(context ctx: SDLContext) async -> SDLSuperInboundMessage? {
-        return await withCheckedContinuation { c in
-            self.registerSuper(context: ctx) { message in
-                c.resume(returning: message)
-            }
-        }
-    }
-    
-    func registerSuper(context ctx: SDLContext, callback: @escaping CallbackFun) {
-        var registerSuper = SDLRegisterSuper()
-        registerSuper.version = UInt32(ctx.config.version)
-        registerSuper.clientID = ctx.config.clientId
-        registerSuper.devAddr = ctx.devAddr
-        registerSuper.pubKey = ctx.rsaCipher.pubKey
-        registerSuper.token = ctx.config.token
-        
-        let data = try! registerSuper.serializedData()
-        
-        self.write(type: .registerSuper, data: data, callback: callback)
-    }
-    
-    func queryInfo(context ctx: SDLContext, dst_mac: Data) async throws -> SDLSuperInboundMessage? {
-        return await withCheckedContinuation { c in
-            self.queryInfo(context: ctx, dst_mac: dst_mac) { message in
-                c.resume(returning: message)
-            }
-        }
-    }
-    
-    // 查询目标服务器的相关信息
-    func queryInfo(context ctx: SDLContext, dst_mac: Data, callback: @escaping CallbackFun) {
-        var queryInfo = SDLQueryInfo()
-        queryInfo.dstMac = dst_mac
-        
-        self.write(type: .queryInfo, data: try! queryInfo.serializedData(), callback: callback)
-    }
-    
-    func unregister(context ctx: SDLContext) throws {
-        self.send(type: .unregisterSuper, packetId: 0, data: Data())
-    }
-    
-    func ping() {
-        self.send(type: .ping, packetId: 0, data: Data())
-    }
-    
-    func flowReport(forwardNum: UInt32, p2pNum: UInt32, inboundNum: UInt32) {
-        var flow = SDLFlows()
-        flow.forwardNum = forwardNum
-        flow.p2PNum = p2pNum
-        flow.inboundNum = inboundNum
-        
-        self.send(type: .flowTracer, packetId: 0, data: try! flow.serializedData())
-    }
-    
-    // --MARK: ChannelInboundHandler
-    
-    public func channelActive(context: ChannelHandlerContext) {
-        self.startPingTicker()
-        self.eventFlow.send(.ready)
-    }
-    
-    public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
-        var buffer = self.unwrapInboundIn(data)
-        if let message = decode(buffer: &buffer) {
-            SDLLogger.log("[SDLSuperTransport] read message: \(message)", level: .warning)
-            
-            switch message.packet {
-            case .event(let event):
-                self.eventFlow.send(.event(event))
-            case .command(let command):
-                self.eventFlow.send(.command(message.msgId, command))
-            default:
-                self.callbackManager.fireCallback(message: message)
-            }
-        }
-    }
-    
-    public func errorCaught(context: ChannelHandlerContext, error: Error) {
-        SDLLogger.log("[SDLSuperTransport] error: \(error)", level: .warning)
-        self.channel = nil
-        self.eventFlow.send(.closed)
-        context.close(promise: nil)
-    }
-    
-    public func channelInactive(context: ChannelHandlerContext) {
-        SDLLogger.log("[SDLSuperTransport] channelInactive", level: .warning)
-        self.channel = nil
-        context.close(promise: nil)
-    }
-    
-    func write(type: SDLPacketType, data: Data, callback: @escaping CallbackFun) {
-        guard let channel = self.channel else {
-            return
-        }
-        
-        SDLLogger.log("[SDLSuperTransport] will write data: \(data)", level: .debug)
-        
-        let packetId = idGenerator.nextId()
-        self.callbackManager.addCallback(id: packetId, callback: callback)
-        
-        channel.eventLoop.execute {
-            var buffer = channel.allocator.buffer(capacity: data.count + 5)
-            buffer.writeInteger(packetId, as: UInt32.self)
-            buffer.writeBytes([type.rawValue])
-            buffer.writeBytes(data)
-            
-            channel.writeAndFlush(self.wrapOutboundOut(buffer), promise: nil)
-        }
-    }
-    
-    func send(type: SDLPacketType, packetId: UInt32, data: Data) {
-        guard let channel = self.channel else {
-            return
-        }
-        
-        channel.eventLoop.execute {
-            var buffer = channel.allocator.buffer(capacity: data.count + 5)
-            buffer.writeInteger(packetId, as: UInt32.self)
-            buffer.writeBytes([type.rawValue])
-            buffer.writeBytes(data)
-            
-            channel.writeAndFlush(self.wrapOutboundOut(buffer), promise: nil)
-        }
-    }
-    
-    // --MARK: 心跳机制
-    
-    private func startPingTicker() {
-        self.pingCancel = Timer.publish(every: 5.0, on: .main, in: .common).autoconnect()
-            .sink { _ in
-                // 保持和super-node的心跳机制
-                self.ping()
-            }
-    }
-    
-    deinit {
-        self.pingCancel?.cancel()
-        try! group.syncShutdownGracefully()
-    }
-    
-}
-
-/// 基于2字节固定长度的分包协议
-extension SDLSuperClient {
-    private final class FixedHeaderDelimiterCoder: ByteToMessageDecoder, MessageToByteEncoder {
-        typealias InboundIn = ByteBuffer
-        typealias InboundOut = ByteBuffer
-        
-        func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
-            guard let len = buffer.getInteger(at: buffer.readerIndex, endianness: .big, as: UInt16.self) else {
-                return .needMoreData
-            }
-            
-            if buffer.readableBytes >= len + 2 {
-                buffer.moveReaderIndex(forwardBy: 2)
-                if let bytes = buffer.readBytes(length: Int(len)) {
-                    context.fireChannelRead(self.wrapInboundOut(ByteBuffer(bytes: bytes)))
-                }
-                return .continue
-            } else {
-                return .needMoreData
-            }
-        }
-        
-        func encode(data: ByteBuffer, out: inout ByteBuffer) throws {
-            let len = data.readableBytes
-            out.writeInteger(UInt16(len))
-            out.writeBytes(data.readableBytesView)
-        }
-    }
-}
-
-// 回调函数管理器
-extension SDLSuperClient {
-    private final class SuperCallbackManager {
-        // 对应请求体和相应的关系
-        private var callbacks: [UInt32:CallbackFun] = [:]
-        private let locker = NSLock()
-        
-        func addCallback(id: UInt32, callback: @escaping CallbackFun) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            self.callbacks[id] = callback
-        }
-        
-        func fireCallback(message: SDLSuperInboundMessage) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            if let callback = self.callbacks[message.msgId] {
-                callback(message)
-                self.callbacks.removeValue(forKey: message.msgId)
-            }
-        }
-        
-        func fireAllCallbacks(message: SDLSuperInboundMessage) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            for (_, callback) in self.callbacks {
-                callback(nil)
-            }
-            self.callbacks.removeAll()
-        }
-    }
-}
-
-// --MARK: 编解码器
-extension SDLSuperClient {
-    // 消息格式为: <<MsgId:32, Type:8, Body/binary>>
-    func decode(buffer: inout ByteBuffer) -> SDLSuperInboundMessage? {
-        guard let msgId = buffer.readInteger(as: UInt32.self),
-              let type = buffer.readInteger(as: UInt8.self),
-              let messageType = SDLPacketType(rawValue: type) else {
-            return nil
-        }
-        
-        switch messageType {
-        case .empty:
-            return .init(msgId: msgId, packet: .empty)
-        case .registerSuperAck:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
-                  let registerSuperAck = try? SDLRegisterSuperAck(serializedData: Data(bytes)) else {
-                return nil
-            }
-            return .init(msgId: msgId, packet: .registerSuperAck(registerSuperAck))
-            
-        case .registerSuperNak:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
-                  let registerSuperNak = try? SDLRegisterSuperNak(serializedData: Data(bytes)) else {
-                return nil
-            }
-            return .init(msgId: msgId, packet: .registerSuperNak(registerSuperNak))
-            
-        case .peerInfo:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
-                  let peerInfo = try? SDLPeerInfo(serializedData: Data(bytes)) else {
-                return nil
-            }
-            
-            return .init(msgId: msgId, packet: .peerInfo(peerInfo))
-        case .pong:
-            return .init(msgId: msgId, packet: .pong)
-            
-        case .command:
-            guard let commandVal = buffer.readInteger(as: UInt8.self),
-                  let command = SDLCommandType(rawValue: commandVal),
-                  let bytes = buffer.readBytes(length: buffer.readableBytes) else {
-                return nil
-            }
-            
-            switch command {
-            case .changeNetwork:
-                guard let changeNetworkCommand = try? SDLChangeNetworkCommand(serializedData: Data(bytes)) else {
-                    return nil
-                }
-                
-                return .init(msgId: msgId, packet: .command(.changeNetwork(changeNetworkCommand)))
-            }
-            
-        case .event:
-            guard let eventVal = buffer.readInteger(as: UInt8.self),
-                  let event = SDLEventType(rawValue: eventVal),
-                  let bytes = buffer.readBytes(length: buffer.readableBytes) else {
-                return nil
-            }
-            
-            switch event {
-            case .natChanged:
-                guard let natChangedEvent = try? SDLNatChangedEvent(serializedData: Data(bytes)) else {
-                    return nil
-                }
-                return .init(msgId: msgId, packet: .event(.natChanged(natChangedEvent)))
-            case .sendRegister:
-                guard let sendRegisterEvent = try? SDLSendRegisterEvent(serializedData: Data(bytes)) else {
-                    return nil
-                }
-                return .init(msgId: msgId, packet: .event(.sendRegister(sendRegisterEvent)))
-            case .networkShutdown:
-                guard let networkShutdownEvent = try? SDLNetworkShutdownEvent(serializedData: Data(bytes)) else {
-                    return nil
-                }
-                return .init(msgId: msgId, packet: .event(.networkShutdown(networkShutdownEvent)))
-            }
-            
-        default:
-            return nil
-        }
-    }
-    
-}

Tun/SDLUDPHole.swift

@@ -1,337 +0,0 @@
-//
-//  SDLanServer.swift
-//  Tun
-//
-//  Created by 安礼成 on 2024/1/31.
-//
-
-import Foundation
-import NIOCore
-import NIOPosix
-import Combine
-
-// 处理和sn-server服务器之间的通讯
-class SDLUDPHole: ChannelInboundHandler {
-    public typealias InboundIn = AddressedEnvelope<ByteBuffer>
-    public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
-    
-    // 回调函数
-    public typealias CallbackFun = (SDLStunProbeReply?) -> Void
-    
-    private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-    
-    private var cookieGenerator = SDLIdGenerator(seed: 1)
-    private let callbackManager = HoleCallbackManager()
-    
-    public var localAddress: SocketAddress?
-    public var channel: Channel?
-    
-    public var eventFlow = PassthroughSubject<UDPEvent, Never>()
-    
-    // 定义事件类型
-    enum UDPEvent {
-        case ready
-        case closed
-        case message(SocketAddress, SDLHoleInboundMessage)
-        case data(SDLData)
-    }
-    
-    init() {
-        
-    }
-    
-    // MARK: super_node apis
-    
-    func stunRequest(context ctx: SDLContext) -> UInt32 {
-        let cookie = self.cookieGenerator.nextId()
-        let remoteAddress = ctx.config.stunSocketAddress
-        
-        var stunRequest = SDLStunRequest()
-        stunRequest.cookie = cookie
-        stunRequest.clientID = ctx.config.clientId
-        stunRequest.networkID = ctx.devAddr.networkID
-        stunRequest.ip = ctx.devAddr.netAddr
-        stunRequest.mac = ctx.devAddr.mac
-        stunRequest.natType = UInt32(ctx.natType.rawValue)
-        
-        SDLLogger.log("[SDLUDPHole] stunRequest: \(remoteAddress), host: \(ctx.config.stunServers[0].host):\(ctx.config.stunServers[0].ports[0])", level: .warning)
-        
-        self.send(remoteAddress: remoteAddress, type: .stunRequest, data: try! stunRequest.serializedData())
-        
-        return cookie
-    }
-    
-    // 探测tun信息
-    func stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int = 5) async -> SDLStunProbeReply? {
-        return await withCheckedContinuation { continuation in
-            self.stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: timeout) { probeReply in
-                continuation.resume(returning: probeReply)
-            }
-        }
-    }
-    
-    private func stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int, callback: @escaping CallbackFun) {
-        let cookie = self.cookieGenerator.nextId()
-        
-        var stunProbe = SDLStunProbe()
-        stunProbe.cookie = cookie
-        stunProbe.attr = UInt32(attr.rawValue)
-        
-        self.send(remoteAddress: remoteAddress, type: .stunProbe, data: try! stunProbe.serializedData())
-        
-        SDLLogger.log("[SDLUDPHole] stunProbe: \(remoteAddress)", level: .warning)
-        
-        self.callbackManager.addCallback(id: cookie, timeout: timeout, callback: callback)
-    }
-    
-    // MARK: client-client apis
-    
-    // 发送数据包到其他session
-    func sendPacket(context ctx: SDLContext, session: SDLContext.Session, data: Data) {
-        let remoteAddress = session.natAddress
-        
-        var dataPacket = SDLData()
-        dataPacket.networkID = ctx.devAddr.networkID
-        dataPacket.srcMac = ctx.devAddr.mac
-        dataPacket.dstMac = session.dstMac
-        dataPacket.ttl = 255
-        dataPacket.data = data
-        let packet = try! dataPacket.serializedData()
-        
-        SDLLogger.log("[SDLUDPHole] sendPacket: \(remoteAddress), count: \(packet.count)", level: .debug)
-        
-        self.send(remoteAddress: remoteAddress, type: .data, data: packet)
-    }
-    
-    // 通过sn服务器转发数据包, data已经是加密过后的数据
-    func forwardPacket(context ctx: SDLContext, dst_mac: Data, data: Data) {
-        let remoteAddress = ctx.config.stunSocketAddress
-        
-        var dataPacket = SDLData()
-        dataPacket.networkID = ctx.devAddr.networkID
-        dataPacket.srcMac = ctx.devAddr.mac
-        dataPacket.dstMac = dst_mac
-        dataPacket.ttl = 255
-        dataPacket.data = data
-        
-        let packet = try! dataPacket.serializedData()
-        
-        NSLog("[SDLContext] forward packet, remoteAddress: \(remoteAddress), data size: \(packet.count)")
-        
-        self.send(remoteAddress: remoteAddress, type: .data, data: packet)
-    }
-    
-    // 发送register包
-    func sendRegister(context ctx: SDLContext, remoteAddress: SocketAddress, dst_mac: Data) {
-        var register = SDLRegister()
-        register.networkID = ctx.devAddr.networkID
-        register.srcMac = ctx.devAddr.mac
-        register.dstMac = dst_mac
-        
-        SDLLogger.log("[SDLUDPHole] SendRegister: \(remoteAddress), src_mac: \(LayerPacket.MacAddress.description(data: ctx.devAddr.mac)), dst_mac: \(LayerPacket.MacAddress.description(data: dst_mac))", level: .debug)
-        
-        self.send(remoteAddress: remoteAddress, type: .register, data: try! register.serializedData())
-    }
-    
-    // 回复registerAck
-    func sendRegisterAck(context ctx: SDLContext, remoteAddress: SocketAddress, dst_mac: Data) {
-        var registerAck = SDLRegisterAck()
-        registerAck.networkID = ctx.devAddr.networkID
-        registerAck.srcMac = ctx.devAddr.mac
-        registerAck.dstMac = dst_mac
-        
-        SDLLogger.log("[SDLUDPHole] SendRegisterAck: \(remoteAddress), \(registerAck)", level: .debug)
-        
-        self.send(remoteAddress: remoteAddress, type: .registerAck, data: try! registerAck.serializedData())
-    }
-    
-    // 启动函数
-    func start() async throws {
-        let bootstrap = DatagramBootstrap(group: self.group)
-            .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
-            .channelInitializer { channel in
-                // 接收缓冲区
-                return channel.setOption(ChannelOptions.socketOption(.so_rcvbuf), value: 5 * 1024  * 1024)
-                    .flatMap {
-                        channel.setOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_SNDBUF), value: 5 * 1024  * 1024)
-                    }.flatMap {
-                        channel.pipeline.addHandler(self)
-                    }
-            }
-        
-        let channel = try await bootstrap.bind(host: "0.0.0.0", port: 0).get()
-        
-        SDLLogger.log("[UDPHole] started and listening on: \(channel.localAddress!)", level: .debug)
-        self.localAddress = channel.localAddress
-        self.channel = channel
-    }
-    
-    // -- MARK: ChannelInboundHandler Methods
-    
-    public func channelActive(context: ChannelHandlerContext) {
-        self.eventFlow.send(.ready)
-    }
-    
-    // 接收到的消息, 消息需要根据类型分流
-    public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
-        let envelope = self.unwrapInboundIn(data)
-        var buffer = envelope.data
-        let remoteAddress = envelope.remoteAddress
-        
-        do {
-            if let message = try decode(buffer: &buffer) {
-                Task {
-                    switch message {
-                    case .data(let data):
-                        SDLLogger.log("[SDLUDPHole] read data: \(data.format()), from: \(remoteAddress)", level: .debug)
-                        self.eventFlow.send(.data(data))
-                    case .stunProbeReply(let probeReply):
-                        self.callbackManager.fireCallback(message: probeReply)
-                    default:
-                        self.eventFlow.send(.message(remoteAddress, message))
-                    }
-                }
-            } else {
-                SDLLogger.log("[SDLUDPHole] decode message, get null", level: .warning)
-            }
-        } catch let err {
-            SDLLogger.log("[SDLUDPHole] decode message, get error: \(err)", level: .debug)
-        }
-    }
-    
-    public func errorCaught(context: ChannelHandlerContext, error: Error) {
-        SDLLogger.log("[SDLUDPHole] get error: \(error)", level: .error)
-        // As we are not really interested getting notified on success or failure we just pass nil as promise to
-        // reduce allocations.
-        context.close(promise: nil)
-        self.channel = nil
-        self.eventFlow.send(.closed)
-    }
-    
-    public func channelInactive(context: ChannelHandlerContext) {
-        self.channel = nil
-        context.close(promise: nil)
-    }
-    
-    // 处理写入逻辑
-    func send(remoteAddress: SocketAddress, type: SDLPacketType, data: Data) {
-        guard let channel = self.channel else {
-            return
-        }
-        
-        // 在Eventloop中时直接写入数据避免线程切换
-        if channel.eventLoop.inEventLoop {
-            var buffer = channel.allocator.buffer(capacity: data.count + 1)
-            buffer.writeBytes([type.rawValue])
-            buffer.writeBytes(data)
-            
-            let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
-            channel.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
-        } else {
-            channel.eventLoop.execute {
-                var buffer = channel.allocator.buffer(capacity: data.count + 1)
-                buffer.writeBytes([type.rawValue])
-                buffer.writeBytes(data)
-                
-                let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
-                channel.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
-            }
-        }
-    }
-    
-    deinit {
-        try? self.group.syncShutdownGracefully()
-    }
-}
-
-//--MARK: 编解码器
-extension SDLUDPHole {
-    
-    func decode(buffer: inout ByteBuffer) throws -> SDLHoleInboundMessage? {
-        guard let type = buffer.readInteger(as: UInt8.self),
-              let packetType = SDLPacketType(rawValue: type),
-              let bytes = buffer.readBytes(length: buffer.readableBytes) else {
-            SDLLogger.log("[SDLUDPHole] decode error", level: .error)
-            return nil
-        }
-        
-        switch packetType {
-        case .data:
-            let dataPacket = try SDLData(serializedData: Data(bytes))
-            return .data(dataPacket)
-        case .register:
-            let registerPacket = try SDLRegister(serializedData: Data(bytes))
-            return .register(registerPacket)
-        case .registerAck:
-            let registerAck = try SDLRegisterAck(serializedData: Data(bytes))
-            return .registerAck(registerAck)
-        case .stunReply:
-            let stunReply = try SDLStunReply(serializedData: Data(bytes))
-            return .stunReply(stunReply)
-        case .stunProbeReply:
-            let stunProbeReply = try SDLStunProbeReply(serializedData: Data(bytes))
-            return .stunProbeReply(stunProbeReply)
-        default:
-            return nil
-        }
-    }
-}
-
-// --MARK: 回调函数管理器
-extension SDLUDPHole {
-    private final class HoleCallbackManager {
-        // 对应请求体和相应的关系
-        private var callbacks: [UInt32:CallbackFun] = [:]
-        private let locker = NSLock()
-        
-        func addCallback(id: UInt32, timeout: Int, callback: @escaping CallbackFun) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            DispatchQueue.global().asyncAfter(deadline: .now() + Double(timeout)) {
-                self.fireCallback(cookie: id)
-            }
-            
-            self.callbacks[id] = callback
-        }
-        
-        func fireCallback(message: SDLStunProbeReply) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            if let callback = self.callbacks[message.cookie] {
-                callback(message)
-                self.callbacks.removeValue(forKey: message.cookie)
-            }
-        }
-        
-        func fireAllCallbacks(message: SDLSuperInboundMessage) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            for (_, callback) in self.callbacks {
-                callback(nil)
-            }
-            self.callbacks.removeAll()
-        }
-        
-        private func fireCallback(cookie: UInt32) {
-            locker.lock()
-            defer {
-                locker.unlock()
-            }
-            
-            if let callback = self.callbacks[cookie] {
-                callback(nil)
-                self.callbacks.removeValue(forKey: cookie)
-            }
-        }
-
-    }
-}

dmg.sh

@@ -1,3 +1,3 @@
 #! /bin/sh
 
-create-dmg --volname "punchnet" --window-pos 200 120 --window-size 800 400 --icon "punchnet.app" 200 190 --hide-extension "punchnet.app" --app-drop-link 600 185 ~/Desktop/punchnet.dmg  /Users/anlicheng/Desktop/punchnet_v1
+create-dmg --volname "punchnet" --window-pos 200 120 --window-size 800 400 --icon "punchnet.app" 200 190 --hide-extension "punchnet.app" --app-drop-link 600 185 ~/Desktop/punchnet.dmg  /Users/anlicheng/Desktop/punchnet_macos_v1

docs.md

@@ -0,0 +1,12 @@
+1. 查看dns的设置
+    networksetup -getdnsservers Wi-Fi
+    scutil --dns
+
+2. 修改系统的dns设置
+    networksetup -setdnsservers Wi-Fi 8.8.8.8 1.1.1.1
+
+    恢复为自动获取
+
+    networksetup -setdnsservers Wi-Fi empty
+
+

punchnet/Core/NoticeMessage.swift

@@ -6,45 +6,85 @@
 //
 
 import Foundation
+import NIOCore
 
 struct NoticeMessage {
-    // 消息类型
-    enum NoticeType: UInt8 {
-        case upgrade = 1
-        case alert = 2
-    }
-    
-    struct UpgradeMessage: Codable {
-        let prompt: String
-        let address: String
-        
-        var binaryData: Data {
-            let json = try! JSONEncoder().encode(self)
-            var data = Data()
-            data.append(contentsOf: [NoticeType.upgrade.rawValue])
-            data.append(json)
-            
-            return data
-        }
-    }
-    
-    struct AlertMessage: Codable {
-        let alert: String
-        
-        var binaryData: Data {
-            let json = try! JSONEncoder().encode(self)
-            var data = Data()
-            data.append(contentsOf: [NoticeType.alert.rawValue])
-            data.append(json)
-            
-            return data
-        }
-    }
-    
     enum InboundMessage {
         case none
-        case upgradeMessage(UpgradeMessage)
-        case alertMessage(AlertMessage)
+        case upgradeMessage(prompt: String, address: String)
+        case alertMessage(alert: String)
+        case ip(ip: String)
+    }
+    
+    static func decodeMessage(buffer: inout ByteBuffer) -> InboundMessage {
+        guard let type = buffer.readInteger(as: UInt8.self) else {
+            return .none
+        }
+        
+        switch type {
+        case 0x01:
+            if let len0 = buffer.readInteger(as: UInt16.self),
+               let prompt = buffer.readString(length: Int(len0)),
+               let len1 = buffer.readInteger(as: UInt16.self),
+               let address = buffer.readString(length: Int(len1)) {
+                return .upgradeMessage(prompt: prompt, address: address)
+            }
+        case 0x02:
+            if let len0 = buffer.readInteger(as: UInt16.self),
+               let alert = buffer.readString(length: Int(len0)) {
+                return .alertMessage(alert: alert)
+            }
+            
+        case 0x03:
+            if let len0 = buffer.readInteger(as: UInt16.self),
+               let ipAddress = buffer.readString(length: Int(len0)) {
+                return .ip(ip: ipAddress)
+            }
+        default:
+            return .none
+        }
+        
+        return .none
+    }
+    
+    static func upgrade(prompt: String, address: String) -> Data {
+        var data = Data()
+        data.append(contentsOf: [0x01])
+        
+        data.append(contentsOf: lenBytes(UInt16(prompt.count)))
+        data.append(prompt.data(using: .utf8)!)
+        
+        data.append(contentsOf: lenBytes(UInt16(address.count)))
+        data.append(address.data(using: .utf8)!)
+        
+        return data
+    }
+    
+    static func alert(alert: String) -> Data {
+        var data = Data()
+        data.append(contentsOf: [0x02])
+        
+        data.append(contentsOf: lenBytes(UInt16(alert.count)))
+        data.append(alert.data(using: .utf8)!)
+        
+        return data
+    }
+    
+    static func ipAdress(ip: String) -> Data {
+        var data = Data()
+        data.append(contentsOf: [0x03])
+        
+        data.append(contentsOf: lenBytes(UInt16(ip.count)))
+        data.append(ip.data(using: .utf8)!)
+        
+        return data
+    }
+    
+    private static func lenBytes(_ value: UInt16) -> [UInt8] {
+        let byte1 = UInt8((value >> 8) & 0xFF)
+        let bytes2 = UInt8(value & 0xFF)
+        
+        return [byte1, bytes2]
     }
     
 }

punchnet/Core/PunchnetConfig.swift

@@ -1,30 +0,0 @@
-//
-//  Config.swift
-//  punchnet
-//
-//  Created by 安礼成 on 2025/5/14.
-//
-import Foundation
-
-enum PunchnetError: Error {
-    case dnsUnreachable
-}
-
-struct PunchnetConfig {
-    static let server = "punchnet.aioe.tech"
-    static let port = 18083
-    
-    static func getOptions() throws -> [String:NSObject] {
-        var options: [String: NSObject] = [:]
-        
-        if let ip = DNSResolver.resolveAddrInfos(PunchnetConfig.server).first {
-            options["super_ip"] = ip as NSObject
-        } else {
-            throw PunchnetError.dnsUnreachable
-        }
-        
-        return options
-    }
-    
-}
-

punchnet/Core/SDLAPI.swift

@@ -20,12 +20,23 @@ struct JSONRPCError: Decodable {
 
 struct SDLAPI {
     
+    static let baseUrl: String = "https://punchnet.s5s8.com/api"
+    static let testBaseUrl: String = "http://127.0.0.1:19082/test"
+
     struct Upgrade: Decodable {
         let upgrade_type: Int
         let upgrade_prompt: String
         let upgrade_address: String
     }
     
+    struct NetworkProfile: Decodable {
+        struct NetworkItem: Decodable {
+            let name: String
+            let code: String
+        }
+        let network: [NetworkItem]
+    }
+    
     static func checkVersion(clientId: String, version: Int, channel: String) async throws -> JSONRPCResponse<Upgrade> {
         let params: [String:Any] = [
             "client_id": clientId,
@@ -34,7 +45,7 @@ struct SDLAPI {
         ]
         
         let postData = try! JSONSerialization.data(withJSONObject: params)
-        var request = URLRequest(url: URL(string: "http://127.0.0.1:18082/test/upgrade")!)
+        var request = URLRequest(url: URL(string: baseUrl + "/upgrade")!)
         request.httpMethod = "POST"
         request.addValue("application/json", forHTTPHeaderField: "Content-Type")
         request.httpBody = postData
@@ -44,4 +55,20 @@ struct SDLAPI {
         return try JSONDecoder().decode(JSONRPCResponse<Upgrade>.self, from: data)
     }
     
+    static func getUserNetworks(clientId: String) async throws -> JSONRPCResponse<NetworkProfile> {
+        let params: [String:Any] = [
+            "client_id": clientId
+        ]
+        
+        let postData = try! JSONSerialization.data(withJSONObject: params)
+        var request = URLRequest(url: URL(string: baseUrl + "/get_user_network")!)
+        request.httpMethod = "POST"
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = postData
+        
+        let (data, _) = try await URLSession.shared.data(for: request)
+        
+        return try JSONDecoder().decode(JSONRPCResponse<NetworkProfile>.self, from: data)
+    }
+    
 }

punchnet/Core/SystemConfig.swift

@@ -15,4 +15,49 @@ struct SystemConfig {
     
     // 安装渠道
     static let installedChannel = "MacAppStore"
+    
+    // super 节点
+    //static let superHost = "118.178.229.213"
+    
+    static let superHost = "punchnet.s5s8.com"
+    static let superPort = 18083
+    
+    // stun探测服务
+    static let stunServers = "118.178.229.213:1265,1266;118.178.229.213:1265,1266"
+    //static let stunServers = "127.0.0.1:1265,1266;127.0.0.1:1265,1266"
+    
+    static func getOptions(networkCode: String, token: String, clientId: String, hostname: String, noticePort: Int) -> [String:NSObject]? {
+        guard let superIp = DNSResolver.resolveAddrInfos(superHost).first else {
+            return nil
+        }
+        
+        let options =  [
+            "version:": version as NSObject,
+            "installed_channel": installedChannel as NSObject,
+            "client_id": clientId as NSObject,
+            "network_code": networkCode as NSObject,
+            "token": token as NSObject,
+            "super_ip": superIp as NSObject,
+            "super_port": superPort as NSObject,
+            "stun_servers": stunServers as NSObject,
+            "remote_dns_server": superIp as NSObject,
+            "hostname": hostname as NSObject,
+            "notice_port": noticePort as NSObject
+        ]
+        
+        return options
+    }
+    
+    public static func getClientId() -> String {
+        let userDefaults = UserDefaults.standard
+        if let uuid = userDefaults.value(forKey: "gClientId") as? String {
+            return uuid
+        } else {
+            let uuid = UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased()
+            userDefaults.setValue(uuid, forKey: "gClientId")
+            
+            return uuid
+        }
+    }
+    
 }

punchnet/Core/UDPNoticeCenterServer.swift

@@ -15,32 +15,23 @@ final class UDPNoticeCenterServer: ChannelInboundHandler {
     public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
     
     private var group: MultiThreadedEventLoopGroup?
-    private var thread: Thread?
+    private var channel: Channel?
     
     var messageFlow = PassthroughSubject<NoticeMessage.InboundMessage, Never>()
-    static let shared = UDPNoticeCenterServer()
-    
-    private init() {
-        
-    }
+    public var port: Int = 0
     
     func start() {
-        self.thread = Thread {
         self.group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         let bootstrap = DatagramBootstrap(group: self.group!)
             .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
             .channelInitializer { channel in
                 channel.pipeline.addHandler(self)
             }
-            
-            let channel = try! bootstrap.bind(host: "127.0.0.1", port: 50195).wait()
-            try! channel.closeFuture.wait()
-        }
-        self.thread?.start()
+        self.channel = try! bootstrap.bind(host: "127.0.0.1", port: 0).wait()
+        self.port = self.channel?.localAddress?.port ?? 0
     }
     
     func stop() {
-        self.thread?.cancel()
         try? self.group?.syncShutdownGracefully()
     }
     
@@ -49,26 +40,9 @@ final class UDPNoticeCenterServer: ChannelInboundHandler {
     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
         let envelope = self.unwrapInboundIn(data)
         var buffer = envelope.data
-        guard let type = buffer.readInteger(as: UInt8.self),
-              let noticeType = NoticeMessage.NoticeType(rawValue: type),
-              let bytes = buffer.readBytes(length: buffer.readableBytes) else {
-            return
-        }
         
-        switch noticeType {
-        case .upgrade:
-            if let upgradeMessage = try? JSONDecoder().decode(NoticeMessage.UpgradeMessage.self, from: Data(bytes)) {
-                DispatchQueue.main.async {
-                    self.messageFlow.send(.upgradeMessage(upgradeMessage))
-                }
-            }
-        case .alert:
-            if let alertMessage = try? JSONDecoder().decode(NoticeMessage.AlertMessage.self, from: Data(bytes)) {
-                DispatchQueue.main.async {
-                    self.messageFlow.send(.alertMessage(alertMessage))
-                }
-            }
-        }
+        let notice = NoticeMessage.decodeMessage(buffer: &buffer)
+        self.messageFlow.send(notice)
     }
     
     public func channelReadComplete(context: ChannelHandlerContext) {

punchnet/Core/VPNManager.swift

@@ -28,14 +28,12 @@ class VPNManager: ObservableObject {
     
     // 开启vpn
     func enableVpn(options: [String : NSObject]) async throws {
+        NSLog("enable vpn with options: \(options)")
         let manager = try await loadAndCreateProviderManager()
         try await manager.loadFromPreferences()
         self.addVPNStatusObserver(manager)
         
-        var configOptions = try PunchnetConfig.getOptions()
-        configOptions.merge(options, uniquingKeysWith: {$1})
-        
-        try manager.connection.startVPNTunnel(options: configOptions)
+        try manager.connection.startVPNTunnel(options: options)
     }
     
     // 关闭vpn
@@ -76,14 +74,14 @@ class VPNManager: ObservableObject {
         let managers = try await NETunnelProviderManager.loadAllFromPreferences()
         
         let manager = managers.first ?? NETunnelProviderManager()
-        manager.localizedDescription = "punchnet"
+        manager.localizedDescription = "punchnetmac"
         manager.isEnabled = true
         
         // 设置相关参数，在PacketTunnel中可以用
         let protocolConfiguration = NETunnelProviderProtocol()
-        protocolConfiguration.serverAddress = "punchnet"
+        protocolConfiguration.serverAddress = "punchnetmac"
         protocolConfiguration.providerConfiguration = [String:AnyObject]()
-        protocolConfiguration.providerBundleIdentifier = "com.jihe.punchnet.tun"
+        protocolConfiguration.providerBundleIdentifier = "com.jihe.punchnetmac.tun"
         manager.protocolConfiguration = protocolConfiguration
         manager.isOnDemandEnabled = false
         

punchnet/Views/AbortView.swift

@@ -9,7 +9,6 @@ import Foundation
 import SwiftUI
 
 struct AbortView: View {
-    
     struct AlertShow: Identifiable {
         enum ShowContent {
             case error(String)

punchnet/Views/IndexView.swift

@@ -9,9 +9,11 @@ import SwiftUI
 import SwiftData
 import Combine
 
-struct ContentView: View {
-    
+struct IndexView: View {
     @AppStorage("token") private var token: String = ""
+    @AppStorage("hostname") private var hostname: String = ""
+    @AppStorage("network_code") private var networkCode: String = ""
+    
     @State private var showToken: Bool = false
     
     @ObservedObject private var vpnManager = VPNManager.shared
@@ -22,6 +24,15 @@ struct ContentView: View {
     
     @State private var showMenu: Bool = false
     
+    @State private var networkProfile: SDLAPI.NetworkProfile = .init(network: [])
+    @State private var selectedIdx: Int = 0
+    
+    // 显示ip信息
+    @State private var showIpAdress: Bool = false
+    @State private var ipAddress: String = ""
+
+    public var noticeServer: UDPNoticeCenterServer
+    
     var body: some View {
         
         VStack(alignment: .center, spacing: 10) {
@@ -47,11 +58,54 @@ struct ContentView: View {
             .onTapGesture {
                 self.showMenu = false
             }
+            TextField("主机名", text: $hostname)
+                .multilineTextAlignment(.leading)
+                .textFieldStyle(PlainTextFieldStyle())
+                .frame(width: 200, height: 25)
+                .background(Color.white)
+                .foregroundColor(Color.black)
+                .cornerRadius(5.0)
+            
+            if showIpAdress {
+                HStack {
+                    Spacer()
+                    
+                    Text("ip: ")
+                        .font(.system(size: 16, weight: .medium))
+                        .foregroundColor(.white)
+                        .cornerRadius(5.0)
+                    
+                    Text(ipAddress)
+                        .font(.system(size: 16, weight: .medium))
+                        .foregroundColor(.white)
+                        .cornerRadius(5.0)
+                    
+                    Spacer()
+                }
+            }
             
             Spacer()
                 .frame(width: 1, height: 10)
             
-            if showToken {
+            VStack(spacing: 0) {
+                ForEach(Array(networkProfile.network.enumerated()), id: \.offset) { idx, network in
+                    NetworkItemView(idx: idx, item: network)
+                        .padding(.horizontal, 8)
+                        .padding(.vertical, 6)
+                        .background(
+                            RoundedRectangle(cornerRadius: 8)
+                                .fill(selectedIdx == idx ? Color.blue.opacity(0.3) : Color.clear)
+                        )
+                        .contentShape(Rectangle())
+                        .onTapGesture {
+                            withAnimation(.easeInOut(duration: 0.2)) {
+                                selectedIdx = idx
+                                self.networkCode = network.code
+                            }
+                        }
+                }
+            }
+            
             TextField("邀请码", text: $token)
                 .multilineTextAlignment(.leading)
                 .textFieldStyle(PlainTextFieldStyle())
@@ -59,7 +113,7 @@ struct ContentView: View {
                 .background(Color.white)
                 .foregroundColor(Color.black)
                 .cornerRadius(5.0)
-            }
+                .opacity(showToken ? 1 : 0)
             
             Spacer()
                 .frame(width: 1, height: 10)
@@ -82,8 +136,6 @@ struct ContentView: View {
                         }
                     }
                 }
-            
-            Spacer()
         }
         .overlay(alignment: .top) {
             
@@ -161,54 +213,95 @@ struct ContentView: View {
             }
             .offset(x: 0, y: 10)
         }
-        .frame(width: 300, height: 500)
+        .padding([.leading, .trailing, .top], 10)
+        .padding([.bottom], 20)
         .background(Color(red: 36 / 255, green: 38 / 255, blue: 51 / 255))
+        .frame(width: 320)
         .alert(isPresented: $showAlert) {
             Alert(title: Text("请输入正确的邀请码"))
         }
         .alert(isPresented: $showStunAlert) {
             switch self.message {
-            case .upgradeMessage(let upgradeMessage):
-                Alert(title: Text(upgradeMessage.prompt))
-            case .alertMessage(let alertMessage):
-                Alert(title: Text(alertMessage.alert))
+            case .upgradeMessage(let prompt, _):
+                Alert(title: Text(prompt))
+            case .alertMessage(let alert):
+                Alert(title: Text(alert))
             default:
                 Alert(title: Text(""))
             }
         }
+        .task {
+            do {
+                let response = try await SDLAPI.getUserNetworks(clientId: SystemConfig.getClientId())
+                print("get user networks: \(response)")
+                if let result = response.result {
+                    self.networkProfile = result
+                    if self.networkProfile.network.count > 0 {
+                        self.networkCode = self.networkProfile.network[0].code
+                    }
+                }
+            } catch let err {
+                NSLog("get user networks get error: \(err)")
+            }
+        }
         .onAppear {
-            self.cancel = UDPNoticeCenterServer.shared.messageFlow.sink{ message in
+            self.cancel = self.noticeServer.messageFlow.sink{ message in
                 DispatchQueue.main.async {
+                    switch message {
+                    case .none:
+                        ()
+                    case .ip(let ip):
+                        self.showIpAdress = true
+                        self.ipAddress = ip
+                    default:
                         self.message = message
                         self.showStunAlert = true
                     }
                 }
             }
         }
+    }
     
     private func clickSwitchButton() async throws {
         switch self.vpnManager.vpnStatus {
         case .connected:
+            self.showIpAdress = false
+            self.ipAddress = ""
             try await vpnManager.disableVpn()
         case .disconnected:
-            /*
-             if self.token.isEmpty {
-             self.showAlert = true
-             return
-             }
-             */
-            //print("use port: \(vpnManager.noticePort as NSObject)")
-            try await vpnManager.enableVpn(options: [
-                "version:": SystemConfig.version as NSObject,
-                "installed_channel": SystemConfig.installedChannel as NSObject,
-                "token": self.token as NSObject
-            ])
+            let clientId = SystemConfig.getClientId()
+            NSLog("[IndexView] use token: \(self.token), network_code: \(networkCode)")
+            // token存在则优先使用token
+            try await vpnManager.enableVpn(options: SystemConfig.getOptions(networkCode: self.networkCode, token: self.token, clientId: clientId, hostname: self.hostname, noticePort: self.noticeServer.port)!)
         }
     }
     
 }
 
+extension IndexView {
+    struct NetworkItemView: View {
+        let idx: Int
+        let item: SDLAPI.NetworkProfile.NetworkItem
+        
+        var body: some View {
+            HStack {
+                Text(item.name)
+                    .font(.system(size: 14))
+                    .foregroundColor(.white)
+                    .frame(width: 80, alignment: .leading)
+                
+                Text(item.code)
+                    .font(.system(size: 14))
+                    .foregroundColor(.white)
+                
+                Spacer()
+            }
+        }
+    }
+}
+
 #Preview {
-    ContentView()
+    let server = UDPNoticeCenterServer()
+    IndexView(noticeServer: server)
     //.modelContainer(for: Item.self, inMemory: true)
 }

punchnet/punchnetApp.swift

@@ -31,12 +31,20 @@ struct punchnetApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
     
     @AppStorage("token") var token: String = ""
+    @AppStorage("network_code") var networkCode: String = ""
+    @AppStorage("hostname") var hostname: String = ""
     @ObservedObject var vpnManager = VPNManager.shared
     
+    private var noticeServer: UDPNoticeCenterServer
+    
+    init() {
+        self.noticeServer = UDPNoticeCenterServer()
+        self.noticeServer.start()
+    }
+    
     var body: some Scene {
         WindowGroup(id: "mainWindow") {
-            ContentView()
-                .frame(minWidth: 300, maxWidth: 300, minHeight: 500, maxHeight: 500)
+            IndexView(noticeServer: self.noticeServer)
                 .onAppear {
                     // 获取主屏幕的尺寸
                     guard let screenFrame = NSScreen.main?.frame else { return }
@@ -53,6 +61,8 @@ struct punchnetApp: App {
                         window.setFrameOrigin(NSPoint(x: centerX, y: centerY))
                     }
                 }
+                .toolbar(.hidden)
+                .navigationTitle("")
         }
         .commands {
             CommandGroup(replacing: .appInfo) {
@@ -94,11 +104,8 @@ struct punchnetApp: App {
         switch self.vpnManager.vpnStatus {
         case .disconnected:
             Task {
-                try await vpnManager.enableVpn(options: [
-                    "version:": SystemConfig.version as NSObject,
-                    "installed_channel": SystemConfig.installedChannel as NSObject,
-                    "token": token as NSObject
-                ])
+                let clientId = SystemConfig.getClientId()
+                try await vpnManager.enableVpn(options: SystemConfig.getOptions(networkCode: self.networkCode, token: self.token, clientId: clientId, hostname: self.hostname, noticePort: self.noticeServer.port)!)
             }
         case .connected:
             Task {
@@ -113,7 +120,7 @@ struct punchnetApp: App {
 class AppDelegate: NSObject, NSApplicationDelegate {
     
     func applicationWillFinishLaunching(_ notification: Notification) {
-        UDPNoticeCenterServer.shared.start()
+        
     }
     
     func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
@@ -122,7 +129,6 @@ class AppDelegate: NSObject, NSApplicationDelegate {
             DispatchQueue.main.async {
                 sender.reply(toApplicationShouldTerminate: true)
             }
-            UDPNoticeCenterServer.shared.stop()
         }
         
         return .terminateLater