// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.7
// 	protoc        v3.19.6
// source: hodu.proto

package hodu

import (
	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 ROUTE_OPTION int32

const (
	ROUTE_OPTION_UNSPEC ROUTE_OPTION = 0
	ROUTE_OPTION_TCP    ROUTE_OPTION = 1
	ROUTE_OPTION_TCP4   ROUTE_OPTION = 2
	ROUTE_OPTION_TCP6   ROUTE_OPTION = 4
	ROUTE_OPTION_TTY    ROUTE_OPTION = 8
	ROUTE_OPTION_HTTP   ROUTE_OPTION = 16
	ROUTE_OPTION_HTTPS  ROUTE_OPTION = 32
	ROUTE_OPTION_SSH    ROUTE_OPTION = 64
)

// Enum value maps for ROUTE_OPTION.
var (
	ROUTE_OPTION_name = map[int32]string{
		0:  "UNSPEC",
		1:  "TCP",
		2:  "TCP4",
		4:  "TCP6",
		8:  "TTY",
		16: "HTTP",
		32: "HTTPS",
		64: "SSH",
	}
	ROUTE_OPTION_value = map[string]int32{
		"UNSPEC": 0,
		"TCP":    1,
		"TCP4":   2,
		"TCP6":   4,
		"TTY":    8,
		"HTTP":   16,
		"HTTPS":  32,
		"SSH":    64,
	}
)

func (x ROUTE_OPTION) Enum() *ROUTE_OPTION {
	p := new(ROUTE_OPTION)
	*p = x
	return p
}

func (x ROUTE_OPTION) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ROUTE_OPTION) Descriptor() protoreflect.EnumDescriptor {
	return file_hodu_proto_enumTypes[0].Descriptor()
}

func (ROUTE_OPTION) Type() protoreflect.EnumType {
	return &file_hodu_proto_enumTypes[0]
}

func (x ROUTE_OPTION) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ROUTE_OPTION.Descriptor instead.
func (ROUTE_OPTION) EnumDescriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{0}
}

type PACKET_KIND int32

const (
	PACKET_KIND_RESERVED      PACKET_KIND = 0 // not used
	PACKET_KIND_ROUTE_START   PACKET_KIND = 1
	PACKET_KIND_ROUTE_STOP    PACKET_KIND = 2
	PACKET_KIND_ROUTE_STARTED PACKET_KIND = 3
	PACKET_KIND_ROUTE_STOPPED PACKET_KIND = 4
	PACKET_KIND_PEER_STARTED  PACKET_KIND = 5
	PACKET_KIND_PEER_STOPPED  PACKET_KIND = 6
	PACKET_KIND_PEER_ABORTED  PACKET_KIND = 7
	PACKET_KIND_PEER_EOF      PACKET_KIND = 8
	PACKET_KIND_PEER_DATA     PACKET_KIND = 9
	PACKET_KIND_CONN_DESC     PACKET_KIND = 11
	PACKET_KIND_CONN_ERROR    PACKET_KIND = 12
	PACKET_KIND_CONN_NOTICE   PACKET_KIND = 13
	PACKET_KIND_RPTY_START    PACKET_KIND = 14
	PACKET_KIND_RPTY_STOP     PACKET_KIND = 15
	PACKET_KIND_RPTY_STARTED  PACKET_KIND = 16
	PACKET_KIND_RPTY_STOPPED  PACKET_KIND = 17
	PACKET_KIND_RPTY_ABORTED  PACKET_KIND = 18
	PACKET_KIND_RPTY_EOF      PACKET_KIND = 19
	PACKET_KIND_RPTY_DATA     PACKET_KIND = 20
)

