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", &params.BufLimit); err != nil {
   464  			return err
   465  		}
   466  		if err := recv.get("flowControl/MRR", &params.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  }