p2p/discover: implement v5.1 wire protocol (#21647)
This change implements the Discovery v5.1 wire protocol and also adds an interactive test suite for this protocol.
This commit is contained in:
Felix Lange
GitHub
@ -24,22 +24,25 @@ import (
|
||||
"math/rand"
|
||||
"net"
|
||||
"reflect"
|
||||
"sort"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/ethereum/go-ethereum/internal/testlog"
|
||||
"github.com/ethereum/go-ethereum/log"
|
||||
"github.com/ethereum/go-ethereum/p2p/discover/v5wire"
|
||||
"github.com/ethereum/go-ethereum/p2p/enode"
|
||||
"github.com/ethereum/go-ethereum/p2p/enr"
|
||||
"github.com/ethereum/go-ethereum/rlp"
|
||||
)
|
||||
|
||||
// Real sockets, real crypto: this test checks end-to-end connectivity for UDPv5.
|
||||
func TestEndToEndV5(t *testing.T) {
|
||||
func TestUDPv5_lookupE2E(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const N = 5
|
||||
var nodes []*UDPv5
|
||||
for i := 0; i < 5; i++ {
|
||||
for i := 0; i < N; i++ {
|
||||
var cfg Config
|
||||
if len(nodes) > 0 {
|
||||
bn := nodes[0].Self()
|
||||
@ -49,12 +52,22 @@ func TestEndToEndV5(t *testing.T) {
|
||||
nodes = append(nodes, node)
|
||||
defer node.Close()
|
||||
}
|
||||
last := nodes[N-1]
|
||||
target := nodes[rand.Intn(N-2)].Self()
|
||||
|
||||
last := nodes[len(nodes)-1]
|
||||
target := nodes[rand.Intn(len(nodes)-2)].Self()
|
||||
// It is expected that all nodes can be found.
|
||||
expectedResult := make([]*enode.Node, len(nodes))
|
||||
for i := range nodes {
|
||||
expectedResult[i] = nodes[i].Self()
|
||||
}
|
||||
sort.Slice(expectedResult, func(i, j int) bool {
|
||||
return enode.DistCmp(target.ID(), expectedResult[i].ID(), expectedResult[j].ID()) < 0
|
||||
})
|
||||
|
||||
// Do the lookup.
|
||||
results := last.Lookup(target.ID())
|
||||
if len(results) == 0 || results[0].ID() != target.ID() {
|
||||
t.Fatalf("lookup returned wrong results: %v", results)
|
||||
if err := checkNodesEqual(results, expectedResult); err != nil {
|
||||
t.Fatalf("lookup returned wrong results: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
@ -93,8 +106,8 @@ func TestUDPv5_pingHandling(t *testing.T) {
|
||||
test := newUDPV5Test(t)
|
||||
defer test.close()
|
||||
|
||||
test.packetIn(&pingV5{ReqID: []byte("foo")})
|
||||
test.waitPacketOut(func(p *pongV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&v5wire.Ping{ReqID: []byte("foo")})
|
||||
test.waitPacketOut(func(p *v5wire.Pong, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if !bytes.Equal(p.ReqID, []byte("foo")) {
|
||||
t.Error("wrong request ID in response:", p.ReqID)
|
||||
}
|
||||
@ -110,13 +123,13 @@ func TestUDPv5_unknownPacket(t *testing.T) {
|
||||
test := newUDPV5Test(t)
|
||||
defer test.close()
|
||||
|
||||
authTag := [12]byte{1, 2, 3}
|
||||
check := func(p *whoareyouV5, wantSeq uint64) {
|
||||
nonce := v5wire.Nonce{1, 2, 3}
|
||||
check := func(p *v5wire.Whoareyou, wantSeq uint64) {
|
||||
t.Helper()
|
||||
if !bytes.Equal(p.AuthTag, authTag[:]) {
|
||||
t.Error("wrong token in WHOAREYOU:", p.AuthTag, authTag[:])
|
||||
if p.Nonce != nonce {
|
||||
t.Error("wrong nonce in WHOAREYOU:", p.Nonce, nonce)
|
||||
}
|
||||
if p.IDNonce == ([32]byte{}) {
|
||||
if p.IDNonce == ([16]byte{}) {
|
||||
t.Error("all zero ID nonce")
|
||||
}
|
||||
if p.RecordSeq != wantSeq {
|
||||
@ -125,8 +138,8 @@ func TestUDPv5_unknownPacket(t *testing.T) {
|
||||
}
|
||||
|
||||
// Unknown packet from unknown node.
|
||||
test.packetIn(&unknownV5{AuthTag: authTag[:]})
|
||||
test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) {
|
||||
test.packetIn(&v5wire.Unknown{Nonce: nonce})
|
||||
test.waitPacketOut(func(p *v5wire.Whoareyou, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
check(p, 0)
|
||||
})
|
||||
|
||||
@ -134,8 +147,8 @@ func TestUDPv5_unknownPacket(t *testing.T) {
|
||||
n := test.getNode(test.remotekey, test.remoteaddr).Node()
|
||||
test.table.addSeenNode(wrapNode(n))
|
||||
|
||||
test.packetIn(&unknownV5{AuthTag: authTag[:]})
|
||||
test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) {
|
||||
test.packetIn(&v5wire.Unknown{Nonce: nonce})
|
||||
test.waitPacketOut(func(p *v5wire.Whoareyou, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
check(p, n.Seq())
|
||||
})
|
||||
}
|
||||
@ -147,24 +160,40 @@ func TestUDPv5_findnodeHandling(t *testing.T) {
|
||||
defer test.close()
|
||||
|
||||
// Create test nodes and insert them into the table.
|
||||
nodes := nodesAtDistance(test.table.self().ID(), 253, 10)
|
||||
fillTable(test.table, wrapNodes(nodes))
|
||||
nodes253 := nodesAtDistance(test.table.self().ID(), 253, 10)
|
||||
nodes249 := nodesAtDistance(test.table.self().ID(), 249, 4)
|
||||
nodes248 := nodesAtDistance(test.table.self().ID(), 248, 10)
|
||||
fillTable(test.table, wrapNodes(nodes253))
|
||||
fillTable(test.table, wrapNodes(nodes249))
|
||||
fillTable(test.table, wrapNodes(nodes248))
|
||||
|
||||
// Requesting with distance zero should return the node's own record.
|
||||
test.packetIn(&findnodeV5{ReqID: []byte{0}, Distance: 0})
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{0}, Distances: []uint{0}})
|
||||
test.expectNodes([]byte{0}, 1, []*enode.Node{test.udp.Self()})
|
||||
|
||||
// Requesting with distance > 256 caps it at 256.
|
||||
test.packetIn(&findnodeV5{ReqID: []byte{1}, Distance: 4234098})
|
||||
// Requesting with distance > 256 shouldn't crash.
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{1}, Distances: []uint{4234098}})
|
||||
test.expectNodes([]byte{1}, 1, nil)
|
||||
|
||||
// This request gets no nodes because the corresponding bucket is empty.
|
||||
test.packetIn(&findnodeV5{ReqID: []byte{2}, Distance: 254})
|
||||
// Requesting with empty distance list shouldn't crash either.
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{2}, Distances: []uint{}})
|
||||
test.expectNodes([]byte{2}, 1, nil)
|
||||
|
||||
// This request gets all test nodes.
|
||||
test.packetIn(&findnodeV5{ReqID: []byte{3}, Distance: 253})
|
||||
test.expectNodes([]byte{3}, 4, nodes)
|
||||
// This request gets no nodes because the corresponding bucket is empty.
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{3}, Distances: []uint{254}})
|
||||
test.expectNodes([]byte{3}, 1, nil)
|
||||
|
||||
// This request gets all the distance-253 nodes.
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{4}, Distances: []uint{253}})
|
||||
test.expectNodes([]byte{4}, 4, nodes253)
|
||||
|
||||
// This request gets all the distance-249 nodes and some more at 248 because
|
||||
// the bucket at 249 is not full.
|
||||
test.packetIn(&v5wire.Findnode{ReqID: []byte{5}, Distances: []uint{249, 248}})
|
||||
var nodes []*enode.Node
|
||||
nodes = append(nodes, nodes249...)
|
||||
nodes = append(nodes, nodes248[:10]...)
|
||||
test.expectNodes([]byte{5}, 5, nodes)
|
||||
}
|
||||
|
||||
func (test *udpV5Test) expectNodes(wantReqID []byte, wantTotal uint8, wantNodes []*enode.Node) {
|
||||
@ -172,16 +201,17 @@ func (test *udpV5Test) expectNodes(wantReqID []byte, wantTotal uint8, wantNodes
|
||||
for _, n := range wantNodes {
|
||||
nodeSet[n.ID()] = n.Record()
|
||||
}
|
||||
|
||||
for {
|
||||
test.waitPacketOut(func(p *nodesV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.waitPacketOut(func(p *v5wire.Nodes, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if !bytes.Equal(p.ReqID, wantReqID) {
|
||||
test.t.Fatalf("wrong request ID %v in response, want %v", p.ReqID, wantReqID)
|
||||
}
|
||||
if len(p.Nodes) > 3 {
|
||||
test.t.Fatalf("too many nodes in response")
|
||||
}
|
||||
if p.Total != wantTotal {
|
||||
test.t.Fatalf("wrong total response count %d", p.Total)
|
||||
}
|
||||
if !bytes.Equal(p.ReqID, wantReqID) {
|
||||
test.t.Fatalf("wrong request ID in response: %v", p.ReqID)
|
||||
test.t.Fatalf("wrong total response count %d, want %d", p.Total, wantTotal)
|
||||
}
|
||||
for _, record := range p.Nodes {
|
||||
n, _ := enode.New(enode.ValidSchemesForTesting, record)
|
||||
@ -215,7 +245,7 @@ func TestUDPv5_pingCall(t *testing.T) {
|
||||
_, err := test.udp.ping(remote)
|
||||
done <- err
|
||||
}()
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {})
|
||||
if err := <-done; err != errTimeout {
|
||||
t.Fatalf("want errTimeout, got %q", err)
|
||||
}
|
||||
@ -225,8 +255,8 @@ func TestUDPv5_pingCall(t *testing.T) {
|
||||
_, err := test.udp.ping(remote)
|
||||
done <- err
|
||||
}()
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetInFrom(test.remotekey, test.remoteaddr, &pongV5{ReqID: p.ReqID})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
test.packetInFrom(test.remotekey, test.remoteaddr, &v5wire.Pong{ReqID: p.ReqID})
|
||||
})
|
||||
if err := <-done; err != nil {
|
||||
t.Fatal(err)
|
||||
@ -237,9 +267,9 @@ func TestUDPv5_pingCall(t *testing.T) {
|
||||
_, err := test.udp.ping(remote)
|
||||
done <- err
|
||||
}()
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
wrongAddr := &net.UDPAddr{IP: net.IP{33, 44, 55, 22}, Port: 10101}
|
||||
test.packetInFrom(test.remotekey, wrongAddr, &pongV5{ReqID: p.ReqID})
|
||||
test.packetInFrom(test.remotekey, wrongAddr, &v5wire.Pong{ReqID: p.ReqID})
|
||||
})
|
||||
if err := <-done; err != errTimeout {
|
||||
t.Fatalf("want errTimeout for reply from wrong IP, got %q", err)
|
||||
@ -255,29 +285,29 @@ func TestUDPv5_findnodeCall(t *testing.T) {
|
||||
|
||||
// Launch the request:
|
||||
var (
|
||||
distance = 230
|
||||
remote = test.getNode(test.remotekey, test.remoteaddr).Node()
|
||||
nodes = nodesAtDistance(remote.ID(), distance, 8)
|
||||
done = make(chan error, 1)
|
||||
response []*enode.Node
|
||||
distances = []uint{230}
|
||||
remote = test.getNode(test.remotekey, test.remoteaddr).Node()
|
||||
nodes = nodesAtDistance(remote.ID(), int(distances[0]), 8)
|
||||
done = make(chan error, 1)
|
||||
response []*enode.Node
|
||||
)
|
||||
go func() {
|
||||
var err error
|
||||
response, err = test.udp.findnode(remote, distance)
|
||||
response, err = test.udp.findnode(remote, distances)
|
||||
done <- err
|
||||
}()
|
||||
|
||||
// Serve the responses:
|
||||
test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) {
|
||||
if p.Distance != uint(distance) {
|
||||
t.Fatalf("wrong bucket: %d", p.Distance)
|
||||
test.waitPacketOut(func(p *v5wire.Findnode, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if !reflect.DeepEqual(p.Distances, distances) {
|
||||
t.Fatalf("wrong distances in request: %v", p.Distances)
|
||||
}
|
||||
test.packetIn(&nodesV5{
|
||||
test.packetIn(&v5wire.Nodes{
|
||||
ReqID: p.ReqID,
|
||||
Total: 2,
|
||||
Nodes: nodesToRecords(nodes[:4]),
|
||||
})
|
||||
test.packetIn(&nodesV5{
|
||||
test.packetIn(&v5wire.Nodes{
|
||||
ReqID: p.ReqID,
|
||||
Total: 2,
|
||||
Nodes: nodesToRecords(nodes[4:]),
|
||||
@ -314,16 +344,16 @@ func TestUDPv5_callResend(t *testing.T) {
|
||||
}()
|
||||
|
||||
// Ping answered by WHOAREYOU.
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&whoareyouV5{AuthTag: authTag})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
|
||||
test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
|
||||
})
|
||||
// Ping should be re-sent.
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&pongV5{ReqID: p.ReqID})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
test.packetIn(&v5wire.Pong{ReqID: p.ReqID})
|
||||
})
|
||||
// Answer the other ping.
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&pongV5{ReqID: p.ReqID})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
test.packetIn(&v5wire.Pong{ReqID: p.ReqID})
|
||||
})
|
||||
if err := <-done; err != nil {
|
||||
t.Fatalf("unexpected ping error: %v", err)
|
||||
@ -347,12 +377,12 @@ func TestUDPv5_multipleHandshakeRounds(t *testing.T) {
|
||||
}()
|
||||
|
||||
// Ping answered by WHOAREYOU.
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&whoareyouV5{AuthTag: authTag})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
|
||||
test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
|
||||
})
|
||||
// Ping answered by WHOAREYOU again.
|
||||
test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.packetIn(&whoareyouV5{AuthTag: authTag})
|
||||
test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
|
||||
test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
|
||||
})
|
||||
if err := <-done; err != errTimeout {
|
||||
t.Fatalf("unexpected ping error: %q", err)
|
||||
@ -367,27 +397,27 @@ func TestUDPv5_callTimeoutReset(t *testing.T) {
|
||||
|
||||
// Launch the request:
|
||||
var (
|
||||
distance = 230
|
||||
distance = uint(230)
|
||||
remote = test.getNode(test.remotekey, test.remoteaddr).Node()
|
||||
nodes = nodesAtDistance(remote.ID(), distance, 8)
|
||||
nodes = nodesAtDistance(remote.ID(), int(distance), 8)
|
||||
done = make(chan error, 1)
|
||||
)
|
||||
go func() {
|
||||
_, err := test.udp.findnode(remote, distance)
|
||||
_, err := test.udp.findnode(remote, []uint{distance})
|
||||
done <- err
|
||||
}()
|
||||
|
||||
// Serve two responses, slowly.
|
||||
test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) {
|
||||
test.waitPacketOut(func(p *v5wire.Findnode, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
time.Sleep(respTimeout - 50*time.Millisecond)
|
||||
test.packetIn(&nodesV5{
|
||||
test.packetIn(&v5wire.Nodes{
|
||||
ReqID: p.ReqID,
|
||||
Total: 2,
|
||||
Nodes: nodesToRecords(nodes[:4]),
|
||||
})
|
||||
|
||||
time.Sleep(respTimeout - 50*time.Millisecond)
|
||||
test.packetIn(&nodesV5{
|
||||
test.packetIn(&v5wire.Nodes{
|
||||
ReqID: p.ReqID,
|
||||
Total: 2,
|
||||
Nodes: nodesToRecords(nodes[4:]),
|
||||
@ -398,6 +428,97 @@ func TestUDPv5_callTimeoutReset(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// This test checks that TALKREQ calls the registered handler function.
|
||||
func TestUDPv5_talkHandling(t *testing.T) {
|
||||
t.Parallel()
|
||||
test := newUDPV5Test(t)
|
||||
defer test.close()
|
||||
|
||||
var recvMessage []byte
|
||||
test.udp.RegisterTalkHandler("test", func(message []byte) []byte {
|
||||
recvMessage = message
|
||||
return []byte("test response")
|
||||
})
|
||||
|
||||
// Successful case:
|
||||
test.packetIn(&v5wire.TalkRequest{
|
||||
ReqID: []byte("foo"),
|
||||
Protocol: "test",
|
||||
Message: []byte("test request"),
|
||||
})
|
||||
test.waitPacketOut(func(p *v5wire.TalkResponse, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if !bytes.Equal(p.ReqID, []byte("foo")) {
|
||||
t.Error("wrong request ID in response:", p.ReqID)
|
||||
}
|
||||
if string(p.Message) != "test response" {
|
||||
t.Errorf("wrong talk response message: %q", p.Message)
|
||||
}
|
||||
if string(recvMessage) != "test request" {
|
||||
t.Errorf("wrong message received in handler: %q", recvMessage)
|
||||
}
|
||||
})
|
||||
|
||||
// Check that empty response is returned for unregistered protocols.
|
||||
recvMessage = nil
|
||||
test.packetIn(&v5wire.TalkRequest{
|
||||
ReqID: []byte("2"),
|
||||
Protocol: "wrong",
|
||||
Message: []byte("test request"),
|
||||
})
|
||||
test.waitPacketOut(func(p *v5wire.TalkResponse, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if !bytes.Equal(p.ReqID, []byte("2")) {
|
||||
t.Error("wrong request ID in response:", p.ReqID)
|
||||
}
|
||||
if string(p.Message) != "" {
|
||||
t.Errorf("wrong talk response message: %q", p.Message)
|
||||
}
|
||||
if recvMessage != nil {
|
||||
t.Errorf("handler was called for wrong protocol: %q", recvMessage)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// This test checks that outgoing TALKREQ calls work.
|
||||
func TestUDPv5_talkRequest(t *testing.T) {
|
||||
t.Parallel()
|
||||
test := newUDPV5Test(t)
|
||||
defer test.close()
|
||||
|
||||
remote := test.getNode(test.remotekey, test.remoteaddr).Node()
|
||||
done := make(chan error, 1)
|
||||
|
||||
// This request times out.
|
||||
go func() {
|
||||
_, err := test.udp.TalkRequest(remote, "test", []byte("test request"))
|
||||
done <- err
|
||||
}()
|
||||
test.waitPacketOut(func(p *v5wire.TalkRequest, addr *net.UDPAddr, _ v5wire.Nonce) {})
|
||||
if err := <-done; err != errTimeout {
|
||||
t.Fatalf("want errTimeout, got %q", err)
|
||||
}
|
||||
|
||||
// This request works.
|
||||
go func() {
|
||||
_, err := test.udp.TalkRequest(remote, "test", []byte("test request"))
|
||||
done <- err
|
||||
}()
|
||||
test.waitPacketOut(func(p *v5wire.TalkRequest, addr *net.UDPAddr, _ v5wire.Nonce) {
|
||||
if p.Protocol != "test" {
|
||||
t.Errorf("wrong protocol ID in talk request: %q", p.Protocol)
|
||||
}
|
||||
if string(p.Message) != "test request" {
|
||||
t.Errorf("wrong message talk request: %q", p.Message)
|
||||
}
|
||||
test.packetInFrom(test.remotekey, test.remoteaddr, &v5wire.TalkResponse{
|
||||
ReqID: p.ReqID,
|
||||
Message: []byte("test response"),
|
||||
})
|
||||
})
|
||||
if err := <-done; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// This test checks that lookup works.
|
||||
func TestUDPv5_lookup(t *testing.T) {
|
||||
t.Parallel()
|
||||
@ -417,7 +538,8 @@ func TestUDPv5_lookup(t *testing.T) {
|
||||
}
|
||||
|
||||
// Seed table with initial node.
|
||||
fillTable(test.table, []*node{wrapNode(lookupTestnet.node(256, 0))})
|
||||
initialNode := lookupTestnet.node(256, 0)
|
||||
fillTable(test.table, []*node{wrapNode(initialNode)})
|
||||
|
||||
// Start the lookup.
|
||||
resultC := make(chan []*enode.Node, 1)
|
||||
@ -427,22 +549,30 @@ func TestUDPv5_lookup(t *testing.T) {
|
||||
}()
|
||||
|
||||
// Answer lookup packets.
|
||||
asked := make(map[enode.ID]bool)
|
||||
for done := false; !done; {
|
||||
done = test.waitPacketOut(func(p packetV5, to *net.UDPAddr, authTag []byte) {
|
||||
done = test.waitPacketOut(func(p v5wire.Packet, to *net.UDPAddr, _ v5wire.Nonce) {
|
||||
recipient, key := lookupTestnet.nodeByAddr(to)
|
||||
switch p := p.(type) {
|
||||
case *pingV5:
|
||||
test.packetInFrom(key, to, &pongV5{ReqID: p.ReqID})
|
||||
case *findnodeV5:
|
||||
nodes := lookupTestnet.neighborsAtDistance(recipient, p.Distance, 3)
|
||||
response := &nodesV5{ReqID: p.ReqID, Total: 1, Nodes: nodesToRecords(nodes)}
|
||||
test.packetInFrom(key, to, response)
|
||||
case *v5wire.Ping:
|
||||
test.packetInFrom(key, to, &v5wire.Pong{ReqID: p.ReqID})
|
||||
case *v5wire.Findnode:
|
||||
if asked[recipient.ID()] {
|
||||
t.Error("Asked node", recipient.ID(), "twice")
|
||||
}
|
||||
asked[recipient.ID()] = true
|
||||
nodes := lookupTestnet.neighborsAtDistances(recipient, p.Distances, 16)
|
||||
t.Logf("Got FINDNODE for %v, returning %d nodes", p.Distances, len(nodes))
|
||||
for _, resp := range packNodes(p.ReqID, nodes) {
|
||||
test.packetInFrom(key, to, resp)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Verify result nodes.
|
||||
checkLookupResults(t, lookupTestnet, <-resultC)
|
||||
results := <-resultC
|
||||
checkLookupResults(t, lookupTestnet, results)
|
||||
}
|
||||
|
||||
// This test checks the local node can be utilised to set key-values.
|
||||
@ -481,6 +611,7 @@ type udpV5Test struct {
|
||||
nodesByIP map[string]*enode.LocalNode
|
||||
}
|
||||
|
||||
// testCodec is the packet encoding used by protocol tests. This codec does not perform encryption.
|
||||
type testCodec struct {
|
||||
test *udpV5Test
|
||||
id enode.ID
|
||||
@ -489,46 +620,44 @@ type testCodec struct {
|
||||
|
||||
type testCodecFrame struct {
|
||||
NodeID enode.ID
|
||||
AuthTag []byte
|
||||
AuthTag v5wire.Nonce
|
||||
Ptype byte
|
||||
Packet rlp.RawValue
|
||||
}
|
||||
|
||||
func (c *testCodec) encode(toID enode.ID, addr string, p packetV5, _ *whoareyouV5) ([]byte, []byte, error) {
|
||||
func (c *testCodec) Encode(toID enode.ID, addr string, p v5wire.Packet, _ *v5wire.Whoareyou) ([]byte, v5wire.Nonce, error) {
|
||||
c.ctr++
|
||||
authTag := make([]byte, 8)
|
||||
binary.BigEndian.PutUint64(authTag, c.ctr)
|
||||
var authTag v5wire.Nonce
|
||||
binary.BigEndian.PutUint64(authTag[:], c.ctr)
|
||||
|
||||
penc, _ := rlp.EncodeToBytes(p)
|
||||
frame, err := rlp.EncodeToBytes(testCodecFrame{c.id, authTag, p.kind(), penc})
|
||||
frame, err := rlp.EncodeToBytes(testCodecFrame{c.id, authTag, p.Kind(), penc})
|
||||
return frame, authTag, err
|
||||
}
|
||||
|
||||
func (c *testCodec) decode(input []byte, addr string) (enode.ID, *enode.Node, packetV5, error) {
|
||||
func (c *testCodec) Decode(input []byte, addr string) (enode.ID, *enode.Node, v5wire.Packet, error) {
|
||||
frame, p, err := c.decodeFrame(input)
|
||||
if err != nil {
|
||||
return enode.ID{}, nil, nil, err
|
||||
}
|
||||
if p.kind() == p_whoareyouV5 {
|
||||
frame.NodeID = enode.ID{} // match wireCodec behavior
|
||||
}
|
||||
return frame.NodeID, nil, p, nil
|
||||
}
|
||||
|
||||
func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p packetV5, err error) {
|
||||
func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p v5wire.Packet, err error) {
|
||||
if err = rlp.DecodeBytes(input, &frame); err != nil {
|
||||
return frame, nil, fmt.Errorf("invalid frame: %v", err)
|
||||
}
|
||||
switch frame.Ptype {
|
||||
case p_unknownV5:
|
||||
dec := new(unknownV5)
|
||||
case v5wire.UnknownPacket:
|
||||
dec := new(v5wire.Unknown)
|
||||
err = rlp.DecodeBytes(frame.Packet, &dec)
|
||||
p = dec
|
||||
case p_whoareyouV5:
|
||||
dec := new(whoareyouV5)
|
||||
case v5wire.WhoareyouPacket:
|
||||
dec := new(v5wire.Whoareyou)
|
||||
err = rlp.DecodeBytes(frame.Packet, &dec)
|
||||
p = dec
|
||||
default:
|
||||
p, err = decodePacketBodyV5(frame.Ptype, frame.Packet)
|
||||
p, err = v5wire.DecodeMessage(frame.Ptype, frame.Packet)
|
||||
}
|
||||
return frame, p, err
|
||||
}
|
||||
@ -561,20 +690,20 @@ func newUDPV5Test(t *testing.T) *udpV5Test {
|
||||
}
|
||||
|
||||
// handles a packet as if it had been sent to the transport.
|
||||
func (test *udpV5Test) packetIn(packet packetV5) {
|
||||
func (test *udpV5Test) packetIn(packet v5wire.Packet) {
|
||||
test.t.Helper()
|
||||
test.packetInFrom(test.remotekey, test.remoteaddr, packet)
|
||||
}
|
||||
|
||||
// handles a packet as if it had been sent to the transport by the key/endpoint.
|
||||
func (test *udpV5Test) packetInFrom(key *ecdsa.PrivateKey, addr *net.UDPAddr, packet packetV5) {
|
||||
func (test *udpV5Test) packetInFrom(key *ecdsa.PrivateKey, addr *net.UDPAddr, packet v5wire.Packet) {
|
||||
test.t.Helper()
|
||||
|
||||
ln := test.getNode(key, addr)
|
||||
codec := &testCodec{test: test, id: ln.ID()}
|
||||
enc, _, err := codec.encode(test.udp.Self().ID(), addr.String(), packet, nil)
|
||||
enc, _, err := codec.Encode(test.udp.Self().ID(), addr.String(), packet, nil)
|
||||
if err != nil {
|
||||
test.t.Errorf("%s encode error: %v", packet.name(), err)
|
||||
test.t.Errorf("%s encode error: %v", packet.Name(), err)
|
||||
}
|
||||
if test.udp.dispatchReadPacket(addr, enc) {
|
||||
<-test.udp.readNextCh // unblock UDPv5.dispatch
|
||||
@ -596,8 +725,12 @@ func (test *udpV5Test) getNode(key *ecdsa.PrivateKey, addr *net.UDPAddr) *enode.
|
||||
return ln
|
||||
}
|
||||
|
||||
// waitPacketOut waits for the next output packet and handles it using the given 'validate'
|
||||
// function. The function must be of type func (X, *net.UDPAddr, v5wire.Nonce) where X is
|
||||
// assignable to packetV5.
|
||||
func (test *udpV5Test) waitPacketOut(validate interface{}) (closed bool) {
|
||||
test.t.Helper()
|
||||
|
||||
fn := reflect.ValueOf(validate)
|
||||
exptype := fn.Type().In(0)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user