简化逻辑

This commit is contained in:
anlicheng 2026-04-16 16:26:49 +08:00
parent 8ebfdd1edf
commit 66721ce7b1

View File

@ -9,58 +9,20 @@ import Network
actor SDLIPV6AssistClient {
struct Packet: Sendable {
enum IPVersion: UInt8, Sendable {
case ipv4 = 4
case ipv6 = 6
var protocolFamily: Int32 {
switch self {
case .ipv4:
return 2
case .ipv6:
return 30
}
}
}
let packetId: UInt32
let ipPacketData: Data
let ipVersion: IPVersion
var protocolFamily: Int32 {
return self.ipVersion.protocolFamily
}
}
private enum State {
case idle
case running
case stopped
}
private struct PendingPacket: Sendable {
let packetId: UInt32
let ipVersion: Packet.IPVersion
}
private enum PacketParseError: Error {
case packetTooShort
case unmatchedPacketId(UInt32)
case invalidIPVersion(UInt8)
case unsupportedIPVersion(UInt8)
}
private var state: State = .idle
private var connection: NWConnection?
private var receiveTask: Task<Void, Never>?
private let assistServerAddress: NWEndpoint
private var idGenerator: SDLIdGenerator
private var pendingPackets: [UInt32: PendingPacket] = [:]
// IP
let packetFlow: AsyncStream<Packet>
private let packetContinuation: AsyncStream<Packet>.Continuation
let packetFlow: AsyncStream<SDLV6AssistProbeReply>
private let packetContinuation: AsyncStream<SDLV6AssistProbeReply>.Continuation
private var didFinishPacketFlow = false
//
@ -73,7 +35,7 @@ actor SDLIPV6AssistClient {
return nil
}
let (packetStream, packetContinuation) = AsyncStream.makeStream(of: Packet.self, bufferingPolicy: .bufferingNewest(256))
let (packetStream, packetContinuation) = AsyncStream.makeStream(of: SDLV6AssistProbeReply.self, bufferingPolicy: .bufferingNewest(256))
self.packetFlow = packetStream
self.packetContinuation = packetContinuation
@ -82,7 +44,6 @@ actor SDLIPV6AssistClient {
self.closeContinuation = closeContinuation
self.assistServerAddress = .hostPort(host: NWEndpoint.Host(host), port: NWEndpoint.Port(integerLiteral: UInt16(assistServerInfo.port)))
self.idGenerator = SDLIdGenerator(seed: UInt32.random(in: 1..<UInt32.max))
}
func start() {
@ -145,33 +106,16 @@ actor SDLIPV6AssistClient {
}
}
/// DNS TUN IP
/// IP 4 packetId
@discardableResult
func forward(ipPacketData: Data) -> UInt32? {
func probe() {
guard case .running = self.state, let connection = self.connection, connection.state == .ready else {
return nil
return
}
var assistProbe = SDLV6AssistProbe()
assistProbe.assistToken = Data()
let ipVersion: Packet.IPVersion
do {
ipVersion = try self.parseIPVersion(packetData: ipPacketData)
} catch {
SDLLogger.log("[SDLIPV6AssistClient] Invalid outbound packet: \(error)", for: .debug)
return nil
if let data = try? assistProbe.serializedData() {
connection.send(content: data, completion: .contentProcessed { _ in})
}
let packetId = self.idGenerator.nextId()
self.pendingPackets[packetId] = .init(packetId: packetId, ipVersion: ipVersion)
let outboundPacket = Data(components: Data(uint32: packetId), ipPacketData)
connection.send(content: outboundPacket, completion: .contentProcessed { [weak self] error in
Task {
await self?.handleSendCompletion(packetId: packetId, error: error)
}
})
return packetId
}
func stop() {
@ -182,7 +126,6 @@ actor SDLIPV6AssistClient {
self.state = .stopped
self.receiveTask?.cancel()
self.receiveTask = nil
self.pendingPackets.removeAll()
self.connection?.cancel()
self.connection = nil
self.finishPacketFlowIfNeeded()
@ -232,24 +175,13 @@ actor SDLIPV6AssistClient {
}
do {
let packet = try self.parseInboundPacket(data)
let packet = try SDLV6AssistProbeReply(serializedBytes: data)
self.packetContinuation.yield(packet)
} catch {
SDLLogger.log("[SDLIPV6AssistClient] Receive error: \(error)", for: .debug)
}
}
private func handleSendCompletion(packetId: UInt32, error: Error?) {
guard case .running = self.state else {
return
}
if let error {
self.pendingPackets.removeValue(forKey: packetId)
SDLLogger.log("[SDLIPV6AssistClient] Send error: \(error), packetId: \(packetId)", for: .debug)
}
}
private func didFinishReceiving(for connection: NWConnection) {
guard case .running = self.state else {
return
@ -262,42 +194,6 @@ actor SDLIPV6AssistClient {
}
}
private func parseInboundPacket(_ data: Data) throws -> Packet {
guard data.count > 4 else {
throw PacketParseError.packetTooShort
}
let packetId = UInt32(data: Data(data.prefix(4)))
guard let pendingPacket = self.pendingPackets.removeValue(forKey: packetId) else {
throw PacketParseError.unmatchedPacketId(packetId)
}
let ipPacketData = Data(data.dropFirst(4))
let ipVersion = try self.parseIPVersion(packetData: ipPacketData)
if ipVersion != pendingPacket.ipVersion {
SDLLogger.log("[SDLIPV6AssistClient] packet version mismatch, packetId: \(packetId), request: \(pendingPacket.ipVersion.rawValue), response: \(ipVersion.rawValue)", for: .debug)
}
return .init(packetId: pendingPacket.packetId, ipPacketData: ipPacketData, ipVersion: ipVersion)
}
private func parseIPVersion(packetData: Data) throws -> Packet.IPVersion {
guard let firstByte = packetData.first else {
throw PacketParseError.packetTooShort
}
let rawVersion = firstByte >> 4
guard let ipVersion = Packet.IPVersion(rawValue: rawVersion) else {
throw PacketParseError.invalidIPVersion(rawVersion)
}
guard ipVersion == .ipv6 else {
throw PacketParseError.unsupportedIPVersion(rawVersion)
}
return ipVersion
}
private func finishPacketFlowIfNeeded() {
guard !self.didFinishPacketFlow else {
return