github.com/gravitational/teleport/api@v0.0.0-20240507183017-3110591cbafc/client/proto/proxyservice.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: teleport/legacy/client/proto/proxyservice.proto

package proto

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gravitational_teleport_api_types "github.com/gravitational/teleport/api/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Frame wraps different message types to be sent over a stream.
type Frame struct {
	// Types that are valid to be assigned to Message:
	//	*Frame_DialRequest
	//	*Frame_ConnectionEstablished
	//	*Frame_Data
	Message              isFrame_Message `protobuf_oneof:"Message"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Frame) Reset()         { *m = Frame{} }
func (m *Frame) String() string { return proto.CompactTextString(m) }
func (*Frame) ProtoMessage()    {}
func (*Frame) Descriptor() ([]byte, []int) {
	return fileDescriptor_b76fff22d4479739, []int{0}
}
func (m *Frame) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Frame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Frame.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Frame) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Frame.Merge(m, src)
}
func (m *Frame) XXX_Size() int {
	return m.Size()
}
func (m *Frame) XXX_DiscardUnknown() {
	xxx_messageInfo_Frame.DiscardUnknown(m)
}

var xxx_messageInfo_Frame proto.InternalMessageInfo

type isFrame_Message interface {
	isFrame_Message()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Frame_DialRequest struct {
	DialRequest *DialRequest `protobuf:"bytes,1,opt,name=DialRequest,proto3,oneof" json:"DialRequest,omitempty"`
}
type Frame_ConnectionEstablished struct {
	ConnectionEstablished *ConnectionEstablished `protobuf:"bytes,2,opt,name=ConnectionEstablished,proto3,oneof" json:"ConnectionEstablished,omitempty"`
}
type Frame_Data struct {
	Data *Data `protobuf:"bytes,3,opt,name=Data,proto3,oneof" json:"Data,omitempty"`
}

func (*Frame_DialRequest) isFrame_Message()           {}
func (*Frame_ConnectionEstablished) isFrame_Message() {}
func (*Frame_Data) isFrame_Message()                  {}

func (m *Frame) GetMessage() isFrame_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *Frame) GetDialRequest() *DialRequest {
	if x, ok := m.GetMessage().(*Frame_DialRequest); ok {
		return x.DialRequest
	}
	return nil
}

func (m *Frame) GetConnectionEstablished() *ConnectionEstablished {
	if x, ok := m.GetMessage().(*Frame_ConnectionEstablished); ok {
		return x.ConnectionEstablished
	}
	return nil
}

func (m *Frame) GetData() *Data {
	if x, ok := m.GetMessage().(*Frame_Data); ok {
		return x.Data
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Frame) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Frame_DialRequest)(nil),
		(*Frame_ConnectionEstablished)(nil),
		(*Frame_Data)(nil),
	}
}

// DialRequest contains details for connecting to a node.
type DialRequest struct {
	// NodeID is the {UUID}.{ClusterName} of the node to connect to.
	NodeID string `protobuf:"bytes,1,opt,name=NodeID,proto3" json:"NodeID,omitempty"`
	// TunnelType is the type of service being accessed. This differentiates agents that
	// create multiple reverse tunnels for different services.
	TunnelType github_com_gravitational_teleport_api_types.TunnelType `protobuf:"bytes,2,opt,name=TunnelType,proto3,casttype=github.com/gravitational/teleport/api/types.TunnelType" json:"TunnelType,omitempty"`
	// Source is the original source address of the client.
	Source *NetAddr `protobuf:"bytes,3,opt,name=Source,proto3" json:"Source,omitempty"`
	// Destination is the destination address to connect to over the reverse tunnel.
	Destination          *NetAddr `protobuf:"bytes,4,opt,name=Destination,proto3" json:"Destination,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DialRequest) Reset()         { *m = DialRequest{} }
func (m *DialRequest) String() string { return proto.CompactTextString(m) }
func (*DialRequest) ProtoMessage()    {}
func (*DialRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b76fff22d4479739, []int{1}
}
func (m *DialRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DialRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DialRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DialRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DialRequest.Merge(m, src)
}
func (m *DialRequest) XXX_Size() int {
	return m.Size()
}
func (m *DialRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DialRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DialRequest proto.InternalMessageInfo

func (m *DialRequest) GetNodeID() string {
	if m != nil {
		return m.NodeID
	}
	return ""
}

func (m *DialRequest) GetTunnelType() github_com_gravitational_teleport_api_types.TunnelType {
	if m != nil {
		return m.TunnelType
	}
	return ""
}

func (m *DialRequest) GetSource() *NetAddr {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *DialRequest) GetDestination() *NetAddr {
	if m != nil {
		return m.Destination
	}
	return nil
}

// Addr is a network address.
type NetAddr struct {
	// Network is the type of network socket. For example tcp or udp.
	Network string `protobuf:"bytes,1,opt,name=Network,proto3" json:"Network,omitempty"`
	// Addr is the host:port address. For example 'localhost:22'
	Addr                 string   `protobuf:"bytes,2,opt,name=Addr,proto3" json:"Addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NetAddr) Reset()         { *m = NetAddr{} }
func (m *NetAddr) String() string { return proto.CompactTextString(m) }
func (*NetAddr) ProtoMessage()    {}
func (*NetAddr) Descriptor() ([]byte, []int) {
	return fileDescriptor_b76fff22d4479739, []int{2}
}
func (m *NetAddr) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NetAddr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetAddr.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NetAddr) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetAddr.Merge(m, src)
}
func (m *NetAddr) XXX_Size() int {
	return m.Size()
}
func (m *NetAddr) XXX_DiscardUnknown() {
	xxx_messageInfo_NetAddr.DiscardUnknown(m)
}

var xxx_messageInfo_NetAddr proto.InternalMessageInfo

func (m *NetAddr) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *NetAddr) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

// Data contains the raw bytes of a connection.
type Data struct {
	Bytes                []byte   `protobuf:"bytes,1,opt,name=Bytes,proto3" json:"Bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Data) Reset()         { *m = Data{} }
func (m *Data) String() string { return proto.CompactTextString(m) }
func (*Data) ProtoMessage()    {}
func (*Data) Descriptor() ([]byte, []int) {
	return fileDescriptor_b76fff22d4479739, []int{3}
}
func (m *Data) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Data.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Data) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Data.Merge(m, src)
}
func (m *Data) XXX_Size() int {
	return m.Size()
}
func (m *Data) XXX_DiscardUnknown() {
	xxx_messageInfo_Data.DiscardUnknown(m)
}

var xxx_messageInfo_Data proto.InternalMessageInfo

func (m *Data) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

// ConnectionEstablished signals to the client a connection to the node has been established.
type ConnectionEstablished struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionEstablished) Reset()         { *m = ConnectionEstablished{} }
func (m *ConnectionEstablished) String() string { return proto.CompactTextString(m) }
func (*ConnectionEstablished) ProtoMessage()    {}
func (*ConnectionEstablished) Descriptor() ([]byte, []int) {
	return fileDescriptor_b76fff22d4479739, []int{4}
}
func (m *ConnectionEstablished) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnectionEstablished) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnectionEstablished.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnectionEstablished) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionEstablished.Merge(m, src)
}
func (m *ConnectionEstablished) XXX_Size() int {
	return m.Size()
}
func (m *ConnectionEstablished) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionEstablished.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionEstablished proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Frame)(nil), "proto.Frame")
	proto.RegisterType((*DialRequest)(nil), "proto.DialRequest")
	proto.RegisterType((*NetAddr)(nil), "proto.NetAddr")
	proto.RegisterType((*Data)(nil), "proto.Data")
	proto.RegisterType((*ConnectionEstablished)(nil), "proto.ConnectionEstablished")
}

