forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 10:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

whisper/whisperv5, whisper/whisperv6: port to p2p/enode

Browse source 
This port was easy because whisper uses []byte for node IDs and
URL strings in the API.
This commit is contained in:
Felix Lange 2018-09-11 18:20:54 +02:00
parent 81f98e8a08
commit 063803074f
4 changed files with 22 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
whisper/whisperv5/api.go
View file

@ -28,7 +28,7 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
) )
@ -96,12 +96,12 @@ func (api *PublicWhisperAPI) SetMinPoW(ctx context.Context, pow float64) (bool,
// MarkTrustedPeer marks a peer trusted. , which will allow it to send historic (expired) messages. // MarkTrustedPeer marks a peer trusted. , which will allow it to send historic (expired) messages.
// Note: This function is not adding new nodes, the node needs to exists as a peer. // Note: This function is not adding new nodes, the node needs to exists as a peer.
func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, enode string) (bool, error) { func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, url string) (bool, error) {
n, err := discover.ParseNode(enode) n, err := enode.ParseV4(url)
if err != nil { if err != nil {
return false, err return false, err
} }
return true, api.w.AllowP2PMessagesFromPeer(n.ID[:]) return true, api.w.AllowP2PMessagesFromPeer(n.ID().Bytes())
} }
// NewKeyPair generates a new public and private key pair for message decryption and encryption. // NewKeyPair generates a new public and private key pair for message decryption and encryption.
@ -270,11 +270,11 @@ func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (bool, er
// send to specific node (skip PoW check) // send to specific node (skip PoW check)
if len(req.TargetPeer) > 0 { if len(req.TargetPeer) > 0 {
n, err := discover.ParseNode(req.TargetPeer) n, err := enode.ParseV4(req.TargetPeer)
if err != nil { if err != nil {
return false, fmt.Errorf("failed to parse target peer: %s", err) return false, fmt.Errorf("failed to parse target peer: %s", err)
} }
return true, api.w.SendP2PMessage(n.ID[:], env) return true, api.w.SendP2PMessage(n.ID().Bytes(), env)
} }
// ensure that the message PoW meets the node's minimum accepted PoW // ensure that the message PoW meets the node's minimum accepted PoW

5
whisper/whisperv5/peer_test.go
View file

@ -27,7 +27,7 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/nat" "github.com/ethereum/go-ethereum/p2p/nat"
) )
@ -146,8 +146,7 @@ func initialize(t *testing.T) {
peerNodeId := nodes[j].id peerNodeId := nodes[j].id
address, _ := net.ResolveTCPAddr("tcp", nodes[j].server.ListenAddr) address, _ := net.ResolveTCPAddr("tcp", nodes[j].server.ListenAddr)
peerPort := uint16(address.Port) peerPort := uint16(address.Port)
peerNode := discover.PubkeyID(&peerNodeId.PublicKey) peer := enode.NewV4(&peerNodeId.PublicKey, address.IP, int(peerPort), int(peerPort))
peer := discover.NewNode(peerNode, address.IP, peerPort, peerPort)
node.server.AddPeer(peer) node.server.AddPeer(peer)
} }

12
whisper/whisperv6/api.go
View file