// Enum value maps for PACKET_KIND.
var (
	PACKET_KIND_name = map[int32]string{
		0:  "RESERVED",
		1:  "ROUTE_START",
		2:  "ROUTE_STOP",
		3:  "ROUTE_STARTED",
		4:  "ROUTE_STOPPED",
		5:  "PEER_STARTED",
		6:  "PEER_STOPPED",
		7:  "PEER_ABORTED",
		8:  "PEER_EOF",
		9:  "PEER_DATA",
		11: "CONN_DESC",
		12: "CONN_ERROR",
		13: "CONN_NOTICE",
		14: "RPTY_START",
		15: "RPTY_STOP",
		16: "RPTY_STARTED",
		17: "RPTY_STOPPED",
		18: "RPTY_ABORTED",
		19: "RPTY_EOF",
		20: "RPTY_DATA",
	}
	PACKET_KIND_value = map[string]int32{
		"RESERVED":      0,
		"ROUTE_START":   1,
		"ROUTE_STOP":    2,
		"ROUTE_STARTED": 3,
		"ROUTE_STOPPED": 4,
		"PEER_STARTED":  5,
		"PEER_STOPPED":  6,
		"PEER_ABORTED":  7,
		"PEER_EOF":      8,
		"PEER_DATA":     9,
		"CONN_DESC":     11,
		"CONN_ERROR":    12,
		"CONN_NOTICE":   13,
		"RPTY_START":    14,
		"RPTY_STOP":     15,
		"RPTY_STARTED":  16,
		"RPTY_STOPPED":  17,
		"RPTY_ABORTED":  18,
		"RPTY_EOF":      19,
		"RPTY_DATA":     20,
	}
)

func (x PACKET_KIND) Enum() *PACKET_KIND {
	p := new(PACKET_KIND)
	*p = x
	return p
}

func (x PACKET_KIND) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PACKET_KIND) Descriptor() protoreflect.EnumDescriptor {
	return file_hodu_proto_enumTypes[1].Descriptor()
}

func (PACKET_KIND) Type() protoreflect.EnumType {
	return &file_hodu_proto_enumTypes[1]
}

func (x PACKET_KIND) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PACKET_KIND.Descriptor instead.
func (PACKET_KIND) EnumDescriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{1}
}

type Seed struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       uint32                 `protobuf:"varint,1,opt,name=Version,proto3" json:"Version,omitempty"`
	Flags         uint64                 `protobuf:"varint,2,opt,name=Flags,proto3" json:"Flags,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Seed) Reset() {
	*x = Seed{}
	mi := &file_hodu_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Seed) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Seed) ProtoMessage() {}

func (x *Seed) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 Seed.ProtoReflect.Descriptor instead.
func (*Seed) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{0}
}

func (x *Seed) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (x *Seed) GetFlags() uint64 {
	if x != nil {
		return x.Flags
	}
	return 0
}

type RouteDesc struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	RouteId uint32                 `protobuf:"varint,1,opt,name=RouteId,proto3" json:"RouteId,omitempty"`
	// C->S(ROUTE_START/STOP): client-side peer address
	// S->C(ROUTE_STARTED/STOPPED): server-side listening address
	TargetAddrStr string `protobuf:"bytes,2,opt,name=TargetAddrStr,proto3" json:"TargetAddrStr,omitempty"`
	// C->S(ROUTE_START/STOPPED): human-readable name of client-side peer
	// S->C(ROUTE_STARTED/STOPPED): clone as sent by C
	TargetName string `protobuf:"bytes,3,opt,name=TargetName,proto3" json:"TargetName,omitempty"`
	// C->S(ROUTE_START): requested listening option on the server-side(e.g. tcp, tcp4, tcp6) +
	//
	//	hint to the service-side peer(e.g. local) +
	//	hint to the client-side peer(e.g. tty, http, https)
	//
	// S->C(ROUTE_STARTED): cloned as sent by C.
	ServiceOption uint32 `protobuf:"varint,4,opt,name=ServiceOption,proto3" json:"ServiceOption,omitempty"`
	// C->S(ROUTE_START): requested lisening address on the service-side
	// S->C(ROUTE_STARTED): cloned as sent by C
	ServiceAddrStr string `protobuf:"bytes,5,opt,name=ServiceAddrStr,proto3" json:"ServiceAddrStr,omitempty"`
	// C->S(ROUTE_START): requested permitted network of server-side peers.
	// S->C(ROUTE_STARTED): actual permitted network of server-side peers
	ServiceNetStr string `protobuf:"bytes,6,opt,name=ServiceNetStr,proto3" json:"ServiceNetStr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RouteDesc) Reset() {
	*x = RouteDesc{}
	mi := &file_hodu_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RouteDesc) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RouteDesc) ProtoMessage() {}

