mirror of
https://github.com/EasyTier/EasyTier.git
synced 2026-10-12 15:26:14 -08:00
KKRainbow
f26c2aa147
* fix(core): normalize secure keys for TOML instances
* feat(wasi): run core behind Cloudflare WebSockets
Introduce the Cloudflare Worker WASI host that runs the EasyTier core
behind host-upgraded WebSockets.
- Worker package scaffold (wrangler Durable Object, build-wasm script,
vitest config) and core-runtime/websocket-host/data-plane runtime.
- WASI host WebSocket tunnel ABI (imports, adapter, runtime exports)
with bounded receive memory and bounded admission queue.
- Route host sockets through the portable listener plan
(HostListenerRegistration, listener queue, admission handler split).
- Build the WASM guest with the aes-gcm feature so secure peer
sessions have their cipher available.
* feat(wasi): add outbound browser client runtime
Add the outbound-only WASI runtime and browser connector host so
browser pages can dial EasyTier peers through WebSocket relays.
- CoreConnectivityMode::{OutboundOnly, InboundOnly} gating for
listeners, discovery, and direct connectivity modules.
- ExternalTunnelConnector plumbing through composite/connector_host/
manual for browser WebSocket dials.
- Browser/Node smoke entries with shared helpers
(smoke-shared.ts).
* feat(wasi): extend browser data plane with TCP half-close
Add the data-plane pieces the browser runtime needs for full-duplex
TCP streams behind host WebSockets:
- Guest TCP shutdown_write operation with submit/take ABI pair
(DATA_PLANE_ABI_VERSION 3 -> 4) and smoltcp half-close support.
- Worker data-plane TCP listener/stream plumbing and core-runtime
listener registration.
- Unit coverage for the new session ops and listener wiring.
* refactor(wasi): make host tunnel ABI transport-neutral
Replace WebSocket-specific core and WASI boundaries with a
message-oriented Host Tunnel interface. Keep WebSocket framing and text
rejection in the Cloudflare host while preserving payload boundaries,
ownership, cancellation, backpressure, and EOF behavior.
Rename feature flags and guest imports and exports to the Host Tunnel
ABI. Update both Worker profiles, tests, and architecture documentation.
* feat(web): split WASI hosts into publishable npm packages
Extract the shared JSPI, WASI, Host Tunnel, and data-plane runtime
into @easytier/runtime. Keep ABI handles, guest memory, TOML, and
operation broker details behind its adapter entry point.
Add typed, auto-starting @easytier/browser and factory-based
@easytier/cloudflare packages. Ship a matching Wasm profile with
each platform package and validate its capabilities before packing.
Persist Cloudflare instance identity in Durable Object storage,
centralize WebSocket admission ownership, and add package-level
coverage for the public interfaces.
* fix(web): make public packages portable
Embed the browser Wasm artifact in the published JavaScript entry
point. This lets esbuild consumers bundle the package without an asset
loader or a copied file.
Return Cloudflare's nominal Durable Object base type and document the
named subclass export required by generated Wrangler bindings.
* docs(web): add public package walkthrough
Expand both package READMEs with installation, configuration, local
validation, health checks, and deployment instructions.
Add a standalone Vite and Wrangler example that imports only the
public Browser and Cloudflare entries. Generate Worker bindings from
configuration and keep local secrets outside version control.
* chore(go): import EasyTier Go host
Add the standalone Go host runtime as a monorepo subtree without
carrying its development branch ancestry.
Preserve its API, tests, examples, generated protobuf bindings, and
embedded WASI artifacts.
* refactor(hosts): colocate Go and JavaScript runtimes
Move the browser, Cloudflare, shared runtime, and web example into
the easytier-js subtree. Update workspace metadata, build paths, and
documentation for the new layout.
Adopt github.com/EasyTier/EasyTier/easytier-go as the Go module path.
Resolve artifact and protobuf generation from the enclosing monorepo.
* build(web): isolate JavaScript host workspace
Keep public browser and Cloudflare packages outside the legacy frontend
workspace so root installs and cross-platform builds do not pull workerd.
Make each package build generate its required WASI artifact from a clean
checkout. Add a dedicated workflow that runs the same install and check
commands documented for contributors.
Move JavaScript dependencies into a scoped lockfile and restore the root
workspace lockfile to its pre-host state.
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
|
|
}
|