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

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

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

View as plain text