func init() {
	proto.RegisterFile("teleport/legacy/client/proto/proxyservice.proto", fileDescriptor_b76fff22d4479739)
}

var fileDescriptor_b76fff22d4479739 = []byte{
	// 422 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x41, 0x6f, 0xd3, 0x30,
	0x14, 0xae, 0xa1, 0xed, 0xe8, 0x4b, 0xc5, 0xc1, 0x1a, 0x10, 0x4d, 0x53, 0x81, 0x1c, 0xd0, 0xc4,
	0x21, 0x99, 0x8a, 0x34, 0xa4, 0x9d, 0x20, 0x04, 0x54, 0x0e, 0x4c, 0xc8, 0xeb, 0x69, 0x37, 0x37,
	0x79, 0xca, 0x2c, 0xb2, 0x38, 0xd8, 0xce, 0x20, 0xbf, 0x8f, 0x0b, 0x47, 0xee, 0x48, 0x08, 0xf5,
	0x67, 0x70, 0x42, 0x71, 0x5c, 0x35, 0x95, 0x8a, 0xc4, 0x25, 0x7e, 0xcf, 0xef, 0x7b, 0x5f, 0xbe,
	0xf7, 0xf9, 0x41, 0x64, 0xb0, 0xc0, 0x4a, 0x2a, 0x13, 0x15, 0x98, 0xf3, 0xb4, 0x89, 0xd2, 0x42,
	0x60, 0x69, 0xa2, 0x4a, 0x49, 0x23, 0xdb, 0xef, 0xd7, 0x46, 0xa3, 0xba, 0x15, 0x29, 0x86, 0xf6,
	0x8a, 0x8e, 0xec, 0x71, 0x74, 0x98, 0xcb, 0x5c, 0x76, 0xa0, 0x36, 0xea, 0x8a, 0xc1, 0x37, 0x02,
	0xa3, 0x77, 0x8a, 0xdf, 0x20, 0x3d, 0x03, 0x2f, 0x11, 0xbc, 0x60, 0xf8, 0xb9, 0x46, 0x6d, 0x7c,
	0xf2, 0x84, 0x9c, 0x78, 0x73, 0xda, 0xc1, 0xc2, 0x5e, 0x65, 0x31, 0x60, 0x7d, 0x20, 0x5d, 0xc2,
	0x83, 0x37, 0xb2, 0x2c, 0x31, 0x35, 0x42, 0x96, 0x6f, 0xb5, 0xe1, 0xab, 0x42, 0xe8, 0x6b, 0xcc,
	0xfc, 0x3b, 0x96, 0xe1, 0xd8, 0x31, 0xec, 0xc5, 0x2c, 0x06, 0x6c, 0x7f, 0x33, 0x7d, 0x0a, 0xc3,
	0x84, 0x1b, 0xee, 0xdf, 0xb5, 0x24, 0xde, 0x46, 0x06, 0x37, 0x7c, 0x31, 0x60, 0xb6, 0x14, 0x4f,
	0xe0, 0xe0, 0x03, 0x6a, 0xcd, 0x73, 0x0c, 0x7e, 0x92, 0x1d, 0xf1, 0xf4, 0x21, 0x8c, 0x2f, 0x64,
	0x86, 0xef, 0x13, 0x3b, 0xc6, 0x84, 0xb9, 0x8c, 0x5e, 0x01, 0x2c, 0xeb, 0xb2, 0xc4, 0x62, 0xd9,
	0x54, 0x68, 0x05, 0x4e, 0xe2, 0xf3, 0x3f, 0xbf, 0x1e, 0x9f, 0xe5, 0xc2, 0x5c, 0xd7, 0xab, 0x30,
	0x95, 0x37, 0x51, 0xae, 0xf8, 0xad, 0x30, 0xbc, 0x15, 0xc4, 0x8b, 0xad, 0xd9, 0xbc, 0x12, 0x91,
	0x69, 0x2a, 0xd4, 0xe1, 0x96, 0x81, 0xf5, 0xd8, 0xe8, 0x33, 0x18, 0x5f, 0xca, 0x5a, 0xa5, 0xe8,
	0x34, 0xdf, 0x77, 0x9a, 0x2f, 0xd0, 0xbc, 0xce, 0x32, 0xc5, 0x5c, 0x95, 0x9e, 0x82, 0x97, 0xa0,
	0x36, 0xa2, 0xb4, 0xbf, 0xf0, 0x87, 0x7b, 0xc1, 0x7d, 0x48, 0xf0, 0x12, 0x0e, 0xdc, 0x3d, 0xf5,
	0x6d, 0xf8, 0x45, 0xaa, 0x4f, 0x6e, 0xb2, 0x4d, 0x4a, 0x29, 0x0c, 0x5b, 0x44, 0x37, 0x14, 0xb3,
	0x71, 0x70, 0xdc, 0x99, 0x48, 0x0f, 0x61, 0x14, 0x37, 0x06, 0xb5, 0xed, 0x99, 0xb2, 0x2e, 0x09,
	0x1e, 0xfd, 0xe3, 0xe1, 0xe6, 0xe7, 0x30, 0xfd, 0xd8, 0xae, 0xd1, 0x65, 0xb7, 0x46, 0xf4, 0x39,
	0xdc, 0x6b, 0xcd, 0x6d, 0x3d, 0xa4, 0x53, 0x27, 0xd4, 0xee, 0xcc, 0xd1, 0x4e, 0x76, 0x42, 0x4e,
	0x49, 0xfc, 0xea, 0xfb, 0x7a, 0x46, 0x7e, 0xac, 0x67, 0xe4, 0xf7, 0x7a, 0x46, 0xae, 0xe6, 0xff,
	0xe7, 0x6b, 0x7f, 0x83, 0x57, 0x63, 0x7b, 0xbc, 0xf8, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x08,
	0x45, 0x85, 0xe8, 0x02, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ProxyServiceClient is the client API for ProxyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProxyServiceClient interface {
	// DialNode opens a bidrectional stream to the requested node.
	DialNode(ctx context.Context, opts ...grpc.CallOption) (ProxyService_DialNodeClient, error)
}

type proxyServiceClient struct {
	cc *grpc.ClientConn
}

func NewProxyServiceClient(cc *grpc.ClientConn) ProxyServiceClient {
	return &proxyServiceClient{cc}
}

func (c *proxyServiceClient) DialNode(ctx context.Context, opts ...grpc.CallOption) (ProxyService_DialNodeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProxyService_serviceDesc.Streams[0], "/proto.ProxyService/DialNode", opts...)
	if err != nil {
		return nil, err
	}
	x := &proxyServiceDialNodeClient{stream}
	return x, nil
}