@ -28,7 +28,7 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
) )
@ -102,12 +102,12 @@ func (api *PublicWhisperAPI) SetBloomFilter(ctx context.Context, bloom hexutil.B
// MarkTrustedPeer marks a peer trusted, which will allow it to send historic (expired) messages. // MarkTrustedPeer marks a peer trusted, which will allow it to send historic (expired) messages.
// Note: This function is not adding new nodes, the node needs to exists as a peer. // Note: This function is not adding new nodes, the node needs to exists as a peer.
func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, enode string) (bool, error) { func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, url string) (bool, error) {
n, err := discover.ParseNode(enode) n, err := enode.ParseV4(url)
if err != nil { if err != nil {
return false, err return false, err
} }
return true, api.w.AllowP2PMessagesFromPeer(n.ID[:]) return true, api.w.AllowP2PMessagesFromPeer(n.ID().Bytes())
} }
// NewKeyPair generates a new public and private key pair for message decryption and encryption. // NewKeyPair generates a new public and private key pair for message decryption and encryption.
@ -291,11 +291,11 @@ func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (hexutil.
// send to specific node (skip PoW check) // send to specific node (skip PoW check)
if len(req.TargetPeer) > 0 { if len(req.TargetPeer) > 0 {
n, err := discover.ParseNode(req.TargetPeer) n, err := enode.ParseV4(req.TargetPeer)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to parse target peer: %s", err) return nil, fmt.Errorf("failed to parse target peer: %s", err)
} }
err = api.w.SendP2PMessage(n.ID[:], env) err = api.w.SendP2PMessage(n.ID().Bytes(), env)
if err == nil { if err == nil {
hash := env.Hash() hash := env.Hash()
result = hash[:] result = hash[:]

18
whisper/whisperv6/peer_test.go
View file

@ -32,7 +32,7 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/nat" "github.com/ethereum/go-ethereum/p2p/nat"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
) )
@ -223,9 +223,7 @@ func initialize(t *testing.T) {
for j := 0; j < i; j++ { for j := 0; j < i; j++ {
peerNodeId := nodes[j].id peerNodeId := nodes[j].id
address, _ := net.ResolveTCPAddr("tcp", nodes[j].server.ListenAddr) address, _ := net.ResolveTCPAddr("tcp", nodes[j].server.ListenAddr)
peerPort := uint16(address.Port) peer := enode.NewV4(&peerNodeId.PublicKey, address.IP, address.Port, address.Port)
peerNode := discover.PubkeyID(&peerNodeId.PublicKey)
peer := discover.NewNode(peerNode, address.IP, peerPort, peerPort)
nodes[i].server.AddPeer(peer) nodes[i].server.AddPeer(peer)
} }
} }
@ -433,7 +431,7 @@ func checkPowExchangeForNodeZeroOnce(t *testing.T, mustPass bool) bool {
cnt := 0 cnt := 0
for i, node := range nodes { for i, node := range nodes {
for peer := range node.shh.peers { for peer := range node.shh.peers {
if peer.peer.ID() == discover.PubkeyID(&nodes[0].id.PublicKey) { if peer.peer.ID() == nodes[0].server.Self().ID() {
cnt++ cnt++
if peer.powRequirement != masterPow { if peer.powRequirement != masterPow {
if mustPass { if mustPass {
@ -454,7 +452,7 @@ func checkPowExchangeForNodeZeroOnce(t *testing.T, mustPass bool) bool {
func checkPowExchange(t *testing.T) { func checkPowExchange(t *testing.T) {
for i, node := range nodes { for i, node := range nodes {
for peer := range node.shh.peers { for peer := range node.shh.peers {
if peer.peer.ID() != discover.PubkeyID(&nodes[0].id.PublicKey) { if peer.peer.ID() != nodes[0].server.Self().ID() {
if peer.powRequirement != masterPow { if peer.powRequirement != masterPow {
t.Fatalf("node %d: failed to exchange pow requirement in round %d; expected %f, got %f", t.Fatalf("node %d: failed to exchange pow requirement in round %d; expected %f, got %f",
i, round, masterPow, peer.powRequirement) i, round, masterPow, peer.powRequirement)
@ -512,7 +510,7 @@ func waitForServersToStart(t *testing.T) {
//two generic whisper node handshake //two generic whisper node handshake
func TestPeerHandshakeWithTwoFullNode(t *testing.T) { func TestPeerHandshakeWithTwoFullNode(t *testing.T) {
w1 := Whisper{} w1 := Whisper{}
p1 := newPeer(&w1, p2p.NewPeer(discover.NodeID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), false}}) p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), false}})
err := p1.handshake() err := p1.handshake()
if err != nil { if err != nil {
t.Fatal() t.Fatal()
@ -522,7 +520,7 @@ func TestPeerHandshakeWithTwoFullNode(t *testing.T) {
//two generic whisper node handshake. one don't send light flag //two generic whisper node handshake. one don't send light flag
func TestHandshakeWithOldVersionWithoutLightModeFlag(t *testing.T) { func TestHandshakeWithOldVersionWithoutLightModeFlag(t *testing.T) {
w1 := Whisper{} w1 := Whisper{}
p1 := newPeer(&w1, p2p.NewPeer(discover.NodeID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize)}}) p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize)}})
err := p1.handshake() err := p1.handshake()
if err != nil { if err != nil {
t.Fatal() t.Fatal()
@ -534,7 +532,7 @@ func TestTwoLightPeerHandshakeRestrictionOff(t *testing.T) {
w1 := Whisper{} w1 := Whisper{}
w1.settings.Store(restrictConnectionBetweenLightClientsIdx, false) w1.settings.Store(restrictConnectionBetweenLightClientsIdx, false)
w1.SetLightClientMode(true) w1.SetLightClientMode(true)
p1 := newPeer(&w1, p2p.NewPeer(discover.NodeID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}}) p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}})
err := p1.handshake() err := p1.handshake()
if err != nil { if err != nil {
t.FailNow() t.FailNow()
@ -546,7 +544,7 @@ func TestTwoLightPeerHandshakeError(t *testing.T) {
w1 := Whisper{} w1 := Whisper{}
w1.settings.Store(restrictConnectionBetweenLightClientsIdx, true) w1.settings.Store(restrictConnectionBetweenLightClientsIdx, true)
w1.SetLightClientMode(true) w1.SetLightClientMode(true)
p1 := newPeer(&w1, p2p.NewPeer(discover.NodeID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}}) p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}})
err := p1.handshake() err := p1.handshake()
if err == nil { if err == nil {
t.FailNow() t.FailNow()