github.com/needkane/go-ethereum@v1.7.4-0.20180131070256-c212876ea2b7/p2p/discv5/net.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 discv5
    18  
    19  import (
    20  	"bytes"
    21  	"crypto/ecdsa"
    22  	"errors"
    23  	"fmt"
    24  	"net"
    25  	"time"
    26  
    27  	"github.com/ethereum/go-ethereum/common"
    28  	"github.com/ethereum/go-ethereum/common/mclock"
    29  	"github.com/ethereum/go-ethereum/crypto"
    30  	"github.com/ethereum/go-ethereum/crypto/sha3"
    31  	"github.com/ethereum/go-ethereum/log"
    32  	"github.com/ethereum/go-ethereum/p2p/netutil"
    33  	"github.com/ethereum/go-ethereum/rlp"
    34  )
    35  
    36  var (
    37  	errInvalidEvent = errors.New("invalid in current state")
    38  	errNoQuery      = errors.New("no pending query")
    39  	errWrongAddress = errors.New("unknown sender address")
    40  )
    41  
    42  const (
    43  	autoRefreshInterval   = 1 * time.Hour
    44  	bucketRefreshInterval = 1 * time.Minute
    45  	seedCount             = 30
    46  	seedMaxAge            = 5 * 24 * time.Hour
    47  	lowPort               = 1024
    48  )
    49  
    50  const testTopic = "foo"
    51  
    52  const (
    53  	printTestImgLogs = false
    54  )
    55  
    56  // Network manages the table and all protocol interaction.
    57  type Network struct {
    58  	db          *nodeDB // database of known nodes
    59  	conn        transport
    60  	netrestrict *netutil.Netlist
    61  
    62  	closed           chan struct{}          // closed when loop is done
    63  	closeReq         chan struct{}          // 'request to close'
    64  	refreshReq       chan []*Node           // lookups ask for refresh on this channel
    65  	refreshResp      chan (<-chan struct{}) // ...and get the channel to block on from this one
    66  	read             chan ingressPacket     // ingress packets arrive here
    67  	timeout          chan timeoutEvent
    68  	queryReq         chan *findnodeQuery // lookups submit findnode queries on this channel
    69  	tableOpReq       chan func()
    70  	tableOpResp      chan struct{}
    71  	topicRegisterReq chan topicRegisterReq
    72  	topicSearchReq   chan topicSearchReq
    73  
    74  	// State of the main loop.
    75  	tab           *Table
    76  	topictab      *topicTable
    77  	ticketStore   *ticketStore
    78  	nursery       []*Node
    79  	nodes         map[NodeID]*Node // tracks active nodes with state != known
    80  	timeoutTimers map[timeoutEvent]*time.Timer
    81  
    82  	// Revalidation queues.
    83  	// Nodes put on these queues will be pinged eventually.
    84  	slowRevalidateQueue []*Node
    85  	fastRevalidateQueue []*Node
    86  
    87  	// Buffers for state transition.
    88  	sendBuf []*ingressPacket
    89  }
    90  
    91  // transport is implemented by the UDP transport.
    92  // it is an interface so we can test without opening lots of UDP
    93  // sockets and without generating a private key.
    94  type transport interface {
    95  	sendPing(remote *Node, remoteAddr *net.UDPAddr, topics []Topic) (hash []byte)
    96  	sendNeighbours(remote *Node, nodes []*Node)
    97  	sendFindnodeHash(remote *Node, target common.Hash)
    98  	sendTopicRegister(remote *Node, topics []Topic, topicIdx int, pong []byte)
    99  	sendTopicNodes(remote *Node, queryHash common.Hash, nodes []*Node)
   100  
   101  	send(remote *Node, ptype nodeEvent, p interface{}) (hash []byte)
   102  
   103  	localAddr() *net.UDPAddr
   104  	Close()
   105  }
   106  
   107  type findnodeQuery struct {
   108  	remote   *Node
   109  	target   common.Hash
   110  	reply    chan<- []*Node
   111  	nresults int // counter for received nodes
   112  }
   113  
   114  type topicRegisterReq struct {
   115  	add   bool
   116  	topic Topic
   117  }
   118  
   119  type topicSearchReq struct {
   120  	topic  Topic
   121  	found  chan<- *Node
   122  	lookup chan<- bool
   123  	delay  time.Duration
   124  }
   125  
   126  type topicSearchResult struct {
   127  	target lookupInfo
   128  	nodes  []*Node
   129  }
   130  
   131  type timeoutEvent struct {
   132  	ev   nodeEvent
   133  	node *Node
   134  }
   135  
   136  func newNetwork(conn transport, ourPubkey ecdsa.PublicKey, dbPath string, netrestrict *netutil.Netlist) (*Network, error) {
   137  	ourID := PubkeyID(&ourPubkey)
   138  
   139  	var db *nodeDB
   140  	if dbPath != "<no database>" {
   141  		var err error
   142  		if db, err = newNodeDB(dbPath, Version, ourID); err != nil {
   143  			return nil, err
   144  		}
   145  	}
   146  
   147  	tab := newTable(ourID, conn.localAddr())
   148  	net := &Network{
   149  		db:               db,
   150  		conn:             conn,
   151  		netrestrict:      netrestrict,
   152  		tab:              tab,
   153  		topictab:         newTopicTable(db, tab.self),
   154  		ticketStore:      newTicketStore(),
   155  		refreshReq:       make(chan []*Node),
   156  		refreshResp:      make(chan (<-chan struct{})),
   157  		closed:           make(chan struct{}),
   158  		closeReq:         make(chan struct{}),
   159  		read:             make(chan ingressPacket, 100),
   160  		timeout:          make(chan timeoutEvent),
   161  		timeoutTimers:    make(map[timeoutEvent]*time.Timer),
   162  		tableOpReq:       make(chan func()),
   163  		tableOpResp:      make(chan struct{}),
   164  		queryReq:         make(chan *findnodeQuery),
   165  		topicRegisterReq: make(chan topicRegisterReq),
   166  		topicSearchReq:   make(chan topicSearchReq),
   167  		nodes:            make(map[NodeID]*Node),
   168  	}
   169  	go net.loop()
   170  	return net, nil
   171  }
   172  
   173  // Close terminates the network listener and flushes the node database.
   174  func (net *Network) Close() {
   175  	net.conn.Close()
   176  	select {
   177  	case <-net.closed:
   178  	case net.closeReq <- struct{}{}:
   179  		<-net.closed
   180  	}
   181  }
   182  
   183  // Self returns the local node.
   184  // The returned node should not be modified by the caller.
   185  func (net *Network) Self() *Node {
   186  	return net.tab.self
   187  }
   188  
   189  // ReadRandomNodes fills the given slice with random nodes from the
   190  // table. It will not write the same node more than once. The nodes in
   191  // the slice are copies and can be modified by the caller.
   192  func (net *Network) ReadRandomNodes(buf []*Node) (n int) {
   193  	net.reqTableOp(func() { n = net.tab.readRandomNodes(buf) })
   194  	return n
   195  }
   196  
   197  // SetFallbackNodes sets the initial points of contact. These nodes
   198  // are used to connect to the network if the table is empty and there
   199  // are no known nodes in the database.
   200  func (net *Network) SetFallbackNodes(nodes []*Node) error {
   201  	nursery := make([]*Node, 0, len(nodes))
   202  	for _, n := range nodes {
   203  		if err := n.validateComplete(); err != nil {
   204  			return fmt.Errorf("bad bootstrap/fallback node %q (%v)", n, err)
   205  		}
   206  		// Recompute cpy.sha because the node might not have been
   207  		// created by NewNode or ParseNode.
   208  		cpy := *n
   209  		cpy.sha = crypto.Keccak256Hash(n.ID[:])
   210  		nursery = append(nursery, &cpy)
   211  	}
   212  	net.reqRefresh(nursery)
   213  	return nil
   214  }
   215  
   216  // Resolve searches for a specific node with the given ID.
   217  // It returns nil if the node could not be found.
   218  func (net *Network) Resolve(targetID NodeID) *Node {
   219  	result := net.lookup(crypto.Keccak256Hash(targetID[:]), true)
   220  	for _, n := range result {
   221  		if n.ID == targetID {
   222  			return n
   223  		}
   224  	}
   225  	return nil
   226  }
   227  
   228  // Lookup performs a network search for nodes close
   229  // to the given target. It approaches the target by querying
   230  // nodes that are closer to it on each iteration.
   231  // The given target does not need to be an actual node
   232  // identifier.
   233  //
   234  // The local node may be included in the result.
   235  func (net *Network) Lookup(targetID NodeID) []*Node {
   236  	return net.lookup(crypto.Keccak256Hash(targetID[:]), false)
   237  }
   238  
   239  func (net *Network) lookup(target common.Hash, stopOnMatch bool) []*Node {
   240  	var (
   241  		asked          = make(map[NodeID]bool)
   242  		seen           = make(map[NodeID]bool)
   243  		reply          = make(chan []*Node, alpha)
   244  		result         = nodesByDistance{target: target}
   245  		pendingQueries = 0
   246  	)
   247  	// Get initial answers from the local node.
   248  	result.push(net.tab.self, bucketSize)
   249  	for {
   250  		// Ask the α closest nodes that we haven't asked yet.
   251  		for i := 0; i < len(result.entries) && pendingQueries < alpha; i++ {
   252  			n := result.entries[i]
   253  			if !asked[n.ID] {
   254  				asked[n.ID] = true
   255  				pendingQueries++
   256  				net.reqQueryFindnode(n, target, reply)
   257  			}
   258  		}
   259  		if pendingQueries == 0 {
   260  			// We have asked all closest nodes, stop the search.
   261  			break
   262  		}
   263  		// Wait for the next reply.
   264  		select {
   265  		case nodes := <-reply:
   266  			for _, n := range nodes {
   267  				if n != nil && !seen[n.ID] {
   268  					seen[n.ID] = true
   269  					result.push(n, bucketSize)
   270  					if stopOnMatch && n.sha == target {
   271  						return result.entries
   272  					}
   273  				}
   274  			}
   275  			pendingQueries--
   276  		case <-time.After(respTimeout):
   277  			// forget all pending requests, start new ones
   278  			pendingQueries = 0
   279  			reply = make(chan []*Node, alpha)
   280  		}
   281  	}
   282  	return result.entries
   283  }
   284  
   285  func (net *Network) RegisterTopic(topic Topic, stop <-chan struct{}) {
   286  	select {
   287  	case net.topicRegisterReq <- topicRegisterReq{true, topic}:
   288  	case <-net.closed:
   289  		return
   290  	}
   291  	select {
   292  	case <-net.closed:
   293  	case <-stop:
   294  		select {
   295  		case net.topicRegisterReq <- topicRegisterReq{false, topic}:
   296  		case <-net.closed:
   297  		}
   298  	}
   299  }
   300  
   301  func (net *Network) SearchTopic(topic Topic, setPeriod <-chan time.Duration, found chan<- *Node, lookup chan<- bool) {
   302  	for {
   303  		select {
   304  		case <-net.closed:
   305  			return
   306  		case delay, ok := <-setPeriod:
   307  			select {
   308  			case net.topicSearchReq <- topicSearchReq{topic: topic, found: found, lookup: lookup, delay: delay}:
   309  			case <-net.closed:
   310  				return
   311  			}
   312  			if !ok {
   313  				return
   314  			}
   315  		}
   316  	}
   317  }
   318  
   319  func (net *Network) reqRefresh(nursery []*Node) <-chan struct{} {
   320  	select {
   321  	case net.refreshReq <- nursery:
   322  		return <-net.refreshResp
   323  	case <-net.closed:
   324  		return net.closed
   325  	}
   326  }
   327  
   328  func (net *Network) reqQueryFindnode(n *Node, target common.Hash, reply chan []*Node) bool {
   329  	q := &findnodeQuery{remote: n, target: target, reply: reply}
   330  	select {
   331  	case net.queryReq <- q:
   332  		return true
   333  	case <-net.closed:
   334  		return false
   335  	}
   336  }
   337  
   338  func (net *Network) reqReadPacket(pkt ingressPacket) {
   339  	select {
   340  	case net.read <- pkt:
   341  	case <-net.closed:
   342  	}
   343  }
   344  
   345  func (net *Network) reqTableOp(f func()) (called bool) {
   346  	select {
   347  	case net.tableOpReq <- f:
   348  		<-net.tableOpResp
   349  		return true
   350  	case <-net.closed:
   351  		return false
   352  	}
   353  }
   354  
   355  // TODO: external address handling.
   356  
   357  type topicSearchInfo struct {
   358  	lookupChn chan<- bool
   359  	period    time.Duration
   360  }
   361  
   362  const maxSearchCount = 5
   363  
   364  func (net *Network) loop() {
   365  	var (
   366  		refreshTimer       = time.NewTicker(autoRefreshInterval)
   367  		bucketRefreshTimer = time.NewTimer(bucketRefreshInterval)
   368  		refreshDone        chan struct{} // closed when the 'refresh' lookup has ended
   369  	)
   370  
   371  	// Tracking the next ticket to register.
   372  	var (
   373  		nextTicket        *ticketRef
   374  		nextRegisterTimer *time.Timer
   375  		nextRegisterTime  <-chan time.Time
   376  	)
   377  	defer func() {
   378  		if nextRegisterTimer != nil {
   379  			nextRegisterTimer.Stop()
   380  		}
   381  	}()
   382  	resetNextTicket := func() {
   383  		ticket, timeout := net.ticketStore.nextFilteredTicket()
   384  		if nextTicket != ticket {
   385  			nextTicket = ticket
   386  			if nextRegisterTimer != nil {
   387  				nextRegisterTimer.Stop()
   388  				nextRegisterTime = nil
   389  			}
   390  			if ticket != nil {
   391  				nextRegisterTimer = time.NewTimer(timeout)
   392  				nextRegisterTime = nextRegisterTimer.C
   393  			}
   394  		}
   395  	}
   396  
   397  	// Tracking registration and search lookups.
   398  	var (
   399  		topicRegisterLookupTarget lookupInfo
   400  		topicRegisterLookupDone   chan []*Node
   401  		topicRegisterLookupTick   = time.NewTimer(0)
   402  		searchReqWhenRefreshDone  []topicSearchReq
   403  		searchInfo                = make(map[Topic]topicSearchInfo)
   404  		activeSearchCount         int
   405  	)
   406  	topicSearchLookupDone := make(chan topicSearchResult, 100)
   407  	topicSearch := make(chan Topic, 100)
   408  	<-topicRegisterLookupTick.C
   409  
   410  	statsDump := time.NewTicker(10 * time.Second)
   411  
   412  loop:
   413  	for {
   414  		resetNextTicket()
   415  
   416  		select {
   417  		case <-net.closeReq:
   418  			log.Trace("<-net.closeReq")
   419  			break loop
   420  
   421  		// Ingress packet handling.
   422  		case pkt := <-net.read:
   423  			//fmt.Println("read", pkt.ev)
   424  			log.Trace("<-net.read")
   425  			n := net.internNode(&pkt)
   426  			prestate := n.state
   427  			status := "ok"
   428  			if err := net.handle(n, pkt.ev, &pkt); err != nil {
   429  				status = err.Error()
   430  			}
   431  			log.Trace("", "msg", log.Lazy{Fn: func() string {
   432  				return fmt.Sprintf("<<< (%d) %v from %x@%v: %v -> %v (%v)",
   433  					net.tab.count, pkt.ev, pkt.remoteID[:8], pkt.remoteAddr, prestate, n.state, status)
   434  			}})
   435  			// TODO: persist state if n.state goes >= known, delete if it goes <= known
   436  
   437  		// State transition timeouts.
   438  		case timeout := <-net.timeout:
   439  			log.Trace("<-net.timeout")
   440  			if net.timeoutTimers[timeout] == nil {
   441  				// Stale timer (was aborted).
   442  				continue
   443  			}
   444  			delete(net.timeoutTimers, timeout)
   445  			prestate := timeout.node.state
   446  			status := "ok"
   447  			if err := net.handle(timeout.node, timeout.ev, nil); err != nil {
   448  				status = err.Error()
   449  			}
   450  			log.Trace("", "msg", log.Lazy{Fn: func() string {
   451  				return fmt.Sprintf("--- (%d) %v for %x@%v: %v -> %v (%v)",
   452  					net.tab.count, timeout.ev, timeout.node.ID[:8], timeout.node.addr(), prestate, timeout.node.state, status)
   453  			}})
   454  
   455  		// Querying.
   456  		case q := <-net.queryReq:
   457  			log.Trace("<-net.queryReq")
   458  			if !q.start(net) {
   459  				q.remote.deferQuery(q)
   460  			}
   461  
   462  		// Interacting with the table.
   463  		case f := <-net.tableOpReq:
   464  			log.Trace("<-net.tableOpReq")
   465  			f()
   466  			net.tableOpResp <- struct{}{}
   467  
   468  		// Topic registration stuff.
   469  		case req := <-net.topicRegisterReq:
   470  			log.Trace("<-net.topicRegisterReq")
   471  			if !req.add {
   472  				net.ticketStore.removeRegisterTopic(req.topic)
   473  				continue
   474  			}
   475  			net.ticketStore.addTopic(req.topic, true)
   476  			// If we're currently waiting idle (nothing to look up), give the ticket store a
   477  			// chance to start it sooner. This should speed up convergence of the radius
   478  			// determination for new topics.
   479  			// if topicRegisterLookupDone == nil {
   480  			if topicRegisterLookupTarget.target == (common.Hash{}) {
   481  				log.Trace("topicRegisterLookupTarget == null")
   482  				if topicRegisterLookupTick.Stop() {
   483  					<-topicRegisterLookupTick.C
   484  				}
   485  				target, delay := net.ticketStore.nextRegisterLookup()
   486  				topicRegisterLookupTarget = target
   487  				topicRegisterLookupTick.Reset(delay)
   488  			}
   489  
   490  		case nodes := <-topicRegisterLookupDone:
   491  			log.Trace("<-topicRegisterLookupDone")
   492  			net.ticketStore.registerLookupDone(topicRegisterLookupTarget, nodes, func(n *Node) []byte {
   493  				net.ping(n, n.addr())
   494  				return n.pingEcho
   495  			})
   496  			target, delay := net.ticketStore.nextRegisterLookup()
   497  			topicRegisterLookupTarget = target
   498  			topicRegisterLookupTick.Reset(delay)
   499  			topicRegisterLookupDone = nil
   500  
   501  		case <-topicRegisterLookupTick.C:
   502  			log.Trace("<-topicRegisterLookupTick")
   503  			if (topicRegisterLookupTarget.target == common.Hash{}) {
   504  				target, delay := net.ticketStore.nextRegisterLookup()
   505  				topicRegisterLookupTarget = target
   506  				topicRegisterLookupTick.Reset(delay)
   507  				topicRegisterLookupDone = nil
   508  			} else {
   509  				topicRegisterLookupDone = make(chan []*Node)
   510  				target := topicRegisterLookupTarget.target
   511  				go func() { topicRegisterLookupDone <- net.lookup(target, false) }()
   512  			}
   513  
   514  		case <-nextRegisterTime:
   515  			log.Trace("<-nextRegisterTime")
   516  			net.ticketStore.ticketRegistered(*nextTicket)
   517  			//fmt.Println("sendTopicRegister", nextTicket.t.node.addr().String(), nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong)
   518  			net.conn.sendTopicRegister(nextTicket.t.node, nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong)
   519  
   520  		case req := <-net.topicSearchReq:
   521  			if refreshDone == nil {
   522  				log.Trace("<-net.topicSearchReq")
   523  				info, ok := searchInfo[req.topic]
   524  				if ok {
   525  					if req.delay == time.Duration(0) {
   526  						delete(searchInfo, req.topic)
   527  						net.ticketStore.removeSearchTopic(req.topic)
   528  					} else {
   529  						info.period = req.delay
   530  						searchInfo[req.topic] = info
   531  					}
   532  					continue
   533  				}
   534  				if req.delay != time.Duration(0) {
   535  					var info topicSearchInfo
   536  					info.period = req.delay
   537  					info.lookupChn = req.lookup
   538  					searchInfo[req.topic] = info
   539  					net.ticketStore.addSearchTopic(req.topic, req.found)
   540  					topicSearch <- req.topic
   541  				}
   542  			} else {
   543  				searchReqWhenRefreshDone = append(searchReqWhenRefreshDone, req)
   544  			}
   545  
   546  		case topic := <-topicSearch:
   547  			if activeSearchCount < maxSearchCount {
   548  				activeSearchCount++
   549  				target := net.ticketStore.nextSearchLookup(topic)
   550  				go func() {
   551  					nodes := net.lookup(target.target, false)
   552  					topicSearchLookupDone <- topicSearchResult{target: target, nodes: nodes}
   553  				}()
   554  			}
   555  			period := searchInfo[topic].period
   556  			if period != time.Duration(0) {
   557  				go func() {
   558  					time.Sleep(period)
   559  					topicSearch <- topic
   560  				}()
   561  			}
   562  
   563  		case res := <-topicSearchLookupDone:
   564  			activeSearchCount--
   565  			if lookupChn := searchInfo[res.target.topic].lookupChn; lookupChn != nil {
   566  				lookupChn <- net.ticketStore.radius[res.target.topic].converged
   567  			}
   568  			net.ticketStore.searchLookupDone(res.target, res.nodes, func(n *Node) []byte {
   569  				net.ping(n, n.addr())
   570  				return n.pingEcho
   571  			}, func(n *Node, topic Topic) []byte {
   572  				if n.state == known {
   573  					return net.conn.send(n, topicQueryPacket, topicQuery{Topic: topic}) // TODO: set expiration
   574  				} else {
   575  					if n.state == unknown {
   576  						net.ping(n, n.addr())
   577  					}
   578  					return nil
   579  				}
   580  			})
   581  
   582  		case <-statsDump.C:
   583  			log.Trace("<-statsDump.C")
   584  			/*r, ok := net.ticketStore.radius[testTopic]
   585  			if !ok {
   586  				fmt.Printf("(%x) no radius @ %v\n", net.tab.self.ID[:8], time.Now())
   587  			} else {
   588  				topics := len(net.ticketStore.tickets)
   589  				tickets := len(net.ticketStore.nodes)
   590  				rad := r.radius / (maxRadius/10000+1)
   591  				fmt.Printf("(%x) topics:%d radius:%d tickets:%d @ %v\n", net.tab.self.ID[:8], topics, rad, tickets, time.Now())
   592  			}*/
   593  
   594  			tm := mclock.Now()
   595  			for topic, r := range net.ticketStore.radius {
   596  				if printTestImgLogs {
   597  					rad := r.radius / (maxRadius/1000000 + 1)
   598  					minrad := r.minRadius / (maxRadius/1000000 + 1)
   599  					fmt.Printf("*R %d %v %016x %v\n", tm/1000000, topic, net.tab.self.sha[:8], rad)
   600  					fmt.Printf("*MR %d %v %016x %v\n", tm/1000000, topic, net.tab.self.sha[:8], minrad)
   601  				}
   602  			}
   603  			for topic, t := range net.topictab.topics {
   604  				wp := t.wcl.nextWaitPeriod(tm)
   605  				if printTestImgLogs {
   606  					fmt.Printf("*W %d %v %016x %d\n", tm/1000000, topic, net.tab.self.sha[:8], wp/1000000)
   607  				}
   608  			}
   609  
   610  		// Periodic / lookup-initiated bucket refresh.
   611  		case <-refreshTimer.C:
   612  			log.Trace("<-refreshTimer.C")
   613  			// TODO: ideally we would start the refresh timer after
   614  			// fallback nodes have been set for the first time.
   615  			if refreshDone == nil {
   616  				refreshDone = make(chan struct{})
   617  				net.refresh(refreshDone)
   618  			}
   619  		case <-bucketRefreshTimer.C:
   620  			target := net.tab.chooseBucketRefreshTarget()
   621  			go func() {
   622  				net.lookup(target, false)
   623  				bucketRefreshTimer.Reset(bucketRefreshInterval)
   624  			}()
   625  		case newNursery := <-net.refreshReq:
   626  			log.Trace("<-net.refreshReq")
   627  			if newNursery != nil {
   628  				net.nursery = newNursery
   629  			}
   630  			if refreshDone == nil {
   631  				refreshDone = make(chan struct{})
   632  				net.refresh(refreshDone)
   633  			}
   634  			net.refreshResp <- refreshDone
   635  		case <-refreshDone:
   636  			log.Trace("<-net.refreshDone")
   637  			refreshDone = nil
   638  			list := searchReqWhenRefreshDone
   639  			searchReqWhenRefreshDone = nil
   640  			go func() {
   641  				for _, req := range list {
   642  					net.topicSearchReq <- req
   643  				}
   644  			}()
   645  		}
   646  	}
   647  	log.Trace("loop stopped")
   648  
   649  	log.Debug(fmt.Sprintf("shutting down"))
   650  	if net.conn != nil {
   651  		net.conn.Close()
   652  	}
   653  	if refreshDone != nil {
   654  		// TODO: wait for pending refresh.
   655  		//<-refreshResults
   656  	}
   657  	// Cancel all pending timeouts.
   658  	for _, timer := range net.timeoutTimers {
   659  		timer.Stop()
   660  	}
   661  	if net.db != nil {
   662  		net.db.close()
   663  	}
   664  	close(net.closed)
   665  }
   666  
   667  // Everything below runs on the Network.loop goroutine
   668  // and can modify Node, Table and Network at any time without locking.
   669  
   670  func (net *Network) refresh(done chan<- struct{}) {
   671  	var seeds []*Node
   672  	if net.db != nil {
   673  		seeds = net.db.querySeeds(seedCount, seedMaxAge)
   674  	}
   675  	if len(seeds) == 0 {
   676  		seeds = net.nursery
   677  	}
   678  	if len(seeds) == 0 {
   679  		log.Trace("no seed nodes found")
   680  		close(done)
   681  		return
   682  	}
   683  	for _, n := range seeds {
   684  		log.Debug("", "msg", log.Lazy{Fn: func() string {
   685  			var age string
   686  			if net.db != nil {
   687  				age = time.Since(net.db.lastPong(n.ID)).String()
   688  			} else {
   689  				age = "unknown"
   690  			}
   691  			return fmt.Sprintf("seed node (age %s): %v", age, n)
   692  		}})
   693  		n = net.internNodeFromDB(n)
   694  		if n.state == unknown {
   695  			net.transition(n, verifyinit)
   696  		}
   697  		// Force-add the seed node so Lookup does something.
   698  		// It will be deleted again if verification fails.
   699  		net.tab.add(n)
   700  	}
   701  	// Start self lookup to fill up the buckets.
   702  	go func() {
   703  		net.Lookup(net.tab.self.ID)
   704  		close(done)
   705  	}()
   706  }
   707  
   708  // Node Interning.
   709  
   710  func (net *Network) internNode(pkt *ingressPacket) *Node {
   711  	if n := net.nodes[pkt.remoteID]; n != nil {
   712  		n.IP = pkt.remoteAddr.IP
   713  		n.UDP = uint16(pkt.remoteAddr.Port)
   714  		n.TCP = uint16(pkt.remoteAddr.Port)
   715  		return n
   716  	}
   717  	n := NewNode(pkt.remoteID, pkt.remoteAddr.IP, uint16(pkt.remoteAddr.Port), uint16(pkt.remoteAddr.Port))
   718  	n.state = unknown
   719  	net.nodes[pkt.remoteID] = n
   720  	return n
   721  }
   722  
   723  func (net *Network) internNodeFromDB(dbn *Node) *Node {
   724  	if n := net.nodes[dbn.ID]; n != nil {
   725  		return n
   726  	}
   727  	n := NewNode(dbn.ID, dbn.IP, dbn.UDP, dbn.TCP)
   728  	n.state = unknown
   729  	net.nodes[n.ID] = n
   730  	return n
   731  }
   732  
   733  func (net *Network) internNodeFromNeighbours(sender *net.UDPAddr, rn rpcNode) (n *Node, err error) {
   734  	if rn.ID == net.tab.self.ID {
   735  		return nil, errors.New("is self")
   736  	}
   737  	if rn.UDP <= lowPort {
   738  		return nil, errors.New("low port")
   739  	}
   740  	n = net.nodes[rn.ID]
   741  	if n == nil {
   742  		// We haven't seen this node before.
   743  		n, err = nodeFromRPC(sender, rn)
   744  		if net.netrestrict != nil && !net.netrestrict.Contains(n.IP) {
   745  			return n, errors.New("not contained in netrestrict whitelist")
   746  		}
   747  		if err == nil {
   748  			n.state = unknown
   749  			net.nodes[n.ID] = n
   750  		}
   751  		return n, err
   752  	}
   753  	if !n.IP.Equal(rn.IP) || n.UDP != rn.UDP || n.TCP != rn.TCP {
   754  		err = fmt.Errorf("metadata mismatch: got %v, want %v", rn, n)
   755  	}
   756  	return n, err
   757  }
   758  
   759  // nodeNetGuts is embedded in Node and contains fields.
   760  type nodeNetGuts struct {
   761  	// This is a cached copy of sha3(ID) which is used for node
   762  	// distance calculations. This is part of Node in order to make it
   763  	// possible to write tests that need a node at a certain distance.
   764  	// In those tests, the content of sha will not actually correspond
   765  	// with ID.
   766  	sha common.Hash
   767  
   768  	// State machine fields. Access to these fields
   769  	// is restricted to the Network.loop goroutine.
   770  	state             *nodeState
   771  	pingEcho          []byte           // hash of last ping sent by us
   772  	pingTopics        []Topic          // topic set sent by us in last ping
   773  	deferredQueries   []*findnodeQuery // queries that can't be sent yet
   774  	pendingNeighbours *findnodeQuery   // current query, waiting for reply
   775  	queryTimeouts     int
   776  }
   777  
   778  func (n *nodeNetGuts) deferQuery(q *findnodeQuery) {
   779  	n.deferredQueries = append(n.deferredQueries, q)
   780  }
   781  
   782  func (n *nodeNetGuts) startNextQuery(net *Network) {
   783  	if len(n.deferredQueries) == 0 {
   784  		return
   785  	}
   786  	nextq := n.deferredQueries[0]
   787  	if nextq.start(net) {
   788  		n.deferredQueries = append(n.deferredQueries[:0], n.deferredQueries[1:]...)
   789  	}
   790  }
   791  
   792  func (q *findnodeQuery) start(net *Network) bool {
   793  	// Satisfy queries against the local node directly.
   794  	if q.remote == net.tab.self {
   795  		closest := net.tab.closest(crypto.Keccak256Hash(q.target[:]), bucketSize)
   796  		q.reply <- closest.entries
   797  		return true
   798  	}
   799  	if q.remote.state.canQuery && q.remote.pendingNeighbours == nil {
   800  		net.conn.sendFindnodeHash(q.remote, q.target)
   801  		net.timedEvent(respTimeout, q.remote, neighboursTimeout)
   802  		q.remote.pendingNeighbours = q
   803  		return true
   804  	}
   805  	// If the node is not known yet, it won't accept queries.
   806  	// Initiate the transition to known.
   807  	// The request will be sent later when the node reaches known state.
   808  	if q.remote.state == unknown {
   809  		net.transition(q.remote, verifyinit)
   810  	}
   811  	return false
   812  }
   813  
   814  // Node Events (the input to the state machine).
   815  
   816  type nodeEvent uint
   817  
   818  //go:generate stringer -type=nodeEvent
   819  
   820  const (
   821  	invalidEvent nodeEvent = iota // zero is reserved
   822  
   823  	// Packet type events.
   824  	// These correspond to packet types in the UDP protocol.
   825  	pingPacket
   826  	pongPacket
   827  	findnodePacket
   828  	neighborsPacket
   829  	findnodeHashPacket
   830  	topicRegisterPacket
   831  	topicQueryPacket
   832  	topicNodesPacket
   833  
   834  	// Non-packet events.
   835  	// Event values in this category are allocated outside
   836  	// the packet type range (packet types are encoded as a single byte).
   837  	pongTimeout nodeEvent = iota + 256
   838  	pingTimeout
   839  	neighboursTimeout
   840  )
   841  
   842  // Node State Machine.
   843  
   844  type nodeState struct {
   845  	name     string
   846  	handle   func(*Network, *Node, nodeEvent, *ingressPacket) (next *nodeState, err error)
   847  	enter    func(*Network, *Node)
   848  	canQuery bool
   849  }
   850  
   851  func (s *nodeState) String() string {
   852  	return s.name
   853  }
   854  
   855  var (
   856  	unknown          *nodeState
   857  	verifyinit       *nodeState
   858  	verifywait       *nodeState
   859  	remoteverifywait *nodeState
   860  	known            *nodeState
   861  	contested        *nodeState
   862  	unresponsive     *nodeState
   863  )
   864  
   865  func init() {
   866  	unknown = &nodeState{
   867  		name: "unknown",
   868  		enter: func(net *Network, n *Node) {
   869  			net.tab.delete(n)
   870  			n.pingEcho = nil
   871  			// Abort active queries.
   872  			for _, q := range n.deferredQueries {
   873  				q.reply <- nil
   874  			}
   875  			n.deferredQueries = nil
   876  			if n.pendingNeighbours != nil {
   877  				n.pendingNeighbours.reply <- nil
   878  				n.pendingNeighbours = nil
   879  			}
   880  			n.queryTimeouts = 0
   881  		},
   882  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   883  			switch ev {
   884  			case pingPacket:
   885  				net.handlePing(n, pkt)
   886  				net.ping(n, pkt.remoteAddr)
   887  				return verifywait, nil
   888  			default:
   889  				return unknown, errInvalidEvent
   890  			}
   891  		},
   892  	}
   893  
   894  	verifyinit = &nodeState{
   895  		name: "verifyinit",
   896  		enter: func(net *Network, n *Node) {
   897  			net.ping(n, n.addr())
   898  		},
   899  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   900  			switch ev {
   901  			case pingPacket:
   902  				net.handlePing(n, pkt)
   903  				return verifywait, nil
   904  			case pongPacket:
   905  				err := net.handleKnownPong(n, pkt)
   906  				return remoteverifywait, err
   907  			case pongTimeout:
   908  				return unknown, nil
   909  			default:
   910  				return verifyinit, errInvalidEvent
   911  			}
   912  		},
   913  	}
   914  
   915  	verifywait = &nodeState{
   916  		name: "verifywait",
   917  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   918  			switch ev {
   919  			case pingPacket:
   920  				net.handlePing(n, pkt)
   921  				return verifywait, nil
   922  			case pongPacket:
   923  				err := net.handleKnownPong(n, pkt)
   924  				return known, err
   925  			case pongTimeout:
   926  				return unknown, nil
   927  			default:
   928  				return verifywait, errInvalidEvent
   929  			}
   930  		},
   931  	}
   932  
   933  	remoteverifywait = &nodeState{
   934  		name: "remoteverifywait",
   935  		enter: func(net *Network, n *Node) {
   936  			net.timedEvent(respTimeout, n, pingTimeout)
   937  		},
   938  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   939  			switch ev {
   940  			case pingPacket:
   941  				net.handlePing(n, pkt)
   942  				return remoteverifywait, nil
   943  			case pingTimeout:
   944  				return known, nil
   945  			default:
   946  				return remoteverifywait, errInvalidEvent
   947  			}
   948  		},
   949  	}
   950  
   951  	known = &nodeState{
   952  		name:     "known",
   953  		canQuery: true,
   954  		enter: func(net *Network, n *Node) {
   955  			n.queryTimeouts = 0
   956  			n.startNextQuery(net)
   957  			// Insert into the table and start revalidation of the last node
   958  			// in the bucket if it is full.
   959  			last := net.tab.add(n)
   960  			if last != nil && last.state == known {
   961  				// TODO: do this asynchronously
   962  				net.transition(last, contested)
   963  			}
   964  		},
   965  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   966  			switch ev {
   967  			case pingPacket:
   968  				net.handlePing(n, pkt)
   969  				return known, nil
   970  			case pongPacket:
   971  				err := net.handleKnownPong(n, pkt)
   972  				return known, err
   973  			default:
   974  				return net.handleQueryEvent(n, ev, pkt)
   975  			}
   976  		},
   977  	}
   978  
   979  	contested = &nodeState{
   980  		name:     "contested",
   981  		canQuery: true,
   982  		enter: func(net *Network, n *Node) {
   983  			net.ping(n, n.addr())
   984  		},
   985  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
   986  			switch ev {
   987  			case pongPacket:
   988  				// Node is still alive.
   989  				err := net.handleKnownPong(n, pkt)
   990  				return known, err
   991  			case pongTimeout:
   992  				net.tab.deleteReplace(n)
   993  				return unresponsive, nil
   994  			case pingPacket:
   995  				net.handlePing(n, pkt)
   996  				return contested, nil
   997  			default:
   998  				return net.handleQueryEvent(n, ev, pkt)
   999  			}
  1000  		},
  1001  	}
  1002  
  1003  	unresponsive = &nodeState{
  1004  		name:     "unresponsive",
  1005  		canQuery: true,
  1006  		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
  1007  			switch ev {
  1008  			case pingPacket:
  1009  				net.handlePing(n, pkt)
  1010  				return known, nil
  1011  			case pongPacket:
  1012  				err := net.handleKnownPong(n, pkt)
  1013  				return known, err
  1014  			default:
  1015  				return net.handleQueryEvent(n, ev, pkt)
  1016  			}
  1017  		},
  1018  	}
  1019  }
  1020  
  1021  // handle processes packets sent by n and events related to n.
  1022  func (net *Network) handle(n *Node, ev nodeEvent, pkt *ingressPacket) error {
  1023  	//fmt.Println("handle", n.addr().String(), n.state, ev)
  1024  	if pkt != nil {
  1025  		if err := net.checkPacket(n, ev, pkt); err != nil {
  1026  			//fmt.Println("check err:", err)
  1027  			return err
  1028  		}
  1029  		// Start the background expiration goroutine after the first
  1030  		// successful communication. Subsequent calls have no effect if it
  1031  		// is already running. We do this here instead of somewhere else
  1032  		// so that the search for seed nodes also considers older nodes
  1033  		// that would otherwise be removed by the expirer.
  1034  		if net.db != nil {
  1035  			net.db.ensureExpirer()
  1036  		}
  1037  	}
  1038  	if n.state == nil {
  1039  		n.state = unknown //???
  1040  	}
  1041  	next, err := n.state.handle(net, n, ev, pkt)
  1042  	net.transition(n, next)
  1043  	//fmt.Println("new state:", n.state)
  1044  	return err
  1045  }
  1046  
  1047  func (net *Network) checkPacket(n *Node, ev nodeEvent, pkt *ingressPacket) error {
  1048  	// Replay prevention checks.
  1049  	switch ev {
  1050  	case pingPacket, findnodeHashPacket, neighborsPacket:
  1051  		// TODO: check date is > last date seen
  1052  		// TODO: check ping version
  1053  	case pongPacket:
  1054  		if !bytes.Equal(pkt.data.(*pong).ReplyTok, n.pingEcho) {
  1055  			// fmt.Println("pong reply token mismatch")
  1056  			return fmt.Errorf("pong reply token mismatch")
  1057  		}
  1058  		n.pingEcho = nil
  1059  	}
  1060  	// Address validation.
  1061  	// TODO: Ideally we would do the following:
  1062  	//  - reject all packets with wrong address except ping.
  1063  	//  - for ping with new address, transition to verifywait but keep the
  1064  	//    previous node (with old address) around. if the new one reaches known,
  1065  	//    swap it out.
  1066  	return nil
  1067  }
  1068  
  1069  func (net *Network) transition(n *Node, next *nodeState) {
  1070  	if n.state != next {
  1071  		n.state = next
  1072  		if next.enter != nil {
  1073  			next.enter(net, n)
  1074  		}
  1075  	}
  1076  
  1077  	// TODO: persist/unpersist node
  1078  }
  1079  
  1080  func (net *Network) timedEvent(d time.Duration, n *Node, ev nodeEvent) {
  1081  	timeout := timeoutEvent{ev, n}
  1082  	net.timeoutTimers[timeout] = time.AfterFunc(d, func() {
  1083  		select {
  1084  		case net.timeout <- timeout:
  1085  		case <-net.closed:
  1086  		}
  1087  	})
  1088  }
  1089  
  1090  func (net *Network) abortTimedEvent(n *Node, ev nodeEvent) {
  1091  	timer := net.timeoutTimers[timeoutEvent{ev, n}]
  1092  	if timer != nil {
  1093  		timer.Stop()
  1094  		delete(net.timeoutTimers, timeoutEvent{ev, n})
  1095  	}
  1096  }
  1097  
  1098  func (net *Network) ping(n *Node, addr *net.UDPAddr) {
  1099  	//fmt.Println("ping", n.addr().String(), n.ID.String(), n.sha.Hex())
  1100  	if n.pingEcho != nil || n.ID == net.tab.self.ID {
  1101  		//fmt.Println(" not sent")
  1102  		return
  1103  	}
  1104  	log.Trace("Pinging remote node", "node", n.ID)
  1105  	n.pingTopics = net.ticketStore.regTopicSet()
  1106  	n.pingEcho = net.conn.sendPing(n, addr, n.pingTopics)
  1107  	net.timedEvent(respTimeout, n, pongTimeout)
  1108  }
  1109  
  1110  func (net *Network) handlePing(n *Node, pkt *ingressPacket) {
  1111  	log.Trace("Handling remote ping", "node", n.ID)
  1112  	ping := pkt.data.(*ping)
  1113  	n.TCP = ping.From.TCP
  1114  	t := net.topictab.getTicket(n, ping.Topics)
  1115  
  1116  	pong := &pong{
  1117  		To:         makeEndpoint(n.addr(), n.TCP), // TODO: maybe use known TCP port from DB
  1118  		ReplyTok:   pkt.hash,
  1119  		Expiration: uint64(time.Now().Add(expiration).Unix()),
  1120  	}
  1121  	ticketToPong(t, pong)
  1122  	net.conn.send(n, pongPacket, pong)
  1123  }
  1124  
  1125  func (net *Network) handleKnownPong(n *Node, pkt *ingressPacket) error {
  1126  	log.Trace("Handling known pong", "node", n.ID)
  1127  	net.abortTimedEvent(n, pongTimeout)
  1128  	now := mclock.Now()
  1129  	ticket, err := pongToTicket(now, n.pingTopics, n, pkt)
  1130  	if err == nil {
  1131  		// fmt.Printf("(%x) ticket: %+v\n", net.tab.self.ID[:8], pkt.data)
  1132  		net.ticketStore.addTicket(now, pkt.data.(*pong).ReplyTok, ticket)
  1133  	} else {
  1134  		log.Trace("Failed to convert pong to ticket", "err", err)
  1135  	}
  1136  	n.pingEcho = nil
  1137  	n.pingTopics = nil
  1138  	return err
  1139  }
  1140  
  1141  func (net *Network) handleQueryEvent(n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
  1142  	switch ev {
  1143  	case findnodePacket:
  1144  		target := crypto.Keccak256Hash(pkt.data.(*findnode).Target[:])
  1145  		results := net.tab.closest(target, bucketSize).entries
  1146  		net.conn.sendNeighbours(n, results)
  1147  		return n.state, nil
  1148  	case neighborsPacket:
  1149  		err := net.handleNeighboursPacket(n, pkt)
  1150  		return n.state, err
  1151  	case neighboursTimeout:
  1152  		if n.pendingNeighbours != nil {
  1153  			n.pendingNeighbours.reply <- nil
  1154  			n.pendingNeighbours = nil
  1155  		}
  1156  		n.queryTimeouts++
  1157  		if n.queryTimeouts > maxFindnodeFailures && n.state == known {
  1158  			return contested, errors.New("too many timeouts")
  1159  		}
  1160  		return n.state, nil
  1161  
  1162  	// v5
  1163  
  1164  	case findnodeHashPacket:
  1165  		results := net.tab.closest(pkt.data.(*findnodeHash).Target, bucketSize).entries
  1166  		net.conn.sendNeighbours(n, results)
  1167  		return n.state, nil
  1168  	case topicRegisterPacket:
  1169  		//fmt.Println("got topicRegisterPacket")
  1170  		regdata := pkt.data.(*topicRegister)
  1171  		pong, err := net.checkTopicRegister(regdata)
  1172  		if err != nil {
  1173  			//fmt.Println(err)
  1174  			return n.state, fmt.Errorf("bad waiting ticket: %v", err)
  1175  		}
  1176  		net.topictab.useTicket(n, pong.TicketSerial, regdata.Topics, int(regdata.Idx), pong.Expiration, pong.WaitPeriods)
  1177  		return n.state, nil
  1178  	case topicQueryPacket:
  1179  		// TODO: handle expiration
  1180  		topic := pkt.data.(*topicQuery).Topic
  1181  		results := net.topictab.getEntries(topic)
  1182  		if _, ok := net.ticketStore.tickets[topic]; ok {
  1183  			results = append(results, net.tab.self) // we're not registering in our own table but if we're advertising, return ourselves too
  1184  		}
  1185  		if len(results) > 10 {
  1186  			results = results[:10]
  1187  		}
  1188  		var hash common.Hash
  1189  		copy(hash[:], pkt.hash)
  1190  		net.conn.sendTopicNodes(n, hash, results)
  1191  		return n.state, nil
  1192  	case topicNodesPacket:
  1193  		p := pkt.data.(*topicNodes)
  1194  		if net.ticketStore.gotTopicNodes(n, p.Echo, p.Nodes) {
  1195  			n.queryTimeouts++
  1196  			if n.queryTimeouts > maxFindnodeFailures && n.state == known {
  1197  				return contested, errors.New("too many timeouts")
  1198  			}
  1199  		}
  1200  		return n.state, nil
  1201  
  1202  	default:
  1203  		return n.state, errInvalidEvent
  1204  	}
  1205  }
  1206  
  1207  func (net *Network) checkTopicRegister(data *topicRegister) (*pong, error) {
  1208  	var pongpkt ingressPacket
  1209  	if err := decodePacket(data.Pong, &pongpkt); err != nil {
  1210  		return nil, err
  1211  	}
  1212  	if pongpkt.ev != pongPacket {
  1213  		return nil, errors.New("is not pong packet")
  1214  	}
  1215  	if pongpkt.remoteID != net.tab.self.ID {
  1216  		return nil, errors.New("not signed by us")
  1217  	}
  1218  	// check that we previously authorised all topics
  1219  	// that the other side is trying to register.
  1220  	if rlpHash(data.Topics) != pongpkt.data.(*pong).TopicHash {
  1221  		return nil, errors.New("topic hash mismatch")
  1222  	}
  1223  	if data.Idx < 0 || int(data.Idx) >= len(data.Topics) {
  1224  		return nil, errors.New("topic index out of range")
  1225  	}
  1226  	return pongpkt.data.(*pong), nil
  1227  }
  1228  
  1229  func rlpHash(x interface{}) (h common.Hash) {
  1230  	hw := sha3.NewKeccak256()
  1231  	rlp.Encode(hw, x)
  1232  	hw.Sum(h[:0])
  1233  	return h
  1234  }
  1235  
  1236  func (net *Network) handleNeighboursPacket(n *Node, pkt *ingressPacket) error {
  1237  	if n.pendingNeighbours == nil {
  1238  		return errNoQuery
  1239  	}
  1240  	net.abortTimedEvent(n, neighboursTimeout)
  1241  
  1242  	req := pkt.data.(*neighbors)
  1243  	nodes := make([]*Node, len(req.Nodes))
  1244  	for i, rn := range req.Nodes {
  1245  		nn, err := net.internNodeFromNeighbours(pkt.remoteAddr, rn)
  1246  		if err != nil {
  1247  			log.Debug(fmt.Sprintf("invalid neighbour (%v) from %x@%v: %v", rn.IP, n.ID[:8], pkt.remoteAddr, err))
  1248  			continue
  1249  		}
  1250  		nodes[i] = nn
  1251  		// Start validation of query results immediately.
  1252  		// This fills the table quickly.
  1253  		// TODO: generates way too many packets, maybe do it via queue.
  1254  		if nn.state == unknown {
  1255  			net.transition(nn, verifyinit)
  1256  		}
  1257  	}
  1258  	// TODO: don't ignore second packet
  1259  	n.pendingNeighbours.reply <- nodes
  1260  	n.pendingNeighbours = nil
  1261  	// Now that this query is done, start the next one.
  1262  	n.startNextQuery(net)
  1263  	return nil
  1264  }