github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/p2p/pex.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/p2p/pex.proto 3 4 package p2p 5 6 import ( 7 fmt "fmt" 8 _ "github.com/gogo/protobuf/gogoproto" 9 proto "github.com/gogo/protobuf/proto" 10 io "io" 11 math "math" 12 math_bits "math/bits" 13 ) 14 15 // Reference imports to suppress errors if they are not otherwise used. 16 var _ = proto.Marshal 17 var _ = fmt.Errorf 18 var _ = math.Inf 19 20 // This is a compile-time assertion to ensure that this generated file 21 // is compatible with the proto package it is being compiled against. 22 // A compilation error at this line likely means your copy of the 23 // proto package needs to be updated. 24 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 25 26 type PexRequest struct { 27 } 28 29 func (m *PexRequest) Reset() { *m = PexRequest{} } 30 func (m *PexRequest) String() string { return proto.CompactTextString(m) } 31 func (*PexRequest) ProtoMessage() {} 32 func (*PexRequest) Descriptor() ([]byte, []int) { 33 return fileDescriptor_81c2f011fd13be57, []int{0} 34 } 35 func (m *PexRequest) XXX_Unmarshal(b []byte) error { 36 return m.Unmarshal(b) 37 } 38 func (m *PexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 39 if deterministic { 40 return xxx_messageInfo_PexRequest.Marshal(b, m, deterministic) 41 } else { 42 b = b[:cap(b)] 43 n, err := m.MarshalToSizedBuffer(b) 44 if err != nil { 45 return nil, err 46 } 47 return b[:n], nil 48 } 49 } 50 func (m *PexRequest) XXX_Merge(src proto.Message) { 51 xxx_messageInfo_PexRequest.Merge(m, src) 52 } 53 func (m *PexRequest) XXX_Size() int { 54 return m.Size() 55 } 56 func (m *PexRequest) XXX_DiscardUnknown() { 57 xxx_messageInfo_PexRequest.DiscardUnknown(m) 58 } 59 60 var xxx_messageInfo_PexRequest proto.InternalMessageInfo 61 62 type PexAddrs struct { 63 Addrs []NetAddress `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs"` 64 } 65 66 func (m *PexAddrs) Reset() { *m = PexAddrs{} } 67 func (m *PexAddrs) String() string { return proto.CompactTextString(m) } 68 func (*PexAddrs) ProtoMessage() {} 69 func (*PexAddrs) Descriptor() ([]byte, []int) { 70 return fileDescriptor_81c2f011fd13be57, []int{1} 71 } 72 func (m *PexAddrs) XXX_Unmarshal(b []byte) error { 73 return m.Unmarshal(b) 74 } 75 func (m *PexAddrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 76 if deterministic { 77 return xxx_messageInfo_PexAddrs.Marshal(b, m, deterministic) 78 } else { 79 b = b[:cap(b)] 80 n, err := m.MarshalToSizedBuffer(b) 81 if err != nil { 82 return nil, err 83 } 84 return b[:n], nil 85 } 86 } 87 func (m *PexAddrs) XXX_Merge(src proto.Message) { 88 xxx_messageInfo_PexAddrs.Merge(m, src) 89 } 90 func (m *PexAddrs) XXX_Size() int { 91 return m.Size() 92 } 93 func (m *PexAddrs) XXX_DiscardUnknown() { 94 xxx_messageInfo_PexAddrs.DiscardUnknown(m) 95 } 96 97 var xxx_messageInfo_PexAddrs proto.InternalMessageInfo 98 99 func (m *PexAddrs) GetAddrs() []NetAddress { 100 if m != nil { 101 return m.Addrs 102 } 103 return nil 104 } 105 106 type Message struct { 107 // Types that are valid to be assigned to Sum: 108 // *Message_PexRequest 109 // *Message_PexAddrs 110 Sum isMessage_Sum `protobuf_oneof:"sum"` 111 } 112 113 func (m *Message) Reset() { *m = Message{} } 114 func (m *Message) String() string { return proto.CompactTextString(m) } 115 func (*Message) ProtoMessage() {} 116 func (*Message) Descriptor() ([]byte, []int) { 117 return fileDescriptor_81c2f011fd13be57, []int{2} 118 } 119 func (m *Message) XXX_Unmarshal(b []byte) error { 120 return m.Unmarshal(b) 121 } 122 func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 123 if deterministic { 124 return xxx_messageInfo_Message.Marshal(b, m, deterministic) 125 } else { 126 b = b[:cap(b)] 127 n, err := m.MarshalToSizedBuffer(b) 128 if err != nil { 129 return nil, err 130 } 131 return b[:n], nil 132 } 133 } 134 func (m *Message) XXX_Merge(src proto.Message) { 135 xxx_messageInfo_Message.Merge(m, src) 136 } 137 func (m *Message) XXX_Size() int { 138 return m.Size() 139 } 140 func (m *Message) XXX_DiscardUnknown() { 141 xxx_messageInfo_Message.DiscardUnknown(m) 142 } 143 144 var xxx_messageInfo_Message proto.InternalMessageInfo 145 146 type isMessage_Sum interface { 147 isMessage_Sum() 148 MarshalTo([]byte) (int, error) 149 Size() int 150 } 151 152 type Message_PexRequest struct { 153 PexRequest *PexRequest `protobuf:"bytes,1,opt,name=pex_request,json=pexRequest,proto3,oneof" json:"pex_request,omitempty"` 154 } 155 type Message_PexAddrs struct { 156 PexAddrs *PexAddrs `protobuf:"bytes,2,opt,name=pex_addrs,json=pexAddrs,proto3,oneof" json:"pex_addrs,omitempty"` 157 } 158 159 func (*Message_PexRequest) isMessage_Sum() {} 160 func (*Message_PexAddrs) isMessage_Sum() {} 161 162 func (m *Message) GetSum() isMessage_Sum { 163 if m != nil { 164 return m.Sum 165 } 166 return nil 167 } 168 169 func (m *Message) GetPexRequest() *PexRequest { 170 if x, ok := m.GetSum().(*Message_PexRequest); ok { 171 return x.PexRequest 172 } 173 return nil 174 } 175 176 func (m *Message) GetPexAddrs() *PexAddrs { 177 if x, ok := m.GetSum().(*Message_PexAddrs); ok { 178 return x.PexAddrs 179 } 180 return nil 181 } 182 183 // XXX_OneofWrappers is for the internal use of the proto package. 184 func (*Message) XXX_OneofWrappers() []interface{} { 185 return []interface{}{ 186 (*Message_PexRequest)(nil), 187 (*Message_PexAddrs)(nil), 188 } 189 } 190 191 func init() { 192 proto.RegisterType((*PexRequest)(nil), "tendermint.p2p.PexRequest") 193 proto.RegisterType((*PexAddrs)(nil), "tendermint.p2p.PexAddrs") 194 proto.RegisterType((*Message)(nil), "tendermint.p2p.Message") 195 } 196 197 func init() { proto.RegisterFile("tendermint/p2p/pex.proto", fileDescriptor_81c2f011fd13be57) } 198 199 var fileDescriptor_81c2f011fd13be57 = []byte{ 200 // 293 bytes of a gzipped FileDescriptorProto 201 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xbd, 0x4e, 0xc3, 0x30, 202 0x14, 0x85, 0x6d, 0x4a, 0xa1, 0xb8, 0x88, 0x21, 0x62, 0x88, 0x32, 0x98, 0x2a, 0x13, 0x53, 0x2c, 203 0xa5, 0x08, 0x26, 0x06, 0xc2, 0x92, 0x05, 0x54, 0x45, 0x4c, 0x2c, 0x28, 0x3f, 0x57, 0x69, 0x86, 204 0xc4, 0xc6, 0x76, 0xa4, 0xf4, 0x0d, 0x18, 0x79, 0xac, 0x8e, 0x1d, 0x99, 0x10, 0x4a, 0x5e, 0x04, 205 0x25, 0x46, 0xad, 0x8a, 0xba, 0x1d, 0x5f, 0x7f, 0xe7, 0xdc, 0xa3, 0x4b, 0x6c, 0x0d, 0x55, 0x06, 206 0xb2, 0x2c, 0x2a, 0xcd, 0x84, 0x2f, 0x98, 0x80, 0xc6, 0x13, 0x92, 0x6b, 0x6e, 0x5d, 0xec, 0x7e, 207 0x3c, 0xe1, 0x0b, 0xc7, 0xf9, 0x47, 0xea, 0x95, 0x00, 0x65, 0x58, 0xe7, 0x32, 0xe7, 0x39, 0x1f, 208 0x24, 0xeb, 0x95, 0x99, 0xba, 0xe7, 0x84, 0x2c, 0xa0, 0x89, 0xe0, 0xbd, 0x06, 0xa5, 0xdd, 0x80, 209 0x4c, 0x16, 0xd0, 0x3c, 0x64, 0x99, 0x54, 0xd6, 0x2d, 0x19, 0xc7, 0xbd, 0xb0, 0xf1, 0x6c, 0x74, 210 0x3d, 0xf5, 0x1d, 0x6f, 0x7f, 0x97, 0xf7, 0x0c, 0xba, 0x07, 0x41, 0xa9, 0xe0, 0x78, 0xfd, 0x7d, 211 0x85, 0x22, 0x83, 0xbb, 0x1f, 0x98, 0x9c, 0x3e, 0x81, 0x52, 0x71, 0x0e, 0xd6, 0x3d, 0x99, 0x0a, 212 0x68, 0xde, 0xa4, 0x89, 0xb7, 0xf1, 0x0c, 0x1f, 0x4a, 0xda, 0x15, 0x08, 0x51, 0x44, 0xc4, 0xf6, 213 0x65, 0xdd, 0x91, 0xb3, 0xde, 0x6e, 0x6a, 0x1c, 0x0d, 0x66, 0xfb, 0x80, 0x79, 0xe8, 0x1b, 0xa2, 214 0x68, 0x22, 0xfe, 0x74, 0x30, 0x26, 0x23, 0x55, 0x97, 0x41, 0xb2, 0x6e, 0x29, 0xde, 0xb4, 0x14, 215 0xff, 0xb4, 0x14, 0x7f, 0x76, 0x14, 0x6d, 0x3a, 0x8a, 0xbe, 0x3a, 0x8a, 0x5e, 0xc3, 0xbc, 0xd0, 216 0xcb, 0x3a, 0xf1, 0x52, 0x5e, 0x32, 0x55, 0x0b, 0x19, 0xe7, 0xab, 0x98, 0xbd, 0x6c, 0x93, 0x1f, 217 0x79, 0x55, 0x41, 0xaa, 0xb9, 0x64, 0xe9, 0x32, 0x2e, 0x2a, 0xc5, 0x74, 0x39, 0xbf, 0x61, 0xe6, 218 0x78, 0xfb, 0x27, 0x4e, 0x4e, 0x86, 0xe9, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x6d, 0xdd, 0xc9, 219 0x51, 0xa5, 0x01, 0x00, 0x00, 220 } 221 222 func (m *PexRequest) Marshal() (dAtA []byte, err error) { 223 size := m.Size() 224 dAtA = make([]byte, size) 225 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 226 if err != nil { 227 return nil, err 228 } 229 return dAtA[:n], nil 230 } 231 232 func (m *PexRequest) MarshalTo(dAtA []byte) (int, error) { 233 size := m.Size() 234 return m.MarshalToSizedBuffer(dAtA[:size]) 235 } 236 237 func (m *PexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 238 i := len(dAtA) 239 _ = i 240 var l int 241 _ = l 242 return len(dAtA) - i, nil 243 } 244 245 func (m *PexAddrs) Marshal() (dAtA []byte, err error) { 246 size := m.Size() 247 dAtA = make([]byte, size) 248 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 249 if err != nil { 250 return nil, err 251 } 252 return dAtA[:n], nil 253 } 254 255 func (m *PexAddrs) MarshalTo(dAtA []byte) (int, error) { 256 size := m.Size() 257 return m.MarshalToSizedBuffer(dAtA[:size]) 258 } 259 260 func (m *PexAddrs) MarshalToSizedBuffer(dAtA []byte) (int, error) { 261 i := len(dAtA) 262 _ = i 263 var l int 264 _ = l 265 if len(m.Addrs) > 0 { 266 for iNdEx := len(m.Addrs) - 1; iNdEx >= 0; iNdEx-- { 267 { 268 size, err := m.Addrs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 269 if err != nil { 270 return 0, err 271 } 272 i -= size 273 i = encodeVarintPex(dAtA, i, uint64(size)) 274 } 275 i-- 276 dAtA[i] = 0xa 277 } 278 } 279 return len(dAtA) - i, nil 280 } 281 282 func (m *Message) Marshal() (dAtA []byte, err error) { 283 size := m.Size() 284 dAtA = make([]byte, size) 285 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 286 if err != nil { 287 return nil, err 288 } 289 return dAtA[:n], nil 290 } 291 292 func (m *Message) MarshalTo(dAtA []byte) (int, error) { 293 size := m.Size() 294 return m.MarshalToSizedBuffer(dAtA[:size]) 295 } 296 297 func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) { 298 i := len(dAtA) 299 _ = i 300 var l int 301 _ = l 302 if m.Sum != nil { 303 { 304 size := m.Sum.Size() 305 i -= size 306 if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil { 307 return 0, err 308 } 309 } 310 } 311 return len(dAtA) - i, nil 312 } 313 314 func (m *Message_PexRequest) MarshalTo(dAtA []byte) (int, error) { 315 size := m.Size() 316 return m.MarshalToSizedBuffer(dAtA[:size]) 317 } 318 319 func (m *Message_PexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 320 i := len(dAtA) 321 if m.PexRequest != nil { 322 { 323 size, err := m.PexRequest.MarshalToSizedBuffer(dAtA[:i]) 324 if err != nil { 325 return 0, err 326 } 327 i -= size 328 i = encodeVarintPex(dAtA, i, uint64(size)) 329 } 330 i-- 331 dAtA[i] = 0xa 332 } 333 return len(dAtA) - i, nil 334 } 335 func (m *Message_PexAddrs) MarshalTo(dAtA []byte) (int, error) { 336 size := m.Size() 337 return m.MarshalToSizedBuffer(dAtA[:size]) 338 } 339 340 func (m *Message_PexAddrs) MarshalToSizedBuffer(dAtA []byte) (int, error) { 341 i := len(dAtA) 342 if m.PexAddrs != nil { 343 { 344 size, err := m.PexAddrs.MarshalToSizedBuffer(dAtA[:i]) 345 if err != nil { 346 return 0, err 347 } 348 i -= size 349 i = encodeVarintPex(dAtA, i, uint64(size)) 350 } 351 i-- 352 dAtA[i] = 0x12 353 } 354 return len(dAtA) - i, nil 355 } 356 func encodeVarintPex(dAtA []byte, offset int, v uint64) int { 357 offset -= sovPex(v) 358 base := offset 359 for v >= 1<<7 { 360 dAtA[offset] = uint8(v&0x7f | 0x80) 361 v >>= 7 362 offset++ 363 } 364 dAtA[offset] = uint8(v) 365 return base 366 } 367 func (m *PexRequest) Size() (n int) { 368 if m == nil { 369 return 0 370 } 371 var l int 372 _ = l 373 return n 374 } 375 376 func (m *PexAddrs) Size() (n int) { 377 if m == nil { 378 return 0 379 } 380 var l int 381 _ = l 382 if len(m.Addrs) > 0 { 383 for _, e := range m.Addrs { 384 l = e.Size() 385 n += 1 + l + sovPex(uint64(l)) 386 } 387 } 388 return n 389 } 390 391 func (m *Message) Size() (n int) { 392 if m == nil { 393 return 0 394 } 395 var l int 396 _ = l 397 if m.Sum != nil { 398 n += m.Sum.Size() 399 } 400 return n 401 } 402 403 func (m *Message_PexRequest) Size() (n int) { 404 if m == nil { 405 return 0 406 } 407 var l int 408 _ = l 409 if m.PexRequest != nil { 410 l = m.PexRequest.Size() 411 n += 1 + l + sovPex(uint64(l)) 412 } 413 return n 414 } 415 func (m *Message_PexAddrs) Size() (n int) { 416 if m == nil { 417 return 0 418 } 419 var l int 420 _ = l 421 if m.PexAddrs != nil { 422 l = m.PexAddrs.Size() 423 n += 1 + l + sovPex(uint64(l)) 424 } 425 return n 426 } 427 428 func sovPex(x uint64) (n int) { 429 return (math_bits.Len64(x|1) + 6) / 7 430 } 431 func sozPex(x uint64) (n int) { 432 return sovPex(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 433 } 434 func (m *PexRequest) Unmarshal(dAtA []byte) error { 435 l := len(dAtA) 436 iNdEx := 0 437 for iNdEx < l { 438 preIndex := iNdEx 439 var wire uint64 440 for shift := uint(0); ; shift += 7 { 441 if shift >= 64 { 442 return ErrIntOverflowPex 443 } 444 if iNdEx >= l { 445 return io.ErrUnexpectedEOF 446 } 447 b := dAtA[iNdEx] 448 iNdEx++ 449 wire |= uint64(b&0x7F) << shift 450 if b < 0x80 { 451 break 452 } 453 } 454 fieldNum := int32(wire >> 3) 455 wireType := int(wire & 0x7) 456 if wireType == 4 { 457 return fmt.Errorf("proto: PexRequest: wiretype end group for non-group") 458 } 459 if fieldNum <= 0 { 460 return fmt.Errorf("proto: PexRequest: illegal tag %d (wire type %d)", fieldNum, wire) 461 } 462 switch fieldNum { 463 default: 464 iNdEx = preIndex 465 skippy, err := skipPex(dAtA[iNdEx:]) 466 if err != nil { 467 return err 468 } 469 if (skippy < 0) || (iNdEx+skippy) < 0 { 470 return ErrInvalidLengthPex 471 } 472 if (iNdEx + skippy) > l { 473 return io.ErrUnexpectedEOF 474 } 475 iNdEx += skippy 476 } 477 } 478 479 if iNdEx > l { 480 return io.ErrUnexpectedEOF 481 } 482 return nil 483 } 484 func (m *PexAddrs) Unmarshal(dAtA []byte) error { 485 l := len(dAtA) 486 iNdEx := 0 487 for iNdEx < l { 488 preIndex := iNdEx 489 var wire uint64 490 for shift := uint(0); ; shift += 7 { 491 if shift >= 64 { 492 return ErrIntOverflowPex 493 } 494 if iNdEx >= l { 495 return io.ErrUnexpectedEOF 496 } 497 b := dAtA[iNdEx] 498 iNdEx++ 499 wire |= uint64(b&0x7F) << shift 500 if b < 0x80 { 501 break 502 } 503 } 504 fieldNum := int32(wire >> 3) 505 wireType := int(wire & 0x7) 506 if wireType == 4 { 507 return fmt.Errorf("proto: PexAddrs: wiretype end group for non-group") 508 } 509 if fieldNum <= 0 { 510 return fmt.Errorf("proto: PexAddrs: illegal tag %d (wire type %d)", fieldNum, wire) 511 } 512 switch fieldNum { 513 case 1: 514 if wireType != 2 { 515 return fmt.Errorf("proto: wrong wireType = %d for field Addrs", wireType) 516 } 517 var msglen int 518 for shift := uint(0); ; shift += 7 { 519 if shift >= 64 { 520 return ErrIntOverflowPex 521 } 522 if iNdEx >= l { 523 return io.ErrUnexpectedEOF 524 } 525 b := dAtA[iNdEx] 526 iNdEx++ 527 msglen |= int(b&0x7F) << shift 528 if b < 0x80 { 529 break 530 } 531 } 532 if msglen < 0 { 533 return ErrInvalidLengthPex 534 } 535 postIndex := iNdEx + msglen 536 if postIndex < 0 { 537 return ErrInvalidLengthPex 538 } 539 if postIndex > l { 540 return io.ErrUnexpectedEOF 541 } 542 m.Addrs = append(m.Addrs, NetAddress{}) 543 if err := m.Addrs[len(m.Addrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 544 return err 545 } 546 iNdEx = postIndex 547 default: 548 iNdEx = preIndex 549 skippy, err := skipPex(dAtA[iNdEx:]) 550 if err != nil { 551 return err 552 } 553 if (skippy < 0) || (iNdEx+skippy) < 0 { 554 return ErrInvalidLengthPex 555 } 556 if (iNdEx + skippy) > l { 557 return io.ErrUnexpectedEOF 558 } 559 iNdEx += skippy 560 } 561 } 562 563 if iNdEx > l { 564 return io.ErrUnexpectedEOF 565 } 566 return nil 567 } 568 func (m *Message) Unmarshal(dAtA []byte) error { 569 l := len(dAtA) 570 iNdEx := 0 571 for iNdEx < l { 572 preIndex := iNdEx 573 var wire uint64 574 for shift := uint(0); ; shift += 7 { 575 if shift >= 64 { 576 return ErrIntOverflowPex 577 } 578 if iNdEx >= l { 579 return io.ErrUnexpectedEOF 580 } 581 b := dAtA[iNdEx] 582 iNdEx++ 583 wire |= uint64(b&0x7F) << shift 584 if b < 0x80 { 585 break 586 } 587 } 588 fieldNum := int32(wire >> 3) 589 wireType := int(wire & 0x7) 590 if wireType == 4 { 591 return fmt.Errorf("proto: Message: wiretype end group for non-group") 592 } 593 if fieldNum <= 0 { 594 return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) 595 } 596 switch fieldNum { 597 case 1: 598 if wireType != 2 { 599 return fmt.Errorf("proto: wrong wireType = %d for field PexRequest", wireType) 600 } 601 var msglen int 602 for shift := uint(0); ; shift += 7 { 603 if shift >= 64 { 604 return ErrIntOverflowPex 605 } 606 if iNdEx >= l { 607 return io.ErrUnexpectedEOF 608 } 609 b := dAtA[iNdEx] 610 iNdEx++ 611 msglen |= int(b&0x7F) << shift 612 if b < 0x80 { 613 break 614 } 615 } 616 if msglen < 0 { 617 return ErrInvalidLengthPex 618 } 619 postIndex := iNdEx + msglen 620 if postIndex < 0 { 621 return ErrInvalidLengthPex 622 } 623 if postIndex > l { 624 return io.ErrUnexpectedEOF 625 } 626 v := &PexRequest{} 627 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 628 return err 629 } 630 m.Sum = &Message_PexRequest{v} 631 iNdEx = postIndex 632 case 2: 633 if wireType != 2 { 634 return fmt.Errorf("proto: wrong wireType = %d for field PexAddrs", wireType) 635 } 636 var msglen int 637 for shift := uint(0); ; shift += 7 { 638 if shift >= 64 { 639 return ErrIntOverflowPex 640 } 641 if iNdEx >= l { 642 return io.ErrUnexpectedEOF 643 } 644 b := dAtA[iNdEx] 645 iNdEx++ 646 msglen |= int(b&0x7F) << shift 647 if b < 0x80 { 648 break 649 } 650 } 651 if msglen < 0 { 652 return ErrInvalidLengthPex 653 } 654 postIndex := iNdEx + msglen 655 if postIndex < 0 { 656 return ErrInvalidLengthPex 657 } 658 if postIndex > l { 659 return io.ErrUnexpectedEOF 660 } 661 v := &PexAddrs{} 662 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 663 return err 664 } 665 m.Sum = &Message_PexAddrs{v} 666 iNdEx = postIndex 667 default: 668 iNdEx = preIndex 669 skippy, err := skipPex(dAtA[iNdEx:]) 670 if err != nil { 671 return err 672 } 673 if (skippy < 0) || (iNdEx+skippy) < 0 { 674 return ErrInvalidLengthPex 675 } 676 if (iNdEx + skippy) > l { 677 return io.ErrUnexpectedEOF 678 } 679 iNdEx += skippy 680 } 681 } 682 683 if iNdEx > l { 684 return io.ErrUnexpectedEOF 685 } 686 return nil 687 } 688 func skipPex(dAtA []byte) (n int, err error) { 689 l := len(dAtA) 690 iNdEx := 0 691 depth := 0 692 for iNdEx < l { 693 var wire uint64 694 for shift := uint(0); ; shift += 7 { 695 if shift >= 64 { 696 return 0, ErrIntOverflowPex 697 } 698 if iNdEx >= l { 699 return 0, io.ErrUnexpectedEOF 700 } 701 b := dAtA[iNdEx] 702 iNdEx++ 703 wire |= (uint64(b) & 0x7F) << shift 704 if b < 0x80 { 705 break 706 } 707 } 708 wireType := int(wire & 0x7) 709 switch wireType { 710 case 0: 711 for shift := uint(0); ; shift += 7 { 712 if shift >= 64 { 713 return 0, ErrIntOverflowPex 714 } 715 if iNdEx >= l { 716 return 0, io.ErrUnexpectedEOF 717 } 718 iNdEx++ 719 if dAtA[iNdEx-1] < 0x80 { 720 break 721 } 722 } 723 case 1: 724 iNdEx += 8 725 case 2: 726 var length int 727 for shift := uint(0); ; shift += 7 { 728 if shift >= 64 { 729 return 0, ErrIntOverflowPex 730 } 731 if iNdEx >= l { 732 return 0, io.ErrUnexpectedEOF 733 } 734 b := dAtA[iNdEx] 735 iNdEx++ 736 length |= (int(b) & 0x7F) << shift 737 if b < 0x80 { 738 break 739 } 740 } 741 if length < 0 { 742 return 0, ErrInvalidLengthPex 743 } 744 iNdEx += length 745 case 3: 746 depth++ 747 case 4: 748 if depth == 0 { 749 return 0, ErrUnexpectedEndOfGroupPex 750 } 751 depth-- 752 case 5: 753 iNdEx += 4 754 default: 755 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 756 } 757 if iNdEx < 0 { 758 return 0, ErrInvalidLengthPex 759 } 760 if depth == 0 { 761 return iNdEx, nil 762 } 763 } 764 return 0, io.ErrUnexpectedEOF 765 } 766 767 var ( 768 ErrInvalidLengthPex = fmt.Errorf("proto: negative length found during unmarshaling") 769 ErrIntOverflowPex = fmt.Errorf("proto: integer overflow") 770 ErrUnexpectedEndOfGroupPex = fmt.Errorf("proto: unexpected end of group") 771 )