github.com/arieschain/arieschain@v0.0.0-20191023063405-37c074544356/les/peer.go (about) 1 // Package les implements the Light Ethereum Subprotocol. 2 package les 3 4 import ( 5 "crypto/ecdsa" 6 "encoding/binary" 7 "errors" 8 "fmt" 9 "math/big" 10 "sync" 11 "time" 12 13 "github.com/quickchainproject/quickchain/common" 14 "github.com/quickchainproject/quickchain/core/types" 15 "github.com/quickchainproject/quickchain/qct" 16 "github.com/quickchainproject/quickchain/les/flowcontrol" 17 "github.com/quickchainproject/quickchain/light" 18 "github.com/quickchainproject/quickchain/p2p" 19 "github.com/quickchainproject/quickchain/rlp" 20 ) 21 22 var ( 23 errClosed = errors.New("peer set is closed") 24 errAlreadyRegistered = errors.New("peer is already registered") 25 errNotRegistered = errors.New("peer is not registered") 26 ) 27 28 const maxResponseErrors = 50 // number of invalid responses tolerated (makes the protocol less brittle but still avoids spam) 29 30 const ( 31 announceTypeNone = iota 32 announceTypeSimple 33 announceTypeSigned 34 ) 35 36 type peer struct { 37 *p2p.Peer 38 pubKey *ecdsa.PublicKey 39 40 rw p2p.MsgReadWriter 41 42 version int // Protocol version negotiated 43 network uint64 // Network ID being on 44 45 announceType, requestAnnounceType uint64 46 47 id string 48 49 headInfo *announceData 50 lock sync.RWMutex 51 52 announceChn chan announceData 53 sendQueue *execQueue 54 55 poolEntry *poolEntry 56 hasBlock func(common.Hash, uint64) bool 57 responseErrors int 58 59 fcClient *flowcontrol.ClientNode // nil if the peer is server only 60 fcServer *flowcontrol.ServerNode // nil if the peer is client only 61 fcServerParams *flowcontrol.ServerParams 62 fcCosts requestCostTable 63 } 64 65 func newPeer(version int, network uint64, p *p2p.Peer, rw p2p.MsgReadWriter) *peer { 66 id := p.ID() 67 pubKey, _ := id.Pubkey() 68 69 return &peer{ 70 Peer: p, 71 pubKey: pubKey, 72 rw: rw, 73 version: version, 74 network: network, 75 id: fmt.Sprintf("%x", id[:8]), 76 announceChn: make(chan announceData, 20), 77 } 78 } 79 80 func (p *peer) canQueue() bool { 81 return p.sendQueue.canQueue() 82 } 83 84 func (p *peer) queueSend(f func()) { 85 p.sendQueue.queue(f) 86 } 87 88 // Info gathers and returns a collection of metadata known about a peer. 89 func (p *peer) Info() *qct.PeerInfo { 90 return &qct.PeerInfo{ 91 Version: p.version, 92 Difficulty: p.Td(), 93 Head: fmt.Sprintf("%x", p.Head()), 94 } 95 } 96 97 // Head retrieves a copy of the current head (most recent) hash of the peer. 98 func (p *peer) Head() (hash common.Hash) { 99 p.lock.RLock() 100 defer p.lock.RUnlock() 101 102 copy(hash[:], p.headInfo.Hash[:]) 103 return hash 104 } 105 106 func (p *peer) HeadAndTd() (hash common.Hash, td *big.Int) { 107 p.lock.RLock() 108 defer p.lock.RUnlock() 109 110 copy(hash[:], p.headInfo.Hash[:]) 111 return hash, p.headInfo.Td 112 } 113 114 func (p *peer) headBlockInfo() blockInfo { 115 p.lock.RLock() 116 defer p.lock.RUnlock() 117 118 return blockInfo{Hash: p.headInfo.Hash, Number: p.headInfo.Number, Td: p.headInfo.Td} 119 } 120 121 // Td retrieves the current total difficulty of a peer. 122 func (p *peer) Td() *big.Int { 123 p.lock.RLock() 124 defer p.lock.RUnlock() 125 126 return new(big.Int).Set(p.headInfo.Td) 127 } 128 129 // waitBefore implements distPeer interface 130 func (p *peer) waitBefore(maxCost uint64) (time.Duration, float64) { 131 return p.fcServer.CanSend(maxCost) 132 } 133 134 func sendRequest(w p2p.MsgWriter, msgcode, reqID, cost uint64, data interface{}) error { 135 type req struct { 136 ReqID uint64 137 Data interface{} 138 } 139 return p2p.Send(w, msgcode, req{reqID, data}) 140 } 141 142 func sendResponse(w p2p.MsgWriter, msgcode, reqID, bv uint64, data interface{}) error { 143 type resp struct { 144 ReqID, BV uint64 145 Data interface{} 146 } 147 return p2p.Send(w, msgcode, resp{reqID, bv, data}) 148 } 149 150 func (p *peer) GetRequestCost(msgcode uint64, amount int) uint64 { 151 p.lock.RLock() 152 defer p.lock.RUnlock() 153 154 cost := p.fcCosts[msgcode].baseCost + p.fcCosts[msgcode].reqCost*uint64(amount) 155 if cost > p.fcServerParams.BufLimit { 156 cost = p.fcServerParams.BufLimit 157 } 158 return cost 159 } 160 161 // HasBlock checks if the peer has a given block 162 func (p *peer) HasBlock(hash common.Hash, number uint64) bool { 163 p.lock.RLock() 164 hasBlock := p.hasBlock 165 p.lock.RUnlock() 166 return hasBlock != nil && hasBlock(hash, number) 167 } 168 169 // SendAnnounce announces the availability of a number of blocks through 170 // a hash notification. 171 func (p *peer) SendAnnounce(request announceData) error { 172 return p2p.Send(p.rw, AnnounceMsg, request) 173 } 174 175 // SendBlockHeaders sends a batch of block headers to the remote peer. 176 func (p *peer) SendBlockHeaders(reqID, bv uint64, headers []*types.Header) error { 177 return sendResponse(p.rw, BlockHeadersMsg, reqID, bv, headers) 178 } 179 180 // SendBlockBodiesRLP sends a batch of block contents to the remote peer from 181 // an already RLP encoded format. 182 func (p *peer) SendBlockBodiesRLP(reqID, bv uint64, bodies []rlp.RawValue) error { 183 return sendResponse(p.rw, BlockBodiesMsg, reqID, bv, bodies) 184 } 185 186 // SendCodeRLP sends a batch of arbitrary internal data, corresponding to the 187 // hashes requested. 188 func (p *peer) SendCode(reqID, bv uint64, data [][]byte) error { 189 return sendResponse(p.rw, CodeMsg, reqID, bv, data) 190 } 191 192 // SendReceiptsRLP sends a batch of transaction receipts, corresponding to the 193 // ones requested from an already RLP encoded format. 194 func (p *peer) SendReceiptsRLP(reqID, bv uint64, receipts []rlp.RawValue) error { 195 return sendResponse(p.rw, ReceiptsMsg, reqID, bv, receipts) 196 } 197 198 // SendProofs sends a batch of legacy LES/1 merkle proofs, corresponding to the ones requested. 199 func (p *peer) SendProofs(reqID, bv uint64, proofs proofsData) error { 200 return sendResponse(p.rw, ProofsV1Msg, reqID, bv, proofs) 201 } 202 203 // SendProofsV2 sends a batch of merkle proofs, corresponding to the ones requested. 204 func (p *peer) SendProofsV2(reqID, bv uint64, proofs light.NodeList) error { 205 return sendResponse(p.rw, ProofsV2Msg, reqID, bv, proofs) 206 } 207 208 // SendHeaderProofs sends a batch of legacy LES/1 header proofs, corresponding to the ones requested. 209 func (p *peer) SendHeaderProofs(reqID, bv uint64, proofs []ChtResp) error { 210 return sendResponse(p.rw, HeaderProofsMsg, reqID, bv, proofs) 211 } 212 213 // SendHelperTrieProofs sends a batch of HelperTrie proofs, corresponding to the ones requested. 214 func (p *peer) SendHelperTrieProofs(reqID, bv uint64, resp HelperTrieResps) error { 215 return sendResponse(p.rw, HelperTrieProofsMsg, reqID, bv, resp) 216 } 217 218 // SendTxStatus sends a batch of transaction status records, corresponding to the ones requested. 219 func (p *peer) SendTxStatus(reqID, bv uint64, stats []txStatus) error { 220 return sendResponse(p.rw, TxStatusMsg, reqID, bv, stats) 221 } 222 223 // RequestHeadersByHash fetches a batch of blocks' headers corresponding to the 224 // specified header query, based on the hash of an origin block. 225 func (p *peer) RequestHeadersByHash(reqID, cost uint64, origin common.Hash, amount int, skip int, reverse bool) error { 226 p.Log().Debug("Fetching batch of headers", "count", amount, "fromhash", origin, "skip", skip, "reverse", reverse) 227 return sendRequest(p.rw, GetBlockHeadersMsg, reqID, cost, &getBlockHeadersData{Origin: hashOrNumber{Hash: origin}, Amount: uint64(amount), Skip: uint64(skip), Reverse: reverse}) 228 } 229 230 // RequestHeadersByNumber fetches a batch of blocks' headers corresponding to the 231 // specified header query, based on the number of an origin block. 232 func (p *peer) RequestHeadersByNumber(reqID, cost, origin uint64, amount int, skip int, reverse bool) error { 233 p.Log().Debug("Fetching batch of headers", "count", amount, "fromnum", origin, "skip", skip, "reverse", reverse) 234 return sendRequest(p.rw, GetBlockHeadersMsg, reqID, cost, &getBlockHeadersData{Origin: hashOrNumber{Number: origin}, Amount: uint64(amount), Skip: uint64(skip), Reverse: reverse}) 235 } 236 237 // RequestBodies fetches a batch of blocks' bodies corresponding to the hashes 238 // specified. 239 func (p *peer) RequestBodies(reqID, cost uint64, hashes []common.Hash) error { 240 p.Log().Debug("Fetching batch of block bodies", "count", len(hashes)) 241 return sendRequest(p.rw, GetBlockBodiesMsg, reqID, cost, hashes) 242 } 243 244 // RequestCode fetches a batch of arbitrary data from a node's known state 245 // data, corresponding to the specified hashes. 246 func (p *peer) RequestCode(reqID, cost uint64, reqs []CodeReq) error { 247 p.Log().Debug("Fetching batch of codes", "count", len(reqs)) 248 return sendRequest(p.rw, GetCodeMsg, reqID, cost, reqs) 249 } 250 251 // RequestReceipts fetches a batch of transaction receipts from a remote node. 252 func (p *peer) RequestReceipts(reqID, cost uint64, hashes []common.Hash) error { 253 p.Log().Debug("Fetching batch of receipts", "count", len(hashes)) 254 return sendRequest(p.rw, GetReceiptsMsg, reqID, cost, hashes) 255 } 256 257 // RequestProofs fetches a batch of merkle proofs from a remote node. 258 func (p *peer) RequestProofs(reqID, cost uint64, reqs []ProofReq) error { 259 p.Log().Debug("Fetching batch of proofs", "count", len(reqs)) 260 switch p.version { 261 case lpv1: 262 return sendRequest(p.rw, GetProofsV1Msg, reqID, cost, reqs) 263 case lpv2: 264 return sendRequest(p.rw, GetProofsV2Msg, reqID, cost, reqs) 265 default: 266 panic(nil) 267 } 268 } 269 270 // RequestHelperTrieProofs fetches a batch of HelperTrie merkle proofs from a remote node. 271 func (p *peer) RequestHelperTrieProofs(reqID, cost uint64, reqs []HelperTrieReq) error { 272 p.Log().Debug("Fetching batch of HelperTrie proofs", "count", len(reqs)) 273 switch p.version { 274 case lpv1: 275 reqsV1 := make([]ChtReq, len(reqs)) 276 for i, req := range reqs { 277 if req.Type != htCanonical || req.AuxReq != auxHeader || len(req.Key) != 8 { 278 return fmt.Errorf("Request invalid in LES/1 mode") 279 } 280 blockNum := binary.BigEndian.Uint64(req.Key) 281 // convert HelperTrie request to old CHT request 282 reqsV1[i] = ChtReq{ChtNum: (req.TrieIdx + 1) * (light.CHTFrequencyClient / light.CHTFrequencyServer), BlockNum: blockNum, FromLevel: req.FromLevel} 283 } 284 return sendRequest(p.rw, GetHeaderProofsMsg, reqID, cost, reqsV1) 285 case lpv2: 286 return sendRequest(p.rw, GetHelperTrieProofsMsg, reqID, cost, reqs) 287 default: 288 panic(nil) 289 } 290 } 291 292 // RequestTxStatus fetches a batch of transaction status records from a remote node. 293 func (p *peer) RequestTxStatus(reqID, cost uint64, txHashes []common.Hash) error { 294 p.Log().Debug("Requesting transaction status", "count", len(txHashes)) 295 return sendRequest(p.rw, GetTxStatusMsg, reqID, cost, txHashes) 296 } 297 298 // SendTxStatus sends a batch of transactions to be added to the remote transaction pool. 299 func (p *peer) SendTxs(reqID, cost uint64, txs types.Transactions) error { 300 p.Log().Debug("Fetching batch of transactions", "count", len(txs)) 301 switch p.version { 302 case lpv1: 303 return p2p.Send(p.rw, SendTxMsg, txs) // old message format does not include reqID 304 case lpv2: 305 return sendRequest(p.rw, SendTxV2Msg, reqID, cost, txs) 306 default: 307 panic(nil) 308 } 309 } 310 311 type keyValueEntry struct { 312 Key string 313 Value rlp.RawValue 314 } 315 type keyValueList []keyValueEntry 316 type keyValueMap map[string]rlp.RawValue 317 318 func (l keyValueList) add(key string, val interface{}) keyValueList { 319 var entry keyValueEntry 320 entry.Key = key 321 if val == nil { 322 val = uint64(0) 323 } 324 enc, err := rlp.EncodeToBytes(val) 325 if err == nil { 326 entry.Value = enc 327 } 328 return append(l, entry) 329 } 330 331 func (l keyValueList) decode() keyValueMap { 332 m := make(keyValueMap) 333 for _, entry := range l { 334 m[entry.Key] = entry.Value 335 } 336 return m 337 } 338 339 func (m keyValueMap) get(key string, val interface{}) error { 340 enc, ok := m[key] 341 if !ok { 342 return errResp(ErrMissingKey, "%s", key) 343 } 344 if val == nil { 345 return nil 346 } 347 return rlp.DecodeBytes(enc, val) 348 } 349 350 func (p *peer) sendReceiveHandshake(sendList keyValueList) (keyValueList, error) { 351 // Send out own handshake in a new thread 352 errc := make(chan error, 1) 353 go func() { 354 errc <- p2p.Send(p.rw, StatusMsg, sendList) 355 }() 356 // In the mean time retrieve the remote status message 357 msg, err := p.rw.ReadMsg() 358 if err != nil { 359 return nil, err 360 } 361 if msg.Code != StatusMsg { 362 return nil, errResp(ErrNoStatusMsg, "first msg has code %x (!= %x)", msg.Code, StatusMsg) 363 } 364 if msg.Size > ProtocolMaxMsgSize { 365 return nil, errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize) 366 } 367 // Decode the handshake 368 var recvList keyValueList 369 if err := msg.Decode(&recvList); err != nil { 370 return nil, errResp(ErrDecode, "msg %v: %v", msg, err) 371 } 372 if err := <-errc; err != nil { 373 return nil, err 374 } 375 return recvList, nil 376 } 377 378 // Handshake executes the les protocol handshake, negotiating version number, 379 // network IDs, difficulties, head and genesis blocks. 380 func (p *peer) Handshake(td *big.Int, head common.Hash, headNum uint64, genesis common.Hash, server *LesServer) error { 381 p.lock.Lock() 382 defer p.lock.Unlock() 383 384 var send keyValueList 385 send = send.add("protocolVersion", uint64(p.version)) 386 send = send.add("networkId", p.network) 387 send = send.add("headTd", td) 388 send = send.add("headHash", head) 389 send = send.add("headNum", headNum) 390 send = send.add("genesisHash", genesis) 391 if server != nil { 392 send = send.add("serveHeaders", nil) 393 send = send.add("serveChainSince", uint64(0)) 394 send = send.add("serveStateSince", uint64(0)) 395 send = send.add("txRelay", nil) 396 send = send.add("flowControl/BL", server.defParams.BufLimit) 397 send = send.add("flowControl/MRR", server.defParams.MinRecharge) 398 list := server.fcCostStats.getCurrentList() 399 send = send.add("flowControl/MRC", list) 400 p.fcCosts = list.decode() 401 } else { 402 p.requestAnnounceType = announceTypeSimple // set to default until "very light" client mode is implemented 403 send = send.add("announceType", p.requestAnnounceType) 404 } 405 recvList, err := p.sendReceiveHandshake(send) 406 if err != nil { 407 return err 408 } 409 recv := recvList.decode() 410 411 var rGenesis, rHash common.Hash 412 var rVersion, rNetwork, rNum uint64 413 var rTd *big.Int 414 415 if err := recv.get("protocolVersion", &rVersion); err != nil { 416 return err 417 } 418 if err := recv.get("networkId", &rNetwork); err != nil { 419 return err 420 } 421 if err := recv.get("headTd", &rTd); err != nil { 422 return err 423 } 424 if err := recv.get("headHash", &rHash); err != nil { 425 return err 426 } 427 if err := recv.get("headNum", &rNum); err != nil { 428 return err 429 } 430 if err := recv.get("genesisHash", &rGenesis); err != nil { 431 return err 432 } 433 434 if rGenesis != genesis { 435 return errResp(ErrGenesisBlockMismatch, "%x (!= %x)", rGenesis[:8], genesis[:8]) 436 } 437 if rNetwork != p.network { 438 return errResp(ErrNetworkIdMismatch, "%d (!= %d)", rNetwork, p.network) 439 } 440 if int(rVersion) != p.version { 441 return errResp(ErrProtocolVersionMismatch, "%d (!= %d)", rVersion, p.version) 442 } 443 if server != nil { 444 // until we have a proper peer connectivity API, allow LES connection to other servers 445 /*if recv.get("serveStateSince", nil) == nil { 446 return errResp(ErrUselessPeer, "wanted client, got server") 447 }*/ 448 if recv.get("announceType", &p.announceType) != nil { 449 p.announceType = announceTypeSimple 450 } 451 p.fcClient = flowcontrol.NewClientNode(server.fcManager, server.defParams) 452 } else { 453 if recv.get("serveChainSince", nil) != nil { 454 return errResp(ErrUselessPeer, "peer cannot serve chain") 455 } 456 if recv.get("serveStateSince", nil) != nil { 457 return errResp(ErrUselessPeer, "peer cannot serve state") 458 } 459 if recv.get("txRelay", nil) != nil { 460 return errResp(ErrUselessPeer, "peer cannot relay transactions") 461 } 462 params := &flowcontrol.ServerParams{} 463 if err := recv.get("flowControl/BL", ¶ms.BufLimit); err != nil { 464 return err 465 } 466 if err := recv.get("flowControl/MRR", ¶ms.MinRecharge); err != nil { 467 return err 468 } 469 var MRC RequestCostList 470 if err := recv.get("flowControl/MRC", &MRC); err != nil { 471 return err 472 } 473 p.fcServerParams = params 474 p.fcServer = flowcontrol.NewServerNode(params) 475 p.fcCosts = MRC.decode() 476 } 477 478 p.headInfo = &announceData{Td: rTd, Hash: rHash, Number: rNum} 479 return nil 480 } 481 482 // String implements fmt.Stringer. 483 func (p *peer) String() string { 484 return fmt.Sprintf("Peer %s [%s]", p.id, 485 fmt.Sprintf("les/%d", p.version), 486 ) 487 } 488 489 // peerSetNotify is a callback interface to notify services about added or 490 // removed peers 491 type peerSetNotify interface { 492 registerPeer(*peer) 493 unregisterPeer(*peer) 494 } 495 496 // peerSet represents the collection of active peers currently participating in 497 // the Light Ethereum sub-protocol. 498 type peerSet struct { 499 peers map[string]*peer 500 lock sync.RWMutex 501 notifyList []peerSetNotify 502 closed bool 503 } 504 505 // newPeerSet creates a new peer set to track the active participants. 506 func newPeerSet() *peerSet { 507 return &peerSet{ 508 peers: make(map[string]*peer), 509 } 510 } 511 512 // notify adds a service to be notified about added or removed peers 513 func (ps *peerSet) notify(n peerSetNotify) { 514 ps.lock.Lock() 515 ps.notifyList = append(ps.notifyList, n) 516 peers := make([]*peer, 0, len(ps.peers)) 517 for _, p := range ps.peers { 518 peers = append(peers, p) 519 } 520 ps.lock.Unlock() 521 522 for _, p := range peers { 523 n.registerPeer(p) 524 } 525 } 526 527 // Register injects a new peer into the working set, or returns an error if the 528 // peer is already known. 529 func (ps *peerSet) Register(p *peer) error { 530 ps.lock.Lock() 531 if ps.closed { 532 ps.lock.Unlock() 533 return errClosed 534 } 535 if _, ok := ps.peers[p.id]; ok { 536 ps.lock.Unlock() 537 return errAlreadyRegistered 538 } 539 ps.peers[p.id] = p 540 p.sendQueue = newExecQueue(100) 541 peers := make([]peerSetNotify, len(ps.notifyList)) 542 copy(peers, ps.notifyList) 543 ps.lock.Unlock() 544 545 for _, n := range peers { 546 n.registerPeer(p) 547 } 548 return nil 549 } 550 551 // Unregister removes a remote peer from the active set, disabling any further 552 // actions to/from that particular entity. It also initiates disconnection at the networking layer. 553 func (ps *peerSet) Unregister(id string) error { 554 ps.lock.Lock() 555 if p, ok := ps.peers[id]; !ok { 556 ps.lock.Unlock() 557 return errNotRegistered 558 } else { 559 delete(ps.peers, id) 560 peers := make([]peerSetNotify, len(ps.notifyList)) 561 copy(peers, ps.notifyList) 562 ps.lock.Unlock() 563 564 for _, n := range peers { 565 n.unregisterPeer(p) 566 } 567 p.sendQueue.quit() 568 p.Peer.Disconnect(p2p.DiscUselessPeer) 569 return nil 570 } 571 } 572 573 // AllPeerIDs returns a list of all registered peer IDs 574 func (ps *peerSet) AllPeerIDs() []string { 575 ps.lock.RLock() 576 defer ps.lock.RUnlock() 577 578 res := make([]string, len(ps.peers)) 579 idx := 0 580 for id := range ps.peers { 581 res[idx] = id 582 idx++ 583 } 584 return res 585 } 586 587 // Peer retrieves the registered peer with the given id. 588 func (ps *peerSet) Peer(id string) *peer { 589 ps.lock.RLock() 590 defer ps.lock.RUnlock() 591 592 return ps.peers[id] 593 } 594 595 // Len returns if the current number of peers in the set. 596 func (ps *peerSet) Len() int { 597 ps.lock.RLock() 598 defer ps.lock.RUnlock() 599 600 return len(ps.peers) 601 } 602 603 // BestPeer retrieves the known peer with the currently highest total difficulty. 604 func (ps *peerSet) BestPeer() *peer { 605 ps.lock.RLock() 606 defer ps.lock.RUnlock() 607 608 var ( 609 bestPeer *peer 610 bestTd *big.Int 611 ) 612 for _, p := range ps.peers { 613 if td := p.Td(); bestPeer == nil || td.Cmp(bestTd) > 0 { 614 bestPeer, bestTd = p, td 615 } 616 } 617 return bestPeer 618 } 619 620 // AllPeers returns all peers in a list 621 func (ps *peerSet) AllPeers() []*peer { 622 ps.lock.RLock() 623 defer ps.lock.RUnlock() 624 625 list := make([]*peer, len(ps.peers)) 626 i := 0 627 for _, peer := range ps.peers { 628 list[i] = peer 629 i++ 630 } 631 return list 632 } 633 634 // Close disconnects all peers. 635 // No new peers can be registered after Close has returned. 636 func (ps *peerSet) Close() { 637 ps.lock.Lock() 638 defer ps.lock.Unlock() 639 640 for _, p := range ps.peers { 641 p.Disconnect(p2p.DiscQuitting) 642 } 643 ps.closed = true 644 }