func (x *RouteDesc) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 RouteDesc.ProtoReflect.Descriptor instead.
func (*RouteDesc) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{1}
}

func (x *RouteDesc) GetRouteId() uint32 {
	if x != nil {
		return x.RouteId
	}
	return 0
}

func (x *RouteDesc) GetTargetAddrStr() string {
	if x != nil {
		return x.TargetAddrStr
	}
	return ""
}

func (x *RouteDesc) GetTargetName() string {
	if x != nil {
		return x.TargetName
	}
	return ""
}

func (x *RouteDesc) GetServiceOption() uint32 {
	if x != nil {
		return x.ServiceOption
	}
	return 0
}

func (x *RouteDesc) GetServiceAddrStr() string {
	if x != nil {
		return x.ServiceAddrStr
	}
	return ""
}

func (x *RouteDesc) GetServiceNetStr() string {
	if x != nil {
		return x.ServiceNetStr
	}
	return ""
}

type PeerDesc struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RouteId       uint32                 `protobuf:"varint,1,opt,name=RouteId,proto3" json:"RouteId,omitempty"`
	PeerId        uint32                 `protobuf:"varint,2,opt,name=PeerId,proto3" json:"PeerId,omitempty"`
	RemoteAddrStr string                 `protobuf:"bytes,3,opt,name=RemoteAddrStr,proto3" json:"RemoteAddrStr,omitempty"`
	LocalAddrStr  string                 `protobuf:"bytes,4,opt,name=LocalAddrStr,proto3" json:"LocalAddrStr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PeerDesc) Reset() {
	*x = PeerDesc{}
	mi := &file_hodu_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeerDesc) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerDesc) ProtoMessage() {}

func (x *PeerDesc) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 PeerDesc.ProtoReflect.Descriptor instead.
func (*PeerDesc) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{2}
}

func (x *PeerDesc) GetRouteId() uint32 {
	if x != nil {
		return x.RouteId
	}
	return 0
}

func (x *PeerDesc) GetPeerId() uint32 {
	if x != nil {
		return x.PeerId
	}
	return 0
}

func (x *PeerDesc) GetRemoteAddrStr() string {
	if x != nil {
		return x.RemoteAddrStr
	}
	return ""
}

func (x *PeerDesc) GetLocalAddrStr() string {
	if x != nil {
		return x.LocalAddrStr
	}
	return ""
}

type PeerData struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RouteId       uint32                 `protobuf:"varint,1,opt,name=RouteId,proto3" json:"RouteId,omitempty"`
	PeerId        uint32                 `protobuf:"varint,2,opt,name=PeerId,proto3" json:"PeerId,omitempty"`
	Data          []byte                 `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PeerData) Reset() {
	*x = PeerData{}
	mi := &file_hodu_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PeerData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PeerData) ProtoMessage() {}

func (x *PeerData) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 PeerData.ProtoReflect.Descriptor instead.
func (*PeerData) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{3}
}

func (x *PeerData) GetRouteId() uint32 {
	if x != nil {
		return x.RouteId
	}
	return 0
}

func (x *PeerData) GetPeerId() uint32 {
	if x != nil {
		return x.PeerId
	}
	return 0
}

func (x *PeerData) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

