1
2
3
4 package v1
5
6 import (
7 context "context"
8 fmt "fmt"
9 proto "github.com/gogo/protobuf/proto"
10 grpc "google.golang.org/grpc"
11 codes "google.golang.org/grpc/codes"
12 status "google.golang.org/grpc/status"
13 io "io"
14 math "math"
15 math_bits "math/bits"
16 reflect "reflect"
17 strings "strings"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25
26
27
28
29 const _ = proto.GoGoProtoPackageIsVersion3
30
31 type HostComputeNetworkSettings_NetworkMode int32
32
33 const (
34 HostComputeNetworkSettings_Transparent HostComputeNetworkSettings_NetworkMode = 0
35 HostComputeNetworkSettings_NAT HostComputeNetworkSettings_NetworkMode = 1
36 )
37
38 var HostComputeNetworkSettings_NetworkMode_name = map[int32]string{
39 0: "Transparent",
40 1: "NAT",
41 }
42
43 var HostComputeNetworkSettings_NetworkMode_value = map[string]int32{
44 "Transparent": 0,
45 "NAT": 1,
46 }
47
48 func (x HostComputeNetworkSettings_NetworkMode) String() string {
49 return proto.EnumName(HostComputeNetworkSettings_NetworkMode_name, int32(x))
50 }
51
52 func (HostComputeNetworkSettings_NetworkMode) EnumDescriptor() ([]byte, []int) {
53 return fileDescriptor_f8f0dd742f8ac3db, []int{9, 0}
54 }
55
56 type HostComputeNetworkSettings_IpamType int32
57
58 const (
59 HostComputeNetworkSettings_Static HostComputeNetworkSettings_IpamType = 0
60 HostComputeNetworkSettings_DHCP HostComputeNetworkSettings_IpamType = 1
61 )
62
63 var HostComputeNetworkSettings_IpamType_name = map[int32]string{
64 0: "Static",
65 1: "DHCP",
66 }
67
68 var HostComputeNetworkSettings_IpamType_value = map[string]int32{
69 "Static": 0,
70 "DHCP": 1,
71 }
72
73 func (x HostComputeNetworkSettings_IpamType) String() string {
74 return proto.EnumName(HostComputeNetworkSettings_IpamType_name, int32(x))
75 }
76
77 func (HostComputeNetworkSettings_IpamType) EnumDescriptor() ([]byte, []int) {
78 return fileDescriptor_f8f0dd742f8ac3db, []int{9, 1}
79 }
80
81 type AddNICRequest struct {
82 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
83 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
84 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
85 EndpointSettings *EndpointSettings `protobuf:"bytes,4,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
86 XXX_NoUnkeyedLiteral struct{} `json:"-"`
87 XXX_unrecognized []byte `json:"-"`
88 XXX_sizecache int32 `json:"-"`
89 }
90
91 func (m *AddNICRequest) Reset() { *m = AddNICRequest{} }
92 func (*AddNICRequest) ProtoMessage() {}
93 func (*AddNICRequest) Descriptor() ([]byte, []int) {
94 return fileDescriptor_f8f0dd742f8ac3db, []int{0}
95 }
96 func (m *AddNICRequest) XXX_Unmarshal(b []byte) error {
97 return m.Unmarshal(b)
98 }
99 func (m *AddNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
100 if deterministic {
101 return xxx_messageInfo_AddNICRequest.Marshal(b, m, deterministic)
102 } else {
103 b = b[:cap(b)]
104 n, err := m.MarshalToSizedBuffer(b)
105 if err != nil {
106 return nil, err
107 }
108 return b[:n], nil
109 }
110 }
111 func (m *AddNICRequest) XXX_Merge(src proto.Message) {
112 xxx_messageInfo_AddNICRequest.Merge(m, src)
113 }
114 func (m *AddNICRequest) XXX_Size() int {
115 return m.Size()
116 }
117 func (m *AddNICRequest) XXX_DiscardUnknown() {
118 xxx_messageInfo_AddNICRequest.DiscardUnknown(m)
119 }
120
121 var xxx_messageInfo_AddNICRequest proto.InternalMessageInfo
122
123 type AddNICResponse struct {
124 XXX_NoUnkeyedLiteral struct{} `json:"-"`
125 XXX_unrecognized []byte `json:"-"`
126 XXX_sizecache int32 `json:"-"`
127 }
128
129 func (m *AddNICResponse) Reset() { *m = AddNICResponse{} }
130 func (*AddNICResponse) ProtoMessage() {}
131 func (*AddNICResponse) Descriptor() ([]byte, []int) {
132 return fileDescriptor_f8f0dd742f8ac3db, []int{1}
133 }
134 func (m *AddNICResponse) XXX_Unmarshal(b []byte) error {
135 return m.Unmarshal(b)
136 }
137 func (m *AddNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
138 if deterministic {
139 return xxx_messageInfo_AddNICResponse.Marshal(b, m, deterministic)
140 } else {
141 b = b[:cap(b)]
142 n, err := m.MarshalToSizedBuffer(b)
143 if err != nil {
144 return nil, err
145 }
146 return b[:n], nil
147 }
148 }
149 func (m *AddNICResponse) XXX_Merge(src proto.Message) {
150 xxx_messageInfo_AddNICResponse.Merge(m, src)
151 }
152 func (m *AddNICResponse) XXX_Size() int {
153 return m.Size()
154 }
155 func (m *AddNICResponse) XXX_DiscardUnknown() {
156 xxx_messageInfo_AddNICResponse.DiscardUnknown(m)
157 }
158
159 var xxx_messageInfo_AddNICResponse proto.InternalMessageInfo
160
161 type ModifyNICRequest struct {
162 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
163 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
164 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
165 EndpointSettings *EndpointSettings `protobuf:"bytes,4,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
166 XXX_NoUnkeyedLiteral struct{} `json:"-"`
167 XXX_unrecognized []byte `json:"-"`
168 XXX_sizecache int32 `json:"-"`
169 }
170
171 func (m *ModifyNICRequest) Reset() { *m = ModifyNICRequest{} }
172 func (*ModifyNICRequest) ProtoMessage() {}
173 func (*ModifyNICRequest) Descriptor() ([]byte, []int) {
174 return fileDescriptor_f8f0dd742f8ac3db, []int{2}
175 }
176 func (m *ModifyNICRequest) XXX_Unmarshal(b []byte) error {
177 return m.Unmarshal(b)
178 }
179 func (m *ModifyNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
180 if deterministic {
181 return xxx_messageInfo_ModifyNICRequest.Marshal(b, m, deterministic)
182 } else {
183 b = b[:cap(b)]
184 n, err := m.MarshalToSizedBuffer(b)
185 if err != nil {
186 return nil, err
187 }
188 return b[:n], nil
189 }
190 }
191 func (m *ModifyNICRequest) XXX_Merge(src proto.Message) {
192 xxx_messageInfo_ModifyNICRequest.Merge(m, src)
193 }
194 func (m *ModifyNICRequest) XXX_Size() int {
195 return m.Size()
196 }
197 func (m *ModifyNICRequest) XXX_DiscardUnknown() {
198 xxx_messageInfo_ModifyNICRequest.DiscardUnknown(m)
199 }
200
201 var xxx_messageInfo_ModifyNICRequest proto.InternalMessageInfo
202
203 type ModifyNICResponse struct {
204 XXX_NoUnkeyedLiteral struct{} `json:"-"`
205 XXX_unrecognized []byte `json:"-"`
206 XXX_sizecache int32 `json:"-"`
207 }
208
209 func (m *ModifyNICResponse) Reset() { *m = ModifyNICResponse{} }
210 func (*ModifyNICResponse) ProtoMessage() {}
211 func (*ModifyNICResponse) Descriptor() ([]byte, []int) {
212 return fileDescriptor_f8f0dd742f8ac3db, []int{3}
213 }
214 func (m *ModifyNICResponse) XXX_Unmarshal(b []byte) error {
215 return m.Unmarshal(b)
216 }
217 func (m *ModifyNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
218 if deterministic {
219 return xxx_messageInfo_ModifyNICResponse.Marshal(b, m, deterministic)
220 } else {
221 b = b[:cap(b)]
222 n, err := m.MarshalToSizedBuffer(b)
223 if err != nil {
224 return nil, err
225 }
226 return b[:n], nil
227 }
228 }
229 func (m *ModifyNICResponse) XXX_Merge(src proto.Message) {
230 xxx_messageInfo_ModifyNICResponse.Merge(m, src)
231 }
232 func (m *ModifyNICResponse) XXX_Size() int {
233 return m.Size()
234 }
235 func (m *ModifyNICResponse) XXX_DiscardUnknown() {
236 xxx_messageInfo_ModifyNICResponse.DiscardUnknown(m)
237 }
238
239 var xxx_messageInfo_ModifyNICResponse proto.InternalMessageInfo
240
241 type DeleteNICRequest struct {
242 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
243 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
244 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
245 XXX_NoUnkeyedLiteral struct{} `json:"-"`
246 XXX_unrecognized []byte `json:"-"`
247 XXX_sizecache int32 `json:"-"`
248 }
249
250 func (m *DeleteNICRequest) Reset() { *m = DeleteNICRequest{} }
251 func (*DeleteNICRequest) ProtoMessage() {}
252 func (*DeleteNICRequest) Descriptor() ([]byte, []int) {
253 return fileDescriptor_f8f0dd742f8ac3db, []int{4}
254 }
255 func (m *DeleteNICRequest) XXX_Unmarshal(b []byte) error {
256 return m.Unmarshal(b)
257 }
258 func (m *DeleteNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
259 if deterministic {
260 return xxx_messageInfo_DeleteNICRequest.Marshal(b, m, deterministic)
261 } else {
262 b = b[:cap(b)]
263 n, err := m.MarshalToSizedBuffer(b)
264 if err != nil {
265 return nil, err
266 }
267 return b[:n], nil
268 }
269 }
270 func (m *DeleteNICRequest) XXX_Merge(src proto.Message) {
271 xxx_messageInfo_DeleteNICRequest.Merge(m, src)
272 }
273 func (m *DeleteNICRequest) XXX_Size() int {
274 return m.Size()
275 }
276 func (m *DeleteNICRequest) XXX_DiscardUnknown() {
277 xxx_messageInfo_DeleteNICRequest.DiscardUnknown(m)
278 }
279
280 var xxx_messageInfo_DeleteNICRequest proto.InternalMessageInfo
281
282 type DeleteNICResponse struct {
283 XXX_NoUnkeyedLiteral struct{} `json:"-"`
284 XXX_unrecognized []byte `json:"-"`
285 XXX_sizecache int32 `json:"-"`
286 }
287
288 func (m *DeleteNICResponse) Reset() { *m = DeleteNICResponse{} }
289 func (*DeleteNICResponse) ProtoMessage() {}
290 func (*DeleteNICResponse) Descriptor() ([]byte, []int) {
291 return fileDescriptor_f8f0dd742f8ac3db, []int{5}
292 }
293 func (m *DeleteNICResponse) XXX_Unmarshal(b []byte) error {
294 return m.Unmarshal(b)
295 }
296 func (m *DeleteNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
297 if deterministic {
298 return xxx_messageInfo_DeleteNICResponse.Marshal(b, m, deterministic)
299 } else {
300 b = b[:cap(b)]
301 n, err := m.MarshalToSizedBuffer(b)
302 if err != nil {
303 return nil, err
304 }
305 return b[:n], nil
306 }
307 }
308 func (m *DeleteNICResponse) XXX_Merge(src proto.Message) {
309 xxx_messageInfo_DeleteNICResponse.Merge(m, src)
310 }
311 func (m *DeleteNICResponse) XXX_Size() int {
312 return m.Size()
313 }
314 func (m *DeleteNICResponse) XXX_DiscardUnknown() {
315 xxx_messageInfo_DeleteNICResponse.DiscardUnknown(m)
316 }
317
318 var xxx_messageInfo_DeleteNICResponse proto.InternalMessageInfo
319
320 type CreateNetworkRequest struct {
321 Network *Network `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"`
322 XXX_NoUnkeyedLiteral struct{} `json:"-"`
323 XXX_unrecognized []byte `json:"-"`
324 XXX_sizecache int32 `json:"-"`
325 }
326
327 func (m *CreateNetworkRequest) Reset() { *m = CreateNetworkRequest{} }
328 func (*CreateNetworkRequest) ProtoMessage() {}
329 func (*CreateNetworkRequest) Descriptor() ([]byte, []int) {
330 return fileDescriptor_f8f0dd742f8ac3db, []int{6}
331 }
332 func (m *CreateNetworkRequest) XXX_Unmarshal(b []byte) error {
333 return m.Unmarshal(b)
334 }
335 func (m *CreateNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
336 if deterministic {
337 return xxx_messageInfo_CreateNetworkRequest.Marshal(b, m, deterministic)
338 } else {
339 b = b[:cap(b)]
340 n, err := m.MarshalToSizedBuffer(b)
341 if err != nil {
342 return nil, err
343 }
344 return b[:n], nil
345 }
346 }
347 func (m *CreateNetworkRequest) XXX_Merge(src proto.Message) {
348 xxx_messageInfo_CreateNetworkRequest.Merge(m, src)
349 }
350 func (m *CreateNetworkRequest) XXX_Size() int {
351 return m.Size()
352 }
353 func (m *CreateNetworkRequest) XXX_DiscardUnknown() {
354 xxx_messageInfo_CreateNetworkRequest.DiscardUnknown(m)
355 }
356
357 var xxx_messageInfo_CreateNetworkRequest proto.InternalMessageInfo
358
359 type Network struct {
360
361
362
363
364 Settings isNetwork_Settings `protobuf_oneof:"settings"`
365 XXX_NoUnkeyedLiteral struct{} `json:"-"`
366 XXX_unrecognized []byte `json:"-"`
367 XXX_sizecache int32 `json:"-"`
368 }
369
370 func (m *Network) Reset() { *m = Network{} }
371 func (*Network) ProtoMessage() {}
372 func (*Network) Descriptor() ([]byte, []int) {
373 return fileDescriptor_f8f0dd742f8ac3db, []int{7}
374 }
375 func (m *Network) XXX_Unmarshal(b []byte) error {
376 return m.Unmarshal(b)
377 }
378 func (m *Network) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
379 if deterministic {
380 return xxx_messageInfo_Network.Marshal(b, m, deterministic)
381 } else {
382 b = b[:cap(b)]
383 n, err := m.MarshalToSizedBuffer(b)
384 if err != nil {
385 return nil, err
386 }
387 return b[:n], nil
388 }
389 }
390 func (m *Network) XXX_Merge(src proto.Message) {
391 xxx_messageInfo_Network.Merge(m, src)
392 }
393 func (m *Network) XXX_Size() int {
394 return m.Size()
395 }
396 func (m *Network) XXX_DiscardUnknown() {
397 xxx_messageInfo_Network.DiscardUnknown(m)
398 }
399
400 var xxx_messageInfo_Network proto.InternalMessageInfo
401
402 type isNetwork_Settings interface {
403 isNetwork_Settings()
404 MarshalTo([]byte) (int, error)
405 Size() int
406 }
407
408 type Network_HcnNetwork struct {
409 HcnNetwork *HostComputeNetworkSettings `protobuf:"bytes,1,opt,name=hcn_network,json=hcnNetwork,proto3,oneof" json:"hcn_network,omitempty"`
410 }
411 type Network_NcproxyNetwork struct {
412 NcproxyNetwork *NCProxyNetworkSettings `protobuf:"bytes,2,opt,name=ncproxy_network,json=ncproxyNetwork,proto3,oneof" json:"ncproxy_network,omitempty"`
413 }
414
415 func (*Network_HcnNetwork) isNetwork_Settings() {}
416 func (*Network_NcproxyNetwork) isNetwork_Settings() {}
417
418 func (m *Network) GetSettings() isNetwork_Settings {
419 if m != nil {
420 return m.Settings
421 }
422 return nil
423 }
424
425 func (m *Network) GetHcnNetwork() *HostComputeNetworkSettings {
426 if x, ok := m.GetSettings().(*Network_HcnNetwork); ok {
427 return x.HcnNetwork
428 }
429 return nil
430 }
431
432 func (m *Network) GetNcproxyNetwork() *NCProxyNetworkSettings {
433 if x, ok := m.GetSettings().(*Network_NcproxyNetwork); ok {
434 return x.NcproxyNetwork
435 }
436 return nil
437 }
438
439
440 func (*Network) XXX_OneofWrappers() []interface{} {
441 return []interface{}{
442 (*Network_HcnNetwork)(nil),
443 (*Network_NcproxyNetwork)(nil),
444 }
445 }
446
447 type NCProxyNetworkSettings struct {
448 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
449 XXX_NoUnkeyedLiteral struct{} `json:"-"`
450 XXX_unrecognized []byte `json:"-"`
451 XXX_sizecache int32 `json:"-"`
452 }
453
454 func (m *NCProxyNetworkSettings) Reset() { *m = NCProxyNetworkSettings{} }
455 func (*NCProxyNetworkSettings) ProtoMessage() {}
456 func (*NCProxyNetworkSettings) Descriptor() ([]byte, []int) {
457 return fileDescriptor_f8f0dd742f8ac3db, []int{8}
458 }
459 func (m *NCProxyNetworkSettings) XXX_Unmarshal(b []byte) error {
460 return m.Unmarshal(b)
461 }
462 func (m *NCProxyNetworkSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
463 if deterministic {
464 return xxx_messageInfo_NCProxyNetworkSettings.Marshal(b, m, deterministic)
465 } else {
466 b = b[:cap(b)]
467 n, err := m.MarshalToSizedBuffer(b)
468 if err != nil {
469 return nil, err
470 }
471 return b[:n], nil
472 }
473 }
474 func (m *NCProxyNetworkSettings) XXX_Merge(src proto.Message) {
475 xxx_messageInfo_NCProxyNetworkSettings.Merge(m, src)
476 }
477 func (m *NCProxyNetworkSettings) XXX_Size() int {
478 return m.Size()
479 }
480 func (m *NCProxyNetworkSettings) XXX_DiscardUnknown() {
481 xxx_messageInfo_NCProxyNetworkSettings.DiscardUnknown(m)
482 }
483
484 var xxx_messageInfo_NCProxyNetworkSettings proto.InternalMessageInfo
485
486 type HostComputeNetworkSettings struct {
487 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
488 Mode HostComputeNetworkSettings_NetworkMode `protobuf:"varint,2,opt,name=mode,proto3,enum=ncproxygrpc.v1.HostComputeNetworkSettings_NetworkMode" json:"mode,omitempty"`
489 SwitchName string `protobuf:"bytes,3,opt,name=switch_name,json=switchName,proto3" json:"switch_name,omitempty"`
490 IpamType HostComputeNetworkSettings_IpamType `protobuf:"varint,4,opt,name=ipam_type,json=ipamType,proto3,enum=ncproxygrpc.v1.HostComputeNetworkSettings_IpamType" json:"ipam_type,omitempty"`
491 SubnetIpaddressPrefix []string `protobuf:"bytes,5,rep,name=subnet_ipaddress_prefix,json=subnetIpaddressPrefix,proto3" json:"subnet_ipaddress_prefix,omitempty"`
492 DefaultGateway string `protobuf:"bytes,6,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
493 SubnetIpaddressPrefixIpv6 []string `protobuf:"bytes,7,rep,name=subnet_ipaddress_prefix_ipv6,json=subnetIpaddressPrefixIpv6,proto3" json:"subnet_ipaddress_prefix_ipv6,omitempty"`
494 DefaultGatewayIpv6 string `protobuf:"bytes,8,opt,name=default_gateway_ipv6,json=defaultGatewayIpv6,proto3" json:"default_gateway_ipv6,omitempty"`
495 XXX_NoUnkeyedLiteral struct{} `json:"-"`
496 XXX_unrecognized []byte `json:"-"`
497 XXX_sizecache int32 `json:"-"`
498 }
499
500 func (m *HostComputeNetworkSettings) Reset() { *m = HostComputeNetworkSettings{} }
501 func (*HostComputeNetworkSettings) ProtoMessage() {}
502 func (*HostComputeNetworkSettings) Descriptor() ([]byte, []int) {
503 return fileDescriptor_f8f0dd742f8ac3db, []int{9}
504 }
505 func (m *HostComputeNetworkSettings) XXX_Unmarshal(b []byte) error {
506 return m.Unmarshal(b)
507 }
508 func (m *HostComputeNetworkSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
509 if deterministic {
510 return xxx_messageInfo_HostComputeNetworkSettings.Marshal(b, m, deterministic)
511 } else {
512 b = b[:cap(b)]
513 n, err := m.MarshalToSizedBuffer(b)
514 if err != nil {
515 return nil, err
516 }
517 return b[:n], nil
518 }
519 }
520 func (m *HostComputeNetworkSettings) XXX_Merge(src proto.Message) {
521 xxx_messageInfo_HostComputeNetworkSettings.Merge(m, src)
522 }
523 func (m *HostComputeNetworkSettings) XXX_Size() int {
524 return m.Size()
525 }
526 func (m *HostComputeNetworkSettings) XXX_DiscardUnknown() {
527 xxx_messageInfo_HostComputeNetworkSettings.DiscardUnknown(m)
528 }
529
530 var xxx_messageInfo_HostComputeNetworkSettings proto.InternalMessageInfo
531
532 type CreateNetworkResponse struct {
533 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
534 XXX_NoUnkeyedLiteral struct{} `json:"-"`
535 XXX_unrecognized []byte `json:"-"`
536 XXX_sizecache int32 `json:"-"`
537 }
538
539 func (m *CreateNetworkResponse) Reset() { *m = CreateNetworkResponse{} }
540 func (*CreateNetworkResponse) ProtoMessage() {}
541 func (*CreateNetworkResponse) Descriptor() ([]byte, []int) {
542 return fileDescriptor_f8f0dd742f8ac3db, []int{10}
543 }
544 func (m *CreateNetworkResponse) XXX_Unmarshal(b []byte) error {
545 return m.Unmarshal(b)
546 }
547 func (m *CreateNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
548 if deterministic {
549 return xxx_messageInfo_CreateNetworkResponse.Marshal(b, m, deterministic)
550 } else {
551 b = b[:cap(b)]
552 n, err := m.MarshalToSizedBuffer(b)
553 if err != nil {
554 return nil, err
555 }
556 return b[:n], nil
557 }
558 }
559 func (m *CreateNetworkResponse) XXX_Merge(src proto.Message) {
560 xxx_messageInfo_CreateNetworkResponse.Merge(m, src)
561 }
562 func (m *CreateNetworkResponse) XXX_Size() int {
563 return m.Size()
564 }
565 func (m *CreateNetworkResponse) XXX_DiscardUnknown() {
566 xxx_messageInfo_CreateNetworkResponse.DiscardUnknown(m)
567 }
568
569 var xxx_messageInfo_CreateNetworkResponse proto.InternalMessageInfo
570
571 type PortNameEndpointPolicySetting struct {
572 PortName string `protobuf:"bytes,1,opt,name=port_name,json=portName,proto3" json:"port_name,omitempty"`
573 XXX_NoUnkeyedLiteral struct{} `json:"-"`
574 XXX_unrecognized []byte `json:"-"`
575 XXX_sizecache int32 `json:"-"`
576 }
577
578 func (m *PortNameEndpointPolicySetting) Reset() { *m = PortNameEndpointPolicySetting{} }
579 func (*PortNameEndpointPolicySetting) ProtoMessage() {}
580 func (*PortNameEndpointPolicySetting) Descriptor() ([]byte, []int) {
581 return fileDescriptor_f8f0dd742f8ac3db, []int{11}
582 }
583 func (m *PortNameEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
584 return m.Unmarshal(b)
585 }
586 func (m *PortNameEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
587 if deterministic {
588 return xxx_messageInfo_PortNameEndpointPolicySetting.Marshal(b, m, deterministic)
589 } else {
590 b = b[:cap(b)]
591 n, err := m.MarshalToSizedBuffer(b)
592 if err != nil {
593 return nil, err
594 }
595 return b[:n], nil
596 }
597 }
598 func (m *PortNameEndpointPolicySetting) XXX_Merge(src proto.Message) {
599 xxx_messageInfo_PortNameEndpointPolicySetting.Merge(m, src)
600 }
601 func (m *PortNameEndpointPolicySetting) XXX_Size() int {
602 return m.Size()
603 }
604 func (m *PortNameEndpointPolicySetting) XXX_DiscardUnknown() {
605 xxx_messageInfo_PortNameEndpointPolicySetting.DiscardUnknown(m)
606 }
607
608 var xxx_messageInfo_PortNameEndpointPolicySetting proto.InternalMessageInfo
609
610 type IovEndpointPolicySetting struct {
611 IovOffloadWeight uint32 `protobuf:"varint,1,opt,name=iov_offload_weight,json=iovOffloadWeight,proto3" json:"iov_offload_weight,omitempty"`
612 QueuePairsRequested uint32 `protobuf:"varint,2,opt,name=queue_pairs_requested,json=queuePairsRequested,proto3" json:"queue_pairs_requested,omitempty"`
613 InterruptModeration uint32 `protobuf:"varint,3,opt,name=interrupt_moderation,json=interruptModeration,proto3" json:"interrupt_moderation,omitempty"`
614 XXX_NoUnkeyedLiteral struct{} `json:"-"`
615 XXX_unrecognized []byte `json:"-"`
616 XXX_sizecache int32 `json:"-"`
617 }
618
619 func (m *IovEndpointPolicySetting) Reset() { *m = IovEndpointPolicySetting{} }
620 func (*IovEndpointPolicySetting) ProtoMessage() {}
621 func (*IovEndpointPolicySetting) Descriptor() ([]byte, []int) {
622 return fileDescriptor_f8f0dd742f8ac3db, []int{12}
623 }
624 func (m *IovEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
625 return m.Unmarshal(b)
626 }
627 func (m *IovEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
628 if deterministic {
629 return xxx_messageInfo_IovEndpointPolicySetting.Marshal(b, m, deterministic)
630 } else {
631 b = b[:cap(b)]
632 n, err := m.MarshalToSizedBuffer(b)
633 if err != nil {
634 return nil, err
635 }
636 return b[:n], nil
637 }
638 }
639 func (m *IovEndpointPolicySetting) XXX_Merge(src proto.Message) {
640 xxx_messageInfo_IovEndpointPolicySetting.Merge(m, src)
641 }
642 func (m *IovEndpointPolicySetting) XXX_Size() int {
643 return m.Size()
644 }
645 func (m *IovEndpointPolicySetting) XXX_DiscardUnknown() {
646 xxx_messageInfo_IovEndpointPolicySetting.DiscardUnknown(m)
647 }
648
649 var xxx_messageInfo_IovEndpointPolicySetting proto.InternalMessageInfo
650
651 type DnsSetting struct {
652 ServerIpAddrs []string `protobuf:"bytes,1,rep,name=server_ip_addrs,json=serverIpAddrs,proto3" json:"server_ip_addrs,omitempty"`
653 Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
654 Search []string `protobuf:"bytes,3,rep,name=search,proto3" json:"search,omitempty"`
655 XXX_NoUnkeyedLiteral struct{} `json:"-"`
656 XXX_unrecognized []byte `json:"-"`
657 XXX_sizecache int32 `json:"-"`
658 }
659
660 func (m *DnsSetting) Reset() { *m = DnsSetting{} }
661 func (*DnsSetting) ProtoMessage() {}
662 func (*DnsSetting) Descriptor() ([]byte, []int) {
663 return fileDescriptor_f8f0dd742f8ac3db, []int{13}
664 }
665 func (m *DnsSetting) XXX_Unmarshal(b []byte) error {
666 return m.Unmarshal(b)
667 }
668 func (m *DnsSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
669 if deterministic {
670 return xxx_messageInfo_DnsSetting.Marshal(b, m, deterministic)
671 } else {
672 b = b[:cap(b)]
673 n, err := m.MarshalToSizedBuffer(b)
674 if err != nil {
675 return nil, err
676 }
677 return b[:n], nil
678 }
679 }
680 func (m *DnsSetting) XXX_Merge(src proto.Message) {
681 xxx_messageInfo_DnsSetting.Merge(m, src)
682 }
683 func (m *DnsSetting) XXX_Size() int {
684 return m.Size()
685 }
686 func (m *DnsSetting) XXX_DiscardUnknown() {
687 xxx_messageInfo_DnsSetting.DiscardUnknown(m)
688 }
689
690 var xxx_messageInfo_DnsSetting proto.InternalMessageInfo
691
692 type CreateEndpointRequest struct {
693 EndpointSettings *EndpointSettings `protobuf:"bytes,1,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
694 XXX_NoUnkeyedLiteral struct{} `json:"-"`
695 XXX_unrecognized []byte `json:"-"`
696 XXX_sizecache int32 `json:"-"`
697 }
698
699 func (m *CreateEndpointRequest) Reset() { *m = CreateEndpointRequest{} }
700 func (*CreateEndpointRequest) ProtoMessage() {}
701 func (*CreateEndpointRequest) Descriptor() ([]byte, []int) {
702 return fileDescriptor_f8f0dd742f8ac3db, []int{14}
703 }
704 func (m *CreateEndpointRequest) XXX_Unmarshal(b []byte) error {
705 return m.Unmarshal(b)
706 }
707 func (m *CreateEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
708 if deterministic {
709 return xxx_messageInfo_CreateEndpointRequest.Marshal(b, m, deterministic)
710 } else {
711 b = b[:cap(b)]
712 n, err := m.MarshalToSizedBuffer(b)
713 if err != nil {
714 return nil, err
715 }
716 return b[:n], nil
717 }
718 }
719 func (m *CreateEndpointRequest) XXX_Merge(src proto.Message) {
720 xxx_messageInfo_CreateEndpointRequest.Merge(m, src)
721 }
722 func (m *CreateEndpointRequest) XXX_Size() int {
723 return m.Size()
724 }
725 func (m *CreateEndpointRequest) XXX_DiscardUnknown() {
726 xxx_messageInfo_CreateEndpointRequest.DiscardUnknown(m)
727 }
728
729 var xxx_messageInfo_CreateEndpointRequest proto.InternalMessageInfo
730
731 type EndpointSettings struct {
732
733
734
735
736 Settings isEndpointSettings_Settings `protobuf_oneof:"settings"`
737 XXX_NoUnkeyedLiteral struct{} `json:"-"`
738 XXX_unrecognized []byte `json:"-"`
739 XXX_sizecache int32 `json:"-"`
740 }
741
742 func (m *EndpointSettings) Reset() { *m = EndpointSettings{} }
743 func (*EndpointSettings) ProtoMessage() {}
744 func (*EndpointSettings) Descriptor() ([]byte, []int) {
745 return fileDescriptor_f8f0dd742f8ac3db, []int{15}
746 }
747 func (m *EndpointSettings) XXX_Unmarshal(b []byte) error {
748 return m.Unmarshal(b)
749 }
750 func (m *EndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
751 if deterministic {
752 return xxx_messageInfo_EndpointSettings.Marshal(b, m, deterministic)
753 } else {
754 b = b[:cap(b)]
755 n, err := m.MarshalToSizedBuffer(b)
756 if err != nil {
757 return nil, err
758 }
759 return b[:n], nil
760 }
761 }
762 func (m *EndpointSettings) XXX_Merge(src proto.Message) {
763 xxx_messageInfo_EndpointSettings.Merge(m, src)
764 }
765 func (m *EndpointSettings) XXX_Size() int {
766 return m.Size()
767 }
768 func (m *EndpointSettings) XXX_DiscardUnknown() {
769 xxx_messageInfo_EndpointSettings.DiscardUnknown(m)
770 }
771
772 var xxx_messageInfo_EndpointSettings proto.InternalMessageInfo
773
774 type isEndpointSettings_Settings interface {
775 isEndpointSettings_Settings()
776 MarshalTo([]byte) (int, error)
777 Size() int
778 }
779
780 type EndpointSettings_HcnEndpoint struct {
781 HcnEndpoint *HcnEndpointSettings `protobuf:"bytes,1,opt,name=hcn_endpoint,json=hcnEndpoint,proto3,oneof" json:"hcn_endpoint,omitempty"`
782 }
783 type EndpointSettings_NcproxyEndpoint struct {
784 NcproxyEndpoint *NCProxyEndpointSettings `protobuf:"bytes,2,opt,name=ncproxy_endpoint,json=ncproxyEndpoint,proto3,oneof" json:"ncproxy_endpoint,omitempty"`
785 }
786
787 func (*EndpointSettings_HcnEndpoint) isEndpointSettings_Settings() {}
788 func (*EndpointSettings_NcproxyEndpoint) isEndpointSettings_Settings() {}
789
790 func (m *EndpointSettings) GetSettings() isEndpointSettings_Settings {
791 if m != nil {
792 return m.Settings
793 }
794 return nil
795 }
796
797 func (m *EndpointSettings) GetHcnEndpoint() *HcnEndpointSettings {
798 if x, ok := m.GetSettings().(*EndpointSettings_HcnEndpoint); ok {
799 return x.HcnEndpoint
800 }
801 return nil
802 }
803
804 func (m *EndpointSettings) GetNcproxyEndpoint() *NCProxyEndpointSettings {
805 if x, ok := m.GetSettings().(*EndpointSettings_NcproxyEndpoint); ok {
806 return x.NcproxyEndpoint
807 }
808 return nil
809 }
810
811
812 func (*EndpointSettings) XXX_OneofWrappers() []interface{} {
813 return []interface{}{
814 (*EndpointSettings_HcnEndpoint)(nil),
815 (*EndpointSettings_NcproxyEndpoint)(nil),
816 }
817 }
818
819 type HcnEndpointResponse struct {
820 Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
821 ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
822 Settings *HcnEndpointSettings `protobuf:"bytes,3,opt,name=settings,proto3" json:"settings,omitempty"`
823 XXX_NoUnkeyedLiteral struct{} `json:"-"`
824 XXX_unrecognized []byte `json:"-"`
825 XXX_sizecache int32 `json:"-"`
826 }
827
828 func (m *HcnEndpointResponse) Reset() { *m = HcnEndpointResponse{} }
829 func (*HcnEndpointResponse) ProtoMessage() {}
830 func (*HcnEndpointResponse) Descriptor() ([]byte, []int) {
831 return fileDescriptor_f8f0dd742f8ac3db, []int{16}
832 }
833 func (m *HcnEndpointResponse) XXX_Unmarshal(b []byte) error {
834 return m.Unmarshal(b)
835 }
836 func (m *HcnEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
837 if deterministic {
838 return xxx_messageInfo_HcnEndpointResponse.Marshal(b, m, deterministic)
839 } else {
840 b = b[:cap(b)]
841 n, err := m.MarshalToSizedBuffer(b)
842 if err != nil {
843 return nil, err
844 }
845 return b[:n], nil
846 }
847 }
848 func (m *HcnEndpointResponse) XXX_Merge(src proto.Message) {
849 xxx_messageInfo_HcnEndpointResponse.Merge(m, src)
850 }
851 func (m *HcnEndpointResponse) XXX_Size() int {
852 return m.Size()
853 }
854 func (m *HcnEndpointResponse) XXX_DiscardUnknown() {
855 xxx_messageInfo_HcnEndpointResponse.DiscardUnknown(m)
856 }
857
858 var xxx_messageInfo_HcnEndpointResponse proto.InternalMessageInfo
859
860 type HcnEndpointSettings struct {
861 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
862 Macaddress string `protobuf:"bytes,2,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
863 Ipaddress string `protobuf:"bytes,3,opt,name=ipaddress,proto3" json:"ipaddress,omitempty"`
864 IpaddressPrefixlength uint32 `protobuf:"varint,4,opt,name=ipaddress_prefixlength,json=ipaddressPrefixlength,proto3" json:"ipaddress_prefixlength,omitempty"`
865 NetworkName string `protobuf:"bytes,5,opt,name=network_name,json=networkName,proto3" json:"network_name,omitempty"`
866 Policies *HcnEndpointPolicies `protobuf:"bytes,6,opt,name=policies,proto3" json:"policies,omitempty"`
867 DnsSetting *DnsSetting `protobuf:"bytes,7,opt,name=dns_setting,json=dnsSetting,proto3" json:"dns_setting,omitempty"`
868 Ipv6Address string `protobuf:"bytes,8,opt,name=ipv6address,proto3" json:"ipv6address,omitempty"`
869 Ipv6AddressPrefixlength uint32 `protobuf:"varint,9,opt,name=ipv6address_prefixlength,json=ipv6addressPrefixlength,proto3" json:"ipv6address_prefixlength,omitempty"`
870 XXX_NoUnkeyedLiteral struct{} `json:"-"`
871 XXX_unrecognized []byte `json:"-"`
872 XXX_sizecache int32 `json:"-"`
873 }
874
875 func (m *HcnEndpointSettings) Reset() { *m = HcnEndpointSettings{} }
876 func (*HcnEndpointSettings) ProtoMessage() {}
877 func (*HcnEndpointSettings) Descriptor() ([]byte, []int) {
878 return fileDescriptor_f8f0dd742f8ac3db, []int{17}
879 }
880 func (m *HcnEndpointSettings) XXX_Unmarshal(b []byte) error {
881 return m.Unmarshal(b)
882 }
883 func (m *HcnEndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
884 if deterministic {
885 return xxx_messageInfo_HcnEndpointSettings.Marshal(b, m, deterministic)
886 } else {
887 b = b[:cap(b)]
888 n, err := m.MarshalToSizedBuffer(b)
889 if err != nil {
890 return nil, err
891 }
892 return b[:n], nil
893 }
894 }
895 func (m *HcnEndpointSettings) XXX_Merge(src proto.Message) {
896 xxx_messageInfo_HcnEndpointSettings.Merge(m, src)
897 }
898 func (m *HcnEndpointSettings) XXX_Size() int {
899 return m.Size()
900 }
901 func (m *HcnEndpointSettings) XXX_DiscardUnknown() {
902 xxx_messageInfo_HcnEndpointSettings.DiscardUnknown(m)
903 }
904
905 var xxx_messageInfo_HcnEndpointSettings proto.InternalMessageInfo
906
907 type HcnEndpointPolicies struct {
908 PortnamePolicySetting *PortNameEndpointPolicySetting `protobuf:"bytes,1,opt,name=portname_policy_setting,json=portnamePolicySetting,proto3" json:"portname_policy_setting,omitempty"`
909 IovPolicySettings *IovEndpointPolicySetting `protobuf:"bytes,2,opt,name=iov_policy_settings,json=iovPolicySettings,proto3" json:"iov_policy_settings,omitempty"`
910 XXX_NoUnkeyedLiteral struct{} `json:"-"`
911 XXX_unrecognized []byte `json:"-"`
912 XXX_sizecache int32 `json:"-"`
913 }
914
915 func (m *HcnEndpointPolicies) Reset() { *m = HcnEndpointPolicies{} }
916 func (*HcnEndpointPolicies) ProtoMessage() {}
917 func (*HcnEndpointPolicies) Descriptor() ([]byte, []int) {
918 return fileDescriptor_f8f0dd742f8ac3db, []int{18}
919 }
920 func (m *HcnEndpointPolicies) XXX_Unmarshal(b []byte) error {
921 return m.Unmarshal(b)
922 }
923 func (m *HcnEndpointPolicies) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
924 if deterministic {
925 return xxx_messageInfo_HcnEndpointPolicies.Marshal(b, m, deterministic)
926 } else {
927 b = b[:cap(b)]
928 n, err := m.MarshalToSizedBuffer(b)
929 if err != nil {
930 return nil, err
931 }
932 return b[:n], nil
933 }
934 }
935 func (m *HcnEndpointPolicies) XXX_Merge(src proto.Message) {
936 xxx_messageInfo_HcnEndpointPolicies.Merge(m, src)
937 }
938 func (m *HcnEndpointPolicies) XXX_Size() int {
939 return m.Size()
940 }
941 func (m *HcnEndpointPolicies) XXX_DiscardUnknown() {
942 xxx_messageInfo_HcnEndpointPolicies.DiscardUnknown(m)
943 }
944
945 var xxx_messageInfo_HcnEndpointPolicies proto.InternalMessageInfo
946
947 type NCProxyEndpointSettings struct {
948 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
949 Macaddress string `protobuf:"bytes,2,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
950 Ipaddress string `protobuf:"bytes,3,opt,name=ipaddress,proto3" json:"ipaddress,omitempty"`
951 IpaddressPrefixlength uint32 `protobuf:"varint,4,opt,name=ipaddress_prefixlength,json=ipaddressPrefixlength,proto3" json:"ipaddress_prefixlength,omitempty"`
952 NetworkName string `protobuf:"bytes,5,opt,name=network_name,json=networkName,proto3" json:"network_name,omitempty"`
953 DefaultGateway string `protobuf:"bytes,6,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
954
955
956
957 DeviceDetails isNCProxyEndpointSettings_DeviceDetails `protobuf_oneof:"device_details"`
958 Ipv6Address string `protobuf:"bytes,8,opt,name=ipv6address,proto3" json:"ipv6address,omitempty"`
959 Ipv6AddressPrefixlength string `protobuf:"bytes,9,opt,name=ipv6address_prefixlength,json=ipv6addressPrefixlength,proto3" json:"ipv6address_prefixlength,omitempty"`
960 XXX_NoUnkeyedLiteral struct{} `json:"-"`
961 XXX_unrecognized []byte `json:"-"`
962 XXX_sizecache int32 `json:"-"`
963 }
964
965 func (m *NCProxyEndpointSettings) Reset() { *m = NCProxyEndpointSettings{} }
966 func (*NCProxyEndpointSettings) ProtoMessage() {}
967 func (*NCProxyEndpointSettings) Descriptor() ([]byte, []int) {
968 return fileDescriptor_f8f0dd742f8ac3db, []int{19}
969 }
970 func (m *NCProxyEndpointSettings) XXX_Unmarshal(b []byte) error {
971 return m.Unmarshal(b)
972 }
973 func (m *NCProxyEndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
974 if deterministic {
975 return xxx_messageInfo_NCProxyEndpointSettings.Marshal(b, m, deterministic)
976 } else {
977 b = b[:cap(b)]
978 n, err := m.MarshalToSizedBuffer(b)
979 if err != nil {
980 return nil, err
981 }
982 return b[:n], nil
983 }
984 }
985 func (m *NCProxyEndpointSettings) XXX_Merge(src proto.Message) {
986 xxx_messageInfo_NCProxyEndpointSettings.Merge(m, src)
987 }
988 func (m *NCProxyEndpointSettings) XXX_Size() int {
989 return m.Size()
990 }
991 func (m *NCProxyEndpointSettings) XXX_DiscardUnknown() {
992 xxx_messageInfo_NCProxyEndpointSettings.DiscardUnknown(m)
993 }
994
995 var xxx_messageInfo_NCProxyEndpointSettings proto.InternalMessageInfo
996
997 type isNCProxyEndpointSettings_DeviceDetails interface {
998 isNCProxyEndpointSettings_DeviceDetails()
999 MarshalTo([]byte) (int, error)
1000 Size() int
1001 }
1002
1003 type NCProxyEndpointSettings_PciDeviceDetails struct {
1004 PciDeviceDetails *PCIDeviceDetails `protobuf:"bytes,7,opt,name=pci_device_details,json=pciDeviceDetails,proto3,oneof" json:"pci_device_details,omitempty"`
1005 }
1006
1007 func (*NCProxyEndpointSettings_PciDeviceDetails) isNCProxyEndpointSettings_DeviceDetails() {}
1008
1009 func (m *NCProxyEndpointSettings) GetDeviceDetails() isNCProxyEndpointSettings_DeviceDetails {
1010 if m != nil {
1011 return m.DeviceDetails
1012 }
1013 return nil
1014 }
1015
1016 func (m *NCProxyEndpointSettings) GetPciDeviceDetails() *PCIDeviceDetails {
1017 if x, ok := m.GetDeviceDetails().(*NCProxyEndpointSettings_PciDeviceDetails); ok {
1018 return x.PciDeviceDetails
1019 }
1020 return nil
1021 }
1022
1023
1024 func (*NCProxyEndpointSettings) XXX_OneofWrappers() []interface{} {
1025 return []interface{}{
1026 (*NCProxyEndpointSettings_PciDeviceDetails)(nil),
1027 }
1028 }
1029
1030 type PCIDeviceDetails struct {
1031 DeviceID string `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
1032 VirtualFunctionIndex uint32 `protobuf:"varint,2,opt,name=virtual_function_index,json=virtualFunctionIndex,proto3" json:"virtual_function_index,omitempty"`
1033 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1034 XXX_unrecognized []byte `json:"-"`
1035 XXX_sizecache int32 `json:"-"`
1036 }
1037
1038 func (m *PCIDeviceDetails) Reset() { *m = PCIDeviceDetails{} }
1039 func (*PCIDeviceDetails) ProtoMessage() {}
1040 func (*PCIDeviceDetails) Descriptor() ([]byte, []int) {
1041 return fileDescriptor_f8f0dd742f8ac3db, []int{20}
1042 }
1043 func (m *PCIDeviceDetails) XXX_Unmarshal(b []byte) error {
1044 return m.Unmarshal(b)
1045 }
1046 func (m *PCIDeviceDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1047 if deterministic {
1048 return xxx_messageInfo_PCIDeviceDetails.Marshal(b, m, deterministic)
1049 } else {
1050 b = b[:cap(b)]
1051 n, err := m.MarshalToSizedBuffer(b)
1052 if err != nil {
1053 return nil, err
1054 }
1055 return b[:n], nil
1056 }
1057 }
1058 func (m *PCIDeviceDetails) XXX_Merge(src proto.Message) {
1059 xxx_messageInfo_PCIDeviceDetails.Merge(m, src)
1060 }
1061 func (m *PCIDeviceDetails) XXX_Size() int {
1062 return m.Size()
1063 }
1064 func (m *PCIDeviceDetails) XXX_DiscardUnknown() {
1065 xxx_messageInfo_PCIDeviceDetails.DiscardUnknown(m)
1066 }
1067
1068 var xxx_messageInfo_PCIDeviceDetails proto.InternalMessageInfo
1069
1070 type CreateEndpointResponse struct {
1071 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
1072 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1073 XXX_unrecognized []byte `json:"-"`
1074 XXX_sizecache int32 `json:"-"`
1075 }
1076
1077 func (m *CreateEndpointResponse) Reset() { *m = CreateEndpointResponse{} }
1078 func (*CreateEndpointResponse) ProtoMessage() {}
1079 func (*CreateEndpointResponse) Descriptor() ([]byte, []int) {
1080 return fileDescriptor_f8f0dd742f8ac3db, []int{21}
1081 }
1082 func (m *CreateEndpointResponse) XXX_Unmarshal(b []byte) error {
1083 return m.Unmarshal(b)
1084 }
1085 func (m *CreateEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1086 if deterministic {
1087 return xxx_messageInfo_CreateEndpointResponse.Marshal(b, m, deterministic)
1088 } else {
1089 b = b[:cap(b)]
1090 n, err := m.MarshalToSizedBuffer(b)
1091 if err != nil {
1092 return nil, err
1093 }
1094 return b[:n], nil
1095 }
1096 }
1097 func (m *CreateEndpointResponse) XXX_Merge(src proto.Message) {
1098 xxx_messageInfo_CreateEndpointResponse.Merge(m, src)
1099 }
1100 func (m *CreateEndpointResponse) XXX_Size() int {
1101 return m.Size()
1102 }
1103 func (m *CreateEndpointResponse) XXX_DiscardUnknown() {
1104 xxx_messageInfo_CreateEndpointResponse.DiscardUnknown(m)
1105 }
1106
1107 var xxx_messageInfo_CreateEndpointResponse proto.InternalMessageInfo
1108
1109 type AddEndpointRequest struct {
1110 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
1111 NamespaceID string `protobuf:"bytes,2,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
1112 AttachToHost bool `protobuf:"varint,3,opt,name=attach_to_host,json=attachToHost,proto3" json:"attach_to_host,omitempty"`
1113 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1114 XXX_unrecognized []byte `json:"-"`
1115 XXX_sizecache int32 `json:"-"`
1116 }
1117
1118 func (m *AddEndpointRequest) Reset() { *m = AddEndpointRequest{} }
1119 func (*AddEndpointRequest) ProtoMessage() {}
1120 func (*AddEndpointRequest) Descriptor() ([]byte, []int) {
1121 return fileDescriptor_f8f0dd742f8ac3db, []int{22}
1122 }
1123 func (m *AddEndpointRequest) XXX_Unmarshal(b []byte) error {
1124 return m.Unmarshal(b)
1125 }
1126 func (m *AddEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1127 if deterministic {
1128 return xxx_messageInfo_AddEndpointRequest.Marshal(b, m, deterministic)
1129 } else {
1130 b = b[:cap(b)]
1131 n, err := m.MarshalToSizedBuffer(b)
1132 if err != nil {
1133 return nil, err
1134 }
1135 return b[:n], nil
1136 }
1137 }
1138 func (m *AddEndpointRequest) XXX_Merge(src proto.Message) {
1139 xxx_messageInfo_AddEndpointRequest.Merge(m, src)
1140 }
1141 func (m *AddEndpointRequest) XXX_Size() int {
1142 return m.Size()
1143 }
1144 func (m *AddEndpointRequest) XXX_DiscardUnknown() {
1145 xxx_messageInfo_AddEndpointRequest.DiscardUnknown(m)
1146 }
1147
1148 var xxx_messageInfo_AddEndpointRequest proto.InternalMessageInfo
1149
1150 type AddEndpointResponse struct {
1151 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1152 XXX_unrecognized []byte `json:"-"`
1153 XXX_sizecache int32 `json:"-"`
1154 }
1155
1156 func (m *AddEndpointResponse) Reset() { *m = AddEndpointResponse{} }
1157 func (*AddEndpointResponse) ProtoMessage() {}
1158 func (*AddEndpointResponse) Descriptor() ([]byte, []int) {
1159 return fileDescriptor_f8f0dd742f8ac3db, []int{23}
1160 }
1161 func (m *AddEndpointResponse) XXX_Unmarshal(b []byte) error {
1162 return m.Unmarshal(b)
1163 }
1164 func (m *AddEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1165 if deterministic {
1166 return xxx_messageInfo_AddEndpointResponse.Marshal(b, m, deterministic)
1167 } else {
1168 b = b[:cap(b)]
1169 n, err := m.MarshalToSizedBuffer(b)
1170 if err != nil {
1171 return nil, err
1172 }
1173 return b[:n], nil
1174 }
1175 }
1176 func (m *AddEndpointResponse) XXX_Merge(src proto.Message) {
1177 xxx_messageInfo_AddEndpointResponse.Merge(m, src)
1178 }
1179 func (m *AddEndpointResponse) XXX_Size() int {
1180 return m.Size()
1181 }
1182 func (m *AddEndpointResponse) XXX_DiscardUnknown() {
1183 xxx_messageInfo_AddEndpointResponse.DiscardUnknown(m)
1184 }
1185
1186 var xxx_messageInfo_AddEndpointResponse proto.InternalMessageInfo
1187
1188 type DeleteEndpointRequest struct {
1189 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
1190 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1191 XXX_unrecognized []byte `json:"-"`
1192 XXX_sizecache int32 `json:"-"`
1193 }
1194
1195 func (m *DeleteEndpointRequest) Reset() { *m = DeleteEndpointRequest{} }
1196 func (*DeleteEndpointRequest) ProtoMessage() {}
1197 func (*DeleteEndpointRequest) Descriptor() ([]byte, []int) {
1198 return fileDescriptor_f8f0dd742f8ac3db, []int{24}
1199 }
1200 func (m *DeleteEndpointRequest) XXX_Unmarshal(b []byte) error {
1201 return m.Unmarshal(b)
1202 }
1203 func (m *DeleteEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1204 if deterministic {
1205 return xxx_messageInfo_DeleteEndpointRequest.Marshal(b, m, deterministic)
1206 } else {
1207 b = b[:cap(b)]
1208 n, err := m.MarshalToSizedBuffer(b)
1209 if err != nil {
1210 return nil, err
1211 }
1212 return b[:n], nil
1213 }
1214 }
1215 func (m *DeleteEndpointRequest) XXX_Merge(src proto.Message) {
1216 xxx_messageInfo_DeleteEndpointRequest.Merge(m, src)
1217 }
1218 func (m *DeleteEndpointRequest) XXX_Size() int {
1219 return m.Size()
1220 }
1221 func (m *DeleteEndpointRequest) XXX_DiscardUnknown() {
1222 xxx_messageInfo_DeleteEndpointRequest.DiscardUnknown(m)
1223 }
1224
1225 var xxx_messageInfo_DeleteEndpointRequest proto.InternalMessageInfo
1226
1227 type DeleteEndpointResponse struct {
1228 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1229 XXX_unrecognized []byte `json:"-"`
1230 XXX_sizecache int32 `json:"-"`
1231 }
1232
1233 func (m *DeleteEndpointResponse) Reset() { *m = DeleteEndpointResponse{} }
1234 func (*DeleteEndpointResponse) ProtoMessage() {}
1235 func (*DeleteEndpointResponse) Descriptor() ([]byte, []int) {
1236 return fileDescriptor_f8f0dd742f8ac3db, []int{25}
1237 }
1238 func (m *DeleteEndpointResponse) XXX_Unmarshal(b []byte) error {
1239 return m.Unmarshal(b)
1240 }
1241 func (m *DeleteEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1242 if deterministic {
1243 return xxx_messageInfo_DeleteEndpointResponse.Marshal(b, m, deterministic)
1244 } else {
1245 b = b[:cap(b)]
1246 n, err := m.MarshalToSizedBuffer(b)
1247 if err != nil {
1248 return nil, err
1249 }
1250 return b[:n], nil
1251 }
1252 }
1253 func (m *DeleteEndpointResponse) XXX_Merge(src proto.Message) {
1254 xxx_messageInfo_DeleteEndpointResponse.Merge(m, src)
1255 }
1256 func (m *DeleteEndpointResponse) XXX_Size() int {
1257 return m.Size()
1258 }
1259 func (m *DeleteEndpointResponse) XXX_DiscardUnknown() {
1260 xxx_messageInfo_DeleteEndpointResponse.DiscardUnknown(m)
1261 }
1262
1263 var xxx_messageInfo_DeleteEndpointResponse proto.InternalMessageInfo
1264
1265 type DeleteNetworkRequest struct {
1266 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
1267 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1268 XXX_unrecognized []byte `json:"-"`
1269 XXX_sizecache int32 `json:"-"`
1270 }
1271
1272 func (m *DeleteNetworkRequest) Reset() { *m = DeleteNetworkRequest{} }
1273 func (*DeleteNetworkRequest) ProtoMessage() {}
1274 func (*DeleteNetworkRequest) Descriptor() ([]byte, []int) {
1275 return fileDescriptor_f8f0dd742f8ac3db, []int{26}
1276 }
1277 func (m *DeleteNetworkRequest) XXX_Unmarshal(b []byte) error {
1278 return m.Unmarshal(b)
1279 }
1280 func (m *DeleteNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1281 if deterministic {
1282 return xxx_messageInfo_DeleteNetworkRequest.Marshal(b, m, deterministic)
1283 } else {
1284 b = b[:cap(b)]
1285 n, err := m.MarshalToSizedBuffer(b)
1286 if err != nil {
1287 return nil, err
1288 }
1289 return b[:n], nil
1290 }
1291 }
1292 func (m *DeleteNetworkRequest) XXX_Merge(src proto.Message) {
1293 xxx_messageInfo_DeleteNetworkRequest.Merge(m, src)
1294 }
1295 func (m *DeleteNetworkRequest) XXX_Size() int {
1296 return m.Size()
1297 }
1298 func (m *DeleteNetworkRequest) XXX_DiscardUnknown() {
1299 xxx_messageInfo_DeleteNetworkRequest.DiscardUnknown(m)
1300 }
1301
1302 var xxx_messageInfo_DeleteNetworkRequest proto.InternalMessageInfo
1303
1304 type DeleteNetworkResponse struct {
1305 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1306 XXX_unrecognized []byte `json:"-"`
1307 XXX_sizecache int32 `json:"-"`
1308 }
1309
1310 func (m *DeleteNetworkResponse) Reset() { *m = DeleteNetworkResponse{} }
1311 func (*DeleteNetworkResponse) ProtoMessage() {}
1312 func (*DeleteNetworkResponse) Descriptor() ([]byte, []int) {
1313 return fileDescriptor_f8f0dd742f8ac3db, []int{27}
1314 }
1315 func (m *DeleteNetworkResponse) XXX_Unmarshal(b []byte) error {
1316 return m.Unmarshal(b)
1317 }
1318 func (m *DeleteNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1319 if deterministic {
1320 return xxx_messageInfo_DeleteNetworkResponse.Marshal(b, m, deterministic)
1321 } else {
1322 b = b[:cap(b)]
1323 n, err := m.MarshalToSizedBuffer(b)
1324 if err != nil {
1325 return nil, err
1326 }
1327 return b[:n], nil
1328 }
1329 }
1330 func (m *DeleteNetworkResponse) XXX_Merge(src proto.Message) {
1331 xxx_messageInfo_DeleteNetworkResponse.Merge(m, src)
1332 }
1333 func (m *DeleteNetworkResponse) XXX_Size() int {
1334 return m.Size()
1335 }
1336 func (m *DeleteNetworkResponse) XXX_DiscardUnknown() {
1337 xxx_messageInfo_DeleteNetworkResponse.DiscardUnknown(m)
1338 }
1339
1340 var xxx_messageInfo_DeleteNetworkResponse proto.InternalMessageInfo
1341
1342 type GetEndpointRequest struct {
1343 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
1344 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1345 XXX_unrecognized []byte `json:"-"`
1346 XXX_sizecache int32 `json:"-"`
1347 }
1348
1349 func (m *GetEndpointRequest) Reset() { *m = GetEndpointRequest{} }
1350 func (*GetEndpointRequest) ProtoMessage() {}
1351 func (*GetEndpointRequest) Descriptor() ([]byte, []int) {
1352 return fileDescriptor_f8f0dd742f8ac3db, []int{28}
1353 }
1354 func (m *GetEndpointRequest) XXX_Unmarshal(b []byte) error {
1355 return m.Unmarshal(b)
1356 }
1357 func (m *GetEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1358 if deterministic {
1359 return xxx_messageInfo_GetEndpointRequest.Marshal(b, m, deterministic)
1360 } else {
1361 b = b[:cap(b)]
1362 n, err := m.MarshalToSizedBuffer(b)
1363 if err != nil {
1364 return nil, err
1365 }
1366 return b[:n], nil
1367 }
1368 }
1369 func (m *GetEndpointRequest) XXX_Merge(src proto.Message) {
1370 xxx_messageInfo_GetEndpointRequest.Merge(m, src)
1371 }
1372 func (m *GetEndpointRequest) XXX_Size() int {
1373 return m.Size()
1374 }
1375 func (m *GetEndpointRequest) XXX_DiscardUnknown() {
1376 xxx_messageInfo_GetEndpointRequest.DiscardUnknown(m)
1377 }
1378
1379 var xxx_messageInfo_GetEndpointRequest proto.InternalMessageInfo
1380
1381 type GetEndpointResponse struct {
1382 Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
1383 ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
1384 Endpoint *EndpointSettings `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
1385 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1386 XXX_unrecognized []byte `json:"-"`
1387 XXX_sizecache int32 `json:"-"`
1388 }
1389
1390 func (m *GetEndpointResponse) Reset() { *m = GetEndpointResponse{} }
1391 func (*GetEndpointResponse) ProtoMessage() {}
1392 func (*GetEndpointResponse) Descriptor() ([]byte, []int) {
1393 return fileDescriptor_f8f0dd742f8ac3db, []int{29}
1394 }
1395 func (m *GetEndpointResponse) XXX_Unmarshal(b []byte) error {
1396 return m.Unmarshal(b)
1397 }
1398 func (m *GetEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1399 if deterministic {
1400 return xxx_messageInfo_GetEndpointResponse.Marshal(b, m, deterministic)
1401 } else {
1402 b = b[:cap(b)]
1403 n, err := m.MarshalToSizedBuffer(b)
1404 if err != nil {
1405 return nil, err
1406 }
1407 return b[:n], nil
1408 }
1409 }
1410 func (m *GetEndpointResponse) XXX_Merge(src proto.Message) {
1411 xxx_messageInfo_GetEndpointResponse.Merge(m, src)
1412 }
1413 func (m *GetEndpointResponse) XXX_Size() int {
1414 return m.Size()
1415 }
1416 func (m *GetEndpointResponse) XXX_DiscardUnknown() {
1417 xxx_messageInfo_GetEndpointResponse.DiscardUnknown(m)
1418 }
1419
1420 var xxx_messageInfo_GetEndpointResponse proto.InternalMessageInfo
1421
1422 type GetNetworkRequest struct {
1423 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
1424 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1425 XXX_unrecognized []byte `json:"-"`
1426 XXX_sizecache int32 `json:"-"`
1427 }
1428
1429 func (m *GetNetworkRequest) Reset() { *m = GetNetworkRequest{} }
1430 func (*GetNetworkRequest) ProtoMessage() {}
1431 func (*GetNetworkRequest) Descriptor() ([]byte, []int) {
1432 return fileDescriptor_f8f0dd742f8ac3db, []int{30}
1433 }
1434 func (m *GetNetworkRequest) XXX_Unmarshal(b []byte) error {
1435 return m.Unmarshal(b)
1436 }
1437 func (m *GetNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1438 if deterministic {
1439 return xxx_messageInfo_GetNetworkRequest.Marshal(b, m, deterministic)
1440 } else {
1441 b = b[:cap(b)]
1442 n, err := m.MarshalToSizedBuffer(b)
1443 if err != nil {
1444 return nil, err
1445 }
1446 return b[:n], nil
1447 }
1448 }
1449 func (m *GetNetworkRequest) XXX_Merge(src proto.Message) {
1450 xxx_messageInfo_GetNetworkRequest.Merge(m, src)
1451 }
1452 func (m *GetNetworkRequest) XXX_Size() int {
1453 return m.Size()
1454 }
1455 func (m *GetNetworkRequest) XXX_DiscardUnknown() {
1456 xxx_messageInfo_GetNetworkRequest.DiscardUnknown(m)
1457 }
1458
1459 var xxx_messageInfo_GetNetworkRequest proto.InternalMessageInfo
1460
1461 type GetNetworkResponse struct {
1462 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
1463 Network *Network `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
1464 MacRange *MacRange `protobuf:"bytes,3,opt,name=macRange,proto3" json:"macRange,omitempty"`
1465 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1466 XXX_unrecognized []byte `json:"-"`
1467 XXX_sizecache int32 `json:"-"`
1468 }
1469
1470 func (m *GetNetworkResponse) Reset() { *m = GetNetworkResponse{} }
1471 func (*GetNetworkResponse) ProtoMessage() {}
1472 func (*GetNetworkResponse) Descriptor() ([]byte, []int) {
1473 return fileDescriptor_f8f0dd742f8ac3db, []int{31}
1474 }
1475 func (m *GetNetworkResponse) XXX_Unmarshal(b []byte) error {
1476 return m.Unmarshal(b)
1477 }
1478 func (m *GetNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1479 if deterministic {
1480 return xxx_messageInfo_GetNetworkResponse.Marshal(b, m, deterministic)
1481 } else {
1482 b = b[:cap(b)]
1483 n, err := m.MarshalToSizedBuffer(b)
1484 if err != nil {
1485 return nil, err
1486 }
1487 return b[:n], nil
1488 }
1489 }
1490 func (m *GetNetworkResponse) XXX_Merge(src proto.Message) {
1491 xxx_messageInfo_GetNetworkResponse.Merge(m, src)
1492 }
1493 func (m *GetNetworkResponse) XXX_Size() int {
1494 return m.Size()
1495 }
1496 func (m *GetNetworkResponse) XXX_DiscardUnknown() {
1497 xxx_messageInfo_GetNetworkResponse.DiscardUnknown(m)
1498 }
1499
1500 var xxx_messageInfo_GetNetworkResponse proto.InternalMessageInfo
1501
1502 type MacRange struct {
1503 StartMacAddress string `protobuf:"bytes,1,opt,name=startMacAddress,proto3" json:"startMacAddress,omitempty"`
1504 EndMacAddress string `protobuf:"bytes,2,opt,name=endMacAddress,proto3" json:"endMacAddress,omitempty"`
1505 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1506 XXX_unrecognized []byte `json:"-"`
1507 XXX_sizecache int32 `json:"-"`
1508 }
1509
1510 func (m *MacRange) Reset() { *m = MacRange{} }
1511 func (*MacRange) ProtoMessage() {}
1512 func (*MacRange) Descriptor() ([]byte, []int) {
1513 return fileDescriptor_f8f0dd742f8ac3db, []int{32}
1514 }
1515 func (m *MacRange) XXX_Unmarshal(b []byte) error {
1516 return m.Unmarshal(b)
1517 }
1518 func (m *MacRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1519 if deterministic {
1520 return xxx_messageInfo_MacRange.Marshal(b, m, deterministic)
1521 } else {
1522 b = b[:cap(b)]
1523 n, err := m.MarshalToSizedBuffer(b)
1524 if err != nil {
1525 return nil, err
1526 }
1527 return b[:n], nil
1528 }
1529 }
1530 func (m *MacRange) XXX_Merge(src proto.Message) {
1531 xxx_messageInfo_MacRange.Merge(m, src)
1532 }
1533 func (m *MacRange) XXX_Size() int {
1534 return m.Size()
1535 }
1536 func (m *MacRange) XXX_DiscardUnknown() {
1537 xxx_messageInfo_MacRange.DiscardUnknown(m)
1538 }
1539
1540 var xxx_messageInfo_MacRange proto.InternalMessageInfo
1541
1542 type GetEndpointsRequest struct {
1543 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1544 XXX_unrecognized []byte `json:"-"`
1545 XXX_sizecache int32 `json:"-"`
1546 }
1547
1548 func (m *GetEndpointsRequest) Reset() { *m = GetEndpointsRequest{} }
1549 func (*GetEndpointsRequest) ProtoMessage() {}
1550 func (*GetEndpointsRequest) Descriptor() ([]byte, []int) {
1551 return fileDescriptor_f8f0dd742f8ac3db, []int{33}
1552 }
1553 func (m *GetEndpointsRequest) XXX_Unmarshal(b []byte) error {
1554 return m.Unmarshal(b)
1555 }
1556 func (m *GetEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1557 if deterministic {
1558 return xxx_messageInfo_GetEndpointsRequest.Marshal(b, m, deterministic)
1559 } else {
1560 b = b[:cap(b)]
1561 n, err := m.MarshalToSizedBuffer(b)
1562 if err != nil {
1563 return nil, err
1564 }
1565 return b[:n], nil
1566 }
1567 }
1568 func (m *GetEndpointsRequest) XXX_Merge(src proto.Message) {
1569 xxx_messageInfo_GetEndpointsRequest.Merge(m, src)
1570 }
1571 func (m *GetEndpointsRequest) XXX_Size() int {
1572 return m.Size()
1573 }
1574 func (m *GetEndpointsRequest) XXX_DiscardUnknown() {
1575 xxx_messageInfo_GetEndpointsRequest.DiscardUnknown(m)
1576 }
1577
1578 var xxx_messageInfo_GetEndpointsRequest proto.InternalMessageInfo
1579
1580 type GetEndpointsResponse struct {
1581 Endpoints []*GetEndpointResponse `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
1582 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1583 XXX_unrecognized []byte `json:"-"`
1584 XXX_sizecache int32 `json:"-"`
1585 }
1586
1587 func (m *GetEndpointsResponse) Reset() { *m = GetEndpointsResponse{} }
1588 func (*GetEndpointsResponse) ProtoMessage() {}
1589 func (*GetEndpointsResponse) Descriptor() ([]byte, []int) {
1590 return fileDescriptor_f8f0dd742f8ac3db, []int{34}
1591 }
1592 func (m *GetEndpointsResponse) XXX_Unmarshal(b []byte) error {
1593 return m.Unmarshal(b)
1594 }
1595 func (m *GetEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1596 if deterministic {
1597 return xxx_messageInfo_GetEndpointsResponse.Marshal(b, m, deterministic)
1598 } else {
1599 b = b[:cap(b)]
1600 n, err := m.MarshalToSizedBuffer(b)
1601 if err != nil {
1602 return nil, err
1603 }
1604 return b[:n], nil
1605 }
1606 }
1607 func (m *GetEndpointsResponse) XXX_Merge(src proto.Message) {
1608 xxx_messageInfo_GetEndpointsResponse.Merge(m, src)
1609 }
1610 func (m *GetEndpointsResponse) XXX_Size() int {
1611 return m.Size()
1612 }
1613 func (m *GetEndpointsResponse) XXX_DiscardUnknown() {
1614 xxx_messageInfo_GetEndpointsResponse.DiscardUnknown(m)
1615 }
1616
1617 var xxx_messageInfo_GetEndpointsResponse proto.InternalMessageInfo
1618
1619 type GetNetworksRequest struct {
1620 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1621 XXX_unrecognized []byte `json:"-"`
1622 XXX_sizecache int32 `json:"-"`
1623 }
1624
1625 func (m *GetNetworksRequest) Reset() { *m = GetNetworksRequest{} }
1626 func (*GetNetworksRequest) ProtoMessage() {}
1627 func (*GetNetworksRequest) Descriptor() ([]byte, []int) {
1628 return fileDescriptor_f8f0dd742f8ac3db, []int{35}
1629 }
1630 func (m *GetNetworksRequest) XXX_Unmarshal(b []byte) error {
1631 return m.Unmarshal(b)
1632 }
1633 func (m *GetNetworksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1634 if deterministic {
1635 return xxx_messageInfo_GetNetworksRequest.Marshal(b, m, deterministic)
1636 } else {
1637 b = b[:cap(b)]
1638 n, err := m.MarshalToSizedBuffer(b)
1639 if err != nil {
1640 return nil, err
1641 }
1642 return b[:n], nil
1643 }
1644 }
1645 func (m *GetNetworksRequest) XXX_Merge(src proto.Message) {
1646 xxx_messageInfo_GetNetworksRequest.Merge(m, src)
1647 }
1648 func (m *GetNetworksRequest) XXX_Size() int {
1649 return m.Size()
1650 }
1651 func (m *GetNetworksRequest) XXX_DiscardUnknown() {
1652 xxx_messageInfo_GetNetworksRequest.DiscardUnknown(m)
1653 }
1654
1655 var xxx_messageInfo_GetNetworksRequest proto.InternalMessageInfo
1656
1657 type GetNetworksResponse struct {
1658 Networks []*GetNetworkResponse `protobuf:"bytes,1,rep,name=networks,proto3" json:"networks,omitempty"`
1659 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1660 XXX_unrecognized []byte `json:"-"`
1661 XXX_sizecache int32 `json:"-"`
1662 }
1663
1664 func (m *GetNetworksResponse) Reset() { *m = GetNetworksResponse{} }
1665 func (*GetNetworksResponse) ProtoMessage() {}
1666 func (*GetNetworksResponse) Descriptor() ([]byte, []int) {
1667 return fileDescriptor_f8f0dd742f8ac3db, []int{36}
1668 }
1669 func (m *GetNetworksResponse) XXX_Unmarshal(b []byte) error {
1670 return m.Unmarshal(b)
1671 }
1672 func (m *GetNetworksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1673 if deterministic {
1674 return xxx_messageInfo_GetNetworksResponse.Marshal(b, m, deterministic)
1675 } else {
1676 b = b[:cap(b)]
1677 n, err := m.MarshalToSizedBuffer(b)
1678 if err != nil {
1679 return nil, err
1680 }
1681 return b[:n], nil
1682 }
1683 }
1684 func (m *GetNetworksResponse) XXX_Merge(src proto.Message) {
1685 xxx_messageInfo_GetNetworksResponse.Merge(m, src)
1686 }
1687 func (m *GetNetworksResponse) XXX_Size() int {
1688 return m.Size()
1689 }
1690 func (m *GetNetworksResponse) XXX_DiscardUnknown() {
1691 xxx_messageInfo_GetNetworksResponse.DiscardUnknown(m)
1692 }
1693
1694 var xxx_messageInfo_GetNetworksResponse proto.InternalMessageInfo
1695
1696 func init() {
1697 proto.RegisterEnum("ncproxygrpc.v1.HostComputeNetworkSettings_NetworkMode", HostComputeNetworkSettings_NetworkMode_name, HostComputeNetworkSettings_NetworkMode_value)
1698 proto.RegisterEnum("ncproxygrpc.v1.HostComputeNetworkSettings_IpamType", HostComputeNetworkSettings_IpamType_name, HostComputeNetworkSettings_IpamType_value)
1699 proto.RegisterType((*AddNICRequest)(nil), "ncproxygrpc.v1.AddNICRequest")
1700 proto.RegisterType((*AddNICResponse)(nil), "ncproxygrpc.v1.AddNICResponse")
1701 proto.RegisterType((*ModifyNICRequest)(nil), "ncproxygrpc.v1.ModifyNICRequest")
1702 proto.RegisterType((*ModifyNICResponse)(nil), "ncproxygrpc.v1.ModifyNICResponse")
1703 proto.RegisterType((*DeleteNICRequest)(nil), "ncproxygrpc.v1.DeleteNICRequest")
1704 proto.RegisterType((*DeleteNICResponse)(nil), "ncproxygrpc.v1.DeleteNICResponse")
1705 proto.RegisterType((*CreateNetworkRequest)(nil), "ncproxygrpc.v1.CreateNetworkRequest")
1706 proto.RegisterType((*Network)(nil), "ncproxygrpc.v1.Network")
1707 proto.RegisterType((*NCProxyNetworkSettings)(nil), "ncproxygrpc.v1.NCProxyNetworkSettings")
1708 proto.RegisterType((*HostComputeNetworkSettings)(nil), "ncproxygrpc.v1.HostComputeNetworkSettings")
1709 proto.RegisterType((*CreateNetworkResponse)(nil), "ncproxygrpc.v1.CreateNetworkResponse")
1710 proto.RegisterType((*PortNameEndpointPolicySetting)(nil), "ncproxygrpc.v1.PortNameEndpointPolicySetting")
1711 proto.RegisterType((*IovEndpointPolicySetting)(nil), "ncproxygrpc.v1.IovEndpointPolicySetting")
1712 proto.RegisterType((*DnsSetting)(nil), "ncproxygrpc.v1.DnsSetting")
1713 proto.RegisterType((*CreateEndpointRequest)(nil), "ncproxygrpc.v1.CreateEndpointRequest")
1714 proto.RegisterType((*EndpointSettings)(nil), "ncproxygrpc.v1.EndpointSettings")
1715 proto.RegisterType((*HcnEndpointResponse)(nil), "ncproxygrpc.v1.HcnEndpointResponse")
1716 proto.RegisterType((*HcnEndpointSettings)(nil), "ncproxygrpc.v1.HcnEndpointSettings")
1717 proto.RegisterType((*HcnEndpointPolicies)(nil), "ncproxygrpc.v1.HcnEndpointPolicies")
1718 proto.RegisterType((*NCProxyEndpointSettings)(nil), "ncproxygrpc.v1.NCProxyEndpointSettings")
1719 proto.RegisterType((*PCIDeviceDetails)(nil), "ncproxygrpc.v1.PCIDeviceDetails")
1720 proto.RegisterType((*CreateEndpointResponse)(nil), "ncproxygrpc.v1.CreateEndpointResponse")
1721 proto.RegisterType((*AddEndpointRequest)(nil), "ncproxygrpc.v1.AddEndpointRequest")
1722 proto.RegisterType((*AddEndpointResponse)(nil), "ncproxygrpc.v1.AddEndpointResponse")
1723 proto.RegisterType((*DeleteEndpointRequest)(nil), "ncproxygrpc.v1.DeleteEndpointRequest")
1724 proto.RegisterType((*DeleteEndpointResponse)(nil), "ncproxygrpc.v1.DeleteEndpointResponse")
1725 proto.RegisterType((*DeleteNetworkRequest)(nil), "ncproxygrpc.v1.DeleteNetworkRequest")
1726 proto.RegisterType((*DeleteNetworkResponse)(nil), "ncproxygrpc.v1.DeleteNetworkResponse")
1727 proto.RegisterType((*GetEndpointRequest)(nil), "ncproxygrpc.v1.GetEndpointRequest")
1728 proto.RegisterType((*GetEndpointResponse)(nil), "ncproxygrpc.v1.GetEndpointResponse")
1729 proto.RegisterType((*GetNetworkRequest)(nil), "ncproxygrpc.v1.GetNetworkRequest")
1730 proto.RegisterType((*GetNetworkResponse)(nil), "ncproxygrpc.v1.GetNetworkResponse")
1731 proto.RegisterType((*MacRange)(nil), "ncproxygrpc.v1.MacRange")
1732 proto.RegisterType((*GetEndpointsRequest)(nil), "ncproxygrpc.v1.GetEndpointsRequest")
1733 proto.RegisterType((*GetEndpointsResponse)(nil), "ncproxygrpc.v1.GetEndpointsResponse")
1734 proto.RegisterType((*GetNetworksRequest)(nil), "ncproxygrpc.v1.GetNetworksRequest")
1735 proto.RegisterType((*GetNetworksResponse)(nil), "ncproxygrpc.v1.GetNetworksResponse")
1736 }
1737
1738 func init() {
1739 proto.RegisterFile("github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1/networkconfigproxy.proto", fileDescriptor_f8f0dd742f8ac3db)
1740 }
1741
1742 var fileDescriptor_f8f0dd742f8ac3db = []byte{
1743
1744 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xdd, 0x73, 0xe3, 0x56,
1745 0x15, 0xb7, 0xe2, 0x6c, 0x22, 0x1f, 0x7f, 0xc4, 0x7b, 0x9d, 0x0f, 0x63, 0x5a, 0x27, 0xab, 0xdd,
1746 0xee, 0x86, 0x52, 0x92, 0xc6, 0x2d, 0x61, 0x18, 0x3a, 0xec, 0x24, 0x36, 0x6c, 0xd4, 0x19, 0x07,
1747 0x57, 0x4d, 0x87, 0x52, 0x66, 0xd0, 0x68, 0xa5, 0x6b, 0xfb, 0x4e, 0x63, 0x49, 0x95, 0xae, 0x9d,
1748 0xcd, 0x1b, 0xc3, 0x1b, 0x33, 0xc0, 0x1b, 0x6f, 0xfc, 0x0f, 0x7d, 0xe4, 0x8d, 0xe7, 0xbe, 0xc1,
1749 0x23, 0xcc, 0x30, 0x19, 0xea, 0xbf, 0x84, 0xd1, 0xd5, 0xbd, 0xb2, 0x24, 0xcb, 0x8e, 0x59, 0x78,
1750 0x00, 0x9e, 0x6c, 0x9d, 0xef, 0x73, 0xee, 0x39, 0xbf, 0xfb, 0x01, 0xbd, 0x01, 0xa1, 0xc3, 0xf1,
1751 0xcb, 0x23, 0xd3, 0x19, 0x1d, 0x77, 0x89, 0xe9, 0x39, 0xbe, 0xd3, 0xa7, 0xc7, 0x43, 0xd3, 0xf7,
1752 0x87, 0x64, 0x74, 0xec, 0x7e, 0x3e, 0x38, 0xb6, 0x4d, 0xd7, 0x73, 0x5e, 0xdd, 0x8a, 0xdf, 0x81,
1753 0xe7, 0x9a, 0xc7, 0x93, 0x93, 0x63, 0x1b, 0xd3, 0x1b, 0xc7, 0xfb, 0xdc, 0x74, 0xec, 0x3e, 0x19,
1754 0x30, 0xce, 0x91, 0xeb, 0x39, 0xd4, 0x41, 0x95, 0x98, 0xe0, 0xd1, 0xe4, 0x44, 0xf9, 0x9b, 0x04,
1755 0xe5, 0x33, 0xcb, 0xba, 0x54, 0xdb, 0x1a, 0xfe, 0x62, 0x8c, 0x7d, 0x8a, 0x5a, 0x50, 0x32, 0x1d,
1756 0x9b, 0x1a, 0xc4, 0xc6, 0x9e, 0x4e, 0xac, 0xba, 0x74, 0x20, 0x1d, 0x16, 0xce, 0xb7, 0xa6, 0x77,
1757 0xfb, 0xc5, 0xb6, 0xa0, 0xab, 0x1d, 0xad, 0x18, 0x09, 0xa9, 0x16, 0x3a, 0x80, 0x0d, 0x9b, 0x98,
1758 0x81, 0xf4, 0x1a, 0x93, 0x2e, 0x4c, 0xef, 0xf6, 0x1f, 0x5c, 0x12, 0x53, 0xed, 0x68, 0x0f, 0x6c,
1759 0x62, 0xaa, 0x16, 0x7a, 0x0c, 0x65, 0x6c, 0x5b, 0xae, 0x43, 0x6c, 0xaa, 0xdb, 0xc6, 0x08, 0xd7,
1760 0xf3, 0x81, 0xa0, 0x56, 0x12, 0xc4, 0x4b, 0x63, 0x84, 0x51, 0x17, 0x1e, 0x46, 0x42, 0x3e, 0xa6,
1761 0x94, 0xd8, 0x03, 0xbf, 0xbe, 0x7e, 0x20, 0x1d, 0x16, 0x5b, 0x07, 0x47, 0xc9, 0xc0, 0x8f, 0x7e,
1762 0xc4, 0x05, 0x3f, 0xe6, 0x72, 0x5a, 0x15, 0xa7, 0x28, 0x4a, 0x15, 0x2a, 0x22, 0x35, 0xdf, 0x75,
1763 0x6c, 0x1f, 0x2b, 0x7f, 0x97, 0xa0, 0xda, 0x75, 0x2c, 0xd2, 0xbf, 0xfd, 0xbf, 0x4c, 0xb8, 0x06,
1764 0x0f, 0x63, 0xd9, 0xf1, 0x9c, 0x7f, 0x2b, 0x41, 0xb5, 0x83, 0xaf, 0x31, 0xc5, 0xff, 0x15, 0x39,
1765 0x07, 0x41, 0xc6, 0xc2, 0xe1, 0x41, 0xaa, 0xb0, 0xdd, 0xf6, 0xb0, 0x41, 0xf1, 0x65, 0xd8, 0xb8,
1766 0x22, 0xce, 0x13, 0xd8, 0xe4, 0xad, 0xcc, 0x42, 0x2c, 0xb6, 0xf6, 0xd2, 0x65, 0x11, 0x0a, 0x42,
1767 0x4e, 0xf9, 0xa3, 0x04, 0x9b, 0x9c, 0x88, 0xba, 0x50, 0x1c, 0x9a, 0xb6, 0x9e, 0x34, 0xf1, 0x76,
1768 0xda, 0xc4, 0x85, 0xe3, 0xd3, 0xb6, 0x33, 0x72, 0xc7, 0x91, 0x7b, 0x51, 0xd1, 0x8b, 0x9c, 0x06,
1769 0x43, 0xd3, 0x16, 0xe6, 0x3e, 0x82, 0x2d, 0xae, 0x1a, 0x99, 0x5c, 0x63, 0x26, 0x9f, 0xce, 0x45,
1770 0xd5, 0xee, 0x05, 0x9f, 0xf3, 0xe6, 0xc4, 0xfc, 0x71, 0xce, 0x39, 0x80, 0x2c, 0x16, 0x5e, 0x79,
1771 0x07, 0x76, 0xb3, 0xf5, 0x10, 0x82, 0x75, 0x56, 0x4f, 0xb6, 0x4c, 0x1a, 0xfb, 0xaf, 0xfc, 0x6e,
1772 0x1d, 0x1a, 0x8b, 0x23, 0xcf, 0x52, 0x41, 0x1f, 0xc2, 0xfa, 0xc8, 0xb1, 0x30, 0x0b, 0xba, 0xd2,
1773 0x3a, 0x5d, 0xbd, 0x0e, 0xa2, 0xca, 0x5d, 0xc7, 0xc2, 0x1a, 0xb3, 0x81, 0xf6, 0xa1, 0xe8, 0xdf,
1774 0x10, 0x6a, 0x0e, 0xe3, 0x2b, 0x0d, 0x21, 0x89, 0xf5, 0x76, 0x0f, 0x0a, 0xc4, 0x35, 0x46, 0x3a,
1775 0xbd, 0x75, 0x31, 0xeb, 0xe9, 0x4a, 0xeb, 0xbd, 0x7f, 0xc1, 0xa3, 0xea, 0x1a, 0xa3, 0xab, 0x5b,
1776 0x17, 0x6b, 0x32, 0xe1, 0xff, 0xd0, 0x29, 0xec, 0xf9, 0xe3, 0x97, 0x36, 0xa6, 0x3a, 0x71, 0x0d,
1777 0xcb, 0xf2, 0xb0, 0xef, 0xeb, 0xae, 0x87, 0xfb, 0xe4, 0x55, 0xfd, 0xc1, 0x41, 0xfe, 0xb0, 0xa0,
1778 0xed, 0x84, 0x6c, 0x55, 0x70, 0x7b, 0x8c, 0x89, 0x9e, 0xc1, 0x96, 0x85, 0xfb, 0xc6, 0xf8, 0x9a,
1779 0xea, 0x03, 0x83, 0xe2, 0x1b, 0xe3, 0xb6, 0xbe, 0xc1, 0xc2, 0xad, 0x70, 0xf2, 0x8b, 0x90, 0x8a,
1780 0x9e, 0xc3, 0x1b, 0x0b, 0x1c, 0xe8, 0xc4, 0x9d, 0x9c, 0xd6, 0x37, 0x99, 0x97, 0x6f, 0x64, 0x7a,
1781 0x51, 0xdd, 0xc9, 0x29, 0x7a, 0x17, 0xb6, 0x53, 0x9e, 0x42, 0x45, 0x99, 0xb9, 0x43, 0x49, 0x77,
1782 0x81, 0x86, 0xf2, 0x0c, 0x8a, 0xb1, 0xda, 0xa2, 0x2d, 0x28, 0x5e, 0x79, 0x86, 0xed, 0xbb, 0x86,
1783 0x87, 0x6d, 0x5a, 0xcd, 0xa1, 0x4d, 0xc8, 0x5f, 0x9e, 0x5d, 0x55, 0x25, 0xe5, 0x00, 0x64, 0x51,
1784 0x12, 0x04, 0xb0, 0xf1, 0x31, 0x35, 0x28, 0x31, 0xab, 0x39, 0x24, 0xc3, 0x7a, 0xe7, 0xa2, 0xdd,
1785 0xab, 0x4a, 0xca, 0x31, 0xec, 0xa4, 0x66, 0x28, 0x1c, 0x2e, 0xb4, 0x0b, 0x6b, 0xd1, 0x88, 0x6f,
1786 0x4c, 0xef, 0xf6, 0xd7, 0xd4, 0x8e, 0xb6, 0x46, 0x2c, 0xe5, 0x03, 0x78, 0xb3, 0xe7, 0x78, 0x6c,
1787 0x2a, 0x05, 0xb8, 0xf4, 0x9c, 0x6b, 0x62, 0xde, 0xf2, 0x45, 0x40, 0xdf, 0x84, 0x82, 0xeb, 0x78,
1788 0x7c, 0x96, 0xc3, 0x46, 0x92, 0x5d, 0xae, 0xa1, 0x7c, 0x29, 0x41, 0x5d, 0x75, 0x26, 0xd9, 0x9a,
1789 0xef, 0x00, 0x22, 0xce, 0x44, 0x77, 0xfa, 0xfd, 0x6b, 0xc7, 0xb0, 0xf4, 0x1b, 0x4c, 0x06, 0x43,
1790 0xca, 0x4c, 0x94, 0xb5, 0x2a, 0x71, 0x26, 0x3f, 0x09, 0x19, 0x3f, 0x65, 0x74, 0xd4, 0x82, 0x9d,
1791 0x2f, 0xc6, 0x78, 0x8c, 0x75, 0xd7, 0x20, 0x9e, 0xaf, 0x7b, 0xe1, 0xf0, 0xe3, 0x10, 0x68, 0xca,
1792 0x5a, 0x8d, 0x31, 0x7b, 0x01, 0x4f, 0x13, 0x2c, 0x74, 0x02, 0xdb, 0xc4, 0xa6, 0xd8, 0xf3, 0xc6,
1793 0x2e, 0xd5, 0x83, 0x8e, 0xf4, 0x0c, 0x4a, 0x1c, 0x9b, 0x35, 0x62, 0x59, 0xab, 0x45, 0xbc, 0x6e,
1794 0xc4, 0x52, 0x2c, 0x80, 0x8e, 0xed, 0x8b, 0x10, 0x9f, 0xc2, 0x96, 0x8f, 0xbd, 0x49, 0x80, 0x7f,
1795 0xae, 0x1e, 0x2c, 0xa5, 0x5f, 0x97, 0xd8, 0xfa, 0x96, 0x43, 0xb2, 0xea, 0x9e, 0x05, 0x44, 0xb4,
1796 0x0b, 0x1b, 0x96, 0x33, 0x32, 0x88, 0x1d, 0xc2, 0x9e, 0xc6, 0xbf, 0x02, 0xba, 0x8f, 0x0d, 0xcf,
1797 0x1c, 0xd6, 0xf3, 0x4c, 0x8d, 0x7f, 0x29, 0x7d, 0xb1, 0x0c, 0xa2, 0x32, 0x02, 0xcb, 0x32, 0xc1,
1798 0x5e, 0x7a, 0x6d, 0xb0, 0xff, 0x93, 0x04, 0xd5, 0xb4, 0x18, 0xba, 0x80, 0x52, 0x00, 0x78, 0x42,
1799 0x98, 0x9b, 0x7f, 0x3c, 0x37, 0x77, 0xa6, 0x9d, 0x56, 0xbd, 0xc8, 0x69, 0x01, 0x56, 0x0a, 0x32,
1800 0xba, 0x82, 0xaa, 0xc0, 0xba, 0xc8, 0x5a, 0x08, 0x76, 0xcf, 0x16, 0x80, 0x5d, 0x86, 0x45, 0x01,
1801 0x97, 0x82, 0x95, 0x80, 0xbb, 0xdf, 0x48, 0x50, 0x8b, 0x05, 0x12, 0xb5, 0xeb, 0x1b, 0x50, 0x08,
1802 0x1a, 0xce, 0x77, 0x0d, 0x53, 0x74, 0xdd, 0x8c, 0xc0, 0x9b, 0x79, 0x2d, 0xdd, 0xcc, 0xe8, 0xf9,
1803 0xcc, 0x32, 0xeb, 0x81, 0xd5, 0xb2, 0xd6, 0x66, 0xe1, 0xfc, 0x21, 0x9f, 0x08, 0x67, 0x29, 0x90,
1804 0x36, 0x01, 0x46, 0x86, 0xc9, 0xe7, 0x9f, 0xf7, 0x45, 0x8c, 0x12, 0xa4, 0x10, 0x21, 0x08, 0x87,
1805 0xc6, 0x19, 0x01, 0x7d, 0x17, 0x76, 0xd3, 0xf8, 0x72, 0x8d, 0xed, 0x01, 0x1d, 0x32, 0x98, 0x2c,
1806 0x6b, 0x3b, 0x24, 0x09, 0x2d, 0x21, 0x13, 0x3d, 0x82, 0x12, 0xdf, 0x75, 0xc2, 0x81, 0x7c, 0xc0,
1807 0xec, 0x16, 0x39, 0x8d, 0x61, 0xee, 0x73, 0x90, 0xdd, 0x60, 0x0e, 0x09, 0xf6, 0x19, 0xc4, 0x2d,
1808 0x2f, 0x42, 0x8f, 0x8b, 0x6a, 0x91, 0x12, 0xfa, 0x01, 0x14, 0x2d, 0xdb, 0x17, 0xed, 0x59, 0xdf,
1809 0x64, 0x36, 0x1a, 0x69, 0x1b, 0xb3, 0x29, 0xd2, 0xc0, 0x9a, 0x4d, 0xd4, 0x01, 0x14, 0x03, 0xb4,
1810 0x13, 0x79, 0x87, 0xa0, 0x17, 0x27, 0xa1, 0xef, 0x43, 0x3d, 0xf6, 0x99, 0xcc, 0xbd, 0xc0, 0x72,
1811 0xdf, 0x8b, 0xf1, 0xe3, 0xd9, 0x07, 0x47, 0xb7, 0x5a, 0x46, 0xec, 0x08, 0xc3, 0x5e, 0x00, 0x49,
1812 0x41, 0x45, 0x74, 0x96, 0xc6, 0x6d, 0x14, 0x7d, 0xd8, 0xfc, 0xdf, 0x49, 0x47, 0xbf, 0x14, 0xf3,
1813 0xb4, 0x1d, 0x61, 0x2d, 0x09, 0x68, 0x9f, 0x42, 0x2d, 0x00, 0xb4, 0xa4, 0x07, 0x9f, 0x4f, 0xc4,
1814 0x61, 0xda, 0xc5, 0x22, 0x5c, 0xd4, 0x1e, 0x12, 0x67, 0x92, 0xa0, 0xf8, 0x1f, 0xae, 0xcb, 0xf9,
1815 0xaa, 0xac, 0x7c, 0x99, 0x87, 0xbd, 0x05, 0x73, 0xf4, 0x3f, 0xd5, 0x81, 0x2b, 0xef, 0xb5, 0x3d,
1816 0x40, 0xae, 0x49, 0x74, 0x0b, 0x4f, 0x88, 0x89, 0x75, 0x0b, 0x53, 0x83, 0x5c, 0xfb, 0xbc, 0xe1,
1817 0xe6, 0xe0, 0xb0, 0xd7, 0x56, 0x3b, 0x4c, 0xb0, 0x13, 0xca, 0x5d, 0xe4, 0xb4, 0xaa, 0x6b, 0x92,
1818 0x04, 0xed, 0x3f, 0xd0, 0x7e, 0x85, 0x85, 0xed, 0x77, 0x5e, 0x85, 0x4a, 0x32, 0x54, 0xc5, 0x87,
1819 0x6a, 0x3a, 0x2c, 0xf4, 0x2d, 0x28, 0x70, 0xa9, 0x68, 0xc3, 0x2d, 0x4d, 0xef, 0xf6, 0xe5, 0x50,
1820 0x4a, 0xed, 0x68, 0x72, 0xc8, 0x56, 0x2d, 0xf4, 0x3e, 0xec, 0x4e, 0x88, 0x47, 0xc7, 0xc6, 0xb5,
1821 0xde, 0x1f, 0xdb, 0x66, 0xb0, 0x41, 0xe9, 0xc4, 0xb6, 0xf0, 0x2b, 0xbe, 0xe9, 0x6d, 0x73, 0xee,
1822 0x8f, 0x39, 0x53, 0x0d, 0x78, 0xca, 0xbb, 0xb0, 0x9b, 0xde, 0x5c, 0xee, 0xd9, 0xe4, 0x7f, 0x25,
1823 0x01, 0x3a, 0xb3, 0xac, 0xf4, 0x66, 0x94, 0xd5, 0x53, 0x2d, 0x28, 0x45, 0x38, 0x3b, 0x3b, 0xe6,
1824 0xb3, 0x4b, 0xc1, 0xa5, 0xa0, 0x07, 0x97, 0x82, 0x48, 0x48, 0xb5, 0xd0, 0x13, 0xa8, 0x18, 0x94,
1825 0x1a, 0xe6, 0x50, 0xa7, 0x8e, 0x3e, 0x74, 0x7c, 0xca, 0x9a, 0x4d, 0xd6, 0x4a, 0x21, 0xf5, 0xca,
1826 0x09, 0x8e, 0x78, 0xca, 0x0e, 0xd4, 0x12, 0x31, 0xf0, 0x53, 0xff, 0xb7, 0x61, 0x27, 0xbc, 0x0a,
1827 0xac, 0x10, 0x9d, 0x52, 0x87, 0xdd, 0xb4, 0x30, 0x37, 0xf3, 0x36, 0x6c, 0xf3, 0x1b, 0x45, 0xf2,
1828 0xf2, 0x90, 0x65, 0x65, 0x4f, 0xb8, 0x4c, 0x1d, 0x92, 0x94, 0x43, 0x40, 0x2f, 0x30, 0x5d, 0x25,
1829 0x90, 0x5f, 0x4b, 0x50, 0x4b, 0x88, 0xfe, 0x5b, 0xfb, 0xd6, 0x07, 0x20, 0x47, 0xfb, 0x6b, 0x7e,
1830 0xc5, 0xc3, 0x40, 0xa4, 0xa1, 0x3c, 0x83, 0x87, 0x2f, 0x30, 0x5d, 0x21, 0xef, 0xdf, 0x4b, 0x2c,
1831 0xbf, 0x15, 0x8f, 0x86, 0xf1, 0x7b, 0xd7, 0xda, 0x6a, 0xf7, 0x2e, 0xf4, 0x3e, 0xc8, 0x23, 0xc3,
1832 0xd4, 0x0c, 0x7b, 0x80, 0x79, 0x22, 0xf5, 0xb4, 0x4e, 0x97, 0xf3, 0xb5, 0x48, 0x52, 0xf9, 0x0c,
1833 0x64, 0x41, 0x45, 0x87, 0xb0, 0xe5, 0x53, 0xc3, 0xa3, 0x5d, 0xc3, 0x3c, 0xe3, 0x43, 0x1c, 0xa6,
1834 0x90, 0x26, 0xa3, 0x27, 0xec, 0xa2, 0x19, 0x93, 0x0b, 0x01, 0x30, 0x49, 0x0c, 0xba, 0x2e, 0xb6,
1835 0x4e, 0xe2, 0xec, 0xa8, 0xfc, 0x0c, 0xb6, 0x93, 0x64, 0x5e, 0x8b, 0x33, 0x28, 0x88, 0xba, 0x86,
1836 0x47, 0xc1, 0x8c, 0xdd, 0x33, 0x63, 0xdd, 0xb5, 0x99, 0x96, 0xb2, 0x1d, 0x2f, 0x72, 0xe4, 0xf0,
1837 0x13, 0x16, 0xc7, 0x8c, 0xca, 0xfd, 0xfd, 0x10, 0x64, 0x5e, 0x3b, 0xe1, 0x4e, 0xc9, 0x70, 0x97,
1838 0x5a, 0x31, 0x2d, 0xd2, 0x69, 0xfd, 0x59, 0x06, 0xc4, 0xb9, 0x6d, 0xf6, 0xce, 0xc3, 0x76, 0x0f,
1839 0xa4, 0xc2, 0x46, 0xf8, 0xea, 0x81, 0xde, 0x4c, 0x9b, 0x4b, 0x3c, 0xf4, 0x34, 0x9a, 0x8b, 0xd8,
1840 0x7c, 0x22, 0x72, 0x48, 0x83, 0x42, 0xf4, 0x9e, 0x80, 0xe6, 0xda, 0x32, 0xfd, 0x90, 0xd2, 0x78,
1841 0xb4, 0x44, 0x22, 0x6e, 0x33, 0xba, 0xfe, 0xcf, 0xdb, 0x4c, 0x3f, 0x54, 0xcc, 0xdb, 0x9c, 0x7f,
1842 0x3b, 0xc8, 0xa1, 0x5f, 0x40, 0x39, 0x71, 0xf3, 0x41, 0x4f, 0xd2, 0x5a, 0x59, 0x8f, 0x0b, 0x8d,
1843 0xb7, 0xee, 0x91, 0x8a, 0xec, 0x1b, 0x50, 0x49, 0xa2, 0x2e, 0x5a, 0xa0, 0x9a, 0x82, 0x8f, 0xc6,
1844 0xd3, 0xfb, 0xc4, 0x22, 0x17, 0x9f, 0x42, 0x31, 0x86, 0x90, 0x48, 0xc9, 0x58, 0x9b, 0xb4, 0xf1,
1845 0xc7, 0x4b, 0x65, 0xe2, 0xc1, 0x27, 0x71, 0x73, 0x3e, 0xf8, 0x4c, 0x10, 0x9e, 0x0f, 0x7e, 0x01,
1846 0xfc, 0xb2, 0xfa, 0x27, 0x40, 0x75, 0xbe, 0xfe, 0x59, 0xf8, 0xdc, 0x78, 0xeb, 0x1e, 0xa9, 0x78,
1847 0x71, 0x62, 0x83, 0x87, 0x94, 0xa5, 0x53, 0xb9, 0xa0, 0x38, 0x19, 0x93, 0xab, 0xe4, 0xd0, 0x27,
1848 0x00, 0xb3, 0x19, 0x43, 0x8f, 0x96, 0xcd, 0x5f, 0x68, 0x77, 0x85, 0x11, 0x55, 0x72, 0xe8, 0xe7,
1849 0x50, 0x8a, 0x43, 0x0c, 0x5a, 0x16, 0x8d, 0x80, 0x89, 0xc6, 0x93, 0xe5, 0x42, 0xa9, 0x6a, 0x08,
1850 0x38, 0x41, 0x4b, 0x22, 0xf2, 0x97, 0x55, 0x23, 0x8d, 0x47, 0x4a, 0xee, 0xfc, 0xa3, 0xaf, 0xbe,
1851 0x6e, 0xe6, 0xfe, 0xfa, 0x75, 0x33, 0xf7, 0xcb, 0x69, 0x53, 0xfa, 0x6a, 0xda, 0x94, 0xfe, 0x32,
1852 0x6d, 0x4a, 0xff, 0x98, 0x36, 0xa5, 0xcf, 0xbe, 0xf7, 0x9a, 0x0f, 0xd1, 0x2f, 0x37, 0xd8, 0xb3,
1853 0xf3, 0x7b, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x72, 0xc7, 0x5f, 0xa9, 0xca, 0x16, 0x00, 0x00,
1854 }
1855
1856
1857 var _ context.Context
1858 var _ grpc.ClientConn
1859
1860
1861
1862 const _ = grpc.SupportPackageIsVersion4
1863
1864
1865
1866
1867 type NetworkConfigProxyClient interface {
1868 AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error)
1869 ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error)
1870 DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error)
1871 CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error)
1872 CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error)
1873 AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error)
1874 DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error)
1875 DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error)
1876 GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error)
1877 GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error)
1878 GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error)
1879 GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error)
1880 }
1881
1882 type networkConfigProxyClient struct {
1883 cc *grpc.ClientConn
1884 }
1885
1886 func NewNetworkConfigProxyClient(cc *grpc.ClientConn) NetworkConfigProxyClient {
1887 return &networkConfigProxyClient{cc}
1888 }
1889
1890 func (c *networkConfigProxyClient) AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error) {
1891 out := new(AddNICResponse)
1892 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/AddNIC", in, out, opts...)
1893 if err != nil {
1894 return nil, err
1895 }
1896 return out, nil
1897 }
1898
1899 func (c *networkConfigProxyClient) ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error) {
1900 out := new(ModifyNICResponse)
1901 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/ModifyNIC", in, out, opts...)
1902 if err != nil {
1903 return nil, err
1904 }
1905 return out, nil
1906 }
1907
1908 func (c *networkConfigProxyClient) DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error) {
1909 out := new(DeleteNICResponse)
1910 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNIC", in, out, opts...)
1911 if err != nil {
1912 return nil, err
1913 }
1914 return out, nil
1915 }
1916
1917 func (c *networkConfigProxyClient) CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error) {
1918 out := new(CreateNetworkResponse)
1919 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/CreateNetwork", in, out, opts...)
1920 if err != nil {
1921 return nil, err
1922 }
1923 return out, nil
1924 }
1925
1926 func (c *networkConfigProxyClient) CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error) {
1927 out := new(CreateEndpointResponse)
1928 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/CreateEndpoint", in, out, opts...)
1929 if err != nil {
1930 return nil, err
1931 }
1932 return out, nil
1933 }
1934
1935 func (c *networkConfigProxyClient) AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error) {
1936 out := new(AddEndpointResponse)
1937 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/AddEndpoint", in, out, opts...)
1938 if err != nil {
1939 return nil, err
1940 }
1941 return out, nil
1942 }
1943
1944 func (c *networkConfigProxyClient) DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error) {
1945 out := new(DeleteEndpointResponse)
1946 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteEndpoint", in, out, opts...)
1947 if err != nil {
1948 return nil, err
1949 }
1950 return out, nil
1951 }
1952
1953 func (c *networkConfigProxyClient) DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error) {
1954 out := new(DeleteNetworkResponse)
1955 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNetwork", in, out, opts...)
1956 if err != nil {
1957 return nil, err
1958 }
1959 return out, nil
1960 }
1961
1962 func (c *networkConfigProxyClient) GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error) {
1963 out := new(GetEndpointResponse)
1964 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoint", in, out, opts...)
1965 if err != nil {
1966 return nil, err
1967 }
1968 return out, nil
1969 }
1970
1971 func (c *networkConfigProxyClient) GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error) {
1972 out := new(GetNetworkResponse)
1973 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetNetwork", in, out, opts...)
1974 if err != nil {
1975 return nil, err
1976 }
1977 return out, nil
1978 }
1979
1980 func (c *networkConfigProxyClient) GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error) {
1981 out := new(GetEndpointsResponse)
1982 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoints", in, out, opts...)
1983 if err != nil {
1984 return nil, err
1985 }
1986 return out, nil
1987 }
1988
1989 func (c *networkConfigProxyClient) GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error) {
1990 out := new(GetNetworksResponse)
1991 err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetNetworks", in, out, opts...)
1992 if err != nil {
1993 return nil, err
1994 }
1995 return out, nil
1996 }
1997
1998
1999 type NetworkConfigProxyServer interface {
2000 AddNIC(context.Context, *AddNICRequest) (*AddNICResponse, error)
2001 ModifyNIC(context.Context, *ModifyNICRequest) (*ModifyNICResponse, error)
2002 DeleteNIC(context.Context, *DeleteNICRequest) (*DeleteNICResponse, error)
2003 CreateNetwork(context.Context, *CreateNetworkRequest) (*CreateNetworkResponse, error)
2004 CreateEndpoint(context.Context, *CreateEndpointRequest) (*CreateEndpointResponse, error)
2005 AddEndpoint(context.Context, *AddEndpointRequest) (*AddEndpointResponse, error)
2006 DeleteEndpoint(context.Context, *DeleteEndpointRequest) (*DeleteEndpointResponse, error)
2007 DeleteNetwork(context.Context, *DeleteNetworkRequest) (*DeleteNetworkResponse, error)
2008 GetEndpoint(context.Context, *GetEndpointRequest) (*GetEndpointResponse, error)
2009 GetNetwork(context.Context, *GetNetworkRequest) (*GetNetworkResponse, error)
2010 GetEndpoints(context.Context, *GetEndpointsRequest) (*GetEndpointsResponse, error)
2011 GetNetworks(context.Context, *GetNetworksRequest) (*GetNetworksResponse, error)
2012 }
2013
2014
2015 type UnimplementedNetworkConfigProxyServer struct {
2016 }
2017
2018 func (*UnimplementedNetworkConfigProxyServer) AddNIC(ctx context.Context, req *AddNICRequest) (*AddNICResponse, error) {
2019 return nil, status.Errorf(codes.Unimplemented, "method AddNIC not implemented")
2020 }
2021 func (*UnimplementedNetworkConfigProxyServer) ModifyNIC(ctx context.Context, req *ModifyNICRequest) (*ModifyNICResponse, error) {
2022 return nil, status.Errorf(codes.Unimplemented, "method ModifyNIC not implemented")
2023 }
2024 func (*UnimplementedNetworkConfigProxyServer) DeleteNIC(ctx context.Context, req *DeleteNICRequest) (*DeleteNICResponse, error) {
2025 return nil, status.Errorf(codes.Unimplemented, "method DeleteNIC not implemented")
2026 }
2027 func (*UnimplementedNetworkConfigProxyServer) CreateNetwork(ctx context.Context, req *CreateNetworkRequest) (*CreateNetworkResponse, error) {
2028 return nil, status.Errorf(codes.Unimplemented, "method CreateNetwork not implemented")
2029 }
2030 func (*UnimplementedNetworkConfigProxyServer) CreateEndpoint(ctx context.Context, req *CreateEndpointRequest) (*CreateEndpointResponse, error) {
2031 return nil, status.Errorf(codes.Unimplemented, "method CreateEndpoint not implemented")
2032 }
2033 func (*UnimplementedNetworkConfigProxyServer) AddEndpoint(ctx context.Context, req *AddEndpointRequest) (*AddEndpointResponse, error) {
2034 return nil, status.Errorf(codes.Unimplemented, "method AddEndpoint not implemented")
2035 }
2036 func (*UnimplementedNetworkConfigProxyServer) DeleteEndpoint(ctx context.Context, req *DeleteEndpointRequest) (*DeleteEndpointResponse, error) {
2037 return nil, status.Errorf(codes.Unimplemented, "method DeleteEndpoint not implemented")
2038 }
2039 func (*UnimplementedNetworkConfigProxyServer) DeleteNetwork(ctx context.Context, req *DeleteNetworkRequest) (*DeleteNetworkResponse, error) {
2040 return nil, status.Errorf(codes.Unimplemented, "method DeleteNetwork not implemented")
2041 }
2042 func (*UnimplementedNetworkConfigProxyServer) GetEndpoint(ctx context.Context, req *GetEndpointRequest) (*GetEndpointResponse, error) {
2043 return nil, status.Errorf(codes.Unimplemented, "method GetEndpoint not implemented")
2044 }
2045 func (*UnimplementedNetworkConfigProxyServer) GetNetwork(ctx context.Context, req *GetNetworkRequest) (*GetNetworkResponse, error) {
2046 return nil, status.Errorf(codes.Unimplemented, "method GetNetwork not implemented")
2047 }
2048 func (*UnimplementedNetworkConfigProxyServer) GetEndpoints(ctx context.Context, req *GetEndpointsRequest) (*GetEndpointsResponse, error) {
2049 return nil, status.Errorf(codes.Unimplemented, "method GetEndpoints not implemented")
2050 }
2051 func (*UnimplementedNetworkConfigProxyServer) GetNetworks(ctx context.Context, req *GetNetworksRequest) (*GetNetworksResponse, error) {
2052 return nil, status.Errorf(codes.Unimplemented, "method GetNetworks not implemented")
2053 }
2054
2055 func RegisterNetworkConfigProxyServer(s *grpc.Server, srv NetworkConfigProxyServer) {
2056 s.RegisterService(&_NetworkConfigProxy_serviceDesc, srv)
2057 }
2058
2059 func _NetworkConfigProxy_AddNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2060 in := new(AddNICRequest)
2061 if err := dec(in); err != nil {
2062 return nil, err
2063 }
2064 if interceptor == nil {
2065 return srv.(NetworkConfigProxyServer).AddNIC(ctx, in)
2066 }
2067 info := &grpc.UnaryServerInfo{
2068 Server: srv,
2069 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/AddNIC",
2070 }
2071 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2072 return srv.(NetworkConfigProxyServer).AddNIC(ctx, req.(*AddNICRequest))
2073 }
2074 return interceptor(ctx, in, info, handler)
2075 }
2076
2077 func _NetworkConfigProxy_ModifyNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2078 in := new(ModifyNICRequest)
2079 if err := dec(in); err != nil {
2080 return nil, err
2081 }
2082 if interceptor == nil {
2083 return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, in)
2084 }
2085 info := &grpc.UnaryServerInfo{
2086 Server: srv,
2087 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/ModifyNIC",
2088 }
2089 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2090 return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, req.(*ModifyNICRequest))
2091 }
2092 return interceptor(ctx, in, info, handler)
2093 }
2094
2095 func _NetworkConfigProxy_DeleteNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2096 in := new(DeleteNICRequest)
2097 if err := dec(in); err != nil {
2098 return nil, err
2099 }
2100 if interceptor == nil {
2101 return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, in)
2102 }
2103 info := &grpc.UnaryServerInfo{
2104 Server: srv,
2105 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNIC",
2106 }
2107 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2108 return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, req.(*DeleteNICRequest))
2109 }
2110 return interceptor(ctx, in, info, handler)
2111 }
2112
2113 func _NetworkConfigProxy_CreateNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2114 in := new(CreateNetworkRequest)
2115 if err := dec(in); err != nil {
2116 return nil, err
2117 }
2118 if interceptor == nil {
2119 return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, in)
2120 }
2121 info := &grpc.UnaryServerInfo{
2122 Server: srv,
2123 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/CreateNetwork",
2124 }
2125 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2126 return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, req.(*CreateNetworkRequest))
2127 }
2128 return interceptor(ctx, in, info, handler)
2129 }
2130
2131 func _NetworkConfigProxy_CreateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2132 in := new(CreateEndpointRequest)
2133 if err := dec(in); err != nil {
2134 return nil, err
2135 }
2136 if interceptor == nil {
2137 return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, in)
2138 }
2139 info := &grpc.UnaryServerInfo{
2140 Server: srv,
2141 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/CreateEndpoint",
2142 }
2143 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2144 return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, req.(*CreateEndpointRequest))
2145 }
2146 return interceptor(ctx, in, info, handler)
2147 }
2148
2149 func _NetworkConfigProxy_AddEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2150 in := new(AddEndpointRequest)
2151 if err := dec(in); err != nil {
2152 return nil, err
2153 }
2154 if interceptor == nil {
2155 return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, in)
2156 }
2157 info := &grpc.UnaryServerInfo{
2158 Server: srv,
2159 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/AddEndpoint",
2160 }
2161 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2162 return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, req.(*AddEndpointRequest))
2163 }
2164 return interceptor(ctx, in, info, handler)
2165 }
2166
2167 func _NetworkConfigProxy_DeleteEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2168 in := new(DeleteEndpointRequest)
2169 if err := dec(in); err != nil {
2170 return nil, err
2171 }
2172 if interceptor == nil {
2173 return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, in)
2174 }
2175 info := &grpc.UnaryServerInfo{
2176 Server: srv,
2177 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteEndpoint",
2178 }
2179 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2180 return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, req.(*DeleteEndpointRequest))
2181 }
2182 return interceptor(ctx, in, info, handler)
2183 }
2184
2185 func _NetworkConfigProxy_DeleteNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2186 in := new(DeleteNetworkRequest)
2187 if err := dec(in); err != nil {
2188 return nil, err
2189 }
2190 if interceptor == nil {
2191 return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, in)
2192 }
2193 info := &grpc.UnaryServerInfo{
2194 Server: srv,
2195 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNetwork",
2196 }
2197 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2198 return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, req.(*DeleteNetworkRequest))
2199 }
2200 return interceptor(ctx, in, info, handler)
2201 }
2202
2203 func _NetworkConfigProxy_GetEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2204 in := new(GetEndpointRequest)
2205 if err := dec(in); err != nil {
2206 return nil, err
2207 }
2208 if interceptor == nil {
2209 return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, in)
2210 }
2211 info := &grpc.UnaryServerInfo{
2212 Server: srv,
2213 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoint",
2214 }
2215 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2216 return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, req.(*GetEndpointRequest))
2217 }
2218 return interceptor(ctx, in, info, handler)
2219 }
2220
2221 func _NetworkConfigProxy_GetNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2222 in := new(GetNetworkRequest)
2223 if err := dec(in); err != nil {
2224 return nil, err
2225 }
2226 if interceptor == nil {
2227 return srv.(NetworkConfigProxyServer).GetNetwork(ctx, in)
2228 }
2229 info := &grpc.UnaryServerInfo{
2230 Server: srv,
2231 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetNetwork",
2232 }
2233 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2234 return srv.(NetworkConfigProxyServer).GetNetwork(ctx, req.(*GetNetworkRequest))
2235 }
2236 return interceptor(ctx, in, info, handler)
2237 }
2238
2239 func _NetworkConfigProxy_GetEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2240 in := new(GetEndpointsRequest)
2241 if err := dec(in); err != nil {
2242 return nil, err
2243 }
2244 if interceptor == nil {
2245 return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, in)
2246 }
2247 info := &grpc.UnaryServerInfo{
2248 Server: srv,
2249 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoints",
2250 }
2251 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2252 return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, req.(*GetEndpointsRequest))
2253 }
2254 return interceptor(ctx, in, info, handler)
2255 }
2256
2257 func _NetworkConfigProxy_GetNetworks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2258 in := new(GetNetworksRequest)
2259 if err := dec(in); err != nil {
2260 return nil, err
2261 }
2262 if interceptor == nil {
2263 return srv.(NetworkConfigProxyServer).GetNetworks(ctx, in)
2264 }
2265 info := &grpc.UnaryServerInfo{
2266 Server: srv,
2267 FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetNetworks",
2268 }
2269 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2270 return srv.(NetworkConfigProxyServer).GetNetworks(ctx, req.(*GetNetworksRequest))
2271 }
2272 return interceptor(ctx, in, info, handler)
2273 }
2274
2275 var _NetworkConfigProxy_serviceDesc = grpc.ServiceDesc{
2276 ServiceName: "ncproxygrpc.v1.NetworkConfigProxy",
2277 HandlerType: (*NetworkConfigProxyServer)(nil),
2278 Methods: []grpc.MethodDesc{
2279 {
2280 MethodName: "AddNIC",
2281 Handler: _NetworkConfigProxy_AddNIC_Handler,
2282 },
2283 {
2284 MethodName: "ModifyNIC",
2285 Handler: _NetworkConfigProxy_ModifyNIC_Handler,
2286 },
2287 {
2288 MethodName: "DeleteNIC",
2289 Handler: _NetworkConfigProxy_DeleteNIC_Handler,
2290 },
2291 {
2292 MethodName: "CreateNetwork",
2293 Handler: _NetworkConfigProxy_CreateNetwork_Handler,
2294 },
2295 {
2296 MethodName: "CreateEndpoint",
2297 Handler: _NetworkConfigProxy_CreateEndpoint_Handler,
2298 },
2299 {
2300 MethodName: "AddEndpoint",
2301 Handler: _NetworkConfigProxy_AddEndpoint_Handler,
2302 },
2303 {
2304 MethodName: "DeleteEndpoint",
2305 Handler: _NetworkConfigProxy_DeleteEndpoint_Handler,
2306 },
2307 {
2308 MethodName: "DeleteNetwork",
2309 Handler: _NetworkConfigProxy_DeleteNetwork_Handler,
2310 },
2311 {
2312 MethodName: "GetEndpoint",
2313 Handler: _NetworkConfigProxy_GetEndpoint_Handler,
2314 },
2315 {
2316 MethodName: "GetNetwork",
2317 Handler: _NetworkConfigProxy_GetNetwork_Handler,
2318 },
2319 {
2320 MethodName: "GetEndpoints",
2321 Handler: _NetworkConfigProxy_GetEndpoints_Handler,
2322 },
2323 {
2324 MethodName: "GetNetworks",
2325 Handler: _NetworkConfigProxy_GetNetworks_Handler,
2326 },
2327 },
2328 Streams: []grpc.StreamDesc{},
2329 Metadata: "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1/networkconfigproxy.proto",
2330 }
2331
2332 func (m *AddNICRequest) Marshal() (dAtA []byte, err error) {
2333 size := m.Size()
2334 dAtA = make([]byte, size)
2335 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2336 if err != nil {
2337 return nil, err
2338 }
2339 return dAtA[:n], nil
2340 }
2341
2342 func (m *AddNICRequest) MarshalTo(dAtA []byte) (int, error) {
2343 size := m.Size()
2344 return m.MarshalToSizedBuffer(dAtA[:size])
2345 }
2346
2347 func (m *AddNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2348 i := len(dAtA)
2349 _ = i
2350 var l int
2351 _ = l
2352 if m.XXX_unrecognized != nil {
2353 i -= len(m.XXX_unrecognized)
2354 copy(dAtA[i:], m.XXX_unrecognized)
2355 }
2356 if m.EndpointSettings != nil {
2357 {
2358 size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
2359 if err != nil {
2360 return 0, err
2361 }
2362 i -= size
2363 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2364 }
2365 i--
2366 dAtA[i] = 0x22
2367 }
2368 if len(m.EndpointName) > 0 {
2369 i -= len(m.EndpointName)
2370 copy(dAtA[i:], m.EndpointName)
2371 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
2372 i--
2373 dAtA[i] = 0x1a
2374 }
2375 if len(m.NicID) > 0 {
2376 i -= len(m.NicID)
2377 copy(dAtA[i:], m.NicID)
2378 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
2379 i--
2380 dAtA[i] = 0x12
2381 }
2382 if len(m.ContainerID) > 0 {
2383 i -= len(m.ContainerID)
2384 copy(dAtA[i:], m.ContainerID)
2385 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
2386 i--
2387 dAtA[i] = 0xa
2388 }
2389 return len(dAtA) - i, nil
2390 }
2391
2392 func (m *AddNICResponse) Marshal() (dAtA []byte, err error) {
2393 size := m.Size()
2394 dAtA = make([]byte, size)
2395 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2396 if err != nil {
2397 return nil, err
2398 }
2399 return dAtA[:n], nil
2400 }
2401
2402 func (m *AddNICResponse) MarshalTo(dAtA []byte) (int, error) {
2403 size := m.Size()
2404 return m.MarshalToSizedBuffer(dAtA[:size])
2405 }
2406
2407 func (m *AddNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2408 i := len(dAtA)
2409 _ = i
2410 var l int
2411 _ = l
2412 if m.XXX_unrecognized != nil {
2413 i -= len(m.XXX_unrecognized)
2414 copy(dAtA[i:], m.XXX_unrecognized)
2415 }
2416 return len(dAtA) - i, nil
2417 }
2418
2419 func (m *ModifyNICRequest) Marshal() (dAtA []byte, err error) {
2420 size := m.Size()
2421 dAtA = make([]byte, size)
2422 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2423 if err != nil {
2424 return nil, err
2425 }
2426 return dAtA[:n], nil
2427 }
2428
2429 func (m *ModifyNICRequest) MarshalTo(dAtA []byte) (int, error) {
2430 size := m.Size()
2431 return m.MarshalToSizedBuffer(dAtA[:size])
2432 }
2433
2434 func (m *ModifyNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2435 i := len(dAtA)
2436 _ = i
2437 var l int
2438 _ = l
2439 if m.XXX_unrecognized != nil {
2440 i -= len(m.XXX_unrecognized)
2441 copy(dAtA[i:], m.XXX_unrecognized)
2442 }
2443 if m.EndpointSettings != nil {
2444 {
2445 size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
2446 if err != nil {
2447 return 0, err
2448 }
2449 i -= size
2450 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2451 }
2452 i--
2453 dAtA[i] = 0x22
2454 }
2455 if len(m.EndpointName) > 0 {
2456 i -= len(m.EndpointName)
2457 copy(dAtA[i:], m.EndpointName)
2458 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
2459 i--
2460 dAtA[i] = 0x1a
2461 }
2462 if len(m.NicID) > 0 {
2463 i -= len(m.NicID)
2464 copy(dAtA[i:], m.NicID)
2465 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
2466 i--
2467 dAtA[i] = 0x12
2468 }
2469 if len(m.ContainerID) > 0 {
2470 i -= len(m.ContainerID)
2471 copy(dAtA[i:], m.ContainerID)
2472 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
2473 i--
2474 dAtA[i] = 0xa
2475 }
2476 return len(dAtA) - i, nil
2477 }
2478
2479 func (m *ModifyNICResponse) Marshal() (dAtA []byte, err error) {
2480 size := m.Size()
2481 dAtA = make([]byte, size)
2482 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2483 if err != nil {
2484 return nil, err
2485 }
2486 return dAtA[:n], nil
2487 }
2488
2489 func (m *ModifyNICResponse) MarshalTo(dAtA []byte) (int, error) {
2490 size := m.Size()
2491 return m.MarshalToSizedBuffer(dAtA[:size])
2492 }
2493
2494 func (m *ModifyNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2495 i := len(dAtA)
2496 _ = i
2497 var l int
2498 _ = l
2499 if m.XXX_unrecognized != nil {
2500 i -= len(m.XXX_unrecognized)
2501 copy(dAtA[i:], m.XXX_unrecognized)
2502 }
2503 return len(dAtA) - i, nil
2504 }
2505
2506 func (m *DeleteNICRequest) Marshal() (dAtA []byte, err error) {
2507 size := m.Size()
2508 dAtA = make([]byte, size)
2509 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2510 if err != nil {
2511 return nil, err
2512 }
2513 return dAtA[:n], nil
2514 }
2515
2516 func (m *DeleteNICRequest) MarshalTo(dAtA []byte) (int, error) {
2517 size := m.Size()
2518 return m.MarshalToSizedBuffer(dAtA[:size])
2519 }
2520
2521 func (m *DeleteNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2522 i := len(dAtA)
2523 _ = i
2524 var l int
2525 _ = l
2526 if m.XXX_unrecognized != nil {
2527 i -= len(m.XXX_unrecognized)
2528 copy(dAtA[i:], m.XXX_unrecognized)
2529 }
2530 if len(m.EndpointName) > 0 {
2531 i -= len(m.EndpointName)
2532 copy(dAtA[i:], m.EndpointName)
2533 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
2534 i--
2535 dAtA[i] = 0x1a
2536 }
2537 if len(m.NicID) > 0 {
2538 i -= len(m.NicID)
2539 copy(dAtA[i:], m.NicID)
2540 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
2541 i--
2542 dAtA[i] = 0x12
2543 }
2544 if len(m.ContainerID) > 0 {
2545 i -= len(m.ContainerID)
2546 copy(dAtA[i:], m.ContainerID)
2547 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
2548 i--
2549 dAtA[i] = 0xa
2550 }
2551 return len(dAtA) - i, nil
2552 }
2553
2554 func (m *DeleteNICResponse) Marshal() (dAtA []byte, err error) {
2555 size := m.Size()
2556 dAtA = make([]byte, size)
2557 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2558 if err != nil {
2559 return nil, err
2560 }
2561 return dAtA[:n], nil
2562 }
2563
2564 func (m *DeleteNICResponse) MarshalTo(dAtA []byte) (int, error) {
2565 size := m.Size()
2566 return m.MarshalToSizedBuffer(dAtA[:size])
2567 }
2568
2569 func (m *DeleteNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2570 i := len(dAtA)
2571 _ = i
2572 var l int
2573 _ = l
2574 if m.XXX_unrecognized != nil {
2575 i -= len(m.XXX_unrecognized)
2576 copy(dAtA[i:], m.XXX_unrecognized)
2577 }
2578 return len(dAtA) - i, nil
2579 }
2580
2581 func (m *CreateNetworkRequest) Marshal() (dAtA []byte, err error) {
2582 size := m.Size()
2583 dAtA = make([]byte, size)
2584 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2585 if err != nil {
2586 return nil, err
2587 }
2588 return dAtA[:n], nil
2589 }
2590
2591 func (m *CreateNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
2592 size := m.Size()
2593 return m.MarshalToSizedBuffer(dAtA[:size])
2594 }
2595
2596 func (m *CreateNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2597 i := len(dAtA)
2598 _ = i
2599 var l int
2600 _ = l
2601 if m.XXX_unrecognized != nil {
2602 i -= len(m.XXX_unrecognized)
2603 copy(dAtA[i:], m.XXX_unrecognized)
2604 }
2605 if m.Network != nil {
2606 {
2607 size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
2608 if err != nil {
2609 return 0, err
2610 }
2611 i -= size
2612 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2613 }
2614 i--
2615 dAtA[i] = 0xa
2616 }
2617 return len(dAtA) - i, nil
2618 }
2619
2620 func (m *Network) Marshal() (dAtA []byte, err error) {
2621 size := m.Size()
2622 dAtA = make([]byte, size)
2623 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2624 if err != nil {
2625 return nil, err
2626 }
2627 return dAtA[:n], nil
2628 }
2629
2630 func (m *Network) MarshalTo(dAtA []byte) (int, error) {
2631 size := m.Size()
2632 return m.MarshalToSizedBuffer(dAtA[:size])
2633 }
2634
2635 func (m *Network) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2636 i := len(dAtA)
2637 _ = i
2638 var l int
2639 _ = l
2640 if m.XXX_unrecognized != nil {
2641 i -= len(m.XXX_unrecognized)
2642 copy(dAtA[i:], m.XXX_unrecognized)
2643 }
2644 if m.Settings != nil {
2645 {
2646 size := m.Settings.Size()
2647 i -= size
2648 if _, err := m.Settings.MarshalTo(dAtA[i:]); err != nil {
2649 return 0, err
2650 }
2651 }
2652 }
2653 return len(dAtA) - i, nil
2654 }
2655
2656 func (m *Network_HcnNetwork) MarshalTo(dAtA []byte) (int, error) {
2657 size := m.Size()
2658 return m.MarshalToSizedBuffer(dAtA[:size])
2659 }
2660
2661 func (m *Network_HcnNetwork) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2662 i := len(dAtA)
2663 if m.HcnNetwork != nil {
2664 {
2665 size, err := m.HcnNetwork.MarshalToSizedBuffer(dAtA[:i])
2666 if err != nil {
2667 return 0, err
2668 }
2669 i -= size
2670 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2671 }
2672 i--
2673 dAtA[i] = 0xa
2674 }
2675 return len(dAtA) - i, nil
2676 }
2677 func (m *Network_NcproxyNetwork) MarshalTo(dAtA []byte) (int, error) {
2678 size := m.Size()
2679 return m.MarshalToSizedBuffer(dAtA[:size])
2680 }
2681
2682 func (m *Network_NcproxyNetwork) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2683 i := len(dAtA)
2684 if m.NcproxyNetwork != nil {
2685 {
2686 size, err := m.NcproxyNetwork.MarshalToSizedBuffer(dAtA[:i])
2687 if err != nil {
2688 return 0, err
2689 }
2690 i -= size
2691 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2692 }
2693 i--
2694 dAtA[i] = 0x12
2695 }
2696 return len(dAtA) - i, nil
2697 }
2698 func (m *NCProxyNetworkSettings) Marshal() (dAtA []byte, err error) {
2699 size := m.Size()
2700 dAtA = make([]byte, size)
2701 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2702 if err != nil {
2703 return nil, err
2704 }
2705 return dAtA[:n], nil
2706 }
2707
2708 func (m *NCProxyNetworkSettings) MarshalTo(dAtA []byte) (int, error) {
2709 size := m.Size()
2710 return m.MarshalToSizedBuffer(dAtA[:size])
2711 }
2712
2713 func (m *NCProxyNetworkSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2714 i := len(dAtA)
2715 _ = i
2716 var l int
2717 _ = l
2718 if m.XXX_unrecognized != nil {
2719 i -= len(m.XXX_unrecognized)
2720 copy(dAtA[i:], m.XXX_unrecognized)
2721 }
2722 if len(m.Name) > 0 {
2723 i -= len(m.Name)
2724 copy(dAtA[i:], m.Name)
2725 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2726 i--
2727 dAtA[i] = 0xa
2728 }
2729 return len(dAtA) - i, nil
2730 }
2731
2732 func (m *HostComputeNetworkSettings) Marshal() (dAtA []byte, err error) {
2733 size := m.Size()
2734 dAtA = make([]byte, size)
2735 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2736 if err != nil {
2737 return nil, err
2738 }
2739 return dAtA[:n], nil
2740 }
2741
2742 func (m *HostComputeNetworkSettings) MarshalTo(dAtA []byte) (int, error) {
2743 size := m.Size()
2744 return m.MarshalToSizedBuffer(dAtA[:size])
2745 }
2746
2747 func (m *HostComputeNetworkSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2748 i := len(dAtA)
2749 _ = i
2750 var l int
2751 _ = l
2752 if m.XXX_unrecognized != nil {
2753 i -= len(m.XXX_unrecognized)
2754 copy(dAtA[i:], m.XXX_unrecognized)
2755 }
2756 if len(m.DefaultGatewayIpv6) > 0 {
2757 i -= len(m.DefaultGatewayIpv6)
2758 copy(dAtA[i:], m.DefaultGatewayIpv6)
2759 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGatewayIpv6)))
2760 i--
2761 dAtA[i] = 0x42
2762 }
2763 if len(m.SubnetIpaddressPrefixIpv6) > 0 {
2764 for iNdEx := len(m.SubnetIpaddressPrefixIpv6) - 1; iNdEx >= 0; iNdEx-- {
2765 i -= len(m.SubnetIpaddressPrefixIpv6[iNdEx])
2766 copy(dAtA[i:], m.SubnetIpaddressPrefixIpv6[iNdEx])
2767 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SubnetIpaddressPrefixIpv6[iNdEx])))
2768 i--
2769 dAtA[i] = 0x3a
2770 }
2771 }
2772 if len(m.DefaultGateway) > 0 {
2773 i -= len(m.DefaultGateway)
2774 copy(dAtA[i:], m.DefaultGateway)
2775 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGateway)))
2776 i--
2777 dAtA[i] = 0x32
2778 }
2779 if len(m.SubnetIpaddressPrefix) > 0 {
2780 for iNdEx := len(m.SubnetIpaddressPrefix) - 1; iNdEx >= 0; iNdEx-- {
2781 i -= len(m.SubnetIpaddressPrefix[iNdEx])
2782 copy(dAtA[i:], m.SubnetIpaddressPrefix[iNdEx])
2783 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SubnetIpaddressPrefix[iNdEx])))
2784 i--
2785 dAtA[i] = 0x2a
2786 }
2787 }
2788 if m.IpamType != 0 {
2789 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpamType))
2790 i--
2791 dAtA[i] = 0x20
2792 }
2793 if len(m.SwitchName) > 0 {
2794 i -= len(m.SwitchName)
2795 copy(dAtA[i:], m.SwitchName)
2796 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SwitchName)))
2797 i--
2798 dAtA[i] = 0x1a
2799 }
2800 if m.Mode != 0 {
2801 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.Mode))
2802 i--
2803 dAtA[i] = 0x10
2804 }
2805 if len(m.Name) > 0 {
2806 i -= len(m.Name)
2807 copy(dAtA[i:], m.Name)
2808 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2809 i--
2810 dAtA[i] = 0xa
2811 }
2812 return len(dAtA) - i, nil
2813 }
2814
2815 func (m *CreateNetworkResponse) Marshal() (dAtA []byte, err error) {
2816 size := m.Size()
2817 dAtA = make([]byte, size)
2818 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2819 if err != nil {
2820 return nil, err
2821 }
2822 return dAtA[:n], nil
2823 }
2824
2825 func (m *CreateNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
2826 size := m.Size()
2827 return m.MarshalToSizedBuffer(dAtA[:size])
2828 }
2829
2830 func (m *CreateNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2831 i := len(dAtA)
2832 _ = i
2833 var l int
2834 _ = l
2835 if m.XXX_unrecognized != nil {
2836 i -= len(m.XXX_unrecognized)
2837 copy(dAtA[i:], m.XXX_unrecognized)
2838 }
2839 if len(m.ID) > 0 {
2840 i -= len(m.ID)
2841 copy(dAtA[i:], m.ID)
2842 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
2843 i--
2844 dAtA[i] = 0xa
2845 }
2846 return len(dAtA) - i, nil
2847 }
2848
2849 func (m *PortNameEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
2850 size := m.Size()
2851 dAtA = make([]byte, size)
2852 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2853 if err != nil {
2854 return nil, err
2855 }
2856 return dAtA[:n], nil
2857 }
2858
2859 func (m *PortNameEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
2860 size := m.Size()
2861 return m.MarshalToSizedBuffer(dAtA[:size])
2862 }
2863
2864 func (m *PortNameEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2865 i := len(dAtA)
2866 _ = i
2867 var l int
2868 _ = l
2869 if m.XXX_unrecognized != nil {
2870 i -= len(m.XXX_unrecognized)
2871 copy(dAtA[i:], m.XXX_unrecognized)
2872 }
2873 if len(m.PortName) > 0 {
2874 i -= len(m.PortName)
2875 copy(dAtA[i:], m.PortName)
2876 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.PortName)))
2877 i--
2878 dAtA[i] = 0xa
2879 }
2880 return len(dAtA) - i, nil
2881 }
2882
2883 func (m *IovEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
2884 size := m.Size()
2885 dAtA = make([]byte, size)
2886 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2887 if err != nil {
2888 return nil, err
2889 }
2890 return dAtA[:n], nil
2891 }
2892
2893 func (m *IovEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
2894 size := m.Size()
2895 return m.MarshalToSizedBuffer(dAtA[:size])
2896 }
2897
2898 func (m *IovEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2899 i := len(dAtA)
2900 _ = i
2901 var l int
2902 _ = l
2903 if m.XXX_unrecognized != nil {
2904 i -= len(m.XXX_unrecognized)
2905 copy(dAtA[i:], m.XXX_unrecognized)
2906 }
2907 if m.InterruptModeration != 0 {
2908 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.InterruptModeration))
2909 i--
2910 dAtA[i] = 0x18
2911 }
2912 if m.QueuePairsRequested != 0 {
2913 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.QueuePairsRequested))
2914 i--
2915 dAtA[i] = 0x10
2916 }
2917 if m.IovOffloadWeight != 0 {
2918 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IovOffloadWeight))
2919 i--
2920 dAtA[i] = 0x8
2921 }
2922 return len(dAtA) - i, nil
2923 }
2924
2925 func (m *DnsSetting) Marshal() (dAtA []byte, err error) {
2926 size := m.Size()
2927 dAtA = make([]byte, size)
2928 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2929 if err != nil {
2930 return nil, err
2931 }
2932 return dAtA[:n], nil
2933 }
2934
2935 func (m *DnsSetting) MarshalTo(dAtA []byte) (int, error) {
2936 size := m.Size()
2937 return m.MarshalToSizedBuffer(dAtA[:size])
2938 }
2939
2940 func (m *DnsSetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2941 i := len(dAtA)
2942 _ = i
2943 var l int
2944 _ = l
2945 if m.XXX_unrecognized != nil {
2946 i -= len(m.XXX_unrecognized)
2947 copy(dAtA[i:], m.XXX_unrecognized)
2948 }
2949 if len(m.Search) > 0 {
2950 for iNdEx := len(m.Search) - 1; iNdEx >= 0; iNdEx-- {
2951 i -= len(m.Search[iNdEx])
2952 copy(dAtA[i:], m.Search[iNdEx])
2953 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Search[iNdEx])))
2954 i--
2955 dAtA[i] = 0x1a
2956 }
2957 }
2958 if len(m.Domain) > 0 {
2959 i -= len(m.Domain)
2960 copy(dAtA[i:], m.Domain)
2961 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Domain)))
2962 i--
2963 dAtA[i] = 0x12
2964 }
2965 if len(m.ServerIpAddrs) > 0 {
2966 for iNdEx := len(m.ServerIpAddrs) - 1; iNdEx >= 0; iNdEx-- {
2967 i -= len(m.ServerIpAddrs[iNdEx])
2968 copy(dAtA[i:], m.ServerIpAddrs[iNdEx])
2969 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ServerIpAddrs[iNdEx])))
2970 i--
2971 dAtA[i] = 0xa
2972 }
2973 }
2974 return len(dAtA) - i, nil
2975 }
2976
2977 func (m *CreateEndpointRequest) Marshal() (dAtA []byte, err error) {
2978 size := m.Size()
2979 dAtA = make([]byte, size)
2980 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2981 if err != nil {
2982 return nil, err
2983 }
2984 return dAtA[:n], nil
2985 }
2986
2987 func (m *CreateEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
2988 size := m.Size()
2989 return m.MarshalToSizedBuffer(dAtA[:size])
2990 }
2991
2992 func (m *CreateEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2993 i := len(dAtA)
2994 _ = i
2995 var l int
2996 _ = l
2997 if m.XXX_unrecognized != nil {
2998 i -= len(m.XXX_unrecognized)
2999 copy(dAtA[i:], m.XXX_unrecognized)
3000 }
3001 if m.EndpointSettings != nil {
3002 {
3003 size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
3004 if err != nil {
3005 return 0, err
3006 }
3007 i -= size
3008 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3009 }
3010 i--
3011 dAtA[i] = 0xa
3012 }
3013 return len(dAtA) - i, nil
3014 }
3015
3016 func (m *EndpointSettings) Marshal() (dAtA []byte, err error) {
3017 size := m.Size()
3018 dAtA = make([]byte, size)
3019 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3020 if err != nil {
3021 return nil, err
3022 }
3023 return dAtA[:n], nil
3024 }
3025
3026 func (m *EndpointSettings) MarshalTo(dAtA []byte) (int, error) {
3027 size := m.Size()
3028 return m.MarshalToSizedBuffer(dAtA[:size])
3029 }
3030
3031 func (m *EndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3032 i := len(dAtA)
3033 _ = i
3034 var l int
3035 _ = l
3036 if m.XXX_unrecognized != nil {
3037 i -= len(m.XXX_unrecognized)
3038 copy(dAtA[i:], m.XXX_unrecognized)
3039 }
3040 if m.Settings != nil {
3041 {
3042 size := m.Settings.Size()
3043 i -= size
3044 if _, err := m.Settings.MarshalTo(dAtA[i:]); err != nil {
3045 return 0, err
3046 }
3047 }
3048 }
3049 return len(dAtA) - i, nil
3050 }
3051
3052 func (m *EndpointSettings_HcnEndpoint) MarshalTo(dAtA []byte) (int, error) {
3053 size := m.Size()
3054 return m.MarshalToSizedBuffer(dAtA[:size])
3055 }
3056
3057 func (m *EndpointSettings_HcnEndpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3058 i := len(dAtA)
3059 if m.HcnEndpoint != nil {
3060 {
3061 size, err := m.HcnEndpoint.MarshalToSizedBuffer(dAtA[:i])
3062 if err != nil {
3063 return 0, err
3064 }
3065 i -= size
3066 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3067 }
3068 i--
3069 dAtA[i] = 0xa
3070 }
3071 return len(dAtA) - i, nil
3072 }
3073 func (m *EndpointSettings_NcproxyEndpoint) MarshalTo(dAtA []byte) (int, error) {
3074 size := m.Size()
3075 return m.MarshalToSizedBuffer(dAtA[:size])
3076 }
3077
3078 func (m *EndpointSettings_NcproxyEndpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3079 i := len(dAtA)
3080 if m.NcproxyEndpoint != nil {
3081 {
3082 size, err := m.NcproxyEndpoint.MarshalToSizedBuffer(dAtA[:i])
3083 if err != nil {
3084 return 0, err
3085 }
3086 i -= size
3087 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3088 }
3089 i--
3090 dAtA[i] = 0x12
3091 }
3092 return len(dAtA) - i, nil
3093 }
3094 func (m *HcnEndpointResponse) Marshal() (dAtA []byte, err error) {
3095 size := m.Size()
3096 dAtA = make([]byte, size)
3097 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3098 if err != nil {
3099 return nil, err
3100 }
3101 return dAtA[:n], nil
3102 }
3103
3104 func (m *HcnEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
3105 size := m.Size()
3106 return m.MarshalToSizedBuffer(dAtA[:size])
3107 }
3108
3109 func (m *HcnEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3110 i := len(dAtA)
3111 _ = i
3112 var l int
3113 _ = l
3114 if m.XXX_unrecognized != nil {
3115 i -= len(m.XXX_unrecognized)
3116 copy(dAtA[i:], m.XXX_unrecognized)
3117 }
3118 if m.Settings != nil {
3119 {
3120 size, err := m.Settings.MarshalToSizedBuffer(dAtA[:i])
3121 if err != nil {
3122 return 0, err
3123 }
3124 i -= size
3125 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3126 }
3127 i--
3128 dAtA[i] = 0x1a
3129 }
3130 if len(m.ID) > 0 {
3131 i -= len(m.ID)
3132 copy(dAtA[i:], m.ID)
3133 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
3134 i--
3135 dAtA[i] = 0x12
3136 }
3137 if len(m.Namespace) > 0 {
3138 i -= len(m.Namespace)
3139 copy(dAtA[i:], m.Namespace)
3140 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Namespace)))
3141 i--
3142 dAtA[i] = 0xa
3143 }
3144 return len(dAtA) - i, nil
3145 }
3146
3147 func (m *HcnEndpointSettings) Marshal() (dAtA []byte, err error) {
3148 size := m.Size()
3149 dAtA = make([]byte, size)
3150 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3151 if err != nil {
3152 return nil, err
3153 }
3154 return dAtA[:n], nil
3155 }
3156
3157 func (m *HcnEndpointSettings) MarshalTo(dAtA []byte) (int, error) {
3158 size := m.Size()
3159 return m.MarshalToSizedBuffer(dAtA[:size])
3160 }
3161
3162 func (m *HcnEndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3163 i := len(dAtA)
3164 _ = i
3165 var l int
3166 _ = l
3167 if m.XXX_unrecognized != nil {
3168 i -= len(m.XXX_unrecognized)
3169 copy(dAtA[i:], m.XXX_unrecognized)
3170 }
3171 if m.Ipv6AddressPrefixlength != 0 {
3172 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.Ipv6AddressPrefixlength))
3173 i--
3174 dAtA[i] = 0x48
3175 }
3176 if len(m.Ipv6Address) > 0 {
3177 i -= len(m.Ipv6Address)
3178 copy(dAtA[i:], m.Ipv6Address)
3179 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6Address)))
3180 i--
3181 dAtA[i] = 0x42
3182 }
3183 if m.DnsSetting != nil {
3184 {
3185 size, err := m.DnsSetting.MarshalToSizedBuffer(dAtA[:i])
3186 if err != nil {
3187 return 0, err
3188 }
3189 i -= size
3190 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3191 }
3192 i--
3193 dAtA[i] = 0x3a
3194 }
3195 if m.Policies != nil {
3196 {
3197 size, err := m.Policies.MarshalToSizedBuffer(dAtA[:i])
3198 if err != nil {
3199 return 0, err
3200 }
3201 i -= size
3202 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3203 }
3204 i--
3205 dAtA[i] = 0x32
3206 }
3207 if len(m.NetworkName) > 0 {
3208 i -= len(m.NetworkName)
3209 copy(dAtA[i:], m.NetworkName)
3210 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NetworkName)))
3211 i--
3212 dAtA[i] = 0x2a
3213 }
3214 if m.IpaddressPrefixlength != 0 {
3215 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpaddressPrefixlength))
3216 i--
3217 dAtA[i] = 0x20
3218 }
3219 if len(m.Ipaddress) > 0 {
3220 i -= len(m.Ipaddress)
3221 copy(dAtA[i:], m.Ipaddress)
3222 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipaddress)))
3223 i--
3224 dAtA[i] = 0x1a
3225 }
3226 if len(m.Macaddress) > 0 {
3227 i -= len(m.Macaddress)
3228 copy(dAtA[i:], m.Macaddress)
3229 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Macaddress)))
3230 i--
3231 dAtA[i] = 0x12
3232 }
3233 if len(m.Name) > 0 {
3234 i -= len(m.Name)
3235 copy(dAtA[i:], m.Name)
3236 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3237 i--
3238 dAtA[i] = 0xa
3239 }
3240 return len(dAtA) - i, nil
3241 }
3242
3243 func (m *HcnEndpointPolicies) Marshal() (dAtA []byte, err error) {
3244 size := m.Size()
3245 dAtA = make([]byte, size)
3246 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3247 if err != nil {
3248 return nil, err
3249 }
3250 return dAtA[:n], nil
3251 }
3252
3253 func (m *HcnEndpointPolicies) MarshalTo(dAtA []byte) (int, error) {
3254 size := m.Size()
3255 return m.MarshalToSizedBuffer(dAtA[:size])
3256 }
3257
3258 func (m *HcnEndpointPolicies) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3259 i := len(dAtA)
3260 _ = i
3261 var l int
3262 _ = l
3263 if m.XXX_unrecognized != nil {
3264 i -= len(m.XXX_unrecognized)
3265 copy(dAtA[i:], m.XXX_unrecognized)
3266 }
3267 if m.IovPolicySettings != nil {
3268 {
3269 size, err := m.IovPolicySettings.MarshalToSizedBuffer(dAtA[:i])
3270 if err != nil {
3271 return 0, err
3272 }
3273 i -= size
3274 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3275 }
3276 i--
3277 dAtA[i] = 0x12
3278 }
3279 if m.PortnamePolicySetting != nil {
3280 {
3281 size, err := m.PortnamePolicySetting.MarshalToSizedBuffer(dAtA[:i])
3282 if err != nil {
3283 return 0, err
3284 }
3285 i -= size
3286 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3287 }
3288 i--
3289 dAtA[i] = 0xa
3290 }
3291 return len(dAtA) - i, nil
3292 }
3293
3294 func (m *NCProxyEndpointSettings) Marshal() (dAtA []byte, err error) {
3295 size := m.Size()
3296 dAtA = make([]byte, size)
3297 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3298 if err != nil {
3299 return nil, err
3300 }
3301 return dAtA[:n], nil
3302 }
3303
3304 func (m *NCProxyEndpointSettings) MarshalTo(dAtA []byte) (int, error) {
3305 size := m.Size()
3306 return m.MarshalToSizedBuffer(dAtA[:size])
3307 }
3308
3309 func (m *NCProxyEndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3310 i := len(dAtA)
3311 _ = i
3312 var l int
3313 _ = l
3314 if m.XXX_unrecognized != nil {
3315 i -= len(m.XXX_unrecognized)
3316 copy(dAtA[i:], m.XXX_unrecognized)
3317 }
3318 if len(m.Ipv6AddressPrefixlength) > 0 {
3319 i -= len(m.Ipv6AddressPrefixlength)
3320 copy(dAtA[i:], m.Ipv6AddressPrefixlength)
3321 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6AddressPrefixlength)))
3322 i--
3323 dAtA[i] = 0x4a
3324 }
3325 if len(m.Ipv6Address) > 0 {
3326 i -= len(m.Ipv6Address)
3327 copy(dAtA[i:], m.Ipv6Address)
3328 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6Address)))
3329 i--
3330 dAtA[i] = 0x42
3331 }
3332 if m.DeviceDetails != nil {
3333 {
3334 size := m.DeviceDetails.Size()
3335 i -= size
3336 if _, err := m.DeviceDetails.MarshalTo(dAtA[i:]); err != nil {
3337 return 0, err
3338 }
3339 }
3340 }
3341 if len(m.DefaultGateway) > 0 {
3342 i -= len(m.DefaultGateway)
3343 copy(dAtA[i:], m.DefaultGateway)
3344 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGateway)))
3345 i--
3346 dAtA[i] = 0x32
3347 }
3348 if len(m.NetworkName) > 0 {
3349 i -= len(m.NetworkName)
3350 copy(dAtA[i:], m.NetworkName)
3351 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NetworkName)))
3352 i--
3353 dAtA[i] = 0x2a
3354 }
3355 if m.IpaddressPrefixlength != 0 {
3356 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpaddressPrefixlength))
3357 i--
3358 dAtA[i] = 0x20
3359 }
3360 if len(m.Ipaddress) > 0 {
3361 i -= len(m.Ipaddress)
3362 copy(dAtA[i:], m.Ipaddress)
3363 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipaddress)))
3364 i--
3365 dAtA[i] = 0x1a
3366 }
3367 if len(m.Macaddress) > 0 {
3368 i -= len(m.Macaddress)
3369 copy(dAtA[i:], m.Macaddress)
3370 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Macaddress)))
3371 i--
3372 dAtA[i] = 0x12
3373 }
3374 if len(m.Name) > 0 {
3375 i -= len(m.Name)
3376 copy(dAtA[i:], m.Name)
3377 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3378 i--
3379 dAtA[i] = 0xa
3380 }
3381 return len(dAtA) - i, nil
3382 }
3383
3384 func (m *NCProxyEndpointSettings_PciDeviceDetails) MarshalTo(dAtA []byte) (int, error) {
3385 size := m.Size()
3386 return m.MarshalToSizedBuffer(dAtA[:size])
3387 }
3388
3389 func (m *NCProxyEndpointSettings_PciDeviceDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3390 i := len(dAtA)
3391 if m.PciDeviceDetails != nil {
3392 {
3393 size, err := m.PciDeviceDetails.MarshalToSizedBuffer(dAtA[:i])
3394 if err != nil {
3395 return 0, err
3396 }
3397 i -= size
3398 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3399 }
3400 i--
3401 dAtA[i] = 0x3a
3402 }
3403 return len(dAtA) - i, nil
3404 }
3405 func (m *PCIDeviceDetails) Marshal() (dAtA []byte, err error) {
3406 size := m.Size()
3407 dAtA = make([]byte, size)
3408 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3409 if err != nil {
3410 return nil, err
3411 }
3412 return dAtA[:n], nil
3413 }
3414
3415 func (m *PCIDeviceDetails) MarshalTo(dAtA []byte) (int, error) {
3416 size := m.Size()
3417 return m.MarshalToSizedBuffer(dAtA[:size])
3418 }
3419
3420 func (m *PCIDeviceDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3421 i := len(dAtA)
3422 _ = i
3423 var l int
3424 _ = l
3425 if m.XXX_unrecognized != nil {
3426 i -= len(m.XXX_unrecognized)
3427 copy(dAtA[i:], m.XXX_unrecognized)
3428 }
3429 if m.VirtualFunctionIndex != 0 {
3430 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.VirtualFunctionIndex))
3431 i--
3432 dAtA[i] = 0x10
3433 }
3434 if len(m.DeviceID) > 0 {
3435 i -= len(m.DeviceID)
3436 copy(dAtA[i:], m.DeviceID)
3437 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DeviceID)))
3438 i--
3439 dAtA[i] = 0xa
3440 }
3441 return len(dAtA) - i, nil
3442 }
3443
3444 func (m *CreateEndpointResponse) Marshal() (dAtA []byte, err error) {
3445 size := m.Size()
3446 dAtA = make([]byte, size)
3447 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3448 if err != nil {
3449 return nil, err
3450 }
3451 return dAtA[:n], nil
3452 }
3453
3454 func (m *CreateEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
3455 size := m.Size()
3456 return m.MarshalToSizedBuffer(dAtA[:size])
3457 }
3458
3459 func (m *CreateEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3460 i := len(dAtA)
3461 _ = i
3462 var l int
3463 _ = l
3464 if m.XXX_unrecognized != nil {
3465 i -= len(m.XXX_unrecognized)
3466 copy(dAtA[i:], m.XXX_unrecognized)
3467 }
3468 if len(m.ID) > 0 {
3469 i -= len(m.ID)
3470 copy(dAtA[i:], m.ID)
3471 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
3472 i--
3473 dAtA[i] = 0xa
3474 }
3475 return len(dAtA) - i, nil
3476 }
3477
3478 func (m *AddEndpointRequest) Marshal() (dAtA []byte, err error) {
3479 size := m.Size()
3480 dAtA = make([]byte, size)
3481 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3482 if err != nil {
3483 return nil, err
3484 }
3485 return dAtA[:n], nil
3486 }
3487
3488 func (m *AddEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
3489 size := m.Size()
3490 return m.MarshalToSizedBuffer(dAtA[:size])
3491 }
3492
3493 func (m *AddEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3494 i := len(dAtA)
3495 _ = i
3496 var l int
3497 _ = l
3498 if m.XXX_unrecognized != nil {
3499 i -= len(m.XXX_unrecognized)
3500 copy(dAtA[i:], m.XXX_unrecognized)
3501 }
3502 if m.AttachToHost {
3503 i--
3504 if m.AttachToHost {
3505 dAtA[i] = 1
3506 } else {
3507 dAtA[i] = 0
3508 }
3509 i--
3510 dAtA[i] = 0x18
3511 }
3512 if len(m.NamespaceID) > 0 {
3513 i -= len(m.NamespaceID)
3514 copy(dAtA[i:], m.NamespaceID)
3515 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NamespaceID)))
3516 i--
3517 dAtA[i] = 0x12
3518 }
3519 if len(m.Name) > 0 {
3520 i -= len(m.Name)
3521 copy(dAtA[i:], m.Name)
3522 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3523 i--
3524 dAtA[i] = 0xa
3525 }
3526 return len(dAtA) - i, nil
3527 }
3528
3529 func (m *AddEndpointResponse) Marshal() (dAtA []byte, err error) {
3530 size := m.Size()
3531 dAtA = make([]byte, size)
3532 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3533 if err != nil {
3534 return nil, err
3535 }
3536 return dAtA[:n], nil
3537 }
3538
3539 func (m *AddEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
3540 size := m.Size()
3541 return m.MarshalToSizedBuffer(dAtA[:size])
3542 }
3543
3544 func (m *AddEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3545 i := len(dAtA)
3546 _ = i
3547 var l int
3548 _ = l
3549 if m.XXX_unrecognized != nil {
3550 i -= len(m.XXX_unrecognized)
3551 copy(dAtA[i:], m.XXX_unrecognized)
3552 }
3553 return len(dAtA) - i, nil
3554 }
3555
3556 func (m *DeleteEndpointRequest) Marshal() (dAtA []byte, err error) {
3557 size := m.Size()
3558 dAtA = make([]byte, size)
3559 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3560 if err != nil {
3561 return nil, err
3562 }
3563 return dAtA[:n], nil
3564 }
3565
3566 func (m *DeleteEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
3567 size := m.Size()
3568 return m.MarshalToSizedBuffer(dAtA[:size])
3569 }
3570
3571 func (m *DeleteEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3572 i := len(dAtA)
3573 _ = i
3574 var l int
3575 _ = l
3576 if m.XXX_unrecognized != nil {
3577 i -= len(m.XXX_unrecognized)
3578 copy(dAtA[i:], m.XXX_unrecognized)
3579 }
3580 if len(m.Name) > 0 {
3581 i -= len(m.Name)
3582 copy(dAtA[i:], m.Name)
3583 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3584 i--
3585 dAtA[i] = 0xa
3586 }
3587 return len(dAtA) - i, nil
3588 }
3589
3590 func (m *DeleteEndpointResponse) Marshal() (dAtA []byte, err error) {
3591 size := m.Size()
3592 dAtA = make([]byte, size)
3593 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3594 if err != nil {
3595 return nil, err
3596 }
3597 return dAtA[:n], nil
3598 }
3599
3600 func (m *DeleteEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
3601 size := m.Size()
3602 return m.MarshalToSizedBuffer(dAtA[:size])
3603 }
3604
3605 func (m *DeleteEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3606 i := len(dAtA)
3607 _ = i
3608 var l int
3609 _ = l
3610 if m.XXX_unrecognized != nil {
3611 i -= len(m.XXX_unrecognized)
3612 copy(dAtA[i:], m.XXX_unrecognized)
3613 }
3614 return len(dAtA) - i, nil
3615 }
3616
3617 func (m *DeleteNetworkRequest) Marshal() (dAtA []byte, err error) {
3618 size := m.Size()
3619 dAtA = make([]byte, size)
3620 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3621 if err != nil {
3622 return nil, err
3623 }
3624 return dAtA[:n], nil
3625 }
3626
3627 func (m *DeleteNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
3628 size := m.Size()
3629 return m.MarshalToSizedBuffer(dAtA[:size])
3630 }
3631
3632 func (m *DeleteNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3633 i := len(dAtA)
3634 _ = i
3635 var l int
3636 _ = l
3637 if m.XXX_unrecognized != nil {
3638 i -= len(m.XXX_unrecognized)
3639 copy(dAtA[i:], m.XXX_unrecognized)
3640 }
3641 if len(m.Name) > 0 {
3642 i -= len(m.Name)
3643 copy(dAtA[i:], m.Name)
3644 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3645 i--
3646 dAtA[i] = 0xa
3647 }
3648 return len(dAtA) - i, nil
3649 }
3650
3651 func (m *DeleteNetworkResponse) Marshal() (dAtA []byte, err error) {
3652 size := m.Size()
3653 dAtA = make([]byte, size)
3654 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3655 if err != nil {
3656 return nil, err
3657 }
3658 return dAtA[:n], nil
3659 }
3660
3661 func (m *DeleteNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
3662 size := m.Size()
3663 return m.MarshalToSizedBuffer(dAtA[:size])
3664 }
3665
3666 func (m *DeleteNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3667 i := len(dAtA)
3668 _ = i
3669 var l int
3670 _ = l
3671 if m.XXX_unrecognized != nil {
3672 i -= len(m.XXX_unrecognized)
3673 copy(dAtA[i:], m.XXX_unrecognized)
3674 }
3675 return len(dAtA) - i, nil
3676 }
3677
3678 func (m *GetEndpointRequest) Marshal() (dAtA []byte, err error) {
3679 size := m.Size()
3680 dAtA = make([]byte, size)
3681 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3682 if err != nil {
3683 return nil, err
3684 }
3685 return dAtA[:n], nil
3686 }
3687
3688 func (m *GetEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
3689 size := m.Size()
3690 return m.MarshalToSizedBuffer(dAtA[:size])
3691 }
3692
3693 func (m *GetEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3694 i := len(dAtA)
3695 _ = i
3696 var l int
3697 _ = l
3698 if m.XXX_unrecognized != nil {
3699 i -= len(m.XXX_unrecognized)
3700 copy(dAtA[i:], m.XXX_unrecognized)
3701 }
3702 if len(m.Name) > 0 {
3703 i -= len(m.Name)
3704 copy(dAtA[i:], m.Name)
3705 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3706 i--
3707 dAtA[i] = 0xa
3708 }
3709 return len(dAtA) - i, nil
3710 }
3711
3712 func (m *GetEndpointResponse) Marshal() (dAtA []byte, err error) {
3713 size := m.Size()
3714 dAtA = make([]byte, size)
3715 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3716 if err != nil {
3717 return nil, err
3718 }
3719 return dAtA[:n], nil
3720 }
3721
3722 func (m *GetEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
3723 size := m.Size()
3724 return m.MarshalToSizedBuffer(dAtA[:size])
3725 }
3726
3727 func (m *GetEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3728 i := len(dAtA)
3729 _ = i
3730 var l int
3731 _ = l
3732 if m.XXX_unrecognized != nil {
3733 i -= len(m.XXX_unrecognized)
3734 copy(dAtA[i:], m.XXX_unrecognized)
3735 }
3736 if m.Endpoint != nil {
3737 {
3738 size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
3739 if err != nil {
3740 return 0, err
3741 }
3742 i -= size
3743 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3744 }
3745 i--
3746 dAtA[i] = 0x1a
3747 }
3748 if len(m.ID) > 0 {
3749 i -= len(m.ID)
3750 copy(dAtA[i:], m.ID)
3751 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
3752 i--
3753 dAtA[i] = 0x12
3754 }
3755 if len(m.Namespace) > 0 {
3756 i -= len(m.Namespace)
3757 copy(dAtA[i:], m.Namespace)
3758 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Namespace)))
3759 i--
3760 dAtA[i] = 0xa
3761 }
3762 return len(dAtA) - i, nil
3763 }
3764
3765 func (m *GetNetworkRequest) Marshal() (dAtA []byte, err error) {
3766 size := m.Size()
3767 dAtA = make([]byte, size)
3768 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3769 if err != nil {
3770 return nil, err
3771 }
3772 return dAtA[:n], nil
3773 }
3774
3775 func (m *GetNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
3776 size := m.Size()
3777 return m.MarshalToSizedBuffer(dAtA[:size])
3778 }
3779
3780 func (m *GetNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3781 i := len(dAtA)
3782 _ = i
3783 var l int
3784 _ = l
3785 if m.XXX_unrecognized != nil {
3786 i -= len(m.XXX_unrecognized)
3787 copy(dAtA[i:], m.XXX_unrecognized)
3788 }
3789 if len(m.Name) > 0 {
3790 i -= len(m.Name)
3791 copy(dAtA[i:], m.Name)
3792 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
3793 i--
3794 dAtA[i] = 0xa
3795 }
3796 return len(dAtA) - i, nil
3797 }
3798
3799 func (m *GetNetworkResponse) Marshal() (dAtA []byte, err error) {
3800 size := m.Size()
3801 dAtA = make([]byte, size)
3802 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3803 if err != nil {
3804 return nil, err
3805 }
3806 return dAtA[:n], nil
3807 }
3808
3809 func (m *GetNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
3810 size := m.Size()
3811 return m.MarshalToSizedBuffer(dAtA[:size])
3812 }
3813
3814 func (m *GetNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3815 i := len(dAtA)
3816 _ = i
3817 var l int
3818 _ = l
3819 if m.XXX_unrecognized != nil {
3820 i -= len(m.XXX_unrecognized)
3821 copy(dAtA[i:], m.XXX_unrecognized)
3822 }
3823 if m.MacRange != nil {
3824 {
3825 size, err := m.MacRange.MarshalToSizedBuffer(dAtA[:i])
3826 if err != nil {
3827 return 0, err
3828 }
3829 i -= size
3830 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3831 }
3832 i--
3833 dAtA[i] = 0x1a
3834 }
3835 if m.Network != nil {
3836 {
3837 size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
3838 if err != nil {
3839 return 0, err
3840 }
3841 i -= size
3842 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3843 }
3844 i--
3845 dAtA[i] = 0x12
3846 }
3847 if len(m.ID) > 0 {
3848 i -= len(m.ID)
3849 copy(dAtA[i:], m.ID)
3850 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
3851 i--
3852 dAtA[i] = 0xa
3853 }
3854 return len(dAtA) - i, nil
3855 }
3856
3857 func (m *MacRange) Marshal() (dAtA []byte, err error) {
3858 size := m.Size()
3859 dAtA = make([]byte, size)
3860 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3861 if err != nil {
3862 return nil, err
3863 }
3864 return dAtA[:n], nil
3865 }
3866
3867 func (m *MacRange) MarshalTo(dAtA []byte) (int, error) {
3868 size := m.Size()
3869 return m.MarshalToSizedBuffer(dAtA[:size])
3870 }
3871
3872 func (m *MacRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3873 i := len(dAtA)
3874 _ = i
3875 var l int
3876 _ = l
3877 if m.XXX_unrecognized != nil {
3878 i -= len(m.XXX_unrecognized)
3879 copy(dAtA[i:], m.XXX_unrecognized)
3880 }
3881 if len(m.EndMacAddress) > 0 {
3882 i -= len(m.EndMacAddress)
3883 copy(dAtA[i:], m.EndMacAddress)
3884 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndMacAddress)))
3885 i--
3886 dAtA[i] = 0x12
3887 }
3888 if len(m.StartMacAddress) > 0 {
3889 i -= len(m.StartMacAddress)
3890 copy(dAtA[i:], m.StartMacAddress)
3891 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.StartMacAddress)))
3892 i--
3893 dAtA[i] = 0xa
3894 }
3895 return len(dAtA) - i, nil
3896 }
3897
3898 func (m *GetEndpointsRequest) Marshal() (dAtA []byte, err error) {
3899 size := m.Size()
3900 dAtA = make([]byte, size)
3901 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3902 if err != nil {
3903 return nil, err
3904 }
3905 return dAtA[:n], nil
3906 }
3907
3908 func (m *GetEndpointsRequest) MarshalTo(dAtA []byte) (int, error) {
3909 size := m.Size()
3910 return m.MarshalToSizedBuffer(dAtA[:size])
3911 }
3912
3913 func (m *GetEndpointsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3914 i := len(dAtA)
3915 _ = i
3916 var l int
3917 _ = l
3918 if m.XXX_unrecognized != nil {
3919 i -= len(m.XXX_unrecognized)
3920 copy(dAtA[i:], m.XXX_unrecognized)
3921 }
3922 return len(dAtA) - i, nil
3923 }
3924
3925 func (m *GetEndpointsResponse) Marshal() (dAtA []byte, err error) {
3926 size := m.Size()
3927 dAtA = make([]byte, size)
3928 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3929 if err != nil {
3930 return nil, err
3931 }
3932 return dAtA[:n], nil
3933 }
3934
3935 func (m *GetEndpointsResponse) MarshalTo(dAtA []byte) (int, error) {
3936 size := m.Size()
3937 return m.MarshalToSizedBuffer(dAtA[:size])
3938 }
3939
3940 func (m *GetEndpointsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3941 i := len(dAtA)
3942 _ = i
3943 var l int
3944 _ = l
3945 if m.XXX_unrecognized != nil {
3946 i -= len(m.XXX_unrecognized)
3947 copy(dAtA[i:], m.XXX_unrecognized)
3948 }
3949 if len(m.Endpoints) > 0 {
3950 for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
3951 {
3952 size, err := m.Endpoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
3953 if err != nil {
3954 return 0, err
3955 }
3956 i -= size
3957 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
3958 }
3959 i--
3960 dAtA[i] = 0xa
3961 }
3962 }
3963 return len(dAtA) - i, nil
3964 }
3965
3966 func (m *GetNetworksRequest) Marshal() (dAtA []byte, err error) {
3967 size := m.Size()
3968 dAtA = make([]byte, size)
3969 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3970 if err != nil {
3971 return nil, err
3972 }
3973 return dAtA[:n], nil
3974 }
3975
3976 func (m *GetNetworksRequest) MarshalTo(dAtA []byte) (int, error) {
3977 size := m.Size()
3978 return m.MarshalToSizedBuffer(dAtA[:size])
3979 }
3980
3981 func (m *GetNetworksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3982 i := len(dAtA)
3983 _ = i
3984 var l int
3985 _ = l
3986 if m.XXX_unrecognized != nil {
3987 i -= len(m.XXX_unrecognized)
3988 copy(dAtA[i:], m.XXX_unrecognized)
3989 }
3990 return len(dAtA) - i, nil
3991 }
3992
3993 func (m *GetNetworksResponse) Marshal() (dAtA []byte, err error) {
3994 size := m.Size()
3995 dAtA = make([]byte, size)
3996 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3997 if err != nil {
3998 return nil, err
3999 }
4000 return dAtA[:n], nil
4001 }
4002
4003 func (m *GetNetworksResponse) MarshalTo(dAtA []byte) (int, error) {
4004 size := m.Size()
4005 return m.MarshalToSizedBuffer(dAtA[:size])
4006 }
4007
4008 func (m *GetNetworksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4009 i := len(dAtA)
4010 _ = i
4011 var l int
4012 _ = l
4013 if m.XXX_unrecognized != nil {
4014 i -= len(m.XXX_unrecognized)
4015 copy(dAtA[i:], m.XXX_unrecognized)
4016 }
4017 if len(m.Networks) > 0 {
4018 for iNdEx := len(m.Networks) - 1; iNdEx >= 0; iNdEx-- {
4019 {
4020 size, err := m.Networks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
4021 if err != nil {
4022 return 0, err
4023 }
4024 i -= size
4025 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
4026 }
4027 i--
4028 dAtA[i] = 0xa
4029 }
4030 }
4031 return len(dAtA) - i, nil
4032 }
4033
4034 func encodeVarintNetworkconfigproxy(dAtA []byte, offset int, v uint64) int {
4035 offset -= sovNetworkconfigproxy(v)
4036 base := offset
4037 for v >= 1<<7 {
4038 dAtA[offset] = uint8(v&0x7f | 0x80)
4039 v >>= 7
4040 offset++
4041 }
4042 dAtA[offset] = uint8(v)
4043 return base
4044 }
4045 func (m *AddNICRequest) Size() (n int) {
4046 if m == nil {
4047 return 0
4048 }
4049 var l int
4050 _ = l
4051 l = len(m.ContainerID)
4052 if l > 0 {
4053 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4054 }
4055 l = len(m.NicID)
4056 if l > 0 {
4057 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4058 }
4059 l = len(m.EndpointName)
4060 if l > 0 {
4061 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4062 }
4063 if m.EndpointSettings != nil {
4064 l = m.EndpointSettings.Size()
4065 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4066 }
4067 if m.XXX_unrecognized != nil {
4068 n += len(m.XXX_unrecognized)
4069 }
4070 return n
4071 }
4072
4073 func (m *AddNICResponse) Size() (n int) {
4074 if m == nil {
4075 return 0
4076 }
4077 var l int
4078 _ = l
4079 if m.XXX_unrecognized != nil {
4080 n += len(m.XXX_unrecognized)
4081 }
4082 return n
4083 }
4084
4085 func (m *ModifyNICRequest) Size() (n int) {
4086 if m == nil {
4087 return 0
4088 }
4089 var l int
4090 _ = l
4091 l = len(m.ContainerID)
4092 if l > 0 {
4093 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4094 }
4095 l = len(m.NicID)
4096 if l > 0 {
4097 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4098 }
4099 l = len(m.EndpointName)
4100 if l > 0 {
4101 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4102 }
4103 if m.EndpointSettings != nil {
4104 l = m.EndpointSettings.Size()
4105 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4106 }
4107 if m.XXX_unrecognized != nil {
4108 n += len(m.XXX_unrecognized)
4109 }
4110 return n
4111 }
4112
4113 func (m *ModifyNICResponse) Size() (n int) {
4114 if m == nil {
4115 return 0
4116 }
4117 var l int
4118 _ = l
4119 if m.XXX_unrecognized != nil {
4120 n += len(m.XXX_unrecognized)
4121 }
4122 return n
4123 }
4124
4125 func (m *DeleteNICRequest) Size() (n int) {
4126 if m == nil {
4127 return 0
4128 }
4129 var l int
4130 _ = l
4131 l = len(m.ContainerID)
4132 if l > 0 {
4133 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4134 }
4135 l = len(m.NicID)
4136 if l > 0 {
4137 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4138 }
4139 l = len(m.EndpointName)
4140 if l > 0 {
4141 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4142 }
4143 if m.XXX_unrecognized != nil {
4144 n += len(m.XXX_unrecognized)
4145 }
4146 return n
4147 }
4148
4149 func (m *DeleteNICResponse) Size() (n int) {
4150 if m == nil {
4151 return 0
4152 }
4153 var l int
4154 _ = l
4155 if m.XXX_unrecognized != nil {
4156 n += len(m.XXX_unrecognized)
4157 }
4158 return n
4159 }
4160
4161 func (m *CreateNetworkRequest) Size() (n int) {
4162 if m == nil {
4163 return 0
4164 }
4165 var l int
4166 _ = l
4167 if m.Network != nil {
4168 l = m.Network.Size()
4169 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4170 }
4171 if m.XXX_unrecognized != nil {
4172 n += len(m.XXX_unrecognized)
4173 }
4174 return n
4175 }
4176
4177 func (m *Network) Size() (n int) {
4178 if m == nil {
4179 return 0
4180 }
4181 var l int
4182 _ = l
4183 if m.Settings != nil {
4184 n += m.Settings.Size()
4185 }
4186 if m.XXX_unrecognized != nil {
4187 n += len(m.XXX_unrecognized)
4188 }
4189 return n
4190 }
4191
4192 func (m *Network_HcnNetwork) Size() (n int) {
4193 if m == nil {
4194 return 0
4195 }
4196 var l int
4197 _ = l
4198 if m.HcnNetwork != nil {
4199 l = m.HcnNetwork.Size()
4200 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4201 }
4202 return n
4203 }
4204 func (m *Network_NcproxyNetwork) Size() (n int) {
4205 if m == nil {
4206 return 0
4207 }
4208 var l int
4209 _ = l
4210 if m.NcproxyNetwork != nil {
4211 l = m.NcproxyNetwork.Size()
4212 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4213 }
4214 return n
4215 }
4216 func (m *NCProxyNetworkSettings) Size() (n int) {
4217 if m == nil {
4218 return 0
4219 }
4220 var l int
4221 _ = l
4222 l = len(m.Name)
4223 if l > 0 {
4224 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4225 }
4226 if m.XXX_unrecognized != nil {
4227 n += len(m.XXX_unrecognized)
4228 }
4229 return n
4230 }
4231
4232 func (m *HostComputeNetworkSettings) Size() (n int) {
4233 if m == nil {
4234 return 0
4235 }
4236 var l int
4237 _ = l
4238 l = len(m.Name)
4239 if l > 0 {
4240 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4241 }
4242 if m.Mode != 0 {
4243 n += 1 + sovNetworkconfigproxy(uint64(m.Mode))
4244 }
4245 l = len(m.SwitchName)
4246 if l > 0 {
4247 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4248 }
4249 if m.IpamType != 0 {
4250 n += 1 + sovNetworkconfigproxy(uint64(m.IpamType))
4251 }
4252 if len(m.SubnetIpaddressPrefix) > 0 {
4253 for _, s := range m.SubnetIpaddressPrefix {
4254 l = len(s)
4255 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4256 }
4257 }
4258 l = len(m.DefaultGateway)
4259 if l > 0 {
4260 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4261 }
4262 if len(m.SubnetIpaddressPrefixIpv6) > 0 {
4263 for _, s := range m.SubnetIpaddressPrefixIpv6 {
4264 l = len(s)
4265 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4266 }
4267 }
4268 l = len(m.DefaultGatewayIpv6)
4269 if l > 0 {
4270 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4271 }
4272 if m.XXX_unrecognized != nil {
4273 n += len(m.XXX_unrecognized)
4274 }
4275 return n
4276 }
4277
4278 func (m *CreateNetworkResponse) Size() (n int) {
4279 if m == nil {
4280 return 0
4281 }
4282 var l int
4283 _ = l
4284 l = len(m.ID)
4285 if l > 0 {
4286 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4287 }
4288 if m.XXX_unrecognized != nil {
4289 n += len(m.XXX_unrecognized)
4290 }
4291 return n
4292 }
4293
4294 func (m *PortNameEndpointPolicySetting) Size() (n int) {
4295 if m == nil {
4296 return 0
4297 }
4298 var l int
4299 _ = l
4300 l = len(m.PortName)
4301 if l > 0 {
4302 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4303 }
4304 if m.XXX_unrecognized != nil {
4305 n += len(m.XXX_unrecognized)
4306 }
4307 return n
4308 }
4309
4310 func (m *IovEndpointPolicySetting) Size() (n int) {
4311 if m == nil {
4312 return 0
4313 }
4314 var l int
4315 _ = l
4316 if m.IovOffloadWeight != 0 {
4317 n += 1 + sovNetworkconfigproxy(uint64(m.IovOffloadWeight))
4318 }
4319 if m.QueuePairsRequested != 0 {
4320 n += 1 + sovNetworkconfigproxy(uint64(m.QueuePairsRequested))
4321 }
4322 if m.InterruptModeration != 0 {
4323 n += 1 + sovNetworkconfigproxy(uint64(m.InterruptModeration))
4324 }
4325 if m.XXX_unrecognized != nil {
4326 n += len(m.XXX_unrecognized)
4327 }
4328 return n
4329 }
4330
4331 func (m *DnsSetting) Size() (n int) {
4332 if m == nil {
4333 return 0
4334 }
4335 var l int
4336 _ = l
4337 if len(m.ServerIpAddrs) > 0 {
4338 for _, s := range m.ServerIpAddrs {
4339 l = len(s)
4340 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4341 }
4342 }
4343 l = len(m.Domain)
4344 if l > 0 {
4345 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4346 }
4347 if len(m.Search) > 0 {
4348 for _, s := range m.Search {
4349 l = len(s)
4350 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4351 }
4352 }
4353 if m.XXX_unrecognized != nil {
4354 n += len(m.XXX_unrecognized)
4355 }
4356 return n
4357 }
4358
4359 func (m *CreateEndpointRequest) Size() (n int) {
4360 if m == nil {
4361 return 0
4362 }
4363 var l int
4364 _ = l
4365 if m.EndpointSettings != nil {
4366 l = m.EndpointSettings.Size()
4367 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4368 }
4369 if m.XXX_unrecognized != nil {
4370 n += len(m.XXX_unrecognized)
4371 }
4372 return n
4373 }
4374
4375 func (m *EndpointSettings) Size() (n int) {
4376 if m == nil {
4377 return 0
4378 }
4379 var l int
4380 _ = l
4381 if m.Settings != nil {
4382 n += m.Settings.Size()
4383 }
4384 if m.XXX_unrecognized != nil {
4385 n += len(m.XXX_unrecognized)
4386 }
4387 return n
4388 }
4389
4390 func (m *EndpointSettings_HcnEndpoint) Size() (n int) {
4391 if m == nil {
4392 return 0
4393 }
4394 var l int
4395 _ = l
4396 if m.HcnEndpoint != nil {
4397 l = m.HcnEndpoint.Size()
4398 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4399 }
4400 return n
4401 }
4402 func (m *EndpointSettings_NcproxyEndpoint) Size() (n int) {
4403 if m == nil {
4404 return 0
4405 }
4406 var l int
4407 _ = l
4408 if m.NcproxyEndpoint != nil {
4409 l = m.NcproxyEndpoint.Size()
4410 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4411 }
4412 return n
4413 }
4414 func (m *HcnEndpointResponse) Size() (n int) {
4415 if m == nil {
4416 return 0
4417 }
4418 var l int
4419 _ = l
4420 l = len(m.Namespace)
4421 if l > 0 {
4422 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4423 }
4424 l = len(m.ID)
4425 if l > 0 {
4426 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4427 }
4428 if m.Settings != nil {
4429 l = m.Settings.Size()
4430 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4431 }
4432 if m.XXX_unrecognized != nil {
4433 n += len(m.XXX_unrecognized)
4434 }
4435 return n
4436 }
4437
4438 func (m *HcnEndpointSettings) Size() (n int) {
4439 if m == nil {
4440 return 0
4441 }
4442 var l int
4443 _ = l
4444 l = len(m.Name)
4445 if l > 0 {
4446 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4447 }
4448 l = len(m.Macaddress)
4449 if l > 0 {
4450 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4451 }
4452 l = len(m.Ipaddress)
4453 if l > 0 {
4454 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4455 }
4456 if m.IpaddressPrefixlength != 0 {
4457 n += 1 + sovNetworkconfigproxy(uint64(m.IpaddressPrefixlength))
4458 }
4459 l = len(m.NetworkName)
4460 if l > 0 {
4461 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4462 }
4463 if m.Policies != nil {
4464 l = m.Policies.Size()
4465 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4466 }
4467 if m.DnsSetting != nil {
4468 l = m.DnsSetting.Size()
4469 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4470 }
4471 l = len(m.Ipv6Address)
4472 if l > 0 {
4473 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4474 }
4475 if m.Ipv6AddressPrefixlength != 0 {
4476 n += 1 + sovNetworkconfigproxy(uint64(m.Ipv6AddressPrefixlength))
4477 }
4478 if m.XXX_unrecognized != nil {
4479 n += len(m.XXX_unrecognized)
4480 }
4481 return n
4482 }
4483
4484 func (m *HcnEndpointPolicies) Size() (n int) {
4485 if m == nil {
4486 return 0
4487 }
4488 var l int
4489 _ = l
4490 if m.PortnamePolicySetting != nil {
4491 l = m.PortnamePolicySetting.Size()
4492 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4493 }
4494 if m.IovPolicySettings != nil {
4495 l = m.IovPolicySettings.Size()
4496 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4497 }
4498 if m.XXX_unrecognized != nil {
4499 n += len(m.XXX_unrecognized)
4500 }
4501 return n
4502 }
4503
4504 func (m *NCProxyEndpointSettings) Size() (n int) {
4505 if m == nil {
4506 return 0
4507 }
4508 var l int
4509 _ = l
4510 l = len(m.Name)
4511 if l > 0 {
4512 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4513 }
4514 l = len(m.Macaddress)
4515 if l > 0 {
4516 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4517 }
4518 l = len(m.Ipaddress)
4519 if l > 0 {
4520 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4521 }
4522 if m.IpaddressPrefixlength != 0 {
4523 n += 1 + sovNetworkconfigproxy(uint64(m.IpaddressPrefixlength))
4524 }
4525 l = len(m.NetworkName)
4526 if l > 0 {
4527 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4528 }
4529 l = len(m.DefaultGateway)
4530 if l > 0 {
4531 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4532 }
4533 if m.DeviceDetails != nil {
4534 n += m.DeviceDetails.Size()
4535 }
4536 l = len(m.Ipv6Address)
4537 if l > 0 {
4538 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4539 }
4540 l = len(m.Ipv6AddressPrefixlength)
4541 if l > 0 {
4542 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4543 }
4544 if m.XXX_unrecognized != nil {
4545 n += len(m.XXX_unrecognized)
4546 }
4547 return n
4548 }
4549
4550 func (m *NCProxyEndpointSettings_PciDeviceDetails) Size() (n int) {
4551 if m == nil {
4552 return 0
4553 }
4554 var l int
4555 _ = l
4556 if m.PciDeviceDetails != nil {
4557 l = m.PciDeviceDetails.Size()
4558 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4559 }
4560 return n
4561 }
4562 func (m *PCIDeviceDetails) Size() (n int) {
4563 if m == nil {
4564 return 0
4565 }
4566 var l int
4567 _ = l
4568 l = len(m.DeviceID)
4569 if l > 0 {
4570 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4571 }
4572 if m.VirtualFunctionIndex != 0 {
4573 n += 1 + sovNetworkconfigproxy(uint64(m.VirtualFunctionIndex))
4574 }
4575 if m.XXX_unrecognized != nil {
4576 n += len(m.XXX_unrecognized)
4577 }
4578 return n
4579 }
4580
4581 func (m *CreateEndpointResponse) Size() (n int) {
4582 if m == nil {
4583 return 0
4584 }
4585 var l int
4586 _ = l
4587 l = len(m.ID)
4588 if l > 0 {
4589 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4590 }
4591 if m.XXX_unrecognized != nil {
4592 n += len(m.XXX_unrecognized)
4593 }
4594 return n
4595 }
4596
4597 func (m *AddEndpointRequest) Size() (n int) {
4598 if m == nil {
4599 return 0
4600 }
4601 var l int
4602 _ = l
4603 l = len(m.Name)
4604 if l > 0 {
4605 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4606 }
4607 l = len(m.NamespaceID)
4608 if l > 0 {
4609 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4610 }
4611 if m.AttachToHost {
4612 n += 2
4613 }
4614 if m.XXX_unrecognized != nil {
4615 n += len(m.XXX_unrecognized)
4616 }
4617 return n
4618 }
4619
4620 func (m *AddEndpointResponse) Size() (n int) {
4621 if m == nil {
4622 return 0
4623 }
4624 var l int
4625 _ = l
4626 if m.XXX_unrecognized != nil {
4627 n += len(m.XXX_unrecognized)
4628 }
4629 return n
4630 }
4631
4632 func (m *DeleteEndpointRequest) Size() (n int) {
4633 if m == nil {
4634 return 0
4635 }
4636 var l int
4637 _ = l
4638 l = len(m.Name)
4639 if l > 0 {
4640 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4641 }
4642 if m.XXX_unrecognized != nil {
4643 n += len(m.XXX_unrecognized)
4644 }
4645 return n
4646 }
4647
4648 func (m *DeleteEndpointResponse) Size() (n int) {
4649 if m == nil {
4650 return 0
4651 }
4652 var l int
4653 _ = l
4654 if m.XXX_unrecognized != nil {
4655 n += len(m.XXX_unrecognized)
4656 }
4657 return n
4658 }
4659
4660 func (m *DeleteNetworkRequest) Size() (n int) {
4661 if m == nil {
4662 return 0
4663 }
4664 var l int
4665 _ = l
4666 l = len(m.Name)
4667 if l > 0 {
4668 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4669 }
4670 if m.XXX_unrecognized != nil {
4671 n += len(m.XXX_unrecognized)
4672 }
4673 return n
4674 }
4675
4676 func (m *DeleteNetworkResponse) Size() (n int) {
4677 if m == nil {
4678 return 0
4679 }
4680 var l int
4681 _ = l
4682 if m.XXX_unrecognized != nil {
4683 n += len(m.XXX_unrecognized)
4684 }
4685 return n
4686 }
4687
4688 func (m *GetEndpointRequest) Size() (n int) {
4689 if m == nil {
4690 return 0
4691 }
4692 var l int
4693 _ = l
4694 l = len(m.Name)
4695 if l > 0 {
4696 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4697 }
4698 if m.XXX_unrecognized != nil {
4699 n += len(m.XXX_unrecognized)
4700 }
4701 return n
4702 }
4703
4704 func (m *GetEndpointResponse) Size() (n int) {
4705 if m == nil {
4706 return 0
4707 }
4708 var l int
4709 _ = l
4710 l = len(m.Namespace)
4711 if l > 0 {
4712 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4713 }
4714 l = len(m.ID)
4715 if l > 0 {
4716 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4717 }
4718 if m.Endpoint != nil {
4719 l = m.Endpoint.Size()
4720 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4721 }
4722 if m.XXX_unrecognized != nil {
4723 n += len(m.XXX_unrecognized)
4724 }
4725 return n
4726 }
4727
4728 func (m *GetNetworkRequest) Size() (n int) {
4729 if m == nil {
4730 return 0
4731 }
4732 var l int
4733 _ = l
4734 l = len(m.Name)
4735 if l > 0 {
4736 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4737 }
4738 if m.XXX_unrecognized != nil {
4739 n += len(m.XXX_unrecognized)
4740 }
4741 return n
4742 }
4743
4744 func (m *GetNetworkResponse) Size() (n int) {
4745 if m == nil {
4746 return 0
4747 }
4748 var l int
4749 _ = l
4750 l = len(m.ID)
4751 if l > 0 {
4752 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4753 }
4754 if m.Network != nil {
4755 l = m.Network.Size()
4756 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4757 }
4758 if m.MacRange != nil {
4759 l = m.MacRange.Size()
4760 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4761 }
4762 if m.XXX_unrecognized != nil {
4763 n += len(m.XXX_unrecognized)
4764 }
4765 return n
4766 }
4767
4768 func (m *MacRange) Size() (n int) {
4769 if m == nil {
4770 return 0
4771 }
4772 var l int
4773 _ = l
4774 l = len(m.StartMacAddress)
4775 if l > 0 {
4776 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4777 }
4778 l = len(m.EndMacAddress)
4779 if l > 0 {
4780 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4781 }
4782 if m.XXX_unrecognized != nil {
4783 n += len(m.XXX_unrecognized)
4784 }
4785 return n
4786 }
4787
4788 func (m *GetEndpointsRequest) Size() (n int) {
4789 if m == nil {
4790 return 0
4791 }
4792 var l int
4793 _ = l
4794 if m.XXX_unrecognized != nil {
4795 n += len(m.XXX_unrecognized)
4796 }
4797 return n
4798 }
4799
4800 func (m *GetEndpointsResponse) Size() (n int) {
4801 if m == nil {
4802 return 0
4803 }
4804 var l int
4805 _ = l
4806 if len(m.Endpoints) > 0 {
4807 for _, e := range m.Endpoints {
4808 l = e.Size()
4809 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4810 }
4811 }
4812 if m.XXX_unrecognized != nil {
4813 n += len(m.XXX_unrecognized)
4814 }
4815 return n
4816 }
4817
4818 func (m *GetNetworksRequest) Size() (n int) {
4819 if m == nil {
4820 return 0
4821 }
4822 var l int
4823 _ = l
4824 if m.XXX_unrecognized != nil {
4825 n += len(m.XXX_unrecognized)
4826 }
4827 return n
4828 }
4829
4830 func (m *GetNetworksResponse) Size() (n int) {
4831 if m == nil {
4832 return 0
4833 }
4834 var l int
4835 _ = l
4836 if len(m.Networks) > 0 {
4837 for _, e := range m.Networks {
4838 l = e.Size()
4839 n += 1 + l + sovNetworkconfigproxy(uint64(l))
4840 }
4841 }
4842 if m.XXX_unrecognized != nil {
4843 n += len(m.XXX_unrecognized)
4844 }
4845 return n
4846 }
4847
4848 func sovNetworkconfigproxy(x uint64) (n int) {
4849 return (math_bits.Len64(x|1) + 6) / 7
4850 }
4851 func sozNetworkconfigproxy(x uint64) (n int) {
4852 return sovNetworkconfigproxy(uint64((x << 1) ^ uint64((int64(x) >> 63))))
4853 }
4854 func (this *AddNICRequest) String() string {
4855 if this == nil {
4856 return "nil"
4857 }
4858 s := strings.Join([]string{`&AddNICRequest{`,
4859 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
4860 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
4861 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
4862 `EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
4863 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4864 `}`,
4865 }, "")
4866 return s
4867 }
4868 func (this *AddNICResponse) String() string {
4869 if this == nil {
4870 return "nil"
4871 }
4872 s := strings.Join([]string{`&AddNICResponse{`,
4873 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4874 `}`,
4875 }, "")
4876 return s
4877 }
4878 func (this *ModifyNICRequest) String() string {
4879 if this == nil {
4880 return "nil"
4881 }
4882 s := strings.Join([]string{`&ModifyNICRequest{`,
4883 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
4884 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
4885 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
4886 `EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
4887 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4888 `}`,
4889 }, "")
4890 return s
4891 }
4892 func (this *ModifyNICResponse) String() string {
4893 if this == nil {
4894 return "nil"
4895 }
4896 s := strings.Join([]string{`&ModifyNICResponse{`,
4897 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4898 `}`,
4899 }, "")
4900 return s
4901 }
4902 func (this *DeleteNICRequest) String() string {
4903 if this == nil {
4904 return "nil"
4905 }
4906 s := strings.Join([]string{`&DeleteNICRequest{`,
4907 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
4908 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
4909 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
4910 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4911 `}`,
4912 }, "")
4913 return s
4914 }
4915 func (this *DeleteNICResponse) String() string {
4916 if this == nil {
4917 return "nil"
4918 }
4919 s := strings.Join([]string{`&DeleteNICResponse{`,
4920 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4921 `}`,
4922 }, "")
4923 return s
4924 }
4925 func (this *CreateNetworkRequest) String() string {
4926 if this == nil {
4927 return "nil"
4928 }
4929 s := strings.Join([]string{`&CreateNetworkRequest{`,
4930 `Network:` + strings.Replace(this.Network.String(), "Network", "Network", 1) + `,`,
4931 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4932 `}`,
4933 }, "")
4934 return s
4935 }
4936 func (this *Network) String() string {
4937 if this == nil {
4938 return "nil"
4939 }
4940 s := strings.Join([]string{`&Network{`,
4941 `Settings:` + fmt.Sprintf("%v", this.Settings) + `,`,
4942 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4943 `}`,
4944 }, "")
4945 return s
4946 }
4947 func (this *Network_HcnNetwork) String() string {
4948 if this == nil {
4949 return "nil"
4950 }
4951 s := strings.Join([]string{`&Network_HcnNetwork{`,
4952 `HcnNetwork:` + strings.Replace(fmt.Sprintf("%v", this.HcnNetwork), "HostComputeNetworkSettings", "HostComputeNetworkSettings", 1) + `,`,
4953 `}`,
4954 }, "")
4955 return s
4956 }
4957 func (this *Network_NcproxyNetwork) String() string {
4958 if this == nil {
4959 return "nil"
4960 }
4961 s := strings.Join([]string{`&Network_NcproxyNetwork{`,
4962 `NcproxyNetwork:` + strings.Replace(fmt.Sprintf("%v", this.NcproxyNetwork), "NCProxyNetworkSettings", "NCProxyNetworkSettings", 1) + `,`,
4963 `}`,
4964 }, "")
4965 return s
4966 }
4967 func (this *NCProxyNetworkSettings) String() string {
4968 if this == nil {
4969 return "nil"
4970 }
4971 s := strings.Join([]string{`&NCProxyNetworkSettings{`,
4972 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
4973 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4974 `}`,
4975 }, "")
4976 return s
4977 }
4978 func (this *HostComputeNetworkSettings) String() string {
4979 if this == nil {
4980 return "nil"
4981 }
4982 s := strings.Join([]string{`&HostComputeNetworkSettings{`,
4983 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
4984 `Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
4985 `SwitchName:` + fmt.Sprintf("%v", this.SwitchName) + `,`,
4986 `IpamType:` + fmt.Sprintf("%v", this.IpamType) + `,`,
4987 `SubnetIpaddressPrefix:` + fmt.Sprintf("%v", this.SubnetIpaddressPrefix) + `,`,
4988 `DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
4989 `SubnetIpaddressPrefixIpv6:` + fmt.Sprintf("%v", this.SubnetIpaddressPrefixIpv6) + `,`,
4990 `DefaultGatewayIpv6:` + fmt.Sprintf("%v", this.DefaultGatewayIpv6) + `,`,
4991 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4992 `}`,
4993 }, "")
4994 return s
4995 }
4996 func (this *CreateNetworkResponse) String() string {
4997 if this == nil {
4998 return "nil"
4999 }
5000 s := strings.Join([]string{`&CreateNetworkResponse{`,
5001 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
5002 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5003 `}`,
5004 }, "")
5005 return s
5006 }
5007 func (this *PortNameEndpointPolicySetting) String() string {
5008 if this == nil {
5009 return "nil"
5010 }
5011 s := strings.Join([]string{`&PortNameEndpointPolicySetting{`,
5012 `PortName:` + fmt.Sprintf("%v", this.PortName) + `,`,
5013 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5014 `}`,
5015 }, "")
5016 return s
5017 }
5018 func (this *IovEndpointPolicySetting) String() string {
5019 if this == nil {
5020 return "nil"
5021 }
5022 s := strings.Join([]string{`&IovEndpointPolicySetting{`,
5023 `IovOffloadWeight:` + fmt.Sprintf("%v", this.IovOffloadWeight) + `,`,
5024 `QueuePairsRequested:` + fmt.Sprintf("%v", this.QueuePairsRequested) + `,`,
5025 `InterruptModeration:` + fmt.Sprintf("%v", this.InterruptModeration) + `,`,
5026 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5027 `}`,
5028 }, "")
5029 return s
5030 }
5031 func (this *DnsSetting) String() string {
5032 if this == nil {
5033 return "nil"
5034 }
5035 s := strings.Join([]string{`&DnsSetting{`,
5036 `ServerIpAddrs:` + fmt.Sprintf("%v", this.ServerIpAddrs) + `,`,
5037 `Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
5038 `Search:` + fmt.Sprintf("%v", this.Search) + `,`,
5039 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5040 `}`,
5041 }, "")
5042 return s
5043 }
5044 func (this *CreateEndpointRequest) String() string {
5045 if this == nil {
5046 return "nil"
5047 }
5048 s := strings.Join([]string{`&CreateEndpointRequest{`,
5049 `EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
5050 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5051 `}`,
5052 }, "")
5053 return s
5054 }
5055 func (this *EndpointSettings) String() string {
5056 if this == nil {
5057 return "nil"
5058 }
5059 s := strings.Join([]string{`&EndpointSettings{`,
5060 `Settings:` + fmt.Sprintf("%v", this.Settings) + `,`,
5061 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5062 `}`,
5063 }, "")
5064 return s
5065 }
5066 func (this *EndpointSettings_HcnEndpoint) String() string {
5067 if this == nil {
5068 return "nil"
5069 }
5070 s := strings.Join([]string{`&EndpointSettings_HcnEndpoint{`,
5071 `HcnEndpoint:` + strings.Replace(fmt.Sprintf("%v", this.HcnEndpoint), "HcnEndpointSettings", "HcnEndpointSettings", 1) + `,`,
5072 `}`,
5073 }, "")
5074 return s
5075 }
5076 func (this *EndpointSettings_NcproxyEndpoint) String() string {
5077 if this == nil {
5078 return "nil"
5079 }
5080 s := strings.Join([]string{`&EndpointSettings_NcproxyEndpoint{`,
5081 `NcproxyEndpoint:` + strings.Replace(fmt.Sprintf("%v", this.NcproxyEndpoint), "NCProxyEndpointSettings", "NCProxyEndpointSettings", 1) + `,`,
5082 `}`,
5083 }, "")
5084 return s
5085 }
5086 func (this *HcnEndpointResponse) String() string {
5087 if this == nil {
5088 return "nil"
5089 }
5090 s := strings.Join([]string{`&HcnEndpointResponse{`,
5091 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
5092 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
5093 `Settings:` + strings.Replace(this.Settings.String(), "HcnEndpointSettings", "HcnEndpointSettings", 1) + `,`,
5094 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5095 `}`,
5096 }, "")
5097 return s
5098 }
5099 func (this *HcnEndpointSettings) String() string {
5100 if this == nil {
5101 return "nil"
5102 }
5103 s := strings.Join([]string{`&HcnEndpointSettings{`,
5104 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5105 `Macaddress:` + fmt.Sprintf("%v", this.Macaddress) + `,`,
5106 `Ipaddress:` + fmt.Sprintf("%v", this.Ipaddress) + `,`,
5107 `IpaddressPrefixlength:` + fmt.Sprintf("%v", this.IpaddressPrefixlength) + `,`,
5108 `NetworkName:` + fmt.Sprintf("%v", this.NetworkName) + `,`,
5109 `Policies:` + strings.Replace(this.Policies.String(), "HcnEndpointPolicies", "HcnEndpointPolicies", 1) + `,`,
5110 `DnsSetting:` + strings.Replace(this.DnsSetting.String(), "DnsSetting", "DnsSetting", 1) + `,`,
5111 `Ipv6Address:` + fmt.Sprintf("%v", this.Ipv6Address) + `,`,
5112 `Ipv6AddressPrefixlength:` + fmt.Sprintf("%v", this.Ipv6AddressPrefixlength) + `,`,
5113 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5114 `}`,
5115 }, "")
5116 return s
5117 }
5118 func (this *HcnEndpointPolicies) String() string {
5119 if this == nil {
5120 return "nil"
5121 }
5122 s := strings.Join([]string{`&HcnEndpointPolicies{`,
5123 `PortnamePolicySetting:` + strings.Replace(this.PortnamePolicySetting.String(), "PortNameEndpointPolicySetting", "PortNameEndpointPolicySetting", 1) + `,`,
5124 `IovPolicySettings:` + strings.Replace(this.IovPolicySettings.String(), "IovEndpointPolicySetting", "IovEndpointPolicySetting", 1) + `,`,
5125 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5126 `}`,
5127 }, "")
5128 return s
5129 }
5130 func (this *NCProxyEndpointSettings) String() string {
5131 if this == nil {
5132 return "nil"
5133 }
5134 s := strings.Join([]string{`&NCProxyEndpointSettings{`,
5135 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5136 `Macaddress:` + fmt.Sprintf("%v", this.Macaddress) + `,`,
5137 `Ipaddress:` + fmt.Sprintf("%v", this.Ipaddress) + `,`,
5138 `IpaddressPrefixlength:` + fmt.Sprintf("%v", this.IpaddressPrefixlength) + `,`,
5139 `NetworkName:` + fmt.Sprintf("%v", this.NetworkName) + `,`,
5140 `DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
5141 `DeviceDetails:` + fmt.Sprintf("%v", this.DeviceDetails) + `,`,
5142 `Ipv6Address:` + fmt.Sprintf("%v", this.Ipv6Address) + `,`,
5143 `Ipv6AddressPrefixlength:` + fmt.Sprintf("%v", this.Ipv6AddressPrefixlength) + `,`,
5144 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5145 `}`,
5146 }, "")
5147 return s
5148 }
5149 func (this *NCProxyEndpointSettings_PciDeviceDetails) String() string {
5150 if this == nil {
5151 return "nil"
5152 }
5153 s := strings.Join([]string{`&NCProxyEndpointSettings_PciDeviceDetails{`,
5154 `PciDeviceDetails:` + strings.Replace(fmt.Sprintf("%v", this.PciDeviceDetails), "PCIDeviceDetails", "PCIDeviceDetails", 1) + `,`,
5155 `}`,
5156 }, "")
5157 return s
5158 }
5159 func (this *PCIDeviceDetails) String() string {
5160 if this == nil {
5161 return "nil"
5162 }
5163 s := strings.Join([]string{`&PCIDeviceDetails{`,
5164 `DeviceID:` + fmt.Sprintf("%v", this.DeviceID) + `,`,
5165 `VirtualFunctionIndex:` + fmt.Sprintf("%v", this.VirtualFunctionIndex) + `,`,
5166 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5167 `}`,
5168 }, "")
5169 return s
5170 }
5171 func (this *CreateEndpointResponse) String() string {
5172 if this == nil {
5173 return "nil"
5174 }
5175 s := strings.Join([]string{`&CreateEndpointResponse{`,
5176 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
5177 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5178 `}`,
5179 }, "")
5180 return s
5181 }
5182 func (this *AddEndpointRequest) String() string {
5183 if this == nil {
5184 return "nil"
5185 }
5186 s := strings.Join([]string{`&AddEndpointRequest{`,
5187 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5188 `NamespaceID:` + fmt.Sprintf("%v", this.NamespaceID) + `,`,
5189 `AttachToHost:` + fmt.Sprintf("%v", this.AttachToHost) + `,`,
5190 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5191 `}`,
5192 }, "")
5193 return s
5194 }
5195 func (this *AddEndpointResponse) String() string {
5196 if this == nil {
5197 return "nil"
5198 }
5199 s := strings.Join([]string{`&AddEndpointResponse{`,
5200 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5201 `}`,
5202 }, "")
5203 return s
5204 }
5205 func (this *DeleteEndpointRequest) String() string {
5206 if this == nil {
5207 return "nil"
5208 }
5209 s := strings.Join([]string{`&DeleteEndpointRequest{`,
5210 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5211 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5212 `}`,
5213 }, "")
5214 return s
5215 }
5216 func (this *DeleteEndpointResponse) String() string {
5217 if this == nil {
5218 return "nil"
5219 }
5220 s := strings.Join([]string{`&DeleteEndpointResponse{`,
5221 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5222 `}`,
5223 }, "")
5224 return s
5225 }
5226 func (this *DeleteNetworkRequest) String() string {
5227 if this == nil {
5228 return "nil"
5229 }
5230 s := strings.Join([]string{`&DeleteNetworkRequest{`,
5231 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5232 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5233 `}`,
5234 }, "")
5235 return s
5236 }
5237 func (this *DeleteNetworkResponse) String() string {
5238 if this == nil {
5239 return "nil"
5240 }
5241 s := strings.Join([]string{`&DeleteNetworkResponse{`,
5242 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5243 `}`,
5244 }, "")
5245 return s
5246 }
5247 func (this *GetEndpointRequest) String() string {
5248 if this == nil {
5249 return "nil"
5250 }
5251 s := strings.Join([]string{`&GetEndpointRequest{`,
5252 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5253 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5254 `}`,
5255 }, "")
5256 return s
5257 }
5258 func (this *GetEndpointResponse) String() string {
5259 if this == nil {
5260 return "nil"
5261 }
5262 s := strings.Join([]string{`&GetEndpointResponse{`,
5263 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
5264 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
5265 `Endpoint:` + strings.Replace(this.Endpoint.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
5266 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5267 `}`,
5268 }, "")
5269 return s
5270 }
5271 func (this *GetNetworkRequest) String() string {
5272 if this == nil {
5273 return "nil"
5274 }
5275 s := strings.Join([]string{`&GetNetworkRequest{`,
5276 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
5277 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5278 `}`,
5279 }, "")
5280 return s
5281 }
5282 func (this *GetNetworkResponse) String() string {
5283 if this == nil {
5284 return "nil"
5285 }
5286 s := strings.Join([]string{`&GetNetworkResponse{`,
5287 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
5288 `Network:` + strings.Replace(this.Network.String(), "Network", "Network", 1) + `,`,
5289 `MacRange:` + strings.Replace(this.MacRange.String(), "MacRange", "MacRange", 1) + `,`,
5290 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5291 `}`,
5292 }, "")
5293 return s
5294 }
5295 func (this *MacRange) String() string {
5296 if this == nil {
5297 return "nil"
5298 }
5299 s := strings.Join([]string{`&MacRange{`,
5300 `StartMacAddress:` + fmt.Sprintf("%v", this.StartMacAddress) + `,`,
5301 `EndMacAddress:` + fmt.Sprintf("%v", this.EndMacAddress) + `,`,
5302 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5303 `}`,
5304 }, "")
5305 return s
5306 }
5307 func (this *GetEndpointsRequest) String() string {
5308 if this == nil {
5309 return "nil"
5310 }
5311 s := strings.Join([]string{`&GetEndpointsRequest{`,
5312 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5313 `}`,
5314 }, "")
5315 return s
5316 }
5317 func (this *GetEndpointsResponse) String() string {
5318 if this == nil {
5319 return "nil"
5320 }
5321 repeatedStringForEndpoints := "[]*GetEndpointResponse{"
5322 for _, f := range this.Endpoints {
5323 repeatedStringForEndpoints += strings.Replace(f.String(), "GetEndpointResponse", "GetEndpointResponse", 1) + ","
5324 }
5325 repeatedStringForEndpoints += "}"
5326 s := strings.Join([]string{`&GetEndpointsResponse{`,
5327 `Endpoints:` + repeatedStringForEndpoints + `,`,
5328 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5329 `}`,
5330 }, "")
5331 return s
5332 }
5333 func (this *GetNetworksRequest) String() string {
5334 if this == nil {
5335 return "nil"
5336 }
5337 s := strings.Join([]string{`&GetNetworksRequest{`,
5338 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5339 `}`,
5340 }, "")
5341 return s
5342 }
5343 func (this *GetNetworksResponse) String() string {
5344 if this == nil {
5345 return "nil"
5346 }
5347 repeatedStringForNetworks := "[]*GetNetworkResponse{"
5348 for _, f := range this.Networks {
5349 repeatedStringForNetworks += strings.Replace(f.String(), "GetNetworkResponse", "GetNetworkResponse", 1) + ","
5350 }
5351 repeatedStringForNetworks += "}"
5352 s := strings.Join([]string{`&GetNetworksResponse{`,
5353 `Networks:` + repeatedStringForNetworks + `,`,
5354 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5355 `}`,
5356 }, "")
5357 return s
5358 }
5359 func valueToStringNetworkconfigproxy(v interface{}) string {
5360 rv := reflect.ValueOf(v)
5361 if rv.IsNil() {
5362 return "nil"
5363 }
5364 pv := reflect.Indirect(rv).Interface()
5365 return fmt.Sprintf("*%v", pv)
5366 }
5367 func (m *AddNICRequest) Unmarshal(dAtA []byte) error {
5368 l := len(dAtA)
5369 iNdEx := 0
5370 for iNdEx < l {
5371 preIndex := iNdEx
5372 var wire uint64
5373 for shift := uint(0); ; shift += 7 {
5374 if shift >= 64 {
5375 return ErrIntOverflowNetworkconfigproxy
5376 }
5377 if iNdEx >= l {
5378 return io.ErrUnexpectedEOF
5379 }
5380 b := dAtA[iNdEx]
5381 iNdEx++
5382 wire |= uint64(b&0x7F) << shift
5383 if b < 0x80 {
5384 break
5385 }
5386 }
5387 fieldNum := int32(wire >> 3)
5388 wireType := int(wire & 0x7)
5389 if wireType == 4 {
5390 return fmt.Errorf("proto: AddNICRequest: wiretype end group for non-group")
5391 }
5392 if fieldNum <= 0 {
5393 return fmt.Errorf("proto: AddNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5394 }
5395 switch fieldNum {
5396 case 1:
5397 if wireType != 2 {
5398 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
5399 }
5400 var stringLen uint64
5401 for shift := uint(0); ; shift += 7 {
5402 if shift >= 64 {
5403 return ErrIntOverflowNetworkconfigproxy
5404 }
5405 if iNdEx >= l {
5406 return io.ErrUnexpectedEOF
5407 }
5408 b := dAtA[iNdEx]
5409 iNdEx++
5410 stringLen |= uint64(b&0x7F) << shift
5411 if b < 0x80 {
5412 break
5413 }
5414 }
5415 intStringLen := int(stringLen)
5416 if intStringLen < 0 {
5417 return ErrInvalidLengthNetworkconfigproxy
5418 }
5419 postIndex := iNdEx + intStringLen
5420 if postIndex < 0 {
5421 return ErrInvalidLengthNetworkconfigproxy
5422 }
5423 if postIndex > l {
5424 return io.ErrUnexpectedEOF
5425 }
5426 m.ContainerID = string(dAtA[iNdEx:postIndex])
5427 iNdEx = postIndex
5428 case 2:
5429 if wireType != 2 {
5430 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
5431 }
5432 var stringLen uint64
5433 for shift := uint(0); ; shift += 7 {
5434 if shift >= 64 {
5435 return ErrIntOverflowNetworkconfigproxy
5436 }
5437 if iNdEx >= l {
5438 return io.ErrUnexpectedEOF
5439 }
5440 b := dAtA[iNdEx]
5441 iNdEx++
5442 stringLen |= uint64(b&0x7F) << shift
5443 if b < 0x80 {
5444 break
5445 }
5446 }
5447 intStringLen := int(stringLen)
5448 if intStringLen < 0 {
5449 return ErrInvalidLengthNetworkconfigproxy
5450 }
5451 postIndex := iNdEx + intStringLen
5452 if postIndex < 0 {
5453 return ErrInvalidLengthNetworkconfigproxy
5454 }
5455 if postIndex > l {
5456 return io.ErrUnexpectedEOF
5457 }
5458 m.NicID = string(dAtA[iNdEx:postIndex])
5459 iNdEx = postIndex
5460 case 3:
5461 if wireType != 2 {
5462 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
5463 }
5464 var stringLen uint64
5465 for shift := uint(0); ; shift += 7 {
5466 if shift >= 64 {
5467 return ErrIntOverflowNetworkconfigproxy
5468 }
5469 if iNdEx >= l {
5470 return io.ErrUnexpectedEOF
5471 }
5472 b := dAtA[iNdEx]
5473 iNdEx++
5474 stringLen |= uint64(b&0x7F) << shift
5475 if b < 0x80 {
5476 break
5477 }
5478 }
5479 intStringLen := int(stringLen)
5480 if intStringLen < 0 {
5481 return ErrInvalidLengthNetworkconfigproxy
5482 }
5483 postIndex := iNdEx + intStringLen
5484 if postIndex < 0 {
5485 return ErrInvalidLengthNetworkconfigproxy
5486 }
5487 if postIndex > l {
5488 return io.ErrUnexpectedEOF
5489 }
5490 m.EndpointName = string(dAtA[iNdEx:postIndex])
5491 iNdEx = postIndex
5492 case 4:
5493 if wireType != 2 {
5494 return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
5495 }
5496 var msglen int
5497 for shift := uint(0); ; shift += 7 {
5498 if shift >= 64 {
5499 return ErrIntOverflowNetworkconfigproxy
5500 }
5501 if iNdEx >= l {
5502 return io.ErrUnexpectedEOF
5503 }
5504 b := dAtA[iNdEx]
5505 iNdEx++
5506 msglen |= int(b&0x7F) << shift
5507 if b < 0x80 {
5508 break
5509 }
5510 }
5511 if msglen < 0 {
5512 return ErrInvalidLengthNetworkconfigproxy
5513 }
5514 postIndex := iNdEx + msglen
5515 if postIndex < 0 {
5516 return ErrInvalidLengthNetworkconfigproxy
5517 }
5518 if postIndex > l {
5519 return io.ErrUnexpectedEOF
5520 }
5521 if m.EndpointSettings == nil {
5522 m.EndpointSettings = &EndpointSettings{}
5523 }
5524 if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5525 return err
5526 }
5527 iNdEx = postIndex
5528 default:
5529 iNdEx = preIndex
5530 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5531 if err != nil {
5532 return err
5533 }
5534 if (skippy < 0) || (iNdEx+skippy) < 0 {
5535 return ErrInvalidLengthNetworkconfigproxy
5536 }
5537 if (iNdEx + skippy) > l {
5538 return io.ErrUnexpectedEOF
5539 }
5540 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5541 iNdEx += skippy
5542 }
5543 }
5544
5545 if iNdEx > l {
5546 return io.ErrUnexpectedEOF
5547 }
5548 return nil
5549 }
5550 func (m *AddNICResponse) Unmarshal(dAtA []byte) error {
5551 l := len(dAtA)
5552 iNdEx := 0
5553 for iNdEx < l {
5554 preIndex := iNdEx
5555 var wire uint64
5556 for shift := uint(0); ; shift += 7 {
5557 if shift >= 64 {
5558 return ErrIntOverflowNetworkconfigproxy
5559 }
5560 if iNdEx >= l {
5561 return io.ErrUnexpectedEOF
5562 }
5563 b := dAtA[iNdEx]
5564 iNdEx++
5565 wire |= uint64(b&0x7F) << shift
5566 if b < 0x80 {
5567 break
5568 }
5569 }
5570 fieldNum := int32(wire >> 3)
5571 wireType := int(wire & 0x7)
5572 if wireType == 4 {
5573 return fmt.Errorf("proto: AddNICResponse: wiretype end group for non-group")
5574 }
5575 if fieldNum <= 0 {
5576 return fmt.Errorf("proto: AddNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5577 }
5578 switch fieldNum {
5579 default:
5580 iNdEx = preIndex
5581 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5582 if err != nil {
5583 return err
5584 }
5585 if (skippy < 0) || (iNdEx+skippy) < 0 {
5586 return ErrInvalidLengthNetworkconfigproxy
5587 }
5588 if (iNdEx + skippy) > l {
5589 return io.ErrUnexpectedEOF
5590 }
5591 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5592 iNdEx += skippy
5593 }
5594 }
5595
5596 if iNdEx > l {
5597 return io.ErrUnexpectedEOF
5598 }
5599 return nil
5600 }
5601 func (m *ModifyNICRequest) Unmarshal(dAtA []byte) error {
5602 l := len(dAtA)
5603 iNdEx := 0
5604 for iNdEx < l {
5605 preIndex := iNdEx
5606 var wire uint64
5607 for shift := uint(0); ; shift += 7 {
5608 if shift >= 64 {
5609 return ErrIntOverflowNetworkconfigproxy
5610 }
5611 if iNdEx >= l {
5612 return io.ErrUnexpectedEOF
5613 }
5614 b := dAtA[iNdEx]
5615 iNdEx++
5616 wire |= uint64(b&0x7F) << shift
5617 if b < 0x80 {
5618 break
5619 }
5620 }
5621 fieldNum := int32(wire >> 3)
5622 wireType := int(wire & 0x7)
5623 if wireType == 4 {
5624 return fmt.Errorf("proto: ModifyNICRequest: wiretype end group for non-group")
5625 }
5626 if fieldNum <= 0 {
5627 return fmt.Errorf("proto: ModifyNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5628 }
5629 switch fieldNum {
5630 case 1:
5631 if wireType != 2 {
5632 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
5633 }
5634 var stringLen uint64
5635 for shift := uint(0); ; shift += 7 {
5636 if shift >= 64 {
5637 return ErrIntOverflowNetworkconfigproxy
5638 }
5639 if iNdEx >= l {
5640 return io.ErrUnexpectedEOF
5641 }
5642 b := dAtA[iNdEx]
5643 iNdEx++
5644 stringLen |= uint64(b&0x7F) << shift
5645 if b < 0x80 {
5646 break
5647 }
5648 }
5649 intStringLen := int(stringLen)
5650 if intStringLen < 0 {
5651 return ErrInvalidLengthNetworkconfigproxy
5652 }
5653 postIndex := iNdEx + intStringLen
5654 if postIndex < 0 {
5655 return ErrInvalidLengthNetworkconfigproxy
5656 }
5657 if postIndex > l {
5658 return io.ErrUnexpectedEOF
5659 }
5660 m.ContainerID = string(dAtA[iNdEx:postIndex])
5661 iNdEx = postIndex
5662 case 2:
5663 if wireType != 2 {
5664 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
5665 }
5666 var stringLen uint64
5667 for shift := uint(0); ; shift += 7 {
5668 if shift >= 64 {
5669 return ErrIntOverflowNetworkconfigproxy
5670 }
5671 if iNdEx >= l {
5672 return io.ErrUnexpectedEOF
5673 }
5674 b := dAtA[iNdEx]
5675 iNdEx++
5676 stringLen |= uint64(b&0x7F) << shift
5677 if b < 0x80 {
5678 break
5679 }
5680 }
5681 intStringLen := int(stringLen)
5682 if intStringLen < 0 {
5683 return ErrInvalidLengthNetworkconfigproxy
5684 }
5685 postIndex := iNdEx + intStringLen
5686 if postIndex < 0 {
5687 return ErrInvalidLengthNetworkconfigproxy
5688 }
5689 if postIndex > l {
5690 return io.ErrUnexpectedEOF
5691 }
5692 m.NicID = string(dAtA[iNdEx:postIndex])
5693 iNdEx = postIndex
5694 case 3:
5695 if wireType != 2 {
5696 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
5697 }
5698 var stringLen uint64
5699 for shift := uint(0); ; shift += 7 {
5700 if shift >= 64 {
5701 return ErrIntOverflowNetworkconfigproxy
5702 }
5703 if iNdEx >= l {
5704 return io.ErrUnexpectedEOF
5705 }
5706 b := dAtA[iNdEx]
5707 iNdEx++
5708 stringLen |= uint64(b&0x7F) << shift
5709 if b < 0x80 {
5710 break
5711 }
5712 }
5713 intStringLen := int(stringLen)
5714 if intStringLen < 0 {
5715 return ErrInvalidLengthNetworkconfigproxy
5716 }
5717 postIndex := iNdEx + intStringLen
5718 if postIndex < 0 {
5719 return ErrInvalidLengthNetworkconfigproxy
5720 }
5721 if postIndex > l {
5722 return io.ErrUnexpectedEOF
5723 }
5724 m.EndpointName = string(dAtA[iNdEx:postIndex])
5725 iNdEx = postIndex
5726 case 4:
5727 if wireType != 2 {
5728 return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
5729 }
5730 var msglen int
5731 for shift := uint(0); ; shift += 7 {
5732 if shift >= 64 {
5733 return ErrIntOverflowNetworkconfigproxy
5734 }
5735 if iNdEx >= l {
5736 return io.ErrUnexpectedEOF
5737 }
5738 b := dAtA[iNdEx]
5739 iNdEx++
5740 msglen |= int(b&0x7F) << shift
5741 if b < 0x80 {
5742 break
5743 }
5744 }
5745 if msglen < 0 {
5746 return ErrInvalidLengthNetworkconfigproxy
5747 }
5748 postIndex := iNdEx + msglen
5749 if postIndex < 0 {
5750 return ErrInvalidLengthNetworkconfigproxy
5751 }
5752 if postIndex > l {
5753 return io.ErrUnexpectedEOF
5754 }
5755 if m.EndpointSettings == nil {
5756 m.EndpointSettings = &EndpointSettings{}
5757 }
5758 if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5759 return err
5760 }
5761 iNdEx = postIndex
5762 default:
5763 iNdEx = preIndex
5764 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5765 if err != nil {
5766 return err
5767 }
5768 if (skippy < 0) || (iNdEx+skippy) < 0 {
5769 return ErrInvalidLengthNetworkconfigproxy
5770 }
5771 if (iNdEx + skippy) > l {
5772 return io.ErrUnexpectedEOF
5773 }
5774 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5775 iNdEx += skippy
5776 }
5777 }
5778
5779 if iNdEx > l {
5780 return io.ErrUnexpectedEOF
5781 }
5782 return nil
5783 }
5784 func (m *ModifyNICResponse) Unmarshal(dAtA []byte) error {
5785 l := len(dAtA)
5786 iNdEx := 0
5787 for iNdEx < l {
5788 preIndex := iNdEx
5789 var wire uint64
5790 for shift := uint(0); ; shift += 7 {
5791 if shift >= 64 {
5792 return ErrIntOverflowNetworkconfigproxy
5793 }
5794 if iNdEx >= l {
5795 return io.ErrUnexpectedEOF
5796 }
5797 b := dAtA[iNdEx]
5798 iNdEx++
5799 wire |= uint64(b&0x7F) << shift
5800 if b < 0x80 {
5801 break
5802 }
5803 }
5804 fieldNum := int32(wire >> 3)
5805 wireType := int(wire & 0x7)
5806 if wireType == 4 {
5807 return fmt.Errorf("proto: ModifyNICResponse: wiretype end group for non-group")
5808 }
5809 if fieldNum <= 0 {
5810 return fmt.Errorf("proto: ModifyNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5811 }
5812 switch fieldNum {
5813 default:
5814 iNdEx = preIndex
5815 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5816 if err != nil {
5817 return err
5818 }
5819 if (skippy < 0) || (iNdEx+skippy) < 0 {
5820 return ErrInvalidLengthNetworkconfigproxy
5821 }
5822 if (iNdEx + skippy) > l {
5823 return io.ErrUnexpectedEOF
5824 }
5825 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5826 iNdEx += skippy
5827 }
5828 }
5829
5830 if iNdEx > l {
5831 return io.ErrUnexpectedEOF
5832 }
5833 return nil
5834 }
5835 func (m *DeleteNICRequest) Unmarshal(dAtA []byte) error {
5836 l := len(dAtA)
5837 iNdEx := 0
5838 for iNdEx < l {
5839 preIndex := iNdEx
5840 var wire uint64
5841 for shift := uint(0); ; shift += 7 {
5842 if shift >= 64 {
5843 return ErrIntOverflowNetworkconfigproxy
5844 }
5845 if iNdEx >= l {
5846 return io.ErrUnexpectedEOF
5847 }
5848 b := dAtA[iNdEx]
5849 iNdEx++
5850 wire |= uint64(b&0x7F) << shift
5851 if b < 0x80 {
5852 break
5853 }
5854 }
5855 fieldNum := int32(wire >> 3)
5856 wireType := int(wire & 0x7)
5857 if wireType == 4 {
5858 return fmt.Errorf("proto: DeleteNICRequest: wiretype end group for non-group")
5859 }
5860 if fieldNum <= 0 {
5861 return fmt.Errorf("proto: DeleteNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5862 }
5863 switch fieldNum {
5864 case 1:
5865 if wireType != 2 {
5866 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
5867 }
5868 var stringLen uint64
5869 for shift := uint(0); ; shift += 7 {
5870 if shift >= 64 {
5871 return ErrIntOverflowNetworkconfigproxy
5872 }
5873 if iNdEx >= l {
5874 return io.ErrUnexpectedEOF
5875 }
5876 b := dAtA[iNdEx]
5877 iNdEx++
5878 stringLen |= uint64(b&0x7F) << shift
5879 if b < 0x80 {
5880 break
5881 }
5882 }
5883 intStringLen := int(stringLen)
5884 if intStringLen < 0 {
5885 return ErrInvalidLengthNetworkconfigproxy
5886 }
5887 postIndex := iNdEx + intStringLen
5888 if postIndex < 0 {
5889 return ErrInvalidLengthNetworkconfigproxy
5890 }
5891 if postIndex > l {
5892 return io.ErrUnexpectedEOF
5893 }
5894 m.ContainerID = string(dAtA[iNdEx:postIndex])
5895 iNdEx = postIndex
5896 case 2:
5897 if wireType != 2 {
5898 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
5899 }
5900 var stringLen uint64
5901 for shift := uint(0); ; shift += 7 {
5902 if shift >= 64 {
5903 return ErrIntOverflowNetworkconfigproxy
5904 }
5905 if iNdEx >= l {
5906 return io.ErrUnexpectedEOF
5907 }
5908 b := dAtA[iNdEx]
5909 iNdEx++
5910 stringLen |= uint64(b&0x7F) << shift
5911 if b < 0x80 {
5912 break
5913 }
5914 }
5915 intStringLen := int(stringLen)
5916 if intStringLen < 0 {
5917 return ErrInvalidLengthNetworkconfigproxy
5918 }
5919 postIndex := iNdEx + intStringLen
5920 if postIndex < 0 {
5921 return ErrInvalidLengthNetworkconfigproxy
5922 }
5923 if postIndex > l {
5924 return io.ErrUnexpectedEOF
5925 }
5926 m.NicID = string(dAtA[iNdEx:postIndex])
5927 iNdEx = postIndex
5928 case 3:
5929 if wireType != 2 {
5930 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
5931 }
5932 var stringLen uint64
5933 for shift := uint(0); ; shift += 7 {
5934 if shift >= 64 {
5935 return ErrIntOverflowNetworkconfigproxy
5936 }
5937 if iNdEx >= l {
5938 return io.ErrUnexpectedEOF
5939 }
5940 b := dAtA[iNdEx]
5941 iNdEx++
5942 stringLen |= uint64(b&0x7F) << shift
5943 if b < 0x80 {
5944 break
5945 }
5946 }
5947 intStringLen := int(stringLen)
5948 if intStringLen < 0 {
5949 return ErrInvalidLengthNetworkconfigproxy
5950 }
5951 postIndex := iNdEx + intStringLen
5952 if postIndex < 0 {
5953 return ErrInvalidLengthNetworkconfigproxy
5954 }
5955 if postIndex > l {
5956 return io.ErrUnexpectedEOF
5957 }
5958 m.EndpointName = string(dAtA[iNdEx:postIndex])
5959 iNdEx = postIndex
5960 default:
5961 iNdEx = preIndex
5962 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5963 if err != nil {
5964 return err
5965 }
5966 if (skippy < 0) || (iNdEx+skippy) < 0 {
5967 return ErrInvalidLengthNetworkconfigproxy
5968 }
5969 if (iNdEx + skippy) > l {
5970 return io.ErrUnexpectedEOF
5971 }
5972 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5973 iNdEx += skippy
5974 }
5975 }
5976
5977 if iNdEx > l {
5978 return io.ErrUnexpectedEOF
5979 }
5980 return nil
5981 }
5982 func (m *DeleteNICResponse) Unmarshal(dAtA []byte) error {
5983 l := len(dAtA)
5984 iNdEx := 0
5985 for iNdEx < l {
5986 preIndex := iNdEx
5987 var wire uint64
5988 for shift := uint(0); ; shift += 7 {
5989 if shift >= 64 {
5990 return ErrIntOverflowNetworkconfigproxy
5991 }
5992 if iNdEx >= l {
5993 return io.ErrUnexpectedEOF
5994 }
5995 b := dAtA[iNdEx]
5996 iNdEx++
5997 wire |= uint64(b&0x7F) << shift
5998 if b < 0x80 {
5999 break
6000 }
6001 }
6002 fieldNum := int32(wire >> 3)
6003 wireType := int(wire & 0x7)
6004 if wireType == 4 {
6005 return fmt.Errorf("proto: DeleteNICResponse: wiretype end group for non-group")
6006 }
6007 if fieldNum <= 0 {
6008 return fmt.Errorf("proto: DeleteNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6009 }
6010 switch fieldNum {
6011 default:
6012 iNdEx = preIndex
6013 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6014 if err != nil {
6015 return err
6016 }
6017 if (skippy < 0) || (iNdEx+skippy) < 0 {
6018 return ErrInvalidLengthNetworkconfigproxy
6019 }
6020 if (iNdEx + skippy) > l {
6021 return io.ErrUnexpectedEOF
6022 }
6023 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6024 iNdEx += skippy
6025 }
6026 }
6027
6028 if iNdEx > l {
6029 return io.ErrUnexpectedEOF
6030 }
6031 return nil
6032 }
6033 func (m *CreateNetworkRequest) Unmarshal(dAtA []byte) error {
6034 l := len(dAtA)
6035 iNdEx := 0
6036 for iNdEx < l {
6037 preIndex := iNdEx
6038 var wire uint64
6039 for shift := uint(0); ; shift += 7 {
6040 if shift >= 64 {
6041 return ErrIntOverflowNetworkconfigproxy
6042 }
6043 if iNdEx >= l {
6044 return io.ErrUnexpectedEOF
6045 }
6046 b := dAtA[iNdEx]
6047 iNdEx++
6048 wire |= uint64(b&0x7F) << shift
6049 if b < 0x80 {
6050 break
6051 }
6052 }
6053 fieldNum := int32(wire >> 3)
6054 wireType := int(wire & 0x7)
6055 if wireType == 4 {
6056 return fmt.Errorf("proto: CreateNetworkRequest: wiretype end group for non-group")
6057 }
6058 if fieldNum <= 0 {
6059 return fmt.Errorf("proto: CreateNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6060 }
6061 switch fieldNum {
6062 case 1:
6063 if wireType != 2 {
6064 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
6065 }
6066 var msglen int
6067 for shift := uint(0); ; shift += 7 {
6068 if shift >= 64 {
6069 return ErrIntOverflowNetworkconfigproxy
6070 }
6071 if iNdEx >= l {
6072 return io.ErrUnexpectedEOF
6073 }
6074 b := dAtA[iNdEx]
6075 iNdEx++
6076 msglen |= int(b&0x7F) << shift
6077 if b < 0x80 {
6078 break
6079 }
6080 }
6081 if msglen < 0 {
6082 return ErrInvalidLengthNetworkconfigproxy
6083 }
6084 postIndex := iNdEx + msglen
6085 if postIndex < 0 {
6086 return ErrInvalidLengthNetworkconfigproxy
6087 }
6088 if postIndex > l {
6089 return io.ErrUnexpectedEOF
6090 }
6091 if m.Network == nil {
6092 m.Network = &Network{}
6093 }
6094 if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6095 return err
6096 }
6097 iNdEx = postIndex
6098 default:
6099 iNdEx = preIndex
6100 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6101 if err != nil {
6102 return err
6103 }
6104 if (skippy < 0) || (iNdEx+skippy) < 0 {
6105 return ErrInvalidLengthNetworkconfigproxy
6106 }
6107 if (iNdEx + skippy) > l {
6108 return io.ErrUnexpectedEOF
6109 }
6110 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6111 iNdEx += skippy
6112 }
6113 }
6114
6115 if iNdEx > l {
6116 return io.ErrUnexpectedEOF
6117 }
6118 return nil
6119 }
6120 func (m *Network) Unmarshal(dAtA []byte) error {
6121 l := len(dAtA)
6122 iNdEx := 0
6123 for iNdEx < l {
6124 preIndex := iNdEx
6125 var wire uint64
6126 for shift := uint(0); ; shift += 7 {
6127 if shift >= 64 {
6128 return ErrIntOverflowNetworkconfigproxy
6129 }
6130 if iNdEx >= l {
6131 return io.ErrUnexpectedEOF
6132 }
6133 b := dAtA[iNdEx]
6134 iNdEx++
6135 wire |= uint64(b&0x7F) << shift
6136 if b < 0x80 {
6137 break
6138 }
6139 }
6140 fieldNum := int32(wire >> 3)
6141 wireType := int(wire & 0x7)
6142 if wireType == 4 {
6143 return fmt.Errorf("proto: Network: wiretype end group for non-group")
6144 }
6145 if fieldNum <= 0 {
6146 return fmt.Errorf("proto: Network: illegal tag %d (wire type %d)", fieldNum, wire)
6147 }
6148 switch fieldNum {
6149 case 1:
6150 if wireType != 2 {
6151 return fmt.Errorf("proto: wrong wireType = %d for field HcnNetwork", wireType)
6152 }
6153 var msglen int
6154 for shift := uint(0); ; shift += 7 {
6155 if shift >= 64 {
6156 return ErrIntOverflowNetworkconfigproxy
6157 }
6158 if iNdEx >= l {
6159 return io.ErrUnexpectedEOF
6160 }
6161 b := dAtA[iNdEx]
6162 iNdEx++
6163 msglen |= int(b&0x7F) << shift
6164 if b < 0x80 {
6165 break
6166 }
6167 }
6168 if msglen < 0 {
6169 return ErrInvalidLengthNetworkconfigproxy
6170 }
6171 postIndex := iNdEx + msglen
6172 if postIndex < 0 {
6173 return ErrInvalidLengthNetworkconfigproxy
6174 }
6175 if postIndex > l {
6176 return io.ErrUnexpectedEOF
6177 }
6178 v := &HostComputeNetworkSettings{}
6179 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6180 return err
6181 }
6182 m.Settings = &Network_HcnNetwork{v}
6183 iNdEx = postIndex
6184 case 2:
6185 if wireType != 2 {
6186 return fmt.Errorf("proto: wrong wireType = %d for field NcproxyNetwork", wireType)
6187 }
6188 var msglen int
6189 for shift := uint(0); ; shift += 7 {
6190 if shift >= 64 {
6191 return ErrIntOverflowNetworkconfigproxy
6192 }
6193 if iNdEx >= l {
6194 return io.ErrUnexpectedEOF
6195 }
6196 b := dAtA[iNdEx]
6197 iNdEx++
6198 msglen |= int(b&0x7F) << shift
6199 if b < 0x80 {
6200 break
6201 }
6202 }
6203 if msglen < 0 {
6204 return ErrInvalidLengthNetworkconfigproxy
6205 }
6206 postIndex := iNdEx + msglen
6207 if postIndex < 0 {
6208 return ErrInvalidLengthNetworkconfigproxy
6209 }
6210 if postIndex > l {
6211 return io.ErrUnexpectedEOF
6212 }
6213 v := &NCProxyNetworkSettings{}
6214 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6215 return err
6216 }
6217 m.Settings = &Network_NcproxyNetwork{v}
6218 iNdEx = postIndex
6219 default:
6220 iNdEx = preIndex
6221 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6222 if err != nil {
6223 return err
6224 }
6225 if (skippy < 0) || (iNdEx+skippy) < 0 {
6226 return ErrInvalidLengthNetworkconfigproxy
6227 }
6228 if (iNdEx + skippy) > l {
6229 return io.ErrUnexpectedEOF
6230 }
6231 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6232 iNdEx += skippy
6233 }
6234 }
6235
6236 if iNdEx > l {
6237 return io.ErrUnexpectedEOF
6238 }
6239 return nil
6240 }
6241 func (m *NCProxyNetworkSettings) Unmarshal(dAtA []byte) error {
6242 l := len(dAtA)
6243 iNdEx := 0
6244 for iNdEx < l {
6245 preIndex := iNdEx
6246 var wire uint64
6247 for shift := uint(0); ; shift += 7 {
6248 if shift >= 64 {
6249 return ErrIntOverflowNetworkconfigproxy
6250 }
6251 if iNdEx >= l {
6252 return io.ErrUnexpectedEOF
6253 }
6254 b := dAtA[iNdEx]
6255 iNdEx++
6256 wire |= uint64(b&0x7F) << shift
6257 if b < 0x80 {
6258 break
6259 }
6260 }
6261 fieldNum := int32(wire >> 3)
6262 wireType := int(wire & 0x7)
6263 if wireType == 4 {
6264 return fmt.Errorf("proto: NCProxyNetworkSettings: wiretype end group for non-group")
6265 }
6266 if fieldNum <= 0 {
6267 return fmt.Errorf("proto: NCProxyNetworkSettings: illegal tag %d (wire type %d)", fieldNum, wire)
6268 }
6269 switch fieldNum {
6270 case 1:
6271 if wireType != 2 {
6272 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6273 }
6274 var stringLen uint64
6275 for shift := uint(0); ; shift += 7 {
6276 if shift >= 64 {
6277 return ErrIntOverflowNetworkconfigproxy
6278 }
6279 if iNdEx >= l {
6280 return io.ErrUnexpectedEOF
6281 }
6282 b := dAtA[iNdEx]
6283 iNdEx++
6284 stringLen |= uint64(b&0x7F) << shift
6285 if b < 0x80 {
6286 break
6287 }
6288 }
6289 intStringLen := int(stringLen)
6290 if intStringLen < 0 {
6291 return ErrInvalidLengthNetworkconfigproxy
6292 }
6293 postIndex := iNdEx + intStringLen
6294 if postIndex < 0 {
6295 return ErrInvalidLengthNetworkconfigproxy
6296 }
6297 if postIndex > l {
6298 return io.ErrUnexpectedEOF
6299 }
6300 m.Name = string(dAtA[iNdEx:postIndex])
6301 iNdEx = postIndex
6302 default:
6303 iNdEx = preIndex
6304 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6305 if err != nil {
6306 return err
6307 }
6308 if (skippy < 0) || (iNdEx+skippy) < 0 {
6309 return ErrInvalidLengthNetworkconfigproxy
6310 }
6311 if (iNdEx + skippy) > l {
6312 return io.ErrUnexpectedEOF
6313 }
6314 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6315 iNdEx += skippy
6316 }
6317 }
6318
6319 if iNdEx > l {
6320 return io.ErrUnexpectedEOF
6321 }
6322 return nil
6323 }
6324 func (m *HostComputeNetworkSettings) Unmarshal(dAtA []byte) error {
6325 l := len(dAtA)
6326 iNdEx := 0
6327 for iNdEx < l {
6328 preIndex := iNdEx
6329 var wire uint64
6330 for shift := uint(0); ; shift += 7 {
6331 if shift >= 64 {
6332 return ErrIntOverflowNetworkconfigproxy
6333 }
6334 if iNdEx >= l {
6335 return io.ErrUnexpectedEOF
6336 }
6337 b := dAtA[iNdEx]
6338 iNdEx++
6339 wire |= uint64(b&0x7F) << shift
6340 if b < 0x80 {
6341 break
6342 }
6343 }
6344 fieldNum := int32(wire >> 3)
6345 wireType := int(wire & 0x7)
6346 if wireType == 4 {
6347 return fmt.Errorf("proto: HostComputeNetworkSettings: wiretype end group for non-group")
6348 }
6349 if fieldNum <= 0 {
6350 return fmt.Errorf("proto: HostComputeNetworkSettings: illegal tag %d (wire type %d)", fieldNum, wire)
6351 }
6352 switch fieldNum {
6353 case 1:
6354 if wireType != 2 {
6355 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6356 }
6357 var stringLen uint64
6358 for shift := uint(0); ; shift += 7 {
6359 if shift >= 64 {
6360 return ErrIntOverflowNetworkconfigproxy
6361 }
6362 if iNdEx >= l {
6363 return io.ErrUnexpectedEOF
6364 }
6365 b := dAtA[iNdEx]
6366 iNdEx++
6367 stringLen |= uint64(b&0x7F) << shift
6368 if b < 0x80 {
6369 break
6370 }
6371 }
6372 intStringLen := int(stringLen)
6373 if intStringLen < 0 {
6374 return ErrInvalidLengthNetworkconfigproxy
6375 }
6376 postIndex := iNdEx + intStringLen
6377 if postIndex < 0 {
6378 return ErrInvalidLengthNetworkconfigproxy
6379 }
6380 if postIndex > l {
6381 return io.ErrUnexpectedEOF
6382 }
6383 m.Name = string(dAtA[iNdEx:postIndex])
6384 iNdEx = postIndex
6385 case 2:
6386 if wireType != 0 {
6387 return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
6388 }
6389 m.Mode = 0
6390 for shift := uint(0); ; shift += 7 {
6391 if shift >= 64 {
6392 return ErrIntOverflowNetworkconfigproxy
6393 }
6394 if iNdEx >= l {
6395 return io.ErrUnexpectedEOF
6396 }
6397 b := dAtA[iNdEx]
6398 iNdEx++
6399 m.Mode |= HostComputeNetworkSettings_NetworkMode(b&0x7F) << shift
6400 if b < 0x80 {
6401 break
6402 }
6403 }
6404 case 3:
6405 if wireType != 2 {
6406 return fmt.Errorf("proto: wrong wireType = %d for field SwitchName", wireType)
6407 }
6408 var stringLen uint64
6409 for shift := uint(0); ; shift += 7 {
6410 if shift >= 64 {
6411 return ErrIntOverflowNetworkconfigproxy
6412 }
6413 if iNdEx >= l {
6414 return io.ErrUnexpectedEOF
6415 }
6416 b := dAtA[iNdEx]
6417 iNdEx++
6418 stringLen |= uint64(b&0x7F) << shift
6419 if b < 0x80 {
6420 break
6421 }
6422 }
6423 intStringLen := int(stringLen)
6424 if intStringLen < 0 {
6425 return ErrInvalidLengthNetworkconfigproxy
6426 }
6427 postIndex := iNdEx + intStringLen
6428 if postIndex < 0 {
6429 return ErrInvalidLengthNetworkconfigproxy
6430 }
6431 if postIndex > l {
6432 return io.ErrUnexpectedEOF
6433 }
6434 m.SwitchName = string(dAtA[iNdEx:postIndex])
6435 iNdEx = postIndex
6436 case 4:
6437 if wireType != 0 {
6438 return fmt.Errorf("proto: wrong wireType = %d for field IpamType", wireType)
6439 }
6440 m.IpamType = 0
6441 for shift := uint(0); ; shift += 7 {
6442 if shift >= 64 {
6443 return ErrIntOverflowNetworkconfigproxy
6444 }
6445 if iNdEx >= l {
6446 return io.ErrUnexpectedEOF
6447 }
6448 b := dAtA[iNdEx]
6449 iNdEx++
6450 m.IpamType |= HostComputeNetworkSettings_IpamType(b&0x7F) << shift
6451 if b < 0x80 {
6452 break
6453 }
6454 }
6455 case 5:
6456 if wireType != 2 {
6457 return fmt.Errorf("proto: wrong wireType = %d for field SubnetIpaddressPrefix", wireType)
6458 }
6459 var stringLen uint64
6460 for shift := uint(0); ; shift += 7 {
6461 if shift >= 64 {
6462 return ErrIntOverflowNetworkconfigproxy
6463 }
6464 if iNdEx >= l {
6465 return io.ErrUnexpectedEOF
6466 }
6467 b := dAtA[iNdEx]
6468 iNdEx++
6469 stringLen |= uint64(b&0x7F) << shift
6470 if b < 0x80 {
6471 break
6472 }
6473 }
6474 intStringLen := int(stringLen)
6475 if intStringLen < 0 {
6476 return ErrInvalidLengthNetworkconfigproxy
6477 }
6478 postIndex := iNdEx + intStringLen
6479 if postIndex < 0 {
6480 return ErrInvalidLengthNetworkconfigproxy
6481 }
6482 if postIndex > l {
6483 return io.ErrUnexpectedEOF
6484 }
6485 m.SubnetIpaddressPrefix = append(m.SubnetIpaddressPrefix, string(dAtA[iNdEx:postIndex]))
6486 iNdEx = postIndex
6487 case 6:
6488 if wireType != 2 {
6489 return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
6490 }
6491 var stringLen uint64
6492 for shift := uint(0); ; shift += 7 {
6493 if shift >= 64 {
6494 return ErrIntOverflowNetworkconfigproxy
6495 }
6496 if iNdEx >= l {
6497 return io.ErrUnexpectedEOF
6498 }
6499 b := dAtA[iNdEx]
6500 iNdEx++
6501 stringLen |= uint64(b&0x7F) << shift
6502 if b < 0x80 {
6503 break
6504 }
6505 }
6506 intStringLen := int(stringLen)
6507 if intStringLen < 0 {
6508 return ErrInvalidLengthNetworkconfigproxy
6509 }
6510 postIndex := iNdEx + intStringLen
6511 if postIndex < 0 {
6512 return ErrInvalidLengthNetworkconfigproxy
6513 }
6514 if postIndex > l {
6515 return io.ErrUnexpectedEOF
6516 }
6517 m.DefaultGateway = string(dAtA[iNdEx:postIndex])
6518 iNdEx = postIndex
6519 case 7:
6520 if wireType != 2 {
6521 return fmt.Errorf("proto: wrong wireType = %d for field SubnetIpaddressPrefixIpv6", wireType)
6522 }
6523 var stringLen uint64
6524 for shift := uint(0); ; shift += 7 {
6525 if shift >= 64 {
6526 return ErrIntOverflowNetworkconfigproxy
6527 }
6528 if iNdEx >= l {
6529 return io.ErrUnexpectedEOF
6530 }
6531 b := dAtA[iNdEx]
6532 iNdEx++
6533 stringLen |= uint64(b&0x7F) << shift
6534 if b < 0x80 {
6535 break
6536 }
6537 }
6538 intStringLen := int(stringLen)
6539 if intStringLen < 0 {
6540 return ErrInvalidLengthNetworkconfigproxy
6541 }
6542 postIndex := iNdEx + intStringLen
6543 if postIndex < 0 {
6544 return ErrInvalidLengthNetworkconfigproxy
6545 }
6546 if postIndex > l {
6547 return io.ErrUnexpectedEOF
6548 }
6549 m.SubnetIpaddressPrefixIpv6 = append(m.SubnetIpaddressPrefixIpv6, string(dAtA[iNdEx:postIndex]))
6550 iNdEx = postIndex
6551 case 8:
6552 if wireType != 2 {
6553 return fmt.Errorf("proto: wrong wireType = %d for field DefaultGatewayIpv6", wireType)
6554 }
6555 var stringLen uint64
6556 for shift := uint(0); ; shift += 7 {
6557 if shift >= 64 {
6558 return ErrIntOverflowNetworkconfigproxy
6559 }
6560 if iNdEx >= l {
6561 return io.ErrUnexpectedEOF
6562 }
6563 b := dAtA[iNdEx]
6564 iNdEx++
6565 stringLen |= uint64(b&0x7F) << shift
6566 if b < 0x80 {
6567 break
6568 }
6569 }
6570 intStringLen := int(stringLen)
6571 if intStringLen < 0 {
6572 return ErrInvalidLengthNetworkconfigproxy
6573 }
6574 postIndex := iNdEx + intStringLen
6575 if postIndex < 0 {
6576 return ErrInvalidLengthNetworkconfigproxy
6577 }
6578 if postIndex > l {
6579 return io.ErrUnexpectedEOF
6580 }
6581 m.DefaultGatewayIpv6 = string(dAtA[iNdEx:postIndex])
6582 iNdEx = postIndex
6583 default:
6584 iNdEx = preIndex
6585 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6586 if err != nil {
6587 return err
6588 }
6589 if (skippy < 0) || (iNdEx+skippy) < 0 {
6590 return ErrInvalidLengthNetworkconfigproxy
6591 }
6592 if (iNdEx + skippy) > l {
6593 return io.ErrUnexpectedEOF
6594 }
6595 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6596 iNdEx += skippy
6597 }
6598 }
6599
6600 if iNdEx > l {
6601 return io.ErrUnexpectedEOF
6602 }
6603 return nil
6604 }
6605 func (m *CreateNetworkResponse) Unmarshal(dAtA []byte) error {
6606 l := len(dAtA)
6607 iNdEx := 0
6608 for iNdEx < l {
6609 preIndex := iNdEx
6610 var wire uint64
6611 for shift := uint(0); ; shift += 7 {
6612 if shift >= 64 {
6613 return ErrIntOverflowNetworkconfigproxy
6614 }
6615 if iNdEx >= l {
6616 return io.ErrUnexpectedEOF
6617 }
6618 b := dAtA[iNdEx]
6619 iNdEx++
6620 wire |= uint64(b&0x7F) << shift
6621 if b < 0x80 {
6622 break
6623 }
6624 }
6625 fieldNum := int32(wire >> 3)
6626 wireType := int(wire & 0x7)
6627 if wireType == 4 {
6628 return fmt.Errorf("proto: CreateNetworkResponse: wiretype end group for non-group")
6629 }
6630 if fieldNum <= 0 {
6631 return fmt.Errorf("proto: CreateNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6632 }
6633 switch fieldNum {
6634 case 1:
6635 if wireType != 2 {
6636 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
6637 }
6638 var stringLen uint64
6639 for shift := uint(0); ; shift += 7 {
6640 if shift >= 64 {
6641 return ErrIntOverflowNetworkconfigproxy
6642 }
6643 if iNdEx >= l {
6644 return io.ErrUnexpectedEOF
6645 }
6646 b := dAtA[iNdEx]
6647 iNdEx++
6648 stringLen |= uint64(b&0x7F) << shift
6649 if b < 0x80 {
6650 break
6651 }
6652 }
6653 intStringLen := int(stringLen)
6654 if intStringLen < 0 {
6655 return ErrInvalidLengthNetworkconfigproxy
6656 }
6657 postIndex := iNdEx + intStringLen
6658 if postIndex < 0 {
6659 return ErrInvalidLengthNetworkconfigproxy
6660 }
6661 if postIndex > l {
6662 return io.ErrUnexpectedEOF
6663 }
6664 m.ID = string(dAtA[iNdEx:postIndex])
6665 iNdEx = postIndex
6666 default:
6667 iNdEx = preIndex
6668 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6669 if err != nil {
6670 return err
6671 }
6672 if (skippy < 0) || (iNdEx+skippy) < 0 {
6673 return ErrInvalidLengthNetworkconfigproxy
6674 }
6675 if (iNdEx + skippy) > l {
6676 return io.ErrUnexpectedEOF
6677 }
6678 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6679 iNdEx += skippy
6680 }
6681 }
6682
6683 if iNdEx > l {
6684 return io.ErrUnexpectedEOF
6685 }
6686 return nil
6687 }
6688 func (m *PortNameEndpointPolicySetting) Unmarshal(dAtA []byte) error {
6689 l := len(dAtA)
6690 iNdEx := 0
6691 for iNdEx < l {
6692 preIndex := iNdEx
6693 var wire uint64
6694 for shift := uint(0); ; shift += 7 {
6695 if shift >= 64 {
6696 return ErrIntOverflowNetworkconfigproxy
6697 }
6698 if iNdEx >= l {
6699 return io.ErrUnexpectedEOF
6700 }
6701 b := dAtA[iNdEx]
6702 iNdEx++
6703 wire |= uint64(b&0x7F) << shift
6704 if b < 0x80 {
6705 break
6706 }
6707 }
6708 fieldNum := int32(wire >> 3)
6709 wireType := int(wire & 0x7)
6710 if wireType == 4 {
6711 return fmt.Errorf("proto: PortNameEndpointPolicySetting: wiretype end group for non-group")
6712 }
6713 if fieldNum <= 0 {
6714 return fmt.Errorf("proto: PortNameEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
6715 }
6716 switch fieldNum {
6717 case 1:
6718 if wireType != 2 {
6719 return fmt.Errorf("proto: wrong wireType = %d for field PortName", wireType)
6720 }
6721 var stringLen uint64
6722 for shift := uint(0); ; shift += 7 {
6723 if shift >= 64 {
6724 return ErrIntOverflowNetworkconfigproxy
6725 }
6726 if iNdEx >= l {
6727 return io.ErrUnexpectedEOF
6728 }
6729 b := dAtA[iNdEx]
6730 iNdEx++
6731 stringLen |= uint64(b&0x7F) << shift
6732 if b < 0x80 {
6733 break
6734 }
6735 }
6736 intStringLen := int(stringLen)
6737 if intStringLen < 0 {
6738 return ErrInvalidLengthNetworkconfigproxy
6739 }
6740 postIndex := iNdEx + intStringLen
6741 if postIndex < 0 {
6742 return ErrInvalidLengthNetworkconfigproxy
6743 }
6744 if postIndex > l {
6745 return io.ErrUnexpectedEOF
6746 }
6747 m.PortName = string(dAtA[iNdEx:postIndex])
6748 iNdEx = postIndex
6749 default:
6750 iNdEx = preIndex
6751 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6752 if err != nil {
6753 return err
6754 }
6755 if (skippy < 0) || (iNdEx+skippy) < 0 {
6756 return ErrInvalidLengthNetworkconfigproxy
6757 }
6758 if (iNdEx + skippy) > l {
6759 return io.ErrUnexpectedEOF
6760 }
6761 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6762 iNdEx += skippy
6763 }
6764 }
6765
6766 if iNdEx > l {
6767 return io.ErrUnexpectedEOF
6768 }
6769 return nil
6770 }
6771 func (m *IovEndpointPolicySetting) Unmarshal(dAtA []byte) error {
6772 l := len(dAtA)
6773 iNdEx := 0
6774 for iNdEx < l {
6775 preIndex := iNdEx
6776 var wire uint64
6777 for shift := uint(0); ; shift += 7 {
6778 if shift >= 64 {
6779 return ErrIntOverflowNetworkconfigproxy
6780 }
6781 if iNdEx >= l {
6782 return io.ErrUnexpectedEOF
6783 }
6784 b := dAtA[iNdEx]
6785 iNdEx++
6786 wire |= uint64(b&0x7F) << shift
6787 if b < 0x80 {
6788 break
6789 }
6790 }
6791 fieldNum := int32(wire >> 3)
6792 wireType := int(wire & 0x7)
6793 if wireType == 4 {
6794 return fmt.Errorf("proto: IovEndpointPolicySetting: wiretype end group for non-group")
6795 }
6796 if fieldNum <= 0 {
6797 return fmt.Errorf("proto: IovEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
6798 }
6799 switch fieldNum {
6800 case 1:
6801 if wireType != 0 {
6802 return fmt.Errorf("proto: wrong wireType = %d for field IovOffloadWeight", wireType)
6803 }
6804 m.IovOffloadWeight = 0
6805 for shift := uint(0); ; shift += 7 {
6806 if shift >= 64 {
6807 return ErrIntOverflowNetworkconfigproxy
6808 }
6809 if iNdEx >= l {
6810 return io.ErrUnexpectedEOF
6811 }
6812 b := dAtA[iNdEx]
6813 iNdEx++
6814 m.IovOffloadWeight |= uint32(b&0x7F) << shift
6815 if b < 0x80 {
6816 break
6817 }
6818 }
6819 case 2:
6820 if wireType != 0 {
6821 return fmt.Errorf("proto: wrong wireType = %d for field QueuePairsRequested", wireType)
6822 }
6823 m.QueuePairsRequested = 0
6824 for shift := uint(0); ; shift += 7 {
6825 if shift >= 64 {
6826 return ErrIntOverflowNetworkconfigproxy
6827 }
6828 if iNdEx >= l {
6829 return io.ErrUnexpectedEOF
6830 }
6831 b := dAtA[iNdEx]
6832 iNdEx++
6833 m.QueuePairsRequested |= uint32(b&0x7F) << shift
6834 if b < 0x80 {
6835 break
6836 }
6837 }
6838 case 3:
6839 if wireType != 0 {
6840 return fmt.Errorf("proto: wrong wireType = %d for field InterruptModeration", wireType)
6841 }
6842 m.InterruptModeration = 0
6843 for shift := uint(0); ; shift += 7 {
6844 if shift >= 64 {
6845 return ErrIntOverflowNetworkconfigproxy
6846 }
6847 if iNdEx >= l {
6848 return io.ErrUnexpectedEOF
6849 }
6850 b := dAtA[iNdEx]
6851 iNdEx++
6852 m.InterruptModeration |= uint32(b&0x7F) << shift
6853 if b < 0x80 {
6854 break
6855 }
6856 }
6857 default:
6858 iNdEx = preIndex
6859 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6860 if err != nil {
6861 return err
6862 }
6863 if (skippy < 0) || (iNdEx+skippy) < 0 {
6864 return ErrInvalidLengthNetworkconfigproxy
6865 }
6866 if (iNdEx + skippy) > l {
6867 return io.ErrUnexpectedEOF
6868 }
6869 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6870 iNdEx += skippy
6871 }
6872 }
6873
6874 if iNdEx > l {
6875 return io.ErrUnexpectedEOF
6876 }
6877 return nil
6878 }
6879 func (m *DnsSetting) Unmarshal(dAtA []byte) error {
6880 l := len(dAtA)
6881 iNdEx := 0
6882 for iNdEx < l {
6883 preIndex := iNdEx
6884 var wire uint64
6885 for shift := uint(0); ; shift += 7 {
6886 if shift >= 64 {
6887 return ErrIntOverflowNetworkconfigproxy
6888 }
6889 if iNdEx >= l {
6890 return io.ErrUnexpectedEOF
6891 }
6892 b := dAtA[iNdEx]
6893 iNdEx++
6894 wire |= uint64(b&0x7F) << shift
6895 if b < 0x80 {
6896 break
6897 }
6898 }
6899 fieldNum := int32(wire >> 3)
6900 wireType := int(wire & 0x7)
6901 if wireType == 4 {
6902 return fmt.Errorf("proto: DnsSetting: wiretype end group for non-group")
6903 }
6904 if fieldNum <= 0 {
6905 return fmt.Errorf("proto: DnsSetting: illegal tag %d (wire type %d)", fieldNum, wire)
6906 }
6907 switch fieldNum {
6908 case 1:
6909 if wireType != 2 {
6910 return fmt.Errorf("proto: wrong wireType = %d for field ServerIpAddrs", wireType)
6911 }
6912 var stringLen uint64
6913 for shift := uint(0); ; shift += 7 {
6914 if shift >= 64 {
6915 return ErrIntOverflowNetworkconfigproxy
6916 }
6917 if iNdEx >= l {
6918 return io.ErrUnexpectedEOF
6919 }
6920 b := dAtA[iNdEx]
6921 iNdEx++
6922 stringLen |= uint64(b&0x7F) << shift
6923 if b < 0x80 {
6924 break
6925 }
6926 }
6927 intStringLen := int(stringLen)
6928 if intStringLen < 0 {
6929 return ErrInvalidLengthNetworkconfigproxy
6930 }
6931 postIndex := iNdEx + intStringLen
6932 if postIndex < 0 {
6933 return ErrInvalidLengthNetworkconfigproxy
6934 }
6935 if postIndex > l {
6936 return io.ErrUnexpectedEOF
6937 }
6938 m.ServerIpAddrs = append(m.ServerIpAddrs, string(dAtA[iNdEx:postIndex]))
6939 iNdEx = postIndex
6940 case 2:
6941 if wireType != 2 {
6942 return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
6943 }
6944 var stringLen uint64
6945 for shift := uint(0); ; shift += 7 {
6946 if shift >= 64 {
6947 return ErrIntOverflowNetworkconfigproxy
6948 }
6949 if iNdEx >= l {
6950 return io.ErrUnexpectedEOF
6951 }
6952 b := dAtA[iNdEx]
6953 iNdEx++
6954 stringLen |= uint64(b&0x7F) << shift
6955 if b < 0x80 {
6956 break
6957 }
6958 }
6959 intStringLen := int(stringLen)
6960 if intStringLen < 0 {
6961 return ErrInvalidLengthNetworkconfigproxy
6962 }
6963 postIndex := iNdEx + intStringLen
6964 if postIndex < 0 {
6965 return ErrInvalidLengthNetworkconfigproxy
6966 }
6967 if postIndex > l {
6968 return io.ErrUnexpectedEOF
6969 }
6970 m.Domain = string(dAtA[iNdEx:postIndex])
6971 iNdEx = postIndex
6972 case 3:
6973 if wireType != 2 {
6974 return fmt.Errorf("proto: wrong wireType = %d for field Search", wireType)
6975 }
6976 var stringLen uint64
6977 for shift := uint(0); ; shift += 7 {
6978 if shift >= 64 {
6979 return ErrIntOverflowNetworkconfigproxy
6980 }
6981 if iNdEx >= l {
6982 return io.ErrUnexpectedEOF
6983 }
6984 b := dAtA[iNdEx]
6985 iNdEx++
6986 stringLen |= uint64(b&0x7F) << shift
6987 if b < 0x80 {
6988 break
6989 }
6990 }
6991 intStringLen := int(stringLen)
6992 if intStringLen < 0 {
6993 return ErrInvalidLengthNetworkconfigproxy
6994 }
6995 postIndex := iNdEx + intStringLen
6996 if postIndex < 0 {
6997 return ErrInvalidLengthNetworkconfigproxy
6998 }
6999 if postIndex > l {
7000 return io.ErrUnexpectedEOF
7001 }
7002 m.Search = append(m.Search, string(dAtA[iNdEx:postIndex]))
7003 iNdEx = postIndex
7004 default:
7005 iNdEx = preIndex
7006 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7007 if err != nil {
7008 return err
7009 }
7010 if (skippy < 0) || (iNdEx+skippy) < 0 {
7011 return ErrInvalidLengthNetworkconfigproxy
7012 }
7013 if (iNdEx + skippy) > l {
7014 return io.ErrUnexpectedEOF
7015 }
7016 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7017 iNdEx += skippy
7018 }
7019 }
7020
7021 if iNdEx > l {
7022 return io.ErrUnexpectedEOF
7023 }
7024 return nil
7025 }
7026 func (m *CreateEndpointRequest) Unmarshal(dAtA []byte) error {
7027 l := len(dAtA)
7028 iNdEx := 0
7029 for iNdEx < l {
7030 preIndex := iNdEx
7031 var wire uint64
7032 for shift := uint(0); ; shift += 7 {
7033 if shift >= 64 {
7034 return ErrIntOverflowNetworkconfigproxy
7035 }
7036 if iNdEx >= l {
7037 return io.ErrUnexpectedEOF
7038 }
7039 b := dAtA[iNdEx]
7040 iNdEx++
7041 wire |= uint64(b&0x7F) << shift
7042 if b < 0x80 {
7043 break
7044 }
7045 }
7046 fieldNum := int32(wire >> 3)
7047 wireType := int(wire & 0x7)
7048 if wireType == 4 {
7049 return fmt.Errorf("proto: CreateEndpointRequest: wiretype end group for non-group")
7050 }
7051 if fieldNum <= 0 {
7052 return fmt.Errorf("proto: CreateEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
7053 }
7054 switch fieldNum {
7055 case 1:
7056 if wireType != 2 {
7057 return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
7058 }
7059 var msglen int
7060 for shift := uint(0); ; shift += 7 {
7061 if shift >= 64 {
7062 return ErrIntOverflowNetworkconfigproxy
7063 }
7064 if iNdEx >= l {
7065 return io.ErrUnexpectedEOF
7066 }
7067 b := dAtA[iNdEx]
7068 iNdEx++
7069 msglen |= int(b&0x7F) << shift
7070 if b < 0x80 {
7071 break
7072 }
7073 }
7074 if msglen < 0 {
7075 return ErrInvalidLengthNetworkconfigproxy
7076 }
7077 postIndex := iNdEx + msglen
7078 if postIndex < 0 {
7079 return ErrInvalidLengthNetworkconfigproxy
7080 }
7081 if postIndex > l {
7082 return io.ErrUnexpectedEOF
7083 }
7084 if m.EndpointSettings == nil {
7085 m.EndpointSettings = &EndpointSettings{}
7086 }
7087 if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7088 return err
7089 }
7090 iNdEx = postIndex
7091 default:
7092 iNdEx = preIndex
7093 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7094 if err != nil {
7095 return err
7096 }
7097 if (skippy < 0) || (iNdEx+skippy) < 0 {
7098 return ErrInvalidLengthNetworkconfigproxy
7099 }
7100 if (iNdEx + skippy) > l {
7101 return io.ErrUnexpectedEOF
7102 }
7103 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7104 iNdEx += skippy
7105 }
7106 }
7107
7108 if iNdEx > l {
7109 return io.ErrUnexpectedEOF
7110 }
7111 return nil
7112 }
7113 func (m *EndpointSettings) Unmarshal(dAtA []byte) error {
7114 l := len(dAtA)
7115 iNdEx := 0
7116 for iNdEx < l {
7117 preIndex := iNdEx
7118 var wire uint64
7119 for shift := uint(0); ; shift += 7 {
7120 if shift >= 64 {
7121 return ErrIntOverflowNetworkconfigproxy
7122 }
7123 if iNdEx >= l {
7124 return io.ErrUnexpectedEOF
7125 }
7126 b := dAtA[iNdEx]
7127 iNdEx++
7128 wire |= uint64(b&0x7F) << shift
7129 if b < 0x80 {
7130 break
7131 }
7132 }
7133 fieldNum := int32(wire >> 3)
7134 wireType := int(wire & 0x7)
7135 if wireType == 4 {
7136 return fmt.Errorf("proto: EndpointSettings: wiretype end group for non-group")
7137 }
7138 if fieldNum <= 0 {
7139 return fmt.Errorf("proto: EndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
7140 }
7141 switch fieldNum {
7142 case 1:
7143 if wireType != 2 {
7144 return fmt.Errorf("proto: wrong wireType = %d for field HcnEndpoint", wireType)
7145 }
7146 var msglen int
7147 for shift := uint(0); ; shift += 7 {
7148 if shift >= 64 {
7149 return ErrIntOverflowNetworkconfigproxy
7150 }
7151 if iNdEx >= l {
7152 return io.ErrUnexpectedEOF
7153 }
7154 b := dAtA[iNdEx]
7155 iNdEx++
7156 msglen |= int(b&0x7F) << shift
7157 if b < 0x80 {
7158 break
7159 }
7160 }
7161 if msglen < 0 {
7162 return ErrInvalidLengthNetworkconfigproxy
7163 }
7164 postIndex := iNdEx + msglen
7165 if postIndex < 0 {
7166 return ErrInvalidLengthNetworkconfigproxy
7167 }
7168 if postIndex > l {
7169 return io.ErrUnexpectedEOF
7170 }
7171 v := &HcnEndpointSettings{}
7172 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7173 return err
7174 }
7175 m.Settings = &EndpointSettings_HcnEndpoint{v}
7176 iNdEx = postIndex
7177 case 2:
7178 if wireType != 2 {
7179 return fmt.Errorf("proto: wrong wireType = %d for field NcproxyEndpoint", wireType)
7180 }
7181 var msglen int
7182 for shift := uint(0); ; shift += 7 {
7183 if shift >= 64 {
7184 return ErrIntOverflowNetworkconfigproxy
7185 }
7186 if iNdEx >= l {
7187 return io.ErrUnexpectedEOF
7188 }
7189 b := dAtA[iNdEx]
7190 iNdEx++
7191 msglen |= int(b&0x7F) << shift
7192 if b < 0x80 {
7193 break
7194 }
7195 }
7196 if msglen < 0 {
7197 return ErrInvalidLengthNetworkconfigproxy
7198 }
7199 postIndex := iNdEx + msglen
7200 if postIndex < 0 {
7201 return ErrInvalidLengthNetworkconfigproxy
7202 }
7203 if postIndex > l {
7204 return io.ErrUnexpectedEOF
7205 }
7206 v := &NCProxyEndpointSettings{}
7207 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7208 return err
7209 }
7210 m.Settings = &EndpointSettings_NcproxyEndpoint{v}
7211 iNdEx = postIndex
7212 default:
7213 iNdEx = preIndex
7214 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7215 if err != nil {
7216 return err
7217 }
7218 if (skippy < 0) || (iNdEx+skippy) < 0 {
7219 return ErrInvalidLengthNetworkconfigproxy
7220 }
7221 if (iNdEx + skippy) > l {
7222 return io.ErrUnexpectedEOF
7223 }
7224 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7225 iNdEx += skippy
7226 }
7227 }
7228
7229 if iNdEx > l {
7230 return io.ErrUnexpectedEOF
7231 }
7232 return nil
7233 }
7234 func (m *HcnEndpointResponse) Unmarshal(dAtA []byte) error {
7235 l := len(dAtA)
7236 iNdEx := 0
7237 for iNdEx < l {
7238 preIndex := iNdEx
7239 var wire uint64
7240 for shift := uint(0); ; shift += 7 {
7241 if shift >= 64 {
7242 return ErrIntOverflowNetworkconfigproxy
7243 }
7244 if iNdEx >= l {
7245 return io.ErrUnexpectedEOF
7246 }
7247 b := dAtA[iNdEx]
7248 iNdEx++
7249 wire |= uint64(b&0x7F) << shift
7250 if b < 0x80 {
7251 break
7252 }
7253 }
7254 fieldNum := int32(wire >> 3)
7255 wireType := int(wire & 0x7)
7256 if wireType == 4 {
7257 return fmt.Errorf("proto: HcnEndpointResponse: wiretype end group for non-group")
7258 }
7259 if fieldNum <= 0 {
7260 return fmt.Errorf("proto: HcnEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
7261 }
7262 switch fieldNum {
7263 case 1:
7264 if wireType != 2 {
7265 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
7266 }
7267 var stringLen uint64
7268 for shift := uint(0); ; shift += 7 {
7269 if shift >= 64 {
7270 return ErrIntOverflowNetworkconfigproxy
7271 }
7272 if iNdEx >= l {
7273 return io.ErrUnexpectedEOF
7274 }
7275 b := dAtA[iNdEx]
7276 iNdEx++
7277 stringLen |= uint64(b&0x7F) << shift
7278 if b < 0x80 {
7279 break
7280 }
7281 }
7282 intStringLen := int(stringLen)
7283 if intStringLen < 0 {
7284 return ErrInvalidLengthNetworkconfigproxy
7285 }
7286 postIndex := iNdEx + intStringLen
7287 if postIndex < 0 {
7288 return ErrInvalidLengthNetworkconfigproxy
7289 }
7290 if postIndex > l {
7291 return io.ErrUnexpectedEOF
7292 }
7293 m.Namespace = string(dAtA[iNdEx:postIndex])
7294 iNdEx = postIndex
7295 case 2:
7296 if wireType != 2 {
7297 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
7298 }
7299 var stringLen uint64
7300 for shift := uint(0); ; shift += 7 {
7301 if shift >= 64 {
7302 return ErrIntOverflowNetworkconfigproxy
7303 }
7304 if iNdEx >= l {
7305 return io.ErrUnexpectedEOF
7306 }
7307 b := dAtA[iNdEx]
7308 iNdEx++
7309 stringLen |= uint64(b&0x7F) << shift
7310 if b < 0x80 {
7311 break
7312 }
7313 }
7314 intStringLen := int(stringLen)
7315 if intStringLen < 0 {
7316 return ErrInvalidLengthNetworkconfigproxy
7317 }
7318 postIndex := iNdEx + intStringLen
7319 if postIndex < 0 {
7320 return ErrInvalidLengthNetworkconfigproxy
7321 }
7322 if postIndex > l {
7323 return io.ErrUnexpectedEOF
7324 }
7325 m.ID = string(dAtA[iNdEx:postIndex])
7326 iNdEx = postIndex
7327 case 3:
7328 if wireType != 2 {
7329 return fmt.Errorf("proto: wrong wireType = %d for field Settings", wireType)
7330 }
7331 var msglen int
7332 for shift := uint(0); ; shift += 7 {
7333 if shift >= 64 {
7334 return ErrIntOverflowNetworkconfigproxy
7335 }
7336 if iNdEx >= l {
7337 return io.ErrUnexpectedEOF
7338 }
7339 b := dAtA[iNdEx]
7340 iNdEx++
7341 msglen |= int(b&0x7F) << shift
7342 if b < 0x80 {
7343 break
7344 }
7345 }
7346 if msglen < 0 {
7347 return ErrInvalidLengthNetworkconfigproxy
7348 }
7349 postIndex := iNdEx + msglen
7350 if postIndex < 0 {
7351 return ErrInvalidLengthNetworkconfigproxy
7352 }
7353 if postIndex > l {
7354 return io.ErrUnexpectedEOF
7355 }
7356 if m.Settings == nil {
7357 m.Settings = &HcnEndpointSettings{}
7358 }
7359 if err := m.Settings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7360 return err
7361 }
7362 iNdEx = postIndex
7363 default:
7364 iNdEx = preIndex
7365 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7366 if err != nil {
7367 return err
7368 }
7369 if (skippy < 0) || (iNdEx+skippy) < 0 {
7370 return ErrInvalidLengthNetworkconfigproxy
7371 }
7372 if (iNdEx + skippy) > l {
7373 return io.ErrUnexpectedEOF
7374 }
7375 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7376 iNdEx += skippy
7377 }
7378 }
7379
7380 if iNdEx > l {
7381 return io.ErrUnexpectedEOF
7382 }
7383 return nil
7384 }
7385 func (m *HcnEndpointSettings) Unmarshal(dAtA []byte) error {
7386 l := len(dAtA)
7387 iNdEx := 0
7388 for iNdEx < l {
7389 preIndex := iNdEx
7390 var wire uint64
7391 for shift := uint(0); ; shift += 7 {
7392 if shift >= 64 {
7393 return ErrIntOverflowNetworkconfigproxy
7394 }
7395 if iNdEx >= l {
7396 return io.ErrUnexpectedEOF
7397 }
7398 b := dAtA[iNdEx]
7399 iNdEx++
7400 wire |= uint64(b&0x7F) << shift
7401 if b < 0x80 {
7402 break
7403 }
7404 }
7405 fieldNum := int32(wire >> 3)
7406 wireType := int(wire & 0x7)
7407 if wireType == 4 {
7408 return fmt.Errorf("proto: HcnEndpointSettings: wiretype end group for non-group")
7409 }
7410 if fieldNum <= 0 {
7411 return fmt.Errorf("proto: HcnEndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
7412 }
7413 switch fieldNum {
7414 case 1:
7415 if wireType != 2 {
7416 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
7417 }
7418 var stringLen uint64
7419 for shift := uint(0); ; shift += 7 {
7420 if shift >= 64 {
7421 return ErrIntOverflowNetworkconfigproxy
7422 }
7423 if iNdEx >= l {
7424 return io.ErrUnexpectedEOF
7425 }
7426 b := dAtA[iNdEx]
7427 iNdEx++
7428 stringLen |= uint64(b&0x7F) << shift
7429 if b < 0x80 {
7430 break
7431 }
7432 }
7433 intStringLen := int(stringLen)
7434 if intStringLen < 0 {
7435 return ErrInvalidLengthNetworkconfigproxy
7436 }
7437 postIndex := iNdEx + intStringLen
7438 if postIndex < 0 {
7439 return ErrInvalidLengthNetworkconfigproxy
7440 }
7441 if postIndex > l {
7442 return io.ErrUnexpectedEOF
7443 }
7444 m.Name = string(dAtA[iNdEx:postIndex])
7445 iNdEx = postIndex
7446 case 2:
7447 if wireType != 2 {
7448 return fmt.Errorf("proto: wrong wireType = %d for field Macaddress", wireType)
7449 }
7450 var stringLen uint64
7451 for shift := uint(0); ; shift += 7 {
7452 if shift >= 64 {
7453 return ErrIntOverflowNetworkconfigproxy
7454 }
7455 if iNdEx >= l {
7456 return io.ErrUnexpectedEOF
7457 }
7458 b := dAtA[iNdEx]
7459 iNdEx++
7460 stringLen |= uint64(b&0x7F) << shift
7461 if b < 0x80 {
7462 break
7463 }
7464 }
7465 intStringLen := int(stringLen)
7466 if intStringLen < 0 {
7467 return ErrInvalidLengthNetworkconfigproxy
7468 }
7469 postIndex := iNdEx + intStringLen
7470 if postIndex < 0 {
7471 return ErrInvalidLengthNetworkconfigproxy
7472 }
7473 if postIndex > l {
7474 return io.ErrUnexpectedEOF
7475 }
7476 m.Macaddress = string(dAtA[iNdEx:postIndex])
7477 iNdEx = postIndex
7478 case 3:
7479 if wireType != 2 {
7480 return fmt.Errorf("proto: wrong wireType = %d for field Ipaddress", wireType)
7481 }
7482 var stringLen uint64
7483 for shift := uint(0); ; shift += 7 {
7484 if shift >= 64 {
7485 return ErrIntOverflowNetworkconfigproxy
7486 }
7487 if iNdEx >= l {
7488 return io.ErrUnexpectedEOF
7489 }
7490 b := dAtA[iNdEx]
7491 iNdEx++
7492 stringLen |= uint64(b&0x7F) << shift
7493 if b < 0x80 {
7494 break
7495 }
7496 }
7497 intStringLen := int(stringLen)
7498 if intStringLen < 0 {
7499 return ErrInvalidLengthNetworkconfigproxy
7500 }
7501 postIndex := iNdEx + intStringLen
7502 if postIndex < 0 {
7503 return ErrInvalidLengthNetworkconfigproxy
7504 }
7505 if postIndex > l {
7506 return io.ErrUnexpectedEOF
7507 }
7508 m.Ipaddress = string(dAtA[iNdEx:postIndex])
7509 iNdEx = postIndex
7510 case 4:
7511 if wireType != 0 {
7512 return fmt.Errorf("proto: wrong wireType = %d for field IpaddressPrefixlength", wireType)
7513 }
7514 m.IpaddressPrefixlength = 0
7515 for shift := uint(0); ; shift += 7 {
7516 if shift >= 64 {
7517 return ErrIntOverflowNetworkconfigproxy
7518 }
7519 if iNdEx >= l {
7520 return io.ErrUnexpectedEOF
7521 }
7522 b := dAtA[iNdEx]
7523 iNdEx++
7524 m.IpaddressPrefixlength |= uint32(b&0x7F) << shift
7525 if b < 0x80 {
7526 break
7527 }
7528 }
7529 case 5:
7530 if wireType != 2 {
7531 return fmt.Errorf("proto: wrong wireType = %d for field NetworkName", wireType)
7532 }
7533 var stringLen uint64
7534 for shift := uint(0); ; shift += 7 {
7535 if shift >= 64 {
7536 return ErrIntOverflowNetworkconfigproxy
7537 }
7538 if iNdEx >= l {
7539 return io.ErrUnexpectedEOF
7540 }
7541 b := dAtA[iNdEx]
7542 iNdEx++
7543 stringLen |= uint64(b&0x7F) << shift
7544 if b < 0x80 {
7545 break
7546 }
7547 }
7548 intStringLen := int(stringLen)
7549 if intStringLen < 0 {
7550 return ErrInvalidLengthNetworkconfigproxy
7551 }
7552 postIndex := iNdEx + intStringLen
7553 if postIndex < 0 {
7554 return ErrInvalidLengthNetworkconfigproxy
7555 }
7556 if postIndex > l {
7557 return io.ErrUnexpectedEOF
7558 }
7559 m.NetworkName = string(dAtA[iNdEx:postIndex])
7560 iNdEx = postIndex
7561 case 6:
7562 if wireType != 2 {
7563 return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType)
7564 }
7565 var msglen int
7566 for shift := uint(0); ; shift += 7 {
7567 if shift >= 64 {
7568 return ErrIntOverflowNetworkconfigproxy
7569 }
7570 if iNdEx >= l {
7571 return io.ErrUnexpectedEOF
7572 }
7573 b := dAtA[iNdEx]
7574 iNdEx++
7575 msglen |= int(b&0x7F) << shift
7576 if b < 0x80 {
7577 break
7578 }
7579 }
7580 if msglen < 0 {
7581 return ErrInvalidLengthNetworkconfigproxy
7582 }
7583 postIndex := iNdEx + msglen
7584 if postIndex < 0 {
7585 return ErrInvalidLengthNetworkconfigproxy
7586 }
7587 if postIndex > l {
7588 return io.ErrUnexpectedEOF
7589 }
7590 if m.Policies == nil {
7591 m.Policies = &HcnEndpointPolicies{}
7592 }
7593 if err := m.Policies.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7594 return err
7595 }
7596 iNdEx = postIndex
7597 case 7:
7598 if wireType != 2 {
7599 return fmt.Errorf("proto: wrong wireType = %d for field DnsSetting", wireType)
7600 }
7601 var msglen int
7602 for shift := uint(0); ; shift += 7 {
7603 if shift >= 64 {
7604 return ErrIntOverflowNetworkconfigproxy
7605 }
7606 if iNdEx >= l {
7607 return io.ErrUnexpectedEOF
7608 }
7609 b := dAtA[iNdEx]
7610 iNdEx++
7611 msglen |= int(b&0x7F) << shift
7612 if b < 0x80 {
7613 break
7614 }
7615 }
7616 if msglen < 0 {
7617 return ErrInvalidLengthNetworkconfigproxy
7618 }
7619 postIndex := iNdEx + msglen
7620 if postIndex < 0 {
7621 return ErrInvalidLengthNetworkconfigproxy
7622 }
7623 if postIndex > l {
7624 return io.ErrUnexpectedEOF
7625 }
7626 if m.DnsSetting == nil {
7627 m.DnsSetting = &DnsSetting{}
7628 }
7629 if err := m.DnsSetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7630 return err
7631 }
7632 iNdEx = postIndex
7633 case 8:
7634 if wireType != 2 {
7635 return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Address", wireType)
7636 }
7637 var stringLen uint64
7638 for shift := uint(0); ; shift += 7 {
7639 if shift >= 64 {
7640 return ErrIntOverflowNetworkconfigproxy
7641 }
7642 if iNdEx >= l {
7643 return io.ErrUnexpectedEOF
7644 }
7645 b := dAtA[iNdEx]
7646 iNdEx++
7647 stringLen |= uint64(b&0x7F) << shift
7648 if b < 0x80 {
7649 break
7650 }
7651 }
7652 intStringLen := int(stringLen)
7653 if intStringLen < 0 {
7654 return ErrInvalidLengthNetworkconfigproxy
7655 }
7656 postIndex := iNdEx + intStringLen
7657 if postIndex < 0 {
7658 return ErrInvalidLengthNetworkconfigproxy
7659 }
7660 if postIndex > l {
7661 return io.ErrUnexpectedEOF
7662 }
7663 m.Ipv6Address = string(dAtA[iNdEx:postIndex])
7664 iNdEx = postIndex
7665 case 9:
7666 if wireType != 0 {
7667 return fmt.Errorf("proto: wrong wireType = %d for field Ipv6AddressPrefixlength", wireType)
7668 }
7669 m.Ipv6AddressPrefixlength = 0
7670 for shift := uint(0); ; shift += 7 {
7671 if shift >= 64 {
7672 return ErrIntOverflowNetworkconfigproxy
7673 }
7674 if iNdEx >= l {
7675 return io.ErrUnexpectedEOF
7676 }
7677 b := dAtA[iNdEx]
7678 iNdEx++
7679 m.Ipv6AddressPrefixlength |= uint32(b&0x7F) << shift
7680 if b < 0x80 {
7681 break
7682 }
7683 }
7684 default:
7685 iNdEx = preIndex
7686 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7687 if err != nil {
7688 return err
7689 }
7690 if (skippy < 0) || (iNdEx+skippy) < 0 {
7691 return ErrInvalidLengthNetworkconfigproxy
7692 }
7693 if (iNdEx + skippy) > l {
7694 return io.ErrUnexpectedEOF
7695 }
7696 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7697 iNdEx += skippy
7698 }
7699 }
7700
7701 if iNdEx > l {
7702 return io.ErrUnexpectedEOF
7703 }
7704 return nil
7705 }
7706 func (m *HcnEndpointPolicies) Unmarshal(dAtA []byte) error {
7707 l := len(dAtA)
7708 iNdEx := 0
7709 for iNdEx < l {
7710 preIndex := iNdEx
7711 var wire uint64
7712 for shift := uint(0); ; shift += 7 {
7713 if shift >= 64 {
7714 return ErrIntOverflowNetworkconfigproxy
7715 }
7716 if iNdEx >= l {
7717 return io.ErrUnexpectedEOF
7718 }
7719 b := dAtA[iNdEx]
7720 iNdEx++
7721 wire |= uint64(b&0x7F) << shift
7722 if b < 0x80 {
7723 break
7724 }
7725 }
7726 fieldNum := int32(wire >> 3)
7727 wireType := int(wire & 0x7)
7728 if wireType == 4 {
7729 return fmt.Errorf("proto: HcnEndpointPolicies: wiretype end group for non-group")
7730 }
7731 if fieldNum <= 0 {
7732 return fmt.Errorf("proto: HcnEndpointPolicies: illegal tag %d (wire type %d)", fieldNum, wire)
7733 }
7734 switch fieldNum {
7735 case 1:
7736 if wireType != 2 {
7737 return fmt.Errorf("proto: wrong wireType = %d for field PortnamePolicySetting", wireType)
7738 }
7739 var msglen int
7740 for shift := uint(0); ; shift += 7 {
7741 if shift >= 64 {
7742 return ErrIntOverflowNetworkconfigproxy
7743 }
7744 if iNdEx >= l {
7745 return io.ErrUnexpectedEOF
7746 }
7747 b := dAtA[iNdEx]
7748 iNdEx++
7749 msglen |= int(b&0x7F) << shift
7750 if b < 0x80 {
7751 break
7752 }
7753 }
7754 if msglen < 0 {
7755 return ErrInvalidLengthNetworkconfigproxy
7756 }
7757 postIndex := iNdEx + msglen
7758 if postIndex < 0 {
7759 return ErrInvalidLengthNetworkconfigproxy
7760 }
7761 if postIndex > l {
7762 return io.ErrUnexpectedEOF
7763 }
7764 if m.PortnamePolicySetting == nil {
7765 m.PortnamePolicySetting = &PortNameEndpointPolicySetting{}
7766 }
7767 if err := m.PortnamePolicySetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7768 return err
7769 }
7770 iNdEx = postIndex
7771 case 2:
7772 if wireType != 2 {
7773 return fmt.Errorf("proto: wrong wireType = %d for field IovPolicySettings", wireType)
7774 }
7775 var msglen int
7776 for shift := uint(0); ; shift += 7 {
7777 if shift >= 64 {
7778 return ErrIntOverflowNetworkconfigproxy
7779 }
7780 if iNdEx >= l {
7781 return io.ErrUnexpectedEOF
7782 }
7783 b := dAtA[iNdEx]
7784 iNdEx++
7785 msglen |= int(b&0x7F) << shift
7786 if b < 0x80 {
7787 break
7788 }
7789 }
7790 if msglen < 0 {
7791 return ErrInvalidLengthNetworkconfigproxy
7792 }
7793 postIndex := iNdEx + msglen
7794 if postIndex < 0 {
7795 return ErrInvalidLengthNetworkconfigproxy
7796 }
7797 if postIndex > l {
7798 return io.ErrUnexpectedEOF
7799 }
7800 if m.IovPolicySettings == nil {
7801 m.IovPolicySettings = &IovEndpointPolicySetting{}
7802 }
7803 if err := m.IovPolicySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7804 return err
7805 }
7806 iNdEx = postIndex
7807 default:
7808 iNdEx = preIndex
7809 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
7810 if err != nil {
7811 return err
7812 }
7813 if (skippy < 0) || (iNdEx+skippy) < 0 {
7814 return ErrInvalidLengthNetworkconfigproxy
7815 }
7816 if (iNdEx + skippy) > l {
7817 return io.ErrUnexpectedEOF
7818 }
7819 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7820 iNdEx += skippy
7821 }
7822 }
7823
7824 if iNdEx > l {
7825 return io.ErrUnexpectedEOF
7826 }
7827 return nil
7828 }
7829 func (m *NCProxyEndpointSettings) Unmarshal(dAtA []byte) error {
7830 l := len(dAtA)
7831 iNdEx := 0
7832 for iNdEx < l {
7833 preIndex := iNdEx
7834 var wire uint64
7835 for shift := uint(0); ; shift += 7 {
7836 if shift >= 64 {
7837 return ErrIntOverflowNetworkconfigproxy
7838 }
7839 if iNdEx >= l {
7840 return io.ErrUnexpectedEOF
7841 }
7842 b := dAtA[iNdEx]
7843 iNdEx++
7844 wire |= uint64(b&0x7F) << shift
7845 if b < 0x80 {
7846 break
7847 }
7848 }
7849 fieldNum := int32(wire >> 3)
7850 wireType := int(wire & 0x7)
7851 if wireType == 4 {
7852 return fmt.Errorf("proto: NCProxyEndpointSettings: wiretype end group for non-group")
7853 }
7854 if fieldNum <= 0 {
7855 return fmt.Errorf("proto: NCProxyEndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
7856 }
7857 switch fieldNum {
7858 case 1:
7859 if wireType != 2 {
7860 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
7861 }
7862 var stringLen uint64
7863 for shift := uint(0); ; shift += 7 {
7864 if shift >= 64 {
7865 return ErrIntOverflowNetworkconfigproxy
7866 }
7867 if iNdEx >= l {
7868 return io.ErrUnexpectedEOF
7869 }
7870 b := dAtA[iNdEx]
7871 iNdEx++
7872 stringLen |= uint64(b&0x7F) << shift
7873 if b < 0x80 {
7874 break
7875 }
7876 }
7877 intStringLen := int(stringLen)
7878 if intStringLen < 0 {
7879 return ErrInvalidLengthNetworkconfigproxy
7880 }
7881 postIndex := iNdEx + intStringLen
7882 if postIndex < 0 {
7883 return ErrInvalidLengthNetworkconfigproxy
7884 }
7885 if postIndex > l {
7886 return io.ErrUnexpectedEOF
7887 }
7888 m.Name = string(dAtA[iNdEx:postIndex])
7889 iNdEx = postIndex
7890 case 2:
7891 if wireType != 2 {
7892 return fmt.Errorf("proto: wrong wireType = %d for field Macaddress", wireType)
7893 }
7894 var stringLen uint64
7895 for shift := uint(0); ; shift += 7 {
7896 if shift >= 64 {
7897 return ErrIntOverflowNetworkconfigproxy
7898 }
7899 if iNdEx >= l {
7900 return io.ErrUnexpectedEOF
7901 }
7902 b := dAtA[iNdEx]
7903 iNdEx++
7904 stringLen |= uint64(b&0x7F) << shift
7905 if b < 0x80 {
7906 break
7907 }
7908 }
7909 intStringLen := int(stringLen)
7910 if intStringLen < 0 {
7911 return ErrInvalidLengthNetworkconfigproxy
7912 }
7913 postIndex := iNdEx + intStringLen
7914 if postIndex < 0 {
7915 return ErrInvalidLengthNetworkconfigproxy
7916 }
7917 if postIndex > l {
7918 return io.ErrUnexpectedEOF
7919 }
7920 m.Macaddress = string(dAtA[iNdEx:postIndex])
7921 iNdEx = postIndex
7922 case 3:
7923 if wireType != 2 {
7924 return fmt.Errorf("proto: wrong wireType = %d for field Ipaddress", wireType)
7925 }
7926 var stringLen uint64
7927 for shift := uint(0); ; shift += 7 {
7928 if shift >= 64 {
7929 return ErrIntOverflowNetworkconfigproxy
7930 }
7931 if iNdEx >= l {
7932 return io.ErrUnexpectedEOF
7933 }
7934 b := dAtA[iNdEx]
7935 iNdEx++
7936 stringLen |= uint64(b&0x7F) << shift
7937 if b < 0x80 {
7938 break
7939 }
7940 }
7941 intStringLen := int(stringLen)
7942 if intStringLen < 0 {
7943 return ErrInvalidLengthNetworkconfigproxy
7944 }
7945 postIndex := iNdEx + intStringLen
7946 if postIndex < 0 {
7947 return ErrInvalidLengthNetworkconfigproxy
7948 }
7949 if postIndex > l {
7950 return io.ErrUnexpectedEOF
7951 }
7952 m.Ipaddress = string(dAtA[iNdEx:postIndex])
7953 iNdEx = postIndex
7954 case 4:
7955 if wireType != 0 {
7956 return fmt.Errorf("proto: wrong wireType = %d for field IpaddressPrefixlength", wireType)
7957 }
7958 m.IpaddressPrefixlength = 0
7959 for shift := uint(0); ; shift += 7 {
7960 if shift >= 64 {
7961 return ErrIntOverflowNetworkconfigproxy
7962 }
7963 if iNdEx >= l {
7964 return io.ErrUnexpectedEOF
7965 }
7966 b := dAtA[iNdEx]
7967 iNdEx++
7968 m.IpaddressPrefixlength |= uint32(b&0x7F) << shift
7969 if b < 0x80 {
7970 break
7971 }
7972 }
7973 case 5:
7974 if wireType != 2 {
7975 return fmt.Errorf("proto: wrong wireType = %d for field NetworkName", wireType)
7976 }
7977 var stringLen uint64
7978 for shift := uint(0); ; shift += 7 {
7979 if shift >= 64 {
7980 return ErrIntOverflowNetworkconfigproxy
7981 }
7982 if iNdEx >= l {
7983 return io.ErrUnexpectedEOF
7984 }
7985 b := dAtA[iNdEx]
7986 iNdEx++
7987 stringLen |= uint64(b&0x7F) << shift
7988 if b < 0x80 {
7989 break
7990 }
7991 }
7992 intStringLen := int(stringLen)
7993 if intStringLen < 0 {
7994 return ErrInvalidLengthNetworkconfigproxy
7995 }
7996 postIndex := iNdEx + intStringLen
7997 if postIndex < 0 {
7998 return ErrInvalidLengthNetworkconfigproxy
7999 }
8000 if postIndex > l {
8001 return io.ErrUnexpectedEOF
8002 }
8003 m.NetworkName = string(dAtA[iNdEx:postIndex])
8004 iNdEx = postIndex
8005 case 6:
8006 if wireType != 2 {
8007 return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
8008 }
8009 var stringLen uint64
8010 for shift := uint(0); ; shift += 7 {
8011 if shift >= 64 {
8012 return ErrIntOverflowNetworkconfigproxy
8013 }
8014 if iNdEx >= l {
8015 return io.ErrUnexpectedEOF
8016 }
8017 b := dAtA[iNdEx]
8018 iNdEx++
8019 stringLen |= uint64(b&0x7F) << shift
8020 if b < 0x80 {
8021 break
8022 }
8023 }
8024 intStringLen := int(stringLen)
8025 if intStringLen < 0 {
8026 return ErrInvalidLengthNetworkconfigproxy
8027 }
8028 postIndex := iNdEx + intStringLen
8029 if postIndex < 0 {
8030 return ErrInvalidLengthNetworkconfigproxy
8031 }
8032 if postIndex > l {
8033 return io.ErrUnexpectedEOF
8034 }
8035 m.DefaultGateway = string(dAtA[iNdEx:postIndex])
8036 iNdEx = postIndex
8037 case 7:
8038 if wireType != 2 {
8039 return fmt.Errorf("proto: wrong wireType = %d for field PciDeviceDetails", wireType)
8040 }
8041 var msglen int
8042 for shift := uint(0); ; shift += 7 {
8043 if shift >= 64 {
8044 return ErrIntOverflowNetworkconfigproxy
8045 }
8046 if iNdEx >= l {
8047 return io.ErrUnexpectedEOF
8048 }
8049 b := dAtA[iNdEx]
8050 iNdEx++
8051 msglen |= int(b&0x7F) << shift
8052 if b < 0x80 {
8053 break
8054 }
8055 }
8056 if msglen < 0 {
8057 return ErrInvalidLengthNetworkconfigproxy
8058 }
8059 postIndex := iNdEx + msglen
8060 if postIndex < 0 {
8061 return ErrInvalidLengthNetworkconfigproxy
8062 }
8063 if postIndex > l {
8064 return io.ErrUnexpectedEOF
8065 }
8066 v := &PCIDeviceDetails{}
8067 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8068 return err
8069 }
8070 m.DeviceDetails = &NCProxyEndpointSettings_PciDeviceDetails{v}
8071 iNdEx = postIndex
8072 case 8:
8073 if wireType != 2 {
8074 return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Address", wireType)
8075 }
8076 var stringLen uint64
8077 for shift := uint(0); ; shift += 7 {
8078 if shift >= 64 {
8079 return ErrIntOverflowNetworkconfigproxy
8080 }
8081 if iNdEx >= l {
8082 return io.ErrUnexpectedEOF
8083 }
8084 b := dAtA[iNdEx]
8085 iNdEx++
8086 stringLen |= uint64(b&0x7F) << shift
8087 if b < 0x80 {
8088 break
8089 }
8090 }
8091 intStringLen := int(stringLen)
8092 if intStringLen < 0 {
8093 return ErrInvalidLengthNetworkconfigproxy
8094 }
8095 postIndex := iNdEx + intStringLen
8096 if postIndex < 0 {
8097 return ErrInvalidLengthNetworkconfigproxy
8098 }
8099 if postIndex > l {
8100 return io.ErrUnexpectedEOF
8101 }
8102 m.Ipv6Address = string(dAtA[iNdEx:postIndex])
8103 iNdEx = postIndex
8104 case 9:
8105 if wireType != 2 {
8106 return fmt.Errorf("proto: wrong wireType = %d for field Ipv6AddressPrefixlength", wireType)
8107 }
8108 var stringLen uint64
8109 for shift := uint(0); ; shift += 7 {
8110 if shift >= 64 {
8111 return ErrIntOverflowNetworkconfigproxy
8112 }
8113 if iNdEx >= l {
8114 return io.ErrUnexpectedEOF
8115 }
8116 b := dAtA[iNdEx]
8117 iNdEx++
8118 stringLen |= uint64(b&0x7F) << shift
8119 if b < 0x80 {
8120 break
8121 }
8122 }
8123 intStringLen := int(stringLen)
8124 if intStringLen < 0 {
8125 return ErrInvalidLengthNetworkconfigproxy
8126 }
8127 postIndex := iNdEx + intStringLen
8128 if postIndex < 0 {
8129 return ErrInvalidLengthNetworkconfigproxy
8130 }
8131 if postIndex > l {
8132 return io.ErrUnexpectedEOF
8133 }
8134 m.Ipv6AddressPrefixlength = string(dAtA[iNdEx:postIndex])
8135 iNdEx = postIndex
8136 default:
8137 iNdEx = preIndex
8138 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8139 if err != nil {
8140 return err
8141 }
8142 if (skippy < 0) || (iNdEx+skippy) < 0 {
8143 return ErrInvalidLengthNetworkconfigproxy
8144 }
8145 if (iNdEx + skippy) > l {
8146 return io.ErrUnexpectedEOF
8147 }
8148 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8149 iNdEx += skippy
8150 }
8151 }
8152
8153 if iNdEx > l {
8154 return io.ErrUnexpectedEOF
8155 }
8156 return nil
8157 }
8158 func (m *PCIDeviceDetails) Unmarshal(dAtA []byte) error {
8159 l := len(dAtA)
8160 iNdEx := 0
8161 for iNdEx < l {
8162 preIndex := iNdEx
8163 var wire uint64
8164 for shift := uint(0); ; shift += 7 {
8165 if shift >= 64 {
8166 return ErrIntOverflowNetworkconfigproxy
8167 }
8168 if iNdEx >= l {
8169 return io.ErrUnexpectedEOF
8170 }
8171 b := dAtA[iNdEx]
8172 iNdEx++
8173 wire |= uint64(b&0x7F) << shift
8174 if b < 0x80 {
8175 break
8176 }
8177 }
8178 fieldNum := int32(wire >> 3)
8179 wireType := int(wire & 0x7)
8180 if wireType == 4 {
8181 return fmt.Errorf("proto: PCIDeviceDetails: wiretype end group for non-group")
8182 }
8183 if fieldNum <= 0 {
8184 return fmt.Errorf("proto: PCIDeviceDetails: illegal tag %d (wire type %d)", fieldNum, wire)
8185 }
8186 switch fieldNum {
8187 case 1:
8188 if wireType != 2 {
8189 return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
8190 }
8191 var stringLen uint64
8192 for shift := uint(0); ; shift += 7 {
8193 if shift >= 64 {
8194 return ErrIntOverflowNetworkconfigproxy
8195 }
8196 if iNdEx >= l {
8197 return io.ErrUnexpectedEOF
8198 }
8199 b := dAtA[iNdEx]
8200 iNdEx++
8201 stringLen |= uint64(b&0x7F) << shift
8202 if b < 0x80 {
8203 break
8204 }
8205 }
8206 intStringLen := int(stringLen)
8207 if intStringLen < 0 {
8208 return ErrInvalidLengthNetworkconfigproxy
8209 }
8210 postIndex := iNdEx + intStringLen
8211 if postIndex < 0 {
8212 return ErrInvalidLengthNetworkconfigproxy
8213 }
8214 if postIndex > l {
8215 return io.ErrUnexpectedEOF
8216 }
8217 m.DeviceID = string(dAtA[iNdEx:postIndex])
8218 iNdEx = postIndex
8219 case 2:
8220 if wireType != 0 {
8221 return fmt.Errorf("proto: wrong wireType = %d for field VirtualFunctionIndex", wireType)
8222 }
8223 m.VirtualFunctionIndex = 0
8224 for shift := uint(0); ; shift += 7 {
8225 if shift >= 64 {
8226 return ErrIntOverflowNetworkconfigproxy
8227 }
8228 if iNdEx >= l {
8229 return io.ErrUnexpectedEOF
8230 }
8231 b := dAtA[iNdEx]
8232 iNdEx++
8233 m.VirtualFunctionIndex |= uint32(b&0x7F) << shift
8234 if b < 0x80 {
8235 break
8236 }
8237 }
8238 default:
8239 iNdEx = preIndex
8240 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8241 if err != nil {
8242 return err
8243 }
8244 if (skippy < 0) || (iNdEx+skippy) < 0 {
8245 return ErrInvalidLengthNetworkconfigproxy
8246 }
8247 if (iNdEx + skippy) > l {
8248 return io.ErrUnexpectedEOF
8249 }
8250 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8251 iNdEx += skippy
8252 }
8253 }
8254
8255 if iNdEx > l {
8256 return io.ErrUnexpectedEOF
8257 }
8258 return nil
8259 }
8260 func (m *CreateEndpointResponse) Unmarshal(dAtA []byte) error {
8261 l := len(dAtA)
8262 iNdEx := 0
8263 for iNdEx < l {
8264 preIndex := iNdEx
8265 var wire uint64
8266 for shift := uint(0); ; shift += 7 {
8267 if shift >= 64 {
8268 return ErrIntOverflowNetworkconfigproxy
8269 }
8270 if iNdEx >= l {
8271 return io.ErrUnexpectedEOF
8272 }
8273 b := dAtA[iNdEx]
8274 iNdEx++
8275 wire |= uint64(b&0x7F) << shift
8276 if b < 0x80 {
8277 break
8278 }
8279 }
8280 fieldNum := int32(wire >> 3)
8281 wireType := int(wire & 0x7)
8282 if wireType == 4 {
8283 return fmt.Errorf("proto: CreateEndpointResponse: wiretype end group for non-group")
8284 }
8285 if fieldNum <= 0 {
8286 return fmt.Errorf("proto: CreateEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8287 }
8288 switch fieldNum {
8289 case 1:
8290 if wireType != 2 {
8291 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
8292 }
8293 var stringLen uint64
8294 for shift := uint(0); ; shift += 7 {
8295 if shift >= 64 {
8296 return ErrIntOverflowNetworkconfigproxy
8297 }
8298 if iNdEx >= l {
8299 return io.ErrUnexpectedEOF
8300 }
8301 b := dAtA[iNdEx]
8302 iNdEx++
8303 stringLen |= uint64(b&0x7F) << shift
8304 if b < 0x80 {
8305 break
8306 }
8307 }
8308 intStringLen := int(stringLen)
8309 if intStringLen < 0 {
8310 return ErrInvalidLengthNetworkconfigproxy
8311 }
8312 postIndex := iNdEx + intStringLen
8313 if postIndex < 0 {
8314 return ErrInvalidLengthNetworkconfigproxy
8315 }
8316 if postIndex > l {
8317 return io.ErrUnexpectedEOF
8318 }
8319 m.ID = string(dAtA[iNdEx:postIndex])
8320 iNdEx = postIndex
8321 default:
8322 iNdEx = preIndex
8323 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8324 if err != nil {
8325 return err
8326 }
8327 if (skippy < 0) || (iNdEx+skippy) < 0 {
8328 return ErrInvalidLengthNetworkconfigproxy
8329 }
8330 if (iNdEx + skippy) > l {
8331 return io.ErrUnexpectedEOF
8332 }
8333 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8334 iNdEx += skippy
8335 }
8336 }
8337
8338 if iNdEx > l {
8339 return io.ErrUnexpectedEOF
8340 }
8341 return nil
8342 }
8343 func (m *AddEndpointRequest) Unmarshal(dAtA []byte) error {
8344 l := len(dAtA)
8345 iNdEx := 0
8346 for iNdEx < l {
8347 preIndex := iNdEx
8348 var wire uint64
8349 for shift := uint(0); ; shift += 7 {
8350 if shift >= 64 {
8351 return ErrIntOverflowNetworkconfigproxy
8352 }
8353 if iNdEx >= l {
8354 return io.ErrUnexpectedEOF
8355 }
8356 b := dAtA[iNdEx]
8357 iNdEx++
8358 wire |= uint64(b&0x7F) << shift
8359 if b < 0x80 {
8360 break
8361 }
8362 }
8363 fieldNum := int32(wire >> 3)
8364 wireType := int(wire & 0x7)
8365 if wireType == 4 {
8366 return fmt.Errorf("proto: AddEndpointRequest: wiretype end group for non-group")
8367 }
8368 if fieldNum <= 0 {
8369 return fmt.Errorf("proto: AddEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8370 }
8371 switch fieldNum {
8372 case 1:
8373 if wireType != 2 {
8374 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
8375 }
8376 var stringLen uint64
8377 for shift := uint(0); ; shift += 7 {
8378 if shift >= 64 {
8379 return ErrIntOverflowNetworkconfigproxy
8380 }
8381 if iNdEx >= l {
8382 return io.ErrUnexpectedEOF
8383 }
8384 b := dAtA[iNdEx]
8385 iNdEx++
8386 stringLen |= uint64(b&0x7F) << shift
8387 if b < 0x80 {
8388 break
8389 }
8390 }
8391 intStringLen := int(stringLen)
8392 if intStringLen < 0 {
8393 return ErrInvalidLengthNetworkconfigproxy
8394 }
8395 postIndex := iNdEx + intStringLen
8396 if postIndex < 0 {
8397 return ErrInvalidLengthNetworkconfigproxy
8398 }
8399 if postIndex > l {
8400 return io.ErrUnexpectedEOF
8401 }
8402 m.Name = string(dAtA[iNdEx:postIndex])
8403 iNdEx = postIndex
8404 case 2:
8405 if wireType != 2 {
8406 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceID", wireType)
8407 }
8408 var stringLen uint64
8409 for shift := uint(0); ; shift += 7 {
8410 if shift >= 64 {
8411 return ErrIntOverflowNetworkconfigproxy
8412 }
8413 if iNdEx >= l {
8414 return io.ErrUnexpectedEOF
8415 }
8416 b := dAtA[iNdEx]
8417 iNdEx++
8418 stringLen |= uint64(b&0x7F) << shift
8419 if b < 0x80 {
8420 break
8421 }
8422 }
8423 intStringLen := int(stringLen)
8424 if intStringLen < 0 {
8425 return ErrInvalidLengthNetworkconfigproxy
8426 }
8427 postIndex := iNdEx + intStringLen
8428 if postIndex < 0 {
8429 return ErrInvalidLengthNetworkconfigproxy
8430 }
8431 if postIndex > l {
8432 return io.ErrUnexpectedEOF
8433 }
8434 m.NamespaceID = string(dAtA[iNdEx:postIndex])
8435 iNdEx = postIndex
8436 case 3:
8437 if wireType != 0 {
8438 return fmt.Errorf("proto: wrong wireType = %d for field AttachToHost", wireType)
8439 }
8440 var v int
8441 for shift := uint(0); ; shift += 7 {
8442 if shift >= 64 {
8443 return ErrIntOverflowNetworkconfigproxy
8444 }
8445 if iNdEx >= l {
8446 return io.ErrUnexpectedEOF
8447 }
8448 b := dAtA[iNdEx]
8449 iNdEx++
8450 v |= int(b&0x7F) << shift
8451 if b < 0x80 {
8452 break
8453 }
8454 }
8455 m.AttachToHost = bool(v != 0)
8456 default:
8457 iNdEx = preIndex
8458 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8459 if err != nil {
8460 return err
8461 }
8462 if (skippy < 0) || (iNdEx+skippy) < 0 {
8463 return ErrInvalidLengthNetworkconfigproxy
8464 }
8465 if (iNdEx + skippy) > l {
8466 return io.ErrUnexpectedEOF
8467 }
8468 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8469 iNdEx += skippy
8470 }
8471 }
8472
8473 if iNdEx > l {
8474 return io.ErrUnexpectedEOF
8475 }
8476 return nil
8477 }
8478 func (m *AddEndpointResponse) Unmarshal(dAtA []byte) error {
8479 l := len(dAtA)
8480 iNdEx := 0
8481 for iNdEx < l {
8482 preIndex := iNdEx
8483 var wire uint64
8484 for shift := uint(0); ; shift += 7 {
8485 if shift >= 64 {
8486 return ErrIntOverflowNetworkconfigproxy
8487 }
8488 if iNdEx >= l {
8489 return io.ErrUnexpectedEOF
8490 }
8491 b := dAtA[iNdEx]
8492 iNdEx++
8493 wire |= uint64(b&0x7F) << shift
8494 if b < 0x80 {
8495 break
8496 }
8497 }
8498 fieldNum := int32(wire >> 3)
8499 wireType := int(wire & 0x7)
8500 if wireType == 4 {
8501 return fmt.Errorf("proto: AddEndpointResponse: wiretype end group for non-group")
8502 }
8503 if fieldNum <= 0 {
8504 return fmt.Errorf("proto: AddEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8505 }
8506 switch fieldNum {
8507 default:
8508 iNdEx = preIndex
8509 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8510 if err != nil {
8511 return err
8512 }
8513 if (skippy < 0) || (iNdEx+skippy) < 0 {
8514 return ErrInvalidLengthNetworkconfigproxy
8515 }
8516 if (iNdEx + skippy) > l {
8517 return io.ErrUnexpectedEOF
8518 }
8519 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8520 iNdEx += skippy
8521 }
8522 }
8523
8524 if iNdEx > l {
8525 return io.ErrUnexpectedEOF
8526 }
8527 return nil
8528 }
8529 func (m *DeleteEndpointRequest) Unmarshal(dAtA []byte) error {
8530 l := len(dAtA)
8531 iNdEx := 0
8532 for iNdEx < l {
8533 preIndex := iNdEx
8534 var wire uint64
8535 for shift := uint(0); ; shift += 7 {
8536 if shift >= 64 {
8537 return ErrIntOverflowNetworkconfigproxy
8538 }
8539 if iNdEx >= l {
8540 return io.ErrUnexpectedEOF
8541 }
8542 b := dAtA[iNdEx]
8543 iNdEx++
8544 wire |= uint64(b&0x7F) << shift
8545 if b < 0x80 {
8546 break
8547 }
8548 }
8549 fieldNum := int32(wire >> 3)
8550 wireType := int(wire & 0x7)
8551 if wireType == 4 {
8552 return fmt.Errorf("proto: DeleteEndpointRequest: wiretype end group for non-group")
8553 }
8554 if fieldNum <= 0 {
8555 return fmt.Errorf("proto: DeleteEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8556 }
8557 switch fieldNum {
8558 case 1:
8559 if wireType != 2 {
8560 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
8561 }
8562 var stringLen uint64
8563 for shift := uint(0); ; shift += 7 {
8564 if shift >= 64 {
8565 return ErrIntOverflowNetworkconfigproxy
8566 }
8567 if iNdEx >= l {
8568 return io.ErrUnexpectedEOF
8569 }
8570 b := dAtA[iNdEx]
8571 iNdEx++
8572 stringLen |= uint64(b&0x7F) << shift
8573 if b < 0x80 {
8574 break
8575 }
8576 }
8577 intStringLen := int(stringLen)
8578 if intStringLen < 0 {
8579 return ErrInvalidLengthNetworkconfigproxy
8580 }
8581 postIndex := iNdEx + intStringLen
8582 if postIndex < 0 {
8583 return ErrInvalidLengthNetworkconfigproxy
8584 }
8585 if postIndex > l {
8586 return io.ErrUnexpectedEOF
8587 }
8588 m.Name = string(dAtA[iNdEx:postIndex])
8589 iNdEx = postIndex
8590 default:
8591 iNdEx = preIndex
8592 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8593 if err != nil {
8594 return err
8595 }
8596 if (skippy < 0) || (iNdEx+skippy) < 0 {
8597 return ErrInvalidLengthNetworkconfigproxy
8598 }
8599 if (iNdEx + skippy) > l {
8600 return io.ErrUnexpectedEOF
8601 }
8602 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8603 iNdEx += skippy
8604 }
8605 }
8606
8607 if iNdEx > l {
8608 return io.ErrUnexpectedEOF
8609 }
8610 return nil
8611 }
8612 func (m *DeleteEndpointResponse) Unmarshal(dAtA []byte) error {
8613 l := len(dAtA)
8614 iNdEx := 0
8615 for iNdEx < l {
8616 preIndex := iNdEx
8617 var wire uint64
8618 for shift := uint(0); ; shift += 7 {
8619 if shift >= 64 {
8620 return ErrIntOverflowNetworkconfigproxy
8621 }
8622 if iNdEx >= l {
8623 return io.ErrUnexpectedEOF
8624 }
8625 b := dAtA[iNdEx]
8626 iNdEx++
8627 wire |= uint64(b&0x7F) << shift
8628 if b < 0x80 {
8629 break
8630 }
8631 }
8632 fieldNum := int32(wire >> 3)
8633 wireType := int(wire & 0x7)
8634 if wireType == 4 {
8635 return fmt.Errorf("proto: DeleteEndpointResponse: wiretype end group for non-group")
8636 }
8637 if fieldNum <= 0 {
8638 return fmt.Errorf("proto: DeleteEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8639 }
8640 switch fieldNum {
8641 default:
8642 iNdEx = preIndex
8643 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8644 if err != nil {
8645 return err
8646 }
8647 if (skippy < 0) || (iNdEx+skippy) < 0 {
8648 return ErrInvalidLengthNetworkconfigproxy
8649 }
8650 if (iNdEx + skippy) > l {
8651 return io.ErrUnexpectedEOF
8652 }
8653 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8654 iNdEx += skippy
8655 }
8656 }
8657
8658 if iNdEx > l {
8659 return io.ErrUnexpectedEOF
8660 }
8661 return nil
8662 }
8663 func (m *DeleteNetworkRequest) Unmarshal(dAtA []byte) error {
8664 l := len(dAtA)
8665 iNdEx := 0
8666 for iNdEx < l {
8667 preIndex := iNdEx
8668 var wire uint64
8669 for shift := uint(0); ; shift += 7 {
8670 if shift >= 64 {
8671 return ErrIntOverflowNetworkconfigproxy
8672 }
8673 if iNdEx >= l {
8674 return io.ErrUnexpectedEOF
8675 }
8676 b := dAtA[iNdEx]
8677 iNdEx++
8678 wire |= uint64(b&0x7F) << shift
8679 if b < 0x80 {
8680 break
8681 }
8682 }
8683 fieldNum := int32(wire >> 3)
8684 wireType := int(wire & 0x7)
8685 if wireType == 4 {
8686 return fmt.Errorf("proto: DeleteNetworkRequest: wiretype end group for non-group")
8687 }
8688 if fieldNum <= 0 {
8689 return fmt.Errorf("proto: DeleteNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8690 }
8691 switch fieldNum {
8692 case 1:
8693 if wireType != 2 {
8694 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
8695 }
8696 var stringLen uint64
8697 for shift := uint(0); ; shift += 7 {
8698 if shift >= 64 {
8699 return ErrIntOverflowNetworkconfigproxy
8700 }
8701 if iNdEx >= l {
8702 return io.ErrUnexpectedEOF
8703 }
8704 b := dAtA[iNdEx]
8705 iNdEx++
8706 stringLen |= uint64(b&0x7F) << shift
8707 if b < 0x80 {
8708 break
8709 }
8710 }
8711 intStringLen := int(stringLen)
8712 if intStringLen < 0 {
8713 return ErrInvalidLengthNetworkconfigproxy
8714 }
8715 postIndex := iNdEx + intStringLen
8716 if postIndex < 0 {
8717 return ErrInvalidLengthNetworkconfigproxy
8718 }
8719 if postIndex > l {
8720 return io.ErrUnexpectedEOF
8721 }
8722 m.Name = string(dAtA[iNdEx:postIndex])
8723 iNdEx = postIndex
8724 default:
8725 iNdEx = preIndex
8726 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8727 if err != nil {
8728 return err
8729 }
8730 if (skippy < 0) || (iNdEx+skippy) < 0 {
8731 return ErrInvalidLengthNetworkconfigproxy
8732 }
8733 if (iNdEx + skippy) > l {
8734 return io.ErrUnexpectedEOF
8735 }
8736 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8737 iNdEx += skippy
8738 }
8739 }
8740
8741 if iNdEx > l {
8742 return io.ErrUnexpectedEOF
8743 }
8744 return nil
8745 }
8746 func (m *DeleteNetworkResponse) Unmarshal(dAtA []byte) error {
8747 l := len(dAtA)
8748 iNdEx := 0
8749 for iNdEx < l {
8750 preIndex := iNdEx
8751 var wire uint64
8752 for shift := uint(0); ; shift += 7 {
8753 if shift >= 64 {
8754 return ErrIntOverflowNetworkconfigproxy
8755 }
8756 if iNdEx >= l {
8757 return io.ErrUnexpectedEOF
8758 }
8759 b := dAtA[iNdEx]
8760 iNdEx++
8761 wire |= uint64(b&0x7F) << shift
8762 if b < 0x80 {
8763 break
8764 }
8765 }
8766 fieldNum := int32(wire >> 3)
8767 wireType := int(wire & 0x7)
8768 if wireType == 4 {
8769 return fmt.Errorf("proto: DeleteNetworkResponse: wiretype end group for non-group")
8770 }
8771 if fieldNum <= 0 {
8772 return fmt.Errorf("proto: DeleteNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8773 }
8774 switch fieldNum {
8775 default:
8776 iNdEx = preIndex
8777 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8778 if err != nil {
8779 return err
8780 }
8781 if (skippy < 0) || (iNdEx+skippy) < 0 {
8782 return ErrInvalidLengthNetworkconfigproxy
8783 }
8784 if (iNdEx + skippy) > l {
8785 return io.ErrUnexpectedEOF
8786 }
8787 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8788 iNdEx += skippy
8789 }
8790 }
8791
8792 if iNdEx > l {
8793 return io.ErrUnexpectedEOF
8794 }
8795 return nil
8796 }
8797 func (m *GetEndpointRequest) Unmarshal(dAtA []byte) error {
8798 l := len(dAtA)
8799 iNdEx := 0
8800 for iNdEx < l {
8801 preIndex := iNdEx
8802 var wire uint64
8803 for shift := uint(0); ; shift += 7 {
8804 if shift >= 64 {
8805 return ErrIntOverflowNetworkconfigproxy
8806 }
8807 if iNdEx >= l {
8808 return io.ErrUnexpectedEOF
8809 }
8810 b := dAtA[iNdEx]
8811 iNdEx++
8812 wire |= uint64(b&0x7F) << shift
8813 if b < 0x80 {
8814 break
8815 }
8816 }
8817 fieldNum := int32(wire >> 3)
8818 wireType := int(wire & 0x7)
8819 if wireType == 4 {
8820 return fmt.Errorf("proto: GetEndpointRequest: wiretype end group for non-group")
8821 }
8822 if fieldNum <= 0 {
8823 return fmt.Errorf("proto: GetEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8824 }
8825 switch fieldNum {
8826 case 1:
8827 if wireType != 2 {
8828 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
8829 }
8830 var stringLen uint64
8831 for shift := uint(0); ; shift += 7 {
8832 if shift >= 64 {
8833 return ErrIntOverflowNetworkconfigproxy
8834 }
8835 if iNdEx >= l {
8836 return io.ErrUnexpectedEOF
8837 }
8838 b := dAtA[iNdEx]
8839 iNdEx++
8840 stringLen |= uint64(b&0x7F) << shift
8841 if b < 0x80 {
8842 break
8843 }
8844 }
8845 intStringLen := int(stringLen)
8846 if intStringLen < 0 {
8847 return ErrInvalidLengthNetworkconfigproxy
8848 }
8849 postIndex := iNdEx + intStringLen
8850 if postIndex < 0 {
8851 return ErrInvalidLengthNetworkconfigproxy
8852 }
8853 if postIndex > l {
8854 return io.ErrUnexpectedEOF
8855 }
8856 m.Name = string(dAtA[iNdEx:postIndex])
8857 iNdEx = postIndex
8858 default:
8859 iNdEx = preIndex
8860 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
8861 if err != nil {
8862 return err
8863 }
8864 if (skippy < 0) || (iNdEx+skippy) < 0 {
8865 return ErrInvalidLengthNetworkconfigproxy
8866 }
8867 if (iNdEx + skippy) > l {
8868 return io.ErrUnexpectedEOF
8869 }
8870 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8871 iNdEx += skippy
8872 }
8873 }
8874
8875 if iNdEx > l {
8876 return io.ErrUnexpectedEOF
8877 }
8878 return nil
8879 }
8880 func (m *GetEndpointResponse) Unmarshal(dAtA []byte) error {
8881 l := len(dAtA)
8882 iNdEx := 0
8883 for iNdEx < l {
8884 preIndex := iNdEx
8885 var wire uint64
8886 for shift := uint(0); ; shift += 7 {
8887 if shift >= 64 {
8888 return ErrIntOverflowNetworkconfigproxy
8889 }
8890 if iNdEx >= l {
8891 return io.ErrUnexpectedEOF
8892 }
8893 b := dAtA[iNdEx]
8894 iNdEx++
8895 wire |= uint64(b&0x7F) << shift
8896 if b < 0x80 {
8897 break
8898 }
8899 }
8900 fieldNum := int32(wire >> 3)
8901 wireType := int(wire & 0x7)
8902 if wireType == 4 {
8903 return fmt.Errorf("proto: GetEndpointResponse: wiretype end group for non-group")
8904 }
8905 if fieldNum <= 0 {
8906 return fmt.Errorf("proto: GetEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8907 }
8908 switch fieldNum {
8909 case 1:
8910 if wireType != 2 {
8911 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
8912 }
8913 var stringLen uint64
8914 for shift := uint(0); ; shift += 7 {
8915 if shift >= 64 {
8916 return ErrIntOverflowNetworkconfigproxy
8917 }
8918 if iNdEx >= l {
8919 return io.ErrUnexpectedEOF
8920 }
8921 b := dAtA[iNdEx]
8922 iNdEx++
8923 stringLen |= uint64(b&0x7F) << shift
8924 if b < 0x80 {
8925 break
8926 }
8927 }
8928 intStringLen := int(stringLen)
8929 if intStringLen < 0 {
8930 return ErrInvalidLengthNetworkconfigproxy
8931 }
8932 postIndex := iNdEx + intStringLen
8933 if postIndex < 0 {
8934 return ErrInvalidLengthNetworkconfigproxy
8935 }
8936 if postIndex > l {
8937 return io.ErrUnexpectedEOF
8938 }
8939 m.Namespace = string(dAtA[iNdEx:postIndex])
8940 iNdEx = postIndex
8941 case 2:
8942 if wireType != 2 {
8943 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
8944 }
8945 var stringLen uint64
8946 for shift := uint(0); ; shift += 7 {
8947 if shift >= 64 {
8948 return ErrIntOverflowNetworkconfigproxy
8949 }
8950 if iNdEx >= l {
8951 return io.ErrUnexpectedEOF
8952 }
8953 b := dAtA[iNdEx]
8954 iNdEx++
8955 stringLen |= uint64(b&0x7F) << shift
8956 if b < 0x80 {
8957 break
8958 }
8959 }
8960 intStringLen := int(stringLen)
8961 if intStringLen < 0 {
8962 return ErrInvalidLengthNetworkconfigproxy
8963 }
8964 postIndex := iNdEx + intStringLen
8965 if postIndex < 0 {
8966 return ErrInvalidLengthNetworkconfigproxy
8967 }
8968 if postIndex > l {
8969 return io.ErrUnexpectedEOF
8970 }
8971 m.ID = string(dAtA[iNdEx:postIndex])
8972 iNdEx = postIndex
8973 case 3:
8974 if wireType != 2 {
8975 return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
8976 }
8977 var msglen int
8978 for shift := uint(0); ; shift += 7 {
8979 if shift >= 64 {
8980 return ErrIntOverflowNetworkconfigproxy
8981 }
8982 if iNdEx >= l {
8983 return io.ErrUnexpectedEOF
8984 }
8985 b := dAtA[iNdEx]
8986 iNdEx++
8987 msglen |= int(b&0x7F) << shift
8988 if b < 0x80 {
8989 break
8990 }
8991 }
8992 if msglen < 0 {
8993 return ErrInvalidLengthNetworkconfigproxy
8994 }
8995 postIndex := iNdEx + msglen
8996 if postIndex < 0 {
8997 return ErrInvalidLengthNetworkconfigproxy
8998 }
8999 if postIndex > l {
9000 return io.ErrUnexpectedEOF
9001 }
9002 if m.Endpoint == nil {
9003 m.Endpoint = &EndpointSettings{}
9004 }
9005 if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9006 return err
9007 }
9008 iNdEx = postIndex
9009 default:
9010 iNdEx = preIndex
9011 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9012 if err != nil {
9013 return err
9014 }
9015 if (skippy < 0) || (iNdEx+skippy) < 0 {
9016 return ErrInvalidLengthNetworkconfigproxy
9017 }
9018 if (iNdEx + skippy) > l {
9019 return io.ErrUnexpectedEOF
9020 }
9021 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9022 iNdEx += skippy
9023 }
9024 }
9025
9026 if iNdEx > l {
9027 return io.ErrUnexpectedEOF
9028 }
9029 return nil
9030 }
9031 func (m *GetNetworkRequest) Unmarshal(dAtA []byte) error {
9032 l := len(dAtA)
9033 iNdEx := 0
9034 for iNdEx < l {
9035 preIndex := iNdEx
9036 var wire uint64
9037 for shift := uint(0); ; shift += 7 {
9038 if shift >= 64 {
9039 return ErrIntOverflowNetworkconfigproxy
9040 }
9041 if iNdEx >= l {
9042 return io.ErrUnexpectedEOF
9043 }
9044 b := dAtA[iNdEx]
9045 iNdEx++
9046 wire |= uint64(b&0x7F) << shift
9047 if b < 0x80 {
9048 break
9049 }
9050 }
9051 fieldNum := int32(wire >> 3)
9052 wireType := int(wire & 0x7)
9053 if wireType == 4 {
9054 return fmt.Errorf("proto: GetNetworkRequest: wiretype end group for non-group")
9055 }
9056 if fieldNum <= 0 {
9057 return fmt.Errorf("proto: GetNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
9058 }
9059 switch fieldNum {
9060 case 1:
9061 if wireType != 2 {
9062 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
9063 }
9064 var stringLen uint64
9065 for shift := uint(0); ; shift += 7 {
9066 if shift >= 64 {
9067 return ErrIntOverflowNetworkconfigproxy
9068 }
9069 if iNdEx >= l {
9070 return io.ErrUnexpectedEOF
9071 }
9072 b := dAtA[iNdEx]
9073 iNdEx++
9074 stringLen |= uint64(b&0x7F) << shift
9075 if b < 0x80 {
9076 break
9077 }
9078 }
9079 intStringLen := int(stringLen)
9080 if intStringLen < 0 {
9081 return ErrInvalidLengthNetworkconfigproxy
9082 }
9083 postIndex := iNdEx + intStringLen
9084 if postIndex < 0 {
9085 return ErrInvalidLengthNetworkconfigproxy
9086 }
9087 if postIndex > l {
9088 return io.ErrUnexpectedEOF
9089 }
9090 m.Name = string(dAtA[iNdEx:postIndex])
9091 iNdEx = postIndex
9092 default:
9093 iNdEx = preIndex
9094 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9095 if err != nil {
9096 return err
9097 }
9098 if (skippy < 0) || (iNdEx+skippy) < 0 {
9099 return ErrInvalidLengthNetworkconfigproxy
9100 }
9101 if (iNdEx + skippy) > l {
9102 return io.ErrUnexpectedEOF
9103 }
9104 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9105 iNdEx += skippy
9106 }
9107 }
9108
9109 if iNdEx > l {
9110 return io.ErrUnexpectedEOF
9111 }
9112 return nil
9113 }
9114 func (m *GetNetworkResponse) Unmarshal(dAtA []byte) error {
9115 l := len(dAtA)
9116 iNdEx := 0
9117 for iNdEx < l {
9118 preIndex := iNdEx
9119 var wire uint64
9120 for shift := uint(0); ; shift += 7 {
9121 if shift >= 64 {
9122 return ErrIntOverflowNetworkconfigproxy
9123 }
9124 if iNdEx >= l {
9125 return io.ErrUnexpectedEOF
9126 }
9127 b := dAtA[iNdEx]
9128 iNdEx++
9129 wire |= uint64(b&0x7F) << shift
9130 if b < 0x80 {
9131 break
9132 }
9133 }
9134 fieldNum := int32(wire >> 3)
9135 wireType := int(wire & 0x7)
9136 if wireType == 4 {
9137 return fmt.Errorf("proto: GetNetworkResponse: wiretype end group for non-group")
9138 }
9139 if fieldNum <= 0 {
9140 return fmt.Errorf("proto: GetNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
9141 }
9142 switch fieldNum {
9143 case 1:
9144 if wireType != 2 {
9145 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
9146 }
9147 var stringLen uint64
9148 for shift := uint(0); ; shift += 7 {
9149 if shift >= 64 {
9150 return ErrIntOverflowNetworkconfigproxy
9151 }
9152 if iNdEx >= l {
9153 return io.ErrUnexpectedEOF
9154 }
9155 b := dAtA[iNdEx]
9156 iNdEx++
9157 stringLen |= uint64(b&0x7F) << shift
9158 if b < 0x80 {
9159 break
9160 }
9161 }
9162 intStringLen := int(stringLen)
9163 if intStringLen < 0 {
9164 return ErrInvalidLengthNetworkconfigproxy
9165 }
9166 postIndex := iNdEx + intStringLen
9167 if postIndex < 0 {
9168 return ErrInvalidLengthNetworkconfigproxy
9169 }
9170 if postIndex > l {
9171 return io.ErrUnexpectedEOF
9172 }
9173 m.ID = string(dAtA[iNdEx:postIndex])
9174 iNdEx = postIndex
9175 case 2:
9176 if wireType != 2 {
9177 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
9178 }
9179 var msglen int
9180 for shift := uint(0); ; shift += 7 {
9181 if shift >= 64 {
9182 return ErrIntOverflowNetworkconfigproxy
9183 }
9184 if iNdEx >= l {
9185 return io.ErrUnexpectedEOF
9186 }
9187 b := dAtA[iNdEx]
9188 iNdEx++
9189 msglen |= int(b&0x7F) << shift
9190 if b < 0x80 {
9191 break
9192 }
9193 }
9194 if msglen < 0 {
9195 return ErrInvalidLengthNetworkconfigproxy
9196 }
9197 postIndex := iNdEx + msglen
9198 if postIndex < 0 {
9199 return ErrInvalidLengthNetworkconfigproxy
9200 }
9201 if postIndex > l {
9202 return io.ErrUnexpectedEOF
9203 }
9204 if m.Network == nil {
9205 m.Network = &Network{}
9206 }
9207 if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9208 return err
9209 }
9210 iNdEx = postIndex
9211 case 3:
9212 if wireType != 2 {
9213 return fmt.Errorf("proto: wrong wireType = %d for field MacRange", wireType)
9214 }
9215 var msglen int
9216 for shift := uint(0); ; shift += 7 {
9217 if shift >= 64 {
9218 return ErrIntOverflowNetworkconfigproxy
9219 }
9220 if iNdEx >= l {
9221 return io.ErrUnexpectedEOF
9222 }
9223 b := dAtA[iNdEx]
9224 iNdEx++
9225 msglen |= int(b&0x7F) << shift
9226 if b < 0x80 {
9227 break
9228 }
9229 }
9230 if msglen < 0 {
9231 return ErrInvalidLengthNetworkconfigproxy
9232 }
9233 postIndex := iNdEx + msglen
9234 if postIndex < 0 {
9235 return ErrInvalidLengthNetworkconfigproxy
9236 }
9237 if postIndex > l {
9238 return io.ErrUnexpectedEOF
9239 }
9240 if m.MacRange == nil {
9241 m.MacRange = &MacRange{}
9242 }
9243 if err := m.MacRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9244 return err
9245 }
9246 iNdEx = postIndex
9247 default:
9248 iNdEx = preIndex
9249 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9250 if err != nil {
9251 return err
9252 }
9253 if (skippy < 0) || (iNdEx+skippy) < 0 {
9254 return ErrInvalidLengthNetworkconfigproxy
9255 }
9256 if (iNdEx + skippy) > l {
9257 return io.ErrUnexpectedEOF
9258 }
9259 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9260 iNdEx += skippy
9261 }
9262 }
9263
9264 if iNdEx > l {
9265 return io.ErrUnexpectedEOF
9266 }
9267 return nil
9268 }
9269 func (m *MacRange) Unmarshal(dAtA []byte) error {
9270 l := len(dAtA)
9271 iNdEx := 0
9272 for iNdEx < l {
9273 preIndex := iNdEx
9274 var wire uint64
9275 for shift := uint(0); ; shift += 7 {
9276 if shift >= 64 {
9277 return ErrIntOverflowNetworkconfigproxy
9278 }
9279 if iNdEx >= l {
9280 return io.ErrUnexpectedEOF
9281 }
9282 b := dAtA[iNdEx]
9283 iNdEx++
9284 wire |= uint64(b&0x7F) << shift
9285 if b < 0x80 {
9286 break
9287 }
9288 }
9289 fieldNum := int32(wire >> 3)
9290 wireType := int(wire & 0x7)
9291 if wireType == 4 {
9292 return fmt.Errorf("proto: MacRange: wiretype end group for non-group")
9293 }
9294 if fieldNum <= 0 {
9295 return fmt.Errorf("proto: MacRange: illegal tag %d (wire type %d)", fieldNum, wire)
9296 }
9297 switch fieldNum {
9298 case 1:
9299 if wireType != 2 {
9300 return fmt.Errorf("proto: wrong wireType = %d for field StartMacAddress", wireType)
9301 }
9302 var stringLen uint64
9303 for shift := uint(0); ; shift += 7 {
9304 if shift >= 64 {
9305 return ErrIntOverflowNetworkconfigproxy
9306 }
9307 if iNdEx >= l {
9308 return io.ErrUnexpectedEOF
9309 }
9310 b := dAtA[iNdEx]
9311 iNdEx++
9312 stringLen |= uint64(b&0x7F) << shift
9313 if b < 0x80 {
9314 break
9315 }
9316 }
9317 intStringLen := int(stringLen)
9318 if intStringLen < 0 {
9319 return ErrInvalidLengthNetworkconfigproxy
9320 }
9321 postIndex := iNdEx + intStringLen
9322 if postIndex < 0 {
9323 return ErrInvalidLengthNetworkconfigproxy
9324 }
9325 if postIndex > l {
9326 return io.ErrUnexpectedEOF
9327 }
9328 m.StartMacAddress = string(dAtA[iNdEx:postIndex])
9329 iNdEx = postIndex
9330 case 2:
9331 if wireType != 2 {
9332 return fmt.Errorf("proto: wrong wireType = %d for field EndMacAddress", wireType)
9333 }
9334 var stringLen uint64
9335 for shift := uint(0); ; shift += 7 {
9336 if shift >= 64 {
9337 return ErrIntOverflowNetworkconfigproxy
9338 }
9339 if iNdEx >= l {
9340 return io.ErrUnexpectedEOF
9341 }
9342 b := dAtA[iNdEx]
9343 iNdEx++
9344 stringLen |= uint64(b&0x7F) << shift
9345 if b < 0x80 {
9346 break
9347 }
9348 }
9349 intStringLen := int(stringLen)
9350 if intStringLen < 0 {
9351 return ErrInvalidLengthNetworkconfigproxy
9352 }
9353 postIndex := iNdEx + intStringLen
9354 if postIndex < 0 {
9355 return ErrInvalidLengthNetworkconfigproxy
9356 }
9357 if postIndex > l {
9358 return io.ErrUnexpectedEOF
9359 }
9360 m.EndMacAddress = string(dAtA[iNdEx:postIndex])
9361 iNdEx = postIndex
9362 default:
9363 iNdEx = preIndex
9364 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9365 if err != nil {
9366 return err
9367 }
9368 if (skippy < 0) || (iNdEx+skippy) < 0 {
9369 return ErrInvalidLengthNetworkconfigproxy
9370 }
9371 if (iNdEx + skippy) > l {
9372 return io.ErrUnexpectedEOF
9373 }
9374 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9375 iNdEx += skippy
9376 }
9377 }
9378
9379 if iNdEx > l {
9380 return io.ErrUnexpectedEOF
9381 }
9382 return nil
9383 }
9384 func (m *GetEndpointsRequest) Unmarshal(dAtA []byte) error {
9385 l := len(dAtA)
9386 iNdEx := 0
9387 for iNdEx < l {
9388 preIndex := iNdEx
9389 var wire uint64
9390 for shift := uint(0); ; shift += 7 {
9391 if shift >= 64 {
9392 return ErrIntOverflowNetworkconfigproxy
9393 }
9394 if iNdEx >= l {
9395 return io.ErrUnexpectedEOF
9396 }
9397 b := dAtA[iNdEx]
9398 iNdEx++
9399 wire |= uint64(b&0x7F) << shift
9400 if b < 0x80 {
9401 break
9402 }
9403 }
9404 fieldNum := int32(wire >> 3)
9405 wireType := int(wire & 0x7)
9406 if wireType == 4 {
9407 return fmt.Errorf("proto: GetEndpointsRequest: wiretype end group for non-group")
9408 }
9409 if fieldNum <= 0 {
9410 return fmt.Errorf("proto: GetEndpointsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
9411 }
9412 switch fieldNum {
9413 default:
9414 iNdEx = preIndex
9415 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9416 if err != nil {
9417 return err
9418 }
9419 if (skippy < 0) || (iNdEx+skippy) < 0 {
9420 return ErrInvalidLengthNetworkconfigproxy
9421 }
9422 if (iNdEx + skippy) > l {
9423 return io.ErrUnexpectedEOF
9424 }
9425 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9426 iNdEx += skippy
9427 }
9428 }
9429
9430 if iNdEx > l {
9431 return io.ErrUnexpectedEOF
9432 }
9433 return nil
9434 }
9435 func (m *GetEndpointsResponse) Unmarshal(dAtA []byte) error {
9436 l := len(dAtA)
9437 iNdEx := 0
9438 for iNdEx < l {
9439 preIndex := iNdEx
9440 var wire uint64
9441 for shift := uint(0); ; shift += 7 {
9442 if shift >= 64 {
9443 return ErrIntOverflowNetworkconfigproxy
9444 }
9445 if iNdEx >= l {
9446 return io.ErrUnexpectedEOF
9447 }
9448 b := dAtA[iNdEx]
9449 iNdEx++
9450 wire |= uint64(b&0x7F) << shift
9451 if b < 0x80 {
9452 break
9453 }
9454 }
9455 fieldNum := int32(wire >> 3)
9456 wireType := int(wire & 0x7)
9457 if wireType == 4 {
9458 return fmt.Errorf("proto: GetEndpointsResponse: wiretype end group for non-group")
9459 }
9460 if fieldNum <= 0 {
9461 return fmt.Errorf("proto: GetEndpointsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
9462 }
9463 switch fieldNum {
9464 case 1:
9465 if wireType != 2 {
9466 return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType)
9467 }
9468 var msglen int
9469 for shift := uint(0); ; shift += 7 {
9470 if shift >= 64 {
9471 return ErrIntOverflowNetworkconfigproxy
9472 }
9473 if iNdEx >= l {
9474 return io.ErrUnexpectedEOF
9475 }
9476 b := dAtA[iNdEx]
9477 iNdEx++
9478 msglen |= int(b&0x7F) << shift
9479 if b < 0x80 {
9480 break
9481 }
9482 }
9483 if msglen < 0 {
9484 return ErrInvalidLengthNetworkconfigproxy
9485 }
9486 postIndex := iNdEx + msglen
9487 if postIndex < 0 {
9488 return ErrInvalidLengthNetworkconfigproxy
9489 }
9490 if postIndex > l {
9491 return io.ErrUnexpectedEOF
9492 }
9493 m.Endpoints = append(m.Endpoints, &GetEndpointResponse{})
9494 if err := m.Endpoints[len(m.Endpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9495 return err
9496 }
9497 iNdEx = postIndex
9498 default:
9499 iNdEx = preIndex
9500 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9501 if err != nil {
9502 return err
9503 }
9504 if (skippy < 0) || (iNdEx+skippy) < 0 {
9505 return ErrInvalidLengthNetworkconfigproxy
9506 }
9507 if (iNdEx + skippy) > l {
9508 return io.ErrUnexpectedEOF
9509 }
9510 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9511 iNdEx += skippy
9512 }
9513 }
9514
9515 if iNdEx > l {
9516 return io.ErrUnexpectedEOF
9517 }
9518 return nil
9519 }
9520 func (m *GetNetworksRequest) Unmarshal(dAtA []byte) error {
9521 l := len(dAtA)
9522 iNdEx := 0
9523 for iNdEx < l {
9524 preIndex := iNdEx
9525 var wire uint64
9526 for shift := uint(0); ; shift += 7 {
9527 if shift >= 64 {
9528 return ErrIntOverflowNetworkconfigproxy
9529 }
9530 if iNdEx >= l {
9531 return io.ErrUnexpectedEOF
9532 }
9533 b := dAtA[iNdEx]
9534 iNdEx++
9535 wire |= uint64(b&0x7F) << shift
9536 if b < 0x80 {
9537 break
9538 }
9539 }
9540 fieldNum := int32(wire >> 3)
9541 wireType := int(wire & 0x7)
9542 if wireType == 4 {
9543 return fmt.Errorf("proto: GetNetworksRequest: wiretype end group for non-group")
9544 }
9545 if fieldNum <= 0 {
9546 return fmt.Errorf("proto: GetNetworksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
9547 }
9548 switch fieldNum {
9549 default:
9550 iNdEx = preIndex
9551 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9552 if err != nil {
9553 return err
9554 }
9555 if (skippy < 0) || (iNdEx+skippy) < 0 {
9556 return ErrInvalidLengthNetworkconfigproxy
9557 }
9558 if (iNdEx + skippy) > l {
9559 return io.ErrUnexpectedEOF
9560 }
9561 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9562 iNdEx += skippy
9563 }
9564 }
9565
9566 if iNdEx > l {
9567 return io.ErrUnexpectedEOF
9568 }
9569 return nil
9570 }
9571 func (m *GetNetworksResponse) Unmarshal(dAtA []byte) error {
9572 l := len(dAtA)
9573 iNdEx := 0
9574 for iNdEx < l {
9575 preIndex := iNdEx
9576 var wire uint64
9577 for shift := uint(0); ; shift += 7 {
9578 if shift >= 64 {
9579 return ErrIntOverflowNetworkconfigproxy
9580 }
9581 if iNdEx >= l {
9582 return io.ErrUnexpectedEOF
9583 }
9584 b := dAtA[iNdEx]
9585 iNdEx++
9586 wire |= uint64(b&0x7F) << shift
9587 if b < 0x80 {
9588 break
9589 }
9590 }
9591 fieldNum := int32(wire >> 3)
9592 wireType := int(wire & 0x7)
9593 if wireType == 4 {
9594 return fmt.Errorf("proto: GetNetworksResponse: wiretype end group for non-group")
9595 }
9596 if fieldNum <= 0 {
9597 return fmt.Errorf("proto: GetNetworksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
9598 }
9599 switch fieldNum {
9600 case 1:
9601 if wireType != 2 {
9602 return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
9603 }
9604 var msglen int
9605 for shift := uint(0); ; shift += 7 {
9606 if shift >= 64 {
9607 return ErrIntOverflowNetworkconfigproxy
9608 }
9609 if iNdEx >= l {
9610 return io.ErrUnexpectedEOF
9611 }
9612 b := dAtA[iNdEx]
9613 iNdEx++
9614 msglen |= int(b&0x7F) << shift
9615 if b < 0x80 {
9616 break
9617 }
9618 }
9619 if msglen < 0 {
9620 return ErrInvalidLengthNetworkconfigproxy
9621 }
9622 postIndex := iNdEx + msglen
9623 if postIndex < 0 {
9624 return ErrInvalidLengthNetworkconfigproxy
9625 }
9626 if postIndex > l {
9627 return io.ErrUnexpectedEOF
9628 }
9629 m.Networks = append(m.Networks, &GetNetworkResponse{})
9630 if err := m.Networks[len(m.Networks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9631 return err
9632 }
9633 iNdEx = postIndex
9634 default:
9635 iNdEx = preIndex
9636 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
9637 if err != nil {
9638 return err
9639 }
9640 if (skippy < 0) || (iNdEx+skippy) < 0 {
9641 return ErrInvalidLengthNetworkconfigproxy
9642 }
9643 if (iNdEx + skippy) > l {
9644 return io.ErrUnexpectedEOF
9645 }
9646 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9647 iNdEx += skippy
9648 }
9649 }
9650
9651 if iNdEx > l {
9652 return io.ErrUnexpectedEOF
9653 }
9654 return nil
9655 }
9656 func skipNetworkconfigproxy(dAtA []byte) (n int, err error) {
9657 l := len(dAtA)
9658 iNdEx := 0
9659 depth := 0
9660 for iNdEx < l {
9661 var wire uint64
9662 for shift := uint(0); ; shift += 7 {
9663 if shift >= 64 {
9664 return 0, ErrIntOverflowNetworkconfigproxy
9665 }
9666 if iNdEx >= l {
9667 return 0, io.ErrUnexpectedEOF
9668 }
9669 b := dAtA[iNdEx]
9670 iNdEx++
9671 wire |= (uint64(b) & 0x7F) << shift
9672 if b < 0x80 {
9673 break
9674 }
9675 }
9676 wireType := int(wire & 0x7)
9677 switch wireType {
9678 case 0:
9679 for shift := uint(0); ; shift += 7 {
9680 if shift >= 64 {
9681 return 0, ErrIntOverflowNetworkconfigproxy
9682 }
9683 if iNdEx >= l {
9684 return 0, io.ErrUnexpectedEOF
9685 }
9686 iNdEx++
9687 if dAtA[iNdEx-1] < 0x80 {
9688 break
9689 }
9690 }
9691 case 1:
9692 iNdEx += 8
9693 case 2:
9694 var length int
9695 for shift := uint(0); ; shift += 7 {
9696 if shift >= 64 {
9697 return 0, ErrIntOverflowNetworkconfigproxy
9698 }
9699 if iNdEx >= l {
9700 return 0, io.ErrUnexpectedEOF
9701 }
9702 b := dAtA[iNdEx]
9703 iNdEx++
9704 length |= (int(b) & 0x7F) << shift
9705 if b < 0x80 {
9706 break
9707 }
9708 }
9709 if length < 0 {
9710 return 0, ErrInvalidLengthNetworkconfigproxy
9711 }
9712 iNdEx += length
9713 case 3:
9714 depth++
9715 case 4:
9716 if depth == 0 {
9717 return 0, ErrUnexpectedEndOfGroupNetworkconfigproxy
9718 }
9719 depth--
9720 case 5:
9721 iNdEx += 4
9722 default:
9723 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
9724 }
9725 if iNdEx < 0 {
9726 return 0, ErrInvalidLengthNetworkconfigproxy
9727 }
9728 if depth == 0 {
9729 return iNdEx, nil
9730 }
9731 }
9732 return 0, io.ErrUnexpectedEOF
9733 }
9734
9735 var (
9736 ErrInvalidLengthNetworkconfigproxy = fmt.Errorf("proto: negative length found during unmarshaling")
9737 ErrIntOverflowNetworkconfigproxy = fmt.Errorf("proto: integer overflow")
9738 ErrUnexpectedEndOfGroupNetworkconfigproxy = fmt.Errorf("proto: unexpected end of group")
9739 )
9740
View as plain text