mirror of
https://github.com/EasyTier/EasyTier.git
synced 2026-10-08 10:56:13 -08:00
KKRainbow
3d0c9c3ca5
* chore(go): use lowercase module import path * ci: scope checks for Go module changes
2533 lines
74 KiB
Go
2533 lines
74 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.11
|
|
// protoc v7.35.1
|
|
// source: common.proto
|
|
|
|
package common
|
|
|
|
import (
|
|
error1 "github.com/easytier/easytier/easytier-go/proto/error"
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
type CompressionAlgoPb int32
|
|
|
|
const (
|
|
CompressionAlgoPb_Invalid CompressionAlgoPb = 0
|
|
CompressionAlgoPb_None CompressionAlgoPb = 1
|
|
CompressionAlgoPb_Zstd CompressionAlgoPb = 2
|
|
)
|
|
|
|
// Enum value maps for CompressionAlgoPb.
|
|
var (
|
|
CompressionAlgoPb_name = map[int32]string{
|
|
0: "Invalid",
|
|
1: "None",
|
|
2: "Zstd",
|
|
}
|
|
CompressionAlgoPb_value = map[string]int32{
|
|
"Invalid": 0,
|
|
"None": 1,
|
|
"Zstd": 2,
|
|
}
|
|
)
|
|
|
|
func (x CompressionAlgoPb) Enum() *CompressionAlgoPb {
|
|
p := new(CompressionAlgoPb)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x CompressionAlgoPb) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (CompressionAlgoPb) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_common_proto_enumTypes[0].Descriptor()
|
|
}
|
|
|
|
func (CompressionAlgoPb) Type() protoreflect.EnumType {
|
|
return &file_common_proto_enumTypes[0]
|
|
}
|
|
|
|
func (x CompressionAlgoPb) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use CompressionAlgoPb.Descriptor instead.
|
|
func (CompressionAlgoPb) EnumDescriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
type NatType int32
|
|
|
|
const (
|
|
// has NAT; but own a single public IP, port is not changed
|
|
NatType_Unknown NatType = 0
|
|
NatType_OpenInternet NatType = 1
|
|
NatType_NoPAT NatType = 2
|
|
NatType_FullCone NatType = 3
|
|
NatType_Restricted NatType = 4
|
|
NatType_PortRestricted NatType = 5
|
|
NatType_Symmetric NatType = 6
|
|
NatType_SymUdpFirewall NatType = 7
|
|
NatType_SymmetricEasyInc NatType = 8
|
|
NatType_SymmetricEasyDec NatType = 9
|
|
)
|
|
|
|
// Enum value maps for NatType.
|
|
var (
|
|
NatType_name = map[int32]string{
|
|
0: "Unknown",
|
|
1: "OpenInternet",
|
|
2: "NoPAT",
|
|
3: "FullCone",
|
|
4: "Restricted",
|
|
5: "PortRestricted",
|
|
6: "Symmetric",
|
|
7: "SymUdpFirewall",
|
|
8: "SymmetricEasyInc",
|
|
9: "SymmetricEasyDec",
|
|
}
|
|
NatType_value = map[string]int32{
|
|
"Unknown": 0,
|
|
"OpenInternet": 1,
|
|
"NoPAT": 2,
|
|
"FullCone": 3,
|
|
"Restricted": 4,
|
|
"PortRestricted": 5,
|
|
"Symmetric": 6,
|
|
"SymUdpFirewall": 7,
|
|
"SymmetricEasyInc": 8,
|
|
"SymmetricEasyDec": 9,
|
|
}
|
|
)
|
|
|
|
func (x NatType) Enum() *NatType {
|
|
p := new(NatType)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x NatType) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (NatType) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_common_proto_enumTypes[1].Descriptor()
|
|
}
|
|
|
|
func (NatType) Type() protoreflect.EnumType {
|
|
return &file_common_proto_enumTypes[1]
|
|
}
|
|
|
|
func (x NatType) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use NatType.Descriptor instead.
|
|
func (NatType) EnumDescriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
type SocketType int32
|
|
|
|
const (
|
|
SocketType_TCP SocketType = 0
|
|
SocketType_UDP SocketType = 1
|
|
)
|
|
|
|
// Enum value maps for SocketType.
|
|
var (
|
|
SocketType_name = map[int32]string{
|
|
0: "TCP",
|
|
1: "UDP",
|
|
}
|
|
SocketType_value = map[string]int32{
|
|
"TCP": 0,
|
|
"UDP": 1,
|
|
}
|
|
)
|
|
|
|
func (x SocketType) Enum() *SocketType {
|
|
p := new(SocketType)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x SocketType) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (SocketType) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_common_proto_enumTypes[2].Descriptor()
|
|
}
|
|
|
|
func (SocketType) Type() protoreflect.EnumType {
|
|
return &file_common_proto_enumTypes[2]
|
|
}
|
|
|
|
func (x SocketType) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use SocketType.Descriptor instead.
|
|
func (SocketType) EnumDescriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
type FlagsInConfig struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
DefaultProtocol string `protobuf:"bytes,1,opt,name=default_protocol,json=defaultProtocol,proto3" json:"default_protocol,omitempty"`
|
|
DevName string `protobuf:"bytes,2,opt,name=dev_name,json=devName,proto3" json:"dev_name,omitempty"`
|
|
EnableEncryption bool `protobuf:"varint,3,opt,name=enable_encryption,json=enableEncryption,proto3" json:"enable_encryption,omitempty"`
|
|
EnableIpv6 bool `protobuf:"varint,4,opt,name=enable_ipv6,json=enableIpv6,proto3" json:"enable_ipv6,omitempty"`
|
|
Mtu uint32 `protobuf:"varint,5,opt,name=mtu,proto3" json:"mtu,omitempty"`
|
|
LatencyFirst bool `protobuf:"varint,6,opt,name=latency_first,json=latencyFirst,proto3" json:"latency_first,omitempty"`
|
|
EnableExitNode bool `protobuf:"varint,7,opt,name=enable_exit_node,json=enableExitNode,proto3" json:"enable_exit_node,omitempty"`
|
|
NoTun bool `protobuf:"varint,8,opt,name=no_tun,json=noTun,proto3" json:"no_tun,omitempty"`
|
|
UseSmoltcp bool `protobuf:"varint,9,opt,name=use_smoltcp,json=useSmoltcp,proto3" json:"use_smoltcp,omitempty"`
|
|
RelayNetworkWhitelist string `protobuf:"bytes,10,opt,name=relay_network_whitelist,json=relayNetworkWhitelist,proto3" json:"relay_network_whitelist,omitempty"`
|
|
DisableP2P bool `protobuf:"varint,11,opt,name=disable_p2p,json=disableP2p,proto3" json:"disable_p2p,omitempty"`
|
|
RelayAllPeerRpc bool `protobuf:"varint,12,opt,name=relay_all_peer_rpc,json=relayAllPeerRpc,proto3" json:"relay_all_peer_rpc,omitempty"`
|
|
DisableUdpHolePunching bool `protobuf:"varint,13,opt,name=disable_udp_hole_punching,json=disableUdpHolePunching,proto3" json:"disable_udp_hole_punching,omitempty"`
|
|
// string ipv6_listener = 14; [deprecated = true]; use -l udp://[::]:12345
|
|
// instead
|
|
MultiThread bool `protobuf:"varint,15,opt,name=multi_thread,json=multiThread,proto3" json:"multi_thread,omitempty"`
|
|
DataCompressAlgo CompressionAlgoPb `protobuf:"varint,16,opt,name=data_compress_algo,json=dataCompressAlgo,proto3,enum=common.CompressionAlgoPb" json:"data_compress_algo,omitempty"`
|
|
BindDevice bool `protobuf:"varint,17,opt,name=bind_device,json=bindDevice,proto3" json:"bind_device,omitempty"`
|
|
// should we convert all tcp streams into kcp streams
|
|
EnableKcpProxy bool `protobuf:"varint,18,opt,name=enable_kcp_proxy,json=enableKcpProxy,proto3" json:"enable_kcp_proxy,omitempty"`
|
|
// does this peer allow kcp input
|
|
DisableKcpInput bool `protobuf:"varint,19,opt,name=disable_kcp_input,json=disableKcpInput,proto3" json:"disable_kcp_input,omitempty"`
|
|
// disable relay local network kcp packets
|
|
DisableRelayKcp bool `protobuf:"varint,20,opt,name=disable_relay_kcp,json=disableRelayKcp,proto3" json:"disable_relay_kcp,omitempty"`
|
|
ProxyForwardBySystem bool `protobuf:"varint,21,opt,name=proxy_forward_by_system,json=proxyForwardBySystem,proto3" json:"proxy_forward_by_system,omitempty"`
|
|
// enable magic dns or not
|
|
AcceptDns bool `protobuf:"varint,22,opt,name=accept_dns,json=acceptDns,proto3" json:"accept_dns,omitempty"`
|
|
// enable private mode
|
|
PrivateMode bool `protobuf:"varint,23,opt,name=private_mode,json=privateMode,proto3" json:"private_mode,omitempty"`
|
|
// should we convert all tcp streams into quic streams
|
|
EnableQuicProxy bool `protobuf:"varint,24,opt,name=enable_quic_proxy,json=enableQuicProxy,proto3" json:"enable_quic_proxy,omitempty"`
|
|
// does this peer allow quic input
|
|
DisableQuicInput bool `protobuf:"varint,25,opt,name=disable_quic_input,json=disableQuicInput,proto3" json:"disable_quic_input,omitempty"`
|
|
// disable relay local network quic packets
|
|
DisableRelayQuic bool `protobuf:"varint,35,opt,name=disable_relay_quic,json=disableRelayQuic,proto3" json:"disable_relay_quic,omitempty"`
|
|
// quic listen port
|
|
//
|
|
// Deprecated: Marked as deprecated in common.proto.
|
|
QuicListenPort uint32 `protobuf:"varint,33,opt,name=quic_listen_port,json=quicListenPort,proto3" json:"quic_listen_port,omitempty"`
|
|
// a global relay limit, only work for foreign network
|
|
ForeignRelayBpsLimit uint64 `protobuf:"varint,26,opt,name=foreign_relay_bps_limit,json=foreignRelayBpsLimit,proto3" json:"foreign_relay_bps_limit,omitempty"`
|
|
MultiThreadCount uint32 `protobuf:"varint,27,opt,name=multi_thread_count,json=multiThreadCount,proto3" json:"multi_thread_count,omitempty"`
|
|
// enable relay foreign network kcp packets
|
|
EnableRelayForeignNetworkKcp bool `protobuf:"varint,28,opt,name=enable_relay_foreign_network_kcp,json=enableRelayForeignNetworkKcp,proto3" json:"enable_relay_foreign_network_kcp,omitempty"`
|
|
// enable relay foreign network quic packets
|
|
EnableRelayForeignNetworkQuic bool `protobuf:"varint,36,opt,name=enable_relay_foreign_network_quic,json=enableRelayForeignNetworkQuic,proto3" json:"enable_relay_foreign_network_quic,omitempty"`
|
|
// encryption algorithm to use, empty string means default (aes-gcm)
|
|
EncryptionAlgorithm string `protobuf:"bytes,29,opt,name=encryption_algorithm,json=encryptionAlgorithm,proto3" json:"encryption_algorithm,omitempty"`
|
|
// disable symmetric nat hole punching, treat symmetric as cone when enabled
|
|
DisableSymHolePunching bool `protobuf:"varint,30,opt,name=disable_sym_hole_punching,json=disableSymHolePunching,proto3" json:"disable_sym_hole_punching,omitempty"`
|
|
// tld dns zone for magic dns
|
|
TldDnsZone string `protobuf:"bytes,31,opt,name=tld_dns_zone,json=tldDnsZone,proto3" json:"tld_dns_zone,omitempty"`
|
|
P2POnly bool `protobuf:"varint,32,opt,name=p2p_only,json=p2pOnly,proto3" json:"p2p_only,omitempty"`
|
|
DisableTcpHolePunching bool `protobuf:"varint,34,opt,name=disable_tcp_hole_punching,json=disableTcpHolePunching,proto3" json:"disable_tcp_hole_punching,omitempty"`
|
|
LazyP2P bool `protobuf:"varint,37,opt,name=lazy_p2p,json=lazyP2p,proto3" json:"lazy_p2p,omitempty"`
|
|
NeedP2P bool `protobuf:"varint,38,opt,name=need_p2p,json=needP2p,proto3" json:"need_p2p,omitempty"`
|
|
InstanceRecvBpsLimit uint64 `protobuf:"varint,39,opt,name=instance_recv_bps_limit,json=instanceRecvBpsLimit,proto3" json:"instance_recv_bps_limit,omitempty"`
|
|
DisableUpnp bool `protobuf:"varint,40,opt,name=disable_upnp,json=disableUpnp,proto3" json:"disable_upnp,omitempty"`
|
|
DisableRelayData bool `protobuf:"varint,41,opt,name=disable_relay_data,json=disableRelayData,proto3" json:"disable_relay_data,omitempty"`
|
|
EnableUdpBroadcastRelay bool `protobuf:"varint,42,opt,name=enable_udp_broadcast_relay,json=enableUdpBroadcastRelay,proto3" json:"enable_udp_broadcast_relay,omitempty"`
|
|
// Linux-only: SO_MARK (fwmark) value applied to every outbound underlay
|
|
// socket (TCP/UDP/QUIC/WS/WG connectors and listeners). Unset = leave
|
|
// SO_MARK untouched (kernel default 0). Any set value (including 0) is
|
|
// applied via setsockopt. Requires CAP_NET_ADMIN; silently ignored on
|
|
// non-Linux platforms.
|
|
SocketMark *uint32 `protobuf:"varint,43,opt,name=socket_mark,json=socketMark,proto3,oneof" json:"socket_mark,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FlagsInConfig) Reset() {
|
|
*x = FlagsInConfig{}
|
|
mi := &file_common_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FlagsInConfig) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FlagsInConfig) ProtoMessage() {}
|
|
|
|
func (x *FlagsInConfig) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FlagsInConfig.ProtoReflect.Descriptor instead.
|
|
func (*FlagsInConfig) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDefaultProtocol() string {
|
|
if x != nil {
|
|
return x.DefaultProtocol
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDevName() string {
|
|
if x != nil {
|
|
return x.DevName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableEncryption() bool {
|
|
if x != nil {
|
|
return x.EnableEncryption
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableIpv6() bool {
|
|
if x != nil {
|
|
return x.EnableIpv6
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetMtu() uint32 {
|
|
if x != nil {
|
|
return x.Mtu
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetLatencyFirst() bool {
|
|
if x != nil {
|
|
return x.LatencyFirst
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableExitNode() bool {
|
|
if x != nil {
|
|
return x.EnableExitNode
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetNoTun() bool {
|
|
if x != nil {
|
|
return x.NoTun
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetUseSmoltcp() bool {
|
|
if x != nil {
|
|
return x.UseSmoltcp
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetRelayNetworkWhitelist() string {
|
|
if x != nil {
|
|
return x.RelayNetworkWhitelist
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableP2P() bool {
|
|
if x != nil {
|
|
return x.DisableP2P
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetRelayAllPeerRpc() bool {
|
|
if x != nil {
|
|
return x.RelayAllPeerRpc
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableUdpHolePunching() bool {
|
|
if x != nil {
|
|
return x.DisableUdpHolePunching
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetMultiThread() bool {
|
|
if x != nil {
|
|
return x.MultiThread
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDataCompressAlgo() CompressionAlgoPb {
|
|
if x != nil {
|
|
return x.DataCompressAlgo
|
|
}
|
|
return CompressionAlgoPb_Invalid
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetBindDevice() bool {
|
|
if x != nil {
|
|
return x.BindDevice
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableKcpProxy() bool {
|
|
if x != nil {
|
|
return x.EnableKcpProxy
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableKcpInput() bool {
|
|
if x != nil {
|
|
return x.DisableKcpInput
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableRelayKcp() bool {
|
|
if x != nil {
|
|
return x.DisableRelayKcp
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetProxyForwardBySystem() bool {
|
|
if x != nil {
|
|
return x.ProxyForwardBySystem
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetAcceptDns() bool {
|
|
if x != nil {
|
|
return x.AcceptDns
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetPrivateMode() bool {
|
|
if x != nil {
|
|
return x.PrivateMode
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableQuicProxy() bool {
|
|
if x != nil {
|
|
return x.EnableQuicProxy
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableQuicInput() bool {
|
|
if x != nil {
|
|
return x.DisableQuicInput
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableRelayQuic() bool {
|
|
if x != nil {
|
|
return x.DisableRelayQuic
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Deprecated: Marked as deprecated in common.proto.
|
|
func (x *FlagsInConfig) GetQuicListenPort() uint32 {
|
|
if x != nil {
|
|
return x.QuicListenPort
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetForeignRelayBpsLimit() uint64 {
|
|
if x != nil {
|
|
return x.ForeignRelayBpsLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetMultiThreadCount() uint32 {
|
|
if x != nil {
|
|
return x.MultiThreadCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableRelayForeignNetworkKcp() bool {
|
|
if x != nil {
|
|
return x.EnableRelayForeignNetworkKcp
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableRelayForeignNetworkQuic() bool {
|
|
if x != nil {
|
|
return x.EnableRelayForeignNetworkQuic
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEncryptionAlgorithm() string {
|
|
if x != nil {
|
|
return x.EncryptionAlgorithm
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableSymHolePunching() bool {
|
|
if x != nil {
|
|
return x.DisableSymHolePunching
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetTldDnsZone() string {
|
|
if x != nil {
|
|
return x.TldDnsZone
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetP2POnly() bool {
|
|
if x != nil {
|
|
return x.P2POnly
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableTcpHolePunching() bool {
|
|
if x != nil {
|
|
return x.DisableTcpHolePunching
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetLazyP2P() bool {
|
|
if x != nil {
|
|
return x.LazyP2P
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetNeedP2P() bool {
|
|
if x != nil {
|
|
return x.NeedP2P
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetInstanceRecvBpsLimit() uint64 {
|
|
if x != nil {
|
|
return x.InstanceRecvBpsLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableUpnp() bool {
|
|
if x != nil {
|
|
return x.DisableUpnp
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetDisableRelayData() bool {
|
|
if x != nil {
|
|
return x.DisableRelayData
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetEnableUdpBroadcastRelay() bool {
|
|
if x != nil {
|
|
return x.EnableUdpBroadcastRelay
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *FlagsInConfig) GetSocketMark() uint32 {
|
|
if x != nil && x.SocketMark != nil {
|
|
return *x.SocketMark
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RpcDescriptor struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// allow same service registered multiple times in different domain
|
|
DomainName string `protobuf:"bytes,1,opt,name=domain_name,json=domainName,proto3" json:"domain_name,omitempty"`
|
|
ProtoName string `protobuf:"bytes,2,opt,name=proto_name,json=protoName,proto3" json:"proto_name,omitempty"`
|
|
ServiceName string `protobuf:"bytes,3,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
|
|
MethodIndex uint32 `protobuf:"varint,4,opt,name=method_index,json=methodIndex,proto3" json:"method_index,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RpcDescriptor) Reset() {
|
|
*x = RpcDescriptor{}
|
|
mi := &file_common_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RpcDescriptor) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RpcDescriptor) ProtoMessage() {}
|
|
|
|
func (x *RpcDescriptor) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RpcDescriptor.ProtoReflect.Descriptor instead.
|
|
func (*RpcDescriptor) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *RpcDescriptor) GetDomainName() string {
|
|
if x != nil {
|
|
return x.DomainName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RpcDescriptor) GetProtoName() string {
|
|
if x != nil {
|
|
return x.ProtoName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RpcDescriptor) GetServiceName() string {
|
|
if x != nil {
|
|
return x.ServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RpcDescriptor) GetMethodIndex() uint32 {
|
|
if x != nil {
|
|
return x.MethodIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RpcRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Deprecated: Marked as deprecated in common.proto.
|
|
Descriptor_ *RpcDescriptor `protobuf:"bytes,1,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
|
|
Request []byte `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
|
|
TimeoutMs int32 `protobuf:"varint,3,opt,name=timeout_ms,json=timeoutMs,proto3" json:"timeout_ms,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RpcRequest) Reset() {
|
|
*x = RpcRequest{}
|
|
mi := &file_common_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RpcRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RpcRequest) ProtoMessage() {}
|
|
|
|
func (x *RpcRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RpcRequest.ProtoReflect.Descriptor instead.
|
|
func (*RpcRequest) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
// Deprecated: Marked as deprecated in common.proto.
|
|
func (x *RpcRequest) GetDescriptor_() *RpcDescriptor {
|
|
if x != nil {
|
|
return x.Descriptor_
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcRequest) GetRequest() []byte {
|
|
if x != nil {
|
|
return x.Request
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcRequest) GetTimeoutMs() int32 {
|
|
if x != nil {
|
|
return x.TimeoutMs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// One transport-neutral RPC invocation submitted through a direct ABI.
|
|
//
|
|
// full_method_name uses the protobuf reflection form:
|
|
// "<package>.<service>.<method>" or "<service>.<method>" for an empty package.
|
|
type DirectRpcRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FullMethodName string `protobuf:"bytes,1,opt,name=full_method_name,json=fullMethodName,proto3" json:"full_method_name,omitempty"`
|
|
Request []byte `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
|
|
TimeoutMs *uint64 `protobuf:"varint,3,opt,name=timeout_ms,json=timeoutMs,proto3,oneof" json:"timeout_ms,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *DirectRpcRequest) Reset() {
|
|
*x = DirectRpcRequest{}
|
|
mi := &file_common_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *DirectRpcRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*DirectRpcRequest) ProtoMessage() {}
|
|
|
|
func (x *DirectRpcRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use DirectRpcRequest.ProtoReflect.Descriptor instead.
|
|
func (*DirectRpcRequest) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *DirectRpcRequest) GetFullMethodName() string {
|
|
if x != nil {
|
|
return x.FullMethodName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *DirectRpcRequest) GetRequest() []byte {
|
|
if x != nil {
|
|
return x.Request
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *DirectRpcRequest) GetTimeoutMs() uint64 {
|
|
if x != nil && x.TimeoutMs != nil {
|
|
return *x.TimeoutMs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// One process-level management call delegated by the WASI WebClient to its host.
|
|
type HostManagementRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Rpc *DirectRpcRequest `protobuf:"bytes,1,opt,name=rpc,proto3" json:"rpc,omitempty"`
|
|
PreparedConfig *string `protobuf:"bytes,2,opt,name=prepared_config,json=preparedConfig,proto3,oneof" json:"prepared_config,omitempty"`
|
|
// Runtime identity paired with prepared_config without rewriting rpc.request.
|
|
PreparedInstanceId *UUID `protobuf:"bytes,3,opt,name=prepared_instance_id,json=preparedInstanceId,proto3" json:"prepared_instance_id,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *HostManagementRequest) Reset() {
|
|
*x = HostManagementRequest{}
|
|
mi := &file_common_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *HostManagementRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*HostManagementRequest) ProtoMessage() {}
|
|
|
|
func (x *HostManagementRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use HostManagementRequest.ProtoReflect.Descriptor instead.
|
|
func (*HostManagementRequest) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *HostManagementRequest) GetRpc() *DirectRpcRequest {
|
|
if x != nil {
|
|
return x.Rpc
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *HostManagementRequest) GetPreparedConfig() string {
|
|
if x != nil && x.PreparedConfig != nil {
|
|
return *x.PreparedConfig
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HostManagementRequest) GetPreparedInstanceId() *UUID {
|
|
if x != nil {
|
|
return x.PreparedInstanceId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RpcResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Response []byte `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
|
|
Error *error1.Error `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
|
|
RuntimeUs uint64 `protobuf:"varint,3,opt,name=runtime_us,json=runtimeUs,proto3" json:"runtime_us,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RpcResponse) Reset() {
|
|
*x = RpcResponse{}
|
|
mi := &file_common_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RpcResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RpcResponse) ProtoMessage() {}
|
|
|
|
func (x *RpcResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RpcResponse.ProtoReflect.Descriptor instead.
|
|
func (*RpcResponse) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{5}
|
|
}
|
|
|
|
func (x *RpcResponse) GetResponse() []byte {
|
|
if x != nil {
|
|
return x.Response
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcResponse) GetError() *error1.Error {
|
|
if x != nil {
|
|
return x.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcResponse) GetRuntimeUs() uint64 {
|
|
if x != nil {
|
|
return x.RuntimeUs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RpcCompressionInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// use this to compress the content
|
|
Algo CompressionAlgoPb `protobuf:"varint,1,opt,name=algo,proto3,enum=common.CompressionAlgoPb" json:"algo,omitempty"`
|
|
// tell the peer which compression algo is used to compress the next
|
|
// response/request
|
|
AcceptedAlgo CompressionAlgoPb `protobuf:"varint,2,opt,name=accepted_algo,json=acceptedAlgo,proto3,enum=common.CompressionAlgoPb" json:"accepted_algo,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RpcCompressionInfo) Reset() {
|
|
*x = RpcCompressionInfo{}
|
|
mi := &file_common_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RpcCompressionInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RpcCompressionInfo) ProtoMessage() {}
|
|
|
|
func (x *RpcCompressionInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RpcCompressionInfo.ProtoReflect.Descriptor instead.
|
|
func (*RpcCompressionInfo) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{6}
|
|
}
|
|
|
|
func (x *RpcCompressionInfo) GetAlgo() CompressionAlgoPb {
|
|
if x != nil {
|
|
return x.Algo
|
|
}
|
|
return CompressionAlgoPb_Invalid
|
|
}
|
|
|
|
func (x *RpcCompressionInfo) GetAcceptedAlgo() CompressionAlgoPb {
|
|
if x != nil {
|
|
return x.AcceptedAlgo
|
|
}
|
|
return CompressionAlgoPb_Invalid
|
|
}
|
|
|
|
type RpcPacket struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FromPeer uint32 `protobuf:"varint,1,opt,name=from_peer,json=fromPeer,proto3" json:"from_peer,omitempty"`
|
|
ToPeer uint32 `protobuf:"varint,2,opt,name=to_peer,json=toPeer,proto3" json:"to_peer,omitempty"`
|
|
TransactionId int64 `protobuf:"varint,3,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
|
|
Descriptor_ *RpcDescriptor `protobuf:"bytes,4,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
|
|
Body []byte `protobuf:"bytes,5,opt,name=body,proto3" json:"body,omitempty"`
|
|
IsRequest bool `protobuf:"varint,6,opt,name=is_request,json=isRequest,proto3" json:"is_request,omitempty"`
|
|
TotalPieces uint32 `protobuf:"varint,7,opt,name=total_pieces,json=totalPieces,proto3" json:"total_pieces,omitempty"`
|
|
PieceIdx uint32 `protobuf:"varint,8,opt,name=piece_idx,json=pieceIdx,proto3" json:"piece_idx,omitempty"`
|
|
TraceId int32 `protobuf:"varint,9,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
|
|
CompressionInfo *RpcCompressionInfo `protobuf:"bytes,10,opt,name=compression_info,json=compressionInfo,proto3" json:"compression_info,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RpcPacket) Reset() {
|
|
*x = RpcPacket{}
|
|
mi := &file_common_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RpcPacket) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RpcPacket) ProtoMessage() {}
|
|
|
|
func (x *RpcPacket) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RpcPacket.ProtoReflect.Descriptor instead.
|
|
func (*RpcPacket) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{7}
|
|
}
|
|
|
|
func (x *RpcPacket) GetFromPeer() uint32 {
|
|
if x != nil {
|
|
return x.FromPeer
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetToPeer() uint32 {
|
|
if x != nil {
|
|
return x.ToPeer
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetTransactionId() int64 {
|
|
if x != nil {
|
|
return x.TransactionId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetDescriptor_() *RpcDescriptor {
|
|
if x != nil {
|
|
return x.Descriptor_
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcPacket) GetBody() []byte {
|
|
if x != nil {
|
|
return x.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RpcPacket) GetIsRequest() bool {
|
|
if x != nil {
|
|
return x.IsRequest
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RpcPacket) GetTotalPieces() uint32 {
|
|
if x != nil {
|
|
return x.TotalPieces
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetPieceIdx() uint32 {
|
|
if x != nil {
|
|
return x.PieceIdx
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetTraceId() int32 {
|
|
if x != nil {
|
|
return x.TraceId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RpcPacket) GetCompressionInfo() *RpcCompressionInfo {
|
|
if x != nil {
|
|
return x.CompressionInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Void struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Void) Reset() {
|
|
*x = Void{}
|
|
mi := &file_common_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Void) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Void) ProtoMessage() {}
|
|
|
|
func (x *Void) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Void.ProtoReflect.Descriptor instead.
|
|
func (*Void) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{8}
|
|
}
|
|
|
|
type UUID struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Part1 uint32 `protobuf:"varint,1,opt,name=part1,proto3" json:"part1,omitempty"`
|
|
Part2 uint32 `protobuf:"varint,2,opt,name=part2,proto3" json:"part2,omitempty"`
|
|
Part3 uint32 `protobuf:"varint,3,opt,name=part3,proto3" json:"part3,omitempty"`
|
|
Part4 uint32 `protobuf:"varint,4,opt,name=part4,proto3" json:"part4,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *UUID) Reset() {
|
|
*x = UUID{}
|
|
mi := &file_common_proto_msgTypes[9]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *UUID) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*UUID) ProtoMessage() {}
|
|
|
|
func (x *UUID) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[9]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use UUID.ProtoReflect.Descriptor instead.
|
|
func (*UUID) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{9}
|
|
}
|
|
|
|
func (x *UUID) GetPart1() uint32 {
|
|
if x != nil {
|
|
return x.Part1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *UUID) GetPart2() uint32 {
|
|
if x != nil {
|
|
return x.Part2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *UUID) GetPart3() uint32 {
|
|
if x != nil {
|
|
return x.Part3
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *UUID) GetPart4() uint32 {
|
|
if x != nil {
|
|
return x.Part4
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Ipv4Addr struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Addr uint32 `protobuf:"varint,1,opt,name=addr,proto3" json:"addr,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Ipv4Addr) Reset() {
|
|
*x = Ipv4Addr{}
|
|
mi := &file_common_proto_msgTypes[10]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Ipv4Addr) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Ipv4Addr) ProtoMessage() {}
|
|
|
|
func (x *Ipv4Addr) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[10]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Ipv4Addr.ProtoReflect.Descriptor instead.
|
|
func (*Ipv4Addr) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{10}
|
|
}
|
|
|
|
func (x *Ipv4Addr) GetAddr() uint32 {
|
|
if x != nil {
|
|
return x.Addr
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Ipv6Addr struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Part1 uint32 `protobuf:"varint,1,opt,name=part1,proto3" json:"part1,omitempty"`
|
|
Part2 uint32 `protobuf:"varint,2,opt,name=part2,proto3" json:"part2,omitempty"`
|
|
Part3 uint32 `protobuf:"varint,3,opt,name=part3,proto3" json:"part3,omitempty"`
|
|
Part4 uint32 `protobuf:"varint,4,opt,name=part4,proto3" json:"part4,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Ipv6Addr) Reset() {
|
|
*x = Ipv6Addr{}
|
|
mi := &file_common_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Ipv6Addr) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Ipv6Addr) ProtoMessage() {}
|
|
|
|
func (x *Ipv6Addr) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Ipv6Addr.ProtoReflect.Descriptor instead.
|
|
func (*Ipv6Addr) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{11}
|
|
}
|
|
|
|
func (x *Ipv6Addr) GetPart1() uint32 {
|
|
if x != nil {
|
|
return x.Part1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Ipv6Addr) GetPart2() uint32 {
|
|
if x != nil {
|
|
return x.Part2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Ipv6Addr) GetPart3() uint32 {
|
|
if x != nil {
|
|
return x.Part3
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Ipv6Addr) GetPart4() uint32 {
|
|
if x != nil {
|
|
return x.Part4
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type IpAddr struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Types that are valid to be assigned to Ip:
|
|
//
|
|
// *IpAddr_Ipv4
|
|
// *IpAddr_Ipv6
|
|
Ip isIpAddr_Ip `protobuf_oneof:"ip"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *IpAddr) Reset() {
|
|
*x = IpAddr{}
|
|
mi := &file_common_proto_msgTypes[12]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *IpAddr) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*IpAddr) ProtoMessage() {}
|
|
|
|
func (x *IpAddr) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[12]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use IpAddr.ProtoReflect.Descriptor instead.
|
|
func (*IpAddr) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{12}
|
|
}
|
|
|
|
func (x *IpAddr) GetIp() isIpAddr_Ip {
|
|
if x != nil {
|
|
return x.Ip
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *IpAddr) GetIpv4() *Ipv4Addr {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*IpAddr_Ipv4); ok {
|
|
return x.Ipv4
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *IpAddr) GetIpv6() *Ipv6Addr {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*IpAddr_Ipv6); ok {
|
|
return x.Ipv6
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isIpAddr_Ip interface {
|
|
isIpAddr_Ip()
|
|
}
|
|
|
|
type IpAddr_Ipv4 struct {
|
|
Ipv4 *Ipv4Addr `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
|
|
}
|
|
|
|
type IpAddr_Ipv6 struct {
|
|
Ipv6 *Ipv6Addr `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
|
|
}
|
|
|
|
func (*IpAddr_Ipv4) isIpAddr_Ip() {}
|
|
|
|
func (*IpAddr_Ipv6) isIpAddr_Ip() {}
|
|
|
|
type Ipv4Inet struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Address *Ipv4Addr `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
|
|
NetworkLength uint32 `protobuf:"varint,2,opt,name=network_length,json=networkLength,proto3" json:"network_length,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Ipv4Inet) Reset() {
|
|
*x = Ipv4Inet{}
|
|
mi := &file_common_proto_msgTypes[13]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Ipv4Inet) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Ipv4Inet) ProtoMessage() {}
|
|
|
|
func (x *Ipv4Inet) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[13]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Ipv4Inet.ProtoReflect.Descriptor instead.
|
|
func (*Ipv4Inet) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{13}
|
|
}
|
|
|
|
func (x *Ipv4Inet) GetAddress() *Ipv4Addr {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Ipv4Inet) GetNetworkLength() uint32 {
|
|
if x != nil {
|
|
return x.NetworkLength
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Ipv6Inet struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Address *Ipv6Addr `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
|
|
NetworkLength uint32 `protobuf:"varint,2,opt,name=network_length,json=networkLength,proto3" json:"network_length,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Ipv6Inet) Reset() {
|
|
*x = Ipv6Inet{}
|
|
mi := &file_common_proto_msgTypes[14]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Ipv6Inet) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Ipv6Inet) ProtoMessage() {}
|
|
|
|
func (x *Ipv6Inet) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[14]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Ipv6Inet.ProtoReflect.Descriptor instead.
|
|
func (*Ipv6Inet) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{14}
|
|
}
|
|
|
|
func (x *Ipv6Inet) GetAddress() *Ipv6Addr {
|
|
if x != nil {
|
|
return x.Address
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Ipv6Inet) GetNetworkLength() uint32 {
|
|
if x != nil {
|
|
return x.NetworkLength
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type IpInet struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Types that are valid to be assigned to Ip:
|
|
//
|
|
// *IpInet_Ipv4
|
|
// *IpInet_Ipv6
|
|
Ip isIpInet_Ip `protobuf_oneof:"ip"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *IpInet) Reset() {
|
|
*x = IpInet{}
|
|
mi := &file_common_proto_msgTypes[15]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *IpInet) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*IpInet) ProtoMessage() {}
|
|
|
|
func (x *IpInet) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[15]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use IpInet.ProtoReflect.Descriptor instead.
|
|
func (*IpInet) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{15}
|
|
}
|
|
|
|
func (x *IpInet) GetIp() isIpInet_Ip {
|
|
if x != nil {
|
|
return x.Ip
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *IpInet) GetIpv4() *Ipv4Inet {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*IpInet_Ipv4); ok {
|
|
return x.Ipv4
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *IpInet) GetIpv6() *Ipv6Inet {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*IpInet_Ipv6); ok {
|
|
return x.Ipv6
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isIpInet_Ip interface {
|
|
isIpInet_Ip()
|
|
}
|
|
|
|
type IpInet_Ipv4 struct {
|
|
Ipv4 *Ipv4Inet `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
|
|
}
|
|
|
|
type IpInet_Ipv6 struct {
|
|
Ipv6 *Ipv6Inet `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
|
|
}
|
|
|
|
func (*IpInet_Ipv4) isIpInet_Ip() {}
|
|
|
|
func (*IpInet_Ipv6) isIpInet_Ip() {}
|
|
|
|
type Url struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Url) Reset() {
|
|
*x = Url{}
|
|
mi := &file_common_proto_msgTypes[16]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Url) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Url) ProtoMessage() {}
|
|
|
|
func (x *Url) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[16]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Url.ProtoReflect.Descriptor instead.
|
|
func (*Url) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{16}
|
|
}
|
|
|
|
func (x *Url) GetUrl() string {
|
|
if x != nil {
|
|
return x.Url
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type SocketAddr struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Types that are valid to be assigned to Ip:
|
|
//
|
|
// *SocketAddr_Ipv4
|
|
// *SocketAddr_Ipv6
|
|
Ip isSocketAddr_Ip `protobuf_oneof:"ip"`
|
|
Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SocketAddr) Reset() {
|
|
*x = SocketAddr{}
|
|
mi := &file_common_proto_msgTypes[17]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SocketAddr) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SocketAddr) ProtoMessage() {}
|
|
|
|
func (x *SocketAddr) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[17]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SocketAddr.ProtoReflect.Descriptor instead.
|
|
func (*SocketAddr) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{17}
|
|
}
|
|
|
|
func (x *SocketAddr) GetIp() isSocketAddr_Ip {
|
|
if x != nil {
|
|
return x.Ip
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SocketAddr) GetIpv4() *Ipv4Addr {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*SocketAddr_Ipv4); ok {
|
|
return x.Ipv4
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SocketAddr) GetIpv6() *Ipv6Addr {
|
|
if x != nil {
|
|
if x, ok := x.Ip.(*SocketAddr_Ipv6); ok {
|
|
return x.Ipv6
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SocketAddr) GetPort() uint32 {
|
|
if x != nil {
|
|
return x.Port
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type isSocketAddr_Ip interface {
|
|
isSocketAddr_Ip()
|
|
}
|
|
|
|
type SocketAddr_Ipv4 struct {
|
|
Ipv4 *Ipv4Addr `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
|
|
}
|
|
|
|
type SocketAddr_Ipv6 struct {
|
|
Ipv6 *Ipv6Addr `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
|
|
}
|
|
|
|
func (*SocketAddr_Ipv4) isSocketAddr_Ip() {}
|
|
|
|
func (*SocketAddr_Ipv6) isSocketAddr_Ip() {}
|
|
|
|
type TunnelInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
TunnelType string `protobuf:"bytes,1,opt,name=tunnel_type,json=tunnelType,proto3" json:"tunnel_type,omitempty"`
|
|
LocalAddr *Url `protobuf:"bytes,2,opt,name=local_addr,json=localAddr,proto3" json:"local_addr,omitempty"`
|
|
RemoteAddr *Url `protobuf:"bytes,3,opt,name=remote_addr,json=remoteAddr,proto3" json:"remote_addr,omitempty"`
|
|
ResolvedRemoteAddr *Url `protobuf:"bytes,4,opt,name=resolved_remote_addr,json=resolvedRemoteAddr,proto3" json:"resolved_remote_addr,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TunnelInfo) Reset() {
|
|
*x = TunnelInfo{}
|
|
mi := &file_common_proto_msgTypes[18]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TunnelInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TunnelInfo) ProtoMessage() {}
|
|
|
|
func (x *TunnelInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[18]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TunnelInfo.ProtoReflect.Descriptor instead.
|
|
func (*TunnelInfo) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{18}
|
|
}
|
|
|
|
func (x *TunnelInfo) GetTunnelType() string {
|
|
if x != nil {
|
|
return x.TunnelType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TunnelInfo) GetLocalAddr() *Url {
|
|
if x != nil {
|
|
return x.LocalAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TunnelInfo) GetRemoteAddr() *Url {
|
|
if x != nil {
|
|
return x.RemoteAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TunnelInfo) GetResolvedRemoteAddr() *Url {
|
|
if x != nil {
|
|
return x.ResolvedRemoteAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type StunInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
UdpNatType NatType `protobuf:"varint,1,opt,name=udp_nat_type,json=udpNatType,proto3,enum=common.NatType" json:"udp_nat_type,omitempty"`
|
|
TcpNatType NatType `protobuf:"varint,2,opt,name=tcp_nat_type,json=tcpNatType,proto3,enum=common.NatType" json:"tcp_nat_type,omitempty"`
|
|
LastUpdateTime int64 `protobuf:"varint,3,opt,name=last_update_time,json=lastUpdateTime,proto3" json:"last_update_time,omitempty"`
|
|
PublicIp []string `protobuf:"bytes,4,rep,name=public_ip,json=publicIp,proto3" json:"public_ip,omitempty"`
|
|
MinPort uint32 `protobuf:"varint,5,opt,name=min_port,json=minPort,proto3" json:"min_port,omitempty"`
|
|
MaxPort uint32 `protobuf:"varint,6,opt,name=max_port,json=maxPort,proto3" json:"max_port,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *StunInfo) Reset() {
|
|
*x = StunInfo{}
|
|
mi := &file_common_proto_msgTypes[19]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *StunInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*StunInfo) ProtoMessage() {}
|
|
|
|
func (x *StunInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[19]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use StunInfo.ProtoReflect.Descriptor instead.
|
|
func (*StunInfo) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{19}
|
|
}
|
|
|
|
func (x *StunInfo) GetUdpNatType() NatType {
|
|
if x != nil {
|
|
return x.UdpNatType
|
|
}
|
|
return NatType_Unknown
|
|
}
|
|
|
|
func (x *StunInfo) GetTcpNatType() NatType {
|
|
if x != nil {
|
|
return x.TcpNatType
|
|
}
|
|
return NatType_Unknown
|
|
}
|
|
|
|
func (x *StunInfo) GetLastUpdateTime() int64 {
|
|
if x != nil {
|
|
return x.LastUpdateTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *StunInfo) GetPublicIp() []string {
|
|
if x != nil {
|
|
return x.PublicIp
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *StunInfo) GetMinPort() uint32 {
|
|
if x != nil {
|
|
return x.MinPort
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *StunInfo) GetMaxPort() uint32 {
|
|
if x != nil {
|
|
return x.MaxPort
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type PeerFeatureFlag struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
IsPublicServer bool `protobuf:"varint,1,opt,name=is_public_server,json=isPublicServer,proto3" json:"is_public_server,omitempty"`
|
|
AvoidRelayData bool `protobuf:"varint,2,opt,name=avoid_relay_data,json=avoidRelayData,proto3" json:"avoid_relay_data,omitempty"`
|
|
KcpInput bool `protobuf:"varint,3,opt,name=kcp_input,json=kcpInput,proto3" json:"kcp_input,omitempty"`
|
|
NoRelayKcp bool `protobuf:"varint,4,opt,name=no_relay_kcp,json=noRelayKcp,proto3" json:"no_relay_kcp,omitempty"`
|
|
SupportConnListSync bool `protobuf:"varint,5,opt,name=support_conn_list_sync,json=supportConnListSync,proto3" json:"support_conn_list_sync,omitempty"`
|
|
QuicInput bool `protobuf:"varint,6,opt,name=quic_input,json=quicInput,proto3" json:"quic_input,omitempty"`
|
|
NoRelayQuic bool `protobuf:"varint,7,opt,name=no_relay_quic,json=noRelayQuic,proto3" json:"no_relay_quic,omitempty"`
|
|
IsCredentialPeer bool `protobuf:"varint,8,opt,name=is_credential_peer,json=isCredentialPeer,proto3" json:"is_credential_peer,omitempty"`
|
|
NeedP2P bool `protobuf:"varint,9,opt,name=need_p2p,json=needP2p,proto3" json:"need_p2p,omitempty"`
|
|
DisableP2P bool `protobuf:"varint,10,opt,name=disable_p2p,json=disableP2p,proto3" json:"disable_p2p,omitempty"`
|
|
Ipv6PublicAddrProvider bool `protobuf:"varint,11,opt,name=ipv6_public_addr_provider,json=ipv6PublicAddrProvider,proto3" json:"ipv6_public_addr_provider,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) Reset() {
|
|
*x = PeerFeatureFlag{}
|
|
mi := &file_common_proto_msgTypes[20]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PeerFeatureFlag) ProtoMessage() {}
|
|
|
|
func (x *PeerFeatureFlag) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[20]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PeerFeatureFlag.ProtoReflect.Descriptor instead.
|
|
func (*PeerFeatureFlag) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{20}
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetIsPublicServer() bool {
|
|
if x != nil {
|
|
return x.IsPublicServer
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetAvoidRelayData() bool {
|
|
if x != nil {
|
|
return x.AvoidRelayData
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetKcpInput() bool {
|
|
if x != nil {
|
|
return x.KcpInput
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetNoRelayKcp() bool {
|
|
if x != nil {
|
|
return x.NoRelayKcp
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetSupportConnListSync() bool {
|
|
if x != nil {
|
|
return x.SupportConnListSync
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetQuicInput() bool {
|
|
if x != nil {
|
|
return x.QuicInput
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetNoRelayQuic() bool {
|
|
if x != nil {
|
|
return x.NoRelayQuic
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetIsCredentialPeer() bool {
|
|
if x != nil {
|
|
return x.IsCredentialPeer
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetNeedP2P() bool {
|
|
if x != nil {
|
|
return x.NeedP2P
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetDisableP2P() bool {
|
|
if x != nil {
|
|
return x.DisableP2P
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *PeerFeatureFlag) GetIpv6PublicAddrProvider() bool {
|
|
if x != nil {
|
|
return x.Ipv6PublicAddrProvider
|
|
}
|
|
return false
|
|
}
|
|
|
|
type PortForwardConfigPb struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BindAddr *SocketAddr `protobuf:"bytes,1,opt,name=bind_addr,json=bindAddr,proto3" json:"bind_addr,omitempty"`
|
|
DstAddr *SocketAddr `protobuf:"bytes,2,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`
|
|
SocketType SocketType `protobuf:"varint,3,opt,name=socket_type,json=socketType,proto3,enum=common.SocketType" json:"socket_type,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PortForwardConfigPb) Reset() {
|
|
*x = PortForwardConfigPb{}
|
|
mi := &file_common_proto_msgTypes[21]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PortForwardConfigPb) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PortForwardConfigPb) ProtoMessage() {}
|
|
|
|
func (x *PortForwardConfigPb) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[21]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PortForwardConfigPb.ProtoReflect.Descriptor instead.
|
|
func (*PortForwardConfigPb) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{21}
|
|
}
|
|
|
|
func (x *PortForwardConfigPb) GetBindAddr() *SocketAddr {
|
|
if x != nil {
|
|
return x.BindAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PortForwardConfigPb) GetDstAddr() *SocketAddr {
|
|
if x != nil {
|
|
return x.DstAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PortForwardConfigPb) GetSocketType() SocketType {
|
|
if x != nil {
|
|
return x.SocketType
|
|
}
|
|
return SocketType_TCP
|
|
}
|
|
|
|
type ProxyDstInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
DstAddr *SocketAddr `protobuf:"bytes,1,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ProxyDstInfo) Reset() {
|
|
*x = ProxyDstInfo{}
|
|
mi := &file_common_proto_msgTypes[22]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ProxyDstInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ProxyDstInfo) ProtoMessage() {}
|
|
|
|
func (x *ProxyDstInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[22]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ProxyDstInfo.ProtoReflect.Descriptor instead.
|
|
func (*ProxyDstInfo) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{22}
|
|
}
|
|
|
|
func (x *ProxyDstInfo) GetDstAddr() *SocketAddr {
|
|
if x != nil {
|
|
return x.DstAddr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type LimiterConfig struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BurstRate *uint64 `protobuf:"varint,1,opt,name=burst_rate,json=burstRate,proto3,oneof" json:"burst_rate,omitempty"` // default 1 means no burst (capacity is same with bps)
|
|
Bps *uint64 `protobuf:"varint,2,opt,name=bps,proto3,oneof" json:"bps,omitempty"` // default 0 means no limit (unit is B/s)
|
|
FillDurationMs *uint64 `protobuf:"varint,3,opt,name=fill_duration_ms,json=fillDurationMs,proto3,oneof" json:"fill_duration_ms,omitempty"` // default 10ms, the period to fill the bucket
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LimiterConfig) Reset() {
|
|
*x = LimiterConfig{}
|
|
mi := &file_common_proto_msgTypes[23]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LimiterConfig) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LimiterConfig) ProtoMessage() {}
|
|
|
|
func (x *LimiterConfig) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[23]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LimiterConfig.ProtoReflect.Descriptor instead.
|
|
func (*LimiterConfig) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{23}
|
|
}
|
|
|
|
func (x *LimiterConfig) GetBurstRate() uint64 {
|
|
if x != nil && x.BurstRate != nil {
|
|
return *x.BurstRate
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LimiterConfig) GetBps() uint64 {
|
|
if x != nil && x.Bps != nil {
|
|
return *x.Bps
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LimiterConfig) GetFillDurationMs() uint64 {
|
|
if x != nil && x.FillDurationMs != nil {
|
|
return *x.FillDurationMs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type SecureModeConfig struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
|
|
// base64(X25519 private key), used by shared node to present a stable identity
|
|
LocalPrivateKey *string `protobuf:"bytes,2,opt,name=local_private_key,json=localPrivateKey,proto3,oneof" json:"local_private_key,omitempty"`
|
|
// base64(X25519 public key), required if local_private_key is set
|
|
LocalPublicKey *string `protobuf:"bytes,3,opt,name=local_public_key,json=localPublicKey,proto3,oneof" json:"local_public_key,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SecureModeConfig) Reset() {
|
|
*x = SecureModeConfig{}
|
|
mi := &file_common_proto_msgTypes[24]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SecureModeConfig) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SecureModeConfig) ProtoMessage() {}
|
|
|
|
func (x *SecureModeConfig) ProtoReflect() protoreflect.Message {
|
|
mi := &file_common_proto_msgTypes[24]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SecureModeConfig.ProtoReflect.Descriptor instead.
|
|
func (*SecureModeConfig) Descriptor() ([]byte, []int) {
|
|
return file_common_proto_rawDescGZIP(), []int{24}
|
|
}
|
|
|
|
func (x *SecureModeConfig) GetEnabled() bool {
|
|
if x != nil {
|
|
return x.Enabled
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *SecureModeConfig) GetLocalPrivateKey() string {
|
|
if x != nil && x.LocalPrivateKey != nil {
|
|
return *x.LocalPrivateKey
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SecureModeConfig) GetLocalPublicKey() string {
|
|
if x != nil && x.LocalPublicKey != nil {
|
|
return *x.LocalPublicKey
|
|
}
|
|
return ""
|
|
}
|
|
|
|
var File_common_proto protoreflect.FileDescriptor
|
|
|
|
const file_common_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\fcommon.proto\x12\x06common\x1a\verror.proto\"\xc9\x0e\n" +
|
|
"\rFlagsInConfig\x12)\n" +
|
|
"\x10default_protocol\x18\x01 \x01(\tR\x0fdefaultProtocol\x12\x19\n" +
|
|
"\bdev_name\x18\x02 \x01(\tR\adevName\x12+\n" +
|
|
"\x11enable_encryption\x18\x03 \x01(\bR\x10enableEncryption\x12\x1f\n" +
|
|
"\venable_ipv6\x18\x04 \x01(\bR\n" +
|
|
"enableIpv6\x12\x10\n" +
|
|
"\x03mtu\x18\x05 \x01(\rR\x03mtu\x12#\n" +
|
|
"\rlatency_first\x18\x06 \x01(\bR\flatencyFirst\x12(\n" +
|
|
"\x10enable_exit_node\x18\a \x01(\bR\x0eenableExitNode\x12\x15\n" +
|
|
"\x06no_tun\x18\b \x01(\bR\x05noTun\x12\x1f\n" +
|
|
"\vuse_smoltcp\x18\t \x01(\bR\n" +
|
|
"useSmoltcp\x126\n" +
|
|
"\x17relay_network_whitelist\x18\n" +
|
|
" \x01(\tR\x15relayNetworkWhitelist\x12\x1f\n" +
|
|
"\vdisable_p2p\x18\v \x01(\bR\n" +
|
|
"disableP2p\x12+\n" +
|
|
"\x12relay_all_peer_rpc\x18\f \x01(\bR\x0frelayAllPeerRpc\x129\n" +
|
|
"\x19disable_udp_hole_punching\x18\r \x01(\bR\x16disableUdpHolePunching\x12!\n" +
|
|
"\fmulti_thread\x18\x0f \x01(\bR\vmultiThread\x12G\n" +
|
|
"\x12data_compress_algo\x18\x10 \x01(\x0e2\x19.common.CompressionAlgoPbR\x10dataCompressAlgo\x12\x1f\n" +
|
|
"\vbind_device\x18\x11 \x01(\bR\n" +
|
|
"bindDevice\x12(\n" +
|
|
"\x10enable_kcp_proxy\x18\x12 \x01(\bR\x0eenableKcpProxy\x12*\n" +
|
|
"\x11disable_kcp_input\x18\x13 \x01(\bR\x0fdisableKcpInput\x12*\n" +
|
|
"\x11disable_relay_kcp\x18\x14 \x01(\bR\x0fdisableRelayKcp\x125\n" +
|
|
"\x17proxy_forward_by_system\x18\x15 \x01(\bR\x14proxyForwardBySystem\x12\x1d\n" +
|
|
"\n" +
|
|
"accept_dns\x18\x16 \x01(\bR\tacceptDns\x12!\n" +
|
|
"\fprivate_mode\x18\x17 \x01(\bR\vprivateMode\x12*\n" +
|
|
"\x11enable_quic_proxy\x18\x18 \x01(\bR\x0fenableQuicProxy\x12,\n" +
|
|
"\x12disable_quic_input\x18\x19 \x01(\bR\x10disableQuicInput\x12,\n" +
|
|
"\x12disable_relay_quic\x18# \x01(\bR\x10disableRelayQuic\x12,\n" +
|
|
"\x10quic_listen_port\x18! \x01(\rB\x02\x18\x01R\x0equicListenPort\x125\n" +
|
|
"\x17foreign_relay_bps_limit\x18\x1a \x01(\x04R\x14foreignRelayBpsLimit\x12,\n" +
|
|
"\x12multi_thread_count\x18\x1b \x01(\rR\x10multiThreadCount\x12F\n" +
|
|
" enable_relay_foreign_network_kcp\x18\x1c \x01(\bR\x1cenableRelayForeignNetworkKcp\x12H\n" +
|
|
"!enable_relay_foreign_network_quic\x18$ \x01(\bR\x1denableRelayForeignNetworkQuic\x121\n" +
|
|
"\x14encryption_algorithm\x18\x1d \x01(\tR\x13encryptionAlgorithm\x129\n" +
|
|
"\x19disable_sym_hole_punching\x18\x1e \x01(\bR\x16disableSymHolePunching\x12 \n" +
|
|
"\ftld_dns_zone\x18\x1f \x01(\tR\n" +
|
|
"tldDnsZone\x12\x19\n" +
|
|
"\bp2p_only\x18 \x01(\bR\ap2pOnly\x129\n" +
|
|
"\x19disable_tcp_hole_punching\x18\" \x01(\bR\x16disableTcpHolePunching\x12\x19\n" +
|
|
"\blazy_p2p\x18% \x01(\bR\alazyP2p\x12\x19\n" +
|
|
"\bneed_p2p\x18& \x01(\bR\aneedP2p\x125\n" +
|
|
"\x17instance_recv_bps_limit\x18' \x01(\x04R\x14instanceRecvBpsLimit\x12!\n" +
|
|
"\fdisable_upnp\x18( \x01(\bR\vdisableUpnp\x12,\n" +
|
|
"\x12disable_relay_data\x18) \x01(\bR\x10disableRelayData\x12;\n" +
|
|
"\x1aenable_udp_broadcast_relay\x18* \x01(\bR\x17enableUdpBroadcastRelay\x12$\n" +
|
|
"\vsocket_mark\x18+ \x01(\rH\x00R\n" +
|
|
"socketMark\x88\x01\x01B\x0e\n" +
|
|
"\f_socket_mark\"\x95\x01\n" +
|
|
"\rRpcDescriptor\x12\x1f\n" +
|
|
"\vdomain_name\x18\x01 \x01(\tR\n" +
|
|
"domainName\x12\x1d\n" +
|
|
"\n" +
|
|
"proto_name\x18\x02 \x01(\tR\tprotoName\x12!\n" +
|
|
"\fservice_name\x18\x03 \x01(\tR\vserviceName\x12!\n" +
|
|
"\fmethod_index\x18\x04 \x01(\rR\vmethodIndex\"\x80\x01\n" +
|
|
"\n" +
|
|
"RpcRequest\x129\n" +
|
|
"\n" +
|
|
"descriptor\x18\x01 \x01(\v2\x15.common.RpcDescriptorB\x02\x18\x01R\n" +
|
|
"descriptor\x12\x18\n" +
|
|
"\arequest\x18\x02 \x01(\fR\arequest\x12\x1d\n" +
|
|
"\n" +
|
|
"timeout_ms\x18\x03 \x01(\x05R\ttimeoutMs\"\x89\x01\n" +
|
|
"\x10DirectRpcRequest\x12(\n" +
|
|
"\x10full_method_name\x18\x01 \x01(\tR\x0efullMethodName\x12\x18\n" +
|
|
"\arequest\x18\x02 \x01(\fR\arequest\x12\"\n" +
|
|
"\n" +
|
|
"timeout_ms\x18\x03 \x01(\x04H\x00R\ttimeoutMs\x88\x01\x01B\r\n" +
|
|
"\v_timeout_ms\"\xc5\x01\n" +
|
|
"\x15HostManagementRequest\x12*\n" +
|
|
"\x03rpc\x18\x01 \x01(\v2\x18.common.DirectRpcRequestR\x03rpc\x12,\n" +
|
|
"\x0fprepared_config\x18\x02 \x01(\tH\x00R\x0epreparedConfig\x88\x01\x01\x12>\n" +
|
|
"\x14prepared_instance_id\x18\x03 \x01(\v2\f.common.UUIDR\x12preparedInstanceIdB\x12\n" +
|
|
"\x10_prepared_config\"l\n" +
|
|
"\vRpcResponse\x12\x1a\n" +
|
|
"\bresponse\x18\x01 \x01(\fR\bresponse\x12\"\n" +
|
|
"\x05error\x18\x02 \x01(\v2\f.error.ErrorR\x05error\x12\x1d\n" +
|
|
"\n" +
|
|
"runtime_us\x18\x03 \x01(\x04R\truntimeUs\"\x83\x01\n" +
|
|
"\x12RpcCompressionInfo\x12-\n" +
|
|
"\x04algo\x18\x01 \x01(\x0e2\x19.common.CompressionAlgoPbR\x04algo\x12>\n" +
|
|
"\raccepted_algo\x18\x02 \x01(\x0e2\x19.common.CompressionAlgoPbR\facceptedAlgo\"\xf4\x02\n" +
|
|
"\tRpcPacket\x12\x1b\n" +
|
|
"\tfrom_peer\x18\x01 \x01(\rR\bfromPeer\x12\x17\n" +
|
|
"\ato_peer\x18\x02 \x01(\rR\x06toPeer\x12%\n" +
|
|
"\x0etransaction_id\x18\x03 \x01(\x03R\rtransactionId\x125\n" +
|
|
"\n" +
|
|
"descriptor\x18\x04 \x01(\v2\x15.common.RpcDescriptorR\n" +
|
|
"descriptor\x12\x12\n" +
|
|
"\x04body\x18\x05 \x01(\fR\x04body\x12\x1d\n" +
|
|
"\n" +
|
|
"is_request\x18\x06 \x01(\bR\tisRequest\x12!\n" +
|
|
"\ftotal_pieces\x18\a \x01(\rR\vtotalPieces\x12\x1b\n" +
|
|
"\tpiece_idx\x18\b \x01(\rR\bpieceIdx\x12\x19\n" +
|
|
"\btrace_id\x18\t \x01(\x05R\atraceId\x12E\n" +
|
|
"\x10compression_info\x18\n" +
|
|
" \x01(\v2\x1a.common.RpcCompressionInfoR\x0fcompressionInfo\"\x06\n" +
|
|
"\x04Void\"^\n" +
|
|
"\x04UUID\x12\x14\n" +
|
|
"\x05part1\x18\x01 \x01(\rR\x05part1\x12\x14\n" +
|
|
"\x05part2\x18\x02 \x01(\rR\x05part2\x12\x14\n" +
|
|
"\x05part3\x18\x03 \x01(\rR\x05part3\x12\x14\n" +
|
|
"\x05part4\x18\x04 \x01(\rR\x05part4\"\x1e\n" +
|
|
"\bIpv4Addr\x12\x12\n" +
|
|
"\x04addr\x18\x01 \x01(\rR\x04addr\"b\n" +
|
|
"\bIpv6Addr\x12\x14\n" +
|
|
"\x05part1\x18\x01 \x01(\rR\x05part1\x12\x14\n" +
|
|
"\x05part2\x18\x02 \x01(\rR\x05part2\x12\x14\n" +
|
|
"\x05part3\x18\x03 \x01(\rR\x05part3\x12\x14\n" +
|
|
"\x05part4\x18\x04 \x01(\rR\x05part4\"^\n" +
|
|
"\x06IpAddr\x12&\n" +
|
|
"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4AddrH\x00R\x04ipv4\x12&\n" +
|
|
"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6AddrH\x00R\x04ipv6B\x04\n" +
|
|
"\x02ip\"]\n" +
|
|
"\bIpv4Inet\x12*\n" +
|
|
"\aaddress\x18\x01 \x01(\v2\x10.common.Ipv4AddrR\aaddress\x12%\n" +
|
|
"\x0enetwork_length\x18\x02 \x01(\rR\rnetworkLength\"]\n" +
|
|
"\bIpv6Inet\x12*\n" +
|
|
"\aaddress\x18\x01 \x01(\v2\x10.common.Ipv6AddrR\aaddress\x12%\n" +
|
|
"\x0enetwork_length\x18\x02 \x01(\rR\rnetworkLength\"^\n" +
|
|
"\x06IpInet\x12&\n" +
|
|
"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4InetH\x00R\x04ipv4\x12&\n" +
|
|
"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6InetH\x00R\x04ipv6B\x04\n" +
|
|
"\x02ip\"\x17\n" +
|
|
"\x03Url\x12\x10\n" +
|
|
"\x03url\x18\x01 \x01(\tR\x03url\"v\n" +
|
|
"\n" +
|
|
"SocketAddr\x12&\n" +
|
|
"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4AddrH\x00R\x04ipv4\x12&\n" +
|
|
"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6AddrH\x00R\x04ipv6\x12\x12\n" +
|
|
"\x04port\x18\x03 \x01(\rR\x04portB\x04\n" +
|
|
"\x02ip\"\xc6\x01\n" +
|
|
"\n" +
|
|
"TunnelInfo\x12\x1f\n" +
|
|
"\vtunnel_type\x18\x01 \x01(\tR\n" +
|
|
"tunnelType\x12*\n" +
|
|
"\n" +
|
|
"local_addr\x18\x02 \x01(\v2\v.common.UrlR\tlocalAddr\x12,\n" +
|
|
"\vremote_addr\x18\x03 \x01(\v2\v.common.UrlR\n" +
|
|
"remoteAddr\x12=\n" +
|
|
"\x14resolved_remote_addr\x18\x04 \x01(\v2\v.common.UrlR\x12resolvedRemoteAddr\"\xed\x01\n" +
|
|
"\bStunInfo\x121\n" +
|
|
"\fudp_nat_type\x18\x01 \x01(\x0e2\x0f.common.NatTypeR\n" +
|
|
"udpNatType\x121\n" +
|
|
"\ftcp_nat_type\x18\x02 \x01(\x0e2\x0f.common.NatTypeR\n" +
|
|
"tcpNatType\x12(\n" +
|
|
"\x10last_update_time\x18\x03 \x01(\x03R\x0elastUpdateTime\x12\x1b\n" +
|
|
"\tpublic_ip\x18\x04 \x03(\tR\bpublicIp\x12\x19\n" +
|
|
"\bmin_port\x18\x05 \x01(\rR\aminPort\x12\x19\n" +
|
|
"\bmax_port\x18\x06 \x01(\rR\amaxPort\"\xc1\x03\n" +
|
|
"\x0fPeerFeatureFlag\x12(\n" +
|
|
"\x10is_public_server\x18\x01 \x01(\bR\x0eisPublicServer\x12(\n" +
|
|
"\x10avoid_relay_data\x18\x02 \x01(\bR\x0eavoidRelayData\x12\x1b\n" +
|
|
"\tkcp_input\x18\x03 \x01(\bR\bkcpInput\x12 \n" +
|
|
"\fno_relay_kcp\x18\x04 \x01(\bR\n" +
|
|
"noRelayKcp\x123\n" +
|
|
"\x16support_conn_list_sync\x18\x05 \x01(\bR\x13supportConnListSync\x12\x1d\n" +
|
|
"\n" +
|
|
"quic_input\x18\x06 \x01(\bR\tquicInput\x12\"\n" +
|
|
"\rno_relay_quic\x18\a \x01(\bR\vnoRelayQuic\x12,\n" +
|
|
"\x12is_credential_peer\x18\b \x01(\bR\x10isCredentialPeer\x12\x19\n" +
|
|
"\bneed_p2p\x18\t \x01(\bR\aneedP2p\x12\x1f\n" +
|
|
"\vdisable_p2p\x18\n" +
|
|
" \x01(\bR\n" +
|
|
"disableP2p\x129\n" +
|
|
"\x19ipv6_public_addr_provider\x18\v \x01(\bR\x16ipv6PublicAddrProvider\"\xaa\x01\n" +
|
|
"\x13PortForwardConfigPb\x12/\n" +
|
|
"\tbind_addr\x18\x01 \x01(\v2\x12.common.SocketAddrR\bbindAddr\x12-\n" +
|
|
"\bdst_addr\x18\x02 \x01(\v2\x12.common.SocketAddrR\adstAddr\x123\n" +
|
|
"\vsocket_type\x18\x03 \x01(\x0e2\x12.common.SocketTypeR\n" +
|
|
"socketType\"=\n" +
|
|
"\fProxyDstInfo\x12-\n" +
|
|
"\bdst_addr\x18\x01 \x01(\v2\x12.common.SocketAddrR\adstAddr\"\xa5\x01\n" +
|
|
"\rLimiterConfig\x12\"\n" +
|
|
"\n" +
|
|
"burst_rate\x18\x01 \x01(\x04H\x00R\tburstRate\x88\x01\x01\x12\x15\n" +
|
|
"\x03bps\x18\x02 \x01(\x04H\x01R\x03bps\x88\x01\x01\x12-\n" +
|
|
"\x10fill_duration_ms\x18\x03 \x01(\x04H\x02R\x0efillDurationMs\x88\x01\x01B\r\n" +
|
|
"\v_burst_rateB\x06\n" +
|
|
"\x04_bpsB\x13\n" +
|
|
"\x11_fill_duration_ms\"\xb7\x01\n" +
|
|
"\x10SecureModeConfig\x12\x18\n" +
|
|
"\aenabled\x18\x01 \x01(\bR\aenabled\x12/\n" +
|
|
"\x11local_private_key\x18\x02 \x01(\tH\x00R\x0flocalPrivateKey\x88\x01\x01\x12-\n" +
|
|
"\x10local_public_key\x18\x03 \x01(\tH\x01R\x0elocalPublicKey\x88\x01\x01B\x14\n" +
|
|
"\x12_local_private_keyB\x13\n" +
|
|
"\x11_local_public_key*4\n" +
|
|
"\x11CompressionAlgoPb\x12\v\n" +
|
|
"\aInvalid\x10\x00\x12\b\n" +
|
|
"\x04None\x10\x01\x12\b\n" +
|
|
"\x04Zstd\x10\x02*\xb4\x01\n" +
|
|
"\aNatType\x12\v\n" +
|
|
"\aUnknown\x10\x00\x12\x10\n" +
|
|
"\fOpenInternet\x10\x01\x12\t\n" +
|
|
"\x05NoPAT\x10\x02\x12\f\n" +
|
|
"\bFullCone\x10\x03\x12\x0e\n" +
|
|
"\n" +
|
|
"Restricted\x10\x04\x12\x12\n" +
|
|
"\x0ePortRestricted\x10\x05\x12\r\n" +
|
|
"\tSymmetric\x10\x06\x12\x12\n" +
|
|
"\x0eSymUdpFirewall\x10\a\x12\x14\n" +
|
|
"\x10SymmetricEasyInc\x10\b\x12\x14\n" +
|
|
"\x10SymmetricEasyDec\x10\t*\x1e\n" +
|
|
"\n" +
|
|
"SocketType\x12\a\n" +
|
|
"\x03TCP\x10\x00\x12\a\n" +
|
|
"\x03UDP\x10\x01b\x06proto3"
|
|
|
|
var (
|
|
file_common_proto_rawDescOnce sync.Once
|
|
file_common_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_common_proto_rawDescGZIP() []byte {
|
|
file_common_proto_rawDescOnce.Do(func() {
|
|
file_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_common_proto_rawDesc), len(file_common_proto_rawDesc)))
|
|
})
|
|
return file_common_proto_rawDescData
|
|
}
|
|
|
|
var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
|
|
var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 25)
|
|
var file_common_proto_goTypes = []any{
|
|
(CompressionAlgoPb)(0), // 0: common.CompressionAlgoPb
|
|
(NatType)(0), // 1: common.NatType
|
|
(SocketType)(0), // 2: common.SocketType
|
|
(*FlagsInConfig)(nil), // 3: common.FlagsInConfig
|
|
(*RpcDescriptor)(nil), // 4: common.RpcDescriptor
|
|
(*RpcRequest)(nil), // 5: common.RpcRequest
|
|
(*DirectRpcRequest)(nil), // 6: common.DirectRpcRequest
|
|
(*HostManagementRequest)(nil), // 7: common.HostManagementRequest
|
|
(*RpcResponse)(nil), // 8: common.RpcResponse
|
|
(*RpcCompressionInfo)(nil), // 9: common.RpcCompressionInfo
|
|
(*RpcPacket)(nil), // 10: common.RpcPacket
|
|
(*Void)(nil), // 11: common.Void
|
|
(*UUID)(nil), // 12: common.UUID
|
|
(*Ipv4Addr)(nil), // 13: common.Ipv4Addr
|
|
(*Ipv6Addr)(nil), // 14: common.Ipv6Addr
|
|
(*IpAddr)(nil), // 15: common.IpAddr
|
|
(*Ipv4Inet)(nil), // 16: common.Ipv4Inet
|
|
(*Ipv6Inet)(nil), // 17: common.Ipv6Inet
|
|
(*IpInet)(nil), // 18: common.IpInet
|
|
(*Url)(nil), // 19: common.Url
|
|
(*SocketAddr)(nil), // 20: common.SocketAddr
|
|
(*TunnelInfo)(nil), // 21: common.TunnelInfo
|
|
(*StunInfo)(nil), // 22: common.StunInfo
|
|
(*PeerFeatureFlag)(nil), // 23: common.PeerFeatureFlag
|
|
(*PortForwardConfigPb)(nil), // 24: common.PortForwardConfigPb
|
|
(*ProxyDstInfo)(nil), // 25: common.ProxyDstInfo
|
|
(*LimiterConfig)(nil), // 26: common.LimiterConfig
|
|
(*SecureModeConfig)(nil), // 27: common.SecureModeConfig
|
|
(*error1.Error)(nil), // 28: error.Error
|
|
}
|
|
var file_common_proto_depIdxs = []int32{
|
|
0, // 0: common.FlagsInConfig.data_compress_algo:type_name -> common.CompressionAlgoPb
|
|
4, // 1: common.RpcRequest.descriptor:type_name -> common.RpcDescriptor
|
|
6, // 2: common.HostManagementRequest.rpc:type_name -> common.DirectRpcRequest
|
|
12, // 3: common.HostManagementRequest.prepared_instance_id:type_name -> common.UUID
|
|
28, // 4: common.RpcResponse.error:type_name -> error.Error
|
|
0, // 5: common.RpcCompressionInfo.algo:type_name -> common.CompressionAlgoPb
|
|
0, // 6: common.RpcCompressionInfo.accepted_algo:type_name -> common.CompressionAlgoPb
|
|
4, // 7: common.RpcPacket.descriptor:type_name -> common.RpcDescriptor
|
|
9, // 8: common.RpcPacket.compression_info:type_name -> common.RpcCompressionInfo
|
|
13, // 9: common.IpAddr.ipv4:type_name -> common.Ipv4Addr
|
|
14, // 10: common.IpAddr.ipv6:type_name -> common.Ipv6Addr
|
|
13, // 11: common.Ipv4Inet.address:type_name -> common.Ipv4Addr
|
|
14, // 12: common.Ipv6Inet.address:type_name -> common.Ipv6Addr
|
|
16, // 13: common.IpInet.ipv4:type_name -> common.Ipv4Inet
|
|
17, // 14: common.IpInet.ipv6:type_name -> common.Ipv6Inet
|
|
13, // 15: common.SocketAddr.ipv4:type_name -> common.Ipv4Addr
|
|
14, // 16: common.SocketAddr.ipv6:type_name -> common.Ipv6Addr
|
|
19, // 17: common.TunnelInfo.local_addr:type_name -> common.Url
|
|
19, // 18: common.TunnelInfo.remote_addr:type_name -> common.Url
|
|
19, // 19: common.TunnelInfo.resolved_remote_addr:type_name -> common.Url
|
|
1, // 20: common.StunInfo.udp_nat_type:type_name -> common.NatType
|
|
1, // 21: common.StunInfo.tcp_nat_type:type_name -> common.NatType
|
|
20, // 22: common.PortForwardConfigPb.bind_addr:type_name -> common.SocketAddr
|
|
20, // 23: common.PortForwardConfigPb.dst_addr:type_name -> common.SocketAddr
|
|
2, // 24: common.PortForwardConfigPb.socket_type:type_name -> common.SocketType
|
|
20, // 25: common.ProxyDstInfo.dst_addr:type_name -> common.SocketAddr
|
|
26, // [26:26] is the sub-list for method output_type
|
|
26, // [26:26] is the sub-list for method input_type
|
|
26, // [26:26] is the sub-list for extension type_name
|
|
26, // [26:26] is the sub-list for extension extendee
|
|
0, // [0:26] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_common_proto_init() }
|
|
func file_common_proto_init() {
|
|
if File_common_proto != nil {
|
|
return
|
|
}
|
|
file_common_proto_msgTypes[0].OneofWrappers = []any{}
|
|
file_common_proto_msgTypes[3].OneofWrappers = []any{}
|
|
file_common_proto_msgTypes[4].OneofWrappers = []any{}
|
|
file_common_proto_msgTypes[12].OneofWrappers = []any{
|
|
(*IpAddr_Ipv4)(nil),
|
|
(*IpAddr_Ipv6)(nil),
|
|
}
|
|
file_common_proto_msgTypes[15].OneofWrappers = []any{
|
|
(*IpInet_Ipv4)(nil),
|
|
(*IpInet_Ipv6)(nil),
|
|
}
|
|
file_common_proto_msgTypes[17].OneofWrappers = []any{
|
|
(*SocketAddr_Ipv4)(nil),
|
|
(*SocketAddr_Ipv6)(nil),
|
|
}
|
|
file_common_proto_msgTypes[23].OneofWrappers = []any{}
|
|
file_common_proto_msgTypes[24].OneofWrappers = []any{}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_common_proto_rawDesc), len(file_common_proto_rawDesc)),
|
|
NumEnums: 3,
|
|
NumMessages: 25,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_common_proto_goTypes,
|
|
DependencyIndexes: file_common_proto_depIdxs,
|
|
EnumInfos: file_common_proto_enumTypes,
|
|
MessageInfos: file_common_proto_msgTypes,
|
|
}.Build()
|
|
File_common_proto = out.File
|
|
file_common_proto_goTypes = nil
|
|
file_common_proto_depIdxs = nil
|
|
}
|