p2p/discover: WIP

p2p/discover/database.go

@@ -62,6 +62,7 @@ var (
 	nodeDBDiscoverPing          = nodeDBDiscoverRoot + ":lastping"
 	nodeDBDiscoverPong          = nodeDBDiscoverRoot + ":lastpong"
 	nodeDBDiscoverFindFails     = nodeDBDiscoverRoot + ":findfail"
+	nodeDBDiscoverLocalEndpoint = nodeDBDiscoverRoot + ":localendpoint"
 )
 
 // newNodeDB creates a new node database for storing and retrieving infos about
@@ -172,33 +173,42 @@ func (db *nodeDB) fetchInt64(key []byte) int64 {
 func (db *nodeDB) storeInt64(key []byte, n int64) error {
 	blob := make([]byte, binary.MaxVarintLen64)
 	blob = blob[:binary.PutVarint(blob, n)]
-
 	return db.lvl.Put(key, blob, nil)
 }
 
+func (db *nodeDB) storeRLP(key []byte, val interface{}) error {
+	blob, err := rlp.EncodeToBytes(val)
+	if err != nil {
+		return err
+	}
+	return db.lvl.Put(key, blob, nil)
+}
+
+func (db *nodeDB) fetchRLP(key []byte, val interface{}) error {
+	blob, err := db.lvl.Get(key, nil)
+	if err != nil {
+		return err
+	}
+	err = rlp.DecodeBytes(blob, val)
+	if err != nil {
+		glog.V(logger.Warn).Infof("key %x (%T) %v", key, val, err)
+	}
+	return err
+}
+
 // node retrieves a node with a given id from the database.
 func (db *nodeDB) node(id NodeID) *Node {
-	blob, err := db.lvl.Get(makeKey(id, nodeDBDiscoverRoot), nil)
+	var node Node
-	if err != nil {
+	if err := db.fetchRLP(makeKey(id, nodeDBDiscoverRoot), &node); err != nil {
-		glog.V(logger.Detail).Infof("failed to retrieve node %v: %v", id, err)
-		return nil
-	}
-	node := new(Node)
-	if err := rlp.DecodeBytes(blob, node); err != nil {
-		glog.V(logger.Warn).Infof("failed to decode node RLP: %v", err)
 		return nil
 	}
 	node.sha = crypto.Keccak256Hash(node.ID[:])
-	return node
+	return &node
 }
 
 // updateNode inserts - potentially overwriting - a node into the peer database.
 func (db *nodeDB) updateNode(node *Node) error {
-	blob, err := rlp.EncodeToBytes(node)
+	return db.storeRLP(makeKey(node.ID, nodeDBDiscoverRoot), node)
-	if err != nil {
-		return err
-	}
-	return db.lvl.Put(makeKey(node.ID, nodeDBDiscoverRoot), blob, nil)
 }
 
 // deleteNode deletes all information/keys associated with a node.
@@ -300,6 +310,20 @@ func (db *nodeDB) updateFindFails(id NodeID, fails int) error {
 	return db.storeInt64(makeKey(id, nodeDBDiscoverFindFails), int64(fails))
 }
 
+// localEndpoint returns the last local endpoint communicated to the
+// given remote node.
+func (db *nodeDB) localEndpoint(id NodeID) *rpcEndpoint {
+	var ep rpcEndpoint
+	if err := db.fetchRLP(makeKey(id, nodeDBDiscoverLocalEndpoint), &ep); err != nil {
+		return nil
+	}
+	return &ep
+}
+
+func (db *nodeDB) updateLocalEndpoint(id NodeID, ep rpcEndpoint) error {
+	return db.storeRLP(makeKey(id, nodeDBDiscoverLocalEndpoint), &ep)
+}
+
 // querySeeds retrieves random nodes to be used as potential seed nodes
 // for bootstrapping.
 func (db *nodeDB) querySeeds(n int, maxAge time.Duration) []*Node {

p2p/discover/net.go

@@ -0,0 +1,793 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package discover
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/p2p/nat"
+)
+
+var (
+	errInvalidEvent = errors.New("invalid in current state")
+	errNoQuery      = errors.New("no pending query")
+	errWrongAddress = errors.New("unknown sender address")
+)
+
+const (
+	autoRefreshInterval = 1 * time.Hour
+	seedCount           = 30
+	seedMaxAge          = 5 * 24 * time.Hour
+)
+
+// Network manages the table and all protocol interaction.
+type Network struct {
+	db   *nodeDB // database of known nodes
+	conn transport
+
+	closed      chan struct{}          // closed when loop is done
+	closeReq    chan struct{}          // 'request to close'
+	refreshReq  chan []*Node           // lookups ask for refresh on this channel
+	refreshResp chan (<-chan struct{}) // ...and get the channel to block on from this one
+	read        chan ingressPacket     // ingress packets arrive here
+	timeout     chan timeoutEvent
+	queryReq    chan *findnodeQuery // lookups submit findnode queries on this channel
+	tableOpReq  chan func()
+	tableOpResp chan struct{}
+
+	// State of the main loop.
+	tab           *Table
+	nursery       []*Node
+	nodes         map[NodeID]*Node // tracks active nodes with state != known
+	timeoutTimers map[timeoutEvent]*time.Timer
+}
+
+// transport is implemented by the UDP transport.
+// it is an interface so we can test without opening lots of UDP
+// sockets and without generating a private key.
+type transport interface {
+	sendPing(remote *Node, remoteAddr *net.UDPAddr) (hash []byte)
+	sendPong(remote *Node, pingHash []byte)
+	sendFindnode(remote *Node, target NodeID)
+	sendNeighbours(remote *Node, nodes []*Node)
+	localAddr() *net.UDPAddr
+	Close()
+}
+
+type findnodeQuery struct {
+	remote   *Node
+	target   NodeID
+	reply    chan<- []*Node
+	nresults int // counter for received nodes
+}
+
+type timeoutEvent struct {
+	ev   nodeEvent
+	node *Node
+}
+
+func newNetwork(conn transport, ourPubkey ecdsa.PublicKey, natm nat.Interface, dbPath string) (*Network, error) {
+	ourID := PubkeyID(&ourPubkey)
+	db, err := newNodeDB(dbPath, Version, ourID)
+	if err != nil {
+		return nil, err
+	}
+	net := &Network{
+		db:            db,
+		conn:          conn,
+		tab:           newTable(ourID, conn.localAddr()),
+		refreshReq:    make(chan []*Node),
+		refreshResp:   make(chan (<-chan struct{})),
+		closed:        make(chan struct{}),
+		closeReq:      make(chan struct{}),
+		read:          make(chan ingressPacket),
+		timeout:       make(chan timeoutEvent),
+		timeoutTimers: make(map[timeoutEvent]*time.Timer),
+		tableOpReq:    make(chan func()),
+		tableOpResp:   make(chan struct{}),
+		queryReq:      make(chan *findnodeQuery),
+		nodes:         make(map[NodeID]*Node),
+	}
+	go net.loop()
+	return net, nil
+}
+
+// Close terminates the network listener and flushes the node database.
+func (net *Network) Close() {
+	net.conn.Close()
+	select {
+	case <-net.closed:
+	case net.closeReq <- struct{}{}:
+		<-net.closed
+	}
+}
+
+// Self returns the local node.
+// The returned node should not be modified by the caller.
+func (net *Network) Self() *Node {
+	return net.tab.self
+}
+
+// ReadRandomNodes fills the given slice with random nodes from the
+// table. It will not write the same node more than once. The nodes in
+// the slice are copies and can be modified by the caller.
+func (net *Network) ReadRandomNodes(buf []*Node) (n int) {
+	net.reqTableOp(func() { n = net.tab.readRandomNodes(buf) })
+	return n
+}
+
+// SetFallbackNodes sets the initial points of contact. These nodes
+// are used to connect to the network if the table is empty and there
+// are no known nodes in the database.
+func (net *Network) SetFallbackNodes(nodes []*Node) error {
+	nursery := make([]*Node, 0, len(nodes))
+	for _, n := range nodes {
+		if err := n.validateComplete(); err != nil {
+			return fmt.Errorf("bad bootstrap/fallback node %q (%v)", n, err)
+		}
+		// Recompute cpy.sha because the node might not have been
+		// created by NewNode or ParseNode.
+		cpy := *n
+		cpy.sha = crypto.Keccak256Hash(n.ID[:])
+		nursery = append(nursery, &cpy)
+	}
+	net.reqRefresh(nursery)
+	return nil
+}
+
+// Resolve searches for a specific node with the given ID.
+// It returns nil if the node could not be found.
+func (net *Network) Resolve(targetID NodeID) *Node {
+	result := net.lookup(targetID, true)
+	for _, n := range result {
+		if n.ID == targetID {
+			return n
+		}
+	}
+	return nil
+}
+
+// Lookup performs a network search for nodes close
+// to the given target. It approaches the target by querying
+// nodes that are closer to it on each iteration.
+// The given target does not need to be an actual node
+// identifier.
+//
+// The local node may be included in the result.
+func (net *Network) Lookup(targetID NodeID) []*Node {
+	return net.lookup(targetID, false)
+}
+
+func (net *Network) lookup(targetID NodeID, stopOnMatch bool) []*Node {
+	var (
+		target         = crypto.Keccak256Hash(targetID[:])
+		asked          = make(map[NodeID]bool)
+		seen           = make(map[NodeID]bool)
+		reply          = make(chan []*Node, alpha)
+		result         = nodesByDistance{target: target}
+		pendingQueries = 0
+	)
+	// Get initial answers from the local node.
+	result.push(net.tab.self, bucketSize)
+	for {
+		// Ask the α closest nodes that we haven't asked yet.
+		for i := 0; i < len(result.entries) && pendingQueries < alpha; i++ {
+			n := result.entries[i]
+			if !asked[n.ID] {
+				asked[n.ID] = true
+				pendingQueries++
+				net.reqQueryFindnode(n, targetID, reply)
+			}
+		}
+		if pendingQueries == 0 {
+			// We have asked all closest nodes, stop the search.
+			break
+		}
+		// Wait for the next reply.
+		for _, n := range <-reply {
+			if n != nil && !seen[n.ID] {
+				seen[n.ID] = true
+				result.push(n, bucketSize)
+				if stopOnMatch && n.ID == targetID {
+					return result.entries
+				}
+			}
+		}
+		pendingQueries--
+	}
+	return result.entries
+}
+
+func (net *Network) reqRefresh(nursery []*Node) <-chan struct{} {
+	select {
+	case net.refreshReq <- nursery:
+		return <-net.refreshResp
+	case <-net.closed:
+		return net.closed
+	}
+}
+
+func (net *Network) reqQueryFindnode(n *Node, targetID NodeID, reply chan []*Node) bool {
+	q := &findnodeQuery{remote: n, target: targetID, reply: reply}
+	select {
+	case net.queryReq <- q:
+		return true
+	case <-net.closed:
+		return false
+	}
+}
+
+func (net *Network) reqReadPacket(pkt ingressPacket) {
+	select {
+	case net.read <- pkt:
+	case <-net.closed:
+	}
+}
+
+func (net *Network) reqTableOp(f func()) (called bool) {
+	select {
+	case net.tableOpReq <- f:
+		<-net.tableOpResp
+		return true
+	case <-net.closed:
+		return false
+	}
+}
+
+// TODO: external address handling.
+
+func (net *Network) loop() {
+	var (
+		refreshTimer = time.NewTicker(autoRefreshInterval)
+		refreshDone  chan struct{} // doRefresh closes to report completion
+	)
+loop:
+	for {
+		select {
+		case <-net.closeReq:
+			break loop
+
+		// Ingress packet handling.
+		case pkt := <-net.read:
+			node := net.getNode(pkt.remoteID, nil)
+			prestate := node.state
+			status := "ok"
+			if err := net.handle(node, pkt.ev, &pkt); err != nil {
+				status = err.Error()
+			}
+			if glog.V(logger.Detail) {
+				glog.Infof("<<< (%d) %v from %x@%v: %v -> %v (%v)",
+					net.tab.count, pkt.ev, pkt.remoteID[:8], pkt.remoteAddr, prestate, node.state, status)
+			}
+
+			// TODO: persist state if n.state goes >= known, delete if it goes <= known
+
+		// State transition timeouts.
+		case timeout := <-net.timeout:
+			if net.timeoutTimers[timeout] == nil {
+				// Stale timer (was aborted).
+				continue
+			}
+			delete(net.timeoutTimers, timeout)
+			prestate := timeout.node.state
+			status := "ok"
+			if err := net.handle(timeout.node, timeout.ev, nil); err != nil {
+				status = err.Error()
+			}
+			if glog.V(logger.Detail) {
+				glog.Infof("--- (%d) %v for %x@%v: %v -> %v (%v)",
+					net.tab.count, timeout.ev, timeout.node.ID[:8], timeout.node.addr(), prestate, timeout.node.state, status)
+			}
+
+		// Querying.
+		case q := <-net.queryReq:
+			if !q.start(net) {
+				q.remote.deferQuery(q)
+			}
+
+		// Interacting with the table.
+		case f := <-net.tableOpReq:
+			f()
+			net.tableOpResp <- struct{}{}
+
+		// Periodic / lookup-initiated bucket refresh.
+		case <-refreshTimer.C:
+			// TODO: ideally we would start the refresh timer after
+			// fallback nodes have been set for the first time.
+			if refreshDone == nil {
+				refreshDone = make(chan struct{})
+				net.refresh(refreshDone)
+			}
+		case newNursery := <-net.refreshReq:
+			if newNursery != nil {
+				net.nursery = newNursery
+			}
+			if refreshDone == nil {
+				refreshDone = make(chan struct{})
+				net.refresh(refreshDone)
+			}
+			net.refreshResp <- refreshDone
+		case <-refreshDone:
+			refreshDone = nil
+		}
+	}
+
+	glog.V(logger.Debug).Infof("shutting down")
+	if net.conn != nil {
+		net.conn.Close()
+	}
+	if refreshDone != nil {
+		// TODO: wait for pending refresh.
+		//<-refreshResults
+	}
+	// Cancel all pending timeouts.
+	for _, timer := range net.timeoutTimers {
+		timer.Stop()
+	}
+	net.db.close()
+	close(net.closed)
+}
+
+// Everything below runs on the Network.loop goroutine
+// and can modify Node, Table and Network at any time without locking.
+
+func (net *Network) getNode(id NodeID, fromDB *Node) *Node {
+	if n := net.nodes[id]; n != nil {
+		return n
+	}
+	if fromDB == nil {
+		fromDB = &Node{ID: id}
+	}
+	if fromDB.state == nil {
+		fromDB.state = unknown
+	}
+	net.nodes[id] = fromDB
+	return net.nodes[id]
+}
+
+func (net *Network) nodeFromRPC(rn rpcNode) (n *Node, err error) {
+	n = net.nodes[rn.ID]
+	if n == nil {
+		// We haven't seen this node before.
+		n, err = nodeFromRPC(rn)
+		n.state = unknown
+		if err == nil {
+			net.nodes[n.ID] = n
+		}
+		return n, err
+	}
+	if !bytes.Equal(n.IP, rn.IP) || n.UDP != rn.UDP || n.TCP != rn.TCP {
+		err = fmt.Errorf("metadata mismatch: got %v, want %v", rn, n)
+	}
+	return n, err
+}
+
+func (net *Network) refresh(done chan<- struct{}) {
+	seeds := net.db.querySeeds(seedCount, seedMaxAge)
+	if len(seeds) == 0 {
+		seeds = net.nursery
+	}
+	if len(seeds) == 0 {
+		glog.V(logger.Detail).Info("no seed nodes found")
+		close(done)
+		return
+	}
+	for _, n := range seeds {
+		if glog.V(logger.Debug) {
+			age := time.Since(net.db.lastPong(n.ID))
+			glog.Infof("seed node (age %v): %v", age, n)
+		}
+		n = net.getNode(n.ID, n)
+		if n.state == unknown {
+			net.transition(n, verifyinit)
+		}
+		// Force-add the seed node so Lookup does something.
+		// It will be deleted again if verification fails.
+		net.tab.add(n)
+	}
+	// Start self lookup to fill up the buckets.
+	go func() {
+		net.Lookup(net.tab.self.ID)
+		close(done)
+	}()
+}
+
+// nodeNetGuts is embedded in Node and contains fields.
+type nodeNetGuts struct {
+	// This is a cached copy of sha3(ID) which is used for node
+	// distance calculations. This is part of Node in order to make it
+	// possible to write tests that need a node at a certain distance.
+	// In those tests, the content of sha will not actually correspond
+	// with ID.
+	sha common.Hash
+
+	// State machine fields. Access to these fields
+	// is restricted to the Network.loop goroutine.
+	state             *nodeState
+	pingEcho          []byte           // hash of last ping sent by us
+	deferredQueries   []*findnodeQuery // queries that can't be sent yet
+	pendingNeighbours *findnodeQuery   // current query, waiting for reply
+}
+
+func (n *nodeNetGuts) deferQuery(q *findnodeQuery) {
+	n.deferredQueries = append(n.deferredQueries, q)
+}
+
+func (n *nodeNetGuts) startNextQuery(net *Network) {
+	if len(n.deferredQueries) == 0 {
+		return
+	}
+	nextq := n.deferredQueries[0]
+	if nextq.start(net) {
+		n.deferredQueries = append(n.deferredQueries[:0], n.deferredQueries[1:]...)
+	}
+}
+
+func (q *findnodeQuery) start(net *Network) bool {
+	// Satisfy queries against the local node directly.
+	if q.remote == net.tab.self {
+		closest := net.tab.closest(crypto.Keccak256Hash(q.target[:]), bucketSize)
+		q.reply <- closest.entries
+		return true
+	}
+	if q.remote.state.canQuery && q.remote.pendingNeighbours == nil {
+		net.conn.sendFindnode(q.remote, q.target)
+		net.timedEvent(respTimeout, q.remote, neighboursTimeout)
+		q.remote.pendingNeighbours = q
+		return true
+	}
+	// If the node is not known yet, it won't accept queries.
+	// Initiate the transition to known.
+	// The request will be sent later when the node reaches known state.
+	if q.remote.state == unknown {
+		net.transition(q.remote, verifyinit)
+	}
+	return false
+}
+
+// Node Events (the input to the state machine).
+
+type nodeEvent uint
+
+//go:generate stringer -type=nodeEvent
+
+const (
+	invalidEvent nodeEvent = iota // zero is 'reserved'
+
+	// Packet type events.
+	// These correspond to packet types in the UDP protocol.
+	pingPacket
+	pongPacket
+	findnodePacket
+	neighborsPacket
+
+	// Non-packet events.
+	// Event values in this category are allocated outside
+	// the packet type range (packet types are encoded as a single byte).
+	pongTimeout nodeEvent = iota + 256
+	pingTimeout
+	neighboursTimeout
+)
+
+// Node State Machine.
+
+type nodeState struct {
+	name     string
+	handle   func(*Network, *Node, nodeEvent, *ingressPacket) (next *nodeState, err error)
+	enter    func(*Network, *Node)
+	canQuery bool
+}
+
+func (s *nodeState) String() string {
+	return s.name
+}
+
+var (
+	unknown          *nodeState
+	verifyinit       *nodeState
+	verifywait       *nodeState
+	remoteverifywait *nodeState
+	known            *nodeState
+	contested        *nodeState
+	unresponsive     *nodeState
+)
+
+func init() {
+	unknown = &nodeState{
+		name: "unknown",
+		enter: func(net *Network, n *Node) {
+			net.tab.delete(n)
+			n.pingEcho = nil
+			// Abort active queries.
+			for _, q := range n.deferredQueries {
+				q.reply <- nil
+			}
+			n.deferredQueries = nil
+			if n.pendingNeighbours != nil {
+				n.pendingNeighbours.reply <- nil
+				n.pendingNeighbours = nil
+			}
+		},
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				net.ping(n, pkt.remoteAddr)
+				return remoteverifywait, nil
+			default:
+				return unknown, errInvalidEvent
+			}
+		},
+	}
+
+	verifyinit = &nodeState{
+		name: "verifyinit",
+		enter: func(net *Network, n *Node) {
+			net.ping(n, n.addr())
+		},
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				return verifywait, nil
+			case pongPacket:
+				net.abortTimedEvent(n, pongTimeout)
+				return remoteverifywait, nil
+			case pongTimeout:
+				return unknown, nil
+			default:
+				return unknown, errInvalidEvent
+			}
+		},
+	}
+
+	verifywait = &nodeState{
+		name: "verifywait",
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pongPacket:
+				net.abortTimedEvent(n, pongTimeout)
+				return known, nil
+			case pongTimeout:
+				return unknown, nil
+			default:
+				return unknown, errInvalidEvent
+			}
+		},
+	}
+
+	remoteverifywait = &nodeState{
+		name: "remoteverifywait",
+		enter: func(net *Network, n *Node) {
+			net.timedEvent(respTimeout, n, pingTimeout)
+		},
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				return remoteverifywait, nil
+			case pingTimeout:
+				return known, nil
+			default:
+				return remoteverifywait, errInvalidEvent
+			}
+		},
+	}
+
+	known = &nodeState{
+		name:     "known",
+		canQuery: true,
+		enter: func(net *Network, n *Node) {
+			n.startNextQuery(net)
+			// Insert into the table and start revalidation of the last node
+			// in the bucket if it is full.
+			last := net.tab.add(n)
+			if last != nil && last.state == known {
+				// TODO: do this asynchronously
+				net.transition(last, contested)
+			}
+		},
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				return known, nil
+			case pingTimeout:
+				return known, nil
+			case findnodePacket, neighborsPacket, neighboursTimeout:
+				err := net.handleQueryEvent(n, ev, pkt)
+				return known, err
+			default:
+				return known, errInvalidEvent
+			}
+		},
+	}
+
+	contested = &nodeState{
+		name:     "contested",
+		canQuery: true,
+		enter: func(net *Network, n *Node) {
+			net.ping(n, n.addr())
+		},
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pongPacket:
+				net.abortTimedEvent(n, pongTimeout)
+				return known, nil
+			case pongTimeout:
+				net.tab.deleteReplace(n)
+				return known, nil
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				return contested, nil
+			case findnodePacket, neighborsPacket, neighboursTimeout:
+				err := net.handleQueryEvent(n, ev, pkt)
+				return contested, err
+			default:
+				return contested, errInvalidEvent
+			}
+		},
+	}
+
+	unresponsive = &nodeState{
+		name:     "unresponsive",
+		canQuery: true,
+		handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
+			switch ev {
+			case pingPacket:
+				net.conn.sendPong(n, pkt.hash)
+				return known, nil
+			case findnodePacket, neighborsPacket, neighboursTimeout:
+				err := net.handleQueryEvent(n, ev, pkt)
+				return unresponsive, err
+			default:
+				return unresponsive, errInvalidEvent
+			}
+		},
+	}
+}
+
+// handle processes packets sent by n and events related to n.
+func (net *Network) handle(n *Node, ev nodeEvent, pkt *ingressPacket) error {
+	if pkt != nil {
+		if err := net.checkPacket(n, ev, pkt); err != nil {
+			return err
+		}
+		// Start the background expiration goroutine after the first
+		// successful communication. Subsequent calls have no effect if it
+		// is already running. We do this here instead of somewhere else
+		// so that the search for seed nodes also considers older nodes
+		// that would otherwise be removed by the expirer.
+		net.db.ensureExpirer()
+	}
+	next, err := n.state.handle(net, n, ev, pkt)
+	net.transition(n, next)
+	return err
+}
+
+func (net *Network) checkPacket(n *Node, ev nodeEvent, pkt *ingressPacket) error {
+	// Replay prevention checks.
+	switch ev {
+	case pingPacket, findnodePacket, neighborsPacket:
+		// TODO: check date is > last date seen
+		// TODO: check ping version
+	case pongPacket:
+		if !bytes.Equal(pkt.data.(*pong).ReplyTok, n.pingEcho) {
+			return fmt.Errorf("pong reply token mismatch")
+		}
+		n.pingEcho = nil
+	}
+	// Address validation.
+	// TODO: Ideally we would do the following:
+	//  - reject all packets with wrong address except ping.
+	//  - for ping with new address, transition to verifywait but keep the
+	//    previous node (with old address) around. if the new one reaches known,
+	//    swap it out.
+	return nil
+}
+
+func (net *Network) transition(n *Node, next *nodeState) {
+	if n.state != next {
+		n.state = next
+		if next.enter != nil {
+			next.enter(net, n)
+		}
+	}
+
+	// TODO: persist/unpersist node
+}
+
+func (net *Network) timedEvent(d time.Duration, n *Node, ev nodeEvent) {
+	timeout := timeoutEvent{ev, n}
+	net.timeoutTimers[timeout] = time.AfterFunc(d, func() {
+		select {
+		case net.timeout <- timeout:
+		case <-net.closed:
+		}
+	})
+}
+
+func (net *Network) abortTimedEvent(n *Node, ev nodeEvent) {
+	timer := net.timeoutTimers[timeoutEvent{ev, n}]
+	if timer != nil {
+		timer.Stop()
+		delete(net.timeoutTimers, timeoutEvent{ev, n})
+	}
+}
+
+func (net *Network) ping(n *Node, addr *net.UDPAddr) {
+	n.pingEcho = net.conn.sendPing(n, addr)
+	net.timedEvent(respTimeout, n, pongTimeout)
+}
+
+func (net *Network) handleQueryEvent(n *Node, ev nodeEvent, pkt *ingressPacket) error {
+	switch ev {
+	case findnodePacket:
+		target := crypto.Keccak256Hash(pkt.data.(*findnode).Target[:])
+		results := net.tab.closest(target, bucketSize).entries
+		net.conn.sendNeighbours(n, results)
+		return nil
+	case neighborsPacket:
+		return net.handleNeighboursPacket(n, pkt.data.(*neighbors))
+	case neighboursTimeout:
+		if n.pendingNeighbours != nil {
+			n.pendingNeighbours.reply <- nil
+			n.pendingNeighbours = nil
+		}
+		return nil
+	default:
+		panic("oops")
+	}
+}
+
+func (net *Network) handleNeighboursPacket(n *Node, req *neighbors) error {
+	if n.pendingNeighbours == nil {
+		return errNoQuery
+	}
+	net.abortTimedEvent(n, neighboursTimeout)
+
+	nodes := make([]*Node, len(req.Nodes))
+	for i, rn := range req.Nodes {
+		nn, err := net.nodeFromRPC(rn)
+		if err != nil {
+			glog.V(logger.Debug).Infof("invalid neighbour from %x: %v", n.ID[:8], err)
+			continue
+		}
+		nodes[i] = nn
+		// Start validation of query results immediately.
+		// This fills the table quickly.
+		// TODO: generates way too many packets, maybe do it via queue.
+		if nn.state == unknown {
+			net.transition(nn, verifyinit)
+		}
+	}
+	// TODO: don't ignore second packet
+	n.pendingNeighbours.reply <- nodes
+	n.pendingNeighbours = nil
+	// Now that this query is done, start the next one.
+	n.startNextQuery(net)
+	return nil
+}

