go-ethereum: github.com/ethereum/go-ethereum/p2p/discv5 Index | Examples | Files

package discv5

import "github.com/ethereum/go-ethereum/p2p/discv5"

Package discv5 is a prototype implementation of Discvery v5. Deprecated: do not use this package.

Index

Examples

Package Files

database.go metrics.go net.go node.go nodeevent_string.go table.go ticket.go topic.go udp.go

Constants

const Version = 4

type Network Uses

type Network struct {
    // contains filtered or unexported fields
}

Network manages the table and all protocol interaction.

func ListenUDP Uses

func ListenUDP(priv *ecdsa.PrivateKey, conn conn, nodeDBPath string, netrestrict *netutil.Netlist) (*Network, error)

ListenUDP returns a new table that listens for UDP packets on laddr.

func (*Network) Close Uses

func (net *Network) Close()

Close terminates the network listener and flushes the node database.

func (*Network) Lookup Uses

func (net *Network) Lookup(targetID NodeID) []*Node

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 (*Network) ReadRandomNodes Uses

func (net *Network) ReadRandomNodes(buf []*Node) (n int)

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 (*Network) RegisterTopic Uses

func (net *Network) RegisterTopic(topic Topic, stop <-chan struct{})

func (*Network) Resolve Uses

func (net *Network) Resolve(targetID NodeID) *Node

Resolve searches for a specific node with the given ID. It returns nil if the node could not be found.

func (*Network) SearchTopic Uses

func (net *Network) SearchTopic(topic Topic, setPeriod <-chan time.Duration, found chan<- *Node, lookup chan<- bool)

func (*Network) Self Uses

func (net *Network) Self() *Node

Self returns the local node. The returned node should not be modified by the caller.

func (*Network) SetFallbackNodes Uses

func (net *Network) SetFallbackNodes(nodes []*Node) error

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.

type Node Uses

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
    // contains filtered or unexported fields
}

Node represents a host on the network. The public fields of Node may not be modified.

func MustParseNode Uses

func MustParseNode(rawurl string) *Node

MustParseNode parses a node URL. It panics if the URL is not valid.

func NewNode Uses

func NewNode(id NodeID, ip net.IP, udpPort, tcpPort uint16) *Node

NewNode creates a new node. It is mostly meant to be used for testing purposes.

Code:

package main

import (
    "fmt"
    "math/big"
    "math/rand"
    "net"
    "reflect"
    "strings"
    "testing"
    "testing/quick"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/crypto"
)

func main() {
    id := MustHexID("1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439")

    // Complete nodes contain UDP and TCP endpoints:
    n1 := NewNode(id, net.ParseIP("2001:db8:3c4d:15::abcd:ef12"), 52150, 30303)
    fmt.Println("n1:", n1)
    fmt.Println("n1.Incomplete() ->", n1.Incomplete())

    // An incomplete node can be created by passing zero values
    // for all parameters except id.
    n2 := NewNode(id, nil, 0, 0)
    fmt.Println("n2:", n2)
    fmt.Println("n2.Incomplete() ->", n2.Incomplete())

}

var parseNodeTests = []struct {
    rawurl     string
    wantError  string
    wantResult *Node
}{
    {
        rawurl:    "http://foobar",
        wantError: `invalid URL scheme, want "enode"`,
    },
    {
        rawurl:    "enode://01010101@123.124.125.126:3",
        wantError: `invalid node ID (wrong length, want 128 hex chars)`,
    },
    // Complete nodes with IP address.
    {
        rawurl:    "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@hostname:3",
        wantError: `invalid IP address`,
    },
    {
        rawurl:    "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo",
        wantError: `invalid port`,
    },
    {
        rawurl:    "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo",
        wantError: `invalid discport in query`,
    },
    {
        rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:52150",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            net.IP{0x7f, 0x0, 0x0, 0x1},
            52150,
            52150,
        ),
    },
    {
        rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@[::]:52150",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            net.ParseIP("::"),
            52150,
            52150,
        ),
    },
    {
        rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@[2001:db8:3c4d:15::abcd:ef12]:52150",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            net.ParseIP("2001:db8:3c4d:15::abcd:ef12"),
            52150,
            52150,
        ),
    },
    {
        rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:52150?discport=22334",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            net.IP{0x7f, 0x0, 0x0, 0x1},
            22334,
            52150,
        ),
    },
    // Incomplete nodes with no address.
    {
        rawurl: "1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            nil, 0, 0,
        ),
    },
    {
        rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439",
        wantResult: NewNode(
            MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"),
            nil, 0, 0,
        ),
    },
    // Invalid URLs
    {
        rawurl:    "01010101",
        wantError: `invalid node ID (wrong length, want 128 hex chars)`,
    },
    {
        rawurl:    "enode://01010101",
        wantError: `invalid node ID (wrong length, want 128 hex chars)`,
    },
    {
        // This test checks that errors from url.Parse are handled.
        rawurl:    "://foo",
        wantError: `missing protocol scheme`,
    },
}