type ConnDesc struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Token         string                 `protobuf:"bytes,1,opt,name=Token,proto3" json:"Token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnDesc) Reset() {
	*x = ConnDesc{}
	mi := &file_hodu_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnDesc) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnDesc) ProtoMessage() {}

func (x *ConnDesc) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 ConnDesc.ProtoReflect.Descriptor instead.
func (*ConnDesc) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{4}
}

func (x *ConnDesc) GetToken() string {
	if x != nil {
		return x.Token
	}
	return ""
}

type ConnError struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ErrorId       uint32                 `protobuf:"varint,1,opt,name=ErrorId,proto3" json:"ErrorId,omitempty"`
	Text          string                 `protobuf:"bytes,2,opt,name=Text,proto3" json:"Text,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnError) Reset() {
	*x = ConnError{}
	mi := &file_hodu_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnError) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnError) ProtoMessage() {}

func (x *ConnError) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 ConnError.ProtoReflect.Descriptor instead.
func (*ConnError) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{5}
}

func (x *ConnError) GetErrorId() uint32 {
	if x != nil {
		return x.ErrorId
	}
	return 0
}

func (x *ConnError) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

type ConnNotice struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Text          string                 `protobuf:"bytes,1,opt,name=Text,proto3" json:"Text,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnNotice) Reset() {
	*x = ConnNotice{}
	mi := &file_hodu_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnNotice) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnNotice) ProtoMessage() {}

func (x *ConnNotice) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 ConnNotice.ProtoReflect.Descriptor instead.
func (*ConnNotice) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{6}
}

func (x *ConnNotice) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

type RptyEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Token         string                 `protobuf:"bytes,1,opt,name=Token,proto3" json:"Token,omitempty"`
	Data          []byte                 `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RptyEvent) Reset() {
	*x = RptyEvent{}
	mi := &file_hodu_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RptyEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RptyEvent) ProtoMessage() {}

func (x *RptyEvent) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 RptyEvent.ProtoReflect.Descriptor instead.
func (*RptyEvent) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{7}
}

func (x *RptyEvent) GetToken() string {
	if x != nil {
		return x.Token
	}
	return ""
}

func (x *RptyEvent) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