p2p/discover/net_test.go

@@ -0,0 +1,338 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package discover
+
+import (
+	"fmt"
+	"net"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger/glog"
+)
+
+func TestNetwork_Lookup(t *testing.T) {
+	glog.SetV(6)
+	glog.SetToStderr(true)
+
+	key, _ := crypto.GenerateKey()
+	network, err := newNetwork(lookupTestnet, key.PublicKey, nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	lookupTestnet.net = network
+	defer network.Close()
+
+	// lookup on empty table returns no nodes
+	// if results := network.Lookup(lookupTestnet.target, false); len(results) > 0 {
+	// 	t.Fatalf("lookup on empty table returned %d results: %#v", len(results), results)
+	// }
+	// seed table with initial node (otherwise lookup will terminate immediately)
+	seeds := []*Node{NewNode(lookupTestnet.dists[256][0], net.IP{}, 256, 999)}
+	if err := network.SetFallbackNodes(seeds); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(3 * time.Second)
+
+	results := network.Lookup(lookupTestnet.target)
+	t.Logf("results:")
+	for _, e := range results {
+		t.Logf("  ld=%d, %x", logdist(lookupTestnet.targetSha, e.sha), e.sha[:])
+	}
+	if len(results) != bucketSize {
+		t.Errorf("wrong number of results: got %d, want %d", len(results), bucketSize)
+	}
+	if hasDuplicates(results) {
+		t.Errorf("result set contains duplicate entries")
+	}
+	if !sortedByDistanceTo(lookupTestnet.targetSha, results) {
+		t.Errorf("result set not sorted by distance to target")
+	}
+	// TODO: check result nodes are actually closest
+}
+
+// This is the test network for the Lookup test.
+// The nodes were obtained by running testnet.mine with a random NodeID as target.
+var lookupTestnet = &preminedTestnet{
+	target:    MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
+	targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
+	dists: [257][]NodeID{
+		240: []NodeID{
+			MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
+			MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
+		},
+		244: []NodeID{
+			MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
+		},
+		246: []NodeID{
+			MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
+			MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
+			MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
+		},
+		247: []NodeID{
+			MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
+			MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
+			MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
+			MustHexID("8dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73"),
+			MustHexID("8b58c6073dd98bbad4e310b97186c8f822d3a5c7d57af40e2136e88e315afd115edb27d2d0685a908cfe5aa49d0debdda6e6e63972691d6bd8c5af2d771dd2a9"),
+			MustHexID("2cbb718b7dc682da19652e7d9eb4fefaf7b7147d82c1c2b6805edf77b85e29fde9f6da195741467ff2638dc62c8d3e014ea5686693c15ed0080b6de90354c137"),
+			MustHexID("e84027696d3f12f2de30a9311afea8fbd313c2360daff52bb5fc8c7094d5295758bec3134e4eef24e4cdf377b40da344993284628a7a346eba94f74160998feb"),
+			MustHexID("f1357a4f04f9d33753a57c0b65ba20a5d8777abbffd04e906014491c9103fb08590e45548d37aa4bd70965e2e81ddba94f31860348df01469eec8c1829200a68"),
+			MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
+			MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
+		},
+		248: []NodeID{
+			MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
+			MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
+			MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
+			MustHexID("3ed426322dee7572b08592e1e079f8b6c6b30e10e6243edd144a6a48fdbdb83df73a6e41b1143722cb82604f2203a32758610b5d9544f44a1a7921ba001528c1"),
+			MustHexID("b2e2a2b7fdd363572a3256e75435fab1da3b16f7891a8bd2015f30995dae665d7eabfd194d87d99d5df628b4bbc7b04e5b492c596422dd8272746c7a1b0b8e4f"),
+			MustHexID("0c69c9756162c593e85615b814ce57a2a8ca2df6c690b9c4e4602731b61e1531a3bbe3f7114271554427ffabea80ad8f36fa95a49fa77b675ae182c6ccac1728"),
+			MustHexID("8d28be21d5a97b0876442fa4f5e5387f5bf3faad0b6f13b8607b64d6e448c0991ca28dd7fe2f64eb8eadd7150bff5d5666aa6ed868b84c71311f4ba9a38569dd"),
+			MustHexID("2c677e1c64b9c9df6359348a7f5f33dc79e22f0177042486d125f8b6ca7f0dc756b1f672aceee5f1746bcff80aaf6f92a8dc0c9fbeb259b3fa0da060de5ab7e8"),
+			MustHexID("3994880f94a8678f0cd247a43f474a8af375d2a072128da1ad6cae84a244105ff85e94fc7d8496f639468de7ee998908a91c7e33ef7585fff92e984b210941a1"),
+			MustHexID("b45a9153c08d002a48090d15d61a7c7dad8c2af85d4ff5bd36ce23a9a11e0709bf8d56614c7b193bc028c16cbf7f20dfbcc751328b64a924995d47b41e452422"),
+			MustHexID("057ab3a9e53c7a84b0f3fc586117a525cdd18e313f52a67bf31798d48078e325abe5cfee3f6c2533230cb37d0549289d692a29dd400e899b8552d4b928f6f907"),
+			MustHexID("0ddf663d308791eb92e6bd88a2f8cb45e4f4f35bb16708a0e6ff7f1362aa6a73fedd0a1b1557fb3365e38e1b79d6918e2fae2788728b70c9ab6b51a3b94a4338"),
+			MustHexID("f637e07ff50cc1e3731735841c4798411059f2023abcf3885674f3e8032531b0edca50fd715df6feb489b6177c345374d64f4b07d257a7745de393a107b013a5"),
+			MustHexID("e24ec7c6eec094f63c7b3239f56d311ec5a3e45bc4e622a1095a65b95eea6fe13e29f3b6b7a2cbfe40906e3989f17ac834c3102dd0cadaaa26e16ee06d782b72"),
+			MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
+			MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
+		},
+		249: []NodeID{
+			MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
+			MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
+			MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
+			MustHexID("b1b4bfbda514d9b8f35b1c28961da5d5216fe50548f4066f69af3b7666a3b2e06eac646735e963e5c8f8138a2fb95af15b13b23ff00c6986eccc0efaa8ee6fb4"),
+			MustHexID("d2139281b289ad0e4d7b4243c4364f5c51aac8b60f4806135de06b12b5b369c9e43a6eb494eab860d115c15c6fbb8c5a1b0e382972e0e460af395b8385363de7"),
+			MustHexID("4a693df4b8fc5bdc7cec342c3ed2e228d7c5b4ab7321ddaa6cccbeb45b05a9f1d95766b4002e6d4791c2deacb8a667aadea6a700da28a3eea810a30395701bbc"),
+			MustHexID("ab41611195ec3c62bb8cd762ee19fb182d194fd141f4a66780efbef4b07ce916246c022b841237a3a6b512a93431157edd221e854ed2a259b72e9c5351f44d0c"),
+			MustHexID("68e8e26099030d10c3c703ae7045c0a48061fb88058d853b3e67880014c449d4311014da99d617d3150a20f1a3da5e34bf0f14f1c51fe4dd9d58afd222823176"),
+			MustHexID("3fbcacf546fb129cd70fc48de3b593ba99d3c473798bc309292aca280320e0eacc04442c914cad5c4cf6950345ba79b0d51302df88285d4e83ee3fe41339eee7"),
+			MustHexID("1d4a623659f7c8f80b6c3939596afdf42e78f892f682c768ad36eb7bfba402dbf97aea3a268f3badd8fe7636be216edf3d67ee1e08789ebbc7be625056bd7109"),
+			MustHexID("a283c474ab09da02bbc96b16317241d0627646fcc427d1fe790b76a7bf1989ced90f92101a973047ae9940c92720dffbac8eff21df8cae468a50f72f9e159417"),
+			MustHexID("dbf7e5ad7f87c3dfecae65d87c3039e14ed0bdc56caf00ce81931073e2e16719d746295512ff7937a15c3b03603e7c41a4f9df94fcd37bb200dd8f332767e9cb"),
+			MustHexID("caaa070a26692f64fc77f30d7b5ae980d419b4393a0f442b1c821ef58c0862898b0d22f74a4f8c5d83069493e3ec0b92f17dc1fe6e4cd437c1ec25039e7ce839"),
+			MustHexID("874cc8d1213beb65c4e0e1de38ef5d8165235893ac74ab5ea937c885eaab25c8d79dad0456e9fd3e9450626cac7e107b004478fb59842f067857f39a47cee695"),
+			MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
+			MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
+		},
+		250: []NodeID{
+			MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
+			MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
+			MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
+			MustHexID("1e1eac1c9add703eb252eb991594f8f5a173255d526a855fab24ae57dc277e055bc3c7a7ae0b45d437c4f47a72d97eb7b126f2ba344ba6c0e14b2c6f27d4b1e6"),
+			MustHexID("ae28953f63d4bc4e706712a59319c111f5ff8f312584f65d7436b4cd3d14b217b958f8486bad666b4481fe879019fb1f767cf15b3e3e2711efc33b56d460448a"),
+			MustHexID("934bb1edf9c7a318b82306aca67feb3d6b434421fa275d694f0b4927afd8b1d3935b727fd4ff6e3d012e0c82f1824385174e8c6450ade59c2a43281a4b3446b6"),
+			MustHexID("9eef3f28f70ce19637519a0916555bf76d26de31312ac656cf9d3e379899ea44e4dd7ffcce923b4f3563f8a00489a34bd6936db0cbb4c959d32c49f017e07d05"),
+			MustHexID("82200872e8f871c48f1fad13daec6478298099b591bb3dbc4ef6890aa28ebee5860d07d70be62f4c0af85085a90ae8179ee8f937cf37915c67ea73e704b03ee7"),
+			MustHexID("6c75a5834a08476b7fc37ff3dc2011dc3ea3b36524bad7a6d319b18878fad813c0ba76d1f4555cacd3890c865438c21f0e0aed1f80e0a157e642124c69f43a11"),
+			MustHexID("995b873742206cb02b736e73a88580c2aacb0bd4a3c97a647b647bcab3f5e03c0e0736520a8b3600da09edf4248991fb01091ec7ff3ec7cdc8a1beae011e7aae"),
+			MustHexID("c773a056594b5cdef2e850d30891ff0e927c3b1b9c35cd8e8d53a1017001e237468e1ece3ae33d612ca3e6abb0a9169aa352e9dcda358e5af2ad982b577447db"),
+			MustHexID("2b46a5f6923f475c6be99ec6d134437a6d11f6bb4b4ac6bcd94572fa1092639d1c08aeefcb51f0912f0a060f71d4f38ee4da70ecc16010b05dd4a674aab14c3a"),
+			MustHexID("af6ab501366debbaa0d22e20e9688f32ef6b3b644440580fd78de4fe0e99e2a16eb5636bbae0d1c259df8ddda77b35b9a35cbc36137473e9c68fbc9d203ba842"),
+			MustHexID("c9f6f2dd1a941926f03f770695bda289859e85fabaf94baaae20b93e5015dc014ba41150176a36a1884adb52f405194693e63b0c464a6891cc9cc1c80d450326"),
+			MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
+			MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
+		},
+		251: []NodeID{
+			MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
+			MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
+			MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
+			MustHexID("42c7483781727051a0b3660f14faf39e0d33de5e643702ae933837d036508ab856ce7eec8ec89c4929a4901256e5233a3d847d5d4893f91bcf21835a9a880fee"),
+			MustHexID("873bae27bf1dc854408fba94046a53ab0c965cebe1e4e12290806fc62b88deb1f4a47f9e18f78fc0e7913a0c6e42ac4d0fc3a20cea6bc65f0c8a0ca90b67521e"),
+			MustHexID("a7e3a370bbd761d413f8d209e85886f68bf73d5c3089b2dc6fa42aab1ecb5162635497eed95dee2417f3c9c74a3e76319625c48ead2e963c7de877cd4551f347"),
+			MustHexID("528597534776a40df2addaaea15b6ff832ce36b9748a265768368f657e76d58569d9f30dbb91e91cf0ae7efe8f402f17aa0ae15f5c55051ba03ba830287f4c42"),
+			MustHexID("461d8bd4f13c3c09031fdb84f104ed737a52f630261463ce0bdb5704259bab4b737dda688285b8444dbecaecad7f50f835190b38684ced5e90c54219e5adf1bc"),
+			MustHexID("6ec50c0be3fd232737090fc0111caaf0bb6b18f72be453428087a11a97fd6b52db0344acbf789a689bd4f5f50f79017ea784f8fd6fe723ad6ae675b9e3b13e21"),
+			MustHexID("12fc5e2f77a83fdcc727b79d8ae7fe6a516881138d3011847ee136b400fed7cfba1f53fd7a9730253c7aa4f39abeacd04f138417ba7fcb0f36cccc3514e0dab6"),
+			MustHexID("4fdbe75914ccd0bce02101606a1ccf3657ec963e3b3c20239d5fec87673fe446d649b4f15f1fe1a40e6cfbd446dda2d31d40bb602b1093b8fcd5f139ba0eb46a"),
+			MustHexID("3753668a0f6281e425ea69b52cb2d17ab97afbe6eb84cf5d25425bc5e53009388857640668fadd7c110721e6047c9697803bd8a6487b43bb343bfa32ebf24039"),
+			MustHexID("2e81b16346637dec4410fd88e527346145b9c0a849dbf2628049ac7dae016c8f4305649d5659ec77f1e8a0fac0db457b6080547226f06283598e3740ad94849a"),
+			MustHexID("802c3cc27f91c89213223d758f8d2ecd41135b357b6d698f24d811cdf113033a81c38e0bdff574a5c005b00a8c193dc2531f8c1fa05fa60acf0ab6f2858af09f"),
+			MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
+			MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
+		},
+		252: []NodeID{
+			MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
+			MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
+			MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
+			MustHexID("0ddc736077da9a12ba410dc5ea63cbcbe7659dd08596485b2bff3435221f82c10d263efd9af938e128464be64a178b7cd22e19f400d5802f4c9df54bf89f2619"),
+			MustHexID("784aa34d833c6ce63fcc1279630113c3272e82c4ae8c126c5a52a88ac461b6baeed4244e607b05dc14e5b2f41c70a273c3804dea237f14f7a1e546f6d1309d14"),
+			MustHexID("f253a2c354ee0e27cfcae786d726753d4ad24be6516b279a936195a487de4a59dbc296accf20463749ff55293263ed8c1b6365eecb248d44e75e9741c0d18205"),
+			MustHexID("a1910b80357b3ad9b4593e0628922939614dc9056a5fbf477279c8b2c1d0b4b31d89a0c09d0d41f795271d14d3360ef08a3f821e65e7e1f56c07a36afe49c7c5"),
+			MustHexID("f1168552c2efe541160f0909b0b4a9d6aeedcf595cdf0e9b165c97e3e197471a1ee6320e93389edfba28af6eaf10de98597ad56e7ab1b504ed762451996c3b98"),
+			MustHexID("b0c8e5d2c8634a7930e1a6fd082e448c6cf9d2d8b7293558b59238815a4df926c286bf297d2049f14e8296a6eb3256af614ec1812c4f2bbe807673b58bf14c8c"),
+			MustHexID("0fb346076396a38badc342df3679b55bd7f40a609ab103411fe45082c01f12ea016729e95914b2b5540e987ff5c9b133e85862648e7f36abdfd23100d248d234"),
+			MustHexID("f736e0cc83417feaa280d9483f5d4d72d1b036cd0c6d9cbdeb8ac35ceb2604780de46dddaa32a378474e1d5ccdf79b373331c30c7911ade2ae32f98832e5de1f"),
+			MustHexID("8b02991457602f42b38b342d3f2259ae4100c354b3843885f7e4e07bd644f64dab94bb7f38a3915f8b7f11d8e3f81c28e07a0078cf79d7397e38a7b7e0c857e2"),
+			MustHexID("9221d9f04a8a184993d12baa91116692bb685f887671302999d69300ad103eb2d2c75a09d8979404c6dd28f12362f58a1a43619c493d9108fd47588a23ce5824"),
+			MustHexID("652797801744dada833fff207d67484742eea6835d695925f3e618d71b68ec3c65bdd85b4302b2cdcb835ad3f94fd00d8da07e570b41bc0d2bcf69a8de1b3284"),
+			MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
+			MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
+		},
+		253: []NodeID{
+			MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
+			MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
+			MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
+			MustHexID("d97bf55f88c83fae36232661af115d66ca600fc4bd6d1fb35ff9bb4dad674c02cf8c8d05f317525b5522250db58bb1ecafb7157392bf5aa61b178c61f098d995"),
+			MustHexID("7045d678f1f9eb7a4613764d17bd5698796494d0bf977b16f2dbc272b8a0f7858a60805c022fc3d1fe4f31c37e63cdaca0416c0d053ef48a815f8b19121605e0"),
+			MustHexID("14e1f21418d445748de2a95cd9a8c3b15b506f86a0acabd8af44bb968ce39885b19c8822af61b3dd58a34d1f265baec30e3ae56149dc7d2aa4a538f7319f69c8"),
+			MustHexID("b9453d78281b66a4eac95a1546017111eaaa5f92a65d0de10b1122940e92b319728a24edf4dec6acc412321b1c95266d39c7b3a5d265c629c3e49a65fb022c09"),
+			MustHexID("e8a49248419e3824a00d86af422f22f7366e2d4922b304b7169937616a01d9d6fa5abf5cc01061a352dc866f48e1fa2240dbb453d872b1d7be62bdfc1d5e248c"),
+			MustHexID("bebcff24b52362f30e0589ee573ce2d86f073d58d18e6852a592fa86ceb1a6c9b96d7fb9ec7ed1ed98a51b6743039e780279f6bb49d0a04327ac7a182d9a56f6"),
+			MustHexID("d0835e5a4291db249b8d2fca9f503049988180c7d247bedaa2cf3a1bad0a76709360a85d4f9a1423b2cbc82bb4d94b47c0cde20afc430224834c49fe312a9ae3"),
+			MustHexID("6b087fe2a2da5e4f0b0f4777598a4a7fb66bf77dbd5bfc44e8a7eaa432ab585a6e226891f56a7d4f5ed11a7c57b90f1661bba1059590ca4267a35801c2802913"),
+			MustHexID("d901e5bde52d1a0f4ddf010a686a53974cdae4ebe5c6551b3c37d6b6d635d38d5b0e5f80bc0186a2c7809dbf3a42870dd09643e68d32db896c6da8ba734579e7"),
+			MustHexID("96419fb80efae4b674402bb969ebaab86c1274f29a83a311e24516d36cdf148fe21754d46c97688cdd7468f24c08b13e4727c29263393638a3b37b99ff60ebca"),
+			MustHexID("7b9c1889ae916a5d5abcdfb0aaedcc9c6f9eb1c1a4f68d0c2d034fe79ac610ce917c3abc670744150fa891bfcd8ab14fed6983fca964de920aa393fa7b326748"),
+			MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
+			MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
+		},
+		254: []NodeID{
+			MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
+			MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
+			MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
+			MustHexID("27f4a16cc085e72d86e25c98bd2eca173eaaee7565c78ec5a52e9e12b2211f35de81b5b45e9195de2ebfe29106742c59112b951a04eb7ae48822911fc1f9389e"),
+			MustHexID("55db5ee7d98e7f0b1c3b9d5be6f2bc619a1b86c3cdd513160ad4dcf267037a5fffad527ac15d50aeb32c59c13d1d4c1e567ebbf4de0d25236130c8361f9aac63"),
+			MustHexID("883df308b0130fc928a8559fe50667a0fff80493bc09685d18213b2db241a3ad11310ed86b0ef662b3ce21fc3d9aa7f3fc24b8d9afe17c7407e9afd3345ae548"),
+			MustHexID("c7af968cc9bc8200c3ee1a387405f7563be1dce6710a3439f42ea40657d0eae9d2b3c16c42d779605351fcdece4da637b9804e60ca08cfb89aec32c197beffa6"),
+			MustHexID("3e66f2b788e3ff1d04106b80597915cd7afa06c405a7ae026556b6e583dca8e05cfbab5039bb9a1b5d06083ffe8de5780b1775550e7218f5e98624bf7af9a0a8"),
+			MustHexID("4fc7f53764de3337fdaec0a711d35d3a923e72fa65025444d12230b3552ed43d9b2d1ad08ccb11f2d50c58809e6dd74dde910e195294fca3b47ae5a3967cc479"),
+			MustHexID("bafdfdcf6ccaa989436752fa97c77477b6baa7deb374b16c095492c529eb133e8e2f99e1977012b64767b9d34b2cf6d2048ed489bd822b5139b523f6a423167b"),
+			MustHexID("7f5d78008a4312fe059104ce80202c82b8915c2eb4411c6b812b16f7642e57c00f2c9425121f5cbac4257fe0b3e81ef5dea97ea2dbaa98f6a8b6fd4d1e5980bb"),
+			MustHexID("598c37fe78f922751a052f463aeb0cb0bc7f52b7c2a4cf2da72ec0931c7c32175d4165d0f8998f7320e87324ac3311c03f9382a5385c55f0407b7a66b2acd864"),
+			MustHexID("f758c4136e1c148777a7f3275a76e2db0b2b04066fd738554ec398c1c6cc9fb47e14a3b4c87bd47deaeab3ffd2110514c3855685a374794daff87b605b27ee2e"),
+			MustHexID("0307bb9e4fd865a49dcf1fe4333d1b944547db650ab580af0b33e53c4fef6c789531110fac801bbcbce21fc4d6f61b6d5b24abdf5b22e3030646d579f6dca9c2"),
+			MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
+			MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
+		},
+		255: []NodeID{
+			MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
+			MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
+			MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
+			MustHexID("c08397d5751b47bd3da044b908be0fb0e510d3149574dff7aeab33749b023bb171b5769990fe17469dbebc100bc150e798aeda426a2dcc766699a225fddd75c6"),
+			MustHexID("0222c1c194b749736e593f937fad67ee348ac57287a15c7e42877aa38a9b87732a408bca370f812efd0eedbff13e6d5b854bf3ba1dec431a796ed47f32552b09"),
+			MustHexID("03d859cd46ef02d9bfad5268461a6955426845eef4126de6be0fa4e8d7e0727ba2385b78f1a883a8239e95ebb814f2af8379632c7d5b100688eebc5841209582"),
+			MustHexID("64d5004b7e043c39ff0bd10cb20094c287721d5251715884c280a612b494b3e9e1c64ba6f67614994c7d969a0d0c0295d107d53fc225d47c44c4b82852d6f960"),
+			MustHexID("b0a5eefb2dab6f786670f35bf9641eefe6dd87fd3f1362bcab4aaa792903500ab23d88fae68411372e0813b057535a601d46e454323745a948017f6063a47b1f"),
+			MustHexID("0cc6df0a3433d448b5684d2a3ffa9d1a825388177a18f44ad0008c7bd7702f1ec0fc38b83506f7de689c3b6ecb552599927e29699eed6bb867ff08f80068b287"),
+			MustHexID("50772f7b8c03a4e153355fbbf79c8a80cf32af656ff0c7873c99911099d04a0dae0674706c357e0145ad017a0ade65e6052cb1b0d574fcd6f67da3eee0ace66b"),
+			MustHexID("1ae37829c9ef41f8b508b82259ebac76b1ed900d7a45c08b7970f25d2d48ddd1829e2f11423a18749940b6dab8598c6e416cef0efd47e46e51f29a0bc65b37cd"),
+			MustHexID("ba973cab31c2af091fc1644a93527d62b2394999e2b6ccbf158dd5ab9796a43d408786f1803ef4e29debfeb62fce2b6caa5ab2b24d1549c822a11c40c2856665"),
+			MustHexID("bc413ad270dd6ea25bddba78f3298b03b8ba6f8608ac03d06007d4116fa78ef5a0cfe8c80155089382fc7a193243ee5500082660cb5d7793f60f2d7d18650964"),
+			MustHexID("5a6a9ef07634d9eec3baa87c997b529b92652afa11473dfee41ef7037d5c06e0ddb9fe842364462d79dd31cff8a59a1b8d5bc2b810dea1d4cbbd3beb80ecec83"),
+			MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
+			MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
+		},
+		256: []NodeID{
+			MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
+			MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
+			MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),
+			MustHexID("7feaee0d818c03eb30e4e0bf03ade0f3c21ca38e938a761aa1781cf70bda8cc5cd631a6cc53dd44f1d4a6d3e2dae6513c6c66ee50cb2f0e9ad6f7e319b309fd9"),
+			MustHexID("4ca3b657b139311db8d583c25dd5963005e46689e1317620496cc64129c7f3e52870820e0ec7941d28809311df6db8a2867bbd4f235b4248af24d7a9c22d1232"),
+			MustHexID("1181defb1d16851d42dd951d84424d6bd1479137f587fa184d5a8152be6b6b16ed08bcdb2c2ed8539bcde98c80c432875f9f724737c316a2bd385a39d3cab1d8"),
+			MustHexID("d9dd818769fa0c3ec9f553c759b92476f082817252a04a47dc1777740b1731d280058c66f982812f173a294acf4944a85ba08346e2de153ba3ba41ce8a62cb64"),
+			MustHexID("bd7c4f8a9e770aa915c771b15e107ca123d838762da0d3ffc53aa6b53e9cd076cffc534ec4d2e4c334c683f1f5ea72e0e123f6c261915ed5b58ac1b59f003d88"),
+			MustHexID("3dd5739c73649d510456a70e9d6b46a855864a4a3f744e088fd8c8da11b18e4c9b5f2d7da50b1c147b2bae5ca9609ae01f7a3cdea9dce34f80a91d29cd82f918"),
+			MustHexID("f0d7df1efc439b4bcc0b762118c1cfa99b2a6143a9f4b10e3c9465125f4c9fca4ab88a2504169bbcad65492cf2f50da9dd5d077c39574a944f94d8246529066b"),
+			MustHexID("dd598b9ba441448e5fb1a6ec6c5f5aa9605bad6e223297c729b1705d11d05f6bfd3d41988b694681ae69bb03b9a08bff4beab5596503d12a39bffb5cd6e94c7c"),
+			MustHexID("3fce284ac97e567aebae681b15b7a2b6df9d873945536335883e4bbc26460c064370537f323fd1ada828ea43154992d14ac0cec0940a2bd2a3f42ec156d60c83"),
+			MustHexID("7c8dfa8c1311cb14fb29a8ac11bca23ecc115e56d9fcf7b7ac1db9066aa4eb39f8b1dabf46e192a65be95ebfb4e839b5ab4533fef414921825e996b210dd53bd"),
+			MustHexID("cafa6934f82120456620573d7f801390ed5e16ed619613a37e409e44ab355ef755e83565a913b48a9466db786f8d4fbd590bfec474c2524d4a2608d4eafd6abd"),
+			MustHexID("9d16600d0dd310d77045769fed2cb427f32db88cd57d86e49390c2ba8a9698cfa856f775be2013237226e7bf47b248871cf865d23015937d1edeb20db5e3e760"),
+			MustHexID("17be6b6ba54199b1d80eff866d348ea11d8a4b341d63ad9a6681d3ef8a43853ac564d153eb2a8737f0afc9ab320f6f95c55aa11aaa13bbb1ff422fd16bdf8188"),
+		},
+	},
+}
+
+type preminedTestnet struct {
+	target    NodeID
+	targetSha common.Hash // sha3(target)
+	dists     [hashBits + 1][]NodeID
+	net       *Network
+}
+
+func (tn *preminedTestnet) sendFindnode(to *Node, target NodeID) {
+	// current log distance is encoded in port number
+	// fmt.Println("findnode query at dist", toaddr.Port)
+	if to.UDP == 0 {
+		panic("query to node at distance 0")
+	}
+	next := to.UDP - 1
+	var result []rpcNode
+	for i, id := range tn.dists[to.UDP] {
+		result = append(result, nodeToRPC(NewNode(id, net.ParseIP("127.0.0.1"), next, uint16(i)+1)))
+	}
+	injectResponse(tn.net, to, neighborsPacket, &neighbors{Nodes: result})
+}
+
+func (tn *preminedTestnet) sendNeighbours(to *Node, nodes []*Node) {
+	panic("sendNeighbours called")
+}
+
+func (tn *preminedTestnet) sendPing(to *Node, addr *net.UDPAddr) []byte {
+	injectResponse(tn.net, to, pongPacket, &pong{ReplyTok: []byte{1}})
+	return []byte{1}
+}
+
+func (tn *preminedTestnet) sendPong(to *Node, pingHash []byte) {
+}
+
+func (*preminedTestnet) Close()                  {}
+func (*preminedTestnet) localAddr() *net.UDPAddr { return new(net.UDPAddr) }
+
+// mine generates a testnet struct literal with nodes at
+// various distances to the given target.
+func (n *preminedTestnet) mine(target NodeID) {
+	n.target = target
+	n.targetSha = crypto.Keccak256Hash(n.target[:])
+	found := 0
+	for found < bucketSize*10 {
+		k := newkey()
+		id := PubkeyID(&k.PublicKey)
+		sha := crypto.Keccak256Hash(id[:])
+		ld := logdist(n.targetSha, sha)
+		if len(n.dists[ld]) < bucketSize {
+			n.dists[ld] = append(n.dists[ld], id)
+			fmt.Println("found ID with ld", ld)
+			found++
+		}
+	}
+	fmt.Println("&preminedTestnet{")
+	fmt.Printf("	target: %#v,\n", n.target)
+	fmt.Printf("	targetSha: %#v,\n", n.targetSha)
+	fmt.Printf("	dists: [%d][]NodeID{\n", len(n.dists))
+	for ld, ns := range n.dists {
+		if len(ns) == 0 {
+			continue
+		}
+		fmt.Printf("		%d: []NodeID{\n", ld)
+		for _, n := range ns {
+			fmt.Printf("			MustHexID(\"%x\"),\n", n[:])
+		}
+		fmt.Println("		},")
+	}
+	fmt.Println("	},")
+	fmt.Println("}")
+}
+
+func injectResponse(net *Network, from *Node, ev nodeEvent, packet interface{}) {
+	go net.reqReadPacket(ingressPacket{remoteID: from.ID, remoteAddr: from.addr(), ev: ev, data: packet})
+}