func TestParseNode(t *testing.T) {
    for _, test := range parseNodeTests {
        n, err := ParseNode(test.rawurl)
        if test.wantError != "" {
            if err == nil {
                t.Errorf("test %q:\n  got nil error, expected %#q", test.rawurl, test.wantError)
                continue
            } else if !strings.Contains(err.Error(), test.wantError) {
                t.Errorf("test %q:\n  got error %#q, expected %#q", test.rawurl, err.Error(), test.wantError)
                continue
            }
        } else {
            if err != nil {
                t.Errorf("test %q:\n  unexpected error: %v", test.rawurl, err)
                continue
            }
            if !reflect.DeepEqual(n, test.wantResult) {
                t.Errorf("test %q:\n  result mismatch:\ngot:  %#v, want: %#v", test.rawurl, n, test.wantResult)
            }
        }
    }
}

func TestNodeString(t *testing.T) {
    for i, test := range parseNodeTests {
        if test.wantError == "" && strings.HasPrefix(test.rawurl, "enode://") {
            str := test.wantResult.String()
            if str != test.rawurl {
                t.Errorf("test %d: Node.String() mismatch:\ngot:  %s\nwant: %s", i, str, test.rawurl)
            }
        }
    }
}

func TestHexID(t *testing.T) {
    ref := NodeID{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 106, 217, 182, 31, 165, 174, 1, 67, 7, 235, 220, 150, 66, 83, 173, 205, 159, 44, 10, 57, 42, 161, 26, 188}
    id1 := MustHexID("0x000000000000000000000000000000000000000000000000000000000000000000000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc")
    id2 := MustHexID("000000000000000000000000000000000000000000000000000000000000000000000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc")

    if id1 != ref {
        t.Errorf("wrong id1\ngot  %v\nwant %v", id1[:], ref[:])
    }
    if id2 != ref {
        t.Errorf("wrong id2\ngot  %v\nwant %v", id2[:], ref[:])
    }
}

func TestNodeID_recover(t *testing.T) {
    prv := newkey()
    hash := make([]byte, 32)
    sig, err := crypto.Sign(hash, prv)
    if err != nil {
        t.Fatalf("signing error: %v", err)
    }

    pub := PubkeyID(&prv.PublicKey)
    recpub, err := recoverNodeID(hash, sig)
    if err != nil {
        t.Fatalf("recovery error: %v", err)
    }
    if pub != recpub {
        t.Errorf("recovered wrong pubkey:\ngot:  %v\nwant: %v", recpub, pub)
    }

    ecdsa, err := pub.Pubkey()
    if err != nil {
        t.Errorf("Pubkey error: %v", err)
    }
    if !reflect.DeepEqual(ecdsa, &prv.PublicKey) {
        t.Errorf("Pubkey mismatch:\n  got:  %#v\n  want: %#v", ecdsa, &prv.PublicKey)
    }
}

func TestNodeID_pubkeyBad(t *testing.T) {
    ecdsa, err := NodeID{}.Pubkey()
    if err == nil {
        t.Error("expected error for zero ID")
    }
    if ecdsa != nil {
        t.Error("expected nil result")
    }
}

func TestNodeID_distcmp(t *testing.T) {
    distcmpBig := func(target, a, b common.Hash) int {
        tbig := new(big.Int).SetBytes(target[:])
        abig := new(big.Int).SetBytes(a[:])
        bbig := new(big.Int).SetBytes(b[:])
        return new(big.Int).Xor(tbig, abig).Cmp(new(big.Int).Xor(tbig, bbig))
    }
    if err := quick.CheckEqual(distcmp, distcmpBig, quickcfg()); err != nil {
        t.Error(err)
    }
}