type ProxyService_DialNodeClient interface {
	Send(*Frame) error
	Recv() (*Frame, error)
	grpc.ClientStream
}

type proxyServiceDialNodeClient struct {
	grpc.ClientStream
}

func (x *proxyServiceDialNodeClient) Send(m *Frame) error {
	return x.ClientStream.SendMsg(m)
}

func (x *proxyServiceDialNodeClient) Recv() (*Frame, error) {
	m := new(Frame)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ProxyServiceServer is the server API for ProxyService service.
type ProxyServiceServer interface {
	// DialNode opens a bidrectional stream to the requested node.
	DialNode(ProxyService_DialNodeServer) error
}

// UnimplementedProxyServiceServer can be embedded to have forward compatible implementations.
type UnimplementedProxyServiceServer struct {
}

func (*UnimplementedProxyServiceServer) DialNode(srv ProxyService_DialNodeServer) error {
	return status.Errorf(codes.Unimplemented, "method DialNode not implemented")
}

func RegisterProxyServiceServer(s *grpc.Server, srv ProxyServiceServer) {
	s.RegisterService(&_ProxyService_serviceDesc, srv)
}

func _ProxyService_DialNode_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ProxyServiceServer).DialNode(&proxyServiceDialNodeServer{stream})
}

type ProxyService_DialNodeServer interface {
	Send(*Frame) error
	Recv() (*Frame, error)
	grpc.ServerStream
}