p2p/discover/node.go

@@ -17,6 +17,7 @@
 package discover
 
 import (
+	"bytes"
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"encoding/hex"
@@ -35,25 +36,17 @@ import (
 	"github.com/ethereum/go-ethereum/crypto/secp256k1"
 )
 
-const nodeIDBits = 512
-
 // Node represents a host on the network.
-// The fields of Node may not be modified.
+// The public fields of Node may not be modified.
 type Node struct {
 	IP       net.IP // len 4 for IPv4 or 16 for IPv6
 	UDP, TCP uint16 // port numbers
 	ID       NodeID // the node's public key
 
-	// This is a cached copy of sha3(ID) which is used for node
+	// Network-related fields are contained in nodeNetGuts.
-	// distance calculations. This is part of Node in order to make it
+	// These fields are not supposed to be used off the
-	// possible to write tests that need a node at a certain distance.
+	// Network.loop goroutine.
-	// In those tests, the content of sha will not actually correspond
+	nodeNetGuts
-	// with ID.
-	sha common.Hash
-
-	// whether this node is currently being pinged in order to replace
-	// it in a bucket
-	contested bool
 }
 
 // NewNode creates a new node. It is mostly meant to be used for
@@ -67,7 +60,7 @@ func NewNode(id NodeID, ip net.IP, udpPort, tcpPort uint16) *Node {
 		UDP:         udpPort,
 		TCP:         tcpPort,
 		ID:          id,
-		sha: crypto.Keccak256Hash(id[:]),
+		nodeNetGuts: nodeNetGuts{sha: crypto.Keccak256Hash(id[:])},
 	}
 }
 
@@ -75,6 +68,23 @@ func (n *Node) addr() *net.UDPAddr {
 	return &net.UDPAddr{IP: n.IP, Port: int(n.UDP)}
 }
 
