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