forked from cerc-io/plugeth
9123eceb0f
* p2p: add DialRatio for configuration of inbound vs. dialed connections * p2p: add connection flags to PeerInfo * p2p/netutil: add SameNet, DistinctNetSet * p2p/discover: improve revalidation and seeding This changes node revalidation to be periodic instead of on-demand. This should prevent issues where dead nodes get stuck in closer buckets because no other node will ever come along to replace them. Every 5 seconds (on average), the last node in a random bucket is checked and moved to the front of the bucket if it is still responding. If revalidation fails, the last node is replaced by an entry of the 'replacement list' containing recently-seen nodes. Most close buckets are removed because it's very unlikely we'll ever encounter a node that would fall into any of those buckets. Table seeding is also improved: we now require a few minutes of table membership before considering a node as a potential seed node. This should make it less likely to store short-lived nodes as potential seeds. * p2p/discover: fix nits in UDP transport We would skip sending neighbors replies if there were fewer than maxNeighbors results and CheckRelayIP returned an error for the last one. While here, also resolve a TODO about pong reply tokens.
263 lines
6.2 KiB
Go
263 lines
6.2 KiB
Go
// 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 netutil
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"reflect"
|
|
"testing"
|
|
"testing/quick"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
)
|
|
|
|
func TestParseNetlist(t *testing.T) {
|
|
var tests = []struct {
|
|
input string
|
|
wantErr error
|
|
wantList *Netlist
|
|
}{
|
|
{
|
|
input: "",
|
|
wantList: &Netlist{},
|
|
},
|
|
{
|
|
input: "127.0.0.0/8",
|
|
wantErr: nil,
|
|
wantList: &Netlist{{IP: net.IP{127, 0, 0, 0}, Mask: net.CIDRMask(8, 32)}},
|
|
},
|
|
{
|
|
input: "127.0.0.0/44",
|
|
wantErr: &net.ParseError{Type: "CIDR address", Text: "127.0.0.0/44"},
|
|
},
|
|
{
|
|
input: "127.0.0.0/16, 23.23.23.23/24,",
|
|
wantList: &Netlist{
|
|
{IP: net.IP{127, 0, 0, 0}, Mask: net.CIDRMask(16, 32)},
|
|
{IP: net.IP{23, 23, 23, 0}, Mask: net.CIDRMask(24, 32)},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
l, err := ParseNetlist(test.input)
|
|
if !reflect.DeepEqual(err, test.wantErr) {
|
|
t.Errorf("%q: got error %q, want %q", test.input, err, test.wantErr)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(l, test.wantList) {
|
|
spew.Dump(l)
|
|
spew.Dump(test.wantList)
|
|
t.Errorf("%q: got %v, want %v", test.input, l, test.wantList)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNilNetListContains(t *testing.T) {
|
|
var list *Netlist
|
|
checkContains(t, list.Contains, nil, []string{"1.2.3.4"})
|
|
}
|
|
|
|
func TestIsLAN(t *testing.T) {
|
|
checkContains(t, IsLAN,
|
|
[]string{ // included
|
|
"0.0.0.0",
|
|
"0.2.0.8",
|
|
"127.0.0.1",
|
|
"10.0.1.1",
|
|
"10.22.0.3",
|
|
"172.31.252.251",
|
|
"192.168.1.4",
|
|
"fe80::f4a1:8eff:fec5:9d9d",
|
|
"febf::ab32:2233",
|
|
"fc00::4",
|
|
},
|
|
[]string{ // excluded
|
|
"192.0.2.1",
|
|
"1.0.0.0",
|
|
"172.32.0.1",
|
|
"fec0::2233",
|
|
},
|
|
)
|
|
}
|
|
|
|
func TestIsSpecialNetwork(t *testing.T) {
|
|
checkContains(t, IsSpecialNetwork,
|
|
[]string{ // included
|
|
"192.0.2.1",
|
|
"192.0.2.44",
|
|
"2001:db8:85a3:8d3:1319:8a2e:370:7348",
|
|
"255.255.255.255",
|
|
"224.0.0.22", // IPv4 multicast
|
|
"ff05::1:3", // IPv6 multicast
|
|
},
|
|
[]string{ // excluded
|
|
"192.0.3.1",
|
|
"1.0.0.0",
|
|
"172.32.0.1",
|
|
"fec0::2233",
|
|
},
|
|
)
|
|
}
|
|
|
|
func checkContains(t *testing.T, fn func(net.IP) bool, inc, exc []string) {
|
|
for _, s := range inc {
|
|
if !fn(parseIP(s)) {
|
|
t.Error("returned false for included address", s)
|
|
}
|
|
}
|
|
for _, s := range exc {
|
|
if fn(parseIP(s)) {
|
|
t.Error("returned true for excluded address", s)
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseIP(s string) net.IP {
|
|
ip := net.ParseIP(s)
|
|
if ip == nil {
|
|
panic("invalid " + s)
|
|
}
|
|
return ip
|
|
}
|
|
|
|
func TestCheckRelayIP(t *testing.T) {
|
|
tests := []struct {
|
|
sender, addr string
|
|
want error
|
|
}{
|
|
{"127.0.0.1", "0.0.0.0", errUnspecified},
|
|
{"192.168.0.1", "0.0.0.0", errUnspecified},
|
|
{"23.55.1.242", "0.0.0.0", errUnspecified},
|
|
{"127.0.0.1", "255.255.255.255", errSpecial},
|
|
{"192.168.0.1", "255.255.255.255", errSpecial},
|
|
{"23.55.1.242", "255.255.255.255", errSpecial},
|
|
{"192.168.0.1", "127.0.2.19", errLoopback},
|
|
{"23.55.1.242", "192.168.0.1", errLAN},
|
|
|
|
{"127.0.0.1", "127.0.2.19", nil},
|
|
{"127.0.0.1", "192.168.0.1", nil},
|
|
{"127.0.0.1", "23.55.1.242", nil},
|
|
{"192.168.0.1", "192.168.0.1", nil},
|
|
{"192.168.0.1", "23.55.1.242", nil},
|
|
{"23.55.1.242", "23.55.1.242", nil},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
err := CheckRelayIP(parseIP(test.sender), parseIP(test.addr))
|
|
if err != test.want {
|
|
t.Errorf("%s from %s: got %q, want %q", test.addr, test.sender, err, test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkCheckRelayIP(b *testing.B) {
|
|
sender := parseIP("23.55.1.242")
|
|
addr := parseIP("23.55.1.2")
|
|
for i := 0; i < b.N; i++ {
|
|
CheckRelayIP(sender, addr)
|
|
}
|
|
}
|
|
|
|
func TestSameNet(t *testing.T) {
|
|
tests := []struct {
|
|
ip, other string
|
|
bits uint
|
|
want bool
|
|
}{
|
|
{"0.0.0.0", "0.0.0.0", 32, true},
|
|
{"0.0.0.0", "0.0.0.1", 0, true},
|
|
{"0.0.0.0", "0.0.0.1", 31, true},
|
|
{"0.0.0.0", "0.0.0.1", 32, false},
|
|
{"0.33.0.1", "0.34.0.2", 8, true},
|
|
{"0.33.0.1", "0.34.0.2", 13, true},
|
|
{"0.33.0.1", "0.34.0.2", 15, false},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if ok := SameNet(test.bits, parseIP(test.ip), parseIP(test.other)); ok != test.want {
|
|
t.Errorf("SameNet(%d, %s, %s) == %t, want %t", test.bits, test.ip, test.other, ok, test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func ExampleSameNet() {
|
|
// This returns true because the IPs are in the same /24 network:
|
|
fmt.Println(SameNet(24, net.IP{127, 0, 0, 1}, net.IP{127, 0, 0, 3}))
|
|
// This call returns false:
|
|
fmt.Println(SameNet(24, net.IP{127, 3, 0, 1}, net.IP{127, 5, 0, 3}))
|
|
// Output:
|
|
// true
|
|
// false
|
|
}
|
|
|
|
func TestDistinctNetSet(t *testing.T) {
|
|
ops := []struct {
|
|
add, remove string
|
|
fails bool
|
|
}{
|
|
{add: "127.0.0.1"},
|
|
{add: "127.0.0.2"},
|
|
{add: "127.0.0.3", fails: true},
|
|
{add: "127.32.0.1"},
|
|
{add: "127.32.0.2"},
|
|
{add: "127.32.0.3", fails: true},
|
|
{add: "127.33.0.1", fails: true},
|
|
{add: "127.34.0.1"},
|
|
{add: "127.34.0.2"},
|
|
{add: "127.34.0.3", fails: true},
|
|
// Make room for an address, then add again.
|
|
{remove: "127.0.0.1"},
|
|
{add: "127.0.0.3"},
|
|
{add: "127.0.0.3", fails: true},
|
|
}
|
|
|
|
set := DistinctNetSet{Subnet: 15, Limit: 2}
|
|
for _, op := range ops {
|
|
var desc string
|
|
if op.add != "" {
|
|
desc = fmt.Sprintf("Add(%s)", op.add)
|
|
if ok := set.Add(parseIP(op.add)); ok != !op.fails {
|
|
t.Errorf("%s == %t, want %t", desc, ok, !op.fails)
|
|
}
|
|
} else {
|
|
desc = fmt.Sprintf("Remove(%s)", op.remove)
|
|
set.Remove(parseIP(op.remove))
|
|
}
|
|
t.Logf("%s: %v", desc, set)
|
|
}
|
|
}
|
|
|
|
func TestDistinctNetSetAddRemove(t *testing.T) {
|
|
cfg := &quick.Config{}
|
|
fn := func(ips []net.IP) bool {
|
|
s := DistinctNetSet{Limit: 3, Subnet: 2}
|
|
for _, ip := range ips {
|
|
s.Add(ip)
|
|
}
|
|
for _, ip := range ips {
|
|
s.Remove(ip)
|
|
}
|
|
return s.Len() == 0
|
|
}
|
|
|
|
if err := quick.Check(fn, cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|