+func (n *Node) setAddr(a *net.UDPAddr) {
+	n.IP = a.IP
+	if ipv4 := a.IP.To4(); ipv4 != nil {
+		n.IP = ipv4
+	}
+	n.UDP = uint16(a.Port)
+}
+
+// compares the given address against the stored values.
+func (n *Node) addrEqual(a *net.UDPAddr) bool {
+	ip := a.IP
+	if ipv4 := a.IP.To4(); ipv4 != nil {
+		ip = ipv4
+	}
+	return n.UDP == uint16(a.Port) && bytes.Equal(n.IP, ip)
+}
+
 // Incomplete returns true for nodes with no IP address.
 func (n *Node) Incomplete() bool {
 	return n.IP == nil
@@ -207,6 +217,8 @@ func MustParseNode(rawurl string) *Node {
 	return n
 }
 
+const nodeIDBits = 512
+
 // NodeID is a unique identifier for each node.
 // The node identifier is a marshaled elliptic curve public key.
 type NodeID [nodeIDBits / 8]byte
@@ -272,6 +284,14 @@ func (id NodeID) Pubkey() (*ecdsa.PublicKey, error) {
 	return p, nil
 }
 
+func (id NodeID) mustPubkey() ecdsa.PublicKey {
+	pk, err := id.Pubkey()
+	if err != nil {
+		panic(err)
+	}
+	return *pk
+}
+
 // recoverNodeID computes the public key used to sign the
 // given hash from the signature.
 func recoverNodeID(hash, sig []byte) (id NodeID, err error) {

p2p/discover/nodeevent_string.go

@@ -0,0 +1,43 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// Code generated by "stringer -type=nodeEvent"; DO NOT EDIT
+
+package discover
+
+import "fmt"
+
+const (
+	_nodeEvent_name_0 = "invalidEventpingPacketpongPacketfindnodePacketneighborsPacket"
+	_nodeEvent_name_1 = "pongTimeoutpingTimeoutneighboursTimeout"
+)
+
+var (
+	_nodeEvent_index_0 = [...]uint8{0, 12, 22, 32, 46, 61}
+	_nodeEvent_index_1 = [...]uint8{0, 11, 22, 39}
+)
+
+func (i nodeEvent) String() string {
+	switch {
+	case 0 <= i && i <= 4:
+		return _nodeEvent_name_0[_nodeEvent_index_0[i]:_nodeEvent_index_0[i+1]]
+	case 261 <= i && i <= 263:
+		i -= 261
+		return _nodeEvent_name_1[_nodeEvent_index_1[i]:_nodeEvent_index_1[i+1]]
+	default:
+		return fmt.Sprintf("nodeEvent(%d)", i)
+	}
+}

p2p/discover/table.go

@@ -25,17 +25,10 @@ package discover
 import (
 	"crypto/rand"
 	"encoding/binary"
-	"errors"
-	"fmt"
 	"net"
 	"sort"
-	"sync"
-	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
 )
 
 const (
@@ -46,90 +39,35 @@ const (
 
 	maxBondingPingPongs = 16
 	maxFindnodeFailures = 5
-
-	autoRefreshInterval = 1 * time.Hour
-	seedCount           = 30
-	seedMaxAge          = 5 * 24 * time.Hour
 )
 
 type Table struct {
-	mutex   sync.Mutex        // protects buckets, their content, and nursery
+	count         int               // number of nodes
 	buckets       [nBuckets]*bucket // index of known nodes by distance
-	nursery []*Node           // bootstrap nodes
-	db      *nodeDB           // database of known nodes
-
-	refreshReq chan chan struct{}
-	closeReq   chan struct{}
-	closed     chan struct{}
-
-	bondmu    sync.Mutex
-	bonding   map[NodeID]*bondproc
-	bondslots chan struct{} // limits total number of active bonding processes
-
 	nodeAddedHook func(*Node)       // for testing
-
-	net  transport
 	self          *Node             // metadata of the local node
 }
 
-type bondproc struct {
-	err  error
-	n    *Node
-	done chan struct{}
-}
-
-// transport is implemented by the UDP transport.
-// it is an interface so we can test without opening lots of UDP
-// sockets and without generating a private key.
-type transport interface {
-	ping(NodeID, *net.UDPAddr) error
-	waitping(NodeID) error
-	findnode(toid NodeID, addr *net.UDPAddr, target NodeID) ([]*Node, error)
-	close()
-}
-
 // bucket contains nodes, ordered by their last activity. the entry
 // that was most recently active is the first element in entries.
-type bucket struct{ entries []*Node }
+type bucket struct {
+	entries      []*Node
+	replacements []*Node
+}
 
-func newTable(t transport, ourID NodeID, ourAddr *net.UDPAddr, nodeDBPath string) (*Table, error) {
+func newTable(ourID NodeID, ourAddr *net.UDPAddr) *Table {
-	// If no node database was given, use an in-memory one
+	self := NewNode(ourID, ourAddr.IP, uint16(ourAddr.Port), uint16(ourAddr.Port))
-	db, err := newNodeDB(nodeDBPath, Version, ourID)
+	tab := &Table{self: self}
-	if err != nil {
-		return nil, err
-	}
-	tab := &Table{
-		net:        t,
-		db:         db,
-		self:       NewNode(ourID, ourAddr.IP, uint16(ourAddr.Port), uint16(ourAddr.Port)),
-		bonding:    make(map[NodeID]*bondproc),
-		bondslots:  make(chan struct{}, maxBondingPingPongs),
-		refreshReq: make(chan chan struct{}),
-		closeReq:   make(chan struct{}),
-		closed:     make(chan struct{}),
-	}
-	for i := 0; i < cap(tab.bondslots); i++ {
-		tab.bondslots <- struct{}{}
-	}
 	for i := range tab.buckets {
 		tab.buckets[i] = new(bucket)
 	}
-	go tab.refreshLoop()
+	return tab
-	return tab, nil
 }
 
-// Self returns the local node.
+// readRandomNodes fills the given slice with random nodes from the
-// The returned node should not be modified by the caller.
-func (tab *Table) Self() *Node {
-	return tab.self
-}
-
-// ReadRandomNodes fills the given slice with random nodes from the
 // table. It will not write the same node more than once. The nodes in
 // the slice are copies and can be modified by the caller.
-func (tab *Table) ReadRandomNodes(buf []*Node) (n int) {
+func (tab *Table) readRandomNodes(buf []*Node) (n int) {
-	tab.mutex.Lock()
-	defer tab.mutex.Unlock()
 	// TODO: tree-based buckets would help here
 	// Find all non-empty buckets and get a fresh slice of their entries.
 	var buckets [][]*Node
@@ -171,236 +109,6 @@ func randUint(max uint32) uint32 {
 	return binary.BigEndian.Uint32(b[:]) % max
 }
 
-// Close terminates the network listener and flushes the node database.
-func (tab *Table) Close() {
-	select {
-	case <-tab.closed:
-		// already closed.
-	case tab.closeReq <- struct{}{}:
-		<-tab.closed // wait for refreshLoop to end.
-	}
-}
-
-// SetFallbackNodes sets the initial points of contact. These nodes
-// are used to connect to the network if the table is empty and there
-// are no known nodes in the database.
-func (tab *Table) SetFallbackNodes(nodes []*Node) error {
-	for _, n := range nodes {
-		if err := n.validateComplete(); err != nil {
-			return fmt.Errorf("bad bootstrap/fallback node %q (%v)", n, err)
-		}
-	}
-	tab.mutex.Lock()
-	tab.nursery = make([]*Node, 0, len(nodes))
-	for _, n := range nodes {
-		cpy := *n
-		// Recompute cpy.sha because the node might not have been
-		// created by NewNode or ParseNode.
-		cpy.sha = crypto.Keccak256Hash(n.ID[:])
-		tab.nursery = append(tab.nursery, &cpy)
-	}
-	tab.mutex.Unlock()
-	tab.refresh()
-	return nil
-}
-
-// Resolve searches for a specific node with the given ID.
-// It returns nil if the node could not be found.
-func (tab *Table) Resolve(targetID NodeID) *Node {
-	// If the node is present in the local table, no
-	// network interaction is required.
-	hash := crypto.Keccak256Hash(targetID[:])
-	tab.mutex.Lock()
-	cl := tab.closest(hash, 1)
-	tab.mutex.Unlock()
-	if len(cl.entries) > 0 && cl.entries[0].ID == targetID {
-		return cl.entries[0]
-	}
-	// Otherwise, do a network lookup.
-	result := tab.Lookup(targetID)
-	for _, n := range result {
-		if n.ID == targetID {
-			return n
-		}
-	}
-	return nil
-}
-
-// Lookup performs a network search for nodes close
-// to the given target. It approaches the target by querying
-// nodes that are closer to it on each iteration.
-// The given target does not need to be an actual node
-// identifier.
-func (tab *Table) Lookup(targetID NodeID) []*Node {
-	return tab.lookup(targetID, true)
-}
-
-func (tab *Table) lookup(targetID NodeID, refreshIfEmpty bool) []*Node {
-	var (
-		target         = crypto.Keccak256Hash(targetID[:])
-		asked          = make(map[NodeID]bool)
-		seen           = make(map[NodeID]bool)
-		reply          = make(chan []*Node, alpha)
-		pendingQueries = 0
-		result         *nodesByDistance
-	)
-	// don't query further if we hit ourself.
-	// unlikely to happen often in practice.
-	asked[tab.self.ID] = true
-
-	for {
-		tab.mutex.Lock()
-		// generate initial result set
-		result = tab.closest(target, bucketSize)
-		tab.mutex.Unlock()
-		if len(result.entries) > 0 || !refreshIfEmpty {
-			break
-		}
-		// The result set is empty, all nodes were dropped, refresh.
-		// We actually wait for the refresh to complete here. The very
-		// first query will hit this case and run the bootstrapping
-		// logic.
-		<-tab.refresh()
-		refreshIfEmpty = false
-	}
-
-	for {
-		// ask the alpha closest nodes that we haven't asked yet
-		for i := 0; i < len(result.entries) && pendingQueries < alpha; i++ {
-			n := result.entries[i]
-			if !asked[n.ID] {
-				asked[n.ID] = true
-				pendingQueries++
-				go func() {
-					// Find potential neighbors to bond with
-					r, err := tab.net.findnode(n.ID, n.addr(), targetID)
-					if err != nil {
-						// Bump the failure counter to detect and evacuate non-bonded entries
-						fails := tab.db.findFails(n.ID) + 1
-						tab.db.updateFindFails(n.ID, fails)
-						glog.V(logger.Detail).Infof("Bumping failures for %x: %d", n.ID[:8], fails)
-
-						if fails >= maxFindnodeFailures {
-							glog.V(logger.Detail).Infof("Evacuating node %x: %d findnode failures", n.ID[:8], fails)
-							tab.delete(n)
-						}
-					}
-					reply <- tab.bondall(r)
-				}()
-			}
-		}
-		if pendingQueries == 0 {
-			// we have asked all closest nodes, stop the search
-			break
-		}
-		// wait for the next reply
-		for _, n := range <-reply {
-			if n != nil && !seen[n.ID] {
-				seen[n.ID] = true
-				result.push(n, bucketSize)
-			}
-		}
-		pendingQueries--
-	}
-	return result.entries
-}
-
-func (tab *Table) refresh() <-chan struct{} {
-	done := make(chan struct{})
-	select {
-	case tab.refreshReq <- done:
-	case <-tab.closed:
-		close(done)
-	}
-	return done
-}
-
-// refreshLoop schedules doRefresh runs and coordinates shutdown.
-func (tab *Table) refreshLoop() {
-	var (
-		timer   = time.NewTicker(autoRefreshInterval)
-		waiting []chan struct{} // accumulates waiting callers while doRefresh runs
-		done    chan struct{}   // where doRefresh reports completion
-	)
-loop:
-	for {
-		select {
-		case <-timer.C:
-			if done == nil {
-				done = make(chan struct{})
-				go tab.doRefresh(done)
-			}
-		case req := <-tab.refreshReq:
-			waiting = append(waiting, req)
-			if done == nil {
-				done = make(chan struct{})
-				go tab.doRefresh(done)
-			}
-		case <-done:
-			for _, ch := range waiting {
-				close(ch)
-			}
-			waiting = nil
-			done = nil
-		case <-tab.closeReq:
-			break loop
-		}
-	}
-
-	if tab.net != nil {
-		tab.net.close()
-	}
-	if done != nil {
-		<-done
-	}
-	for _, ch := range waiting {
-		close(ch)
-	}
-	tab.db.close()
-	close(tab.closed)
-}
-
-// doRefresh performs a lookup for a random target to keep buckets
-// full. seed nodes are inserted if the table is empty (initial
-// bootstrap or discarded faulty peers).
-func (tab *Table) doRefresh(done chan struct{}) {
-	defer close(done)
-
-	// The Kademlia paper specifies that the bucket refresh should
-	// perform a lookup in the least recently used bucket. We cannot
-	// adhere to this because the findnode target is a 512bit value
-	// (not hash-sized) and it is not easily possible to generate a
-	// sha3 preimage that falls into a chosen bucket.
-	// We perform a lookup with a random target instead.
-	var target NodeID
-	rand.Read(target[:])
-	result := tab.lookup(target, false)
-	if len(result) > 0 {
-		return
-	}
-
-	// The table is empty. Load nodes from the database and insert
-	// them. This should yield a few previously seen nodes that are
-	// (hopefully) still alive.
-	seeds := tab.db.querySeeds(seedCount, seedMaxAge)
-	seeds = tab.bondall(append(seeds, tab.nursery...))
-	if glog.V(logger.Debug) {
-		if len(seeds) == 0 {
-			glog.Infof("no seed nodes found")
-		}
-		for _, n := range seeds {
-			age := time.Since(tab.db.lastPong(n.ID))
-			glog.Infof("seed node (age %v): %v", age, n)
-		}
-	}
-	tab.mutex.Lock()
-	tab.stuff(seeds)
-	tab.mutex.Unlock()
-
-	// Finally, do a self lookup to fill up the buckets.
-	tab.lookup(tab.self.ID, false)
-}
-
 // closest returns the n nodes in the table that are closest to the
 // given id. The caller must hold tab.mutex.
 func (tab *Table) closest(target common.Hash, nresults int) *nodesByDistance {
@@ -416,177 +124,38 @@ func (tab *Table) closest(target common.Hash, nresults int) *nodesByDistance {
 	return close
 }
 
-func (tab *Table) len() (n int) {
-	for _, b := range tab.buckets {
-		n += len(b.entries)
-	}
-	return n
-}
-
-// bondall bonds with all given nodes concurrently and returns
-// those nodes for which bonding has probably succeeded.
-func (tab *Table) bondall(nodes []*Node) (result []*Node) {
-	rc := make(chan *Node, len(nodes))
-	for i := range nodes {
-		go func(n *Node) {
-			nn, _ := tab.bond(false, n.ID, n.addr(), uint16(n.TCP))
-			rc <- nn
-		}(nodes[i])
-	}
-	for _ = range nodes {
-		if n := <-rc; n != nil {
-			result = append(result, n)
-		}
-	}
-	return result
-}
-
-// bond ensures the local node has a bond with the given remote node.
-// It also attempts to insert the node into the table if bonding succeeds.
-// The caller must not hold tab.mutex.
-//
-// A bond is must be established before sending findnode requests.
-// Both sides must have completed a ping/pong exchange for a bond to
-// exist. The total number of active bonding processes is limited in
-// order to restrain network use.
-//
-// bond is meant to operate idempotently in that bonding with a remote
-// node which still remembers a previously established bond will work.
-// The remote node will simply not send a ping back, causing waitping
-// to time out.
-//
-// If pinged is true, the remote node has just pinged us and one half
-// of the process can be skipped.
-func (tab *Table) bond(pinged bool, id NodeID, addr *net.UDPAddr, tcpPort uint16) (*Node, error) {
-	if id == tab.self.ID {
-		return nil, errors.New("is self")
-	}
-	// Retrieve a previously known node and any recent findnode failures
-	node, fails := tab.db.node(id), 0
-	if node != nil {
-		fails = tab.db.findFails(id)
-	}
-	// If the node is unknown (non-bonded) or failed (remotely unknown), bond from scratch
-	var result error
-	age := time.Since(tab.db.lastPong(id))
-	if node == nil || fails > 0 || age > nodeDBNodeExpiration {
-		glog.V(logger.Detail).Infof("Bonding %x: known=%t, fails=%d age=%v", id[:8], node != nil, fails, age)
-
-		tab.bondmu.Lock()
-		w := tab.bonding[id]
-		if w != nil {
-			// Wait for an existing bonding process to complete.
-			tab.bondmu.Unlock()
-			<-w.done
-		} else {
-			// Register a new bonding process.
-			w = &bondproc{done: make(chan struct{})}
-			tab.bonding[id] = w
-			tab.bondmu.Unlock()
-			// Do the ping/pong. The result goes into w.
-			tab.pingpong(w, pinged, id, addr, tcpPort)
-			// Unregister the process after it's done.
-			tab.bondmu.Lock()
-			delete(tab.bonding, id)
-			tab.bondmu.Unlock()
-		}
-		// Retrieve the bonding results
-		result = w.err
-		if result == nil {
-			node = w.n
-		}
-	}
-	if node != nil {
-		// Add the node to the table even if the bonding ping/pong
-		// fails. It will be relaced quickly if it continues to be
-		// unresponsive.
-		tab.add(node)
-		tab.db.updateFindFails(id, 0)
-	}
-	return node, result
-}
-
-func (tab *Table) pingpong(w *bondproc, pinged bool, id NodeID, addr *net.UDPAddr, tcpPort uint16) {
-	// Request a bonding slot to limit network usage
-	<-tab.bondslots
-	defer func() { tab.bondslots <- struct{}{} }()
-
-	// Ping the remote side and wait for a pong.
-	if w.err = tab.ping(id, addr); w.err != nil {
-		close(w.done)
-		return
-	}
-	if !pinged {
-		// Give the remote node a chance to ping us before we start
-		// sending findnode requests. If they still remember us,
-		// waitping will simply time out.
-		tab.net.waitping(id)
-	}
-	// Bonding succeeded, update the node database.
-	w.n = NewNode(id, addr.IP, uint16(addr.Port), tcpPort)
-	tab.db.updateNode(w.n)
-	close(w.done)
-}
-
-// ping a remote endpoint and wait for a reply, also updating the node
-// database accordingly.
-func (tab *Table) ping(id NodeID, addr *net.UDPAddr) error {
-	tab.db.updateLastPing(id, time.Now())
-	if err := tab.net.ping(id, addr); err != nil {
-		return err
-	}
-	tab.db.updateLastPong(id, time.Now())
-
-	// Start the background expiration goroutine after the first
-	// successful communication. Subsequent calls have no effect if it
-	// is already running. We do this here instead of somewhere else
-	// so that the search for seed nodes also considers older nodes
-	// that would otherwise be removed by the expiration.
-	tab.db.ensureExpirer()
-	return nil
-}
-
 // add attempts to add the given node its corresponding bucket. If the
 // bucket has space available, adding the node succeeds immediately.
-// Otherwise, the node is added if the least recently active node in
+// Otherwise, the node is added to the replacement cache for the bucket.
-// the bucket does not respond to a ping packet.
+func (tab *Table) add(n *Node) (contested *Node) {
-//
+	b := tab.buckets[logdist(tab.self.sha, n.sha)]
-// The caller must not hold tab.mutex.
+	switch {
-func (tab *Table) add(new *Node) {
+	case b.bump(n):
-	b := tab.buckets[logdist(tab.self.sha, new.sha)]
+		// n exists in b.
-	tab.mutex.Lock()
+		return nil
-	defer tab.mutex.Unlock()
+	case len(b.entries) < bucketSize:
-	if b.bump(new) {
+		// b has space available.
-		return
+		b.addFront(n)
+		tab.count++
+		if tab.nodeAddedHook != nil {
+			tab.nodeAddedHook(n)
 		}
-	var oldest *Node
+		return nil
-	if len(b.entries) == bucketSize {
+	default:
-		oldest = b.entries[bucketSize-1]
+		// b has no space left, add to replacement cache
-		if oldest.contested {
+		// and revalidate the last entry.
-			// The node is already being replaced, don't attempt
+		// TODO: drop previous node
-			// to replace it.
+		b.replacements = append(b.replacements, n)
-			return
+		if len(b.replacements) > bucketSize {
+			copy(b.replacements, b.replacements[1:])
+			b.replacements = b.replacements[:len(b.replacements)-1]
 		}
-		oldest.contested = true
+		return b.entries[len(b.entries)-1]
-		// Let go of the mutex so other goroutines can access
-		// the table while we ping the least recently active node.
-		tab.mutex.Unlock()
-		err := tab.ping(oldest.ID, oldest.addr())
-		tab.mutex.Lock()
-		oldest.contested = false
-		if err == nil {
-			// The node responded, don't replace it.
-			return
-		}
-	}
-	added := b.replace(new, oldest)
-	if added && tab.nodeAddedHook != nil {
-		tab.nodeAddedHook(new)
 	}
 }
 
 // stuff adds nodes the table to the end of their corresponding bucket
-// if the bucket is not full. The caller must hold tab.mutex.
+// if the bucket is not full.
 func (tab *Table) stuff(nodes []*Node) {
 outer:
 	for _, n := range nodes {
@@ -601,6 +170,7 @@ outer:
 		}
 		if len(bucket.entries) < bucketSize {
 			bucket.entries = append(bucket.entries, n)
+			tab.count++
 			if tab.nodeAddedHook != nil {
 				tab.nodeAddedHook(n)
 			}
@@ -611,36 +181,39 @@ outer:
 // delete removes an entry from the node table (used to evacuate
 // failed/non-bonded discovery peers).
 func (tab *Table) delete(node *Node) {
-	tab.mutex.Lock()
-	defer tab.mutex.Unlock()
 	bucket := tab.buckets[logdist(tab.self.sha, node.sha)]
 	for i := range bucket.entries {
 		if bucket.entries[i].ID == node.ID {
 			bucket.entries = append(bucket.entries[:i], bucket.entries[i+1:]...)
+			tab.count--
 			return
 		}
 	}
 }
 
-func (b *bucket) replace(n *Node, last *Node) bool {
+func (tab *Table) deleteReplace(node *Node) {
-	// Don't add if b already contains n.
+	b := tab.buckets[logdist(tab.self.sha, node.sha)]
 	for i := range b.entries {
-		if b.entries[i].ID == n.ID {
+		if b.entries[i].ID == node.ID {
-			return false
+			b.entries = append(b.entries[:i], b.entries[i+1:]...)
+			tab.count--
 		}
 	}
-	// Replace last if it is still the last entry or just add n if b
+	// refill from replacement cache
-	// isn't full. If is no longer the last entry, it has either been
+	// TODO: maybe use random index
-	// replaced with someone else or became active.
+	if len(b.entries) < bucketSize && len(b.replacements) > 0 {
-	if len(b.entries) == bucketSize && (last == nil || b.entries[bucketSize-1].ID != last.ID) {
+		ri := len(b.replacements) - 1
-		return false
+		b.addFront(b.replacements[ri])
+		tab.count++
+		b.replacements[ri] = nil
+		b.replacements = b.replacements[:ri]
 	}
-	if len(b.entries) < bucketSize {
+}
+
+func (b *bucket) addFront(n *Node) {
 	b.entries = append(b.entries, nil)
-	}
 	copy(b.entries[1:], b.entries)
 	b.entries[0] = n
-	return true
 }
 
 func (b *bucket) bump(n *Node) bool {

p2p/discover/table_test.go

@@ -31,62 +31,71 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
-func TestTable_pingReplace(t *testing.T) {
+type nullTransport struct{}
-	doit := func(newNodeIsResponding, lastInBucketIsResponding bool) {
-		transport := newPingRecorder()
-		tab, _ := newTable(transport, NodeID{}, &net.UDPAddr{}, "")
-		defer tab.Close()
-		pingSender := NewNode(MustHexID("a502af0f59b2aab7746995408c79e9ca312d2793cc997e44fc55eda62f0150bbb8c59a6f9269ba3a081518b62699ee807c7c19c20125ddfccca872608af9e370"), net.IP{}, 99, 99)
 
-		// fill up the sender's bucket.
+func (nullTransport) sendPing(remote *Node, remoteAddr *net.UDPAddr) []byte { return []byte{1} }
-		last := fillBucket(tab, 253)
+func (nullTransport) sendPong(remote *Node, pingHash []byte)                {}
+func (nullTransport) sendFindnode(remote *Node, target NodeID)              {}
+func (nullTransport) sendNeighbours(remote *Node, nodes []*Node)            {}
+func (nullTransport) localAddr() *net.UDPAddr                               { return new(net.UDPAddr) }
+func (nullTransport) Close()                                                {}
 
-		// this call to bond should replace the last node
+// func TestTable_pingReplace(t *testing.T) {
-		// in its bucket if the node is not responding.
+// 	doit := func(newNodeIsResponding, lastInBucketIsResponding bool) {
-		transport.responding[last.ID] = lastInBucketIsResponding
+// 		transport := newPingRecorder()
-		transport.responding[pingSender.ID] = newNodeIsResponding
+// 		tab, _ := newTable(transport, NodeID{}, &net.UDPAddr{})
-		tab.bond(true, pingSender.ID, &net.UDPAddr{}, 0)
+// 		defer tab.Close()
-
+// 		pingSender := NewNode(MustHexID("a502af0f59b2aab7746995408c79e9ca312d2793cc997e44fc55eda62f0150bbb8c59a6f9269ba3a081518b62699ee807c7c19c20125ddfccca872608af9e370"), net.IP{}, 99, 99)
-		// first ping goes to sender (bonding pingback)
+//
-		if !transport.pinged[pingSender.ID] {
+// 		// fill up the sender's bucket.
-			t.Error("table did not ping back sender")
+// 		last := fillBucket(tab, 253)
-		}
+//
-		if newNodeIsResponding {
+// 		// this call to bond should replace the last node
-			// second ping goes to oldest node in bucket
+// 		// in its bucket if the node is not responding.
-			// to see whether it is still alive.
+// 		transport.responding[last.ID] = lastInBucketIsResponding
-			if !transport.pinged[last.ID] {
+// 		transport.responding[pingSender.ID] = newNodeIsResponding
-				t.Error("table did not ping last node in bucket")
+// 		tab.bond(true, pingSender.ID, &net.UDPAddr{}, 0)
-			}
+//
-		}
+// 		// first ping goes to sender (bonding pingback)
-
+// 		if !transport.pinged[pingSender.ID] {
-		tab.mutex.Lock()
+// 			t.Error("table did not ping back sender")
-		defer tab.mutex.Unlock()
+// 		}
-		if l := len(tab.buckets[253].entries); l != bucketSize {
+// 		if newNodeIsResponding {
-			t.Errorf("wrong bucket size after bond: got %d, want %d", l, bucketSize)
+// 			// second ping goes to oldest node in bucket
-		}
+// 			// to see whether it is still alive.
-
+// 			if !transport.pinged[last.ID] {
-		if lastInBucketIsResponding || !newNodeIsResponding {
+// 				t.Error("table did not ping last node in bucket")
-			if !contains(tab.buckets[253].entries, last.ID) {
+// 			}
-				t.Error("last entry was removed")
+// 		}
-			}
+//
-			if contains(tab.buckets[253].entries, pingSender.ID) {
+// 		tab.mutex.Lock()
-				t.Error("new entry was added")
+// 		defer tab.mutex.Unlock()
-			}
+// 		if l := len(tab.buckets[253].entries); l != bucketSize {
-		} else {
+// 			t.Errorf("wrong bucket size after bond: got %d, want %d", l, bucketSize)
-			if contains(tab.buckets[253].entries, last.ID) {
+// 		}
-				t.Error("last entry was not removed")
+//
-			}
+// 		if lastInBucketIsResponding || !newNodeIsResponding {
-			if !contains(tab.buckets[253].entries, pingSender.ID) {
+// 			if !contains(tab.buckets[253].entries, last.ID) {
-				t.Error("new entry was not added")
+// 				t.Error("last entry was removed")
-			}
+// 			}
-		}
+// 			if contains(tab.buckets[253].entries, pingSender.ID) {
-	}
+// 				t.Error("new entry was added")
-
+// 			}
-	doit(true, true)
+// 		} else {
-	doit(false, true)
+// 			if contains(tab.buckets[253].entries, last.ID) {
-	doit(true, false)
+// 				t.Error("last entry was not removed")
-	doit(false, false)
+// 			}
-}
+// 			if !contains(tab.buckets[253].entries, pingSender.ID) {
+// 				t.Error("new entry was not added")
+// 			}
+// 		}
+// 	}
+//
+// 	doit(true, true)
+// 	doit(false, true)
+// 	doit(true, false)
+// 	doit(false, false)
+// }
 
 func TestBucket_bumpNoDuplicates(t *testing.T) {
 	t.Parallel()
@@ -177,8 +186,7 @@ func TestTable_closest(t *testing.T) {
 
 	test := func(test *closeTest) bool {
 		// for any node table, Target and N
-		tab, _ := newTable(nil, test.Self, &net.UDPAddr{}, "")
+		tab := newTable(test.Self, &net.UDPAddr{})
-		defer tab.Close()
 		tab.stuff(test.All)
 
 		// check that doClosest(Target, N) returns nodes
@@ -194,8 +202,8 @@ func TestTable_closest(t *testing.T) {
 
 		// check that the number of results is min(N, tablen)
 		wantN := test.N
-		if tlen := tab.len(); tlen < test.N {
+		if tab.count < test.N {
-			wantN = tlen
+			wantN = tab.count
 		}
 		if len(result) != wantN {
 			t.Errorf("wrong number of nodes: got %d, want %d", len(result), wantN)
@@ -236,15 +244,14 @@ func TestTable_ReadRandomNodesGetAll(t *testing.T) {
 		},
 	}
 	test := func(buf []*Node) bool {
-		tab, _ := newTable(nil, NodeID{}, &net.UDPAddr{}, "")
+		tab := newTable(NodeID{}, &net.UDPAddr{})
-		defer tab.Close()
 		for i := 0; i < len(buf); i++ {
 			ld := cfg.Rand.Intn(len(tab.buckets))
 			tab.stuff([]*Node{nodeAtDistance(tab.self.sha, ld)})
 		}
-		gotN := tab.ReadRandomNodes(buf)
+		gotN := tab.readRandomNodes(buf)
-		if gotN != tab.len() {
+		if gotN != tab.count {
-			t.Errorf("wrong number of nodes, got %d, want %d", gotN, tab.len())
+			t.Errorf("wrong number of nodes, got %d, want %d", gotN, tab.count)
 			return false
 		}
 		if hasDuplicates(buf[:gotN]) {
@@ -277,290 +284,6 @@ func (*closeTest) Generate(rand *rand.Rand, size int) reflect.Value {
 	return reflect.ValueOf(t)
 }
 
-func TestTable_Lookup(t *testing.T) {
-	self := nodeAtDistance(common.Hash{}, 0)
-	tab, _ := newTable(lookupTestnet, self.ID, &net.UDPAddr{}, "")
-	defer tab.Close()
-
-	// lookup on empty table returns no nodes
-	if results := tab.Lookup(lookupTestnet.target); len(results) > 0 {
-		t.Fatalf("lookup on empty table returned %d results: %#v", len(results), results)
-	}
-	// seed table with initial node (otherwise lookup will terminate immediately)
-	seed := NewNode(lookupTestnet.dists[256][0], net.IP{}, 256, 0)
-	tab.stuff([]*Node{seed})
-
-	results := tab.Lookup(lookupTestnet.target)
-	t.Logf("results:")
-	for _, e := range results {
-		t.Logf("  ld=%d, %x", logdist(lookupTestnet.targetSha, e.sha), e.sha[:])
-	}
-	if len(results) != bucketSize {
-		t.Errorf("wrong number of results: got %d, want %d", len(results), bucketSize)
-	}
-	if hasDuplicates(results) {
-		t.Errorf("result set contains duplicate entries")
-	}
-	if !sortedByDistanceTo(lookupTestnet.targetSha, results) {
-		t.Errorf("result set not sorted by distance to target")
-	}
-	// TODO: check result nodes are actually closest
-}
-
-// This is the test network for the Lookup test.
-// The nodes were obtained by running testnet.mine with a random NodeID as target.
-var lookupTestnet = &preminedTestnet{
-	target:    MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
-	targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
-	dists: [257][]NodeID{
-		240: []NodeID{
-			MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
-			MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
-		},
-		244: []NodeID{
-			MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
-		},
-		246: []NodeID{
-			MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
-			MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
-			MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
-		},
-		247: []NodeID{
-			MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
-			MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
-			MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
-			MustHexID("8dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73"),
-			MustHexID("8b58c6073dd98bbad4e310b97186c8f822d3a5c7d57af40e2136e88e315afd115edb27d2d0685a908cfe5aa49d0debdda6e6e63972691d6bd8c5af2d771dd2a9"),
-			MustHexID("2cbb718b7dc682da19652e7d9eb4fefaf7b7147d82c1c2b6805edf77b85e29fde9f6da195741467ff2638dc62c8d3e014ea5686693c15ed0080b6de90354c137"),
-			MustHexID("e84027696d3f12f2de30a9311afea8fbd313c2360daff52bb5fc8c7094d5295758bec3134e4eef24e4cdf377b40da344993284628a7a346eba94f74160998feb"),
-			MustHexID("f1357a4f04f9d33753a57c0b65ba20a5d8777abbffd04e906014491c9103fb08590e45548d37aa4bd70965e2e81ddba94f31860348df01469eec8c1829200a68"),
-			MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
-			MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
-		},
-		248: []NodeID{
-			MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
-			MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
-			MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
-			MustHexID("3ed426322dee7572b08592e1e079f8b6c6b30e10e6243edd144a6a48fdbdb83df73a6e41b1143722cb82604f2203a32758610b5d9544f44a1a7921ba001528c1"),
-			MustHexID("b2e2a2b7fdd363572a3256e75435fab1da3b16f7891a8bd2015f30995dae665d7eabfd194d87d99d5df628b4bbc7b04e5b492c596422dd8272746c7a1b0b8e4f"),
-			MustHexID("0c69c9756162c593e85615b814ce57a2a8ca2df6c690b9c4e4602731b61e1531a3bbe3f7114271554427ffabea80ad8f36fa95a49fa77b675ae182c6ccac1728"),
-			MustHexID("8d28be21d5a97b0876442fa4f5e5387f5bf3faad0b6f13b8607b64d6e448c0991ca28dd7fe2f64eb8eadd7150bff5d5666aa6ed868b84c71311f4ba9a38569dd"),
-			MustHexID("2c677e1c64b9c9df6359348a7f5f33dc79e22f0177042486d125f8b6ca7f0dc756b1f672aceee5f1746bcff80aaf6f92a8dc0c9fbeb259b3fa0da060de5ab7e8"),
-			MustHexID("3994880f94a8678f0cd247a43f474a8af375d2a072128da1ad6cae84a244105ff85e94fc7d8496f639468de7ee998908a91c7e33ef7585fff92e984b210941a1"),
-			MustHexID("b45a9153c08d002a48090d15d61a7c7dad8c2af85d4ff5bd36ce23a9a11e0709bf8d56614c7b193bc028c16cbf7f20dfbcc751328b64a924995d47b41e452422"),
-			MustHexID("057ab3a9e53c7a84b0f3fc586117a525cdd18e313f52a67bf31798d48078e325abe5cfee3f6c2533230cb37d0549289d692a29dd400e899b8552d4b928f6f907"),
-			MustHexID("0ddf663d308791eb92e6bd88a2f8cb45e4f4f35bb16708a0e6ff7f1362aa6a73fedd0a1b1557fb3365e38e1b79d6918e2fae2788728b70c9ab6b51a3b94a4338"),
-			MustHexID("f637e07ff50cc1e3731735841c4798411059f2023abcf3885674f3e8032531b0edca50fd715df6feb489b6177c345374d64f4b07d257a7745de393a107b013a5"),
-			MustHexID("e24ec7c6eec094f63c7b3239f56d311ec5a3e45bc4e622a1095a65b95eea6fe13e29f3b6b7a2cbfe40906e3989f17ac834c3102dd0cadaaa26e16ee06d782b72"),
-			MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
-			MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
-		},
-		249: []NodeID{
-			MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
-			MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
-			MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
-			MustHexID("b1b4bfbda514d9b8f35b1c28961da5d5216fe50548f4066f69af3b7666a3b2e06eac646735e963e5c8f8138a2fb95af15b13b23ff00c6986eccc0efaa8ee6fb4"),
-			MustHexID("d2139281b289ad0e4d7b4243c4364f5c51aac8b60f4806135de06b12b5b369c9e43a6eb494eab860d115c15c6fbb8c5a1b0e382972e0e460af395b8385363de7"),
-			MustHexID("4a693df4b8fc5bdc7cec342c3ed2e228d7c5b4ab7321ddaa6cccbeb45b05a9f1d95766b4002e6d4791c2deacb8a667aadea6a700da28a3eea810a30395701bbc"),
-			MustHexID("ab41611195ec3c62bb8cd762ee19fb182d194fd141f4a66780efbef4b07ce916246c022b841237a3a6b512a93431157edd221e854ed2a259b72e9c5351f44d0c"),
-			MustHexID("68e8e26099030d10c3c703ae7045c0a48061fb88058d853b3e67880014c449d4311014da99d617d3150a20f1a3da5e34bf0f14f1c51fe4dd9d58afd222823176"),
-			MustHexID("3fbcacf546fb129cd70fc48de3b593ba99d3c473798bc309292aca280320e0eacc04442c914cad5c4cf6950345ba79b0d51302df88285d4e83ee3fe41339eee7"),
-			MustHexID("1d4a623659f7c8f80b6c3939596afdf42e78f892f682c768ad36eb7bfba402dbf97aea3a268f3badd8fe7636be216edf3d67ee1e08789ebbc7be625056bd7109"),
-			MustHexID("a283c474ab09da02bbc96b16317241d0627646fcc427d1fe790b76a7bf1989ced90f92101a973047ae9940c92720dffbac8eff21df8cae468a50f72f9e159417"),
-			MustHexID("dbf7e5ad7f87c3dfecae65d87c3039e14ed0bdc56caf00ce81931073e2e16719d746295512ff7937a15c3b03603e7c41a4f9df94fcd37bb200dd8f332767e9cb"),
-			MustHexID("caaa070a26692f64fc77f30d7b5ae980d419b4393a0f442b1c821ef58c0862898b0d22f74a4f8c5d83069493e3ec0b92f17dc1fe6e4cd437c1ec25039e7ce839"),
-			MustHexID("874cc8d1213beb65c4e0e1de38ef5d8165235893ac74ab5ea937c885eaab25c8d79dad0456e9fd3e9450626cac7e107b004478fb59842f067857f39a47cee695"),
-			MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
-			MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
-		},
-		250: []NodeID{
-			MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
-			MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
-			MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
-			MustHexID("1e1eac1c9add703eb252eb991594f8f5a173255d526a855fab24ae57dc277e055bc3c7a7ae0b45d437c4f47a72d97eb7b126f2ba344ba6c0e14b2c6f27d4b1e6"),
-			MustHexID("ae28953f63d4bc4e706712a59319c111f5ff8f312584f65d7436b4cd3d14b217b958f8486bad666b4481fe879019fb1f767cf15b3e3e2711efc33b56d460448a"),
-			MustHexID("934bb1edf9c7a318b82306aca67feb3d6b434421fa275d694f0b4927afd8b1d3935b727fd4ff6e3d012e0c82f1824385174e8c6450ade59c2a43281a4b3446b6"),
-			MustHexID("9eef3f28f70ce19637519a0916555bf76d26de31312ac656cf9d3e379899ea44e4dd7ffcce923b4f3563f8a00489a34bd6936db0cbb4c959d32c49f017e07d05"),
-			MustHexID("82200872e8f871c48f1fad13daec6478298099b591bb3dbc4ef6890aa28ebee5860d07d70be62f4c0af85085a90ae8179ee8f937cf37915c67ea73e704b03ee7"),
-			MustHexID("6c75a5834a08476b7fc37ff3dc2011dc3ea3b36524bad7a6d319b18878fad813c0ba76d1f4555cacd3890c865438c21f0e0aed1f80e0a157e642124c69f43a11"),
-			MustHexID("995b873742206cb02b736e73a88580c2aacb0bd4a3c97a647b647bcab3f5e03c0e0736520a8b3600da09edf4248991fb01091ec7ff3ec7cdc8a1beae011e7aae"),
-			MustHexID("c773a056594b5cdef2e850d30891ff0e927c3b1b9c35cd8e8d53a1017001e237468e1ece3ae33d612ca3e6abb0a9169aa352e9dcda358e5af2ad982b577447db"),
-			MustHexID("2b46a5f6923f475c6be99ec6d134437a6d11f6bb4b4ac6bcd94572fa1092639d1c08aeefcb51f0912f0a060f71d4f38ee4da70ecc16010b05dd4a674aab14c3a"),
-			MustHexID("af6ab501366debbaa0d22e20e9688f32ef6b3b644440580fd78de4fe0e99e2a16eb5636bbae0d1c259df8ddda77b35b9a35cbc36137473e9c68fbc9d203ba842"),
-			MustHexID("c9f6f2dd1a941926f03f770695bda289859e85fabaf94baaae20b93e5015dc014ba41150176a36a1884adb52f405194693e63b0c464a6891cc9cc1c80d450326"),
-			MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
-			MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
-		},
-		251: []NodeID{
-			MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
-			MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
-			MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
-			MustHexID("42c7483781727051a0b3660f14faf39e0d33de5e643702ae933837d036508ab856ce7eec8ec89c4929a4901256e5233a3d847d5d4893f91bcf21835a9a880fee"),
-			MustHexID("873bae27bf1dc854408fba94046a53ab0c965cebe1e4e12290806fc62b88deb1f4a47f9e18f78fc0e7913a0c6e42ac4d0fc3a20cea6bc65f0c8a0ca90b67521e"),
-			MustHexID("a7e3a370bbd761d413f8d209e85886f68bf73d5c3089b2dc6fa42aab1ecb5162635497eed95dee2417f3c9c74a3e76319625c48ead2e963c7de877cd4551f347"),
-			MustHexID("528597534776a40df2addaaea15b6ff832ce36b9748a265768368f657e76d58569d9f30dbb91e91cf0ae7efe8f402f17aa0ae15f5c55051ba03ba830287f4c42"),
-			MustHexID("461d8bd4f13c3c09031fdb84f104ed737a52f630261463ce0bdb5704259bab4b737dda688285b8444dbecaecad7f50f835190b38684ced5e90c54219e5adf1bc"),
-			MustHexID("6ec50c0be3fd232737090fc0111caaf0bb6b18f72be453428087a11a97fd6b52db0344acbf789a689bd4f5f50f79017ea784f8fd6fe723ad6ae675b9e3b13e21"),
-			MustHexID("12fc5e2f77a83fdcc727b79d8ae7fe6a516881138d3011847ee136b400fed7cfba1f53fd7a9730253c7aa4f39abeacd04f138417ba7fcb0f36cccc3514e0dab6"),
-			MustHexID("4fdbe75914ccd0bce02101606a1ccf3657ec963e3b3c20239d5fec87673fe446d649b4f15f1fe1a40e6cfbd446dda2d31d40bb602b1093b8fcd5f139ba0eb46a"),
-			MustHexID("3753668a0f6281e425ea69b52cb2d17ab97afbe6eb84cf5d25425bc5e53009388857640668fadd7c110721e6047c9697803bd8a6487b43bb343bfa32ebf24039"),
-			MustHexID("2e81b16346637dec4410fd88e527346145b9c0a849dbf2628049ac7dae016c8f4305649d5659ec77f1e8a0fac0db457b6080547226f06283598e3740ad94849a"),
-			MustHexID("802c3cc27f91c89213223d758f8d2ecd41135b357b6d698f24d811cdf113033a81c38e0bdff574a5c005b00a8c193dc2531f8c1fa05fa60acf0ab6f2858af09f"),
-			MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
-			MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
-		},
-		252: []NodeID{
-			MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
-			MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
-			MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
-			MustHexID("0ddc736077da9a12ba410dc5ea63cbcbe7659dd08596485b2bff3435221f82c10d263efd9af938e128464be64a178b7cd22e19f400d5802f4c9df54bf89f2619"),
-			MustHexID("784aa34d833c6ce63fcc1279630113c3272e82c4ae8c126c5a52a88ac461b6baeed4244e607b05dc14e5b2f41c70a273c3804dea237f14f7a1e546f6d1309d14"),
-			MustHexID("f253a2c354ee0e27cfcae786d726753d4ad24be6516b279a936195a487de4a59dbc296accf20463749ff55293263ed8c1b6365eecb248d44e75e9741c0d18205"),
-			MustHexID("a1910b80357b3ad9b4593e0628922939614dc9056a5fbf477279c8b2c1d0b4b31d89a0c09d0d41f795271d14d3360ef08a3f821e65e7e1f56c07a36afe49c7c5"),
-			MustHexID("f1168552c2efe541160f0909b0b4a9d6aeedcf595cdf0e9b165c97e3e197471a1ee6320e93389edfba28af6eaf10de98597ad56e7ab1b504ed762451996c3b98"),
-			MustHexID("b0c8e5d2c8634a7930e1a6fd082e448c6cf9d2d8b7293558b59238815a4df926c286bf297d2049f14e8296a6eb3256af614ec1812c4f2bbe807673b58bf14c8c"),
-			MustHexID("0fb346076396a38badc342df3679b55bd7f40a609ab103411fe45082c01f12ea016729e95914b2b5540e987ff5c9b133e85862648e7f36abdfd23100d248d234"),
-			MustHexID("f736e0cc83417feaa280d9483f5d4d72d1b036cd0c6d9cbdeb8ac35ceb2604780de46dddaa32a378474e1d5ccdf79b373331c30c7911ade2ae32f98832e5de1f"),
-			MustHexID("8b02991457602f42b38b342d3f2259ae4100c354b3843885f7e4e07bd644f64dab94bb7f38a3915f8b7f11d8e3f81c28e07a0078cf79d7397e38a7b7e0c857e2"),
-			MustHexID("9221d9f04a8a184993d12baa91116692bb685f887671302999d69300ad103eb2d2c75a09d8979404c6dd28f12362f58a1a43619c493d9108fd47588a23ce5824"),
-			MustHexID("652797801744dada833fff207d67484742eea6835d695925f3e618d71b68ec3c65bdd85b4302b2cdcb835ad3f94fd00d8da07e570b41bc0d2bcf69a8de1b3284"),
-			MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
-			MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
-		},
-		253: []NodeID{
-			MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
-			MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
-			MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
-			MustHexID("d97bf55f88c83fae36232661af115d66ca600fc4bd6d1fb35ff9bb4dad674c02cf8c8d05f317525b5522250db58bb1ecafb7157392bf5aa61b178c61f098d995"),
-			MustHexID("7045d678f1f9eb7a4613764d17bd5698796494d0bf977b16f2dbc272b8a0f7858a60805c022fc3d1fe4f31c37e63cdaca0416c0d053ef48a815f8b19121605e0"),
-			MustHexID("14e1f21418d445748de2a95cd9a8c3b15b506f86a0acabd8af44bb968ce39885b19c8822af61b3dd58a34d1f265baec30e3ae56149dc7d2aa4a538f7319f69c8"),
-			MustHexID("b9453d78281b66a4eac95a1546017111eaaa5f92a65d0de10b1122940e92b319728a24edf4dec6acc412321b1c95266d39c7b3a5d265c629c3e49a65fb022c09"),
-			MustHexID("e8a49248419e3824a00d86af422f22f7366e2d4922b304b7169937616a01d9d6fa5abf5cc01061a352dc866f48e1fa2240dbb453d872b1d7be62bdfc1d5e248c"),
-			MustHexID("bebcff24b52362f30e0589ee573ce2d86f073d58d18e6852a592fa86ceb1a6c9b96d7fb9ec7ed1ed98a51b6743039e780279f6bb49d0a04327ac7a182d9a56f6"),
-			MustHexID("d0835e5a4291db249b8d2fca9f503049988180c7d247bedaa2cf3a1bad0a76709360a85d4f9a1423b2cbc82bb4d94b47c0cde20afc430224834c49fe312a9ae3"),
-			MustHexID("6b087fe2a2da5e4f0b0f4777598a4a7fb66bf77dbd5bfc44e8a7eaa432ab585a6e226891f56a7d4f5ed11a7c57b90f1661bba1059590ca4267a35801c2802913"),
-			MustHexID("d901e5bde52d1a0f4ddf010a686a53974cdae4ebe5c6551b3c37d6b6d635d38d5b0e5f80bc0186a2c7809dbf3a42870dd09643e68d32db896c6da8ba734579e7"),
-			MustHexID("96419fb80efae4b674402bb969ebaab86c1274f29a83a311e24516d36cdf148fe21754d46c97688cdd7468f24c08b13e4727c29263393638a3b37b99ff60ebca"),
-			MustHexID("7b9c1889ae916a5d5abcdfb0aaedcc9c6f9eb1c1a4f68d0c2d034fe79ac610ce917c3abc670744150fa891bfcd8ab14fed6983fca964de920aa393fa7b326748"),
-			MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
-			MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
-		},
-		254: []NodeID{
-			MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
-			MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
-			MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
-			MustHexID("27f4a16cc085e72d86e25c98bd2eca173eaaee7565c78ec5a52e9e12b2211f35de81b5b45e9195de2ebfe29106742c59112b951a04eb7ae48822911fc1f9389e"),
-			MustHexID("55db5ee7d98e7f0b1c3b9d5be6f2bc619a1b86c3cdd513160ad4dcf267037a5fffad527ac15d50aeb32c59c13d1d4c1e567ebbf4de0d25236130c8361f9aac63"),
-			MustHexID("883df308b0130fc928a8559fe50667a0fff80493bc09685d18213b2db241a3ad11310ed86b0ef662b3ce21fc3d9aa7f3fc24b8d9afe17c7407e9afd3345ae548"),
-			MustHexID("c7af968cc9bc8200c3ee1a387405f7563be1dce6710a3439f42ea40657d0eae9d2b3c16c42d779605351fcdece4da637b9804e60ca08cfb89aec32c197beffa6"),
-			MustHexID("3e66f2b788e3ff1d04106b80597915cd7afa06c405a7ae026556b6e583dca8e05cfbab5039bb9a1b5d06083ffe8de5780b1775550e7218f5e98624bf7af9a0a8"),
-			MustHexID("4fc7f53764de3337fdaec0a711d35d3a923e72fa65025444d12230b3552ed43d9b2d1ad08ccb11f2d50c58809e6dd74dde910e195294fca3b47ae5a3967cc479"),
-			MustHexID("bafdfdcf6ccaa989436752fa97c77477b6baa7deb374b16c095492c529eb133e8e2f99e1977012b64767b9d34b2cf6d2048ed489bd822b5139b523f6a423167b"),
-			MustHexID("7f5d78008a4312fe059104ce80202c82b8915c2eb4411c6b812b16f7642e57c00f2c9425121f5cbac4257fe0b3e81ef5dea97ea2dbaa98f6a8b6fd4d1e5980bb"),
-			MustHexID("598c37fe78f922751a052f463aeb0cb0bc7f52b7c2a4cf2da72ec0931c7c32175d4165d0f8998f7320e87324ac3311c03f9382a5385c55f0407b7a66b2acd864"),
-			MustHexID("f758c4136e1c148777a7f3275a76e2db0b2b04066fd738554ec398c1c6cc9fb47e14a3b4c87bd47deaeab3ffd2110514c3855685a374794daff87b605b27ee2e"),
-			MustHexID("0307bb9e4fd865a49dcf1fe4333d1b944547db650ab580af0b33e53c4fef6c789531110fac801bbcbce21fc4d6f61b6d5b24abdf5b22e3030646d579f6dca9c2"),
-			MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
-			MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
-		},
-		255: []NodeID{
-			MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
-			MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
-			MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
-			MustHexID("c08397d5751b47bd3da044b908be0fb0e510d3149574dff7aeab33749b023bb171b5769990fe17469dbebc100bc150e798aeda426a2dcc766699a225fddd75c6"),
-			MustHexID("0222c1c194b749736e593f937fad67ee348ac57287a15c7e42877aa38a9b87732a408bca370f812efd0eedbff13e6d5b854bf3ba1dec431a796ed47f32552b09"),
-			MustHexID("03d859cd46ef02d9bfad5268461a6955426845eef4126de6be0fa4e8d7e0727ba2385b78f1a883a8239e95ebb814f2af8379632c7d5b100688eebc5841209582"),
-			MustHexID("64d5004b7e043c39ff0bd10cb20094c287721d5251715884c280a612b494b3e9e1c64ba6f67614994c7d969a0d0c0295d107d53fc225d47c44c4b82852d6f960"),
-			MustHexID("b0a5eefb2dab6f786670f35bf9641eefe6dd87fd3f1362bcab4aaa792903500ab23d88fae68411372e0813b057535a601d46e454323745a948017f6063a47b1f"),
-			MustHexID("0cc6df0a3433d448b5684d2a3ffa9d1a825388177a18f44ad0008c7bd7702f1ec0fc38b83506f7de689c3b6ecb552599927e29699eed6bb867ff08f80068b287"),
-			MustHexID("50772f7b8c03a4e153355fbbf79c8a80cf32af656ff0c7873c99911099d04a0dae0674706c357e0145ad017a0ade65e6052cb1b0d574fcd6f67da3eee0ace66b"),
-			MustHexID("1ae37829c9ef41f8b508b82259ebac76b1ed900d7a45c08b7970f25d2d48ddd1829e2f11423a18749940b6dab8598c6e416cef0efd47e46e51f29a0bc65b37cd"),
-			MustHexID("ba973cab31c2af091fc1644a93527d62b2394999e2b6ccbf158dd5ab9796a43d408786f1803ef4e29debfeb62fce2b6caa5ab2b24d1549c822a11c40c2856665"),
-			MustHexID("bc413ad270dd6ea25bddba78f3298b03b8ba6f8608ac03d06007d4116fa78ef5a0cfe8c80155089382fc7a193243ee5500082660cb5d7793f60f2d7d18650964"),
-			MustHexID("5a6a9ef07634d9eec3baa87c997b529b92652afa11473dfee41ef7037d5c06e0ddb9fe842364462d79dd31cff8a59a1b8d5bc2b810dea1d4cbbd3beb80ecec83"),
-			MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
-			MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
-		},
-		256: []NodeID{
-			MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
-			MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
-			MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),
-			MustHexID("7feaee0d818c03eb30e4e0bf03ade0f3c21ca38e938a761aa1781cf70bda8cc5cd631a6cc53dd44f1d4a6d3e2dae6513c6c66ee50cb2f0e9ad6f7e319b309fd9"),
-			MustHexID("4ca3b657b139311db8d583c25dd5963005e46689e1317620496cc64129c7f3e52870820e0ec7941d28809311df6db8a2867bbd4f235b4248af24d7a9c22d1232"),
-			MustHexID("1181defb1d16851d42dd951d84424d6bd1479137f587fa184d5a8152be6b6b16ed08bcdb2c2ed8539bcde98c80c432875f9f724737c316a2bd385a39d3cab1d8"),
-			MustHexID("d9dd818769fa0c3ec9f553c759b92476f082817252a04a47dc1777740b1731d280058c66f982812f173a294acf4944a85ba08346e2de153ba3ba41ce8a62cb64"),
-			MustHexID("bd7c4f8a9e770aa915c771b15e107ca123d838762da0d3ffc53aa6b53e9cd076cffc534ec4d2e4c334c683f1f5ea72e0e123f6c261915ed5b58ac1b59f003d88"),
-			MustHexID("3dd5739c73649d510456a70e9d6b46a855864a4a3f744e088fd8c8da11b18e4c9b5f2d7da50b1c147b2bae5ca9609ae01f7a3cdea9dce34f80a91d29cd82f918"),
-			MustHexID("f0d7df1efc439b4bcc0b762118c1cfa99b2a6143a9f4b10e3c9465125f4c9fca4ab88a2504169bbcad65492cf2f50da9dd5d077c39574a944f94d8246529066b"),
-			MustHexID("dd598b9ba441448e5fb1a6ec6c5f5aa9605bad6e223297c729b1705d11d05f6bfd3d41988b694681ae69bb03b9a08bff4beab5596503d12a39bffb5cd6e94c7c"),
-			MustHexID("3fce284ac97e567aebae681b15b7a2b6df9d873945536335883e4bbc26460c064370537f323fd1ada828ea43154992d14ac0cec0940a2bd2a3f42ec156d60c83"),
-			MustHexID("7c8dfa8c1311cb14fb29a8ac11bca23ecc115e56d9fcf7b7ac1db9066aa4eb39f8b1dabf46e192a65be95ebfb4e839b5ab4533fef414921825e996b210dd53bd"),
-			MustHexID("cafa6934f82120456620573d7f801390ed5e16ed619613a37e409e44ab355ef755e83565a913b48a9466db786f8d4fbd590bfec474c2524d4a2608d4eafd6abd"),
-			MustHexID("9d16600d0dd310d77045769fed2cb427f32db88cd57d86e49390c2ba8a9698cfa856f775be2013237226e7bf47b248871cf865d23015937d1edeb20db5e3e760"),
-			MustHexID("17be6b6ba54199b1d80eff866d348ea11d8a4b341d63ad9a6681d3ef8a43853ac564d153eb2a8737f0afc9ab320f6f95c55aa11aaa13bbb1ff422fd16bdf8188"),
-		},
-	},
-}
-
-type preminedTestnet struct {
-	target    NodeID
-	targetSha common.Hash // sha3(target)
-	dists     [hashBits + 1][]NodeID
-}
-
-func (tn *preminedTestnet) findnode(toid NodeID, toaddr *net.UDPAddr, target NodeID) ([]*Node, error) {
-	// current log distance is encoded in port number
-	// fmt.Println("findnode query at dist", toaddr.Port)
-	if toaddr.Port == 0 {
-		panic("query to node at distance 0")
-	}
-	next := uint16(toaddr.Port) - 1
-	var result []*Node
-	for i, id := range tn.dists[toaddr.Port] {
-		result = append(result, NewNode(id, net.ParseIP("127.0.0.1"), next, uint16(i)))
-	}
-	return result, nil
-}
-
-func (*preminedTestnet) close()                                      {}
-func (*preminedTestnet) waitping(from NodeID) error                  { return nil }
-func (*preminedTestnet) ping(toid NodeID, toaddr *net.UDPAddr) error { return nil }
-
-// mine generates a testnet struct literal with nodes at
-// various distances to the given target.
-func (n *preminedTestnet) mine(target NodeID) {
-	n.target = target
-	n.targetSha = crypto.Keccak256Hash(n.target[:])
-	found := 0
-	for found < bucketSize*10 {
-		k := newkey()
-		id := PubkeyID(&k.PublicKey)
-		sha := crypto.Keccak256Hash(id[:])
-		ld := logdist(n.targetSha, sha)
-		if len(n.dists[ld]) < bucketSize {
-			n.dists[ld] = append(n.dists[ld], id)
-			fmt.Println("found ID with ld", ld)
-			found++
-		}
-	}
-	fmt.Println("&preminedTestnet{")
-	fmt.Printf("	target: %#v,\n", n.target)
-	fmt.Printf("	targetSha: %#v,\n", n.targetSha)
-	fmt.Printf("	dists: [%d][]NodeID{\n", len(n.dists))
-	for ld, ns := range n.dists {
-		if len(ns) == 0 {
-			continue
-		}
-		fmt.Printf("		%d: []NodeID{\n", ld)
-		for _, n := range ns {
-			fmt.Printf("			MustHexID(\"%x\"),\n", n[:])
-		}
-		fmt.Println("		},")
-	}
-	fmt.Println("	},")
-	fmt.Println("}")
-}
-
 func hasDuplicates(slice []*Node) bool {
 	seen := make(map[NodeID]bool)
 	for i, e := range slice {

p2p/discover/udp.go

@@ -18,7 +18,6 @@ package discover
 
 import (
 	"bytes"
-	"container/list"
 	"crypto/ecdsa"
 	"errors"
 	"fmt"
@@ -57,14 +56,6 @@ const (
 	driftThreshold      = 10 * time.Second // Allowed clock drift before warning user
 )
 
-// RPC packet types
-const (
-	pingPacket = iota + 1 // zero is 'reserved'
-	pongPacket
-	findnodePacket
-	neighborsPacket
-)
-
 // RPC request structures
 type (
 	ping struct {
@@ -118,6 +109,31 @@ type (
 	}
 )
 
+const (
+	macSize  = 256 / 8
+	sigSize  = 520 / 8
+	headSize = macSize + sigSize // space of packet frame data
+)
+
+// Neighbors replies are sent across multiple packets to
+// stay below the 1280 byte limit. We compute the maximum number
+// of entries by stuffing a packet until it grows too large.
+var maxNeighbors = func() int {
+	p := neighbors{Expiration: ^uint64(0)}
+	maxSizeNode := rpcNode{IP: make(net.IP, 16), UDP: ^uint16(0), TCP: ^uint16(0)}
+	for n := 0; ; n++ {
+		p.Nodes = append(p.Nodes, maxSizeNode)
+		size, _, err := rlp.EncodeToReader(p)
+		if err != nil {
+			// If this ever happens, it will be caught by the unit tests.
+			panic("cannot encode: " + err.Error())
+		}
+		if headSize+size+1 >= 1280 {
+			return n
+		}
+	}
+}()
+
 func makeEndpoint(addr *net.UDPAddr, tcpPort uint16) rpcEndpoint {
 	ip := addr.IP.To4()
 	if ip == nil {
@@ -126,6 +142,10 @@ func makeEndpoint(addr *net.UDPAddr, tcpPort uint16) rpcEndpoint {
 	return rpcEndpoint{IP: ip, UDP: uint16(addr.Port), TCP: tcpPort}
 }
 
+func (e1 rpcEndpoint) equal(e2 rpcEndpoint) bool {
+	return e1.UDP == e2.UDP && e1.TCP == e2.TCP && bytes.Equal(e1.IP, e2.IP)
+}
+
 func nodeFromRPC(rn rpcNode) (*Node, error) {
 	// TODO: don't accept localhost, LAN addresses from internet hosts
 	n := NewNode(rn.ID, rn.IP, rn.UDP, rn.TCP)
@@ -137,8 +157,12 @@ func nodeToRPC(n *Node) rpcNode {
 	return rpcNode{ID: n.ID, IP: n.IP, UDP: n.UDP, TCP: n.TCP}
 }
 
-type packet interface {
+type ingressPacket struct {
-	handle(t *udp, from *net.UDPAddr, fromID NodeID, mac []byte) error
+	remoteID   NodeID
+	remoteAddr *net.UDPAddr
+	ev         nodeEvent
+	hash       []byte
+	data       interface{} // one of the RPC structs
 }
 
 type conn interface {
@@ -153,55 +177,26 @@ type udp struct {
 	conn        conn
 	priv        *ecdsa.PrivateKey
 	ourEndpoint rpcEndpoint
-
-	addpending chan *pending
-	gotreply   chan reply
-
-	closing chan struct{}
 	nat         nat.Interface
-
+	net         *Network
-	*Table
-}
-
-// pending represents a pending reply.
-//
-// some implementations of the protocol wish to send more than one
-// reply packet to findnode. in general, any neighbors packet cannot
-// be matched up with a specific findnode packet.
-//
-// our implementation handles this by storing a callback function for
-// each pending reply. incoming packets from a node are dispatched
-// to all the callback functions for that node.
-type pending struct {
-	// these fields must match in the reply.
-	from  NodeID
-	ptype byte
-
-	// time when the request must complete
-	deadline time.Time
-
-	// callback is called when a matching reply arrives. if it returns
-	// true, the callback is removed from the pending reply queue.
-	// if it returns false, the reply is considered incomplete and
-	// the callback will be invoked again for the next matching reply.
-	callback func(resp interface{}) (done bool)
-
-	// errc receives nil when the callback indicates completion or an
-	// error if no further reply is received within the timeout.
-	errc chan<- error
-}
-
-type reply struct {
-	from  NodeID
-	ptype byte
-	data  interface{}
-	// loop indicates whether there was
-	// a matching request by sending on this channel.
-	matched chan<- bool
 }
 
 // ListenUDP returns a new table that listens for UDP packets on laddr.
-func ListenUDP(priv *ecdsa.PrivateKey, laddr string, natm nat.Interface, nodeDBPath string) (*Table, error) {
+func ListenUDP(priv *ecdsa.PrivateKey, laddr string, natm nat.Interface, nodeDBPath string) (*Network, error) {
+	transport, err := listenUDP(priv, laddr)
+	if err != nil {
+		return nil, err
+	}
+	net, err := newNetwork(transport, priv.PublicKey, natm, nodeDBPath)
+	if err != nil {
+		return nil, err
+	}
+	transport.net = net
+	go transport.readLoop()
+	return net, nil
+}
+
+func listenUDP(priv *ecdsa.PrivateKey, laddr string) (*udp, error) {
 	addr, err := net.ResolveUDPAddr("udp", laddr)
 	if err != nil {
 		return nil, err
@@ -210,283 +205,94 @@ func ListenUDP(priv *ecdsa.PrivateKey, laddr string, natm nat.Interface, nodeDBP
 	if err != nil {
 		return nil, err
 	}
-	tab, _, err := newUDP(priv, conn, natm, nodeDBPath)
+	return &udp{conn: conn, priv: priv}, nil
-	if err != nil {
-		return nil, err
-	}
-	glog.V(logger.Info).Infoln("Listening,", tab.self)
-	return tab, nil
 }
 
-func newUDP(priv *ecdsa.PrivateKey, c conn, natm nat.Interface, nodeDBPath string) (*Table, *udp, error) {
+func (t *udp) localAddr() *net.UDPAddr {
-	udp := &udp{
+	return t.conn.LocalAddr().(*net.UDPAddr)
-		conn:       c,
-		priv:       priv,
-		closing:    make(chan struct{}),
-		gotreply:   make(chan reply),
-		addpending: make(chan *pending),
-	}
-	realaddr := c.LocalAddr().(*net.UDPAddr)
-	if natm != nil {
-		if !realaddr.IP.IsLoopback() {
-			go nat.Map(natm, udp.closing, "udp", realaddr.Port, realaddr.Port, "ethereum discovery")
-		}
-		// TODO: react to external IP changes over time.
-		if ext, err := natm.ExternalIP(); err == nil {
-			realaddr = &net.UDPAddr{IP: ext, Port: realaddr.Port}
-		}
-	}
-	// TODO: separate TCP port
-	udp.ourEndpoint = makeEndpoint(realaddr, uint16(realaddr.Port))
-	tab, err := newTable(udp, PubkeyID(&priv.PublicKey), realaddr, nodeDBPath)
-	if err != nil {
-		return nil, nil, err
-	}
-	udp.Table = tab
-
-	go udp.loop()
-	go udp.readLoop()
-	return udp.Table, udp, nil
 }
 
-func (t *udp) close() {
+func (t *udp) Close() {
-	close(t.closing)
 	t.conn.Close()
-	// TODO: wait for the loops to end.
 }
 
-// ping sends a ping message to the given node and waits for a reply.
+func (t *udp) sendPing(remote *Node, toaddr *net.UDPAddr) (hash []byte) {
-func (t *udp) ping(toid NodeID, toaddr *net.UDPAddr) error {
+	hash, _ = t.send(remote.ID, toaddr, byte(pingPacket), ping{
-	// TODO: maybe check for ReplyTo field in callback to measure RTT
-	errc := t.pending(toid, pongPacket, func(interface{}) bool { return true })
-	t.send(toaddr, pingPacket, ping{
 		Version:    Version,
 		From:       t.ourEndpoint,
 		To:         makeEndpoint(toaddr, 0), // TODO: maybe use known TCP port from DB
 		Expiration: uint64(time.Now().Add(expiration).Unix()),
 	})
-	return <-errc
+	return hash
 }
 
-func (t *udp) waitping(from NodeID) error {
+func (t *udp) sendPong(remote *Node, pingHash []byte) {
-	return <-t.pending(from, pingPacket, func(interface{}) bool { return true })
+	t.send(remote.ID, remote.addr(), byte(pongPacket), pong{
-}
+		To:         makeEndpoint(remote.addr(), 0), // TODO: maybe use known TCP port from DB
-
+		ReplyTok:   pingHash,
-// findnode sends a findnode request to the given node and waits until
+		Expiration: uint64(time.Now().Add(expiration).Unix()),
-// the node has sent up to k neighbors.
-func (t *udp) findnode(toid NodeID, toaddr *net.UDPAddr, target NodeID) ([]*Node, error) {
-	nodes := make([]*Node, 0, bucketSize)
-	nreceived := 0
-	errc := t.pending(toid, neighborsPacket, func(r interface{}) bool {
-		reply := r.(*neighbors)
-		for _, rn := range reply.Nodes {
-			nreceived++
-			if n, err := nodeFromRPC(rn); err == nil {
-				nodes = append(nodes, n)
-			}
-		}
-		return nreceived >= bucketSize
 	})
-	t.send(toaddr, findnodePacket, findnode{
+}
+
+func (t *udp) sendFindnode(remote *Node, target NodeID) {
+	t.send(remote.ID, remote.addr(), byte(findnodePacket), findnode{
 		Target:     target,
 		Expiration: uint64(time.Now().Add(expiration).Unix()),
 	})
-	err := <-errc
-	return nodes, err
 }
 
-// pending adds a reply callback to the pending reply queue.
+func (t *udp) sendNeighbours(remote *Node, results []*Node) {
-// see the documentation of type pending for a detailed explanation.
+	// Send neighbors in chunks with at most maxNeighbors per packet
-func (t *udp) pending(id NodeID, ptype byte, callback func(interface{}) bool) <-chan error {
+	// to stay below the 1280 byte limit.
-	ch := make(chan error, 1)
+	p := neighbors{Expiration: uint64(time.Now().Add(expiration).Unix())}
-	p := &pending{from: id, ptype: ptype, callback: callback, errc: ch}
+	for i, result := range results {
-	select {
+		p.Nodes = append(p.Nodes, nodeToRPC(result))
-	case t.addpending <- p:
+		if len(p.Nodes) == maxNeighbors || i == len(results)-1 {
-		// loop will handle it
+			t.send(remote.ID, remote.addr(), byte(neighborsPacket), p)
-	case <-t.closing:
+			p.Nodes = p.Nodes[:0]
-		ch <- errClosed
-	}
-	return ch
-}
-
-func (t *udp) handleReply(from NodeID, ptype byte, req packet) bool {
-	matched := make(chan bool, 1)
-	select {
-	case t.gotreply <- reply{from, ptype, req, matched}:
-		// loop will handle it
-		return <-matched
-	case <-t.closing:
-		return false
-	}
-}
-
-// loop runs in its own goroutine. it keeps track of
-// the refresh timer and the pending reply queue.
-func (t *udp) loop() {
-	var (
-		plist        = list.New()
-		timeout      = time.NewTimer(0)
-		nextTimeout  *pending // head of plist when timeout was last reset
-		contTimeouts = 0      // number of continuous timeouts to do NTP checks
-		ntpWarnTime  = time.Unix(0, 0)
-	)
-	<-timeout.C // ignore first timeout
-	defer timeout.Stop()
-
-	resetTimeout := func() {
-		if plist.Front() == nil || nextTimeout == plist.Front().Value {
-			return
-		}
-		// Start the timer so it fires when the next pending reply has expired.
-		now := time.Now()
-		for el := plist.Front(); el != nil; el = el.Next() {
-			nextTimeout = el.Value.(*pending)
-			if dist := nextTimeout.deadline.Sub(now); dist < 2*respTimeout {
-				timeout.Reset(dist)
-				return
-			}
-			// Remove pending replies whose deadline is too far in the
-			// future. These can occur if the system clock jumped
-			// backwards after the deadline was assigned.
-			nextTimeout.errc <- errClockWarp
-			plist.Remove(el)
-		}
-		nextTimeout = nil
-		timeout.Stop()
-	}
-
-	for {
-		resetTimeout()
-
-		select {
-		case <-t.closing:
-			for el := plist.Front(); el != nil; el = el.Next() {
-				el.Value.(*pending).errc <- errClosed
-			}
-			return
-
-		case p := <-t.addpending:
-			p.deadline = time.Now().Add(respTimeout)
-			plist.PushBack(p)
-
-		case r := <-t.gotreply:
-			var matched bool
-			for el := plist.Front(); el != nil; el = el.Next() {
-				p := el.Value.(*pending)
-				if p.from == r.from && p.ptype == r.ptype {
-					matched = true
-					// Remove the matcher if its callback indicates
-					// that all replies have been received. This is
-					// required for packet types that expect multiple
-					// reply packets.
-					if p.callback(r.data) {
-						p.errc <- nil
-						plist.Remove(el)
-					}
-					// Reset the continuous timeout counter (time drift detection)
-					contTimeouts = 0
-				}
-			}
-			r.matched <- matched
-
-		case now := <-timeout.C:
-			nextTimeout = nil
-
-			// Notify and remove callbacks whose deadline is in the past.
-			for el := plist.Front(); el != nil; el = el.Next() {
-				p := el.Value.(*pending)
-				if now.After(p.deadline) || now.Equal(p.deadline) {
-					p.errc <- errTimeout
-					plist.Remove(el)
-					contTimeouts++
-				}
-			}
-			// If we've accumulated too many timeouts, do an NTP time sync check
-			if contTimeouts > ntpFailureThreshold {
-				if time.Since(ntpWarnTime) >= ntpWarningCooldown {
-					ntpWarnTime = time.Now()
-					go checkClockDrift()
-				}
-				contTimeouts = 0
-			}
 		}
 	}
 }
 
-const (
+func (t *udp) send(toid NodeID, toaddr *net.UDPAddr, ptype byte, req interface{}) (hash []byte, err error) {
-	macSize  = 256 / 8
+	packet, hash, err := encodePacket(t.priv, ptype, req)
-	sigSize  = 520 / 8
-	headSize = macSize + sigSize // space of packet frame data
-)
-
-var (
-	headSpace = make([]byte, headSize)
-
-	// Neighbors replies are sent across multiple packets to
-	// stay below the 1280 byte limit. We compute the maximum number
-	// of entries by stuffing a packet until it grows too large.
-	maxNeighbors int
-)
-
-func init() {
-	p := neighbors{Expiration: ^uint64(0)}
-	maxSizeNode := rpcNode{IP: make(net.IP, 16), UDP: ^uint16(0), TCP: ^uint16(0)}
-	for n := 0; ; n++ {
-		p.Nodes = append(p.Nodes, maxSizeNode)
-		size, _, err := rlp.EncodeToReader(p)
 	if err != nil {
-			// If this ever happens, it will be caught by the unit tests.
+		return hash, err
-			panic("cannot encode: " + err.Error())
 	}
-		if headSize+size+1 >= 1280 {
+	glog.V(logger.Detail).Infof(">>> %v to %x@%v\n", nodeEvent(ptype), toid[:8], toaddr)
-			maxNeighbors = n
-			break
-		}
-	}
-}
-
-func (t *udp) send(toaddr *net.UDPAddr, ptype byte, req interface{}) error {
-	packet, err := encodePacket(t.priv, ptype, req)
-	if err != nil {
-		return err
-	}
-	glog.V(logger.Detail).Infof(">>> %v %T\n", toaddr, req)
 	if _, err = t.conn.WriteToUDP(packet, toaddr); err != nil {
 		glog.V(logger.Detail).Infoln("UDP send failed:", err)
 	}
-	return err
+	return hash, err
 }
 
-func encodePacket(priv *ecdsa.PrivateKey, ptype byte, req interface{}) ([]byte, error) {
+// zeroed padding space for encodePacket.
+var headSpace = make([]byte, headSize)
+
+func encodePacket(priv *ecdsa.PrivateKey, ptype byte, req interface{}) (p, hash []byte, err error) {
 	b := new(bytes.Buffer)
 	b.Write(headSpace)
 	b.WriteByte(ptype)
 	if err := rlp.Encode(b, req); err != nil {
 		glog.V(logger.Error).Infoln("error encoding packet:", err)
-		return nil, err
+		return nil, nil, err
 	}
 	packet := b.Bytes()
 	sig, err := crypto.Sign(crypto.Keccak256(packet[headSize:]), priv)
 	if err != nil {
 		glog.V(logger.Error).Infoln("could not sign packet:", err)
-		return nil, err
+		return nil, nil, err
 	}
 	copy(packet[macSize:], sig)
 	// add the hash to the front. Note: this doesn't protect the
-	// packet in any way. Our public key will be part of this hash in
+	// packet in any way.
-	// The future.
+	hash = crypto.Keccak256(packet[macSize:])
-	copy(packet, crypto.Keccak256(packet[macSize:]))
+	copy(packet, hash)
-	return packet, nil
+	return packet, hash, nil
 }
 
-func isTemporaryError(err error) bool {
+// readLoop runs in its own goroutine. it injects ingress UDP packets
-	tempErr, ok := err.(interface {
+// into the network loop.
-		Temporary() bool
-	})
-	return ok && tempErr.Temporary() || isPacketTooBig(err)
-}
-
-// readLoop runs in its own goroutine. it handles incoming UDP packets.
 func (t *udp) readLoop() {
 	defer t.conn.Close()
 	// Discovery packets are defined to be no larger than 1280 bytes.
@@ -508,119 +314,51 @@ func (t *udp) readLoop() {
 	}
 }
 
+func isTemporaryError(err error) bool {
+	tempErr, ok := err.(interface {
+		Temporary() bool
+	})
+	return ok && tempErr.Temporary() || isPacketTooBig(err)
+}
+
 func (t *udp) handlePacket(from *net.UDPAddr, buf []byte) error {
-	packet, fromID, hash, err := decodePacket(buf)
+	pkt := ingressPacket{remoteAddr: from}
-	if err != nil {
+	if err := decodePacket(buf, &pkt); err != nil {
 		glog.V(logger.Debug).Infof("Bad packet from %v: %v\n", from, err)
 		return err
 	}
-	status := "ok"
+	t.net.reqReadPacket(pkt)
-	if err = packet.handle(t, from, fromID, hash); err != nil {
+	return nil
-		status = err.Error()
-	}
-	glog.V(logger.Detail).Infof("<<< %v %T: %s\n", from, packet, status)
-	return err
 }
 
-func decodePacket(buf []byte) (packet, NodeID, []byte, error) {
+func decodePacket(buf []byte, pkt *ingressPacket) error {
 	if len(buf) < headSize+1 {
-		return nil, NodeID{}, nil, errPacketTooSmall
+		return errPacketTooSmall
 	}
 	hash, sig, sigdata := buf[:macSize], buf[macSize:headSize], buf[headSize:]
 	shouldhash := crypto.Keccak256(buf[macSize:])
 	if !bytes.Equal(hash, shouldhash) {
-		return nil, NodeID{}, nil, errBadHash
+		return errBadHash
 	}
 	fromID, err := recoverNodeID(crypto.Keccak256(buf[headSize:]), sig)
 	if err != nil {
-		return nil, NodeID{}, hash, err
+		return err
 	}
-	var req packet
+	pkt.hash = hash
-	switch ptype := sigdata[0]; ptype {
+	pkt.remoteID = fromID
+	switch pkt.ev = nodeEvent(sigdata[0]); pkt.ev {
 	case pingPacket:
-		req = new(ping)
+		pkt.data = new(ping)
 	case pongPacket:
-		req = new(pong)
+		pkt.data = new(pong)
 	case findnodePacket:
-		req = new(findnode)
+		pkt.data = new(findnode)
 	case neighborsPacket:
-		req = new(neighbors)
+		pkt.data = new(neighbors)
 	default:
-		return nil, fromID, hash, fmt.Errorf("unknown type: %d", ptype)
+		return fmt.Errorf("unknown packet type: %d", sigdata[0])
 	}
 	s := rlp.NewStream(bytes.NewReader(sigdata[1:]), 0)
-	err = s.Decode(req)
+	err = s.Decode(pkt.data)
-	return req, fromID, hash, err
+	return err
-}
-
-func (req *ping) handle(t *udp, from *net.UDPAddr, fromID NodeID, mac []byte) error {
-	if expired(req.Expiration) {
-		return errExpired
-	}
-	t.send(from, pongPacket, pong{
-		To:         makeEndpoint(from, req.From.TCP),
-		ReplyTok:   mac,
-		Expiration: uint64(time.Now().Add(expiration).Unix()),
-	})
-	if !t.handleReply(fromID, pingPacket, req) {
-		// Note: we're ignoring the provided IP address right now
-		go t.bond(true, fromID, from, req.From.TCP)
-	}
-	return nil
-}
-
-func (req *pong) handle(t *udp, from *net.UDPAddr, fromID NodeID, mac []byte) error {
-	if expired(req.Expiration) {
-		return errExpired
-	}
-	if !t.handleReply(fromID, pongPacket, req) {
-		return errUnsolicitedReply
-	}
-	return nil
-}
-
-func (req *findnode) handle(t *udp, from *net.UDPAddr, fromID NodeID, mac []byte) error {
-	if expired(req.Expiration) {
-		return errExpired
-	}
-	if t.db.node(fromID) == nil {
-		// No bond exists, we don't process the packet. This prevents
-		// an attack vector where the discovery protocol could be used
-		// to amplify traffic in a DDOS attack. A malicious actor
-		// would send a findnode request with the IP address and UDP
-		// port of the target as the source address. The recipient of
-		// the findnode packet would then send a neighbors packet
-		// (which is a much bigger packet than findnode) to the victim.
-		return errUnknownNode
-	}
-	target := crypto.Keccak256Hash(req.Target[:])
-	t.mutex.Lock()
-	closest := t.closest(target, bucketSize).entries
-	t.mutex.Unlock()
-
-	p := neighbors{Expiration: uint64(time.Now().Add(expiration).Unix())}
-	// Send neighbors in chunks with at most maxNeighbors per packet
-	// to stay below the 1280 byte limit.
-	for i, n := range closest {
-		p.Nodes = append(p.Nodes, nodeToRPC(n))
-		if len(p.Nodes) == maxNeighbors || i == len(closest)-1 {
-			t.send(from, neighborsPacket, p)
-			p.Nodes = p.Nodes[:0]
-		}
-	}
-	return nil
-}
-
-func (req *neighbors) handle(t *udp, from *net.UDPAddr, fromID NodeID, mac []byte) error {
-	if expired(req.Expiration) {
-		return errExpired
-	}
-	if !t.handleReply(fromID, neighborsPacket, req) {
-		return errUnsolicitedReply
-	}
-	return nil
-}
-
-func expired(ts uint64) bool {
-	return time.Unix(int64(ts), 0).Before(time.Now())
 }

p2p/discover/udp_test.go

@@ -17,18 +17,11 @@
 package discover
 
 import (
-	"bytes"
-	"crypto/ecdsa"
-	"encoding/binary"
 	"encoding/hex"
 	"errors"
-	"fmt"
 	"io"
-	"math/rand"
 	"net"
-	"path/filepath"
 	"reflect"
-	"runtime"
 	"sync"
 	"testing"
 	"time"
@@ -102,340 +95,239 @@ var (
 	testLocal          = rpcEndpoint{IP: net.ParseIP("3.3.3.3").To4(), UDP: 5, TCP: 6}
 )
 
-type udpTest struct {
+// type udpTest struct {
-	t                   *testing.T
+// 	t                   *testing.T
-	pipe                *dgramPipe
+// 	pipe                *dgramPipe
-	table               *Table
+// 	table               *Table
-	udp                 *udp
+// 	udp                 *udp
-	sent                [][]byte
+// 	sent                [][]byte
-	localkey, remotekey *ecdsa.PrivateKey
+// 	localkey, remotekey *ecdsa.PrivateKey
-	remoteaddr          *net.UDPAddr
+// 	remoteaddr          *net.UDPAddr
-}
+// }
-
+//
-func newUDPTest(t *testing.T) *udpTest {
+// func newUDPTest(t *testing.T) *udpTest {
-	test := &udpTest{
+// 	test := &udpTest{
-		t:          t,
+// 		t:          t,
-		pipe:       newpipe(),
+// 		pipe:       newpipe(),
-		localkey:   newkey(),
+// 		localkey:   newkey(),
-		remotekey:  newkey(),
+// 		remotekey:  newkey(),
-		remoteaddr: &net.UDPAddr{IP: net.IP{1, 2, 3, 4}, Port: 30303},
+// 		remoteaddr: &net.UDPAddr{IP: net.IP{1, 2, 3, 4}, Port: 30303},
-	}
+// 	}
-	test.table, test.udp, _ = newUDP(test.localkey, test.pipe, nil, "")
+// 	test.table, test.udp, _ = newUDP(test.localkey, test.pipe, nil, "")
-	return test
+// 	return test
-}
+// }
-
+//
-// handles a packet as if it had been sent to the transport.
+// // handles a packet as if it had been sent to the transport.
-func (test *udpTest) packetIn(wantError error, ptype byte, data packet) error {
+// func (test *udpTest) packetIn(wantError error, ptype byte, data packet) error {
-	enc, err := encodePacket(test.remotekey, ptype, data)
+// 	enc, err := encodePacket(test.remotekey, ptype, data)
-	if err != nil {
+// 	if err != nil {
-		return test.errorf("packet (%d) encode error: %v", ptype, err)
+// 		return test.errorf("packet (%d) encode error: %v", ptype, err)
-	}
+// 	}
-	test.sent = append(test.sent, enc)
+// 	test.sent = append(test.sent, enc)
-	if err = test.udp.handlePacket(test.remoteaddr, enc); err != wantError {
+// 	if err = test.udp.handlePacket(test.remoteaddr, enc); err != wantError {
-		return test.errorf("error mismatch: got %q, want %q", err, wantError)
+// 		return test.errorf("error mismatch: got %q, want %q", err, wantError)
-	}
+// 	}
-	return nil
+// 	return nil
-}
+// }
-
+//
-// waits for a packet to be sent by the transport.
+// // waits for a packet to be sent by the transport.
-// validate should have type func(*udpTest, X) error, where X is a packet type.
+// // validate should have type func(*udpTest, X) error, where X is a packet type.
-func (test *udpTest) waitPacketOut(validate interface{}) error {
+// func (test *udpTest) waitPacketOut(validate interface{}) error {
-	dgram := test.pipe.waitPacketOut()
+// 	dgram := test.pipe.waitPacketOut()
-	p, _, _, err := decodePacket(dgram)
+// 	p, _, _, err := decodePacket(dgram)
-	if err != nil {
+// 	if err != nil {
-		return test.errorf("sent packet decode error: %v", err)
+// 		return test.errorf("sent packet decode error: %v", err)
-	}
+// 	}
-	fn := reflect.ValueOf(validate)
+// 	fn := reflect.ValueOf(validate)
-	exptype := fn.Type().In(0)
+// 	exptype := fn.Type().In(0)
-	if reflect.TypeOf(p) != exptype {
+// 	if reflect.TypeOf(p) != exptype {
-		return test.errorf("sent packet type mismatch, got: %v, want: %v", reflect.TypeOf(p), exptype)
+// 		return test.errorf("sent packet type mismatch, got: %v, want: %v", reflect.TypeOf(p), exptype)
-	}
+// 	}
-	fn.Call([]reflect.Value{reflect.ValueOf(p)})
+// 	fn.Call([]reflect.Value{reflect.ValueOf(p)})
-	return nil
+// 	return nil
-}
+// }
-
+//
-func (test *udpTest) errorf(format string, args ...interface{}) error {
+// func (test *udpTest) errorf(format string, args ...interface{}) error {
-	_, file, line, ok := runtime.Caller(2) // errorf + waitPacketOut
+// 	_, file, line, ok := runtime.Caller(2) // errorf + waitPacketOut
-	if ok {
+// 	if ok {
-		file = filepath.Base(file)
+// 		file = filepath.Base(file)
-	} else {
+// 	} else {
-		file = "???"
+// 		file = "???"
-		line = 1
+// 		line = 1
-	}
+// 	}
-	err := fmt.Errorf(format, args...)
+// 	err := fmt.Errorf(format, args...)
-	fmt.Printf("\t%s:%d: %v\n", file, line, err)
+// 	fmt.Printf("\t%s:%d: %v\n", file, line, err)
-	test.t.Fail()
+// 	test.t.Fail()
-	return err
+// 	return err
-}
+// }
-
+//
-func TestUDP_packetErrors(t *testing.T) {
+// func TestUDP_packetErrors(t *testing.T) {
-	test := newUDPTest(t)
+// 	test := newUDPTest(t)
-	defer test.table.Close()
+// 	defer test.table.Close()
-
+//
-	test.packetIn(errExpired, pingPacket, &ping{From: testRemote, To: testLocalAnnounced, Version: Version})
+// 	test.packetIn(errExpired, pingPacket, &ping{From: testRemote, To: testLocalAnnounced, Version: Version})
-	test.packetIn(errUnsolicitedReply, pongPacket, &pong{ReplyTok: []byte{}, Expiration: futureExp})
+// 	test.packetIn(errUnsolicitedReply, pongPacket, &pong{ReplyTok: []byte{}, Expiration: futureExp})
-	test.packetIn(errUnknownNode, findnodePacket, &findnode{Expiration: futureExp})
+// 	test.packetIn(errUnknownNode, findnodePacket, &findnode{Expiration: futureExp})
-	test.packetIn(errUnsolicitedReply, neighborsPacket, &neighbors{Expiration: futureExp})
+// 	test.packetIn(errUnsolicitedReply, neighborsPacket, &neighbors{Expiration: futureExp})
-}
+// }
-
+//
-func TestUDP_pingTimeout(t *testing.T) {
+// func TestUDP_findnode(t *testing.T) {
-	t.Parallel()
+// 	test := newUDPTest(t)
-	test := newUDPTest(t)
+// 	defer test.table.Close()
-	defer test.table.Close()
+//
-
+// 	// put a few nodes into the table. their exact
-	toaddr := &net.UDPAddr{IP: net.ParseIP("1.2.3.4"), Port: 2222}
+// 	// distribution shouldn't matter much, altough we need to
-	toid := NodeID{1, 2, 3, 4}
+// 	// take care not to overflow any bucket.
-	if err := test.udp.ping(toid, toaddr); err != errTimeout {
+// 	targetHash := crypto.Keccak256Hash(testTarget[:])
-		t.Error("expected timeout error, got", err)
+// 	nodes := &nodesByDistance{target: targetHash}
-	}
+// 	for i := 0; i < bucketSize; i++ {
-}
+// 		nodes.push(nodeAtDistance(test.table.self.sha, i+2), bucketSize)
-
+// 	}
-func TestUDP_responseTimeouts(t *testing.T) {
+// 	test.table.stuff(nodes.entries)
-	t.Parallel()
+//
-	test := newUDPTest(t)
+// 	// ensure there's a bond with the test node,
-	defer test.table.Close()
+// 	// findnode won't be accepted otherwise.
-
+// 	test.table.db.updateNode(NewNode(
-	rand.Seed(time.Now().UnixNano())
+// 		PubkeyID(&test.remotekey.PublicKey),
-	randomDuration := func(max time.Duration) time.Duration {
+// 		test.remoteaddr.IP,
-		return time.Duration(rand.Int63n(int64(max)))
+// 		uint16(test.remoteaddr.Port),
-	}
+// 		99,
-
+// 	))
-	var (
+// 	// check that closest neighbors are returned.
-		nReqs      = 200
+// 	test.packetIn(nil, findnodePacket, &findnode{Target: testTarget, Expiration: futureExp})
-		nTimeouts  = 0                       // number of requests with ptype > 128
+// 	expected := test.table.closest(targetHash, bucketSize)
-		nilErr     = make(chan error, nReqs) // for requests that get a reply
+//
-		timeoutErr = make(chan error, nReqs) // for requests that time out
+// 	waitNeighbors := func(want []*Node) {
-	)
+// 		test.waitPacketOut(func(p *neighbors) {
-	for i := 0; i < nReqs; i++ {
+// 			if len(p.Nodes) != len(want) {
-		// Create a matcher for a random request in udp.loop. Requests
+// 				t.Errorf("wrong number of results: got %d, want %d", len(p.Nodes), bucketSize)
-		// with ptype <= 128 will not get a reply and should time out.
+// 			}
-		// For all other requests, a reply is scheduled to arrive
+// 			for i := range p.Nodes {
-		// within the timeout window.
+// 				if p.Nodes[i].ID != want[i].ID {
-		p := &pending{
+// 					t.Errorf("result mismatch at %d:\n  got:  %v\n  want: %v", i, p.Nodes[i], expected.entries[i])
-			ptype:    byte(rand.Intn(255)),
+// 				}
-			callback: func(interface{}) bool { return true },
+// 			}
-		}
+// 		})
-		binary.BigEndian.PutUint64(p.from[:], uint64(i))
+// 	}
-		if p.ptype <= 128 {
+// 	waitNeighbors(expected.entries[:maxNeighbors])
-			p.errc = timeoutErr
+// 	waitNeighbors(expected.entries[maxNeighbors:])
-			test.udp.addpending <- p
+// }
-			nTimeouts++
+//
-		} else {
+// func TestUDP_findnodeMultiReply(t *testing.T) {
-			p.errc = nilErr
+// 	test := newUDPTest(t)
-			test.udp.addpending <- p
+// 	defer test.table.Close()
-			time.AfterFunc(randomDuration(60*time.Millisecond), func() {
+//
-				if !test.udp.handleReply(p.from, p.ptype, nil) {
+// 	// queue a pending findnode request
-					t.Logf("not matched: %v", p)
+// 	resultc, errc := make(chan []*Node), make(chan error)
-				}
+// 	go func() {
-			})
+// 		rid := PubkeyID(&test.remotekey.PublicKey)
-		}
+// 		ns, err := test.udp.findnode(rid, test.remoteaddr, testTarget)
-		time.Sleep(randomDuration(30 * time.Millisecond))
+// 		if err != nil && len(ns) == 0 {
-	}
+// 			errc <- err
-
+// 		} else {
-	// Check that all timeouts were delivered and that the rest got nil errors.
+// 			resultc <- ns
-	// The replies must be delivered.
+// 		}
-	var (
+// 	}()
-		recvDeadline        = time.After(20 * time.Second)
+//
-		nTimeoutsRecv, nNil = 0, 0
+// 	// wait for the findnode to be sent.
-	)
+// 	// after it is sent, the transport is waiting for a reply
-	for i := 0; i < nReqs; i++ {
+// 	test.waitPacketOut(func(p *findnode) {
-		select {
+// 		if p.Target != testTarget {
-		case err := <-timeoutErr:
+// 			t.Errorf("wrong target: got %v, want %v", p.Target, testTarget)
-			if err != errTimeout {
+// 		}
-				t.Fatalf("got non-timeout error on timeoutErr %d: %v", i, err)
+// 	})
-			}
+//
-			nTimeoutsRecv++
+// 	// send the reply as two packets.
-		case err := <-nilErr:
+// 	list := []*Node{
-			if err != nil {
+// 		MustParseNode("enode://ba85011c70bcc5c04d8607d3a0ed29aa6179c092cbdda10d5d32684fb33ed01bd94f588ca8f91ac48318087dcb02eaf36773a7a453f0eedd6742af668097b29c@10.0.1.16:30303?discport=30304"),
-				t.Fatalf("got non-nil error on nilErr %d: %v", i, err)
+// 		MustParseNode("enode://81fa361d25f157cd421c60dcc28d8dac5ef6a89476633339c5df30287474520caca09627da18543d9079b5b288698b542d56167aa5c09111e55acdbbdf2ef799@10.0.1.16:30303"),
-			}
+// 		MustParseNode("enode://9bffefd833d53fac8e652415f4973bee289e8b1a5c6c4cbe70abf817ce8a64cee11b823b66a987f51aaa9fba0d6a91b3e6bf0d5a5d1042de8e9eeea057b217f8@10.0.1.36:30301?discport=17"),
-			nNil++
+// 		MustParseNode("enode://1b5b4aa662d7cb44a7221bfba67302590b643028197a7d5214790f3bac7aaa4a3241be9e83c09cf1f6c69d007c634faae3dc1b1221793e8446c0b3a09de65960@10.0.1.16:30303"),
-		case <-recvDeadline:
+// 	}
-			t.Fatalf("exceeded recv deadline")
+// 	rpclist := make([]rpcNode, len(list))
-		}
+// 	for i := range list {
-	}
+// 		rpclist[i] = nodeToRPC(list[i])
-	if nTimeoutsRecv != nTimeouts {
+// 	}
-		t.Errorf("wrong number of timeout errors received: got %d, want %d", nTimeoutsRecv, nTimeouts)
+// 	test.packetIn(nil, neighborsPacket, &neighbors{Expiration: futureExp, Nodes: rpclist[:2]})
-	}
+// 	test.packetIn(nil, neighborsPacket, &neighbors{Expiration: futureExp, Nodes: rpclist[2:]})
-	if nNil != nReqs-nTimeouts {
+//
-		t.Errorf("wrong number of successful replies: got %d, want %d", nNil, nReqs-nTimeouts)
+// 	// check that the sent neighbors are all returned by findnode
-	}
+// 	select {
-}
+// 	case result := <-resultc:
-
+// 		if !reflect.DeepEqual(result, list) {
-func TestUDP_findnodeTimeout(t *testing.T) {
+// 			t.Errorf("neighbors mismatch:\n  got:  %v\n  want: %v", result, list)
-	t.Parallel()
+// 		}
-	test := newUDPTest(t)
+// 	case err := <-errc:
-	defer test.table.Close()
+// 		t.Errorf("findnode error: %v", err)
-
+// 	case <-time.After(5 * time.Second):
-	toaddr := &net.UDPAddr{IP: net.ParseIP("1.2.3.4"), Port: 2222}
+// 		t.Error("findnode did not return within 5 seconds")
-	toid := NodeID{1, 2, 3, 4}
+// 	}
-	target := NodeID{4, 5, 6, 7}
+// }
-	result, err := test.udp.findnode(toid, toaddr, target)
+//
-	if err != errTimeout {
+// func TestUDP_successfulPing(t *testing.T) {
-		t.Error("expected timeout error, got", err)
+// 	test := newUDPTest(t)
-	}
+// 	added := make(chan *Node, 1)
-	if len(result) > 0 {
+// 	test.table.nodeAddedHook = func(n *Node) { added <- n }
-		t.Error("expected empty result, got", result)
+// 	defer test.table.Close()
-	}
+//
-}
+// 	// The remote side sends a ping packet to initiate the exchange.
-
+// 	go test.packetIn(nil, pingPacket, &ping{From: testRemote, To: testLocalAnnounced, Version: Version, Expiration: futureExp})
-func TestUDP_findnode(t *testing.T) {
+//
-	test := newUDPTest(t)
+// 	// the ping is replied to.
-	defer test.table.Close()
+// 	test.waitPacketOut(func(p *pong) {
-
+// 		pinghash := test.sent[0][:macSize]
-	// put a few nodes into the table. their exact
+// 		if !bytes.Equal(p.ReplyTok, pinghash) {
-	// distribution shouldn't matter much, altough we need to
+// 			t.Errorf("got pong.ReplyTok %x, want %x", p.ReplyTok, pinghash)
-	// take care not to overflow any bucket.
+// 		}
-	targetHash := crypto.Keccak256Hash(testTarget[:])
+// 		wantTo := rpcEndpoint{
-	nodes := &nodesByDistance{target: targetHash}
+// 			// The mirrored UDP address is the UDP packet sender
-	for i := 0; i < bucketSize; i++ {
+// 			IP: test.remoteaddr.IP, UDP: uint16(test.remoteaddr.Port),
-		nodes.push(nodeAtDistance(test.table.self.sha, i+2), bucketSize)
+// 			// The mirrored TCP port is the one from the ping packet
-	}
+// 			TCP: testRemote.TCP,
-	test.table.stuff(nodes.entries)
+// 		}
-
+// 		if !reflect.DeepEqual(p.To, wantTo) {
-	// ensure there's a bond with the test node,
+// 			t.Errorf("got pong.To %v, want %v", p.To, wantTo)
-	// findnode won't be accepted otherwise.
+// 		}
-	test.table.db.updateNode(NewNode(
+// 	})
-		PubkeyID(&test.remotekey.PublicKey),
+//
-		test.remoteaddr.IP,
+// 	// remote is unknown, the table pings back.
-		uint16(test.remoteaddr.Port),
+// 	test.waitPacketOut(func(p *ping) error {
-		99,
+// 		if !reflect.DeepEqual(p.From, test.udp.ourEndpoint) {
-	))
+// 			t.Errorf("got ping.From %v, want %v", p.From, test.udp.ourEndpoint)
-	// check that closest neighbors are returned.
+// 		}
-	test.packetIn(nil, findnodePacket, &findnode{Target: testTarget, Expiration: futureExp})
+// 		wantTo := rpcEndpoint{
-	expected := test.table.closest(targetHash, bucketSize)
+// 			// The mirrored UDP address is the UDP packet sender.
-
+// 			IP: test.remoteaddr.IP, UDP: uint16(test.remoteaddr.Port),
-	waitNeighbors := func(want []*Node) {
+// 			TCP: 0,
-		test.waitPacketOut(func(p *neighbors) {
+// 		}
-			if len(p.Nodes) != len(want) {
+// 		if !reflect.DeepEqual(p.To, wantTo) {
-				t.Errorf("wrong number of results: got %d, want %d", len(p.Nodes), bucketSize)
+// 			t.Errorf("got ping.To %v, want %v", p.To, wantTo)
-			}
+// 		}
-			for i := range p.Nodes {
+// 		return nil
-				if p.Nodes[i].ID != want[i].ID {
+// 	})
-					t.Errorf("result mismatch at %d:\n  got:  %v\n  want: %v", i, p.Nodes[i], expected.entries[i])
+// 	test.packetIn(nil, pongPacket, &pong{Expiration: futureExp})
-				}
+//
-			}
+// 	// the node should be added to the table shortly after getting the
-		})
+// 	// pong packet.
-	}
+// 	select {
-	waitNeighbors(expected.entries[:maxNeighbors])
+// 	case n := <-added:
-	waitNeighbors(expected.entries[maxNeighbors:])
+// 		rid := PubkeyID(&test.remotekey.PublicKey)
-}
+// 		if n.ID != rid {
-
+// 			t.Errorf("node has wrong ID: got %v, want %v", n.ID, rid)
-func TestUDP_findnodeMultiReply(t *testing.T) {
+// 		}
-	test := newUDPTest(t)
+// 		if !bytes.Equal(n.IP, test.remoteaddr.IP) {
-	defer test.table.Close()
+// 			t.Errorf("node has wrong IP: got %v, want: %v", n.IP, test.remoteaddr.IP)
-
+// 		}
-	// queue a pending findnode request
+// 		if int(n.UDP) != test.remoteaddr.Port {
-	resultc, errc := make(chan []*Node), make(chan error)
+// 			t.Errorf("node has wrong UDP port: got %v, want: %v", n.UDP, test.remoteaddr.Port)
-	go func() {
+// 		}
-		rid := PubkeyID(&test.remotekey.PublicKey)
+// 		if n.TCP != testRemote.TCP {
-		ns, err := test.udp.findnode(rid, test.remoteaddr, testTarget)
+// 			t.Errorf("node has wrong TCP port: got %v, want: %v", n.TCP, testRemote.TCP)
-		if err != nil && len(ns) == 0 {
+// 		}
-			errc <- err
+// 	case <-time.After(2 * time.Second):
-		} else {
+// 		t.Errorf("node was not added within 2 seconds")
-			resultc <- ns
+// 	}
-		}
+// }
-	}()
-
-	// wait for the findnode to be sent.
-	// after it is sent, the transport is waiting for a reply
-	test.waitPacketOut(func(p *findnode) {
-		if p.Target != testTarget {
-			t.Errorf("wrong target: got %v, want %v", p.Target, testTarget)
-		}
-	})
-
-	// send the reply as two packets.
-	list := []*Node{
-		MustParseNode("enode://ba85011c70bcc5c04d8607d3a0ed29aa6179c092cbdda10d5d32684fb33ed01bd94f588ca8f91ac48318087dcb02eaf36773a7a453f0eedd6742af668097b29c@10.0.1.16:30303?discport=30304"),
-		MustParseNode("enode://81fa361d25f157cd421c60dcc28d8dac5ef6a89476633339c5df30287474520caca09627da18543d9079b5b288698b542d56167aa5c09111e55acdbbdf2ef799@10.0.1.16:30303"),
-		MustParseNode("enode://9bffefd833d53fac8e652415f4973bee289e8b1a5c6c4cbe70abf817ce8a64cee11b823b66a987f51aaa9fba0d6a91b3e6bf0d5a5d1042de8e9eeea057b217f8@10.0.1.36:30301?discport=17"),
-		MustParseNode("enode://1b5b4aa662d7cb44a7221bfba67302590b643028197a7d5214790f3bac7aaa4a3241be9e83c09cf1f6c69d007c634faae3dc1b1221793e8446c0b3a09de65960@10.0.1.16:30303"),
-	}
-	rpclist := make([]rpcNode, len(list))
-	for i := range list {
-		rpclist[i] = nodeToRPC(list[i])
-	}
-	test.packetIn(nil, neighborsPacket, &neighbors{Expiration: futureExp, Nodes: rpclist[:2]})
-	test.packetIn(nil, neighborsPacket, &neighbors{Expiration: futureExp, Nodes: rpclist[2:]})
-
-	// check that the sent neighbors are all returned by findnode
-	select {
-	case result := <-resultc:
-		if !reflect.DeepEqual(result, list) {
-			t.Errorf("neighbors mismatch:\n  got:  %v\n  want: %v", result, list)
-		}
-	case err := <-errc:
-		t.Errorf("findnode error: %v", err)
-	case <-time.After(5 * time.Second):
-		t.Error("findnode did not return within 5 seconds")
-	}
-}
-
-func TestUDP_successfulPing(t *testing.T) {
-	test := newUDPTest(t)
-	added := make(chan *Node, 1)
-	test.table.nodeAddedHook = func(n *Node) { added <- n }
-	defer test.table.Close()
-
-	// The remote side sends a ping packet to initiate the exchange.
-	go test.packetIn(nil, pingPacket, &ping{From: testRemote, To: testLocalAnnounced, Version: Version, Expiration: futureExp})
-
-	// the ping is replied to.
-	test.waitPacketOut(func(p *pong) {
-		pinghash := test.sent[0][:macSize]
-		if !bytes.Equal(p.ReplyTok, pinghash) {
-			t.Errorf("got pong.ReplyTok %x, want %x", p.ReplyTok, pinghash)
-		}
-		wantTo := rpcEndpoint{
-			// The mirrored UDP address is the UDP packet sender
-			IP: test.remoteaddr.IP, UDP: uint16(test.remoteaddr.Port),
-			// The mirrored TCP port is the one from the ping packet
-			TCP: testRemote.TCP,
-		}
-		if !reflect.DeepEqual(p.To, wantTo) {
-			t.Errorf("got pong.To %v, want %v", p.To, wantTo)
-		}
-	})
-
-	// remote is unknown, the table pings back.
-	test.waitPacketOut(func(p *ping) error {
-		if !reflect.DeepEqual(p.From, test.udp.ourEndpoint) {
-			t.Errorf("got ping.From %v, want %v", p.From, test.udp.ourEndpoint)
-		}
-		wantTo := rpcEndpoint{
-			// The mirrored UDP address is the UDP packet sender.
-			IP: test.remoteaddr.IP, UDP: uint16(test.remoteaddr.Port),
-			TCP: 0,
-		}
-		if !reflect.DeepEqual(p.To, wantTo) {
-			t.Errorf("got ping.To %v, want %v", p.To, wantTo)
-		}
-		return nil
-	})
-	test.packetIn(nil, pongPacket, &pong{Expiration: futureExp})
-
-	// the node should be added to the table shortly after getting the
-	// pong packet.
-	select {
-	case n := <-added:
-		rid := PubkeyID(&test.remotekey.PublicKey)
-		if n.ID != rid {
-			t.Errorf("node has wrong ID: got %v, want %v", n.ID, rid)
-		}
-		if !bytes.Equal(n.IP, test.remoteaddr.IP) {
-			t.Errorf("node has wrong IP: got %v, want: %v", n.IP, test.remoteaddr.IP)
-		}
-		if int(n.UDP) != test.remoteaddr.Port {
-			t.Errorf("node has wrong UDP port: got %v, want: %v", n.UDP, test.remoteaddr.Port)
-		}
-		if n.TCP != testRemote.TCP {
-			t.Errorf("node has wrong TCP port: got %v, want: %v", n.TCP, testRemote.TCP)
-		}
-	case <-time.After(2 * time.Second):
-		t.Errorf("node was not added within 2 seconds")
-	}
-}
 
 var testPackets = []struct {
 	input      string
@@ -532,16 +424,16 @@ func TestForwardCompatibility(t *testing.T) {
 		if err != nil {
 			t.Fatalf("invalid hex: %s", test.input)
 		}
-		packet, nodeid, _, err := decodePacket(input)
+		var pkt ingressPacket
-		if err != nil {
+		if err := decodePacket(input, &pkt); err != nil {
 			t.Errorf("did not accept packet %s\n%v", test.input, err)
 			continue
 		}
-		if !reflect.DeepEqual(packet, test.wantPacket) {
+		if !reflect.DeepEqual(pkt.data, test.wantPacket) {
-			t.Errorf("got %s\nwant %s", spew.Sdump(packet), spew.Sdump(test.wantPacket))
+			t.Errorf("got %s\nwant %s", spew.Sdump(pkt.data), spew.Sdump(test.wantPacket))
 		}
-		if nodeid != wantNodeID {
+		if pkt.remoteID != wantNodeID {
-			t.Errorf("got id %v\nwant id %v", nodeid, wantNodeID)
+			t.Errorf("got id %v\nwant id %v", pkt.remoteID, wantNodeID)
 		}
 	}
 }