github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/p2p/conn.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/p2p/conn.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 crypto "github.com/supragya/TendermintConnector/chains/tm34/proto/tendermint/crypto" 11 io "io" 12 math "math" 13 math_bits "math/bits" 14 ) 15 16 // Reference imports to suppress errors if they are not otherwise used. 17 var _ = proto.Marshal 18 var _ = fmt.Errorf 19 var _ = math.Inf 20 21 // This is a compile-time assertion to ensure that this generated file 22 // is compatible with the proto package it is being compiled against. 23 // A compilation error at this line likely means your copy of the 24 // proto package needs to be updated. 25 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 26 27 type PacketPing struct { 28 } 29 30 func (m *PacketPing) Reset() { *m = PacketPing{} } 31 func (m *PacketPing) String() string { return proto.CompactTextString(m) } 32 func (*PacketPing) ProtoMessage() {} 33 func (*PacketPing) Descriptor() ([]byte, []int) { 34 return fileDescriptor_22474b5527c8fa9f, []int{0} 35 } 36 func (m *PacketPing) XXX_Unmarshal(b []byte) error { 37 return m.Unmarshal(b) 38 } 39 func (m *PacketPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 40 if deterministic { 41 return xxx_messageInfo_PacketPing.Marshal(b, m, deterministic) 42 } else { 43 b = b[:cap(b)] 44 n, err := m.MarshalToSizedBuffer(b) 45 if err != nil { 46 return nil, err 47 } 48 return b[:n], nil 49 } 50 } 51 func (m *PacketPing) XXX_Merge(src proto.Message) { 52 xxx_messageInfo_PacketPing.Merge(m, src) 53 } 54 func (m *PacketPing) XXX_Size() int { 55 return m.Size() 56 } 57 func (m *PacketPing) XXX_DiscardUnknown() { 58 xxx_messageInfo_PacketPing.DiscardUnknown(m) 59 } 60 61 var xxx_messageInfo_PacketPing proto.InternalMessageInfo 62 63 type PacketPong struct { 64 } 65 66 func (m *PacketPong) Reset() { *m = PacketPong{} } 67 func (m *PacketPong) String() string { return proto.CompactTextString(m) } 68 func (*PacketPong) ProtoMessage() {} 69 func (*PacketPong) Descriptor() ([]byte, []int) { 70 return fileDescriptor_22474b5527c8fa9f, []int{1} 71 } 72 func (m *PacketPong) XXX_Unmarshal(b []byte) error { 73 return m.Unmarshal(b) 74 } 75 func (m *PacketPong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 76 if deterministic { 77 return xxx_messageInfo_PacketPong.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 *PacketPong) XXX_Merge(src proto.Message) { 88 xxx_messageInfo_PacketPong.Merge(m, src) 89 } 90 func (m *PacketPong) XXX_Size() int { 91 return m.Size() 92 } 93 func (m *PacketPong) XXX_DiscardUnknown() { 94 xxx_messageInfo_PacketPong.DiscardUnknown(m) 95 } 96 97 var xxx_messageInfo_PacketPong proto.InternalMessageInfo 98 99 type PacketMsg struct { 100 ChannelID int32 `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` 101 EOF bool `protobuf:"varint,2,opt,name=eof,proto3" json:"eof,omitempty"` 102 Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` 103 } 104 105 func (m *PacketMsg) Reset() { *m = PacketMsg{} } 106 func (m *PacketMsg) String() string { return proto.CompactTextString(m) } 107 func (*PacketMsg) ProtoMessage() {} 108 func (*PacketMsg) Descriptor() ([]byte, []int) { 109 return fileDescriptor_22474b5527c8fa9f, []int{2} 110 } 111 func (m *PacketMsg) XXX_Unmarshal(b []byte) error { 112 return m.Unmarshal(b) 113 } 114 func (m *PacketMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 115 if deterministic { 116 return xxx_messageInfo_PacketMsg.Marshal(b, m, deterministic) 117 } else { 118 b = b[:cap(b)] 119 n, err := m.MarshalToSizedBuffer(b) 120 if err != nil { 121 return nil, err 122 } 123 return b[:n], nil 124 } 125 } 126 func (m *PacketMsg) XXX_Merge(src proto.Message) { 127 xxx_messageInfo_PacketMsg.Merge(m, src) 128 } 129 func (m *PacketMsg) XXX_Size() int { 130 return m.Size() 131 } 132 func (m *PacketMsg) XXX_DiscardUnknown() { 133 xxx_messageInfo_PacketMsg.DiscardUnknown(m) 134 } 135 136 var xxx_messageInfo_PacketMsg proto.InternalMessageInfo 137 138 func (m *PacketMsg) GetChannelID() int32 { 139 if m != nil { 140 return m.ChannelID 141 } 142 return 0 143 } 144 145 func (m *PacketMsg) GetEOF() bool { 146 if m != nil { 147 return m.EOF 148 } 149 return false 150 } 151 152 func (m *PacketMsg) GetData() []byte { 153 if m != nil { 154 return m.Data 155 } 156 return nil 157 } 158 159 type Packet struct { 160 // Types that are valid to be assigned to Sum: 161 // *Packet_PacketPing 162 // *Packet_PacketPong 163 // *Packet_PacketMsg 164 Sum isPacket_Sum `protobuf_oneof:"sum"` 165 } 166 167 func (m *Packet) Reset() { *m = Packet{} } 168 func (m *Packet) String() string { return proto.CompactTextString(m) } 169 func (*Packet) ProtoMessage() {} 170 func (*Packet) Descriptor() ([]byte, []int) { 171 return fileDescriptor_22474b5527c8fa9f, []int{3} 172 } 173 func (m *Packet) XXX_Unmarshal(b []byte) error { 174 return m.Unmarshal(b) 175 } 176 func (m *Packet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 177 if deterministic { 178 return xxx_messageInfo_Packet.Marshal(b, m, deterministic) 179 } else { 180 b = b[:cap(b)] 181 n, err := m.MarshalToSizedBuffer(b) 182 if err != nil { 183 return nil, err 184 } 185 return b[:n], nil 186 } 187 } 188 func (m *Packet) XXX_Merge(src proto.Message) { 189 xxx_messageInfo_Packet.Merge(m, src) 190 } 191 func (m *Packet) XXX_Size() int { 192 return m.Size() 193 } 194 func (m *Packet) XXX_DiscardUnknown() { 195 xxx_messageInfo_Packet.DiscardUnknown(m) 196 } 197 198 var xxx_messageInfo_Packet proto.InternalMessageInfo 199 200 type isPacket_Sum interface { 201 isPacket_Sum() 202 MarshalTo([]byte) (int, error) 203 Size() int 204 } 205 206 type Packet_PacketPing struct { 207 PacketPing *PacketPing `protobuf:"bytes,1,opt,name=packet_ping,json=packetPing,proto3,oneof" json:"packet_ping,omitempty"` 208 } 209 type Packet_PacketPong struct { 210 PacketPong *PacketPong `protobuf:"bytes,2,opt,name=packet_pong,json=packetPong,proto3,oneof" json:"packet_pong,omitempty"` 211 } 212 type Packet_PacketMsg struct { 213 PacketMsg *PacketMsg `protobuf:"bytes,3,opt,name=packet_msg,json=packetMsg,proto3,oneof" json:"packet_msg,omitempty"` 214 } 215 216 func (*Packet_PacketPing) isPacket_Sum() {} 217 func (*Packet_PacketPong) isPacket_Sum() {} 218 func (*Packet_PacketMsg) isPacket_Sum() {} 219 220 func (m *Packet) GetSum() isPacket_Sum { 221 if m != nil { 222 return m.Sum 223 } 224 return nil 225 } 226 227 func (m *Packet) GetPacketPing() *PacketPing { 228 if x, ok := m.GetSum().(*Packet_PacketPing); ok { 229 return x.PacketPing 230 } 231 return nil 232 } 233 234 func (m *Packet) GetPacketPong() *PacketPong { 235 if x, ok := m.GetSum().(*Packet_PacketPong); ok { 236 return x.PacketPong 237 } 238 return nil 239 } 240 241 func (m *Packet) GetPacketMsg() *PacketMsg { 242 if x, ok := m.GetSum().(*Packet_PacketMsg); ok { 243 return x.PacketMsg 244 } 245 return nil 246 } 247 248 // XXX_OneofWrappers is for the internal use of the proto package. 249 func (*Packet) XXX_OneofWrappers() []interface{} { 250 return []interface{}{ 251 (*Packet_PacketPing)(nil), 252 (*Packet_PacketPong)(nil), 253 (*Packet_PacketMsg)(nil), 254 } 255 } 256 257 type AuthSigMessage struct { 258 PubKey crypto.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"` 259 Sig []byte `protobuf:"bytes,2,opt,name=sig,proto3" json:"sig,omitempty"` 260 } 261 262 func (m *AuthSigMessage) Reset() { *m = AuthSigMessage{} } 263 func (m *AuthSigMessage) String() string { return proto.CompactTextString(m) } 264 func (*AuthSigMessage) ProtoMessage() {} 265 func (*AuthSigMessage) Descriptor() ([]byte, []int) { 266 return fileDescriptor_22474b5527c8fa9f, []int{4} 267 } 268 func (m *AuthSigMessage) XXX_Unmarshal(b []byte) error { 269 return m.Unmarshal(b) 270 } 271 func (m *AuthSigMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 272 if deterministic { 273 return xxx_messageInfo_AuthSigMessage.Marshal(b, m, deterministic) 274 } else { 275 b = b[:cap(b)] 276 n, err := m.MarshalToSizedBuffer(b) 277 if err != nil { 278 return nil, err 279 } 280 return b[:n], nil 281 } 282 } 283 func (m *AuthSigMessage) XXX_Merge(src proto.Message) { 284 xxx_messageInfo_AuthSigMessage.Merge(m, src) 285 } 286 func (m *AuthSigMessage) XXX_Size() int { 287 return m.Size() 288 } 289 func (m *AuthSigMessage) XXX_DiscardUnknown() { 290 xxx_messageInfo_AuthSigMessage.DiscardUnknown(m) 291 } 292 293 var xxx_messageInfo_AuthSigMessage proto.InternalMessageInfo 294 295 func (m *AuthSigMessage) GetPubKey() crypto.PublicKey { 296 if m != nil { 297 return m.PubKey 298 } 299 return crypto.PublicKey{} 300 } 301 302 func (m *AuthSigMessage) GetSig() []byte { 303 if m != nil { 304 return m.Sig 305 } 306 return nil 307 } 308 309 func init() { 310 proto.RegisterType((*PacketPing)(nil), "tendermint.p2p.PacketPing") 311 proto.RegisterType((*PacketPong)(nil), "tendermint.p2p.PacketPong") 312 proto.RegisterType((*PacketMsg)(nil), "tendermint.p2p.PacketMsg") 313 proto.RegisterType((*Packet)(nil), "tendermint.p2p.Packet") 314 proto.RegisterType((*AuthSigMessage)(nil), "tendermint.p2p.AuthSigMessage") 315 } 316 317 func init() { proto.RegisterFile("tendermint/p2p/conn.proto", fileDescriptor_22474b5527c8fa9f) } 318 319 var fileDescriptor_22474b5527c8fa9f = []byte{ 320 // 416 bytes of a gzipped FileDescriptorProto 321 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0x41, 0x6f, 0xd3, 0x30, 322 0x14, 0x4e, 0xc8, 0xd6, 0xd1, 0xd7, 0x32, 0x21, 0x8b, 0x43, 0x5b, 0x4d, 0x69, 0xd5, 0x53, 0x0f, 323 0x28, 0x96, 0x3a, 0x4e, 0x20, 0x0e, 0x64, 0x80, 0x36, 0x4d, 0x15, 0x55, 0xe0, 0xc4, 0x25, 0x4a, 324 0x5c, 0xe3, 0x58, 0x5d, 0x6c, 0x2b, 0x76, 0x0e, 0xf9, 0x17, 0xfc, 0xac, 0x71, 0xdb, 0x91, 0x53, 325 0x85, 0xd2, 0x3f, 0x82, 0x1a, 0x97, 0x35, 0x95, 0xd8, 0xed, 0xfb, 0xde, 0xf3, 0xf7, 0xde, 0xf7, 326 0xc9, 0x0f, 0x86, 0x86, 0x8a, 0x15, 0x2d, 0x72, 0x2e, 0x0c, 0x56, 0x73, 0x85, 0x89, 0x14, 0x22, 327 0x50, 0x85, 0x34, 0x12, 0x9d, 0x1f, 0x5a, 0x81, 0x9a, 0xab, 0xd1, 0x2b, 0x26, 0x99, 0x6c, 0x5a, 328 0x78, 0x87, 0xec, 0xab, 0xd1, 0x45, 0x6b, 0x00, 0x29, 0x2a, 0x65, 0x24, 0x5e, 0xd3, 0x4a, 0xdb, 329 0xee, 0xb4, 0x0f, 0xb0, 0x4c, 0xc8, 0x9a, 0x9a, 0x25, 0x17, 0xac, 0xc5, 0xa4, 0x60, 0xd3, 0x0c, 330 0xba, 0x96, 0x2d, 0x34, 0x43, 0xaf, 0x01, 0x48, 0x96, 0x08, 0x41, 0xef, 0x62, 0xbe, 0x1a, 0xb8, 331 0x13, 0x77, 0x76, 0x1a, 0xbe, 0xa8, 0x37, 0xe3, 0xee, 0x95, 0xad, 0xde, 0x7c, 0x8c, 0xba, 0xfb, 332 0x07, 0x37, 0x2b, 0x34, 0x04, 0x8f, 0xca, 0x1f, 0x83, 0x67, 0x13, 0x77, 0xf6, 0x3c, 0x3c, 0xab, 333 0x37, 0x63, 0xef, 0xd3, 0x97, 0xcf, 0xd1, 0xae, 0x86, 0x10, 0x9c, 0xac, 0x12, 0x93, 0x0c, 0xbc, 334 0x89, 0x3b, 0xeb, 0x47, 0x0d, 0x9e, 0xfe, 0x72, 0xa1, 0x63, 0x57, 0xa1, 0xf7, 0xd0, 0x53, 0x0d, 335 0x8a, 0x15, 0x17, 0xac, 0x59, 0xd4, 0x9b, 0x8f, 0x82, 0xe3, 0xa8, 0xc1, 0xc1, 0xf3, 0xb5, 0x13, 336 0x81, 0x7a, 0x64, 0x6d, 0xb9, 0x14, 0xac, 0x31, 0xf0, 0xb4, 0x5c, 0x1e, 0xc9, 0xa5, 0x60, 0xe8, 337 0x2d, 0xec, 0x59, 0x9c, 0x6b, 0xd6, 0x58, 0xec, 0xcd, 0x87, 0xff, 0x57, 0x2f, 0xf4, 0x4e, 0xdc, 338 0x55, 0xff, 0x48, 0x78, 0x0a, 0x9e, 0x2e, 0xf3, 0x69, 0x0c, 0xe7, 0x1f, 0x4a, 0x93, 0x7d, 0xe5, 339 0x6c, 0x41, 0xb5, 0x4e, 0x18, 0x45, 0xef, 0xe0, 0x4c, 0x95, 0x69, 0xbc, 0xa6, 0xd5, 0x3e, 0xce, 340 0x45, 0x7b, 0xa2, 0xfd, 0x93, 0x60, 0x59, 0xa6, 0x77, 0x9c, 0xdc, 0xd2, 0x2a, 0x3c, 0xb9, 0xdf, 341 0x8c, 0x9d, 0xa8, 0xa3, 0xca, 0xf4, 0x96, 0x56, 0xe8, 0x25, 0x78, 0x9a, 0xdb, 0x20, 0xfd, 0x68, 342 0x07, 0xc3, 0xf4, 0xbe, 0xf6, 0xdd, 0x87, 0xda, 0x77, 0xff, 0xd4, 0xbe, 0xfb, 0x73, 0xeb, 0x3b, 343 0x0f, 0x5b, 0xdf, 0xf9, 0xbd, 0xf5, 0x9d, 0xef, 0xd7, 0x8c, 0x9b, 0xac, 0x4c, 0x03, 0x22, 0x73, 344 0xac, 0x4b, 0x55, 0x24, 0xac, 0x4a, 0xf0, 0xb7, 0xc7, 0x55, 0x57, 0x52, 0x08, 0x4a, 0x8c, 0x2c, 345 0x30, 0xc9, 0x12, 0x2e, 0x34, 0x36, 0xf9, 0xe5, 0x1b, 0x6c, 0x0f, 0xe6, 0xf8, 0xca, 0xd2, 0x4e, 346 0x53, 0xbd, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x10, 0xb4, 0xa6, 0x7e, 0x02, 0x00, 0x00, 347 } 348 349 func (m *PacketPing) Marshal() (dAtA []byte, err error) { 350 size := m.Size() 351 dAtA = make([]byte, size) 352 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 353 if err != nil { 354 return nil, err 355 } 356 return dAtA[:n], nil 357 } 358 359 func (m *PacketPing) MarshalTo(dAtA []byte) (int, error) { 360 size := m.Size() 361 return m.MarshalToSizedBuffer(dAtA[:size]) 362 } 363 364 func (m *PacketPing) MarshalToSizedBuffer(dAtA []byte) (int, error) { 365 i := len(dAtA) 366 _ = i 367 var l int 368 _ = l 369 return len(dAtA) - i, nil 370 } 371 372 func (m *PacketPong) Marshal() (dAtA []byte, err error) { 373 size := m.Size() 374 dAtA = make([]byte, size) 375 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 376 if err != nil { 377 return nil, err 378 } 379 return dAtA[:n], nil 380 } 381 382 func (m *PacketPong) MarshalTo(dAtA []byte) (int, error) { 383 size := m.Size() 384 return m.MarshalToSizedBuffer(dAtA[:size]) 385 } 386 387 func (m *PacketPong) MarshalToSizedBuffer(dAtA []byte) (int, error) { 388 i := len(dAtA) 389 _ = i 390 var l int 391 _ = l 392 return len(dAtA) - i, nil 393 } 394 395 func (m *PacketMsg) Marshal() (dAtA []byte, err error) { 396 size := m.Size() 397 dAtA = make([]byte, size) 398 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 399 if err != nil { 400 return nil, err 401 } 402 return dAtA[:n], nil 403 } 404 405 func (m *PacketMsg) MarshalTo(dAtA []byte) (int, error) { 406 size := m.Size() 407 return m.MarshalToSizedBuffer(dAtA[:size]) 408 } 409 410 func (m *PacketMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) { 411 i := len(dAtA) 412 _ = i 413 var l int 414 _ = l 415 if len(m.Data) > 0 { 416 i -= len(m.Data) 417 copy(dAtA[i:], m.Data) 418 i = encodeVarintConn(dAtA, i, uint64(len(m.Data))) 419 i-- 420 dAtA[i] = 0x1a 421 } 422 if m.EOF { 423 i-- 424 if m.EOF { 425 dAtA[i] = 1 426 } else { 427 dAtA[i] = 0 428 } 429 i-- 430 dAtA[i] = 0x10 431 } 432 if m.ChannelID != 0 { 433 i = encodeVarintConn(dAtA, i, uint64(m.ChannelID)) 434 i-- 435 dAtA[i] = 0x8 436 } 437 return len(dAtA) - i, nil 438 } 439 440 func (m *Packet) Marshal() (dAtA []byte, err error) { 441 size := m.Size() 442 dAtA = make([]byte, size) 443 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 444 if err != nil { 445 return nil, err 446 } 447 return dAtA[:n], nil 448 } 449 450 func (m *Packet) MarshalTo(dAtA []byte) (int, error) { 451 size := m.Size() 452 return m.MarshalToSizedBuffer(dAtA[:size]) 453 } 454 455 func (m *Packet) MarshalToSizedBuffer(dAtA []byte) (int, error) { 456 i := len(dAtA) 457 _ = i 458 var l int 459 _ = l 460 if m.Sum != nil { 461 { 462 size := m.Sum.Size() 463 i -= size 464 if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil { 465 return 0, err 466 } 467 } 468 } 469 return len(dAtA) - i, nil 470 } 471 472 func (m *Packet_PacketPing) MarshalTo(dAtA []byte) (int, error) { 473 size := m.Size() 474 return m.MarshalToSizedBuffer(dAtA[:size]) 475 } 476 477 func (m *Packet_PacketPing) MarshalToSizedBuffer(dAtA []byte) (int, error) { 478 i := len(dAtA) 479 if m.PacketPing != nil { 480 { 481 size, err := m.PacketPing.MarshalToSizedBuffer(dAtA[:i]) 482 if err != nil { 483 return 0, err 484 } 485 i -= size 486 i = encodeVarintConn(dAtA, i, uint64(size)) 487 } 488 i-- 489 dAtA[i] = 0xa 490 } 491 return len(dAtA) - i, nil 492 } 493 func (m *Packet_PacketPong) MarshalTo(dAtA []byte) (int, error) { 494 size := m.Size() 495 return m.MarshalToSizedBuffer(dAtA[:size]) 496 } 497 498 func (m *Packet_PacketPong) MarshalToSizedBuffer(dAtA []byte) (int, error) { 499 i := len(dAtA) 500 if m.PacketPong != nil { 501 { 502 size, err := m.PacketPong.MarshalToSizedBuffer(dAtA[:i]) 503 if err != nil { 504 return 0, err 505 } 506 i -= size 507 i = encodeVarintConn(dAtA, i, uint64(size)) 508 } 509 i-- 510 dAtA[i] = 0x12 511 } 512 return len(dAtA) - i, nil 513 } 514 func (m *Packet_PacketMsg) MarshalTo(dAtA []byte) (int, error) { 515 size := m.Size() 516 return m.MarshalToSizedBuffer(dAtA[:size]) 517 } 518 519 func (m *Packet_PacketMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) { 520 i := len(dAtA) 521 if m.PacketMsg != nil { 522 { 523 size, err := m.PacketMsg.MarshalToSizedBuffer(dAtA[:i]) 524 if err != nil { 525 return 0, err 526 } 527 i -= size 528 i = encodeVarintConn(dAtA, i, uint64(size)) 529 } 530 i-- 531 dAtA[i] = 0x1a 532 } 533 return len(dAtA) - i, nil 534 } 535 func (m *AuthSigMessage) Marshal() (dAtA []byte, err error) { 536 size := m.Size() 537 dAtA = make([]byte, size) 538 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 539 if err != nil { 540 return nil, err 541 } 542 return dAtA[:n], nil 543 } 544 545 func (m *AuthSigMessage) MarshalTo(dAtA []byte) (int, error) { 546 size := m.Size() 547 return m.MarshalToSizedBuffer(dAtA[:size]) 548 } 549 550 func (m *AuthSigMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) { 551 i := len(dAtA) 552 _ = i 553 var l int 554 _ = l 555 if len(m.Sig) > 0 { 556 i -= len(m.Sig) 557 copy(dAtA[i:], m.Sig) 558 i = encodeVarintConn(dAtA, i, uint64(len(m.Sig))) 559 i-- 560 dAtA[i] = 0x12 561 } 562 { 563 size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i]) 564 if err != nil { 565 return 0, err 566 } 567 i -= size 568 i = encodeVarintConn(dAtA, i, uint64(size)) 569 } 570 i-- 571 dAtA[i] = 0xa 572 return len(dAtA) - i, nil 573 } 574 575 func encodeVarintConn(dAtA []byte, offset int, v uint64) int { 576 offset -= sovConn(v) 577 base := offset 578 for v >= 1<<7 { 579 dAtA[offset] = uint8(v&0x7f | 0x80) 580 v >>= 7 581 offset++ 582 } 583 dAtA[offset] = uint8(v) 584 return base 585 } 586 func (m *PacketPing) Size() (n int) { 587 if m == nil { 588 return 0 589 } 590 var l int 591 _ = l 592 return n 593 } 594 595 func (m *PacketPong) Size() (n int) { 596 if m == nil { 597 return 0 598 } 599 var l int 600 _ = l 601 return n 602 } 603 604 func (m *PacketMsg) Size() (n int) { 605 if m == nil { 606 return 0 607 } 608 var l int 609 _ = l 610 if m.ChannelID != 0 { 611 n += 1 + sovConn(uint64(m.ChannelID)) 612 } 613 if m.EOF { 614 n += 2 615 } 616 l = len(m.Data) 617 if l > 0 { 618 n += 1 + l + sovConn(uint64(l)) 619 } 620 return n 621 } 622 623 func (m *Packet) Size() (n int) { 624 if m == nil { 625 return 0 626 } 627 var l int 628 _ = l 629 if m.Sum != nil { 630 n += m.Sum.Size() 631 } 632 return n 633 } 634 635 func (m *Packet_PacketPing) Size() (n int) { 636 if m == nil { 637 return 0 638 } 639 var l int 640 _ = l 641 if m.PacketPing != nil { 642 l = m.PacketPing.Size() 643 n += 1 + l + sovConn(uint64(l)) 644 } 645 return n 646 } 647 func (m *Packet_PacketPong) Size() (n int) { 648 if m == nil { 649 return 0 650 } 651 var l int 652 _ = l 653 if m.PacketPong != nil { 654 l = m.PacketPong.Size() 655 n += 1 + l + sovConn(uint64(l)) 656 } 657 return n 658 } 659 func (m *Packet_PacketMsg) Size() (n int) { 660 if m == nil { 661 return 0 662 } 663 var l int 664 _ = l 665 if m.PacketMsg != nil { 666 l = m.PacketMsg.Size() 667 n += 1 + l + sovConn(uint64(l)) 668 } 669 return n 670 } 671 func (m *AuthSigMessage) Size() (n int) { 672 if m == nil { 673 return 0 674 } 675 var l int 676 _ = l 677 l = m.PubKey.Size() 678 n += 1 + l + sovConn(uint64(l)) 679 l = len(m.Sig) 680 if l > 0 { 681 n += 1 + l + sovConn(uint64(l)) 682 } 683 return n 684 } 685 686 func sovConn(x uint64) (n int) { 687 return (math_bits.Len64(x|1) + 6) / 7 688 } 689 func sozConn(x uint64) (n int) { 690 return sovConn(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 691 } 692 func (m *PacketPing) Unmarshal(dAtA []byte) error { 693 l := len(dAtA) 694 iNdEx := 0 695 for iNdEx < l { 696 preIndex := iNdEx 697 var wire uint64 698 for shift := uint(0); ; shift += 7 { 699 if shift >= 64 { 700 return ErrIntOverflowConn 701 } 702 if iNdEx >= l { 703 return io.ErrUnexpectedEOF 704 } 705 b := dAtA[iNdEx] 706 iNdEx++ 707 wire |= uint64(b&0x7F) << shift 708 if b < 0x80 { 709 break 710 } 711 } 712 fieldNum := int32(wire >> 3) 713 wireType := int(wire & 0x7) 714 if wireType == 4 { 715 return fmt.Errorf("proto: PacketPing: wiretype end group for non-group") 716 } 717 if fieldNum <= 0 { 718 return fmt.Errorf("proto: PacketPing: illegal tag %d (wire type %d)", fieldNum, wire) 719 } 720 switch fieldNum { 721 default: 722 iNdEx = preIndex 723 skippy, err := skipConn(dAtA[iNdEx:]) 724 if err != nil { 725 return err 726 } 727 if (skippy < 0) || (iNdEx+skippy) < 0 { 728 return ErrInvalidLengthConn 729 } 730 if (iNdEx + skippy) > l { 731 return io.ErrUnexpectedEOF 732 } 733 iNdEx += skippy 734 } 735 } 736 737 if iNdEx > l { 738 return io.ErrUnexpectedEOF 739 } 740 return nil 741 } 742 func (m *PacketPong) Unmarshal(dAtA []byte) error { 743 l := len(dAtA) 744 iNdEx := 0 745 for iNdEx < l { 746 preIndex := iNdEx 747 var wire uint64 748 for shift := uint(0); ; shift += 7 { 749 if shift >= 64 { 750 return ErrIntOverflowConn 751 } 752 if iNdEx >= l { 753 return io.ErrUnexpectedEOF 754 } 755 b := dAtA[iNdEx] 756 iNdEx++ 757 wire |= uint64(b&0x7F) << shift 758 if b < 0x80 { 759 break 760 } 761 } 762 fieldNum := int32(wire >> 3) 763 wireType := int(wire & 0x7) 764 if wireType == 4 { 765 return fmt.Errorf("proto: PacketPong: wiretype end group for non-group") 766 } 767 if fieldNum <= 0 { 768 return fmt.Errorf("proto: PacketPong: illegal tag %d (wire type %d)", fieldNum, wire) 769 } 770 switch fieldNum { 771 default: 772 iNdEx = preIndex 773 skippy, err := skipConn(dAtA[iNdEx:]) 774 if err != nil { 775 return err 776 } 777 if (skippy < 0) || (iNdEx+skippy) < 0 { 778 return ErrInvalidLengthConn 779 } 780 if (iNdEx + skippy) > l { 781 return io.ErrUnexpectedEOF 782 } 783 iNdEx += skippy 784 } 785 } 786 787 if iNdEx > l { 788 return io.ErrUnexpectedEOF 789 } 790 return nil 791 } 792 func (m *PacketMsg) Unmarshal(dAtA []byte) error { 793 l := len(dAtA) 794 iNdEx := 0 795 for iNdEx < l { 796 preIndex := iNdEx 797 var wire uint64 798 for shift := uint(0); ; shift += 7 { 799 if shift >= 64 { 800 return ErrIntOverflowConn 801 } 802 if iNdEx >= l { 803 return io.ErrUnexpectedEOF 804 } 805 b := dAtA[iNdEx] 806 iNdEx++ 807 wire |= uint64(b&0x7F) << shift 808 if b < 0x80 { 809 break 810 } 811 } 812 fieldNum := int32(wire >> 3) 813 wireType := int(wire & 0x7) 814 if wireType == 4 { 815 return fmt.Errorf("proto: PacketMsg: wiretype end group for non-group") 816 } 817 if fieldNum <= 0 { 818 return fmt.Errorf("proto: PacketMsg: illegal tag %d (wire type %d)", fieldNum, wire) 819 } 820 switch fieldNum { 821 case 1: 822 if wireType != 0 { 823 return fmt.Errorf("proto: wrong wireType = %d for field ChannelID", wireType) 824 } 825 m.ChannelID = 0 826 for shift := uint(0); ; shift += 7 { 827 if shift >= 64 { 828 return ErrIntOverflowConn 829 } 830 if iNdEx >= l { 831 return io.ErrUnexpectedEOF 832 } 833 b := dAtA[iNdEx] 834 iNdEx++ 835 m.ChannelID |= int32(b&0x7F) << shift 836 if b < 0x80 { 837 break 838 } 839 } 840 case 2: 841 if wireType != 0 { 842 return fmt.Errorf("proto: wrong wireType = %d for field EOF", wireType) 843 } 844 var v int 845 for shift := uint(0); ; shift += 7 { 846 if shift >= 64 { 847 return ErrIntOverflowConn 848 } 849 if iNdEx >= l { 850 return io.ErrUnexpectedEOF 851 } 852 b := dAtA[iNdEx] 853 iNdEx++ 854 v |= int(b&0x7F) << shift 855 if b < 0x80 { 856 break 857 } 858 } 859 m.EOF = bool(v != 0) 860 case 3: 861 if wireType != 2 { 862 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 863 } 864 var byteLen int 865 for shift := uint(0); ; shift += 7 { 866 if shift >= 64 { 867 return ErrIntOverflowConn 868 } 869 if iNdEx >= l { 870 return io.ErrUnexpectedEOF 871 } 872 b := dAtA[iNdEx] 873 iNdEx++ 874 byteLen |= int(b&0x7F) << shift 875 if b < 0x80 { 876 break 877 } 878 } 879 if byteLen < 0 { 880 return ErrInvalidLengthConn 881 } 882 postIndex := iNdEx + byteLen 883 if postIndex < 0 { 884 return ErrInvalidLengthConn 885 } 886 if postIndex > l { 887 return io.ErrUnexpectedEOF 888 } 889 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 890 if m.Data == nil { 891 m.Data = []byte{} 892 } 893 iNdEx = postIndex 894 default: 895 iNdEx = preIndex 896 skippy, err := skipConn(dAtA[iNdEx:]) 897 if err != nil { 898 return err 899 } 900 if (skippy < 0) || (iNdEx+skippy) < 0 { 901 return ErrInvalidLengthConn 902 } 903 if (iNdEx + skippy) > l { 904 return io.ErrUnexpectedEOF 905 } 906 iNdEx += skippy 907 } 908 } 909 910 if iNdEx > l { 911 return io.ErrUnexpectedEOF 912 } 913 return nil 914 } 915 func (m *Packet) Unmarshal(dAtA []byte) error { 916 l := len(dAtA) 917 iNdEx := 0 918 for iNdEx < l { 919 preIndex := iNdEx 920 var wire uint64 921 for shift := uint(0); ; shift += 7 { 922 if shift >= 64 { 923 return ErrIntOverflowConn 924 } 925 if iNdEx >= l { 926 return io.ErrUnexpectedEOF 927 } 928 b := dAtA[iNdEx] 929 iNdEx++ 930 wire |= uint64(b&0x7F) << shift 931 if b < 0x80 { 932 break 933 } 934 } 935 fieldNum := int32(wire >> 3) 936 wireType := int(wire & 0x7) 937 if wireType == 4 { 938 return fmt.Errorf("proto: Packet: wiretype end group for non-group") 939 } 940 if fieldNum <= 0 { 941 return fmt.Errorf("proto: Packet: illegal tag %d (wire type %d)", fieldNum, wire) 942 } 943 switch fieldNum { 944 case 1: 945 if wireType != 2 { 946 return fmt.Errorf("proto: wrong wireType = %d for field PacketPing", wireType) 947 } 948 var msglen int 949 for shift := uint(0); ; shift += 7 { 950 if shift >= 64 { 951 return ErrIntOverflowConn 952 } 953 if iNdEx >= l { 954 return io.ErrUnexpectedEOF 955 } 956 b := dAtA[iNdEx] 957 iNdEx++ 958 msglen |= int(b&0x7F) << shift 959 if b < 0x80 { 960 break 961 } 962 } 963 if msglen < 0 { 964 return ErrInvalidLengthConn 965 } 966 postIndex := iNdEx + msglen 967 if postIndex < 0 { 968 return ErrInvalidLengthConn 969 } 970 if postIndex > l { 971 return io.ErrUnexpectedEOF 972 } 973 v := &PacketPing{} 974 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 975 return err 976 } 977 m.Sum = &Packet_PacketPing{v} 978 iNdEx = postIndex 979 case 2: 980 if wireType != 2 { 981 return fmt.Errorf("proto: wrong wireType = %d for field PacketPong", wireType) 982 } 983 var msglen int 984 for shift := uint(0); ; shift += 7 { 985 if shift >= 64 { 986 return ErrIntOverflowConn 987 } 988 if iNdEx >= l { 989 return io.ErrUnexpectedEOF 990 } 991 b := dAtA[iNdEx] 992 iNdEx++ 993 msglen |= int(b&0x7F) << shift 994 if b < 0x80 { 995 break 996 } 997 } 998 if msglen < 0 { 999 return ErrInvalidLengthConn 1000 } 1001 postIndex := iNdEx + msglen 1002 if postIndex < 0 { 1003 return ErrInvalidLengthConn 1004 } 1005 if postIndex > l { 1006 return io.ErrUnexpectedEOF 1007 } 1008 v := &PacketPong{} 1009 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1010 return err 1011 } 1012 m.Sum = &Packet_PacketPong{v} 1013 iNdEx = postIndex 1014 case 3: 1015 if wireType != 2 { 1016 return fmt.Errorf("proto: wrong wireType = %d for field PacketMsg", wireType) 1017 } 1018 var msglen int 1019 for shift := uint(0); ; shift += 7 { 1020 if shift >= 64 { 1021 return ErrIntOverflowConn 1022 } 1023 if iNdEx >= l { 1024 return io.ErrUnexpectedEOF 1025 } 1026 b := dAtA[iNdEx] 1027 iNdEx++ 1028 msglen |= int(b&0x7F) << shift 1029 if b < 0x80 { 1030 break 1031 } 1032 } 1033 if msglen < 0 { 1034 return ErrInvalidLengthConn 1035 } 1036 postIndex := iNdEx + msglen 1037 if postIndex < 0 { 1038 return ErrInvalidLengthConn 1039 } 1040 if postIndex > l { 1041 return io.ErrUnexpectedEOF 1042 } 1043 v := &PacketMsg{} 1044 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1045 return err 1046 } 1047 m.Sum = &Packet_PacketMsg{v} 1048 iNdEx = postIndex 1049 default: 1050 iNdEx = preIndex 1051 skippy, err := skipConn(dAtA[iNdEx:]) 1052 if err != nil { 1053 return err 1054 } 1055 if (skippy < 0) || (iNdEx+skippy) < 0 { 1056 return ErrInvalidLengthConn 1057 } 1058 if (iNdEx + skippy) > l { 1059 return io.ErrUnexpectedEOF 1060 } 1061 iNdEx += skippy 1062 } 1063 } 1064 1065 if iNdEx > l { 1066 return io.ErrUnexpectedEOF 1067 } 1068 return nil 1069 } 1070 func (m *AuthSigMessage) Unmarshal(dAtA []byte) error { 1071 l := len(dAtA) 1072 iNdEx := 0 1073 for iNdEx < l { 1074 preIndex := iNdEx 1075 var wire uint64 1076 for shift := uint(0); ; shift += 7 { 1077 if shift >= 64 { 1078 return ErrIntOverflowConn 1079 } 1080 if iNdEx >= l { 1081 return io.ErrUnexpectedEOF 1082 } 1083 b := dAtA[iNdEx] 1084 iNdEx++ 1085 wire |= uint64(b&0x7F) << shift 1086 if b < 0x80 { 1087 break 1088 } 1089 } 1090 fieldNum := int32(wire >> 3) 1091 wireType := int(wire & 0x7) 1092 if wireType == 4 { 1093 return fmt.Errorf("proto: AuthSigMessage: wiretype end group for non-group") 1094 } 1095 if fieldNum <= 0 { 1096 return fmt.Errorf("proto: AuthSigMessage: illegal tag %d (wire type %d)", fieldNum, wire) 1097 } 1098 switch fieldNum { 1099 case 1: 1100 if wireType != 2 { 1101 return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) 1102 } 1103 var msglen int 1104 for shift := uint(0); ; shift += 7 { 1105 if shift >= 64 { 1106 return ErrIntOverflowConn 1107 } 1108 if iNdEx >= l { 1109 return io.ErrUnexpectedEOF 1110 } 1111 b := dAtA[iNdEx] 1112 iNdEx++ 1113 msglen |= int(b&0x7F) << shift 1114 if b < 0x80 { 1115 break 1116 } 1117 } 1118 if msglen < 0 { 1119 return ErrInvalidLengthConn 1120 } 1121 postIndex := iNdEx + msglen 1122 if postIndex < 0 { 1123 return ErrInvalidLengthConn 1124 } 1125 if postIndex > l { 1126 return io.ErrUnexpectedEOF 1127 } 1128 if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1129 return err 1130 } 1131 iNdEx = postIndex 1132 case 2: 1133 if wireType != 2 { 1134 return fmt.Errorf("proto: wrong wireType = %d for field Sig", wireType) 1135 } 1136 var byteLen int 1137 for shift := uint(0); ; shift += 7 { 1138 if shift >= 64 { 1139 return ErrIntOverflowConn 1140 } 1141 if iNdEx >= l { 1142 return io.ErrUnexpectedEOF 1143 } 1144 b := dAtA[iNdEx] 1145 iNdEx++ 1146 byteLen |= int(b&0x7F) << shift 1147 if b < 0x80 { 1148 break 1149 } 1150 } 1151 if byteLen < 0 { 1152 return ErrInvalidLengthConn 1153 } 1154 postIndex := iNdEx + byteLen 1155 if postIndex < 0 { 1156 return ErrInvalidLengthConn 1157 } 1158 if postIndex > l { 1159 return io.ErrUnexpectedEOF 1160 } 1161 m.Sig = append(m.Sig[:0], dAtA[iNdEx:postIndex]...) 1162 if m.Sig == nil { 1163 m.Sig = []byte{} 1164 } 1165 iNdEx = postIndex 1166 default: 1167 iNdEx = preIndex 1168 skippy, err := skipConn(dAtA[iNdEx:]) 1169 if err != nil { 1170 return err 1171 } 1172 if (skippy < 0) || (iNdEx+skippy) < 0 { 1173 return ErrInvalidLengthConn 1174 } 1175 if (iNdEx + skippy) > l { 1176 return io.ErrUnexpectedEOF 1177 } 1178 iNdEx += skippy 1179 } 1180 } 1181 1182 if iNdEx > l { 1183 return io.ErrUnexpectedEOF 1184 } 1185 return nil 1186 } 1187 func skipConn(dAtA []byte) (n int, err error) { 1188 l := len(dAtA) 1189 iNdEx := 0 1190 depth := 0 1191 for iNdEx < l { 1192 var wire uint64 1193 for shift := uint(0); ; shift += 7 { 1194 if shift >= 64 { 1195 return 0, ErrIntOverflowConn 1196 } 1197 if iNdEx >= l { 1198 return 0, io.ErrUnexpectedEOF 1199 } 1200 b := dAtA[iNdEx] 1201 iNdEx++ 1202 wire |= (uint64(b) & 0x7F) << shift 1203 if b < 0x80 { 1204 break 1205 } 1206 } 1207 wireType := int(wire & 0x7) 1208 switch wireType { 1209 case 0: 1210 for shift := uint(0); ; shift += 7 { 1211 if shift >= 64 { 1212 return 0, ErrIntOverflowConn 1213 } 1214 if iNdEx >= l { 1215 return 0, io.ErrUnexpectedEOF 1216 } 1217 iNdEx++ 1218 if dAtA[iNdEx-1] < 0x80 { 1219 break 1220 } 1221 } 1222 case 1: 1223 iNdEx += 8 1224 case 2: 1225 var length int 1226 for shift := uint(0); ; shift += 7 { 1227 if shift >= 64 { 1228 return 0, ErrIntOverflowConn 1229 } 1230 if iNdEx >= l { 1231 return 0, io.ErrUnexpectedEOF 1232 } 1233 b := dAtA[iNdEx] 1234 iNdEx++ 1235 length |= (int(b) & 0x7F) << shift 1236 if b < 0x80 { 1237 break 1238 } 1239 } 1240 if length < 0 { 1241 return 0, ErrInvalidLengthConn 1242 } 1243 iNdEx += length 1244 case 3: 1245 depth++ 1246 case 4: 1247 if depth == 0 { 1248 return 0, ErrUnexpectedEndOfGroupConn 1249 } 1250 depth-- 1251 case 5: 1252 iNdEx += 4 1253 default: 1254 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1255 } 1256 if iNdEx < 0 { 1257 return 0, ErrInvalidLengthConn 1258 } 1259 if depth == 0 { 1260 return iNdEx, nil 1261 } 1262 } 1263 return 0, io.ErrUnexpectedEOF 1264 } 1265 1266 var ( 1267 ErrInvalidLengthConn = fmt.Errorf("proto: negative length found during unmarshaling") 1268 ErrIntOverflowConn = fmt.Errorf("proto: integer overflow") 1269 ErrUnexpectedEndOfGroupConn = fmt.Errorf("proto: unexpected end of group") 1270 )