diff --git a/Tun/Punchnet/SDLMessage.pb.swift b/Tun/Punchnet/SDLMessage.pb.swift index 29d09b8..51edb8f 100644 --- a/Tun/Punchnet/SDLMessage.pb.swift +++ b/Tun/Punchnet/SDLMessage.pb.swift @@ -260,56 +260,165 @@ struct SDLPolicyResponse: @unchecked Sendable { init() {} } -struct SDLNatChangedEvent: @unchecked Sendable { +struct SDLEvent: 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. - var mac: Data = Data() + var event: SDLEvent.OneOf_Event? = nil - var ip: UInt32 = 0 - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -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. - - var dstMac: Data = Data() - - var natIp: UInt32 = 0 - - var natPort: UInt32 = 0 - - var natType: UInt32 = 0 - - var v6Info: SDLV6Info { - get {return _v6Info ?? SDLV6Info()} - set {_v6Info = newValue} + var natChanged: SDLEvent.NatChanged { + get { + if case .natChanged(let v)? = event {return v} + return SDLEvent.NatChanged() + } + set {event = .natChanged(newValue)} + } + + var sendRegister: SDLEvent.SendRegister { + get { + if case .sendRegister(let v)? = event {return v} + return SDLEvent.SendRegister() + } + set {event = .sendRegister(newValue)} + } + + var shutdown: SDLEvent.NetworkShutdown { + get { + if case .shutdown(let v)? = event {return v} + return SDLEvent.NetworkShutdown() + } + set {event = .shutdown(newValue)} } - /// Returns true if `v6Info` has been explicitly set. - var hasV6Info: Bool {return self._v6Info != nil} - /// Clears the value of `v6Info`. Subsequent reads from it will return its default value. - mutating func clearV6Info() {self._v6Info = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - init() {} + enum OneOf_Event: Equatable, Sendable { + case natChanged(SDLEvent.NatChanged) + case sendRegister(SDLEvent.SendRegister) + case shutdown(SDLEvent.NetworkShutdown) - fileprivate var _v6Info: SDLV6Info? = nil + } + + /// nat映射变化 + struct NatChanged: @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. + + var mac: Data = Data() + + var ip: UInt32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + /// 发送register消息 + struct SendRegister: @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. + + var dstMac: Data = Data() + + var natIp: UInt32 = 0 + + var natPort: UInt32 = 0 + + var natType: UInt32 = 0 + + var v6Info: SDLV6Info { + get {return _v6Info ?? SDLV6Info()} + set {_v6Info = newValue} + } + /// Returns true if `v6Info` has been explicitly set. + var hasV6Info: Bool {return self._v6Info != nil} + /// Clears the value of `v6Info`. Subsequent reads from it will return its default value. + mutating func clearV6Info() {self._v6Info = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _v6Info: SDLV6Info? = nil + } + + /// 网络关闭 + struct NetworkShutdown: 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. + + var message: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} } -struct SDLNetworkShutdownEvent: Sendable { +/// Command指令 +struct SDLCommand: 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. + var pktID: UInt32 = 0 + + var command: SDLCommand.OneOf_Command? = nil + + var exitNode: SDLCommand.ExitNodeControl { + get { + if case .exitNode(let v)? = command {return v} + return SDLCommand.ExitNodeControl() + } + set {command = .exitNode(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Command: Equatable, Sendable { + case exitNode(SDLCommand.ExitNodeControl) + + } + + /// 出口节点控制 + struct ExitNodeControl: 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. + + /// 必选：操作类型 + var action: Int32 = 0 + + /// 可选：备注（方便日志/调试） + var remark: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} +} + +struct SDLCommandAck: @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. + + var pktID: UInt32 = 0 + + var code: Int32 = 0 + var message: String = String() + var data: Data = Data() + var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -1019,8 +1128,96 @@ extension SDLPolicyResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem } } -extension SDLNatChangedEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SDLNatChangedEvent" +extension SDLEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = "SDLEvent" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .standard(proto: "nat_changed"), + 2: .standard(proto: "send_register"), + 3: .same(proto: "shutdown"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { + var v: SDLEvent.NatChanged? + var hadOneofValue = false + if let current = self.event { + hadOneofValue = true + if case .natChanged(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.event = .natChanged(v) + } + }() + case 2: try { + var v: SDLEvent.SendRegister? + var hadOneofValue = false + if let current = self.event { + hadOneofValue = true + if case .sendRegister(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.event = .sendRegister(v) + } + }() + case 3: try { + var v: SDLEvent.NetworkShutdown? + var hadOneofValue = false + if let current = self.event { + hadOneofValue = true + if case .shutdown(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.event = .shutdown(v) + } + }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + switch self.event { + case .natChanged?: try { + guard case .natChanged(let v)? = self.event else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .sendRegister?: try { + guard case .sendRegister(let v)? = self.event else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .shutdown?: try { + guard case .shutdown(let v)? = self.event else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SDLEvent, rhs: SDLEvent) -> Bool { + if lhs.event != rhs.event {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SDLEvent.NatChanged: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SDLEvent.protoMessageName + ".NatChanged" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "mac"), 2: .same(proto: "ip"), @@ -1049,7 +1246,7 @@ extension SDLNatChangedEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImple try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SDLNatChangedEvent, rhs: SDLNatChangedEvent) -> Bool { + static func ==(lhs: SDLEvent.NatChanged, rhs: SDLEvent.NatChanged) -> Bool { if lhs.mac != rhs.mac {return false} if lhs.ip != rhs.ip {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -1057,8 +1254,8 @@ extension SDLNatChangedEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImple } } -extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SDLSendRegisterEvent" +extension SDLEvent.SendRegister: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SDLEvent.protoMessageName + ".SendRegister" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "dst_mac"), 2: .standard(proto: "nat_ip"), @@ -1106,7 +1303,7 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SDLSendRegisterEvent, rhs: SDLSendRegisterEvent) -> Bool { + static func ==(lhs: SDLEvent.SendRegister, rhs: SDLEvent.SendRegister) -> Bool { if lhs.dstMac != rhs.dstMac {return false} if lhs.natIp != rhs.natIp {return false} if lhs.natPort != rhs.natPort {return false} @@ -1117,8 +1314,8 @@ extension SDLSendRegisterEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } } -extension SDLNetworkShutdownEvent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SDLNetworkShutdownEvent" +extension SDLEvent.NetworkShutdown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SDLEvent.protoMessageName + ".NetworkShutdown" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "message"), ] @@ -1142,13 +1339,155 @@ extension SDLNetworkShutdownEvent: SwiftProtobuf.Message, SwiftProtobuf._Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SDLNetworkShutdownEvent, rhs: SDLNetworkShutdownEvent) -> Bool { + static func ==(lhs: SDLEvent.NetworkShutdown, rhs: SDLEvent.NetworkShutdown) -> Bool { if lhs.message != rhs.message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } +extension SDLCommand: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = "SDLCommand" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .standard(proto: "pkt_id"), + 2: .standard(proto: "exit_node"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularUInt32Field(value: &self.pktID) }() + case 2: try { + var v: SDLCommand.ExitNodeControl? + var hadOneofValue = false + if let current = self.command { + hadOneofValue = true + if case .exitNode(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.command = .exitNode(v) + } + }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if self.pktID != 0 { + try visitor.visitSingularUInt32Field(value: self.pktID, fieldNumber: 1) + } + try { if case .exitNode(let v)? = self.command { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SDLCommand, rhs: SDLCommand) -> Bool { + if lhs.pktID != rhs.pktID {return false} + if lhs.command != rhs.command {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SDLCommand.ExitNodeControl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SDLCommand.protoMessageName + ".ExitNodeControl" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "action"), + 2: .same(proto: "remark"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularInt32Field(value: &self.action) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.remark) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.action != 0 { + try visitor.visitSingularInt32Field(value: self.action, fieldNumber: 1) + } + if !self.remark.isEmpty { + try visitor.visitSingularStringField(value: self.remark, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SDLCommand.ExitNodeControl, rhs: SDLCommand.ExitNodeControl) -> Bool { + if lhs.action != rhs.action {return false} + if lhs.remark != rhs.remark {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SDLCommandAck: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = "SDLCommandAck" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .standard(proto: "pkt_id"), + 2: .same(proto: "code"), + 3: .same(proto: "message"), + 4: .same(proto: "data"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularUInt32Field(value: &self.pktID) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self.code) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.message) }() + case 4: try { try decoder.decodeSingularBytesField(value: &self.data) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.pktID != 0 { + try visitor.visitSingularUInt32Field(value: self.pktID, fieldNumber: 1) + } + if self.code != 0 { + try visitor.visitSingularInt32Field(value: self.code, fieldNumber: 2) + } + if !self.message.isEmpty { + try visitor.visitSingularStringField(value: self.message, fieldNumber: 3) + } + if !self.data.isEmpty { + try visitor.visitSingularBytesField(value: self.data, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SDLCommandAck, rhs: SDLCommandAck) -> Bool { + if lhs.pktID != rhs.pktID {return false} + if lhs.code != rhs.code {return false} + if lhs.message != rhs.message {return false} + if lhs.data != rhs.data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension SDLStunRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = "SDLStunRequest" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ diff --git a/Tun/Punchnet/SDLMessage.swift b/Tun/Punchnet/SDLMessage.swift index ec4a3b9..8ec4fdf 100644 --- a/Tun/Punchnet/SDLMessage.swift +++ b/Tun/Punchnet/SDLMessage.swift @@ -137,9 +137,3 @@ enum SDLEventType: UInt8 { case sendRegister = 0x04 case networkShutdown = 0xFF } - -enum SDLEvent { - case natChanged(SDLNatChangedEvent) - case sendRegister(SDLSendRegisterEvent) - case networkShutdown(SDLNetworkShutdownEvent) -}