type proxyServiceDialNodeServer struct {
	grpc.ServerStream
}

func (x *proxyServiceDialNodeServer) Send(m *Frame) error {
	return x.ServerStream.SendMsg(m)
}

func (x *proxyServiceDialNodeServer) Recv() (*Frame, error) {
	m := new(Frame)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _ProxyService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.ProxyService",
	HandlerType: (*ProxyServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "DialNode",
			Handler:       _ProxyService_DialNode_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "teleport/legacy/client/proto/proxyservice.proto",
}

func (m *Frame) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Frame) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Frame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Message != nil {
		{
			size := m.Message.Size()
			i -= size
			if _, err := m.Message.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Frame_DialRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Frame_DialRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DialRequest != nil {
		{
			size, err := m.DialRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProxyservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Frame_ConnectionEstablished) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Frame_ConnectionEstablished) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ConnectionEstablished != nil {
		{
			size, err := m.ConnectionEstablished.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProxyservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Frame_Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Frame_Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProxyservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *DialRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DialRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DialRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Destination != nil {
		{
			size, err := m.Destination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProxyservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProxyservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TunnelType) > 0 {
		i -= len(m.TunnelType)
		copy(dAtA[i:], m.TunnelType)
		i = encodeVarintProxyservice(dAtA, i, uint64(len(m.TunnelType)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NodeID) > 0 {
		i -= len(m.NodeID)
		copy(dAtA[i:], m.NodeID)
		i = encodeVarintProxyservice(dAtA, i, uint64(len(m.NodeID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NetAddr) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NetAddr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NetAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Addr) > 0 {
		i -= len(m.Addr)
		copy(dAtA[i:], m.Addr)
		i = encodeVarintProxyservice(dAtA, i, uint64(len(m.Addr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Network) > 0 {
		i -= len(m.Network)
		copy(dAtA[i:], m.Network)
		i = encodeVarintProxyservice(dAtA, i, uint64(len(m.Network)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Data) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Bytes) > 0 {
		i -= len(m.Bytes)
		copy(dAtA[i:], m.Bytes)
		i = encodeVarintProxyservice(dAtA, i, uint64(len(m.Bytes)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConnectionEstablished) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnectionEstablished) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnectionEstablished) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func encodeVarintProxyservice(dAtA []byte, offset int, v uint64) int {
	offset -= sovProxyservice(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Frame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Message != nil {
		n += m.Message.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Frame_DialRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DialRequest != nil {
		l = m.DialRequest.Size()
		n += 1 + l + sovProxyservice(uint64(l))
	}
	return n
}
func (m *Frame_ConnectionEstablished) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConnectionEstablished != nil {
		l = m.ConnectionEstablished.Size()
		n += 1 + l + sovProxyservice(uint64(l))
	}
	return n
}
func (m *Frame_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovProxyservice(uint64(l))
	}
	return n
}
func (m *DialRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NodeID)
	if l > 0 {
		n += 1 + l + sovProxyservice(uint64(l))
	}
	l = len(m.TunnelType)
	if l > 0 {
		n += 1 + l + sovProxyservice(uint64(l))
	}
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovProxyservice(uint64(l))
	}
	if m.Destination != nil {
		l = m.Destination.Size()
		n += 1 + l + sovProxyservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NetAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Network)
	if l > 0 {
		n += 1 + l + sovProxyservice(uint64(l))
	}
	l = len(m.Addr)
	if l > 0 {
		n += 1 + l + sovProxyservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Bytes)
	if l > 0 {
		n += 1 + l + sovProxyservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ConnectionEstablished) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovProxyservice(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProxyservice(x uint64) (n int) {
	return sovProxyservice(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Frame) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Frame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Frame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DialRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DialRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &Frame_DialRequest{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionEstablished", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ConnectionEstablished{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &Frame_ConnectionEstablished{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Data{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &Frame_Data{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProxyservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProxyservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DialRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DialRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DialRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TunnelType = github_com_gravitational_teleport_api_types.TunnelType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &NetAddr{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Destination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Destination == nil {
				m.Destination = &NetAddr{}
			}
			if err := m.Destination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProxyservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProxyservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NetAddr) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NetAddr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetAddr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Network = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProxyservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProxyservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Data) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Data: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProxyservice
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProxyservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bytes = append(m.Bytes[:0], dAtA[iNdEx:postIndex]...)
			if m.Bytes == nil {
				m.Bytes = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProxyservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProxyservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectionEstablished) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnectionEstablished: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectionEstablished: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipProxyservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProxyservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipProxyservice(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowProxyservice
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowProxyservice
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthProxyservice
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupProxyservice
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthProxyservice
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthProxyservice        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProxyservice          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProxyservice = fmt.Errorf("proto: unexpected end of group")
)