2019-10-09 15:32:15 -07:00
|
|
|
package zcash
|
|
|
|
|
|
|
|
import (
|
|
|
|
"log"
|
|
|
|
"net"
|
|
|
|
"os"
|
2019-10-16 19:18:30 -07:00
|
|
|
"strconv"
|
2019-10-09 15:32:15 -07:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
"github.com/btcsuite/btcd/addrmgr"
|
2019-10-09 15:32:15 -07:00
|
|
|
"github.com/btcsuite/btcd/peer"
|
|
|
|
"github.com/btcsuite/btcd/wire"
|
|
|
|
|
|
|
|
"github.com/gtank/coredns-zcash/zcash/network"
|
|
|
|
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
)
|
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
var (
|
|
|
|
ErrRepeatConnection = errors.New("attempted repeat connection to existing peer")
|
2019-10-12 19:00:20 -07:00
|
|
|
ErrNoSuchPeer = errors.New("no record of requested peer")
|
2019-10-16 19:18:30 -07:00
|
|
|
ErrAddressTimeout = errors.New("wait for addreses timed out")
|
2019-10-16 21:41:08 -07:00
|
|
|
ErrBlacklistedPeer = errors.New("peer is blacklisted")
|
2019-10-12 16:18:25 -07:00
|
|
|
)
|
|
|
|
|
2019-10-09 15:32:15 -07:00
|
|
|
var defaultPeerConfig = &peer.Config{
|
|
|
|
UserAgentName: "MagicBean",
|
|
|
|
UserAgentVersion: "2.0.7",
|
|
|
|
ChainParams: nil,
|
|
|
|
Services: 0,
|
|
|
|
TrickleInterval: time.Second * 10,
|
|
|
|
ProtocolVersion: 170009, // Blossom
|
|
|
|
}
|
|
|
|
|
|
|
|
type Seeder struct {
|
|
|
|
peer *peer.Peer
|
|
|
|
config *peer.Config
|
2019-10-12 09:42:16 -07:00
|
|
|
logger *log.Logger
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
// Peer list handling
|
|
|
|
peerState sync.RWMutex
|
2019-10-12 16:18:25 -07:00
|
|
|
handshakeSignals *sync.Map
|
|
|
|
pendingPeers *sync.Map
|
|
|
|
livePeers *sync.Map
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
// Address list handling
|
|
|
|
addrState sync.RWMutex
|
|
|
|
addrRecvCond *sync.Cond
|
|
|
|
addrList []*Address
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
2019-10-12 09:42:16 -07:00
|
|
|
func NewSeeder(network network.Network) (*Seeder, error) {
|
|
|
|
config, err := newSeederPeerConfig(network, defaultPeerConfig)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "could not construct seeder")
|
|
|
|
}
|
|
|
|
|
|
|
|
logger := log.New(os.Stdout, "zcash_seeder: ", log.Ldate|log.Ltime|log.Lshortfile|log.LUTC)
|
|
|
|
|
|
|
|
newSeeder := Seeder{
|
|
|
|
config: config,
|
|
|
|
logger: logger,
|
2019-10-12 16:18:25 -07:00
|
|
|
handshakeSignals: new(sync.Map),
|
|
|
|
pendingPeers: new(sync.Map),
|
|
|
|
livePeers: new(sync.Map),
|
2019-10-16 19:18:30 -07:00
|
|
|
addrList: make([]*Address, 0, 1000),
|
2019-10-12 09:42:16 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
newSeeder.addrRecvCond = sync.NewCond(&newSeeder.addrState)
|
|
|
|
|
2019-10-12 09:42:16 -07:00
|
|
|
newSeeder.config.Listeners.OnVerAck = newSeeder.onVerAck
|
2019-10-12 19:00:20 -07:00
|
|
|
newSeeder.config.Listeners.OnAddr = newSeeder.onAddr
|
2019-10-12 09:42:16 -07:00
|
|
|
|
|
|
|
return &newSeeder, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newTestSeeder(network network.Network) (*Seeder, error) {
|
|
|
|
config, err := newSeederPeerConfig(network, defaultPeerConfig)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "could not construct seeder")
|
|
|
|
}
|
|
|
|
|
|
|
|
sink, _ := os.OpenFile(os.DevNull, os.O_WRONLY, 0666)
|
|
|
|
logger := log.New(sink, "zcash_seeder: ", log.Ldate|log.Ltime|log.Lshortfile|log.LUTC)
|
|
|
|
|
|
|
|
// Allows connections to self for easy mocking
|
|
|
|
config.AllowSelfConns = true
|
|
|
|
|
|
|
|
newSeeder := Seeder{
|
|
|
|
config: config,
|
|
|
|
logger: logger,
|
2019-10-12 16:18:25 -07:00
|
|
|
handshakeSignals: new(sync.Map),
|
|
|
|
pendingPeers: new(sync.Map),
|
|
|
|
livePeers: new(sync.Map),
|
2019-10-16 19:18:30 -07:00
|
|
|
addrList: make([]*Address, 0, 1000),
|
2019-10-12 09:42:16 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
newSeeder.addrRecvCond = sync.NewCond(&newSeeder.addrState)
|
|
|
|
|
2019-10-12 09:42:16 -07:00
|
|
|
newSeeder.config.Listeners.OnVerAck = newSeeder.onVerAck
|
2019-10-12 19:00:20 -07:00
|
|
|
newSeeder.config.Listeners.OnAddr = newSeeder.onAddr
|
2019-10-12 09:42:16 -07:00
|
|
|
|
|
|
|
return &newSeeder, nil
|
|
|
|
}
|
|
|
|
|
2019-10-09 15:32:15 -07:00
|
|
|
func newSeederPeerConfig(magic network.Network, template *peer.Config) (*peer.Config, error) {
|
|
|
|
var newPeerConfig peer.Config
|
|
|
|
|
|
|
|
// Load the default values
|
|
|
|
if template != nil {
|
|
|
|
newPeerConfig = *template
|
|
|
|
}
|
|
|
|
|
|
|
|
params, err := network.GetNetworkParams(magic)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "couldn't construct peer config")
|
|
|
|
}
|
|
|
|
newPeerConfig.ChainParams = params
|
|
|
|
|
|
|
|
return &newPeerConfig, nil
|
|
|
|
}
|
|
|
|
|
2019-10-16 18:05:42 -07:00
|
|
|
// GetNetworkDefaultPort returns the default port of the network this seeder is configured for.
|
|
|
|
func (s *Seeder) GetNetworkDefaultPort() string {
|
|
|
|
return s.config.ChainParams.DefaultPort
|
|
|
|
}
|
|
|
|
|
2019-10-12 09:42:16 -07:00
|
|
|
func (s *Seeder) onVerAck(p *peer.Peer, msg *wire.MsgVerAck) {
|
2019-10-12 16:18:25 -07:00
|
|
|
// Check if we're expecting to hear from this peer
|
|
|
|
_, ok := s.pendingPeers.Load(p.Addr())
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
if !ok {
|
2019-10-12 09:42:16 -07:00
|
|
|
s.logger.Printf("Got verack from unexpected peer %s", p.Addr())
|
|
|
|
return
|
|
|
|
}
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
// Add to set of live peers
|
|
|
|
s.livePeers.Store(p.Addr(), p)
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
// Remove from set of pending peers
|
|
|
|
s.pendingPeers.Delete(p.Addr())
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
// Signal successful connection
|
|
|
|
if signal, ok := s.handshakeSignals.Load(p.Addr()); ok {
|
|
|
|
signal.(chan struct{}) <- struct{}{}
|
2019-10-16 19:18:30 -07:00
|
|
|
} else {
|
|
|
|
s.logger.Printf("Got verack from peer without a callback channel: %s", p.Addr())
|
|
|
|
s.DisconnectPeer(p.Addr())
|
2019-10-12 16:18:25 -07:00
|
|
|
return
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 21:41:08 -07:00
|
|
|
// Add to list of known good addresses if we don't already have it.
|
|
|
|
// Otherwise, update the last-valid time.
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
newAddr := &Address{
|
|
|
|
netaddr: p.NA(),
|
|
|
|
valid: true,
|
2019-10-16 21:41:08 -07:00
|
|
|
blacklist: false,
|
2019-10-16 19:18:30 -07:00
|
|
|
lastTried: time.Now(),
|
|
|
|
}
|
|
|
|
|
2019-10-16 21:41:08 -07:00
|
|
|
if s.alreadyKnowsAddress(p.NA()) {
|
|
|
|
s.updateAddressState(newAddr)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
s.logger.Printf("Adding %s to address list", p.Addr())
|
|
|
|
|
|
|
|
s.addrState.Lock()
|
|
|
|
s.addrList = append(s.addrList, newAddr)
|
|
|
|
s.addrState.Unlock()
|
|
|
|
|
|
|
|
return
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// ConnectToPeer attempts to connect to a peer on the default port at the
|
2019-10-16 18:05:42 -07:00
|
|
|
// specified address. It returns an error if it can't complete handshake with
|
|
|
|
// the peer. Otherwise it returns nil and adds the peer to the list of live
|
|
|
|
// connections and known-good addresses.
|
|
|
|
func (s *Seeder) ConnectOnDefaultPort(addr string) error {
|
|
|
|
return s.Connect(addr, s.config.ChainParams.DefaultPort)
|
|
|
|
}
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-16 18:05:42 -07:00
|
|
|
func (s *Seeder) Connect(addr, port string) error {
|
|
|
|
connectionString := net.JoinHostPort(addr, port)
|
2019-10-09 15:32:15 -07:00
|
|
|
p, err := peer.NewOutboundPeer(s.config, connectionString)
|
|
|
|
if err != nil {
|
2019-10-12 09:42:16 -07:00
|
|
|
return errors.Wrap(err, "constructing outbound peer")
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 21:41:08 -07:00
|
|
|
if s.isBlacklistedAddress(p.NA()) {
|
|
|
|
return ErrBlacklistedPeer
|
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
_, alreadyPending := s.pendingPeers.Load(p.Addr())
|
|
|
|
_, alreadyHandshaking := s.handshakeSignals.Load(p.Addr())
|
2019-10-12 16:18:25 -07:00
|
|
|
_, alreadyLive := s.livePeers.Load(p.Addr())
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
if alreadyPending {
|
|
|
|
s.logger.Printf("Peer is already pending: %s", p.Addr())
|
|
|
|
return ErrRepeatConnection
|
|
|
|
} else {
|
|
|
|
s.pendingPeers.Store(p.Addr(), p)
|
|
|
|
}
|
|
|
|
|
|
|
|
if alreadyHandshaking {
|
|
|
|
s.logger.Printf("Peer is already handshaking: %s", p.Addr())
|
|
|
|
return ErrRepeatConnection
|
|
|
|
} else {
|
|
|
|
s.handshakeSignals.Store(p.Addr(), make(chan struct{}, 1))
|
|
|
|
}
|
|
|
|
|
|
|
|
if alreadyLive {
|
|
|
|
s.logger.Printf("Peer is already live: %s", p.Addr())
|
2019-10-12 16:18:25 -07:00
|
|
|
return ErrRepeatConnection
|
|
|
|
}
|
|
|
|
|
2019-10-16 21:54:23 -07:00
|
|
|
conn, err := net.DialTimeout("tcp", p.Addr(), 1*time.Second)
|
2019-10-09 15:32:15 -07:00
|
|
|
if err != nil {
|
2019-10-12 09:42:16 -07:00
|
|
|
return errors.Wrap(err, "dialing new peer address")
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
2019-10-12 09:42:16 -07:00
|
|
|
// Begin connection negotiation.
|
|
|
|
s.logger.Printf("Handshake initated with new peer %s", p.Addr())
|
2019-10-09 15:32:15 -07:00
|
|
|
p.AssociateConnection(conn)
|
|
|
|
|
2019-10-12 19:00:20 -07:00
|
|
|
// TODO: handle disconnect during this
|
2019-10-12 16:18:25 -07:00
|
|
|
handshakeChan, _ := s.handshakeSignals.Load(p.Addr())
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-handshakeChan.(chan struct{}):
|
|
|
|
s.logger.Printf("Handshake completed with new peer %s", p.Addr())
|
|
|
|
s.handshakeSignals.Delete(p.Addr())
|
|
|
|
return nil
|
2019-10-16 21:54:23 -07:00
|
|
|
case <-time.After(1 * time.Second):
|
|
|
|
return errors.New("peer handshake started but timed out")
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
panic("This should be unreachable")
|
|
|
|
}
|
|
|
|
|
2019-10-16 18:05:42 -07:00
|
|
|
// GetPeer returns a live peer identified by "host:port" string, or an error if
|
|
|
|
// we aren't connected to that peer.
|
2019-10-12 09:42:16 -07:00
|
|
|
func (s *Seeder) GetPeer(addr string) (*peer.Peer, error) {
|
2019-10-16 18:05:42 -07:00
|
|
|
p, ok := s.livePeers.Load(addr)
|
2019-10-09 15:32:15 -07:00
|
|
|
|
2019-10-12 16:18:25 -07:00
|
|
|
if ok {
|
|
|
|
return p.(*peer.Peer), nil
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
|
|
|
|
2019-10-12 19:00:20 -07:00
|
|
|
return nil, ErrNoSuchPeer
|
|
|
|
}
|
|
|
|
|
2019-10-16 18:05:42 -07:00
|
|
|
// DisconnectPeer disconnects from a live peer identified by "host:port"
|
|
|
|
// string. It returns an error if we aren't connected to that peer.
|
2019-10-12 19:00:20 -07:00
|
|
|
func (s *Seeder) DisconnectPeer(addr string) error {
|
2019-10-16 18:05:42 -07:00
|
|
|
p, ok := s.livePeers.Load(addr)
|
2019-10-12 19:00:20 -07:00
|
|
|
|
|
|
|
if !ok {
|
|
|
|
return ErrNoSuchPeer
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: type safety and error handling
|
|
|
|
|
|
|
|
v := p.(*peer.Peer)
|
2019-10-16 19:18:30 -07:00
|
|
|
s.logger.Printf("Disconnecting from peer %s", v.Addr())
|
2019-10-12 19:00:20 -07:00
|
|
|
v.Disconnect()
|
|
|
|
v.WaitForDisconnect()
|
2019-10-16 18:05:42 -07:00
|
|
|
s.livePeers.Delete(addr)
|
2019-10-12 19:00:20 -07:00
|
|
|
|
|
|
|
return nil
|
2019-10-12 09:42:16 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
// DisconnectPeerDishonorably disconnects from a live peer identified by
|
|
|
|
// "host:port" string. It returns an error if we aren't connected to that peer.
|
|
|
|
// "Dishonorably" furthermore removes this peer from the list of known good
|
|
|
|
// addresses and adds them to a blacklist.
|
|
|
|
func (s *Seeder) DisconnectPeerDishonorably(addr string) error {
|
|
|
|
p, ok := s.livePeers.Load(addr)
|
|
|
|
|
|
|
|
if !ok {
|
|
|
|
return ErrNoSuchPeer
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: type safety and error handling
|
|
|
|
|
|
|
|
v := p.(*peer.Peer)
|
|
|
|
s.logger.Printf("Disconnecting from peer %s", v.Addr())
|
|
|
|
v.Disconnect()
|
|
|
|
v.WaitForDisconnect()
|
|
|
|
s.livePeers.Delete(addr)
|
|
|
|
|
|
|
|
s.addrState.Lock()
|
|
|
|
for i := 0; i < len(s.addrList); i++ {
|
|
|
|
address := s.addrList[i]
|
|
|
|
if address.String() == addr {
|
|
|
|
s.logger.Printf("Blacklisting peer %s", v.Addr())
|
|
|
|
address.valid = false
|
|
|
|
address.blacklist = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.addrState.Unlock()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-10-16 18:05:42 -07:00
|
|
|
// DisconnectAllPeers terminates the connections to all live and pending peers.
|
2019-10-12 09:42:16 -07:00
|
|
|
func (s *Seeder) DisconnectAllPeers() {
|
2019-10-12 16:18:25 -07:00
|
|
|
s.pendingPeers.Range(func(key, value interface{}) bool {
|
|
|
|
p, ok := value.(*peer.Peer)
|
|
|
|
if !ok {
|
|
|
|
s.logger.Printf("Invalid peer in pendingPeers")
|
|
|
|
return false
|
2019-10-12 09:42:16 -07:00
|
|
|
}
|
2019-10-12 16:18:25 -07:00
|
|
|
p.Disconnect()
|
|
|
|
p.WaitForDisconnect()
|
|
|
|
s.pendingPeers.Delete(key)
|
|
|
|
return true
|
|
|
|
})
|
|
|
|
|
|
|
|
s.livePeers.Range(func(key, value interface{}) bool {
|
|
|
|
p, ok := value.(*peer.Peer)
|
|
|
|
if !ok {
|
|
|
|
s.logger.Printf("Invalid peer in livePeers")
|
|
|
|
return false
|
2019-10-12 09:42:16 -07:00
|
|
|
}
|
2019-10-12 19:00:20 -07:00
|
|
|
s.DisconnectPeer(p.Addr())
|
|
|
|
return true
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Seeder) RequestAddresses() {
|
|
|
|
s.livePeers.Range(func(key, value interface{}) bool {
|
|
|
|
p, ok := value.(*peer.Peer)
|
|
|
|
if !ok {
|
|
|
|
s.logger.Printf("Invalid peer in livePeers")
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
s.logger.Printf("Requesting addresses from peer %s", p.Addr())
|
|
|
|
p.QueueMessage(wire.NewMsgGetAddr(), nil)
|
2019-10-12 16:18:25 -07:00
|
|
|
return true
|
|
|
|
})
|
2019-10-09 15:32:15 -07:00
|
|
|
}
|
2019-10-12 16:18:25 -07:00
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
// WaitForAddresses waits for n addresses to be received and their initial
|
|
|
|
// connection attempts to resolve. There is no escape if that does not happen -
|
|
|
|
// this is intended for test runners.
|
|
|
|
func (s *Seeder) WaitForAddresses(n int) error {
|
|
|
|
s.addrState.Lock()
|
|
|
|
for {
|
|
|
|
addrCount := len(s.addrList)
|
|
|
|
if addrCount < n {
|
|
|
|
s.addrRecvCond.Wait()
|
|
|
|
} else {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.addrState.Unlock()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Seeder) alreadyKnowsAddress(na *wire.NetAddress) bool {
|
|
|
|
s.addrState.RLock()
|
|
|
|
defer s.addrState.RUnlock()
|
|
|
|
|
|
|
|
ref := &Address{
|
|
|
|
netaddr: na,
|
|
|
|
}
|
|
|
|
|
|
|
|
for i := 0; i < len(s.addrList); i++ {
|
|
|
|
if s.addrList[i].String() == ref.String() {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Seeder) isBlacklistedAddress(na *wire.NetAddress) bool {
|
|
|
|
s.addrState.RLock()
|
|
|
|
defer s.addrState.RUnlock()
|
|
|
|
|
|
|
|
ref := &Address{
|
|
|
|
netaddr: na,
|
|
|
|
}
|
|
|
|
|
|
|
|
for i := 0; i < len(s.addrList); i++ {
|
|
|
|
if s.addrList[i].String() == ref.String() {
|
|
|
|
return s.addrList[i].IsBad()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
2019-10-12 19:00:20 -07:00
|
|
|
}
|
|
|
|
|
2019-10-16 21:41:08 -07:00
|
|
|
func (s *Seeder) updateAddressState(update *Address) {
|
|
|
|
s.addrState.Lock()
|
|
|
|
defer s.addrState.Unlock()
|
|
|
|
|
|
|
|
for i := 0; i < len(s.addrList); i++ {
|
|
|
|
if s.addrList[i].String() == update.String() {
|
|
|
|
s.addrList[i].valid = update.valid
|
|
|
|
s.addrList[i].blacklist = update.blacklist
|
|
|
|
s.addrList[i].lastTried = update.lastTried
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 19:00:20 -07:00
|
|
|
func (s *Seeder) onAddr(p *peer.Peer, msg *wire.MsgAddr) {
|
|
|
|
if len(msg.AddrList) == 0 {
|
|
|
|
s.logger.Printf("Got empty addr message from peer %s. Disconnecting.", p.Addr())
|
|
|
|
s.DisconnectPeer(p.Addr())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
s.logger.Printf("Got %d addrs from peer %s", len(msg.AddrList), p.Addr())
|
2019-10-16 19:18:30 -07:00
|
|
|
|
|
|
|
for _, na := range msg.AddrList {
|
|
|
|
s.logger.Printf("Trying %s:%d from peer %s", na.IP, na.Port, p.Addr())
|
|
|
|
go func(na *wire.NetAddress) {
|
|
|
|
if !addrmgr.IsRoutable(na) && !s.config.AllowSelfConns {
|
|
|
|
s.logger.Printf("Got bad addr %s:%d from peer %s", na.IP, na.Port, p.Addr())
|
|
|
|
s.DisconnectPeerDishonorably(p.Addr())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if s.alreadyKnowsAddress(na) {
|
|
|
|
s.logger.Printf("Already knew about address %s:%d", na.IP, na.Port)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if s.isBlacklistedAddress(na) {
|
|
|
|
s.logger.Printf("Address %s:%d is blacklisted", na.IP, na.Port)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
portString := strconv.Itoa(int(na.Port))
|
|
|
|
err := s.Connect(na.IP.String(), portString)
|
|
|
|
|
|
|
|
if err != nil {
|
2019-10-16 21:41:08 -07:00
|
|
|
s.logger.Printf("Got unusable peer %s:%d from peer %s. Error: %s", na.IP, na.Port, p.Addr(), err)
|
|
|
|
|
|
|
|
// Mark previously-known peers as invalid
|
|
|
|
newAddr := &Address{
|
|
|
|
netaddr: p.NA(),
|
|
|
|
valid: false,
|
|
|
|
lastTried: time.Now(),
|
|
|
|
}
|
|
|
|
|
|
|
|
if s.alreadyKnowsAddress(p.NA()) {
|
|
|
|
s.updateAddressState(newAddr)
|
|
|
|
}
|
|
|
|
|
2019-10-16 19:18:30 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
peerString := net.JoinHostPort(na.IP.String(), portString)
|
|
|
|
s.DisconnectPeer(peerString)
|
|
|
|
|
|
|
|
s.addrRecvCond.Broadcast()
|
|
|
|
}(na)
|
2019-10-12 19:00:20 -07:00
|
|
|
}
|
|
|
|
}
|