type Packet struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Kind  PACKET_KIND            `protobuf:"varint,1,opt,name=Kind,proto3,enum=PACKET_KIND" json:"Kind,omitempty"`
	// Types that are valid to be assigned to U:
	//
	//	*Packet_Route
	//	*Packet_Peer
	//	*Packet_Data
	//	*Packet_Conn
	//	*Packet_ConnErr
	//	*Packet_ConnNoti
	//	*Packet_Rpty
	U             isPacket_U `protobuf_oneof:"U"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Packet) Reset() {
	*x = Packet{}
	mi := &file_hodu_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Packet) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Packet) ProtoMessage() {}

func (x *Packet) ProtoReflect() protoreflect.Message {
	mi := &file_hodu_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 Packet.ProtoReflect.Descriptor instead.
func (*Packet) Descriptor() ([]byte, []int) {
	return file_hodu_proto_rawDescGZIP(), []int{8}
}

func (x *Packet) GetKind() PACKET_KIND {
	if x != nil {
		return x.Kind
	}
	return PACKET_KIND_RESERVED
}

func (x *Packet) GetU() isPacket_U {
	if x != nil {
		return x.U
	}
	return nil
}

func (x *Packet) GetRoute() *RouteDesc {
	if x != nil {
		if x, ok := x.U.(*Packet_Route); ok {
			return x.Route
		}
	}
	return nil
}

func (x *Packet) GetPeer() *PeerDesc {
	if x != nil {
		if x, ok := x.U.(*Packet_Peer); ok {
			return x.Peer
		}
	}
	return nil
}

func (x *Packet) GetData() *PeerData {
	if x != nil {
		if x, ok := x.U.(*Packet_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *Packet) GetConn() *ConnDesc {
	if x != nil {
		if x, ok := x.U.(*Packet_Conn); ok {
			return x.Conn
		}
	}
	return nil
}

func (x *Packet) GetConnErr() *ConnError {
	if x != nil {
		if x, ok := x.U.(*Packet_ConnErr); ok {
			return x.ConnErr
		}
	}
	return nil
}

func (x *Packet) GetConnNoti() *ConnNotice {
	if x != nil {
		if x, ok := x.U.(*Packet_ConnNoti); ok {
			return x.ConnNoti
		}
	}
	return nil
}

func (x *Packet) GetRpty() *RptyEvent {
	if x != nil {
		if x, ok := x.U.(*Packet_Rpty); ok {
			return x.Rpty
		}
	}
	return nil
}

type isPacket_U interface {
	isPacket_U()
}

type Packet_Route struct {
	Route *RouteDesc `protobuf:"bytes,2,opt,name=Route,proto3,oneof"`
}

type Packet_Peer struct {
	Peer *PeerDesc `protobuf:"bytes,3,opt,name=Peer,proto3,oneof"`
}

type Packet_Data struct {
	Data *PeerData `protobuf:"bytes,4,opt,name=Data,proto3,oneof"`
}

type Packet_Conn struct {
	Conn *ConnDesc `protobuf:"bytes,5,opt,name=Conn,proto3,oneof"`
}

type Packet_ConnErr struct {
	ConnErr *ConnError `protobuf:"bytes,6,opt,name=ConnErr,proto3,oneof"`
}

type Packet_ConnNoti struct {
	ConnNoti *ConnNotice `protobuf:"bytes,7,opt,name=ConnNoti,proto3,oneof"`
}

type Packet_Rpty struct {
	Rpty *RptyEvent `protobuf:"bytes,8,opt,name=Rpty,proto3,oneof"`
}

func (*Packet_Route) isPacket_U() {}

func (*Packet_Peer) isPacket_U() {}

func (*Packet_Data) isPacket_U() {}

func (*Packet_Conn) isPacket_U() {}

func (*Packet_ConnErr) isPacket_U() {}

func (*Packet_ConnNoti) isPacket_U() {}

func (*Packet_Rpty) isPacket_U() {}

var File_hodu_proto protoreflect.FileDescriptor

const file_hodu_proto_rawDesc = "" +
	"\n" +
	"\n" +
	"hodu.proto\"6\n" +
	"\x04Seed\x12\x18\n" +
	"\aVersion\x18\x01 \x01(\rR\aVersion\x12\x14\n" +
	"\x05Flags\x18\x02 \x01(\x04R\x05Flags\"\xdf\x01\n" +
	"\tRouteDesc\x12\x18\n" +
	"\aRouteId\x18\x01 \x01(\rR\aRouteId\x12$\n" +
	"\rTargetAddrStr\x18\x02 \x01(\tR\rTargetAddrStr\x12\x1e\n" +
	"\n" +
	"TargetName\x18\x03 \x01(\tR\n" +
	"TargetName\x12$\n" +
	"\rServiceOption\x18\x04 \x01(\rR\rServiceOption\x12&\n" +
	"\x0eServiceAddrStr\x18\x05 \x01(\tR\x0eServiceAddrStr\x12$\n" +
	"\rServiceNetStr\x18\x06 \x01(\tR\rServiceNetStr\"\x86\x01\n" +
	"\bPeerDesc\x12\x18\n" +
	"\aRouteId\x18\x01 \x01(\rR\aRouteId\x12\x16\n" +
	"\x06PeerId\x18\x02 \x01(\rR\x06PeerId\x12$\n" +
	"\rRemoteAddrStr\x18\x03 \x01(\tR\rRemoteAddrStr\x12\"\n" +
	"\fLocalAddrStr\x18\x04 \x01(\tR\fLocalAddrStr\"P\n" +
	"\bPeerData\x12\x18\n" +
	"\aRouteId\x18\x01 \x01(\rR\aRouteId\x12\x16\n" +
	"\x06PeerId\x18\x02 \x01(\rR\x06PeerId\x12\x12\n" +
	"\x04Data\x18\x03 \x01(\fR\x04Data\" \n" +
	"\bConnDesc\x12\x14\n" +
	"\x05Token\x18\x01 \x01(\tR\x05Token\"9\n" +
	"\tConnError\x12\x18\n" +
	"\aErrorId\x18\x01 \x01(\rR\aErrorId\x12\x12\n" +
	"\x04Text\x18\x02 \x01(\tR\x04Text\" \n" +
	"\n" +
	"ConnNotice\x12\x12\n" +
	"\x04Text\x18\x01 \x01(\tR\x04Text\"5\n" +
	"\tRptyEvent\x12\x14\n" +
	"\x05Token\x18\x01 \x01(\tR\x05Token\x12\x12\n" +
	"\x04Data\x18\x02 \x01(\fR\x04Data\"\xab\x02\n" +
	"\x06Packet\x12 \n" +
	"\x04Kind\x18\x01 \x01(\x0e2\f.PACKET_KINDR\x04Kind\x12\"\n" +
	"\x05Route\x18\x02 \x01(\v2\n" +
	".RouteDescH\x00R\x05Route\x12\x1f\n" +
	"\x04Peer\x18\x03 \x01(\v2\t.PeerDescH\x00R\x04Peer\x12\x1f\n" +
	"\x04Data\x18\x04 \x01(\v2\t.PeerDataH\x00R\x04Data\x12\x1f\n" +
	"\x04Conn\x18\x05 \x01(\v2\t.ConnDescH\x00R\x04Conn\x12&\n" +
	"\aConnErr\x18\x06 \x01(\v2\n" +
	".ConnErrorH\x00R\aConnErr\x12)\n" +
	"\bConnNoti\x18\a \x01(\v2\v.ConnNoticeH\x00R\bConnNoti\x12 \n" +
	"\x04Rpty\x18\b \x01(\v2\n" +
	".RptyEventH\x00R\x04RptyB\x03\n" +
	"\x01U*^\n" +
	"\fROUTE_OPTION\x12\n" +
	"\n" +
	"\x06UNSPEC\x10\x00\x12\a\n" +
	"\x03TCP\x10\x01\x12\b\n" +
	"\x04TCP4\x10\x02\x12\b\n" +
	"\x04TCP6\x10\x04\x12\a\n" +
	"\x03TTY\x10\b\x12\b\n" +
	"\x04HTTP\x10\x10\x12\t\n" +
	"\x05HTTPS\x10 \x12\a\n" +
	"\x03SSH\x10@*\xd7\x02\n" +
	"\vPACKET_KIND\x12\f\n" +
	"\bRESERVED\x10\x00\x12\x0f\n" +
	"\vROUTE_START\x10\x01\x12\x0e\n" +
	"\n" +
	"ROUTE_STOP\x10\x02\x12\x11\n" +
	"\rROUTE_STARTED\x10\x03\x12\x11\n" +
	"\rROUTE_STOPPED\x10\x04\x12\x10\n" +
	"\fPEER_STARTED\x10\x05\x12\x10\n" +
	"\fPEER_STOPPED\x10\x06\x12\x10\n" +
	"\fPEER_ABORTED\x10\a\x12\f\n" +
	"\bPEER_EOF\x10\b\x12\r\n" +
	"\tPEER_DATA\x10\t\x12\r\n" +
	"\tCONN_DESC\x10\v\x12\x0e\n" +
	"\n" +
	"CONN_ERROR\x10\f\x12\x0f\n" +
	"\vCONN_NOTICE\x10\r\x12\x0e\n" +
	"\n" +
	"RPTY_START\x10\x0e\x12\r\n" +
	"\tRPTY_STOP\x10\x0f\x12\x10\n" +
	"\fRPTY_STARTED\x10\x10\x12\x10\n" +
	"\fRPTY_STOPPED\x10\x11\x12\x10\n" +
	"\fRPTY_ABORTED\x10\x12\x12\f\n" +
	"\bRPTY_EOF\x10\x13\x12\r\n" +
	"\tRPTY_DATA\x10\x142I\n" +
	"\x04Hodu\x12\x19\n" +
	"\aGetSeed\x12\x05.Seed\x1a\x05.Seed\"\x00\x12&\n" +
	"\fPacketStream\x12\a.Packet\x1a\a.Packet\"\x00(\x010\x01B\bZ\x06./hodub\x06proto3"

var (
	file_hodu_proto_rawDescOnce sync.Once
	file_hodu_proto_rawDescData []byte
)

func file_hodu_proto_rawDescGZIP() []byte {
	file_hodu_proto_rawDescOnce.Do(func() {
		file_hodu_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_hodu_proto_rawDesc), len(file_hodu_proto_rawDesc)))
	})
	return file_hodu_proto_rawDescData
}

var file_hodu_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_hodu_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_hodu_proto_goTypes = []any{
	(ROUTE_OPTION)(0),  // 0: ROUTE_OPTION
	(PACKET_KIND)(0),   // 1: PACKET_KIND
	(*Seed)(nil),       // 2: Seed
	(*RouteDesc)(nil),  // 3: RouteDesc
	(*PeerDesc)(nil),   // 4: PeerDesc
	(*PeerData)(nil),   // 5: PeerData
	(*ConnDesc)(nil),   // 6: ConnDesc
	(*ConnError)(nil),  // 7: ConnError
	(*ConnNotice)(nil), // 8: ConnNotice
	(*RptyEvent)(nil),  // 9: RptyEvent
	(*Packet)(nil),     // 10: Packet
}
var file_hodu_proto_depIdxs = []int32{
	1,  // 0: Packet.Kind:type_name -> PACKET_KIND
	3,  // 1: Packet.Route:type_name -> RouteDesc
	4,  // 2: Packet.Peer:type_name -> PeerDesc
	5,  // 3: Packet.Data:type_name -> PeerData
	6,  // 4: Packet.Conn:type_name -> ConnDesc
	7,  // 5: Packet.ConnErr:type_name -> ConnError
	8,  // 6: Packet.ConnNoti:type_name -> ConnNotice
	9,  // 7: Packet.Rpty:type_name -> RptyEvent
	2,  // 8: Hodu.GetSeed:input_type -> Seed
	10, // 9: Hodu.PacketStream:input_type -> Packet
	2,  // 10: Hodu.GetSeed:output_type -> Seed
	10, // 11: Hodu.PacketStream:output_type -> Packet
	10, // [10:12] is the sub-list for method output_type
	8,  // [8:10] is the sub-list for method input_type
	8,  // [8:8] is the sub-list for extension type_name
	8,  // [8:8] is the sub-list for extension extendee
	0,  // [0:8] is the sub-list for field type_name
}

func init() { file_hodu_proto_init() }
func file_hodu_proto_init() {
	if File_hodu_proto != nil {
		return
	}
	file_hodu_proto_msgTypes[8].OneofWrappers = []any{
		(*Packet_Route)(nil),
		(*Packet_Peer)(nil),
		(*Packet_Data)(nil),
		(*Packet_Conn)(nil),
		(*Packet_ConnErr)(nil),
		(*Packet_ConnNoti)(nil),
		(*Packet_Rpty)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_hodu_proto_rawDesc), len(file_hodu_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_hodu_proto_goTypes,
		DependencyIndexes: file_hodu_proto_depIdxs,
		EnumInfos:         file_hodu_proto_enumTypes,
		MessageInfos:      file_hodu_proto_msgTypes,
	}.Build()
	File_hodu_proto = out.File
	file_hodu_proto_goTypes = nil
	file_hodu_proto_depIdxs = nil
}