// the random tests is likely to miss the case where they're equal.
func TestNodeID_distcmpEqual(t *testing.T) {
    base := common.Hash{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
    x := common.Hash{15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    if distcmp(base, x, x) != 0 {
        t.Errorf("distcmp(base, x, x) != 0")
    }
}

func TestNodeID_logdist(t *testing.T) {
    logdistBig := func(a, b common.Hash) int {
        abig, bbig := new(big.Int).SetBytes(a[:]), new(big.Int).SetBytes(b[:])
        return new(big.Int).Xor(abig, bbig).BitLen()
    }
    if err := quick.CheckEqual(logdist, logdistBig, quickcfg()); err != nil {
        t.Error(err)
    }
}

// the random tests is likely to miss the case where they're equal.
func TestNodeID_logdistEqual(t *testing.T) {
    x := common.Hash{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
    if logdist(x, x) != 0 {
        t.Errorf("logdist(x, x) != 0")
    }
}

func TestNodeID_hashAtDistance(t *testing.T) {
    // we don't use quick.Check here because its output isn't
    // very helpful when the test fails.
    cfg := quickcfg()
    for i := 0; i < cfg.MaxCount; i++ {
        a := gen(common.Hash{}, cfg.Rand).(common.Hash)
        dist := cfg.Rand.Intn(len(common.Hash{}) * 8)
        result := hashAtDistance(a, dist)
        actualdist := logdist(result, a)

        if dist != actualdist {
            t.Log("a:     ", a)
            t.Log("result:", result)
            t.Fatalf("#%d: distance of result is %d, want %d", i, actualdist, dist)
        }
    }
}

func quickcfg() *quick.Config {
    return &quick.Config{
        MaxCount: 5000,
        Rand:     rand.New(rand.NewSource(time.Now().Unix())),
    }
}

// TODO: The Generate method can be dropped when we require Go >= 1.5
// because testing/quick learned to generate arrays in 1.5.

func (NodeID) Generate(rand *rand.Rand, size int) reflect.Value {
    var id NodeID
    m := rand.Intn(len(id))
    for i := len(id) - 1; i > m; i-- {
        id[i] = byte(rand.Uint32())
    }
    return reflect.ValueOf(id)
}

func ParseNode Uses

func ParseNode(rawurl string) (*Node, error)

ParseNode parses a node designator.

There are two basic forms of node designators

- incomplete nodes, which only have the public key (node ID)
- complete nodes, which contain the public key and IP/Port information

For incomplete nodes, the designator must look like one of these

enode://<hex node id>
<hex node id>

For complete nodes, the node ID is encoded in the username portion of the URL, separated from the host by an @ sign. The hostname can only be given as an IP address, DNS domain names are not allowed. The port in the host name section is the TCP listening port. If the TCP and UDP (discovery) ports differ, the UDP port is specified as query parameter "discport".

In the following example, the node URL describes a node with IP address 10.3.58.6, TCP listening port 30303 and UDP discovery port 30301.

enode://<hex node id>@10.3.58.6:30303?discport=30301

func (*Node) Incomplete Uses

func (n *Node) Incomplete() bool

Incomplete returns true for nodes with no IP address.

func (*Node) MarshalText Uses

func (n *Node) MarshalText() ([]byte, error)

MarshalText implements encoding.TextMarshaler.

func (*Node) String Uses

func (n *Node) String() string

The string representation of a Node is a URL. Please see ParseNode for a description of the format.

func (*Node) UnmarshalText Uses

func (n *Node) UnmarshalText(text []byte) error

UnmarshalText implements encoding.TextUnmarshaler.

type NodeID Uses

type NodeID [nodeIDBits / 8]byte

NodeID is a unique identifier for each node. The node identifier is a marshaled elliptic curve public key.

func HexID Uses

func HexID(in string) (NodeID, error)

HexID converts a hex string to a NodeID. The string may be prefixed with 0x.

func MustHexID Uses

func MustHexID(in string) NodeID

MustHexID converts a hex string to a NodeID. It panics if the string is not a valid NodeID.

func PubkeyID Uses

func PubkeyID(pub *ecdsa.PublicKey) NodeID

PubkeyID returns a marshaled representation of the given public key.

func (NodeID) GoString Uses

func (n NodeID) GoString() string

The Go syntax representation of a NodeID is a call to HexID.

func (NodeID) Pubkey Uses

func (n NodeID) Pubkey() (*ecdsa.PublicKey, error)

Pubkey returns the public key represented by the node ID. It returns an error if the ID is not a point on the curve.

func (NodeID) String Uses

func (n NodeID) String() string

NodeID prints as a long hexadecimal number.

func (NodeID) TerminalString Uses

func (n NodeID) TerminalString() string

TerminalString returns a shortened hex string for terminal logging.

type Table Uses

type Table struct {
    // contains filtered or unexported fields
}

type Topic Uses

type Topic string

Package discv5 imports 35 packages (graph) and is imported by 518 packages. Updated 2020-04-08. Refresh now. Tools for package owners.