Source file src/github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1/nodenetsvc.pb.go

Documentation: github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1/nodenetsvc.proto
     3  
     4  package v1
     5  
     6  import (
     7  	context "context"
     8  	fmt "fmt"
     9  	proto "github.com/gogo/protobuf/proto"
    10  	grpc "google.golang.org/grpc"
    11  	codes "google.golang.org/grpc/codes"
    12  	status "google.golang.org/grpc/status"
    13  	io "io"
    14  	math "math"
    15  	math_bits "math/bits"
    16  	reflect "reflect"
    17  	strings "strings"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var _ = proto.Marshal
    22  var _ = fmt.Errorf
    23  var _ = math.Inf
    24  
    25  // This is a compile-time assertion to ensure that this generated file
    26  // is compatible with the proto package it is being compiled against.
    27  // A compilation error at this line likely means your copy of the
    28  // proto package needs to be updated.
    29  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    30  
    31  type RequestType int32
    32  
    33  const (
    34  	RequestType_Setup    RequestType = 0
    35  	RequestType_Teardown RequestType = 1
    36  )
    37  
    38  var RequestType_name = map[int32]string{
    39  	0: "Setup",
    40  	1: "Teardown",
    41  }
    42  
    43  var RequestType_value = map[string]int32{
    44  	"Setup":    0,
    45  	"Teardown": 1,
    46  }
    47  
    48  func (x RequestType) String() string {
    49  	return proto.EnumName(RequestType_name, int32(x))
    50  }
    51  
    52  func (RequestType) EnumDescriptor() ([]byte, []int) {
    53  	return fileDescriptor_912a3d4a179bd2c2, []int{0}
    54  }
    55  
    56  type ConfigureNetworkingRequest struct {
    57  	ContainerID          string      `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
    58  	RequestType          RequestType `protobuf:"varint,2,opt,name=request_type,json=requestType,proto3,enum=nodenetsvc.v1.RequestType" json:"request_type,omitempty"`
    59  	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
    60  	XXX_unrecognized     []byte      `json:"-"`
    61  	XXX_sizecache        int32       `json:"-"`
    62  }
    63  
    64  func (m *ConfigureNetworkingRequest) Reset()      { *m = ConfigureNetworkingRequest{} }
    65  func (*ConfigureNetworkingRequest) ProtoMessage() {}
    66  func (*ConfigureNetworkingRequest) Descriptor() ([]byte, []int) {
    67  	return fileDescriptor_912a3d4a179bd2c2, []int{0}
    68  }
    69  func (m *ConfigureNetworkingRequest) XXX_Unmarshal(b []byte) error {
    70  	return m.Unmarshal(b)
    71  }
    72  func (m *ConfigureNetworkingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    73  	if deterministic {
    74  		return xxx_messageInfo_ConfigureNetworkingRequest.Marshal(b, m, deterministic)
    75  	} else {
    76  		b = b[:cap(b)]
    77  		n, err := m.MarshalToSizedBuffer(b)
    78  		if err != nil {
    79  			return nil, err
    80  		}
    81  		return b[:n], nil
    82  	}
    83  }
    84  func (m *ConfigureNetworkingRequest) XXX_Merge(src proto.Message) {
    85  	xxx_messageInfo_ConfigureNetworkingRequest.Merge(m, src)
    86  }
    87  func (m *ConfigureNetworkingRequest) XXX_Size() int {
    88  	return m.Size()
    89  }
    90  func (m *ConfigureNetworkingRequest) XXX_DiscardUnknown() {
    91  	xxx_messageInfo_ConfigureNetworkingRequest.DiscardUnknown(m)
    92  }
    93  
    94  var xxx_messageInfo_ConfigureNetworkingRequest proto.InternalMessageInfo
    95  
    96  type ConfigureNetworkingResponse struct {
    97  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    98  	XXX_unrecognized     []byte   `json:"-"`
    99  	XXX_sizecache        int32    `json:"-"`
   100  }
   101  
   102  func (m *ConfigureNetworkingResponse) Reset()      { *m = ConfigureNetworkingResponse{} }
   103  func (*ConfigureNetworkingResponse) ProtoMessage() {}
   104  func (*ConfigureNetworkingResponse) Descriptor() ([]byte, []int) {
   105  	return fileDescriptor_912a3d4a179bd2c2, []int{1}
   106  }
   107  func (m *ConfigureNetworkingResponse) XXX_Unmarshal(b []byte) error {
   108  	return m.Unmarshal(b)
   109  }
   110  func (m *ConfigureNetworkingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   111  	if deterministic {
   112  		return xxx_messageInfo_ConfigureNetworkingResponse.Marshal(b, m, deterministic)
   113  	} else {
   114  		b = b[:cap(b)]
   115  		n, err := m.MarshalToSizedBuffer(b)
   116  		if err != nil {
   117  			return nil, err
   118  		}
   119  		return b[:n], nil
   120  	}
   121  }
   122  func (m *ConfigureNetworkingResponse) XXX_Merge(src proto.Message) {
   123  	xxx_messageInfo_ConfigureNetworkingResponse.Merge(m, src)
   124  }
   125  func (m *ConfigureNetworkingResponse) XXX_Size() int {
   126  	return m.Size()
   127  }
   128  func (m *ConfigureNetworkingResponse) XXX_DiscardUnknown() {
   129  	xxx_messageInfo_ConfigureNetworkingResponse.DiscardUnknown(m)
   130  }
   131  
   132  var xxx_messageInfo_ConfigureNetworkingResponse proto.InternalMessageInfo
   133  
   134  type PingNodeNetworkServiceRequest struct {
   135  	PingRequestMessage   string   `protobuf:"bytes,1,opt,name=ping_request_message,json=pingRequestMessage,proto3" json:"ping_request_message,omitempty"`
   136  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   137  	XXX_unrecognized     []byte   `json:"-"`
   138  	XXX_sizecache        int32    `json:"-"`
   139  }
   140  
   141  func (m *PingNodeNetworkServiceRequest) Reset()      { *m = PingNodeNetworkServiceRequest{} }
   142  func (*PingNodeNetworkServiceRequest) ProtoMessage() {}
   143  func (*PingNodeNetworkServiceRequest) Descriptor() ([]byte, []int) {
   144  	return fileDescriptor_912a3d4a179bd2c2, []int{2}
   145  }
   146  func (m *PingNodeNetworkServiceRequest) XXX_Unmarshal(b []byte) error {
   147  	return m.Unmarshal(b)
   148  }
   149  func (m *PingNodeNetworkServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   150  	if deterministic {
   151  		return xxx_messageInfo_PingNodeNetworkServiceRequest.Marshal(b, m, deterministic)
   152  	} else {
   153  		b = b[:cap(b)]
   154  		n, err := m.MarshalToSizedBuffer(b)
   155  		if err != nil {
   156  			return nil, err
   157  		}
   158  		return b[:n], nil
   159  	}
   160  }
   161  func (m *PingNodeNetworkServiceRequest) XXX_Merge(src proto.Message) {
   162  	xxx_messageInfo_PingNodeNetworkServiceRequest.Merge(m, src)
   163  }
   164  func (m *PingNodeNetworkServiceRequest) XXX_Size() int {
   165  	return m.Size()
   166  }
   167  func (m *PingNodeNetworkServiceRequest) XXX_DiscardUnknown() {
   168  	xxx_messageInfo_PingNodeNetworkServiceRequest.DiscardUnknown(m)
   169  }
   170  
   171  var xxx_messageInfo_PingNodeNetworkServiceRequest proto.InternalMessageInfo
   172  
   173  type PingNodeNetworkServiceResponse struct {
   174  	PingResponseMessage  string   `protobuf:"bytes,1,opt,name=ping_response_message,json=pingResponseMessage,proto3" json:"ping_response_message,omitempty"`
   175  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   176  	XXX_unrecognized     []byte   `json:"-"`
   177  	XXX_sizecache        int32    `json:"-"`
   178  }
   179  
   180  func (m *PingNodeNetworkServiceResponse) Reset()      { *m = PingNodeNetworkServiceResponse{} }
   181  func (*PingNodeNetworkServiceResponse) ProtoMessage() {}
   182  func (*PingNodeNetworkServiceResponse) Descriptor() ([]byte, []int) {
   183  	return fileDescriptor_912a3d4a179bd2c2, []int{3}
   184  }
   185  func (m *PingNodeNetworkServiceResponse) XXX_Unmarshal(b []byte) error {
   186  	return m.Unmarshal(b)
   187  }
   188  func (m *PingNodeNetworkServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   189  	if deterministic {
   190  		return xxx_messageInfo_PingNodeNetworkServiceResponse.Marshal(b, m, deterministic)
   191  	} else {
   192  		b = b[:cap(b)]
   193  		n, err := m.MarshalToSizedBuffer(b)
   194  		if err != nil {
   195  			return nil, err
   196  		}
   197  		return b[:n], nil
   198  	}
   199  }
   200  func (m *PingNodeNetworkServiceResponse) XXX_Merge(src proto.Message) {
   201  	xxx_messageInfo_PingNodeNetworkServiceResponse.Merge(m, src)
   202  }
   203  func (m *PingNodeNetworkServiceResponse) XXX_Size() int {
   204  	return m.Size()
   205  }
   206  func (m *PingNodeNetworkServiceResponse) XXX_DiscardUnknown() {
   207  	xxx_messageInfo_PingNodeNetworkServiceResponse.DiscardUnknown(m)
   208  }
   209  
   210  var xxx_messageInfo_PingNodeNetworkServiceResponse proto.InternalMessageInfo
   211  
   212  type ConfigureContainerNetworkingRequest struct {
   213  	RequestType          RequestType `protobuf:"varint,1,opt,name=request_type,json=requestType,proto3,enum=nodenetsvc.v1.RequestType" json:"request_type,omitempty"`
   214  	ContainerID          string      `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
   215  	NetworkNamespaceID   string      `protobuf:"bytes,3,opt,name=network_namespace_id,json=networkNamespaceId,proto3" json:"network_namespace_id,omitempty"`
   216  	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   217  	XXX_unrecognized     []byte      `json:"-"`
   218  	XXX_sizecache        int32       `json:"-"`
   219  }
   220  
   221  func (m *ConfigureContainerNetworkingRequest) Reset()      { *m = ConfigureContainerNetworkingRequest{} }
   222  func (*ConfigureContainerNetworkingRequest) ProtoMessage() {}
   223  func (*ConfigureContainerNetworkingRequest) Descriptor() ([]byte, []int) {
   224  	return fileDescriptor_912a3d4a179bd2c2, []int{4}
   225  }
   226  func (m *ConfigureContainerNetworkingRequest) XXX_Unmarshal(b []byte) error {
   227  	return m.Unmarshal(b)
   228  }
   229  func (m *ConfigureContainerNetworkingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   230  	if deterministic {
   231  		return xxx_messageInfo_ConfigureContainerNetworkingRequest.Marshal(b, m, deterministic)
   232  	} else {
   233  		b = b[:cap(b)]
   234  		n, err := m.MarshalToSizedBuffer(b)
   235  		if err != nil {
   236  			return nil, err
   237  		}
   238  		return b[:n], nil
   239  	}
   240  }
   241  func (m *ConfigureContainerNetworkingRequest) XXX_Merge(src proto.Message) {
   242  	xxx_messageInfo_ConfigureContainerNetworkingRequest.Merge(m, src)
   243  }
   244  func (m *ConfigureContainerNetworkingRequest) XXX_Size() int {
   245  	return m.Size()
   246  }
   247  func (m *ConfigureContainerNetworkingRequest) XXX_DiscardUnknown() {
   248  	xxx_messageInfo_ConfigureContainerNetworkingRequest.DiscardUnknown(m)
   249  }
   250  
   251  var xxx_messageInfo_ConfigureContainerNetworkingRequest proto.InternalMessageInfo
   252  
   253  type ConfigureContainerNetworkingResponse struct {
   254  	Interfaces           []*ContainerNetworkInterface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
   255  	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
   256  	XXX_unrecognized     []byte                       `json:"-"`
   257  	XXX_sizecache        int32                        `json:"-"`
   258  }
   259  
   260  func (m *ConfigureContainerNetworkingResponse) Reset()      { *m = ConfigureContainerNetworkingResponse{} }
   261  func (*ConfigureContainerNetworkingResponse) ProtoMessage() {}
   262  func (*ConfigureContainerNetworkingResponse) Descriptor() ([]byte, []int) {
   263  	return fileDescriptor_912a3d4a179bd2c2, []int{5}
   264  }
   265  func (m *ConfigureContainerNetworkingResponse) XXX_Unmarshal(b []byte) error {
   266  	return m.Unmarshal(b)
   267  }
   268  func (m *ConfigureContainerNetworkingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   269  	if deterministic {
   270  		return xxx_messageInfo_ConfigureContainerNetworkingResponse.Marshal(b, m, deterministic)
   271  	} else {
   272  		b = b[:cap(b)]
   273  		n, err := m.MarshalToSizedBuffer(b)
   274  		if err != nil {
   275  			return nil, err
   276  		}
   277  		return b[:n], nil
   278  	}
   279  }
   280  func (m *ConfigureContainerNetworkingResponse) XXX_Merge(src proto.Message) {
   281  	xxx_messageInfo_ConfigureContainerNetworkingResponse.Merge(m, src)
   282  }
   283  func (m *ConfigureContainerNetworkingResponse) XXX_Size() int {
   284  	return m.Size()
   285  }
   286  func (m *ConfigureContainerNetworkingResponse) XXX_DiscardUnknown() {
   287  	xxx_messageInfo_ConfigureContainerNetworkingResponse.DiscardUnknown(m)
   288  }
   289  
   290  var xxx_messageInfo_ConfigureContainerNetworkingResponse proto.InternalMessageInfo
   291  
   292  type ContainerIPAddress struct {
   293  	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
   294  	Ip                   string   `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"`
   295  	PrefixLength         string   `protobuf:"bytes,4,opt,name=prefix_length,json=prefixLength,proto3" json:"prefix_length,omitempty"`
   296  	DefaultGateway       string   `protobuf:"bytes,5,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
   297  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   298  	XXX_unrecognized     []byte   `json:"-"`
   299  	XXX_sizecache        int32    `json:"-"`
   300  }
   301  
   302  func (m *ContainerIPAddress) Reset()      { *m = ContainerIPAddress{} }
   303  func (*ContainerIPAddress) ProtoMessage() {}
   304  func (*ContainerIPAddress) Descriptor() ([]byte, []int) {
   305  	return fileDescriptor_912a3d4a179bd2c2, []int{6}
   306  }
   307  func (m *ContainerIPAddress) XXX_Unmarshal(b []byte) error {
   308  	return m.Unmarshal(b)
   309  }
   310  func (m *ContainerIPAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   311  	if deterministic {
   312  		return xxx_messageInfo_ContainerIPAddress.Marshal(b, m, deterministic)
   313  	} else {
   314  		b = b[:cap(b)]
   315  		n, err := m.MarshalToSizedBuffer(b)
   316  		if err != nil {
   317  			return nil, err
   318  		}
   319  		return b[:n], nil
   320  	}
   321  }
   322  func (m *ContainerIPAddress) XXX_Merge(src proto.Message) {
   323  	xxx_messageInfo_ContainerIPAddress.Merge(m, src)
   324  }
   325  func (m *ContainerIPAddress) XXX_Size() int {
   326  	return m.Size()
   327  }
   328  func (m *ContainerIPAddress) XXX_DiscardUnknown() {
   329  	xxx_messageInfo_ContainerIPAddress.DiscardUnknown(m)
   330  }
   331  
   332  var xxx_messageInfo_ContainerIPAddress proto.InternalMessageInfo
   333  
   334  type ContainerNetworkInterface struct {
   335  	Name                 string                `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
   336  	MacAddress           string                `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
   337  	NetworkNamespaceID   string                `protobuf:"bytes,3,opt,name=network_namespace_id,json=networkNamespaceId,proto3" json:"network_namespace_id,omitempty"`
   338  	Ipaddresses          []*ContainerIPAddress `protobuf:"bytes,4,rep,name=ipaddresses,proto3" json:"ipaddresses,omitempty"`
   339  	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
   340  	XXX_unrecognized     []byte                `json:"-"`
   341  	XXX_sizecache        int32                 `json:"-"`
   342  }
   343  
   344  func (m *ContainerNetworkInterface) Reset()      { *m = ContainerNetworkInterface{} }
   345  func (*ContainerNetworkInterface) ProtoMessage() {}
   346  func (*ContainerNetworkInterface) Descriptor() ([]byte, []int) {
   347  	return fileDescriptor_912a3d4a179bd2c2, []int{7}
   348  }
   349  func (m *ContainerNetworkInterface) XXX_Unmarshal(b []byte) error {
   350  	return m.Unmarshal(b)
   351  }
   352  func (m *ContainerNetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   353  	if deterministic {
   354  		return xxx_messageInfo_ContainerNetworkInterface.Marshal(b, m, deterministic)
   355  	} else {
   356  		b = b[:cap(b)]
   357  		n, err := m.MarshalToSizedBuffer(b)
   358  		if err != nil {
   359  			return nil, err
   360  		}
   361  		return b[:n], nil
   362  	}
   363  }
   364  func (m *ContainerNetworkInterface) XXX_Merge(src proto.Message) {
   365  	xxx_messageInfo_ContainerNetworkInterface.Merge(m, src)
   366  }
   367  func (m *ContainerNetworkInterface) XXX_Size() int {
   368  	return m.Size()
   369  }
   370  func (m *ContainerNetworkInterface) XXX_DiscardUnknown() {
   371  	xxx_messageInfo_ContainerNetworkInterface.DiscardUnknown(m)
   372  }
   373  
   374  var xxx_messageInfo_ContainerNetworkInterface proto.InternalMessageInfo
   375  
   376  type GetHostLocalIpAddressRequest struct {
   377  	ContainerID          string   `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
   378  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   379  	XXX_unrecognized     []byte   `json:"-"`
   380  	XXX_sizecache        int32    `json:"-"`
   381  }
   382  
   383  func (m *GetHostLocalIpAddressRequest) Reset()      { *m = GetHostLocalIpAddressRequest{} }
   384  func (*GetHostLocalIpAddressRequest) ProtoMessage() {}
   385  func (*GetHostLocalIpAddressRequest) Descriptor() ([]byte, []int) {
   386  	return fileDescriptor_912a3d4a179bd2c2, []int{8}
   387  }
   388  func (m *GetHostLocalIpAddressRequest) XXX_Unmarshal(b []byte) error {
   389  	return m.Unmarshal(b)
   390  }
   391  func (m *GetHostLocalIpAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   392  	if deterministic {
   393  		return xxx_messageInfo_GetHostLocalIpAddressRequest.Marshal(b, m, deterministic)
   394  	} else {
   395  		b = b[:cap(b)]
   396  		n, err := m.MarshalToSizedBuffer(b)
   397  		if err != nil {
   398  			return nil, err
   399  		}
   400  		return b[:n], nil
   401  	}
   402  }
   403  func (m *GetHostLocalIpAddressRequest) XXX_Merge(src proto.Message) {
   404  	xxx_messageInfo_GetHostLocalIpAddressRequest.Merge(m, src)
   405  }
   406  func (m *GetHostLocalIpAddressRequest) XXX_Size() int {
   407  	return m.Size()
   408  }
   409  func (m *GetHostLocalIpAddressRequest) XXX_DiscardUnknown() {
   410  	xxx_messageInfo_GetHostLocalIpAddressRequest.DiscardUnknown(m)
   411  }
   412  
   413  var xxx_messageInfo_GetHostLocalIpAddressRequest proto.InternalMessageInfo
   414  
   415  type GetHostLocalIpAddressResponse struct {
   416  	IpAddr               string   `protobuf:"bytes,1,opt,name=ip_addr,json=ipAddr,proto3" json:"ip_addr,omitempty"`
   417  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   418  	XXX_unrecognized     []byte   `json:"-"`
   419  	XXX_sizecache        int32    `json:"-"`
   420  }
   421  
   422  func (m *GetHostLocalIpAddressResponse) Reset()      { *m = GetHostLocalIpAddressResponse{} }
   423  func (*GetHostLocalIpAddressResponse) ProtoMessage() {}
   424  func (*GetHostLocalIpAddressResponse) Descriptor() ([]byte, []int) {
   425  	return fileDescriptor_912a3d4a179bd2c2, []int{9}
   426  }
   427  func (m *GetHostLocalIpAddressResponse) XXX_Unmarshal(b []byte) error {
   428  	return m.Unmarshal(b)
   429  }
   430  func (m *GetHostLocalIpAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   431  	if deterministic {
   432  		return xxx_messageInfo_GetHostLocalIpAddressResponse.Marshal(b, m, deterministic)
   433  	} else {
   434  		b = b[:cap(b)]
   435  		n, err := m.MarshalToSizedBuffer(b)
   436  		if err != nil {
   437  			return nil, err
   438  		}
   439  		return b[:n], nil
   440  	}
   441  }
   442  func (m *GetHostLocalIpAddressResponse) XXX_Merge(src proto.Message) {
   443  	xxx_messageInfo_GetHostLocalIpAddressResponse.Merge(m, src)
   444  }
   445  func (m *GetHostLocalIpAddressResponse) XXX_Size() int {
   446  	return m.Size()
   447  }
   448  func (m *GetHostLocalIpAddressResponse) XXX_DiscardUnknown() {
   449  	xxx_messageInfo_GetHostLocalIpAddressResponse.DiscardUnknown(m)
   450  }
   451  
   452  var xxx_messageInfo_GetHostLocalIpAddressResponse proto.InternalMessageInfo
   453  
   454  func init() {
   455  	proto.RegisterEnum("nodenetsvc.v1.RequestType", RequestType_name, RequestType_value)
   456  	proto.RegisterType((*ConfigureNetworkingRequest)(nil), "nodenetsvc.v1.ConfigureNetworkingRequest")
   457  	proto.RegisterType((*ConfigureNetworkingResponse)(nil), "nodenetsvc.v1.ConfigureNetworkingResponse")
   458  	proto.RegisterType((*PingNodeNetworkServiceRequest)(nil), "nodenetsvc.v1.PingNodeNetworkServiceRequest")
   459  	proto.RegisterType((*PingNodeNetworkServiceResponse)(nil), "nodenetsvc.v1.PingNodeNetworkServiceResponse")
   460  	proto.RegisterType((*ConfigureContainerNetworkingRequest)(nil), "nodenetsvc.v1.ConfigureContainerNetworkingRequest")
   461  	proto.RegisterType((*ConfigureContainerNetworkingResponse)(nil), "nodenetsvc.v1.ConfigureContainerNetworkingResponse")
   462  	proto.RegisterType((*ContainerIPAddress)(nil), "nodenetsvc.v1.ContainerIPAddress")
   463  	proto.RegisterType((*ContainerNetworkInterface)(nil), "nodenetsvc.v1.ContainerNetworkInterface")
   464  	proto.RegisterType((*GetHostLocalIpAddressRequest)(nil), "nodenetsvc.v1.GetHostLocalIpAddressRequest")
   465  	proto.RegisterType((*GetHostLocalIpAddressResponse)(nil), "nodenetsvc.v1.GetHostLocalIpAddressResponse")
   466  }
   467  
   468  func init() {
   469  	proto.RegisterFile("github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1/nodenetsvc.proto", fileDescriptor_912a3d4a179bd2c2)
   470  }
   471  
   472  var fileDescriptor_912a3d4a179bd2c2 = []byte{
   473  	// 703 bytes of a gzipped FileDescriptorProto
   474  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4b, 0x4f, 0x1b, 0x3b,
   475  	0x14, 0xc6, 0xe1, 0x75, 0x39, 0x09, 0x0f, 0x99, 0xc7, 0xcd, 0xcd, 0x85, 0xc0, 0x1d, 0xae, 0xda,
   476  	0x94, 0xd2, 0xa4, 0x04, 0xa9, 0xea, 0xa6, 0x8b, 0x02, 0x12, 0x44, 0x02, 0x44, 0x07, 0x56, 0xdd,
   477  	0x44, 0xc3, 0x8c, 0x33, 0xb1, 0x48, 0x6c, 0xd7, 0x76, 0x02, 0xd9, 0x75, 0xd7, 0x4d, 0xa5, 0xfe,
   478  	0x2d, 0x96, 0x5d, 0x76, 0x45, 0x4b, 0xfe, 0x44, 0xb7, 0x15, 0xf3, 0x08, 0xe9, 0x24, 0x13, 0x05,
   479  	0xd4, 0xdd, 0xf8, 0x3c, 0xbf, 0xef, 0x3b, 0xe3, 0x63, 0xd8, 0x77, 0xa9, 0xae, 0x36, 0xce, 0xf3,
   480  	0x36, 0xaf, 0x17, 0x8e, 0xa8, 0x2d, 0xb9, 0xe2, 0x15, 0x5d, 0xa8, 0xda, 0x4a, 0x55, 0x69, 0xbd,
   481  	0x20, 0x2e, 0xdc, 0x02, 0xb3, 0x85, 0xe4, 0x57, 0xad, 0x02, 0xe3, 0x0e, 0x61, 0x44, 0xab, 0xa6,
   482  	0x5d, 0x68, 0x6e, 0x75, 0x9d, 0xf2, 0x42, 0x72, 0xcd, 0xf1, 0x74, 0x97, 0xa5, 0xb9, 0x65, 0x7c,
   483  	0x41, 0x90, 0xd9, 0xe5, 0xac, 0x42, 0xdd, 0x86, 0x24, 0xc7, 0x44, 0x5f, 0x72, 0x79, 0x41, 0x99,
   484  	0x6b, 0x92, 0x0f, 0x0d, 0xa2, 0x34, 0x2e, 0x42, 0xca, 0xe6, 0x4c, 0x5b, 0x94, 0x11, 0x59, 0xa6,
   485  	0x4e, 0x1a, 0xad, 0xa1, 0xdc, 0xd4, 0xce, 0x6c, 0xfb, 0x66, 0x35, 0xb9, 0x1b, 0xda, 0x4b, 0x7b,
   486  	0x66, 0xb2, 0x13, 0x54, 0x72, 0xf0, 0x1b, 0x48, 0x49, 0x3f, 0xbd, 0xac, 0x5b, 0x82, 0xa4, 0x13,
   487  	0x6b, 0x28, 0x37, 0x53, 0xcc, 0xe4, 0x7f, 0x6b, 0x9c, 0x0f, 0x3a, 0x9c, 0xb5, 0x04, 0x31, 0x93,
   488  	0xf2, 0xfe, 0x60, 0xac, 0xc0, 0xbf, 0x7d, 0x01, 0x29, 0xc1, 0x99, 0x22, 0xc6, 0x3b, 0x58, 0x39,
   489  	0xa1, 0xcc, 0x3d, 0xe6, 0x4e, 0xe8, 0x3d, 0x25, 0xb2, 0x49, 0x6d, 0x12, 0x42, 0x7e, 0x09, 0x0b,
   490  	0x82, 0x32, 0xb7, 0x1c, 0x62, 0xa8, 0x13, 0xa5, 0x2c, 0x97, 0xf8, 0xd0, 0x4d, 0x2c, 0xee, 0xd9,
   491  	0x1d, 0xf9, 0x1e, 0xe3, 0x0c, 0xb2, 0x71, 0x25, 0xfd, 0xa6, 0xb8, 0x08, 0x8b, 0x41, 0x4d, 0xdf,
   492  	0x10, 0x29, 0x3a, 0x2f, 0xba, 0x10, 0x86, 0x55, 0xdb, 0x08, 0xd6, 0x3b, 0x44, 0x3a, 0x62, 0xf5,
   493  	0x4a, 0x1c, 0x95, 0x0b, 0x3d, 0x48, 0xae, 0x9e, 0x09, 0x25, 0x86, 0x98, 0xd0, 0x01, 0x2c, 0x30,
   494  	0x1f, 0x47, 0x99, 0x59, 0x75, 0xa2, 0x84, 0x65, 0x93, 0xbb, 0xdc, 0x51, 0x2f, 0x77, 0xa9, 0x7d,
   495  	0xb3, 0x8a, 0x03, 0x9c, 0xc7, 0xa1, 0xbb, 0xb4, 0x67, 0x62, 0x16, 0xb5, 0x39, 0x86, 0x80, 0xff,
   496  	0x07, 0x73, 0x0c, 0x04, 0x3c, 0x00, 0xa0, 0x4c, 0x13, 0x59, 0xb1, 0x6c, 0xa2, 0xd2, 0x68, 0x6d,
   497  	0x34, 0x97, 0x2c, 0xe6, 0x22, 0x14, 0xa3, 0xf9, 0xa5, 0x30, 0xc1, 0xec, 0xca, 0x35, 0x3e, 0x23,
   498  	0xc0, 0xf7, 0xc4, 0x4e, 0xde, 0x3a, 0x8e, 0x24, 0x4a, 0xe1, 0x34, 0x4c, 0x36, 0x89, 0x54, 0x94,
   499  	0xb3, 0x60, 0x26, 0xe1, 0x11, 0xcf, 0x40, 0x82, 0x0a, 0x9f, 0x9a, 0x99, 0xa0, 0x02, 0xaf, 0xc3,
   500  	0xb4, 0x90, 0xa4, 0x42, 0xaf, 0xca, 0x35, 0xc2, 0x5c, 0x5d, 0x4d, 0x8f, 0x79, 0xae, 0x94, 0x6f,
   501  	0x3c, 0xf4, 0x6c, 0xf8, 0x29, 0xcc, 0x3a, 0xa4, 0x62, 0x35, 0x6a, 0xba, 0xec, 0x5a, 0x9a, 0x5c,
   502  	0x5a, 0xad, 0xf4, 0xb8, 0x17, 0x36, 0x13, 0x98, 0xf7, 0x7d, 0xab, 0xf1, 0x1d, 0xc1, 0x3f, 0xb1,
   503  	0xc0, 0x31, 0x86, 0xb1, 0x3b, 0x81, 0x03, 0x48, 0xde, 0x37, 0x5e, 0x85, 0x64, 0xdd, 0xb2, 0xcb,
   504  	0x96, 0x0f, 0xdc, 0x9f, 0x97, 0x09, 0x75, 0xcb, 0x0e, 0xa9, 0xfc, 0xb1, 0xe9, 0xe0, 0x5d, 0x48,
   505  	0x52, 0x11, 0x34, 0x22, 0x2a, 0x3d, 0xe6, 0xc9, 0xfe, 0x5f, 0x9c, 0xec, 0x1d, 0x31, 0xcd, 0xee,
   506  	0x2c, 0xc3, 0x84, 0xe5, 0x7d, 0xa2, 0x0f, 0xb8, 0xd2, 0x87, 0xdc, 0xb6, 0x6a, 0x25, 0x11, 0x46,
   507  	0x3d, 0x7e, 0x45, 0x18, 0xaf, 0x61, 0x25, 0xa6, 0x66, 0xf0, 0xbf, 0xfc, 0x0d, 0x93, 0x54, 0x78,
   508  	0x1a, 0x05, 0xda, 0x4d, 0x50, 0x2f, 0x66, 0xe3, 0x09, 0x24, 0xbb, 0xae, 0x02, 0x9e, 0x82, 0xf1,
   509  	0x53, 0xa2, 0x1b, 0x62, 0x6e, 0x04, 0xa7, 0xe0, 0xaf, 0x33, 0x62, 0x49, 0x87, 0x5f, 0xb2, 0x39,
   510  	0x54, 0xfc, 0x39, 0x0a, 0xb8, 0xf7, 0x42, 0xe3, 0x1a, 0xcc, 0xf7, 0x59, 0x2e, 0xf8, 0x59, 0xaf,
   511  	0x26, 0x31, 0x1b, 0x31, 0xb3, 0x31, 0x4c, 0x68, 0xc0, 0xe2, 0x13, 0x82, 0xe5, 0x41, 0xd7, 0x03,
   512  	0x17, 0xe3, 0x8a, 0xc5, 0xef, 0x8b, 0xcc, 0xf6, 0x83, 0x72, 0x02, 0x24, 0x0d, 0x58, 0xea, 0xbf,
   513  	0xe2, 0xf0, 0x66, 0xa4, 0xdc, 0xc0, 0xe5, 0x9a, 0x79, 0x31, 0x64, 0x74, 0xd0, 0x56, 0xc2, 0x62,
   514  	0xdf, 0x39, 0xe3, 0xe7, 0x91, 0x3a, 0x83, 0xfe, 0xb0, 0xcc, 0xe6, 0x70, 0xc1, 0x7e, 0xcf, 0x9d,
   515  	0x93, 0xeb, 0xdb, 0xec, 0xc8, 0xb7, 0xdb, 0xec, 0xc8, 0xc7, 0x76, 0x16, 0x5d, 0xb7, 0xb3, 0xe8,
   516  	0x6b, 0x3b, 0x8b, 0x7e, 0xb4, 0xb3, 0xe8, 0xfd, 0xab, 0xc7, 0xbd, 0xa1, 0xe7, 0x13, 0xde, 0xcb,
   517  	0xb9, 0xfd, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x82, 0x7f, 0x15, 0x14, 0x84, 0x07, 0x00, 0x00,
   518  }
   519  
   520  // Reference imports to suppress errors if they are not otherwise used.
   521  var _ context.Context
   522  var _ grpc.ClientConn
   523  
   524  // This is a compile-time assertion to ensure that this generated file
   525  // is compatible with the grpc package it is being compiled against.
   526  const _ = grpc.SupportPackageIsVersion4
   527  
   528  // NodeNetworkServiceClient is the client API for NodeNetworkService service.
   529  //
   530  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
   531  type NodeNetworkServiceClient interface {
   532  	ConfigureNetworking(ctx context.Context, in *ConfigureNetworkingRequest, opts ...grpc.CallOption) (*ConfigureNetworkingResponse, error)
   533  	ConfigureContainerNetworking(ctx context.Context, in *ConfigureContainerNetworkingRequest, opts ...grpc.CallOption) (*ConfigureContainerNetworkingResponse, error)
   534  	PingNodeNetworkService(ctx context.Context, in *PingNodeNetworkServiceRequest, opts ...grpc.CallOption) (*PingNodeNetworkServiceResponse, error)
   535  	GetHostLocalIpAddress(ctx context.Context, in *GetHostLocalIpAddressRequest, opts ...grpc.CallOption) (*GetHostLocalIpAddressResponse, error)
   536  }
   537  
   538  type nodeNetworkServiceClient struct {
   539  	cc *grpc.ClientConn
   540  }
   541  
   542  func NewNodeNetworkServiceClient(cc *grpc.ClientConn) NodeNetworkServiceClient {
   543  	return &nodeNetworkServiceClient{cc}
   544  }
   545  
   546  func (c *nodeNetworkServiceClient) ConfigureNetworking(ctx context.Context, in *ConfigureNetworkingRequest, opts ...grpc.CallOption) (*ConfigureNetworkingResponse, error) {
   547  	out := new(ConfigureNetworkingResponse)
   548  	err := c.cc.Invoke(ctx, "/nodenetsvc.v1.NodeNetworkService/ConfigureNetworking", in, out, opts...)
   549  	if err != nil {
   550  		return nil, err
   551  	}
   552  	return out, nil
   553  }
   554  
   555  func (c *nodeNetworkServiceClient) ConfigureContainerNetworking(ctx context.Context, in *ConfigureContainerNetworkingRequest, opts ...grpc.CallOption) (*ConfigureContainerNetworkingResponse, error) {
   556  	out := new(ConfigureContainerNetworkingResponse)
   557  	err := c.cc.Invoke(ctx, "/nodenetsvc.v1.NodeNetworkService/ConfigureContainerNetworking", in, out, opts...)
   558  	if err != nil {
   559  		return nil, err
   560  	}
   561  	return out, nil
   562  }
   563  
   564  func (c *nodeNetworkServiceClient) PingNodeNetworkService(ctx context.Context, in *PingNodeNetworkServiceRequest, opts ...grpc.CallOption) (*PingNodeNetworkServiceResponse, error) {
   565  	out := new(PingNodeNetworkServiceResponse)
   566  	err := c.cc.Invoke(ctx, "/nodenetsvc.v1.NodeNetworkService/PingNodeNetworkService", in, out, opts...)
   567  	if err != nil {
   568  		return nil, err
   569  	}
   570  	return out, nil
   571  }
   572  
   573  func (c *nodeNetworkServiceClient) GetHostLocalIpAddress(ctx context.Context, in *GetHostLocalIpAddressRequest, opts ...grpc.CallOption) (*GetHostLocalIpAddressResponse, error) {
   574  	out := new(GetHostLocalIpAddressResponse)
   575  	err := c.cc.Invoke(ctx, "/nodenetsvc.v1.NodeNetworkService/GetHostLocalIpAddress", in, out, opts...)
   576  	if err != nil {
   577  		return nil, err
   578  	}
   579  	return out, nil
   580  }
   581  
   582  // NodeNetworkServiceServer is the server API for NodeNetworkService service.
   583  type NodeNetworkServiceServer interface {
   584  	ConfigureNetworking(context.Context, *ConfigureNetworkingRequest) (*ConfigureNetworkingResponse, error)
   585  	ConfigureContainerNetworking(context.Context, *ConfigureContainerNetworkingRequest) (*ConfigureContainerNetworkingResponse, error)
   586  	PingNodeNetworkService(context.Context, *PingNodeNetworkServiceRequest) (*PingNodeNetworkServiceResponse, error)
   587  	GetHostLocalIpAddress(context.Context, *GetHostLocalIpAddressRequest) (*GetHostLocalIpAddressResponse, error)
   588  }
   589  
   590  // UnimplementedNodeNetworkServiceServer can be embedded to have forward compatible implementations.
   591  type UnimplementedNodeNetworkServiceServer struct {
   592  }
   593  
   594  func (*UnimplementedNodeNetworkServiceServer) ConfigureNetworking(ctx context.Context, req *ConfigureNetworkingRequest) (*ConfigureNetworkingResponse, error) {
   595  	return nil, status.Errorf(codes.Unimplemented, "method ConfigureNetworking not implemented")
   596  }
   597  func (*UnimplementedNodeNetworkServiceServer) ConfigureContainerNetworking(ctx context.Context, req *ConfigureContainerNetworkingRequest) (*ConfigureContainerNetworkingResponse, error) {
   598  	return nil, status.Errorf(codes.Unimplemented, "method ConfigureContainerNetworking not implemented")
   599  }
   600  func (*UnimplementedNodeNetworkServiceServer) PingNodeNetworkService(ctx context.Context, req *PingNodeNetworkServiceRequest) (*PingNodeNetworkServiceResponse, error) {
   601  	return nil, status.Errorf(codes.Unimplemented, "method PingNodeNetworkService not implemented")
   602  }
   603  func (*UnimplementedNodeNetworkServiceServer) GetHostLocalIpAddress(ctx context.Context, req *GetHostLocalIpAddressRequest) (*GetHostLocalIpAddressResponse, error) {
   604  	return nil, status.Errorf(codes.Unimplemented, "method GetHostLocalIpAddress not implemented")
   605  }
   606  
   607  func RegisterNodeNetworkServiceServer(s *grpc.Server, srv NodeNetworkServiceServer) {
   608  	s.RegisterService(&_NodeNetworkService_serviceDesc, srv)
   609  }
   610  
   611  func _NodeNetworkService_ConfigureNetworking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   612  	in := new(ConfigureNetworkingRequest)
   613  	if err := dec(in); err != nil {
   614  		return nil, err
   615  	}
   616  	if interceptor == nil {
   617  		return srv.(NodeNetworkServiceServer).ConfigureNetworking(ctx, in)
   618  	}
   619  	info := &grpc.UnaryServerInfo{
   620  		Server:     srv,
   621  		FullMethod: "/nodenetsvc.v1.NodeNetworkService/ConfigureNetworking",
   622  	}
   623  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   624  		return srv.(NodeNetworkServiceServer).ConfigureNetworking(ctx, req.(*ConfigureNetworkingRequest))
   625  	}
   626  	return interceptor(ctx, in, info, handler)
   627  }
   628  
   629  func _NodeNetworkService_ConfigureContainerNetworking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   630  	in := new(ConfigureContainerNetworkingRequest)
   631  	if err := dec(in); err != nil {
   632  		return nil, err
   633  	}
   634  	if interceptor == nil {
   635  		return srv.(NodeNetworkServiceServer).ConfigureContainerNetworking(ctx, in)
   636  	}
   637  	info := &grpc.UnaryServerInfo{
   638  		Server:     srv,
   639  		FullMethod: "/nodenetsvc.v1.NodeNetworkService/ConfigureContainerNetworking",
   640  	}
   641  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   642  		return srv.(NodeNetworkServiceServer).ConfigureContainerNetworking(ctx, req.(*ConfigureContainerNetworkingRequest))
   643  	}
   644  	return interceptor(ctx, in, info, handler)
   645  }
   646  
   647  func _NodeNetworkService_PingNodeNetworkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   648  	in := new(PingNodeNetworkServiceRequest)
   649  	if err := dec(in); err != nil {
   650  		return nil, err
   651  	}
   652  	if interceptor == nil {
   653  		return srv.(NodeNetworkServiceServer).PingNodeNetworkService(ctx, in)
   654  	}
   655  	info := &grpc.UnaryServerInfo{
   656  		Server:     srv,
   657  		FullMethod: "/nodenetsvc.v1.NodeNetworkService/PingNodeNetworkService",
   658  	}
   659  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   660  		return srv.(NodeNetworkServiceServer).PingNodeNetworkService(ctx, req.(*PingNodeNetworkServiceRequest))
   661  	}
   662  	return interceptor(ctx, in, info, handler)
   663  }
   664  
   665  func _NodeNetworkService_GetHostLocalIpAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   666  	in := new(GetHostLocalIpAddressRequest)
   667  	if err := dec(in); err != nil {
   668  		return nil, err
   669  	}
   670  	if interceptor == nil {
   671  		return srv.(NodeNetworkServiceServer).GetHostLocalIpAddress(ctx, in)
   672  	}
   673  	info := &grpc.UnaryServerInfo{
   674  		Server:     srv,
   675  		FullMethod: "/nodenetsvc.v1.NodeNetworkService/GetHostLocalIpAddress",
   676  	}
   677  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   678  		return srv.(NodeNetworkServiceServer).GetHostLocalIpAddress(ctx, req.(*GetHostLocalIpAddressRequest))
   679  	}
   680  	return interceptor(ctx, in, info, handler)
   681  }
   682  
   683  var _NodeNetworkService_serviceDesc = grpc.ServiceDesc{
   684  	ServiceName: "nodenetsvc.v1.NodeNetworkService",
   685  	HandlerType: (*NodeNetworkServiceServer)(nil),
   686  	Methods: []grpc.MethodDesc{
   687  		{
   688  			MethodName: "ConfigureNetworking",
   689  			Handler:    _NodeNetworkService_ConfigureNetworking_Handler,
   690  		},
   691  		{
   692  			MethodName: "ConfigureContainerNetworking",
   693  			Handler:    _NodeNetworkService_ConfigureContainerNetworking_Handler,
   694  		},
   695  		{
   696  			MethodName: "PingNodeNetworkService",
   697  			Handler:    _NodeNetworkService_PingNodeNetworkService_Handler,
   698  		},
   699  		{
   700  			MethodName: "GetHostLocalIpAddress",
   701  			Handler:    _NodeNetworkService_GetHostLocalIpAddress_Handler,
   702  		},
   703  	},
   704  	Streams:  []grpc.StreamDesc{},
   705  	Metadata: "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1/nodenetsvc.proto",
   706  }
   707  
   708  func (m *ConfigureNetworkingRequest) Marshal() (dAtA []byte, err error) {
   709  	size := m.Size()
   710  	dAtA = make([]byte, size)
   711  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   712  	if err != nil {
   713  		return nil, err
   714  	}
   715  	return dAtA[:n], nil
   716  }
   717  
   718  func (m *ConfigureNetworkingRequest) MarshalTo(dAtA []byte) (int, error) {
   719  	size := m.Size()
   720  	return m.MarshalToSizedBuffer(dAtA[:size])
   721  }
   722  
   723  func (m *ConfigureNetworkingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   724  	i := len(dAtA)
   725  	_ = i
   726  	var l int
   727  	_ = l
   728  	if m.XXX_unrecognized != nil {
   729  		i -= len(m.XXX_unrecognized)
   730  		copy(dAtA[i:], m.XXX_unrecognized)
   731  	}
   732  	if m.RequestType != 0 {
   733  		i = encodeVarintNodenetsvc(dAtA, i, uint64(m.RequestType))
   734  		i--
   735  		dAtA[i] = 0x10
   736  	}
   737  	if len(m.ContainerID) > 0 {
   738  		i -= len(m.ContainerID)
   739  		copy(dAtA[i:], m.ContainerID)
   740  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID)))
   741  		i--
   742  		dAtA[i] = 0xa
   743  	}
   744  	return len(dAtA) - i, nil
   745  }
   746  
   747  func (m *ConfigureNetworkingResponse) Marshal() (dAtA []byte, err error) {
   748  	size := m.Size()
   749  	dAtA = make([]byte, size)
   750  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   751  	if err != nil {
   752  		return nil, err
   753  	}
   754  	return dAtA[:n], nil
   755  }
   756  
   757  func (m *ConfigureNetworkingResponse) MarshalTo(dAtA []byte) (int, error) {
   758  	size := m.Size()
   759  	return m.MarshalToSizedBuffer(dAtA[:size])
   760  }
   761  
   762  func (m *ConfigureNetworkingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   763  	i := len(dAtA)
   764  	_ = i
   765  	var l int
   766  	_ = l
   767  	if m.XXX_unrecognized != nil {
   768  		i -= len(m.XXX_unrecognized)
   769  		copy(dAtA[i:], m.XXX_unrecognized)
   770  	}
   771  	return len(dAtA) - i, nil
   772  }
   773  
   774  func (m *PingNodeNetworkServiceRequest) Marshal() (dAtA []byte, err error) {
   775  	size := m.Size()
   776  	dAtA = make([]byte, size)
   777  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   778  	if err != nil {
   779  		return nil, err
   780  	}
   781  	return dAtA[:n], nil
   782  }
   783  
   784  func (m *PingNodeNetworkServiceRequest) MarshalTo(dAtA []byte) (int, error) {
   785  	size := m.Size()
   786  	return m.MarshalToSizedBuffer(dAtA[:size])
   787  }
   788  
   789  func (m *PingNodeNetworkServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   790  	i := len(dAtA)
   791  	_ = i
   792  	var l int
   793  	_ = l
   794  	if m.XXX_unrecognized != nil {
   795  		i -= len(m.XXX_unrecognized)
   796  		copy(dAtA[i:], m.XXX_unrecognized)
   797  	}
   798  	if len(m.PingRequestMessage) > 0 {
   799  		i -= len(m.PingRequestMessage)
   800  		copy(dAtA[i:], m.PingRequestMessage)
   801  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PingRequestMessage)))
   802  		i--
   803  		dAtA[i] = 0xa
   804  	}
   805  	return len(dAtA) - i, nil
   806  }
   807  
   808  func (m *PingNodeNetworkServiceResponse) Marshal() (dAtA []byte, err error) {
   809  	size := m.Size()
   810  	dAtA = make([]byte, size)
   811  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   812  	if err != nil {
   813  		return nil, err
   814  	}
   815  	return dAtA[:n], nil
   816  }
   817  
   818  func (m *PingNodeNetworkServiceResponse) MarshalTo(dAtA []byte) (int, error) {
   819  	size := m.Size()
   820  	return m.MarshalToSizedBuffer(dAtA[:size])
   821  }
   822  
   823  func (m *PingNodeNetworkServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   824  	i := len(dAtA)
   825  	_ = i
   826  	var l int
   827  	_ = l
   828  	if m.XXX_unrecognized != nil {
   829  		i -= len(m.XXX_unrecognized)
   830  		copy(dAtA[i:], m.XXX_unrecognized)
   831  	}
   832  	if len(m.PingResponseMessage) > 0 {
   833  		i -= len(m.PingResponseMessage)
   834  		copy(dAtA[i:], m.PingResponseMessage)
   835  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PingResponseMessage)))
   836  		i--
   837  		dAtA[i] = 0xa
   838  	}
   839  	return len(dAtA) - i, nil
   840  }
   841  
   842  func (m *ConfigureContainerNetworkingRequest) Marshal() (dAtA []byte, err error) {
   843  	size := m.Size()
   844  	dAtA = make([]byte, size)
   845  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   846  	if err != nil {
   847  		return nil, err
   848  	}
   849  	return dAtA[:n], nil
   850  }
   851  
   852  func (m *ConfigureContainerNetworkingRequest) MarshalTo(dAtA []byte) (int, error) {
   853  	size := m.Size()
   854  	return m.MarshalToSizedBuffer(dAtA[:size])
   855  }
   856  
   857  func (m *ConfigureContainerNetworkingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   858  	i := len(dAtA)
   859  	_ = i
   860  	var l int
   861  	_ = l
   862  	if m.XXX_unrecognized != nil {
   863  		i -= len(m.XXX_unrecognized)
   864  		copy(dAtA[i:], m.XXX_unrecognized)
   865  	}
   866  	if len(m.NetworkNamespaceID) > 0 {
   867  		i -= len(m.NetworkNamespaceID)
   868  		copy(dAtA[i:], m.NetworkNamespaceID)
   869  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.NetworkNamespaceID)))
   870  		i--
   871  		dAtA[i] = 0x1a
   872  	}
   873  	if len(m.ContainerID) > 0 {
   874  		i -= len(m.ContainerID)
   875  		copy(dAtA[i:], m.ContainerID)
   876  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID)))
   877  		i--
   878  		dAtA[i] = 0x12
   879  	}
   880  	if m.RequestType != 0 {
   881  		i = encodeVarintNodenetsvc(dAtA, i, uint64(m.RequestType))
   882  		i--
   883  		dAtA[i] = 0x8
   884  	}
   885  	return len(dAtA) - i, nil
   886  }
   887  
   888  func (m *ConfigureContainerNetworkingResponse) Marshal() (dAtA []byte, err error) {
   889  	size := m.Size()
   890  	dAtA = make([]byte, size)
   891  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   892  	if err != nil {
   893  		return nil, err
   894  	}
   895  	return dAtA[:n], nil
   896  }
   897  
   898  func (m *ConfigureContainerNetworkingResponse) MarshalTo(dAtA []byte) (int, error) {
   899  	size := m.Size()
   900  	return m.MarshalToSizedBuffer(dAtA[:size])
   901  }
   902  
   903  func (m *ConfigureContainerNetworkingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   904  	i := len(dAtA)
   905  	_ = i
   906  	var l int
   907  	_ = l
   908  	if m.XXX_unrecognized != nil {
   909  		i -= len(m.XXX_unrecognized)
   910  		copy(dAtA[i:], m.XXX_unrecognized)
   911  	}
   912  	if len(m.Interfaces) > 0 {
   913  		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
   914  			{
   915  				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   916  				if err != nil {
   917  					return 0, err
   918  				}
   919  				i -= size
   920  				i = encodeVarintNodenetsvc(dAtA, i, uint64(size))
   921  			}
   922  			i--
   923  			dAtA[i] = 0xa
   924  		}
   925  	}
   926  	return len(dAtA) - i, nil
   927  }
   928  
   929  func (m *ContainerIPAddress) Marshal() (dAtA []byte, err error) {
   930  	size := m.Size()
   931  	dAtA = make([]byte, size)
   932  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   933  	if err != nil {
   934  		return nil, err
   935  	}
   936  	return dAtA[:n], nil
   937  }
   938  
   939  func (m *ContainerIPAddress) MarshalTo(dAtA []byte) (int, error) {
   940  	size := m.Size()
   941  	return m.MarshalToSizedBuffer(dAtA[:size])
   942  }
   943  
   944  func (m *ContainerIPAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   945  	i := len(dAtA)
   946  	_ = i
   947  	var l int
   948  	_ = l
   949  	if m.XXX_unrecognized != nil {
   950  		i -= len(m.XXX_unrecognized)
   951  		copy(dAtA[i:], m.XXX_unrecognized)
   952  	}
   953  	if len(m.DefaultGateway) > 0 {
   954  		i -= len(m.DefaultGateway)
   955  		copy(dAtA[i:], m.DefaultGateway)
   956  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.DefaultGateway)))
   957  		i--
   958  		dAtA[i] = 0x2a
   959  	}
   960  	if len(m.PrefixLength) > 0 {
   961  		i -= len(m.PrefixLength)
   962  		copy(dAtA[i:], m.PrefixLength)
   963  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PrefixLength)))
   964  		i--
   965  		dAtA[i] = 0x22
   966  	}
   967  	if len(m.Ip) > 0 {
   968  		i -= len(m.Ip)
   969  		copy(dAtA[i:], m.Ip)
   970  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Ip)))
   971  		i--
   972  		dAtA[i] = 0x1a
   973  	}
   974  	if len(m.Version) > 0 {
   975  		i -= len(m.Version)
   976  		copy(dAtA[i:], m.Version)
   977  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Version)))
   978  		i--
   979  		dAtA[i] = 0xa
   980  	}
   981  	return len(dAtA) - i, nil
   982  }
   983  
   984  func (m *ContainerNetworkInterface) Marshal() (dAtA []byte, err error) {
   985  	size := m.Size()
   986  	dAtA = make([]byte, size)
   987  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   988  	if err != nil {
   989  		return nil, err
   990  	}
   991  	return dAtA[:n], nil
   992  }
   993  
   994  func (m *ContainerNetworkInterface) MarshalTo(dAtA []byte) (int, error) {
   995  	size := m.Size()
   996  	return m.MarshalToSizedBuffer(dAtA[:size])
   997  }
   998  
   999  func (m *ContainerNetworkInterface) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1000  	i := len(dAtA)
  1001  	_ = i
  1002  	var l int
  1003  	_ = l
  1004  	if m.XXX_unrecognized != nil {
  1005  		i -= len(m.XXX_unrecognized)
  1006  		copy(dAtA[i:], m.XXX_unrecognized)
  1007  	}
  1008  	if len(m.Ipaddresses) > 0 {
  1009  		for iNdEx := len(m.Ipaddresses) - 1; iNdEx >= 0; iNdEx-- {
  1010  			{
  1011  				size, err := m.Ipaddresses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1012  				if err != nil {
  1013  					return 0, err
  1014  				}
  1015  				i -= size
  1016  				i = encodeVarintNodenetsvc(dAtA, i, uint64(size))
  1017  			}
  1018  			i--
  1019  			dAtA[i] = 0x22
  1020  		}
  1021  	}
  1022  	if len(m.NetworkNamespaceID) > 0 {
  1023  		i -= len(m.NetworkNamespaceID)
  1024  		copy(dAtA[i:], m.NetworkNamespaceID)
  1025  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.NetworkNamespaceID)))
  1026  		i--
  1027  		dAtA[i] = 0x1a
  1028  	}
  1029  	if len(m.MacAddress) > 0 {
  1030  		i -= len(m.MacAddress)
  1031  		copy(dAtA[i:], m.MacAddress)
  1032  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.MacAddress)))
  1033  		i--
  1034  		dAtA[i] = 0x12
  1035  	}
  1036  	if len(m.Name) > 0 {
  1037  		i -= len(m.Name)
  1038  		copy(dAtA[i:], m.Name)
  1039  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Name)))
  1040  		i--
  1041  		dAtA[i] = 0xa
  1042  	}
  1043  	return len(dAtA) - i, nil
  1044  }
  1045  
  1046  func (m *GetHostLocalIpAddressRequest) Marshal() (dAtA []byte, err error) {
  1047  	size := m.Size()
  1048  	dAtA = make([]byte, size)
  1049  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1050  	if err != nil {
  1051  		return nil, err
  1052  	}
  1053  	return dAtA[:n], nil
  1054  }
  1055  
  1056  func (m *GetHostLocalIpAddressRequest) MarshalTo(dAtA []byte) (int, error) {
  1057  	size := m.Size()
  1058  	return m.MarshalToSizedBuffer(dAtA[:size])
  1059  }
  1060  
  1061  func (m *GetHostLocalIpAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1062  	i := len(dAtA)
  1063  	_ = i
  1064  	var l int
  1065  	_ = l
  1066  	if m.XXX_unrecognized != nil {
  1067  		i -= len(m.XXX_unrecognized)
  1068  		copy(dAtA[i:], m.XXX_unrecognized)
  1069  	}
  1070  	if len(m.ContainerID) > 0 {
  1071  		i -= len(m.ContainerID)
  1072  		copy(dAtA[i:], m.ContainerID)
  1073  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID)))
  1074  		i--
  1075  		dAtA[i] = 0xa
  1076  	}
  1077  	return len(dAtA) - i, nil
  1078  }
  1079  
  1080  func (m *GetHostLocalIpAddressResponse) Marshal() (dAtA []byte, err error) {
  1081  	size := m.Size()
  1082  	dAtA = make([]byte, size)
  1083  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1084  	if err != nil {
  1085  		return nil, err
  1086  	}
  1087  	return dAtA[:n], nil
  1088  }
  1089  
  1090  func (m *GetHostLocalIpAddressResponse) MarshalTo(dAtA []byte) (int, error) {
  1091  	size := m.Size()
  1092  	return m.MarshalToSizedBuffer(dAtA[:size])
  1093  }
  1094  
  1095  func (m *GetHostLocalIpAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1096  	i := len(dAtA)
  1097  	_ = i
  1098  	var l int
  1099  	_ = l
  1100  	if m.XXX_unrecognized != nil {
  1101  		i -= len(m.XXX_unrecognized)
  1102  		copy(dAtA[i:], m.XXX_unrecognized)
  1103  	}
  1104  	if len(m.IpAddr) > 0 {
  1105  		i -= len(m.IpAddr)
  1106  		copy(dAtA[i:], m.IpAddr)
  1107  		i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.IpAddr)))
  1108  		i--
  1109  		dAtA[i] = 0xa
  1110  	}
  1111  	return len(dAtA) - i, nil
  1112  }
  1113  
  1114  func encodeVarintNodenetsvc(dAtA []byte, offset int, v uint64) int {
  1115  	offset -= sovNodenetsvc(v)
  1116  	base := offset
  1117  	for v >= 1<<7 {
  1118  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1119  		v >>= 7
  1120  		offset++
  1121  	}
  1122  	dAtA[offset] = uint8(v)
  1123  	return base
  1124  }
  1125  func (m *ConfigureNetworkingRequest) Size() (n int) {
  1126  	if m == nil {
  1127  		return 0
  1128  	}
  1129  	var l int
  1130  	_ = l
  1131  	l = len(m.ContainerID)
  1132  	if l > 0 {
  1133  		n += 1 + l + sovNodenetsvc(uint64(l))
  1134  	}
  1135  	if m.RequestType != 0 {
  1136  		n += 1 + sovNodenetsvc(uint64(m.RequestType))
  1137  	}
  1138  	if m.XXX_unrecognized != nil {
  1139  		n += len(m.XXX_unrecognized)
  1140  	}
  1141  	return n
  1142  }
  1143  
  1144  func (m *ConfigureNetworkingResponse) Size() (n int) {
  1145  	if m == nil {
  1146  		return 0
  1147  	}
  1148  	var l int
  1149  	_ = l
  1150  	if m.XXX_unrecognized != nil {
  1151  		n += len(m.XXX_unrecognized)
  1152  	}
  1153  	return n
  1154  }
  1155  
  1156  func (m *PingNodeNetworkServiceRequest) Size() (n int) {
  1157  	if m == nil {
  1158  		return 0
  1159  	}
  1160  	var l int
  1161  	_ = l
  1162  	l = len(m.PingRequestMessage)
  1163  	if l > 0 {
  1164  		n += 1 + l + sovNodenetsvc(uint64(l))
  1165  	}
  1166  	if m.XXX_unrecognized != nil {
  1167  		n += len(m.XXX_unrecognized)
  1168  	}
  1169  	return n
  1170  }
  1171  
  1172  func (m *PingNodeNetworkServiceResponse) Size() (n int) {
  1173  	if m == nil {
  1174  		return 0
  1175  	}
  1176  	var l int
  1177  	_ = l
  1178  	l = len(m.PingResponseMessage)
  1179  	if l > 0 {
  1180  		n += 1 + l + sovNodenetsvc(uint64(l))
  1181  	}
  1182  	if m.XXX_unrecognized != nil {
  1183  		n += len(m.XXX_unrecognized)
  1184  	}
  1185  	return n
  1186  }
  1187  
  1188  func (m *ConfigureContainerNetworkingRequest) Size() (n int) {
  1189  	if m == nil {
  1190  		return 0
  1191  	}
  1192  	var l int
  1193  	_ = l
  1194  	if m.RequestType != 0 {
  1195  		n += 1 + sovNodenetsvc(uint64(m.RequestType))
  1196  	}
  1197  	l = len(m.ContainerID)
  1198  	if l > 0 {
  1199  		n += 1 + l + sovNodenetsvc(uint64(l))
  1200  	}
  1201  	l = len(m.NetworkNamespaceID)
  1202  	if l > 0 {
  1203  		n += 1 + l + sovNodenetsvc(uint64(l))
  1204  	}
  1205  	if m.XXX_unrecognized != nil {
  1206  		n += len(m.XXX_unrecognized)
  1207  	}
  1208  	return n
  1209  }
  1210  
  1211  func (m *ConfigureContainerNetworkingResponse) Size() (n int) {
  1212  	if m == nil {
  1213  		return 0
  1214  	}
  1215  	var l int
  1216  	_ = l
  1217  	if len(m.Interfaces) > 0 {
  1218  		for _, e := range m.Interfaces {
  1219  			l = e.Size()
  1220  			n += 1 + l + sovNodenetsvc(uint64(l))
  1221  		}
  1222  	}
  1223  	if m.XXX_unrecognized != nil {
  1224  		n += len(m.XXX_unrecognized)
  1225  	}
  1226  	return n
  1227  }
  1228  
  1229  func (m *ContainerIPAddress) Size() (n int) {
  1230  	if m == nil {
  1231  		return 0
  1232  	}
  1233  	var l int
  1234  	_ = l
  1235  	l = len(m.Version)
  1236  	if l > 0 {
  1237  		n += 1 + l + sovNodenetsvc(uint64(l))
  1238  	}
  1239  	l = len(m.Ip)
  1240  	if l > 0 {
  1241  		n += 1 + l + sovNodenetsvc(uint64(l))
  1242  	}
  1243  	l = len(m.PrefixLength)
  1244  	if l > 0 {
  1245  		n += 1 + l + sovNodenetsvc(uint64(l))
  1246  	}
  1247  	l = len(m.DefaultGateway)
  1248  	if l > 0 {
  1249  		n += 1 + l + sovNodenetsvc(uint64(l))
  1250  	}
  1251  	if m.XXX_unrecognized != nil {
  1252  		n += len(m.XXX_unrecognized)
  1253  	}
  1254  	return n
  1255  }
  1256  
  1257  func (m *ContainerNetworkInterface) Size() (n int) {
  1258  	if m == nil {
  1259  		return 0
  1260  	}
  1261  	var l int
  1262  	_ = l
  1263  	l = len(m.Name)
  1264  	if l > 0 {
  1265  		n += 1 + l + sovNodenetsvc(uint64(l))
  1266  	}
  1267  	l = len(m.MacAddress)
  1268  	if l > 0 {
  1269  		n += 1 + l + sovNodenetsvc(uint64(l))
  1270  	}
  1271  	l = len(m.NetworkNamespaceID)
  1272  	if l > 0 {
  1273  		n += 1 + l + sovNodenetsvc(uint64(l))
  1274  	}
  1275  	if len(m.Ipaddresses) > 0 {
  1276  		for _, e := range m.Ipaddresses {
  1277  			l = e.Size()
  1278  			n += 1 + l + sovNodenetsvc(uint64(l))
  1279  		}
  1280  	}
  1281  	if m.XXX_unrecognized != nil {
  1282  		n += len(m.XXX_unrecognized)
  1283  	}
  1284  	return n
  1285  }
  1286  
  1287  func (m *GetHostLocalIpAddressRequest) Size() (n int) {
  1288  	if m == nil {
  1289  		return 0
  1290  	}
  1291  	var l int
  1292  	_ = l
  1293  	l = len(m.ContainerID)
  1294  	if l > 0 {
  1295  		n += 1 + l + sovNodenetsvc(uint64(l))
  1296  	}
  1297  	if m.XXX_unrecognized != nil {
  1298  		n += len(m.XXX_unrecognized)
  1299  	}
  1300  	return n
  1301  }
  1302  
  1303  func (m *GetHostLocalIpAddressResponse) Size() (n int) {
  1304  	if m == nil {
  1305  		return 0
  1306  	}
  1307  	var l int
  1308  	_ = l
  1309  	l = len(m.IpAddr)
  1310  	if l > 0 {
  1311  		n += 1 + l + sovNodenetsvc(uint64(l))
  1312  	}
  1313  	if m.XXX_unrecognized != nil {
  1314  		n += len(m.XXX_unrecognized)
  1315  	}
  1316  	return n
  1317  }
  1318  
  1319  func sovNodenetsvc(x uint64) (n int) {
  1320  	return (math_bits.Len64(x|1) + 6) / 7
  1321  }
  1322  func sozNodenetsvc(x uint64) (n int) {
  1323  	return sovNodenetsvc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1324  }
  1325  func (this *ConfigureNetworkingRequest) String() string {
  1326  	if this == nil {
  1327  		return "nil"
  1328  	}
  1329  	s := strings.Join([]string{`&ConfigureNetworkingRequest{`,
  1330  		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
  1331  		`RequestType:` + fmt.Sprintf("%v", this.RequestType) + `,`,
  1332  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1333  		`}`,
  1334  	}, "")
  1335  	return s
  1336  }
  1337  func (this *ConfigureNetworkingResponse) String() string {
  1338  	if this == nil {
  1339  		return "nil"
  1340  	}
  1341  	s := strings.Join([]string{`&ConfigureNetworkingResponse{`,
  1342  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1343  		`}`,
  1344  	}, "")
  1345  	return s
  1346  }
  1347  func (this *PingNodeNetworkServiceRequest) String() string {
  1348  	if this == nil {
  1349  		return "nil"
  1350  	}
  1351  	s := strings.Join([]string{`&PingNodeNetworkServiceRequest{`,
  1352  		`PingRequestMessage:` + fmt.Sprintf("%v", this.PingRequestMessage) + `,`,
  1353  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1354  		`}`,
  1355  	}, "")
  1356  	return s
  1357  }
  1358  func (this *PingNodeNetworkServiceResponse) String() string {
  1359  	if this == nil {
  1360  		return "nil"
  1361  	}
  1362  	s := strings.Join([]string{`&PingNodeNetworkServiceResponse{`,
  1363  		`PingResponseMessage:` + fmt.Sprintf("%v", this.PingResponseMessage) + `,`,
  1364  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1365  		`}`,
  1366  	}, "")
  1367  	return s
  1368  }
  1369  func (this *ConfigureContainerNetworkingRequest) String() string {
  1370  	if this == nil {
  1371  		return "nil"
  1372  	}
  1373  	s := strings.Join([]string{`&ConfigureContainerNetworkingRequest{`,
  1374  		`RequestType:` + fmt.Sprintf("%v", this.RequestType) + `,`,
  1375  		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
  1376  		`NetworkNamespaceID:` + fmt.Sprintf("%v", this.NetworkNamespaceID) + `,`,
  1377  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1378  		`}`,
  1379  	}, "")
  1380  	return s
  1381  }
  1382  func (this *ConfigureContainerNetworkingResponse) String() string {
  1383  	if this == nil {
  1384  		return "nil"
  1385  	}
  1386  	repeatedStringForInterfaces := "[]*ContainerNetworkInterface{"
  1387  	for _, f := range this.Interfaces {
  1388  		repeatedStringForInterfaces += strings.Replace(f.String(), "ContainerNetworkInterface", "ContainerNetworkInterface", 1) + ","
  1389  	}
  1390  	repeatedStringForInterfaces += "}"
  1391  	s := strings.Join([]string{`&ConfigureContainerNetworkingResponse{`,
  1392  		`Interfaces:` + repeatedStringForInterfaces + `,`,
  1393  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1394  		`}`,
  1395  	}, "")
  1396  	return s
  1397  }
  1398  func (this *ContainerIPAddress) String() string {
  1399  	if this == nil {
  1400  		return "nil"
  1401  	}
  1402  	s := strings.Join([]string{`&ContainerIPAddress{`,
  1403  		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
  1404  		`Ip:` + fmt.Sprintf("%v", this.Ip) + `,`,
  1405  		`PrefixLength:` + fmt.Sprintf("%v", this.PrefixLength) + `,`,
  1406  		`DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
  1407  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1408  		`}`,
  1409  	}, "")
  1410  	return s
  1411  }
  1412  func (this *ContainerNetworkInterface) String() string {
  1413  	if this == nil {
  1414  		return "nil"
  1415  	}
  1416  	repeatedStringForIpaddresses := "[]*ContainerIPAddress{"
  1417  	for _, f := range this.Ipaddresses {
  1418  		repeatedStringForIpaddresses += strings.Replace(f.String(), "ContainerIPAddress", "ContainerIPAddress", 1) + ","
  1419  	}
  1420  	repeatedStringForIpaddresses += "}"
  1421  	s := strings.Join([]string{`&ContainerNetworkInterface{`,
  1422  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  1423  		`MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`,
  1424  		`NetworkNamespaceID:` + fmt.Sprintf("%v", this.NetworkNamespaceID) + `,`,
  1425  		`Ipaddresses:` + repeatedStringForIpaddresses + `,`,
  1426  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1427  		`}`,
  1428  	}, "")
  1429  	return s
  1430  }
  1431  func (this *GetHostLocalIpAddressRequest) String() string {
  1432  	if this == nil {
  1433  		return "nil"
  1434  	}
  1435  	s := strings.Join([]string{`&GetHostLocalIpAddressRequest{`,
  1436  		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
  1437  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1438  		`}`,
  1439  	}, "")
  1440  	return s
  1441  }
  1442  func (this *GetHostLocalIpAddressResponse) String() string {
  1443  	if this == nil {
  1444  		return "nil"
  1445  	}
  1446  	s := strings.Join([]string{`&GetHostLocalIpAddressResponse{`,
  1447  		`IpAddr:` + fmt.Sprintf("%v", this.IpAddr) + `,`,
  1448  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1449  		`}`,
  1450  	}, "")
  1451  	return s
  1452  }
  1453  func valueToStringNodenetsvc(v interface{}) string {
  1454  	rv := reflect.ValueOf(v)
  1455  	if rv.IsNil() {
  1456  		return "nil"
  1457  	}
  1458  	pv := reflect.Indirect(rv).Interface()
  1459  	return fmt.Sprintf("*%v", pv)
  1460  }
  1461  func (m *ConfigureNetworkingRequest) Unmarshal(dAtA []byte) error {
  1462  	l := len(dAtA)
  1463  	iNdEx := 0
  1464  	for iNdEx < l {
  1465  		preIndex := iNdEx
  1466  		var wire uint64
  1467  		for shift := uint(0); ; shift += 7 {
  1468  			if shift >= 64 {
  1469  				return ErrIntOverflowNodenetsvc
  1470  			}
  1471  			if iNdEx >= l {
  1472  				return io.ErrUnexpectedEOF
  1473  			}
  1474  			b := dAtA[iNdEx]
  1475  			iNdEx++
  1476  			wire |= uint64(b&0x7F) << shift
  1477  			if b < 0x80 {
  1478  				break
  1479  			}
  1480  		}
  1481  		fieldNum := int32(wire >> 3)
  1482  		wireType := int(wire & 0x7)
  1483  		if wireType == 4 {
  1484  			return fmt.Errorf("proto: ConfigureNetworkingRequest: wiretype end group for non-group")
  1485  		}
  1486  		if fieldNum <= 0 {
  1487  			return fmt.Errorf("proto: ConfigureNetworkingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1488  		}
  1489  		switch fieldNum {
  1490  		case 1:
  1491  			if wireType != 2 {
  1492  				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
  1493  			}
  1494  			var stringLen uint64
  1495  			for shift := uint(0); ; shift += 7 {
  1496  				if shift >= 64 {
  1497  					return ErrIntOverflowNodenetsvc
  1498  				}
  1499  				if iNdEx >= l {
  1500  					return io.ErrUnexpectedEOF
  1501  				}
  1502  				b := dAtA[iNdEx]
  1503  				iNdEx++
  1504  				stringLen |= uint64(b&0x7F) << shift
  1505  				if b < 0x80 {
  1506  					break
  1507  				}
  1508  			}
  1509  			intStringLen := int(stringLen)
  1510  			if intStringLen < 0 {
  1511  				return ErrInvalidLengthNodenetsvc
  1512  			}
  1513  			postIndex := iNdEx + intStringLen
  1514  			if postIndex < 0 {
  1515  				return ErrInvalidLengthNodenetsvc
  1516  			}
  1517  			if postIndex > l {
  1518  				return io.ErrUnexpectedEOF
  1519  			}
  1520  			m.ContainerID = string(dAtA[iNdEx:postIndex])
  1521  			iNdEx = postIndex
  1522  		case 2:
  1523  			if wireType != 0 {
  1524  				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
  1525  			}
  1526  			m.RequestType = 0
  1527  			for shift := uint(0); ; shift += 7 {
  1528  				if shift >= 64 {
  1529  					return ErrIntOverflowNodenetsvc
  1530  				}
  1531  				if iNdEx >= l {
  1532  					return io.ErrUnexpectedEOF
  1533  				}
  1534  				b := dAtA[iNdEx]
  1535  				iNdEx++
  1536  				m.RequestType |= RequestType(b&0x7F) << shift
  1537  				if b < 0x80 {
  1538  					break
  1539  				}
  1540  			}
  1541  		default:
  1542  			iNdEx = preIndex
  1543  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1544  			if err != nil {
  1545  				return err
  1546  			}
  1547  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1548  				return ErrInvalidLengthNodenetsvc
  1549  			}
  1550  			if (iNdEx + skippy) > l {
  1551  				return io.ErrUnexpectedEOF
  1552  			}
  1553  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1554  			iNdEx += skippy
  1555  		}
  1556  	}
  1557  
  1558  	if iNdEx > l {
  1559  		return io.ErrUnexpectedEOF
  1560  	}
  1561  	return nil
  1562  }
  1563  func (m *ConfigureNetworkingResponse) Unmarshal(dAtA []byte) error {
  1564  	l := len(dAtA)
  1565  	iNdEx := 0
  1566  	for iNdEx < l {
  1567  		preIndex := iNdEx
  1568  		var wire uint64
  1569  		for shift := uint(0); ; shift += 7 {
  1570  			if shift >= 64 {
  1571  				return ErrIntOverflowNodenetsvc
  1572  			}
  1573  			if iNdEx >= l {
  1574  				return io.ErrUnexpectedEOF
  1575  			}
  1576  			b := dAtA[iNdEx]
  1577  			iNdEx++
  1578  			wire |= uint64(b&0x7F) << shift
  1579  			if b < 0x80 {
  1580  				break
  1581  			}
  1582  		}
  1583  		fieldNum := int32(wire >> 3)
  1584  		wireType := int(wire & 0x7)
  1585  		if wireType == 4 {
  1586  			return fmt.Errorf("proto: ConfigureNetworkingResponse: wiretype end group for non-group")
  1587  		}
  1588  		if fieldNum <= 0 {
  1589  			return fmt.Errorf("proto: ConfigureNetworkingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  1590  		}
  1591  		switch fieldNum {
  1592  		default:
  1593  			iNdEx = preIndex
  1594  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1595  			if err != nil {
  1596  				return err
  1597  			}
  1598  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1599  				return ErrInvalidLengthNodenetsvc
  1600  			}
  1601  			if (iNdEx + skippy) > l {
  1602  				return io.ErrUnexpectedEOF
  1603  			}
  1604  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1605  			iNdEx += skippy
  1606  		}
  1607  	}
  1608  
  1609  	if iNdEx > l {
  1610  		return io.ErrUnexpectedEOF
  1611  	}
  1612  	return nil
  1613  }
  1614  func (m *PingNodeNetworkServiceRequest) Unmarshal(dAtA []byte) error {
  1615  	l := len(dAtA)
  1616  	iNdEx := 0
  1617  	for iNdEx < l {
  1618  		preIndex := iNdEx
  1619  		var wire uint64
  1620  		for shift := uint(0); ; shift += 7 {
  1621  			if shift >= 64 {
  1622  				return ErrIntOverflowNodenetsvc
  1623  			}
  1624  			if iNdEx >= l {
  1625  				return io.ErrUnexpectedEOF
  1626  			}
  1627  			b := dAtA[iNdEx]
  1628  			iNdEx++
  1629  			wire |= uint64(b&0x7F) << shift
  1630  			if b < 0x80 {
  1631  				break
  1632  			}
  1633  		}
  1634  		fieldNum := int32(wire >> 3)
  1635  		wireType := int(wire & 0x7)
  1636  		if wireType == 4 {
  1637  			return fmt.Errorf("proto: PingNodeNetworkServiceRequest: wiretype end group for non-group")
  1638  		}
  1639  		if fieldNum <= 0 {
  1640  			return fmt.Errorf("proto: PingNodeNetworkServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1641  		}
  1642  		switch fieldNum {
  1643  		case 1:
  1644  			if wireType != 2 {
  1645  				return fmt.Errorf("proto: wrong wireType = %d for field PingRequestMessage", wireType)
  1646  			}
  1647  			var stringLen uint64
  1648  			for shift := uint(0); ; shift += 7 {
  1649  				if shift >= 64 {
  1650  					return ErrIntOverflowNodenetsvc
  1651  				}
  1652  				if iNdEx >= l {
  1653  					return io.ErrUnexpectedEOF
  1654  				}
  1655  				b := dAtA[iNdEx]
  1656  				iNdEx++
  1657  				stringLen |= uint64(b&0x7F) << shift
  1658  				if b < 0x80 {
  1659  					break
  1660  				}
  1661  			}
  1662  			intStringLen := int(stringLen)
  1663  			if intStringLen < 0 {
  1664  				return ErrInvalidLengthNodenetsvc
  1665  			}
  1666  			postIndex := iNdEx + intStringLen
  1667  			if postIndex < 0 {
  1668  				return ErrInvalidLengthNodenetsvc
  1669  			}
  1670  			if postIndex > l {
  1671  				return io.ErrUnexpectedEOF
  1672  			}
  1673  			m.PingRequestMessage = string(dAtA[iNdEx:postIndex])
  1674  			iNdEx = postIndex
  1675  		default:
  1676  			iNdEx = preIndex
  1677  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1678  			if err != nil {
  1679  				return err
  1680  			}
  1681  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1682  				return ErrInvalidLengthNodenetsvc
  1683  			}
  1684  			if (iNdEx + skippy) > l {
  1685  				return io.ErrUnexpectedEOF
  1686  			}
  1687  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1688  			iNdEx += skippy
  1689  		}
  1690  	}
  1691  
  1692  	if iNdEx > l {
  1693  		return io.ErrUnexpectedEOF
  1694  	}
  1695  	return nil
  1696  }
  1697  func (m *PingNodeNetworkServiceResponse) Unmarshal(dAtA []byte) error {
  1698  	l := len(dAtA)
  1699  	iNdEx := 0
  1700  	for iNdEx < l {
  1701  		preIndex := iNdEx
  1702  		var wire uint64
  1703  		for shift := uint(0); ; shift += 7 {
  1704  			if shift >= 64 {
  1705  				return ErrIntOverflowNodenetsvc
  1706  			}
  1707  			if iNdEx >= l {
  1708  				return io.ErrUnexpectedEOF
  1709  			}
  1710  			b := dAtA[iNdEx]
  1711  			iNdEx++
  1712  			wire |= uint64(b&0x7F) << shift
  1713  			if b < 0x80 {
  1714  				break
  1715  			}
  1716  		}
  1717  		fieldNum := int32(wire >> 3)
  1718  		wireType := int(wire & 0x7)
  1719  		if wireType == 4 {
  1720  			return fmt.Errorf("proto: PingNodeNetworkServiceResponse: wiretype end group for non-group")
  1721  		}
  1722  		if fieldNum <= 0 {
  1723  			return fmt.Errorf("proto: PingNodeNetworkServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  1724  		}
  1725  		switch fieldNum {
  1726  		case 1:
  1727  			if wireType != 2 {
  1728  				return fmt.Errorf("proto: wrong wireType = %d for field PingResponseMessage", wireType)
  1729  			}
  1730  			var stringLen uint64
  1731  			for shift := uint(0); ; shift += 7 {
  1732  				if shift >= 64 {
  1733  					return ErrIntOverflowNodenetsvc
  1734  				}
  1735  				if iNdEx >= l {
  1736  					return io.ErrUnexpectedEOF
  1737  				}
  1738  				b := dAtA[iNdEx]
  1739  				iNdEx++
  1740  				stringLen |= uint64(b&0x7F) << shift
  1741  				if b < 0x80 {
  1742  					break
  1743  				}
  1744  			}
  1745  			intStringLen := int(stringLen)
  1746  			if intStringLen < 0 {
  1747  				return ErrInvalidLengthNodenetsvc
  1748  			}
  1749  			postIndex := iNdEx + intStringLen
  1750  			if postIndex < 0 {
  1751  				return ErrInvalidLengthNodenetsvc
  1752  			}
  1753  			if postIndex > l {
  1754  				return io.ErrUnexpectedEOF
  1755  			}
  1756  			m.PingResponseMessage = string(dAtA[iNdEx:postIndex])
  1757  			iNdEx = postIndex
  1758  		default:
  1759  			iNdEx = preIndex
  1760  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1761  			if err != nil {
  1762  				return err
  1763  			}
  1764  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1765  				return ErrInvalidLengthNodenetsvc
  1766  			}
  1767  			if (iNdEx + skippy) > l {
  1768  				return io.ErrUnexpectedEOF
  1769  			}
  1770  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1771  			iNdEx += skippy
  1772  		}
  1773  	}
  1774  
  1775  	if iNdEx > l {
  1776  		return io.ErrUnexpectedEOF
  1777  	}
  1778  	return nil
  1779  }
  1780  func (m *ConfigureContainerNetworkingRequest) Unmarshal(dAtA []byte) error {
  1781  	l := len(dAtA)
  1782  	iNdEx := 0
  1783  	for iNdEx < l {
  1784  		preIndex := iNdEx
  1785  		var wire uint64
  1786  		for shift := uint(0); ; shift += 7 {
  1787  			if shift >= 64 {
  1788  				return ErrIntOverflowNodenetsvc
  1789  			}
  1790  			if iNdEx >= l {
  1791  				return io.ErrUnexpectedEOF
  1792  			}
  1793  			b := dAtA[iNdEx]
  1794  			iNdEx++
  1795  			wire |= uint64(b&0x7F) << shift
  1796  			if b < 0x80 {
  1797  				break
  1798  			}
  1799  		}
  1800  		fieldNum := int32(wire >> 3)
  1801  		wireType := int(wire & 0x7)
  1802  		if wireType == 4 {
  1803  			return fmt.Errorf("proto: ConfigureContainerNetworkingRequest: wiretype end group for non-group")
  1804  		}
  1805  		if fieldNum <= 0 {
  1806  			return fmt.Errorf("proto: ConfigureContainerNetworkingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1807  		}
  1808  		switch fieldNum {
  1809  		case 1:
  1810  			if wireType != 0 {
  1811  				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
  1812  			}
  1813  			m.RequestType = 0
  1814  			for shift := uint(0); ; shift += 7 {
  1815  				if shift >= 64 {
  1816  					return ErrIntOverflowNodenetsvc
  1817  				}
  1818  				if iNdEx >= l {
  1819  					return io.ErrUnexpectedEOF
  1820  				}
  1821  				b := dAtA[iNdEx]
  1822  				iNdEx++
  1823  				m.RequestType |= RequestType(b&0x7F) << shift
  1824  				if b < 0x80 {
  1825  					break
  1826  				}
  1827  			}
  1828  		case 2:
  1829  			if wireType != 2 {
  1830  				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
  1831  			}
  1832  			var stringLen uint64
  1833  			for shift := uint(0); ; shift += 7 {
  1834  				if shift >= 64 {
  1835  					return ErrIntOverflowNodenetsvc
  1836  				}
  1837  				if iNdEx >= l {
  1838  					return io.ErrUnexpectedEOF
  1839  				}
  1840  				b := dAtA[iNdEx]
  1841  				iNdEx++
  1842  				stringLen |= uint64(b&0x7F) << shift
  1843  				if b < 0x80 {
  1844  					break
  1845  				}
  1846  			}
  1847  			intStringLen := int(stringLen)
  1848  			if intStringLen < 0 {
  1849  				return ErrInvalidLengthNodenetsvc
  1850  			}
  1851  			postIndex := iNdEx + intStringLen
  1852  			if postIndex < 0 {
  1853  				return ErrInvalidLengthNodenetsvc
  1854  			}
  1855  			if postIndex > l {
  1856  				return io.ErrUnexpectedEOF
  1857  			}
  1858  			m.ContainerID = string(dAtA[iNdEx:postIndex])
  1859  			iNdEx = postIndex
  1860  		case 3:
  1861  			if wireType != 2 {
  1862  				return fmt.Errorf("proto: wrong wireType = %d for field NetworkNamespaceID", wireType)
  1863  			}
  1864  			var stringLen uint64
  1865  			for shift := uint(0); ; shift += 7 {
  1866  				if shift >= 64 {
  1867  					return ErrIntOverflowNodenetsvc
  1868  				}
  1869  				if iNdEx >= l {
  1870  					return io.ErrUnexpectedEOF
  1871  				}
  1872  				b := dAtA[iNdEx]
  1873  				iNdEx++
  1874  				stringLen |= uint64(b&0x7F) << shift
  1875  				if b < 0x80 {
  1876  					break
  1877  				}
  1878  			}
  1879  			intStringLen := int(stringLen)
  1880  			if intStringLen < 0 {
  1881  				return ErrInvalidLengthNodenetsvc
  1882  			}
  1883  			postIndex := iNdEx + intStringLen
  1884  			if postIndex < 0 {
  1885  				return ErrInvalidLengthNodenetsvc
  1886  			}
  1887  			if postIndex > l {
  1888  				return io.ErrUnexpectedEOF
  1889  			}
  1890  			m.NetworkNamespaceID = string(dAtA[iNdEx:postIndex])
  1891  			iNdEx = postIndex
  1892  		default:
  1893  			iNdEx = preIndex
  1894  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1895  			if err != nil {
  1896  				return err
  1897  			}
  1898  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1899  				return ErrInvalidLengthNodenetsvc
  1900  			}
  1901  			if (iNdEx + skippy) > l {
  1902  				return io.ErrUnexpectedEOF
  1903  			}
  1904  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1905  			iNdEx += skippy
  1906  		}
  1907  	}
  1908  
  1909  	if iNdEx > l {
  1910  		return io.ErrUnexpectedEOF
  1911  	}
  1912  	return nil
  1913  }
  1914  func (m *ConfigureContainerNetworkingResponse) Unmarshal(dAtA []byte) error {
  1915  	l := len(dAtA)
  1916  	iNdEx := 0
  1917  	for iNdEx < l {
  1918  		preIndex := iNdEx
  1919  		var wire uint64
  1920  		for shift := uint(0); ; shift += 7 {
  1921  			if shift >= 64 {
  1922  				return ErrIntOverflowNodenetsvc
  1923  			}
  1924  			if iNdEx >= l {
  1925  				return io.ErrUnexpectedEOF
  1926  			}
  1927  			b := dAtA[iNdEx]
  1928  			iNdEx++
  1929  			wire |= uint64(b&0x7F) << shift
  1930  			if b < 0x80 {
  1931  				break
  1932  			}
  1933  		}
  1934  		fieldNum := int32(wire >> 3)
  1935  		wireType := int(wire & 0x7)
  1936  		if wireType == 4 {
  1937  			return fmt.Errorf("proto: ConfigureContainerNetworkingResponse: wiretype end group for non-group")
  1938  		}
  1939  		if fieldNum <= 0 {
  1940  			return fmt.Errorf("proto: ConfigureContainerNetworkingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  1941  		}
  1942  		switch fieldNum {
  1943  		case 1:
  1944  			if wireType != 2 {
  1945  				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
  1946  			}
  1947  			var msglen int
  1948  			for shift := uint(0); ; shift += 7 {
  1949  				if shift >= 64 {
  1950  					return ErrIntOverflowNodenetsvc
  1951  				}
  1952  				if iNdEx >= l {
  1953  					return io.ErrUnexpectedEOF
  1954  				}
  1955  				b := dAtA[iNdEx]
  1956  				iNdEx++
  1957  				msglen |= int(b&0x7F) << shift
  1958  				if b < 0x80 {
  1959  					break
  1960  				}
  1961  			}
  1962  			if msglen < 0 {
  1963  				return ErrInvalidLengthNodenetsvc
  1964  			}
  1965  			postIndex := iNdEx + msglen
  1966  			if postIndex < 0 {
  1967  				return ErrInvalidLengthNodenetsvc
  1968  			}
  1969  			if postIndex > l {
  1970  				return io.ErrUnexpectedEOF
  1971  			}
  1972  			m.Interfaces = append(m.Interfaces, &ContainerNetworkInterface{})
  1973  			if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1974  				return err
  1975  			}
  1976  			iNdEx = postIndex
  1977  		default:
  1978  			iNdEx = preIndex
  1979  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  1980  			if err != nil {
  1981  				return err
  1982  			}
  1983  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1984  				return ErrInvalidLengthNodenetsvc
  1985  			}
  1986  			if (iNdEx + skippy) > l {
  1987  				return io.ErrUnexpectedEOF
  1988  			}
  1989  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1990  			iNdEx += skippy
  1991  		}
  1992  	}
  1993  
  1994  	if iNdEx > l {
  1995  		return io.ErrUnexpectedEOF
  1996  	}
  1997  	return nil
  1998  }
  1999  func (m *ContainerIPAddress) Unmarshal(dAtA []byte) error {
  2000  	l := len(dAtA)
  2001  	iNdEx := 0
  2002  	for iNdEx < l {
  2003  		preIndex := iNdEx
  2004  		var wire uint64
  2005  		for shift := uint(0); ; shift += 7 {
  2006  			if shift >= 64 {
  2007  				return ErrIntOverflowNodenetsvc
  2008  			}
  2009  			if iNdEx >= l {
  2010  				return io.ErrUnexpectedEOF
  2011  			}
  2012  			b := dAtA[iNdEx]
  2013  			iNdEx++
  2014  			wire |= uint64(b&0x7F) << shift
  2015  			if b < 0x80 {
  2016  				break
  2017  			}
  2018  		}
  2019  		fieldNum := int32(wire >> 3)
  2020  		wireType := int(wire & 0x7)
  2021  		if wireType == 4 {
  2022  			return fmt.Errorf("proto: ContainerIPAddress: wiretype end group for non-group")
  2023  		}
  2024  		if fieldNum <= 0 {
  2025  			return fmt.Errorf("proto: ContainerIPAddress: illegal tag %d (wire type %d)", fieldNum, wire)
  2026  		}
  2027  		switch fieldNum {
  2028  		case 1:
  2029  			if wireType != 2 {
  2030  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  2031  			}
  2032  			var stringLen uint64
  2033  			for shift := uint(0); ; shift += 7 {
  2034  				if shift >= 64 {
  2035  					return ErrIntOverflowNodenetsvc
  2036  				}
  2037  				if iNdEx >= l {
  2038  					return io.ErrUnexpectedEOF
  2039  				}
  2040  				b := dAtA[iNdEx]
  2041  				iNdEx++
  2042  				stringLen |= uint64(b&0x7F) << shift
  2043  				if b < 0x80 {
  2044  					break
  2045  				}
  2046  			}
  2047  			intStringLen := int(stringLen)
  2048  			if intStringLen < 0 {
  2049  				return ErrInvalidLengthNodenetsvc
  2050  			}
  2051  			postIndex := iNdEx + intStringLen
  2052  			if postIndex < 0 {
  2053  				return ErrInvalidLengthNodenetsvc
  2054  			}
  2055  			if postIndex > l {
  2056  				return io.ErrUnexpectedEOF
  2057  			}
  2058  			m.Version = string(dAtA[iNdEx:postIndex])
  2059  			iNdEx = postIndex
  2060  		case 3:
  2061  			if wireType != 2 {
  2062  				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
  2063  			}
  2064  			var stringLen uint64
  2065  			for shift := uint(0); ; shift += 7 {
  2066  				if shift >= 64 {
  2067  					return ErrIntOverflowNodenetsvc
  2068  				}
  2069  				if iNdEx >= l {
  2070  					return io.ErrUnexpectedEOF
  2071  				}
  2072  				b := dAtA[iNdEx]
  2073  				iNdEx++
  2074  				stringLen |= uint64(b&0x7F) << shift
  2075  				if b < 0x80 {
  2076  					break
  2077  				}
  2078  			}
  2079  			intStringLen := int(stringLen)
  2080  			if intStringLen < 0 {
  2081  				return ErrInvalidLengthNodenetsvc
  2082  			}
  2083  			postIndex := iNdEx + intStringLen
  2084  			if postIndex < 0 {
  2085  				return ErrInvalidLengthNodenetsvc
  2086  			}
  2087  			if postIndex > l {
  2088  				return io.ErrUnexpectedEOF
  2089  			}
  2090  			m.Ip = string(dAtA[iNdEx:postIndex])
  2091  			iNdEx = postIndex
  2092  		case 4:
  2093  			if wireType != 2 {
  2094  				return fmt.Errorf("proto: wrong wireType = %d for field PrefixLength", wireType)
  2095  			}
  2096  			var stringLen uint64
  2097  			for shift := uint(0); ; shift += 7 {
  2098  				if shift >= 64 {
  2099  					return ErrIntOverflowNodenetsvc
  2100  				}
  2101  				if iNdEx >= l {
  2102  					return io.ErrUnexpectedEOF
  2103  				}
  2104  				b := dAtA[iNdEx]
  2105  				iNdEx++
  2106  				stringLen |= uint64(b&0x7F) << shift
  2107  				if b < 0x80 {
  2108  					break
  2109  				}
  2110  			}
  2111  			intStringLen := int(stringLen)
  2112  			if intStringLen < 0 {
  2113  				return ErrInvalidLengthNodenetsvc
  2114  			}
  2115  			postIndex := iNdEx + intStringLen
  2116  			if postIndex < 0 {
  2117  				return ErrInvalidLengthNodenetsvc
  2118  			}
  2119  			if postIndex > l {
  2120  				return io.ErrUnexpectedEOF
  2121  			}
  2122  			m.PrefixLength = string(dAtA[iNdEx:postIndex])
  2123  			iNdEx = postIndex
  2124  		case 5:
  2125  			if wireType != 2 {
  2126  				return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
  2127  			}
  2128  			var stringLen uint64
  2129  			for shift := uint(0); ; shift += 7 {
  2130  				if shift >= 64 {
  2131  					return ErrIntOverflowNodenetsvc
  2132  				}
  2133  				if iNdEx >= l {
  2134  					return io.ErrUnexpectedEOF
  2135  				}
  2136  				b := dAtA[iNdEx]
  2137  				iNdEx++
  2138  				stringLen |= uint64(b&0x7F) << shift
  2139  				if b < 0x80 {
  2140  					break
  2141  				}
  2142  			}
  2143  			intStringLen := int(stringLen)
  2144  			if intStringLen < 0 {
  2145  				return ErrInvalidLengthNodenetsvc
  2146  			}
  2147  			postIndex := iNdEx + intStringLen
  2148  			if postIndex < 0 {
  2149  				return ErrInvalidLengthNodenetsvc
  2150  			}
  2151  			if postIndex > l {
  2152  				return io.ErrUnexpectedEOF
  2153  			}
  2154  			m.DefaultGateway = string(dAtA[iNdEx:postIndex])
  2155  			iNdEx = postIndex
  2156  		default:
  2157  			iNdEx = preIndex
  2158  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  2159  			if err != nil {
  2160  				return err
  2161  			}
  2162  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2163  				return ErrInvalidLengthNodenetsvc
  2164  			}
  2165  			if (iNdEx + skippy) > l {
  2166  				return io.ErrUnexpectedEOF
  2167  			}
  2168  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2169  			iNdEx += skippy
  2170  		}
  2171  	}
  2172  
  2173  	if iNdEx > l {
  2174  		return io.ErrUnexpectedEOF
  2175  	}
  2176  	return nil
  2177  }
  2178  func (m *ContainerNetworkInterface) Unmarshal(dAtA []byte) error {
  2179  	l := len(dAtA)
  2180  	iNdEx := 0
  2181  	for iNdEx < l {
  2182  		preIndex := iNdEx
  2183  		var wire uint64
  2184  		for shift := uint(0); ; shift += 7 {
  2185  			if shift >= 64 {
  2186  				return ErrIntOverflowNodenetsvc
  2187  			}
  2188  			if iNdEx >= l {
  2189  				return io.ErrUnexpectedEOF
  2190  			}
  2191  			b := dAtA[iNdEx]
  2192  			iNdEx++
  2193  			wire |= uint64(b&0x7F) << shift
  2194  			if b < 0x80 {
  2195  				break
  2196  			}
  2197  		}
  2198  		fieldNum := int32(wire >> 3)
  2199  		wireType := int(wire & 0x7)
  2200  		if wireType == 4 {
  2201  			return fmt.Errorf("proto: ContainerNetworkInterface: wiretype end group for non-group")
  2202  		}
  2203  		if fieldNum <= 0 {
  2204  			return fmt.Errorf("proto: ContainerNetworkInterface: illegal tag %d (wire type %d)", fieldNum, wire)
  2205  		}
  2206  		switch fieldNum {
  2207  		case 1:
  2208  			if wireType != 2 {
  2209  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  2210  			}
  2211  			var stringLen uint64
  2212  			for shift := uint(0); ; shift += 7 {
  2213  				if shift >= 64 {
  2214  					return ErrIntOverflowNodenetsvc
  2215  				}
  2216  				if iNdEx >= l {
  2217  					return io.ErrUnexpectedEOF
  2218  				}
  2219  				b := dAtA[iNdEx]
  2220  				iNdEx++
  2221  				stringLen |= uint64(b&0x7F) << shift
  2222  				if b < 0x80 {
  2223  					break
  2224  				}
  2225  			}
  2226  			intStringLen := int(stringLen)
  2227  			if intStringLen < 0 {
  2228  				return ErrInvalidLengthNodenetsvc
  2229  			}
  2230  			postIndex := iNdEx + intStringLen
  2231  			if postIndex < 0 {
  2232  				return ErrInvalidLengthNodenetsvc
  2233  			}
  2234  			if postIndex > l {
  2235  				return io.ErrUnexpectedEOF
  2236  			}
  2237  			m.Name = string(dAtA[iNdEx:postIndex])
  2238  			iNdEx = postIndex
  2239  		case 2:
  2240  			if wireType != 2 {
  2241  				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
  2242  			}
  2243  			var stringLen uint64
  2244  			for shift := uint(0); ; shift += 7 {
  2245  				if shift >= 64 {
  2246  					return ErrIntOverflowNodenetsvc
  2247  				}
  2248  				if iNdEx >= l {
  2249  					return io.ErrUnexpectedEOF
  2250  				}
  2251  				b := dAtA[iNdEx]
  2252  				iNdEx++
  2253  				stringLen |= uint64(b&0x7F) << shift
  2254  				if b < 0x80 {
  2255  					break
  2256  				}
  2257  			}
  2258  			intStringLen := int(stringLen)
  2259  			if intStringLen < 0 {
  2260  				return ErrInvalidLengthNodenetsvc
  2261  			}
  2262  			postIndex := iNdEx + intStringLen
  2263  			if postIndex < 0 {
  2264  				return ErrInvalidLengthNodenetsvc
  2265  			}
  2266  			if postIndex > l {
  2267  				return io.ErrUnexpectedEOF
  2268  			}
  2269  			m.MacAddress = string(dAtA[iNdEx:postIndex])
  2270  			iNdEx = postIndex
  2271  		case 3:
  2272  			if wireType != 2 {
  2273  				return fmt.Errorf("proto: wrong wireType = %d for field NetworkNamespaceID", wireType)
  2274  			}
  2275  			var stringLen uint64
  2276  			for shift := uint(0); ; shift += 7 {
  2277  				if shift >= 64 {
  2278  					return ErrIntOverflowNodenetsvc
  2279  				}
  2280  				if iNdEx >= l {
  2281  					return io.ErrUnexpectedEOF
  2282  				}
  2283  				b := dAtA[iNdEx]
  2284  				iNdEx++
  2285  				stringLen |= uint64(b&0x7F) << shift
  2286  				if b < 0x80 {
  2287  					break
  2288  				}
  2289  			}
  2290  			intStringLen := int(stringLen)
  2291  			if intStringLen < 0 {
  2292  				return ErrInvalidLengthNodenetsvc
  2293  			}
  2294  			postIndex := iNdEx + intStringLen
  2295  			if postIndex < 0 {
  2296  				return ErrInvalidLengthNodenetsvc
  2297  			}
  2298  			if postIndex > l {
  2299  				return io.ErrUnexpectedEOF
  2300  			}
  2301  			m.NetworkNamespaceID = string(dAtA[iNdEx:postIndex])
  2302  			iNdEx = postIndex
  2303  		case 4:
  2304  			if wireType != 2 {
  2305  				return fmt.Errorf("proto: wrong wireType = %d for field Ipaddresses", wireType)
  2306  			}
  2307  			var msglen int
  2308  			for shift := uint(0); ; shift += 7 {
  2309  				if shift >= 64 {
  2310  					return ErrIntOverflowNodenetsvc
  2311  				}
  2312  				if iNdEx >= l {
  2313  					return io.ErrUnexpectedEOF
  2314  				}
  2315  				b := dAtA[iNdEx]
  2316  				iNdEx++
  2317  				msglen |= int(b&0x7F) << shift
  2318  				if b < 0x80 {
  2319  					break
  2320  				}
  2321  			}
  2322  			if msglen < 0 {
  2323  				return ErrInvalidLengthNodenetsvc
  2324  			}
  2325  			postIndex := iNdEx + msglen
  2326  			if postIndex < 0 {
  2327  				return ErrInvalidLengthNodenetsvc
  2328  			}
  2329  			if postIndex > l {
  2330  				return io.ErrUnexpectedEOF
  2331  			}
  2332  			m.Ipaddresses = append(m.Ipaddresses, &ContainerIPAddress{})
  2333  			if err := m.Ipaddresses[len(m.Ipaddresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2334  				return err
  2335  			}
  2336  			iNdEx = postIndex
  2337  		default:
  2338  			iNdEx = preIndex
  2339  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  2340  			if err != nil {
  2341  				return err
  2342  			}
  2343  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2344  				return ErrInvalidLengthNodenetsvc
  2345  			}
  2346  			if (iNdEx + skippy) > l {
  2347  				return io.ErrUnexpectedEOF
  2348  			}
  2349  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2350  			iNdEx += skippy
  2351  		}
  2352  	}
  2353  
  2354  	if iNdEx > l {
  2355  		return io.ErrUnexpectedEOF
  2356  	}
  2357  	return nil
  2358  }
  2359  func (m *GetHostLocalIpAddressRequest) Unmarshal(dAtA []byte) error {
  2360  	l := len(dAtA)
  2361  	iNdEx := 0
  2362  	for iNdEx < l {
  2363  		preIndex := iNdEx
  2364  		var wire uint64
  2365  		for shift := uint(0); ; shift += 7 {
  2366  			if shift >= 64 {
  2367  				return ErrIntOverflowNodenetsvc
  2368  			}
  2369  			if iNdEx >= l {
  2370  				return io.ErrUnexpectedEOF
  2371  			}
  2372  			b := dAtA[iNdEx]
  2373  			iNdEx++
  2374  			wire |= uint64(b&0x7F) << shift
  2375  			if b < 0x80 {
  2376  				break
  2377  			}
  2378  		}
  2379  		fieldNum := int32(wire >> 3)
  2380  		wireType := int(wire & 0x7)
  2381  		if wireType == 4 {
  2382  			return fmt.Errorf("proto: GetHostLocalIpAddressRequest: wiretype end group for non-group")
  2383  		}
  2384  		if fieldNum <= 0 {
  2385  			return fmt.Errorf("proto: GetHostLocalIpAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  2386  		}
  2387  		switch fieldNum {
  2388  		case 1:
  2389  			if wireType != 2 {
  2390  				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
  2391  			}
  2392  			var stringLen uint64
  2393  			for shift := uint(0); ; shift += 7 {
  2394  				if shift >= 64 {
  2395  					return ErrIntOverflowNodenetsvc
  2396  				}
  2397  				if iNdEx >= l {
  2398  					return io.ErrUnexpectedEOF
  2399  				}
  2400  				b := dAtA[iNdEx]
  2401  				iNdEx++
  2402  				stringLen |= uint64(b&0x7F) << shift
  2403  				if b < 0x80 {
  2404  					break
  2405  				}
  2406  			}
  2407  			intStringLen := int(stringLen)
  2408  			if intStringLen < 0 {
  2409  				return ErrInvalidLengthNodenetsvc
  2410  			}
  2411  			postIndex := iNdEx + intStringLen
  2412  			if postIndex < 0 {
  2413  				return ErrInvalidLengthNodenetsvc
  2414  			}
  2415  			if postIndex > l {
  2416  				return io.ErrUnexpectedEOF
  2417  			}
  2418  			m.ContainerID = string(dAtA[iNdEx:postIndex])
  2419  			iNdEx = postIndex
  2420  		default:
  2421  			iNdEx = preIndex
  2422  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  2423  			if err != nil {
  2424  				return err
  2425  			}
  2426  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2427  				return ErrInvalidLengthNodenetsvc
  2428  			}
  2429  			if (iNdEx + skippy) > l {
  2430  				return io.ErrUnexpectedEOF
  2431  			}
  2432  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2433  			iNdEx += skippy
  2434  		}
  2435  	}
  2436  
  2437  	if iNdEx > l {
  2438  		return io.ErrUnexpectedEOF
  2439  	}
  2440  	return nil
  2441  }
  2442  func (m *GetHostLocalIpAddressResponse) Unmarshal(dAtA []byte) error {
  2443  	l := len(dAtA)
  2444  	iNdEx := 0
  2445  	for iNdEx < l {
  2446  		preIndex := iNdEx
  2447  		var wire uint64
  2448  		for shift := uint(0); ; shift += 7 {
  2449  			if shift >= 64 {
  2450  				return ErrIntOverflowNodenetsvc
  2451  			}
  2452  			if iNdEx >= l {
  2453  				return io.ErrUnexpectedEOF
  2454  			}
  2455  			b := dAtA[iNdEx]
  2456  			iNdEx++
  2457  			wire |= uint64(b&0x7F) << shift
  2458  			if b < 0x80 {
  2459  				break
  2460  			}
  2461  		}
  2462  		fieldNum := int32(wire >> 3)
  2463  		wireType := int(wire & 0x7)
  2464  		if wireType == 4 {
  2465  			return fmt.Errorf("proto: GetHostLocalIpAddressResponse: wiretype end group for non-group")
  2466  		}
  2467  		if fieldNum <= 0 {
  2468  			return fmt.Errorf("proto: GetHostLocalIpAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  2469  		}
  2470  		switch fieldNum {
  2471  		case 1:
  2472  			if wireType != 2 {
  2473  				return fmt.Errorf("proto: wrong wireType = %d for field IpAddr", wireType)
  2474  			}
  2475  			var stringLen uint64
  2476  			for shift := uint(0); ; shift += 7 {
  2477  				if shift >= 64 {
  2478  					return ErrIntOverflowNodenetsvc
  2479  				}
  2480  				if iNdEx >= l {
  2481  					return io.ErrUnexpectedEOF
  2482  				}
  2483  				b := dAtA[iNdEx]
  2484  				iNdEx++
  2485  				stringLen |= uint64(b&0x7F) << shift
  2486  				if b < 0x80 {
  2487  					break
  2488  				}
  2489  			}
  2490  			intStringLen := int(stringLen)
  2491  			if intStringLen < 0 {
  2492  				return ErrInvalidLengthNodenetsvc
  2493  			}
  2494  			postIndex := iNdEx + intStringLen
  2495  			if postIndex < 0 {
  2496  				return ErrInvalidLengthNodenetsvc
  2497  			}
  2498  			if postIndex > l {
  2499  				return io.ErrUnexpectedEOF
  2500  			}
  2501  			m.IpAddr = string(dAtA[iNdEx:postIndex])
  2502  			iNdEx = postIndex
  2503  		default:
  2504  			iNdEx = preIndex
  2505  			skippy, err := skipNodenetsvc(dAtA[iNdEx:])
  2506  			if err != nil {
  2507  				return err
  2508  			}
  2509  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2510  				return ErrInvalidLengthNodenetsvc
  2511  			}
  2512  			if (iNdEx + skippy) > l {
  2513  				return io.ErrUnexpectedEOF
  2514  			}
  2515  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2516  			iNdEx += skippy
  2517  		}
  2518  	}
  2519  
  2520  	if iNdEx > l {
  2521  		return io.ErrUnexpectedEOF
  2522  	}
  2523  	return nil
  2524  }
  2525  func skipNodenetsvc(dAtA []byte) (n int, err error) {
  2526  	l := len(dAtA)
  2527  	iNdEx := 0
  2528  	depth := 0
  2529  	for iNdEx < l {
  2530  		var wire uint64
  2531  		for shift := uint(0); ; shift += 7 {
  2532  			if shift >= 64 {
  2533  				return 0, ErrIntOverflowNodenetsvc
  2534  			}
  2535  			if iNdEx >= l {
  2536  				return 0, io.ErrUnexpectedEOF
  2537  			}
  2538  			b := dAtA[iNdEx]
  2539  			iNdEx++
  2540  			wire |= (uint64(b) & 0x7F) << shift
  2541  			if b < 0x80 {
  2542  				break
  2543  			}
  2544  		}
  2545  		wireType := int(wire & 0x7)
  2546  		switch wireType {
  2547  		case 0:
  2548  			for shift := uint(0); ; shift += 7 {
  2549  				if shift >= 64 {
  2550  					return 0, ErrIntOverflowNodenetsvc
  2551  				}
  2552  				if iNdEx >= l {
  2553  					return 0, io.ErrUnexpectedEOF
  2554  				}
  2555  				iNdEx++
  2556  				if dAtA[iNdEx-1] < 0x80 {
  2557  					break
  2558  				}
  2559  			}
  2560  		case 1:
  2561  			iNdEx += 8
  2562  		case 2:
  2563  			var length int
  2564  			for shift := uint(0); ; shift += 7 {
  2565  				if shift >= 64 {
  2566  					return 0, ErrIntOverflowNodenetsvc
  2567  				}
  2568  				if iNdEx >= l {
  2569  					return 0, io.ErrUnexpectedEOF
  2570  				}
  2571  				b := dAtA[iNdEx]
  2572  				iNdEx++
  2573  				length |= (int(b) & 0x7F) << shift
  2574  				if b < 0x80 {
  2575  					break
  2576  				}
  2577  			}
  2578  			if length < 0 {
  2579  				return 0, ErrInvalidLengthNodenetsvc
  2580  			}
  2581  			iNdEx += length
  2582  		case 3:
  2583  			depth++
  2584  		case 4:
  2585  			if depth == 0 {
  2586  				return 0, ErrUnexpectedEndOfGroupNodenetsvc
  2587  			}
  2588  			depth--
  2589  		case 5:
  2590  			iNdEx += 4
  2591  		default:
  2592  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2593  		}
  2594  		if iNdEx < 0 {
  2595  			return 0, ErrInvalidLengthNodenetsvc
  2596  		}
  2597  		if depth == 0 {
  2598  			return iNdEx, nil
  2599  		}
  2600  	}
  2601  	return 0, io.ErrUnexpectedEOF
  2602  }
  2603  
  2604  var (
  2605  	ErrInvalidLengthNodenetsvc        = fmt.Errorf("proto: negative length found during unmarshaling")
  2606  	ErrIntOverflowNodenetsvc          = fmt.Errorf("proto: integer overflow")
  2607  	ErrUnexpectedEndOfGroupNodenetsvc = fmt.Errorf("proto: unexpected end of group")
  2608  )
  2609  

View as plain text