github.com/codingfuture/orig-energi3@v0.8.4/p2p/server.go (about)

     1  // Copyright 2014 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 p2p implements the Ethereum p2p network protocols.
    18  package p2p
    19  
    20  import (
    21  	"bytes"
    22  	"crypto/ecdsa"
    23  	"encoding/hex"
    24  	"errors"
    25  	"net"
    26  	"sort"
    27  	"sync"
    28  	"sync/atomic"
    29  	"time"
    30  
    31  	"github.com/ethereum/go-ethereum/common"
    32  	"github.com/ethereum/go-ethereum/common/mclock"
    33  	"github.com/ethereum/go-ethereum/crypto"
    34  	"github.com/ethereum/go-ethereum/event"
    35  	"github.com/ethereum/go-ethereum/log"
    36  	"github.com/ethereum/go-ethereum/p2p/discover"
    37  	"github.com/ethereum/go-ethereum/p2p/discv5"
    38  	"github.com/ethereum/go-ethereum/p2p/enode"
    39  	"github.com/ethereum/go-ethereum/p2p/enr"
    40  	"github.com/ethereum/go-ethereum/p2p/nat"
    41  	"github.com/ethereum/go-ethereum/p2p/netutil"
    42  	"github.com/ethereum/go-ethereum/rlp"
    43  )
    44  
    45  const (
    46  	defaultDialTimeout = 15 * time.Second
    47  
    48  	// Connectivity defaults.
    49  	maxActiveDialTasks     = 16
    50  	defaultMaxPendingPeers = 50
    51  	defaultDialRatio       = 3
    52  
    53  	// Maximum time allowed for reading a complete message.
    54  	// This is effectively the amount of time a connection can be idle.
    55  	frameReadTimeout = 30 * time.Second
    56  
    57  	// Maximum amount of time allowed for writing a complete message.
    58  	frameWriteTimeout = 20 * time.Second
    59  )
    60  
    61  var errServerStopped = errors.New("server stopped")
    62  
    63  // Config holds Server options.
    64  type Config struct {
    65  	// This field must be set to a valid secp256k1 private key.
    66  	PrivateKey *ecdsa.PrivateKey `toml:"-"`
    67  
    68  	// MaxPeers is the maximum number of peers that can be
    69  	// connected. It must be greater than zero.
    70  	MaxPeers int
    71  
    72  	// MaxPendingPeers is the maximum number of peers that can be pending in the
    73  	// handshake phase, counted separately for inbound and outbound connections.
    74  	// Zero defaults to preset values.
    75  	MaxPendingPeers int `toml:",omitempty"`
    76  
    77  	// DialRatio controls the ratio of inbound to dialed connections.
    78  	// Example: a DialRatio of 2 allows 1/2 of connections to be dialed.
    79  	// Setting DialRatio to zero defaults it to 3.
    80  	DialRatio int `toml:",omitempty"`
    81  
    82  	// NoDiscovery can be used to disable the peer discovery mechanism.
    83  	// Disabling is useful for protocol debugging (manual topology).
    84  	NoDiscovery bool
    85  
    86  	// DiscoveryV5 specifies whether the new topic-discovery based V5 discovery
    87  	// protocol should be started or not.
    88  	DiscoveryV5 bool `toml:",omitempty"`
    89  
    90  	// Name sets the node name of this server.
    91  	// Use common.MakeName to create a name that follows existing conventions.
    92  	Name string `toml:"-"`
    93  
    94  	// BootstrapNodes are used to establish connectivity
    95  	// with the rest of the network.
    96  	BootstrapNodes []*enode.Node
    97  
    98  	// BootstrapNodesV5 are used to establish connectivity
    99  	// with the rest of the network using the V5 discovery
   100  	// protocol.
   101  	BootstrapNodesV5 []*discv5.Node `toml:",omitempty"`
   102  
   103  	// Static nodes are used as pre-configured connections which are always
   104  	// maintained and re-connected on disconnects.
   105  	StaticNodes []*enode.Node
   106  
   107  	// Trusted nodes are used as pre-configured connections which are always
   108  	// allowed to connect, even above the peer limit.
   109  	TrustedNodes []*enode.Node
   110  
   111  	// Connectivity can be restricted to certain IP networks.
   112  	// If this option is set to a non-nil value, only hosts which match one of the
   113  	// IP networks contained in the list are considered.
   114  	NetRestrict *netutil.Netlist `toml:",omitempty"`
   115  
   116  	// NodeDatabase is the path to the database containing the previously seen
   117  	// live nodes in the network.
   118  	NodeDatabase string `toml:",omitempty"`
   119  
   120  	// Protocols should contain the protocols supported
   121  	// by the server. Matching protocols are launched for
   122  	// each peer.
   123  	Protocols []Protocol `toml:"-"`
   124  
   125  	// If ListenAddr is set to a non-nil address, the server
   126  	// will listen for incoming connections.
   127  	//
   128  	// If the port is zero, the operating system will pick a port. The
   129  	// ListenAddr field will be updated with the actual address when
   130  	// the server is started.
   131  	ListenAddr string
   132  
   133  	// If set to a non-nil value, the given NAT port mapper
   134  	// is used to make the listening port available to the
   135  	// Internet.
   136  	NAT nat.Interface `toml:",omitempty"`
   137  
   138  	// If Dialer is set to a non-nil value, the given Dialer
   139  	// is used to dial outbound peer connections.
   140  	Dialer NodeDialer `toml:"-"`
   141  
   142  	// If NoDial is true, the server will not dial any peers.
   143  	NoDial bool `toml:",omitempty"`
   144  
   145  	// If EnableMsgEvents is set then the server will emit PeerEvents
   146  	// whenever a message is sent to or received from a peer
   147  	EnableMsgEvents bool
   148  
   149  	// Logger is a custom logger to use with the p2p.Server.
   150  	Logger log.Logger `toml:",omitempty"`
   151  }
   152  
   153  // Server manages all peer connections.
   154  type Server struct {
   155  	// Config fields may not be modified while the server is running.
   156  	Config
   157  
   158  	// Hooks for testing. These are useful because we can inhibit
   159  	// the whole protocol stack.
   160  	newTransport func(net.Conn) transport
   161  	newPeerHook  func(*Peer)
   162  
   163  	lock    sync.Mutex // protects running
   164  	running bool
   165  
   166  	nodedb       *enode.DB
   167  	localnode    *enode.LocalNode
   168  	ntab         discoverTable
   169  	listener     net.Listener
   170  	ourHandshake *protoHandshake
   171  	lastLookup   time.Time
   172  	DiscV5       *discv5.Network
   173  
   174  	// These are for Peers, PeerCount (and nothing else).
   175  	peerOp     chan peerOpFunc
   176  	peerOpDone chan struct{}
   177  
   178  	quit          chan struct{}
   179  	addstatic     chan *enode.Node
   180  	removestatic  chan *enode.Node
   181  	addtrusted    chan *enode.Node
   182  	removetrusted chan *enode.Node
   183  	posthandshake chan *conn
   184  	addpeer       chan *conn
   185  	delpeer       chan peerDrop
   186  	loopWG        sync.WaitGroup // loop, listenLoop
   187  	peerFeed      event.Feed
   188  	log           log.Logger
   189  }
   190  
   191  type peerOpFunc func(map[enode.ID]*Peer)
   192  
   193  type peerDrop struct {
   194  	*Peer
   195  	err       error
   196  	requested bool // true if signaled by the peer
   197  }
   198  
   199  type connFlag int32
   200  
   201  const (
   202  	dynDialedConn connFlag = 1 << iota
   203  	staticDialedConn
   204  	inboundConn
   205  	trustedConn
   206  )
   207  
   208  // conn wraps a network connection with information gathered
   209  // during the two handshakes.
   210  type conn struct {
   211  	fd net.Conn
   212  	transport
   213  	node  *enode.Node
   214  	flags connFlag
   215  	cont  chan error // The run loop uses cont to signal errors to SetupConn.
   216  	caps  []Cap      // valid after the protocol handshake
   217  	name  string     // valid after the protocol handshake
   218  }
   219  
   220  type transport interface {
   221  	// The two handshakes.
   222  	doEncHandshake(prv *ecdsa.PrivateKey, dialDest *ecdsa.PublicKey) (*ecdsa.PublicKey, error)
   223  	doProtoHandshake(our *protoHandshake) (*protoHandshake, error)
   224  	// The MsgReadWriter can only be used after the encryption
   225  	// handshake has completed. The code uses conn.id to track this
   226  	// by setting it to a non-nil value after the encryption handshake.
   227  	MsgReadWriter
   228  	// transports must provide Close because we use MsgPipe in some of
   229  	// the tests. Closing the actual network connection doesn't do
   230  	// anything in those tests because MsgPipe doesn't use it.
   231  	close(err error)
   232  }
   233  
   234  func (c *conn) String() string {
   235  	s := c.flags.String()
   236  	if (c.node.ID() != enode.ID{}) {
   237  		s += " " + c.node.ID().String()
   238  	}
   239  	s += " " + c.fd.RemoteAddr().String()
   240  	return s
   241  }
   242  
   243  func (f connFlag) String() string {
   244  	s := ""
   245  	if f&trustedConn != 0 {
   246  		s += "-trusted"
   247  	}
   248  	if f&dynDialedConn != 0 {
   249  		s += "-dyndial"
   250  	}
   251  	if f&staticDialedConn != 0 {
   252  		s += "-staticdial"
   253  	}
   254  	if f&inboundConn != 0 {
   255  		s += "-inbound"
   256  	}
   257  	if s != "" {
   258  		s = s[1:]
   259  	}
   260  	return s
   261  }
   262  
   263  func (c *conn) is(f connFlag) bool {
   264  	flags := connFlag(atomic.LoadInt32((*int32)(&c.flags)))
   265  	return flags&f != 0
   266  }
   267  
   268  func (c *conn) set(f connFlag, val bool) {
   269  	for {
   270  		oldFlags := connFlag(atomic.LoadInt32((*int32)(&c.flags)))
   271  		flags := oldFlags
   272  		if val {
   273  			flags |= f
   274  		} else {
   275  			flags &= ^f
   276  		}
   277  		if atomic.CompareAndSwapInt32((*int32)(&c.flags), int32(oldFlags), int32(flags)) {
   278  			return
   279  		}
   280  	}
   281  }
   282  
   283  // Peers returns all connected peers.
   284  func (srv *Server) Peers() []*Peer {
   285  	var ps []*Peer
   286  	select {
   287  	// Note: We'd love to put this function into a variable but
   288  	// that seems to cause a weird compiler error in some
   289  	// environments.
   290  	case srv.peerOp <- func(peers map[enode.ID]*Peer) {
   291  		for _, p := range peers {
   292  			ps = append(ps, p)
   293  		}
   294  	}:
   295  		<-srv.peerOpDone
   296  	case <-srv.quit:
   297  	}
   298  	return ps
   299  }
   300  
   301  // PeerCount returns the number of connected peers.
   302  func (srv *Server) PeerCount() int {
   303  	var count int
   304  	select {
   305  	case srv.peerOp <- func(ps map[enode.ID]*Peer) { count = len(ps) }:
   306  		<-srv.peerOpDone
   307  	case <-srv.quit:
   308  	}
   309  	return count
   310  }
   311  
   312  // AddPeer connects to the given node and maintains the connection until the
   313  // server is shut down. If the connection fails for any reason, the server will
   314  // attempt to reconnect the peer.
   315  func (srv *Server) AddPeer(node *enode.Node) {
   316  	select {
   317  	case srv.addstatic <- node:
   318  	case <-srv.quit:
   319  	}
   320  }
   321  
   322  // RemovePeer disconnects from the given node
   323  func (srv *Server) RemovePeer(node *enode.Node) {
   324  	select {
   325  	case srv.removestatic <- node:
   326  	case <-srv.quit:
   327  	}
   328  }
   329  
   330  // AddTrustedPeer adds the given node to a reserved whitelist which allows the
   331  // node to always connect, even if the slot are full.
   332  func (srv *Server) AddTrustedPeer(node *enode.Node) {
   333  	select {
   334  	case srv.addtrusted <- node:
   335  	case <-srv.quit:
   336  	}
   337  }
   338  
   339  // RemoveTrustedPeer removes the given node from the trusted peer set.
   340  func (srv *Server) RemoveTrustedPeer(node *enode.Node) {
   341  	select {
   342  	case srv.removetrusted <- node:
   343  	case <-srv.quit:
   344  	}
   345  }
   346  
   347  // SubscribePeers subscribes the given channel to peer events
   348  func (srv *Server) SubscribeEvents(ch chan *PeerEvent) event.Subscription {
   349  	return srv.peerFeed.Subscribe(ch)
   350  }
   351  
   352  // Self returns the local node's endpoint information.
   353  func (srv *Server) Self() *enode.Node {
   354  	srv.lock.Lock()
   355  	ln := srv.localnode
   356  	srv.lock.Unlock()
   357  
   358  	if ln == nil {
   359  		return enode.NewV4(&srv.PrivateKey.PublicKey, net.ParseIP("0.0.0.0"), 0, 0)
   360  	}
   361  	return ln.Node()
   362  }
   363  
   364  // Stop terminates the server and all active peer connections.
   365  // It blocks until all active connections have been closed.
   366  func (srv *Server) Stop() {
   367  	srv.lock.Lock()
   368  	if !srv.running {
   369  		srv.lock.Unlock()
   370  		return
   371  	}
   372  	srv.running = false
   373  	if srv.listener != nil {
   374  		// this unblocks listener Accept
   375  		srv.listener.Close()
   376  	}
   377  	close(srv.quit)
   378  	srv.lock.Unlock()
   379  	srv.loopWG.Wait()
   380  }
   381  
   382  // sharedUDPConn implements a shared connection. Write sends messages to the underlying connection while read returns
   383  // messages that were found unprocessable and sent to the unhandled channel by the primary listener.
   384  type sharedUDPConn struct {
   385  	*net.UDPConn
   386  	unhandled chan discover.ReadPacket
   387  }
   388  
   389  // ReadFromUDP implements discv5.conn
   390  func (s *sharedUDPConn) ReadFromUDP(b []byte) (n int, addr *net.UDPAddr, err error) {
   391  	packet, ok := <-s.unhandled
   392  	if !ok {
   393  		return 0, nil, errors.New("Connection was closed")
   394  	}
   395  	l := len(packet.Data)
   396  	if l > len(b) {
   397  		l = len(b)
   398  	}
   399  	copy(b[:l], packet.Data[:l])
   400  	return l, packet.Addr, nil
   401  }
   402  
   403  // Close implements discv5.conn
   404  func (s *sharedUDPConn) Close() error {
   405  	return nil
   406  }
   407  
   408  // Start starts running the server.
   409  // Servers can not be re-used after stopping.
   410  func (srv *Server) Start() (err error) {
   411  	srv.lock.Lock()
   412  	defer srv.lock.Unlock()
   413  	if srv.running {
   414  		return errors.New("server already running")
   415  	}
   416  	srv.running = true
   417  	srv.log = srv.Config.Logger
   418  	if srv.log == nil {
   419  		srv.log = log.New()
   420  	}
   421  	if srv.NoDial && srv.ListenAddr == "" {
   422  		srv.log.Warn("P2P server will be useless, neither dialing nor listening")
   423  	}
   424  
   425  	// static fields
   426  	if srv.PrivateKey == nil {
   427  		return errors.New("Server.PrivateKey must be set to a non-nil key")
   428  	}
   429  	if srv.newTransport == nil {
   430  		srv.newTransport = newRLPX
   431  	}
   432  	if srv.Dialer == nil {
   433  		srv.Dialer = TCPDialer{&net.Dialer{Timeout: defaultDialTimeout}}
   434  	}
   435  	srv.quit = make(chan struct{})
   436  	srv.addpeer = make(chan *conn)
   437  	srv.delpeer = make(chan peerDrop)
   438  	srv.posthandshake = make(chan *conn)
   439  	srv.addstatic = make(chan *enode.Node)
   440  	srv.removestatic = make(chan *enode.Node)
   441  	srv.addtrusted = make(chan *enode.Node)
   442  	srv.removetrusted = make(chan *enode.Node)
   443  	srv.peerOp = make(chan peerOpFunc)
   444  	srv.peerOpDone = make(chan struct{})
   445  
   446  	if err := srv.setupLocalNode(); err != nil {
   447  		return err
   448  	}
   449  	if srv.ListenAddr != "" {
   450  		if err := srv.setupListening(); err != nil {
   451  			return err
   452  		}
   453  	}
   454  	if err := srv.setupDiscovery(); err != nil {
   455  		return err
   456  	}
   457  
   458  	dynPeers := srv.maxDialedConns()
   459  	dialer := newDialState(srv.localnode.ID(), srv.StaticNodes, srv.BootstrapNodes, srv.ntab, dynPeers, srv.NetRestrict)
   460  	srv.loopWG.Add(1)
   461  	go srv.run(dialer)
   462  	return nil
   463  }
   464  
   465  func (srv *Server) setupLocalNode() error {
   466  	// Create the devp2p handshake.
   467  	pubkey := crypto.FromECDSAPub(&srv.PrivateKey.PublicKey)
   468  	srv.ourHandshake = &protoHandshake{Version: baseProtocolVersion, Name: srv.Name, ID: pubkey[1:]}
   469  	for _, p := range srv.Protocols {
   470  		srv.ourHandshake.Caps = append(srv.ourHandshake.Caps, p.cap())
   471  	}
   472  	sort.Sort(capsByNameAndVersion(srv.ourHandshake.Caps))
   473  
   474  	// Create the local node.
   475  	db, err := enode.OpenDB(srv.Config.NodeDatabase)
   476  	if err != nil {
   477  		return err
   478  	}
   479  	srv.nodedb = db
   480  	srv.localnode = enode.NewLocalNode(db, srv.PrivateKey)
   481  	srv.localnode.SetFallbackIP(net.IP{127, 0, 0, 1})
   482  	srv.localnode.Set(capsByNameAndVersion(srv.ourHandshake.Caps))
   483  	// TODO: check conflicts
   484  	for _, p := range srv.Protocols {
   485  		for _, e := range p.Attributes {
   486  			srv.localnode.Set(e)
   487  		}
   488  	}
   489  	switch srv.NAT.(type) {
   490  	case nil:
   491  		// No NAT interface, do nothing.
   492  	case nat.ExtIP:
   493  		// ExtIP doesn't block, set the IP right away.
   494  		ip, _ := srv.NAT.ExternalIP()
   495  		srv.localnode.SetStaticIP(ip)
   496  	default:
   497  		// Ask the router about the IP. This takes a while and blocks startup,
   498  		// do it in the background.
   499  		srv.loopWG.Add(1)
   500  		go func() {
   501  			defer srv.loopWG.Done()
   502  			if ip, err := srv.NAT.ExternalIP(); err == nil {
   503  				srv.localnode.SetStaticIP(ip)
   504  			}
   505  		}()
   506  	}
   507  	return nil
   508  }
   509  
   510  func (srv *Server) setupDiscovery() error {
   511  	if srv.NoDiscovery && !srv.DiscoveryV5 {
   512  		return nil
   513  	}
   514  
   515  	addr, err := net.ResolveUDPAddr("udp", srv.ListenAddr)
   516  	if err != nil {
   517  		return err
   518  	}
   519  	conn, err := net.ListenUDP("udp", addr)
   520  	if err != nil {
   521  		return err
   522  	}
   523  	realaddr := conn.LocalAddr().(*net.UDPAddr)
   524  	srv.log.Debug("UDP listener up", "addr", realaddr)
   525  	if srv.NAT != nil {
   526  		if !realaddr.IP.IsLoopback() {
   527  			go nat.Map(srv.NAT, srv.quit, "udp", realaddr.Port, realaddr.Port, "ethereum discovery")
   528  		}
   529  	}
   530  	srv.localnode.SetFallbackUDP(realaddr.Port)
   531  
   532  	// Discovery V4
   533  	var unhandled chan discover.ReadPacket
   534  	var sconn *sharedUDPConn
   535  	if !srv.NoDiscovery {
   536  		if srv.DiscoveryV5 {
   537  			unhandled = make(chan discover.ReadPacket, 100)
   538  			sconn = &sharedUDPConn{conn, unhandled}
   539  		}
   540  		cfg := discover.Config{
   541  			PrivateKey:  srv.PrivateKey,
   542  			NetRestrict: srv.NetRestrict,
   543  			Bootnodes:   srv.BootstrapNodes,
   544  			Unhandled:   unhandled,
   545  		}
   546  		ntab, err := discover.ListenUDP(conn, srv.localnode, cfg)
   547  		if err != nil {
   548  			return err
   549  		}
   550  		srv.ntab = ntab
   551  	}
   552  	// Discovery V5
   553  	if srv.DiscoveryV5 {
   554  		var ntab *discv5.Network
   555  		var err error
   556  		if sconn != nil {
   557  			ntab, err = discv5.ListenUDP(srv.PrivateKey, sconn, "", srv.NetRestrict)
   558  		} else {
   559  			ntab, err = discv5.ListenUDP(srv.PrivateKey, conn, "", srv.NetRestrict)
   560  		}
   561  		if err != nil {
   562  			return err
   563  		}
   564  		if err := ntab.SetFallbackNodes(srv.BootstrapNodesV5); err != nil {
   565  			return err
   566  		}
   567  		srv.DiscV5 = ntab
   568  	}
   569  	return nil
   570  }
   571  
   572  func (srv *Server) setupListening() error {
   573  	// Launch the TCP listener.
   574  	listener, err := net.Listen("tcp", srv.ListenAddr)
   575  	if err != nil {
   576  		return err
   577  	}
   578  	laddr := listener.Addr().(*net.TCPAddr)
   579  	srv.ListenAddr = laddr.String()
   580  	srv.listener = listener
   581  	srv.localnode.Set(enr.TCP(laddr.Port))
   582  
   583  	srv.loopWG.Add(1)
   584  	go srv.listenLoop()
   585  
   586  	// Map the TCP listening port if NAT is configured.
   587  	if !laddr.IP.IsLoopback() && srv.NAT != nil {
   588  		srv.loopWG.Add(1)
   589  		go func() {
   590  			nat.Map(srv.NAT, srv.quit, "tcp", laddr.Port, laddr.Port, "ethereum p2p")
   591  			srv.loopWG.Done()
   592  		}()
   593  	}
   594  	return nil
   595  }
   596  
   597  type dialer interface {
   598  	newTasks(running int, peers map[enode.ID]*Peer, now time.Time) []task
   599  	taskDone(task, time.Time)
   600  	addStatic(*enode.Node)
   601  	removeStatic(*enode.Node)
   602  }
   603  
   604  func (srv *Server) run(dialstate dialer) {
   605  	srv.log.Info("Started P2P networking", "self", srv.localnode.Node())
   606  	defer srv.loopWG.Done()
   607  	defer srv.nodedb.Close()
   608  
   609  	var (
   610  		peers        = make(map[enode.ID]*Peer)
   611  		inboundCount = 0
   612  		trusted      = make(map[enode.ID]bool, len(srv.TrustedNodes))
   613  		taskdone     = make(chan task, maxActiveDialTasks)
   614  		runningTasks []task
   615  		queuedTasks  []task // tasks that can't run yet
   616  	)
   617  	// Put trusted nodes into a map to speed up checks.
   618  	// Trusted peers are loaded on startup or added via AddTrustedPeer RPC.
   619  	for _, n := range srv.TrustedNodes {
   620  		trusted[n.ID()] = true
   621  	}
   622  
   623  	// removes t from runningTasks
   624  	delTask := func(t task) {
   625  		for i := range runningTasks {
   626  			if runningTasks[i] == t {
   627  				runningTasks = append(runningTasks[:i], runningTasks[i+1:]...)
   628  				break
   629  			}
   630  		}
   631  	}
   632  	// starts until max number of active tasks is satisfied
   633  	startTasks := func(ts []task) (rest []task) {
   634  		i := 0
   635  		for ; len(runningTasks) < maxActiveDialTasks && i < len(ts); i++ {
   636  			t := ts[i]
   637  			srv.log.Trace("New dial task", "task", t)
   638  			go func() { t.Do(srv); taskdone <- t }()
   639  			runningTasks = append(runningTasks, t)
   640  		}
   641  		return ts[i:]
   642  	}
   643  	scheduleTasks := func() {
   644  		// Start from queue first.
   645  		queuedTasks = append(queuedTasks[:0], startTasks(queuedTasks)...)
   646  		// Query dialer for new tasks and start as many as possible now.
   647  		if len(runningTasks) < maxActiveDialTasks {
   648  			nt := dialstate.newTasks(len(runningTasks)+len(queuedTasks), peers, time.Now())
   649  			queuedTasks = append(queuedTasks, startTasks(nt)...)
   650  		}
   651  	}
   652  
   653  running:
   654  	for {
   655  		scheduleTasks()
   656  
   657  		select {
   658  		case <-srv.quit:
   659  			// The server was stopped. Run the cleanup logic.
   660  			break running
   661  		case n := <-srv.addstatic:
   662  			// This channel is used by AddPeer to add to the
   663  			// ephemeral static peer list. Add it to the dialer,
   664  			// it will keep the node connected.
   665  			srv.log.Trace("Adding static node", "node", n)
   666  			dialstate.addStatic(n)
   667  		case n := <-srv.removestatic:
   668  			// This channel is used by RemovePeer to send a
   669  			// disconnect request to a peer and begin the
   670  			// stop keeping the node connected.
   671  			srv.log.Trace("Removing static node", "node", n)
   672  			dialstate.removeStatic(n)
   673  			if p, ok := peers[n.ID()]; ok {
   674  				p.Disconnect(DiscRequested)
   675  			}
   676  		case n := <-srv.addtrusted:
   677  			// This channel is used by AddTrustedPeer to add an enode
   678  			// to the trusted node set.
   679  			srv.log.Trace("Adding trusted node", "node", n)
   680  			trusted[n.ID()] = true
   681  			// Mark any already-connected peer as trusted
   682  			if p, ok := peers[n.ID()]; ok {
   683  				p.rw.set(trustedConn, true)
   684  			}
   685  		case n := <-srv.removetrusted:
   686  			// This channel is used by RemoveTrustedPeer to remove an enode
   687  			// from the trusted node set.
   688  			srv.log.Trace("Removing trusted node", "node", n)
   689  			if _, ok := trusted[n.ID()]; ok {
   690  				delete(trusted, n.ID())
   691  			}
   692  			// Unmark any already-connected peer as trusted
   693  			if p, ok := peers[n.ID()]; ok {
   694  				p.rw.set(trustedConn, false)
   695  			}
   696  		case op := <-srv.peerOp:
   697  			// This channel is used by Peers and PeerCount.
   698  			op(peers)
   699  			srv.peerOpDone <- struct{}{}
   700  		case t := <-taskdone:
   701  			// A task got done. Tell dialstate about it so it
   702  			// can update its state and remove it from the active
   703  			// tasks list.
   704  			srv.log.Trace("Dial task done", "task", t)
   705  			dialstate.taskDone(t, time.Now())
   706  			delTask(t)
   707  		case c := <-srv.posthandshake:
   708  			// A connection has passed the encryption handshake so
   709  			// the remote identity is known (but hasn't been verified yet).
   710  			if trusted[c.node.ID()] {
   711  				// Ensure that the trusted flag is set before checking against MaxPeers.
   712  				c.flags |= trustedConn
   713  			}
   714  			// TODO: track in-progress inbound node IDs (pre-Peer) to avoid dialing them.
   715  			select {
   716  			case c.cont <- srv.encHandshakeChecks(peers, inboundCount, c):
   717  			case <-srv.quit:
   718  				break running
   719  			}
   720  		case c := <-srv.addpeer:
   721  			// At this point the connection is past the protocol handshake.
   722  			// Its capabilities are known and the remote identity is verified.
   723  			err := srv.protoHandshakeChecks(peers, inboundCount, c)
   724  			if err == nil {
   725  				// The handshakes are done and it passed all checks.
   726  				p := newPeer(c, srv.Protocols)
   727  				// If message events are enabled, pass the peerFeed
   728  				// to the peer
   729  				if srv.EnableMsgEvents {
   730  					p.events = &srv.peerFeed
   731  				}
   732  				name := truncateName(c.name)
   733  				srv.log.Debug("Adding p2p peer", "name", name, "addr", c.fd.RemoteAddr(), "peers", len(peers)+1)
   734  				go srv.runPeer(p)
   735  				peers[c.node.ID()] = p
   736  				if p.Inbound() {
   737  					inboundCount++
   738  				}
   739  			}
   740  			// The dialer logic relies on the assumption that
   741  			// dial tasks complete after the peer has been added or
   742  			// discarded. Unblock the task last.
   743  			select {
   744  			case c.cont <- err:
   745  			case <-srv.quit:
   746  				break running
   747  			}
   748  		case pd := <-srv.delpeer:
   749  			// A peer disconnected.
   750  			d := common.PrettyDuration(mclock.Now() - pd.created)
   751  			pd.log.Debug("Removing p2p peer", "duration", d, "peers", len(peers)-1, "req", pd.requested, "err", pd.err)
   752  			delete(peers, pd.ID())
   753  			if pd.Inbound() {
   754  				inboundCount--
   755  			}
   756  		}
   757  	}
   758  
   759  	srv.log.Trace("P2P networking is spinning down")
   760  
   761  	// Terminate discovery. If there is a running lookup it will terminate soon.
   762  	if srv.ntab != nil {
   763  		srv.ntab.Close()
   764  	}
   765  	if srv.DiscV5 != nil {
   766  		srv.DiscV5.Close()
   767  	}
   768  	// Disconnect all peers.
   769  	for _, p := range peers {
   770  		p.Disconnect(DiscQuitting)
   771  	}
   772  	// Wait for peers to shut down. Pending connections and tasks are
   773  	// not handled here and will terminate soon-ish because srv.quit
   774  	// is closed.
   775  	for len(peers) > 0 {
   776  		p := <-srv.delpeer
   777  		p.log.Trace("<-delpeer (spindown)", "remainingTasks", len(runningTasks))
   778  		delete(peers, p.ID())
   779  	}
   780  }
   781  
   782  func (srv *Server) protoHandshakeChecks(peers map[enode.ID]*Peer, inboundCount int, c *conn) error {
   783  	// Drop connections with no matching protocols.
   784  	if len(srv.Protocols) > 0 && countMatchingProtocols(srv.Protocols, c.caps) == 0 {
   785  		return DiscUselessPeer
   786  	}
   787  	// Repeat the encryption handshake checks because the
   788  	// peer set might have changed between the handshakes.
   789  	return srv.encHandshakeChecks(peers, inboundCount, c)
   790  }
   791  
   792  func (srv *Server) encHandshakeChecks(peers map[enode.ID]*Peer, inboundCount int, c *conn) error {
   793  	switch {
   794  	case !c.is(trustedConn|staticDialedConn) && len(peers) >= srv.MaxPeers:
   795  		return DiscTooManyPeers
   796  	case !c.is(trustedConn) && c.is(inboundConn) && inboundCount >= srv.maxInboundConns():
   797  		return DiscTooManyPeers
   798  	case peers[c.node.ID()] != nil:
   799  		return DiscAlreadyConnected
   800  	case c.node.ID() == srv.localnode.ID():
   801  		return DiscSelf
   802  	default:
   803  		return nil
   804  	}
   805  }
   806  
   807  func (srv *Server) maxInboundConns() int {
   808  	return srv.MaxPeers - srv.maxDialedConns()
   809  }
   810  func (srv *Server) maxDialedConns() int {
   811  	if srv.NoDiscovery || srv.NoDial {
   812  		return 0
   813  	}
   814  	r := srv.DialRatio
   815  	if r == 0 {
   816  		r = defaultDialRatio
   817  	}
   818  	return srv.MaxPeers / r
   819  }
   820  
   821  // listenLoop runs in its own goroutine and accepts
   822  // inbound connections.
   823  func (srv *Server) listenLoop() {
   824  	defer srv.loopWG.Done()
   825  	srv.log.Debug("TCP listener up", "addr", srv.listener.Addr())
   826  
   827  	tokens := defaultMaxPendingPeers
   828  	if srv.MaxPendingPeers > 0 {
   829  		tokens = srv.MaxPendingPeers
   830  	}
   831  	slots := make(chan struct{}, tokens)
   832  	for i := 0; i < tokens; i++ {
   833  		slots <- struct{}{}
   834  	}
   835  
   836  	for {
   837  		// Wait for a handshake slot before accepting.
   838  		<-slots
   839  
   840  		var (
   841  			fd  net.Conn
   842  			err error
   843  		)
   844  		for {
   845  			fd, err = srv.listener.Accept()
   846  			if netutil.IsTemporaryError(err) {
   847  				srv.log.Debug("Temporary read error", "err", err)
   848  				continue
   849  			} else if err != nil {
   850  				srv.log.Debug("Read error", "err", err)
   851  				return
   852  			}
   853  			break
   854  		}
   855  
   856  		// Reject connections that do not match NetRestrict.
   857  		if srv.NetRestrict != nil {
   858  			if tcp, ok := fd.RemoteAddr().(*net.TCPAddr); ok && !srv.NetRestrict.Contains(tcp.IP) {
   859  				srv.log.Debug("Rejected conn (not whitelisted in NetRestrict)", "addr", fd.RemoteAddr())
   860  				fd.Close()
   861  				slots <- struct{}{}
   862  				continue
   863  			}
   864  		}
   865  
   866  		var ip net.IP
   867  		if tcp, ok := fd.RemoteAddr().(*net.TCPAddr); ok {
   868  			ip = tcp.IP
   869  		}
   870  		fd = newMeteredConn(fd, true, ip)
   871  		srv.log.Trace("Accepted connection", "addr", fd.RemoteAddr())
   872  		go func() {
   873  			srv.SetupConn(fd, inboundConn, nil)
   874  			slots <- struct{}{}
   875  		}()
   876  	}
   877  }
   878  
   879  // SetupConn runs the handshakes and attempts to add the connection
   880  // as a peer. It returns when the connection has been added as a peer
   881  // or the handshakes have failed.
   882  func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error {
   883  	c := &conn{fd: fd, transport: srv.newTransport(fd), flags: flags, cont: make(chan error)}
   884  	err := srv.setupConn(c, flags, dialDest)
   885  	if err != nil {
   886  		c.close(err)
   887  		srv.log.Trace("Setting up connection failed", "addr", fd.RemoteAddr(), "err", err)
   888  	}
   889  	return err
   890  }
   891  
   892  func (srv *Server) setupConn(c *conn, flags connFlag, dialDest *enode.Node) error {
   893  	// Prevent leftover pending conns from entering the handshake.
   894  	srv.lock.Lock()
   895  	running := srv.running
   896  	srv.lock.Unlock()
   897  	if !running {
   898  		return errServerStopped
   899  	}
   900  	// If dialing, figure out the remote public key.
   901  	var dialPubkey *ecdsa.PublicKey
   902  	if dialDest != nil {
   903  		dialPubkey = new(ecdsa.PublicKey)
   904  		if err := dialDest.Load((*enode.Secp256k1)(dialPubkey)); err != nil {
   905  			return errors.New("dial destination doesn't have a secp256k1 public key")
   906  		}
   907  	}
   908  	// Run the encryption handshake.
   909  	remotePubkey, err := c.doEncHandshake(srv.PrivateKey, dialPubkey)
   910  	if err != nil {
   911  		srv.log.Trace("Failed RLPx handshake", "addr", c.fd.RemoteAddr(), "conn", c.flags, "err", err)
   912  		return err
   913  	}
   914  	if dialDest != nil {
   915  		// For dialed connections, check that the remote public key matches.
   916  		if dialPubkey.X.Cmp(remotePubkey.X) != 0 || dialPubkey.Y.Cmp(remotePubkey.Y) != 0 {
   917  			return DiscUnexpectedIdentity
   918  		}
   919  		c.node = dialDest
   920  	} else {
   921  		c.node = nodeFromConn(remotePubkey, c.fd)
   922  	}
   923  	if conn, ok := c.fd.(*meteredConn); ok {
   924  		conn.handshakeDone(c.node.ID())
   925  	}
   926  	clog := srv.log.New("id", c.node.ID(), "addr", c.fd.RemoteAddr(), "conn", c.flags)
   927  	err = srv.checkpoint(c, srv.posthandshake)
   928  	if err != nil {
   929  		clog.Trace("Rejected peer before protocol handshake", "err", err)
   930  		return err
   931  	}
   932  	// Run the protocol handshake
   933  	phs, err := c.doProtoHandshake(srv.ourHandshake)
   934  	if err != nil {
   935  		clog.Trace("Failed proto handshake", "err", err)
   936  		return err
   937  	}
   938  	if id := c.node.ID(); !bytes.Equal(crypto.Keccak256(phs.ID), id[:]) {
   939  		clog.Trace("Wrong devp2p handshake identity", "phsid", hex.EncodeToString(phs.ID))
   940  		return DiscUnexpectedIdentity
   941  	}
   942  	c.caps, c.name = phs.Caps, phs.Name
   943  	err = srv.checkpoint(c, srv.addpeer)
   944  	if err != nil {
   945  		clog.Trace("Rejected peer", "err", err)
   946  		return err
   947  	}
   948  	// If the checks completed successfully, runPeer has now been
   949  	// launched by run.
   950  	clog.Trace("connection set up", "inbound", dialDest == nil)
   951  	return nil
   952  }
   953  
   954  func nodeFromConn(pubkey *ecdsa.PublicKey, conn net.Conn) *enode.Node {
   955  	var ip net.IP
   956  	var port int
   957  	if tcp, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
   958  		ip = tcp.IP
   959  		port = tcp.Port
   960  	}
   961  	return enode.NewV4(pubkey, ip, port, port)
   962  }
   963  
   964  func truncateName(s string) string {
   965  	if len(s) > 20 {
   966  		return s[:20] + "..."
   967  	}
   968  	return s
   969  }
   970  
   971  // checkpoint sends the conn to run, which performs the
   972  // post-handshake checks for the stage (posthandshake, addpeer).
   973  func (srv *Server) checkpoint(c *conn, stage chan<- *conn) error {
   974  	select {
   975  	case stage <- c:
   976  	case <-srv.quit:
   977  		return errServerStopped
   978  	}
   979  	select {
   980  	case err := <-c.cont:
   981  		return err
   982  	case <-srv.quit:
   983  		return errServerStopped
   984  	}
   985  }
   986  
   987  // runPeer runs in its own goroutine for each peer.
   988  // it waits until the Peer logic returns and removes
   989  // the peer.
   990  func (srv *Server) runPeer(p *Peer) {
   991  	if srv.newPeerHook != nil {
   992  		srv.newPeerHook(p)
   993  	}
   994  
   995  	// broadcast peer add
   996  	srv.peerFeed.Send(&PeerEvent{
   997  		Type: PeerEventTypeAdd,
   998  		Peer: p.ID(),
   999  	})
  1000  
  1001  	// run the protocol
  1002  	remoteRequested, err := p.run()
  1003  
  1004  	// broadcast peer drop
  1005  	srv.peerFeed.Send(&PeerEvent{
  1006  		Type:  PeerEventTypeDrop,
  1007  		Peer:  p.ID(),
  1008  		Error: err.Error(),
  1009  	})
  1010  
  1011  	// Note: run waits for existing peers to be sent on srv.delpeer
  1012  	// before returning, so this send should not select on srv.quit.
  1013  	srv.delpeer <- peerDrop{p, err, remoteRequested}
  1014  }
  1015  
  1016  // NodeInfo represents a short summary of the information known about the host.
  1017  type NodeInfo struct {
  1018  	ID    string `json:"id"`    // Unique node identifier (also the encryption key)
  1019  	Name  string `json:"name"`  // Name of the node, including client type, version, OS, custom data
  1020  	Enode string `json:"enode"` // Enode URL for adding this peer from remote peers
  1021  	ENR   string `json:"enr"`   // Ethereum Node Record
  1022  	IP    string `json:"ip"`    // IP address of the node
  1023  	Ports struct {
  1024  		Discovery int `json:"discovery"` // UDP listening port for discovery protocol
  1025  		Listener  int `json:"listener"`  // TCP listening port for RLPx
  1026  	} `json:"ports"`
  1027  	ListenAddr string                 `json:"listenAddr"`
  1028  	Protocols  map[string]interface{} `json:"protocols"`
  1029  }
  1030  
  1031  // NodeInfo gathers and returns a collection of metadata known about the host.
  1032  func (srv *Server) NodeInfo() *NodeInfo {
  1033  	// Gather and assemble the generic node infos
  1034  	node := srv.Self()
  1035  	info := &NodeInfo{
  1036  		Name:       srv.Name,
  1037  		Enode:      node.String(),
  1038  		ID:         node.ID().String(),
  1039  		IP:         node.IP().String(),
  1040  		ListenAddr: srv.ListenAddr,
  1041  		Protocols:  make(map[string]interface{}),
  1042  	}
  1043  	info.Ports.Discovery = node.UDP()
  1044  	info.Ports.Listener = node.TCP()
  1045  	if enc, err := rlp.EncodeToBytes(node.Record()); err == nil {
  1046  		info.ENR = "0x" + hex.EncodeToString(enc)
  1047  	}
  1048  
  1049  	// Gather all the running protocol infos (only once per protocol type)
  1050  	for _, proto := range srv.Protocols {
  1051  		if _, ok := info.Protocols[proto.Name]; !ok {
  1052  			nodeInfo := interface{}("unknown")
  1053  			if query := proto.NodeInfo; query != nil {
  1054  				nodeInfo = proto.NodeInfo()
  1055  			}
  1056  			info.Protocols[proto.Name] = nodeInfo
  1057  		}
  1058  	}
  1059  	return info
  1060  }
  1061  
  1062  // PeersInfo returns an array of metadata objects describing connected peers.
  1063  func (srv *Server) PeersInfo() []*PeerInfo {
  1064  	// Gather all the generic and sub-protocol specific infos
  1065  	infos := make([]*PeerInfo, 0, srv.PeerCount())
  1066  	for _, peer := range srv.Peers() {
  1067  		if peer != nil {
  1068  			infos = append(infos, peer.Info())
  1069  		}
  1070  	}
  1071  	// Sort the result array alphabetically by node identifier
  1072  	for i := 0; i < len(infos); i++ {
  1073  		for j := i + 1; j < len(infos); j++ {
  1074  			if infos[i].ID > infos[j].ID {
  1075  				infos[i], infos[j] = infos[j], infos[i]
  1076  			}
  1077  		}
  1078  	}
  1079  	return infos
  1080  }