2014-01-23 11:14:01 -08:00
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
2014-02-13 06:12:16 -08:00
|
|
|
"bytes"
|
2014-06-18 04:06:48 -07:00
|
|
|
"container/list"
|
2014-02-10 02:45:08 -08:00
|
|
|
"fmt"
|
2014-08-21 05:47:58 -07:00
|
|
|
"math"
|
|
|
|
"math/big"
|
2014-01-23 11:14:01 -08:00
|
|
|
"net"
|
|
|
|
"strconv"
|
2014-01-31 11:01:28 -08:00
|
|
|
"strings"
|
2014-01-23 11:14:01 -08:00
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
2014-07-26 02:24:44 -07:00
|
|
|
|
2014-10-31 02:59:17 -07:00
|
|
|
"github.com/ethereum/go-ethereum/chain"
|
2014-10-23 06:01:27 -07:00
|
|
|
"github.com/ethereum/go-ethereum/ethutil"
|
2014-10-31 04:56:05 -07:00
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
2014-10-31 06:53:42 -07:00
|
|
|
"github.com/ethereum/go-ethereum/wire"
|
2014-01-23 11:14:01 -08:00
|
|
|
)
|
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
var peerlogger = logger.NewLogger("PEER")
|
2014-06-23 04:54:10 -07:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
const (
|
|
|
|
// The size of the output buffer for writing messages
|
|
|
|
outputBufferSize = 50
|
2014-03-03 02:34:04 -08:00
|
|
|
// Current protocol version
|
2014-11-07 03:18:48 -08:00
|
|
|
ProtocolVersion = 39
|
2014-09-10 02:22:19 -07:00
|
|
|
// Current P2P version
|
2014-10-17 08:11:34 -07:00
|
|
|
P2PVersion = 2
|
2014-09-17 16:02:15 -07:00
|
|
|
// Ethereum network version
|
|
|
|
NetVersion = 0
|
2014-06-10 04:51:34 -07:00
|
|
|
// Interval for ping/pong message
|
2014-06-14 15:04:18 -07:00
|
|
|
pingPongTimer = 2 * time.Second
|
2014-01-23 11:14:01 -08:00
|
|
|
)
|
|
|
|
|
2014-02-02 11:00:09 -08:00
|
|
|
type DiscReason byte
|
|
|
|
|
|
|
|
const (
|
2014-02-18 14:24:44 -08:00
|
|
|
// Values are given explicitly instead of by iota because these values are
|
|
|
|
// defined by the wire protocol spec; it is easier for humans to ensure
|
|
|
|
// correctness when values are explicit.
|
2014-10-02 08:03:48 -07:00
|
|
|
DiscRequested DiscReason = iota
|
|
|
|
DiscReTcpSysErr
|
|
|
|
DiscBadProto
|
|
|
|
DiscBadPeer
|
|
|
|
DiscTooManyPeers
|
|
|
|
DiscConnDup
|
|
|
|
DiscGenesisErr
|
|
|
|
DiscProtoErr
|
|
|
|
DiscQuitting
|
2014-02-02 11:00:09 -08:00
|
|
|
)
|
|
|
|
|
|
|
|
var discReasonToString = []string{
|
2014-07-01 11:32:47 -07:00
|
|
|
"requested",
|
|
|
|
"TCP sys error",
|
|
|
|
"bad protocol",
|
|
|
|
"useless peer",
|
|
|
|
"too many peers",
|
|
|
|
"already connected",
|
|
|
|
"wrong genesis block",
|
|
|
|
"incompatible network",
|
|
|
|
"quitting",
|
2014-02-02 11:00:09 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (d DiscReason) String() string {
|
2014-03-05 01:42:51 -08:00
|
|
|
if len(discReasonToString) < int(d) {
|
2014-02-02 11:00:09 -08:00
|
|
|
return "Unknown"
|
|
|
|
}
|
|
|
|
|
|
|
|
return discReasonToString[d]
|
|
|
|
}
|
|
|
|
|
|
|
|
// Peer capabilities
|
2014-01-31 11:01:28 -08:00
|
|
|
type Caps byte
|
|
|
|
|
|
|
|
const (
|
2014-09-17 16:02:15 -07:00
|
|
|
CapPeerDiscTy Caps = 1 << iota
|
2014-02-18 14:20:41 -08:00
|
|
|
CapTxTy
|
|
|
|
CapChainTy
|
2014-02-02 07:15:39 -08:00
|
|
|
|
2014-02-02 11:00:09 -08:00
|
|
|
CapDefault = CapChainTy | CapTxTy | CapPeerDiscTy
|
2014-01-31 11:01:28 -08:00
|
|
|
)
|
|
|
|
|
|
|
|
var capsToString = map[Caps]string{
|
2014-02-02 11:00:09 -08:00
|
|
|
CapPeerDiscTy: "Peer discovery",
|
|
|
|
CapTxTy: "Transaction relaying",
|
|
|
|
CapChainTy: "Block chain relaying",
|
2014-01-31 11:01:28 -08:00
|
|
|
}
|
|
|
|
|
2014-02-06 04:27:57 -08:00
|
|
|
func (c Caps) IsCap(cap Caps) bool {
|
|
|
|
return c&cap > 0
|
|
|
|
}
|
|
|
|
|
2014-01-31 11:01:28 -08:00
|
|
|
func (c Caps) String() string {
|
|
|
|
var caps []string
|
2014-02-06 04:27:57 -08:00
|
|
|
if c.IsCap(CapPeerDiscTy) {
|
2014-02-02 11:00:09 -08:00
|
|
|
caps = append(caps, capsToString[CapPeerDiscTy])
|
2014-01-31 11:01:28 -08:00
|
|
|
}
|
2014-02-06 04:27:57 -08:00
|
|
|
if c.IsCap(CapChainTy) {
|
2014-01-31 11:01:28 -08:00
|
|
|
caps = append(caps, capsToString[CapChainTy])
|
|
|
|
}
|
2014-02-06 04:27:57 -08:00
|
|
|
if c.IsCap(CapTxTy) {
|
2014-01-31 11:01:28 -08:00
|
|
|
caps = append(caps, capsToString[CapTxTy])
|
|
|
|
}
|
|
|
|
|
|
|
|
return strings.Join(caps, " | ")
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
type Peer struct {
|
|
|
|
// Ethereum interface
|
|
|
|
ethereum *Ethereum
|
|
|
|
// Net connection
|
|
|
|
conn net.Conn
|
|
|
|
// Output queue which is used to communicate and handle messages
|
2014-10-31 06:53:42 -07:00
|
|
|
outputQueue chan *wire.Msg
|
2014-01-23 11:14:01 -08:00
|
|
|
// Quit channel
|
|
|
|
quit chan bool
|
|
|
|
// Determines whether it's an inbound or outbound peer
|
|
|
|
inbound bool
|
|
|
|
// Flag for checking the peer's connectivity state
|
|
|
|
connected int32
|
|
|
|
disconnect int32
|
|
|
|
// Last known message send
|
|
|
|
lastSend time.Time
|
|
|
|
// Indicated whether a verack has been send or not
|
|
|
|
// This flag is used by writeMessage to check if messages are allowed
|
|
|
|
// to be send or not. If no version is known all messages are ignored.
|
|
|
|
versionKnown bool
|
2014-09-10 02:22:19 -07:00
|
|
|
statusKnown bool
|
2014-01-23 11:14:01 -08:00
|
|
|
|
|
|
|
// Last received pong message
|
2014-10-01 16:36:59 -07:00
|
|
|
lastPong int64
|
|
|
|
lastBlockReceived time.Time
|
|
|
|
doneFetchingHashes bool
|
2014-01-30 14:48:52 -08:00
|
|
|
|
2014-08-21 05:47:58 -07:00
|
|
|
host []byte
|
|
|
|
port uint16
|
|
|
|
caps Caps
|
|
|
|
td *big.Int
|
|
|
|
bestHash []byte
|
|
|
|
lastReceivedHash []byte
|
|
|
|
requestedHashes [][]byte
|
2014-02-09 14:34:33 -08:00
|
|
|
|
2014-06-18 01:39:42 -07:00
|
|
|
// This peer's public key
|
2014-02-09 14:34:33 -08:00
|
|
|
pubkey []byte
|
2014-02-09 16:09:12 -08:00
|
|
|
|
|
|
|
// Indicated whether the node is catching up or not
|
2014-03-21 07:06:23 -07:00
|
|
|
catchingUp bool
|
2014-05-20 02:50:34 -07:00
|
|
|
diverted bool
|
2014-03-21 07:06:23 -07:00
|
|
|
blocksRequested int
|
2014-02-13 06:12:16 -08:00
|
|
|
|
2014-06-02 06:20:27 -07:00
|
|
|
version string
|
2014-06-03 01:42:55 -07:00
|
|
|
|
|
|
|
// We use this to give some kind of pingtime to a node, not very accurate, could be improved.
|
|
|
|
pingTime time.Duration
|
|
|
|
pingStartTime time.Time
|
2014-06-23 02:24:45 -07:00
|
|
|
|
2014-10-31 02:59:17 -07:00
|
|
|
lastRequestedBlock *chain.Block
|
2014-09-23 08:55:34 -07:00
|
|
|
|
|
|
|
protocolCaps *ethutil.Value
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewPeer(conn net.Conn, ethereum *Ethereum, inbound bool) *Peer {
|
2014-06-29 10:30:05 -07:00
|
|
|
pubkey := ethereum.KeyManager().PublicKey()[1:]
|
2014-02-13 06:12:16 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
return &Peer{
|
2014-10-31 06:53:42 -07:00
|
|
|
outputQueue: make(chan *wire.Msg, outputBufferSize),
|
2014-10-01 16:36:59 -07:00
|
|
|
quit: make(chan bool),
|
|
|
|
ethereum: ethereum,
|
|
|
|
conn: conn,
|
|
|
|
inbound: inbound,
|
|
|
|
disconnect: 0,
|
|
|
|
connected: 1,
|
|
|
|
port: 30303,
|
|
|
|
pubkey: pubkey,
|
|
|
|
blocksRequested: 10,
|
|
|
|
caps: ethereum.ServerCaps(),
|
|
|
|
version: ethereum.ClientIdentity().String(),
|
|
|
|
protocolCaps: ethutil.NewValue(nil),
|
|
|
|
td: big.NewInt(0),
|
|
|
|
doneFetchingHashes: true,
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func NewOutboundPeer(addr string, ethereum *Ethereum, caps Caps) *Peer {
|
2014-01-23 11:14:01 -08:00
|
|
|
p := &Peer{
|
2014-10-31 06:53:42 -07:00
|
|
|
outputQueue: make(chan *wire.Msg, outputBufferSize),
|
2014-10-01 16:36:59 -07:00
|
|
|
quit: make(chan bool),
|
|
|
|
ethereum: ethereum,
|
|
|
|
inbound: false,
|
|
|
|
connected: 0,
|
|
|
|
disconnect: 0,
|
|
|
|
port: 30303,
|
|
|
|
caps: caps,
|
|
|
|
version: ethereum.ClientIdentity().String(),
|
|
|
|
protocolCaps: ethutil.NewValue(nil),
|
|
|
|
td: big.NewInt(0),
|
|
|
|
doneFetchingHashes: true,
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the connection in another goroutine so we don't block the main thread
|
|
|
|
go func() {
|
2014-07-24 03:30:04 -07:00
|
|
|
conn, err := p.Connect(addr)
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
2014-10-02 08:35:38 -07:00
|
|
|
//peerlogger.Debugln("Connection to peer failed. Giving up.", err)
|
2014-01-23 11:14:01 -08:00
|
|
|
p.Stop()
|
2014-01-27 06:34:50 -08:00
|
|
|
return
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
p.conn = conn
|
|
|
|
|
|
|
|
// Atomically set the connection state
|
|
|
|
atomic.StoreInt32(&p.connected, 1)
|
|
|
|
atomic.StoreInt32(&p.disconnect, 0)
|
|
|
|
|
2014-02-02 10:46:37 -08:00
|
|
|
p.Start()
|
2014-01-23 11:14:01 -08:00
|
|
|
}()
|
|
|
|
|
|
|
|
return p
|
|
|
|
}
|
|
|
|
|
2014-07-24 03:30:04 -07:00
|
|
|
func (self *Peer) Connect(addr string) (conn net.Conn, err error) {
|
2014-07-26 02:24:44 -07:00
|
|
|
const maxTries = 3
|
|
|
|
for attempts := 0; attempts < maxTries; attempts++ {
|
2014-07-24 03:30:04 -07:00
|
|
|
conn, err = net.DialTimeout("tcp", addr, 10*time.Second)
|
|
|
|
if err != nil {
|
2014-07-26 02:24:44 -07:00
|
|
|
time.Sleep(time.Duration(attempts*20) * time.Second)
|
2014-07-24 03:30:04 -07:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Success
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-06-02 06:20:27 -07:00
|
|
|
// Getters
|
2014-06-03 01:42:55 -07:00
|
|
|
func (p *Peer) PingTime() string {
|
|
|
|
return p.pingTime.String()
|
|
|
|
}
|
2014-06-02 06:20:27 -07:00
|
|
|
func (p *Peer) Inbound() bool {
|
|
|
|
return p.inbound
|
|
|
|
}
|
|
|
|
func (p *Peer) LastSend() time.Time {
|
|
|
|
return p.lastSend
|
|
|
|
}
|
|
|
|
func (p *Peer) LastPong() int64 {
|
|
|
|
return p.lastPong
|
|
|
|
}
|
|
|
|
func (p *Peer) Host() []byte {
|
|
|
|
return p.host
|
|
|
|
}
|
|
|
|
func (p *Peer) Port() uint16 {
|
|
|
|
return p.port
|
|
|
|
}
|
|
|
|
func (p *Peer) Version() string {
|
|
|
|
return p.version
|
|
|
|
}
|
|
|
|
func (p *Peer) Connected() *int32 {
|
|
|
|
return &p.connected
|
|
|
|
}
|
|
|
|
|
|
|
|
// Setters
|
|
|
|
func (p *Peer) SetVersion(version string) {
|
|
|
|
p.version = version
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Outputs any RLP encoded data to the peer
|
2014-10-31 06:53:42 -07:00
|
|
|
func (p *Peer) QueueMessage(msg *wire.Msg) {
|
2014-05-14 02:29:57 -07:00
|
|
|
if atomic.LoadInt32(&p.connected) != 1 {
|
|
|
|
return
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
p.outputQueue <- msg
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (p *Peer) writeMessage(msg *wire.Msg) {
|
2014-01-23 11:14:01 -08:00
|
|
|
// Ignore the write if we're not connected
|
|
|
|
if atomic.LoadInt32(&p.connected) != 1 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !p.versionKnown {
|
|
|
|
switch msg.Type {
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgHandshakeTy: // Ok
|
2014-01-23 11:14:01 -08:00
|
|
|
default: // Anything but ack is allowed
|
|
|
|
return
|
|
|
|
}
|
2014-09-10 02:22:19 -07:00
|
|
|
} else {
|
2014-09-15 06:42:12 -07:00
|
|
|
/*
|
|
|
|
if !p.statusKnown {
|
|
|
|
switch msg.Type {
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgStatusTy: // Ok
|
2014-09-15 06:42:12 -07:00
|
|
|
default: // Anything but ack is allowed
|
|
|
|
return
|
|
|
|
}
|
2014-09-10 02:22:19 -07:00
|
|
|
}
|
2014-09-15 06:42:12 -07:00
|
|
|
*/
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-09-17 06:58:02 -07:00
|
|
|
peerlogger.DebugDetailf("(%v) <= %v\n", p.conn.RemoteAddr(), formatMessage(msg))
|
2014-06-14 06:44:13 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
err := wire.WriteMessage(p.conn, msg)
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
2014-06-23 04:54:10 -07:00
|
|
|
peerlogger.Debugln(" Can't send message:", err)
|
2014-01-23 11:14:01 -08:00
|
|
|
// Stop the client if there was an error writing to it
|
|
|
|
p.Stop()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Outbound message handler. Outbound messages are handled here
|
|
|
|
func (p *Peer) HandleOutbound() {
|
|
|
|
// The ping timer. Makes sure that every 2 minutes a ping is send to the peer
|
2014-06-10 04:51:34 -07:00
|
|
|
pingTimer := time.NewTicker(pingPongTimer)
|
2014-09-24 12:20:57 -07:00
|
|
|
serviceTimer := time.NewTicker(10 * time.Second)
|
2014-02-11 09:46:28 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
out:
|
|
|
|
for {
|
2014-09-26 11:19:01 -07:00
|
|
|
skip:
|
2014-01-23 11:14:01 -08:00
|
|
|
select {
|
|
|
|
// Main message queue. All outbound messages are processed through here
|
|
|
|
case msg := <-p.outputQueue:
|
2014-09-17 16:02:15 -07:00
|
|
|
if !p.statusKnown {
|
|
|
|
switch msg.Type {
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgTxTy, wire.MsgGetBlockHashesTy, wire.MsgBlockHashesTy, wire.MsgGetBlocksTy, wire.MsgBlockTy:
|
2014-09-26 11:19:01 -07:00
|
|
|
break skip
|
2014-09-17 16:02:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
p.writeMessage(msg)
|
|
|
|
p.lastSend = time.Now()
|
|
|
|
|
2014-06-10 04:51:34 -07:00
|
|
|
// Ping timer
|
2014-02-02 07:15:39 -08:00
|
|
|
case <-pingTimer.C:
|
2014-07-30 02:26:38 -07:00
|
|
|
/*
|
|
|
|
timeSince := time.Since(time.Unix(p.lastPong, 0))
|
|
|
|
if !p.pingStartTime.IsZero() && p.lastPong != 0 && timeSince > (pingPongTimer+30*time.Second) {
|
|
|
|
peerlogger.Infof("Peer did not respond to latest pong fast enough, it took %s, disconnecting.\n", timeSince)
|
|
|
|
p.Stop()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
*/
|
2014-10-31 06:53:42 -07:00
|
|
|
p.writeMessage(wire.NewMessage(wire.MsgPingTy, ""))
|
2014-06-03 01:42:55 -07:00
|
|
|
p.pingStartTime = time.Now()
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
// Service timer takes care of peer broadcasting, transaction
|
|
|
|
// posting or block posting
|
|
|
|
case <-serviceTimer.C:
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgGetPeersTy, ""))
|
2014-02-02 07:15:39 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
case <-p.quit:
|
2014-02-02 07:15:39 -08:00
|
|
|
// Break out of the for loop if a quit message is posted
|
2014-01-23 11:14:01 -08:00
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clean:
|
|
|
|
// This loop is for draining the output queue and anybody waiting for us
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-p.outputQueue:
|
|
|
|
// TODO
|
|
|
|
default:
|
|
|
|
break clean
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func formatMessage(msg *wire.Msg) (ret string) {
|
2014-09-22 07:28:28 -07:00
|
|
|
ret = fmt.Sprintf("%v %v", msg.Type, msg.Data)
|
2014-09-17 06:58:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
XXX Commented out because I need the log level here to determine
|
|
|
|
if i should or shouldn't generate this message
|
|
|
|
*/
|
2014-09-22 07:28:28 -07:00
|
|
|
/*
|
|
|
|
switch msg.Type {
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgPeersTy:
|
2014-09-22 07:28:28 -07:00
|
|
|
ret += fmt.Sprintf("(%d entries)", msg.Data.Len())
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgBlockTy:
|
2014-10-31 02:59:17 -07:00
|
|
|
b1, b2 := chain.NewBlockFromRlpValue(msg.Data.Get(0)), ethchain.NewBlockFromRlpValue(msg.Data.Get(msg.Data.Len()-1))
|
2014-09-22 07:28:28 -07:00
|
|
|
ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), b1.Hash()[0:4], b2.Hash()[0:4])
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgBlockHashesTy:
|
2014-09-22 07:28:28 -07:00
|
|
|
h1, h2 := msg.Data.Get(0).Bytes(), msg.Data.Get(msg.Data.Len()-1).Bytes()
|
|
|
|
ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), h1, h2)
|
|
|
|
}
|
|
|
|
*/
|
2014-09-17 06:58:02 -07:00
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Inbound handler. Inbound messages are received here and passed to the appropriate methods
|
|
|
|
func (p *Peer) HandleInbound() {
|
|
|
|
for atomic.LoadInt32(&p.disconnect) == 0 {
|
2014-06-03 01:42:55 -07:00
|
|
|
|
2014-02-09 16:09:12 -08:00
|
|
|
// HMM?
|
2014-07-15 11:36:11 -07:00
|
|
|
time.Sleep(50 * time.Millisecond)
|
2014-01-23 11:14:01 -08:00
|
|
|
// Wait for a message from the peer
|
2014-10-31 06:53:42 -07:00
|
|
|
msgs, err := wire.ReadMessages(p.conn)
|
2014-02-09 14:34:33 -08:00
|
|
|
if err != nil {
|
2014-06-23 04:54:10 -07:00
|
|
|
peerlogger.Debugln(err)
|
2014-02-09 14:34:33 -08:00
|
|
|
}
|
|
|
|
for _, msg := range msgs {
|
2014-09-17 06:58:02 -07:00
|
|
|
peerlogger.DebugDetailf("(%v) => %v\n", p.conn.RemoteAddr(), formatMessage(msg))
|
2014-06-14 06:44:13 -07:00
|
|
|
|
2014-01-30 14:48:52 -08:00
|
|
|
switch msg.Type {
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgHandshakeTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// Version message
|
|
|
|
p.handleHandshake(msg)
|
2014-01-30 15:56:32 -08:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
//if p.caps.IsCap(CapPeerDiscTy) {
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgGetPeersTy, ""))
|
2014-09-10 02:22:19 -07:00
|
|
|
//}
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgDiscTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
p.Stop()
|
2014-07-30 02:26:38 -07:00
|
|
|
peerlogger.Infoln("Disconnect peer: ", DiscReason(msg.Data.Get(0).Uint()))
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgPingTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// Respond back with pong
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgPongTy, ""))
|
|
|
|
case wire.MsgPongTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// If we received a pong back from a peer we set the
|
|
|
|
// last pong so the peer handler knows this peer is still
|
|
|
|
// active.
|
|
|
|
p.lastPong = time.Now().Unix()
|
2014-07-30 02:26:38 -07:00
|
|
|
p.pingTime = time.Since(p.pingStartTime)
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgTxTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// If the message was a transaction queue the transaction
|
|
|
|
// in the TxPool where it will undergo validation and
|
|
|
|
// processing when a new block is found
|
2014-02-13 06:12:16 -08:00
|
|
|
for i := 0; i < msg.Data.Len(); i++ {
|
2014-10-31 02:59:17 -07:00
|
|
|
tx := chain.NewTransactionFromValue(msg.Data.Get(i))
|
2014-03-28 03:20:07 -07:00
|
|
|
p.ethereum.TxPool().QueueTransaction(tx)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgGetPeersTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// Peer asked for list of connected peers
|
2014-10-17 08:11:34 -07:00
|
|
|
//p.pushPeers()
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgPeersTy:
|
2014-01-30 14:48:52 -08:00
|
|
|
// Received a list of peers (probably because MsgGetPeersTy was send)
|
2014-07-24 03:04:15 -07:00
|
|
|
data := msg.Data
|
|
|
|
// Create new list of possible peers for the ethereum to process
|
|
|
|
peers := make([]string, data.Len())
|
|
|
|
// Parse each possible peer
|
|
|
|
for i := 0; i < data.Len(); i++ {
|
|
|
|
value := data.Get(i)
|
|
|
|
peers[i] = unpackAddr(value.Get(0), value.Get(1).Uint())
|
|
|
|
}
|
2014-01-30 14:48:52 -08:00
|
|
|
|
2014-07-24 03:04:15 -07:00
|
|
|
// Connect to the list of peers
|
|
|
|
p.ethereum.ProcessPeerList(peers)
|
2014-09-10 02:22:19 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgStatusTy:
|
2014-09-10 02:22:19 -07:00
|
|
|
// Handle peer's status msg
|
|
|
|
p.handleStatus(msg)
|
2014-09-17 16:02:15 -07:00
|
|
|
}
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
// TMP
|
|
|
|
if p.statusKnown {
|
|
|
|
switch msg.Type {
|
2014-10-21 04:25:31 -07:00
|
|
|
/*
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgGetTxsTy:
|
2014-10-21 04:25:31 -07:00
|
|
|
// Get the current transactions of the pool
|
|
|
|
txs := p.ethereum.TxPool().CurrentTransactions()
|
|
|
|
// Get the RlpData values from the txs
|
|
|
|
txsInterface := make([]interface{}, len(txs))
|
|
|
|
for i, tx := range txs {
|
|
|
|
txsInterface[i] = tx.RlpData()
|
|
|
|
}
|
|
|
|
// Broadcast it back to the peer
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgTxTy, txsInterface))
|
2014-10-21 04:25:31 -07:00
|
|
|
*/
|
2014-09-17 16:02:15 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgGetBlockHashesTy:
|
2014-09-17 16:02:15 -07:00
|
|
|
if msg.Data.Len() < 2 {
|
|
|
|
peerlogger.Debugln("err: argument length invalid ", msg.Data.Len())
|
|
|
|
}
|
2014-01-27 06:34:50 -08:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
hash := msg.Data.Get(0).Bytes()
|
|
|
|
amount := msg.Data.Get(1).Uint()
|
2014-03-21 07:06:23 -07:00
|
|
|
|
2014-10-20 02:53:11 -07:00
|
|
|
hashes := p.ethereum.ChainManager().GetChainHashesFromHash(hash, amount)
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgBlockHashesTy, ethutil.ByteSliceToInterface(hashes)))
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgGetBlocksTy:
|
2014-09-17 16:02:15 -07:00
|
|
|
// Limit to max 300 blocks
|
|
|
|
max := int(math.Min(float64(msg.Data.Len()), 300.0))
|
|
|
|
var blocks []interface{}
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
for i := 0; i < max; i++ {
|
|
|
|
hash := msg.Data.Get(i).Bytes()
|
2014-10-20 02:53:11 -07:00
|
|
|
block := p.ethereum.ChainManager().GetBlock(hash)
|
2014-09-17 16:02:15 -07:00
|
|
|
if block != nil {
|
|
|
|
blocks = append(blocks, block.Value().Raw())
|
|
|
|
}
|
2014-01-30 14:48:52 -08:00
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
p.QueueMessage(wire.NewMessage(wire.MsgBlockTy, blocks))
|
2014-05-14 11:35:23 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgBlockHashesTy:
|
2014-09-17 16:02:15 -07:00
|
|
|
p.catchingUp = true
|
2014-08-21 05:52:21 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
blockPool := p.ethereum.blockPool
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
foundCommonHash := false
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
it := msg.Data.NewIterator()
|
|
|
|
for it.Next() {
|
|
|
|
hash := it.Value().Bytes()
|
2014-10-01 16:36:59 -07:00
|
|
|
p.lastReceivedHash = hash
|
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
if blockPool.HasCommonHash(hash) {
|
|
|
|
foundCommonHash = true
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
break
|
|
|
|
}
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-24 10:55:28 -07:00
|
|
|
blockPool.AddHash(hash, p)
|
2014-09-17 16:02:15 -07:00
|
|
|
}
|
2014-08-21 05:52:21 -07:00
|
|
|
|
2014-10-07 02:18:46 -07:00
|
|
|
if !foundCommonHash {
|
|
|
|
//if !p.FetchHashes() {
|
|
|
|
// p.doneFetchingHashes = true
|
|
|
|
//}
|
|
|
|
p.FetchHashes()
|
2014-10-01 16:36:59 -07:00
|
|
|
} else {
|
|
|
|
peerlogger.Infof("Found common hash (%x...)\n", p.lastReceivedHash[0:4])
|
|
|
|
p.doneFetchingHashes = true
|
2014-09-17 16:02:15 -07:00
|
|
|
}
|
2014-08-21 05:52:21 -07:00
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgBlockTy:
|
2014-09-17 16:02:15 -07:00
|
|
|
p.catchingUp = true
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
blockPool := p.ethereum.blockPool
|
2014-08-21 05:52:21 -07:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
it := msg.Data.NewIterator()
|
|
|
|
for it.Next() {
|
2014-10-31 02:59:17 -07:00
|
|
|
block := chain.NewBlockFromRlpValue(it.Value())
|
2014-09-28 05:52:58 -07:00
|
|
|
blockPool.Add(block, p)
|
2014-01-25 08:13:33 -08:00
|
|
|
|
2014-09-17 16:02:15 -07:00
|
|
|
p.lastBlockReceived = time.Now()
|
|
|
|
}
|
2014-10-31 06:53:42 -07:00
|
|
|
case wire.MsgNewBlockTy:
|
2014-10-08 03:33:33 -07:00
|
|
|
var (
|
|
|
|
blockPool = p.ethereum.blockPool
|
2014-10-31 02:59:17 -07:00
|
|
|
block = chain.NewBlockFromRlpValue(msg.Data.Get(0))
|
2014-10-08 03:33:33 -07:00
|
|
|
td = msg.Data.Get(1).BigInt()
|
|
|
|
)
|
|
|
|
|
|
|
|
if td.Cmp(blockPool.td) > 0 {
|
|
|
|
p.ethereum.blockPool.AddNew(block, p)
|
|
|
|
}
|
2014-09-15 13:11:05 -07:00
|
|
|
}
|
2014-10-08 03:29:49 -07:00
|
|
|
|
2014-01-30 14:48:52 -08:00
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
p.Stop()
|
|
|
|
}
|
|
|
|
|
2014-09-24 02:41:57 -07:00
|
|
|
func (self *Peer) FetchBlocks(hashes [][]byte) {
|
2014-08-21 05:47:58 -07:00
|
|
|
if len(hashes) > 0 {
|
2014-10-01 16:36:59 -07:00
|
|
|
peerlogger.Debugf("Fetching blocks (%d)\n", len(hashes))
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
self.QueueMessage(wire.NewMessage(wire.MsgGetBlocksTy, ethutil.ByteSliceToInterface(hashes)))
|
2014-08-21 05:47:58 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-02 08:35:38 -07:00
|
|
|
func (self *Peer) FetchHashes() bool {
|
2014-08-21 05:47:58 -07:00
|
|
|
blockPool := self.ethereum.blockPool
|
|
|
|
|
2014-10-07 02:18:46 -07:00
|
|
|
return blockPool.FetchHashes(self)
|
2014-08-21 05:47:58 -07:00
|
|
|
}
|
|
|
|
|
2014-09-24 02:41:57 -07:00
|
|
|
func (self *Peer) FetchingHashes() bool {
|
2014-10-01 16:36:59 -07:00
|
|
|
return !self.doneFetchingHashes
|
2014-09-24 02:41:57 -07:00
|
|
|
}
|
|
|
|
|
2014-07-24 08:10:54 -07:00
|
|
|
// General update method
|
|
|
|
func (self *Peer) update() {
|
2014-09-24 02:55:02 -07:00
|
|
|
serviceTimer := time.NewTicker(100 * time.Millisecond)
|
2014-07-24 08:10:54 -07:00
|
|
|
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-serviceTimer.C:
|
2014-09-24 02:55:02 -07:00
|
|
|
if self.IsCap("eth") {
|
|
|
|
var (
|
|
|
|
sinceBlock = time.Since(self.lastBlockReceived)
|
|
|
|
)
|
|
|
|
|
2014-10-01 16:36:59 -07:00
|
|
|
if sinceBlock > 5*time.Second {
|
2014-09-24 02:55:02 -07:00
|
|
|
self.catchingUp = false
|
|
|
|
}
|
2014-07-24 08:10:54 -07:00
|
|
|
}
|
|
|
|
case <-self.quit:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
serviceTimer.Stop()
|
|
|
|
}
|
|
|
|
|
2014-02-02 10:46:37 -08:00
|
|
|
func (p *Peer) Start() {
|
2014-01-31 11:01:28 -08:00
|
|
|
peerHost, peerPort, _ := net.SplitHostPort(p.conn.LocalAddr().String())
|
|
|
|
servHost, servPort, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
|
2014-01-30 15:56:32 -08:00
|
|
|
|
2014-01-31 11:01:28 -08:00
|
|
|
if p.inbound {
|
|
|
|
p.host, p.port = packAddr(peerHost, peerPort)
|
|
|
|
} else {
|
|
|
|
p.host, p.port = packAddr(servHost, servPort)
|
2014-01-30 15:56:32 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
err := p.pushHandshake()
|
|
|
|
if err != nil {
|
2014-06-23 04:54:10 -07:00
|
|
|
peerlogger.Debugln("Peer can't send outbound version ack", err)
|
2014-01-30 15:56:32 -08:00
|
|
|
|
|
|
|
p.Stop()
|
|
|
|
|
|
|
|
return
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
go p.HandleOutbound()
|
|
|
|
// Run the inbound handler in a new goroutine
|
|
|
|
go p.HandleInbound()
|
2014-07-24 08:10:54 -07:00
|
|
|
// Run the general update handler
|
|
|
|
go p.update()
|
2014-01-30 14:48:52 -08:00
|
|
|
|
2014-06-03 01:42:55 -07:00
|
|
|
// Wait a few seconds for startup and then ask for an initial ping
|
|
|
|
time.Sleep(2 * time.Second)
|
2014-10-31 06:53:42 -07:00
|
|
|
p.writeMessage(wire.NewMessage(wire.MsgPingTy, ""))
|
2014-06-03 01:42:55 -07:00
|
|
|
p.pingStartTime = time.Now()
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Peer) Stop() {
|
2014-10-02 08:03:48 -07:00
|
|
|
p.StopWithReason(DiscRequested)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Peer) StopWithReason(reason DiscReason) {
|
2014-01-23 11:14:01 -08:00
|
|
|
if atomic.AddInt32(&p.disconnect, 1) != 1 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-10-02 08:03:48 -07:00
|
|
|
// Pre-emptively remove the peer; don't wait for reaping. We already know it's dead if we are here
|
|
|
|
p.ethereum.RemovePeer(p)
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
close(p.quit)
|
|
|
|
if atomic.LoadInt32(&p.connected) != 0 {
|
2014-10-31 06:53:42 -07:00
|
|
|
p.writeMessage(wire.NewMessage(wire.MsgDiscTy, reason))
|
2014-01-23 11:14:01 -08:00
|
|
|
p.conn.Close()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (p *Peer) peersMessage() *wire.Msg {
|
2014-01-31 02:57:56 -08:00
|
|
|
outPeers := make([]interface{}, len(p.ethereum.InOutPeers()))
|
2014-01-23 11:14:01 -08:00
|
|
|
// Serialise each peer
|
2014-01-31 02:57:56 -08:00
|
|
|
for i, peer := range p.ethereum.InOutPeers() {
|
2014-05-12 06:43:10 -07:00
|
|
|
// Don't return localhost as valid peer
|
|
|
|
if !net.ParseIP(peer.conn.RemoteAddr().String()).IsLoopback() {
|
|
|
|
outPeers[i] = peer.RlpData()
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
// Return the message to the peer with the known list of connected clients
|
2014-10-31 06:53:42 -07:00
|
|
|
return wire.NewMessage(wire.MsgPeersTy, outPeers)
|
2014-02-02 07:15:39 -08:00
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
// Pushes the list of outbound peers to the client when requested
|
|
|
|
func (p *Peer) pushPeers() {
|
|
|
|
p.QueueMessage(p.peersMessage())
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
func (self *Peer) pushStatus() {
|
2014-11-03 16:47:02 -08:00
|
|
|
fmt.Println("push status")
|
2014-10-31 06:53:42 -07:00
|
|
|
msg := wire.NewMessage(wire.MsgStatusTy, []interface{}{
|
2014-10-22 06:22:21 -07:00
|
|
|
uint32(ProtocolVersion),
|
2014-09-17 16:02:15 -07:00
|
|
|
uint32(NetVersion),
|
2014-10-20 02:53:11 -07:00
|
|
|
self.ethereum.ChainManager().TD,
|
|
|
|
self.ethereum.ChainManager().CurrentBlock.Hash(),
|
|
|
|
self.ethereum.ChainManager().Genesis().Hash(),
|
2014-09-10 02:22:19 -07:00
|
|
|
})
|
|
|
|
|
|
|
|
self.QueueMessage(msg)
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (self *Peer) handleStatus(msg *wire.Msg) {
|
2014-09-10 02:22:19 -07:00
|
|
|
c := msg.Data
|
2014-09-14 05:09:46 -07:00
|
|
|
|
|
|
|
var (
|
2014-10-17 08:11:34 -07:00
|
|
|
//protoVersion = c.Get(0).Uint()
|
2014-10-21 04:25:31 -07:00
|
|
|
netVersion = c.Get(1).Uint()
|
|
|
|
td = c.Get(2).BigInt()
|
|
|
|
bestHash = c.Get(3).Bytes()
|
|
|
|
genesis = c.Get(4).Bytes()
|
2014-09-14 05:09:46 -07:00
|
|
|
)
|
2014-09-17 06:58:02 -07:00
|
|
|
|
2014-10-20 02:53:11 -07:00
|
|
|
if bytes.Compare(self.ethereum.ChainManager().Genesis().Hash(), genesis) != 0 {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Warnf("Invalid genisis hash %x. Disabling [eth]\n", genesis)
|
2014-09-17 16:02:15 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if netVersion != NetVersion {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Warnf("Invalid network version %d. Disabling [eth]\n", netVersion)
|
2014-09-17 16:02:15 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-10-17 08:11:34 -07:00
|
|
|
/*
|
|
|
|
if protoVersion != ProtocolVersion {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Warnf("Invalid protocol version %d. Disabling [eth]\n", protoVersion)
|
2014-10-17 08:11:34 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
*/
|
2014-09-10 02:22:19 -07:00
|
|
|
|
|
|
|
// Get the td and last hash
|
2014-09-14 05:09:46 -07:00
|
|
|
self.td = td
|
|
|
|
self.bestHash = bestHash
|
|
|
|
self.lastReceivedHash = bestHash
|
|
|
|
|
|
|
|
self.statusKnown = true
|
2014-09-10 02:22:19 -07:00
|
|
|
|
|
|
|
// Compare the total TD with the blockchain TD. If remote is higher
|
|
|
|
// fetch hashes from highest TD node.
|
2014-10-02 08:35:38 -07:00
|
|
|
self.FetchHashes()
|
2014-09-10 02:22:19 -07:00
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Infof("Peer is [eth] capable. (TD = %v ~ %x)", self.td, self.bestHash)
|
2014-09-14 05:09:46 -07:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
}
|
|
|
|
|
2014-09-14 04:42:02 -07:00
|
|
|
func (p *Peer) pushHandshake() error {
|
|
|
|
pubkey := p.ethereum.KeyManager().PublicKey()
|
2014-10-31 06:53:42 -07:00
|
|
|
msg := wire.NewMessage(wire.MsgHandshakeTy, []interface{}{
|
2014-10-20 02:53:11 -07:00
|
|
|
P2PVersion, []byte(p.version), []interface{}{[]interface{}{"eth", ProtocolVersion}}, p.port, pubkey[1:],
|
2014-09-14 04:42:02 -07:00
|
|
|
})
|
|
|
|
|
|
|
|
p.QueueMessage(msg)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-10-31 06:53:42 -07:00
|
|
|
func (p *Peer) handleHandshake(msg *wire.Msg) {
|
2014-01-23 13:32:50 -08:00
|
|
|
c := msg.Data
|
2014-02-09 14:34:33 -08:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
var (
|
|
|
|
p2pVersion = c.Get(0).Uint()
|
|
|
|
clientId = c.Get(1).Str()
|
2014-09-16 07:36:27 -07:00
|
|
|
caps = c.Get(2)
|
2014-09-10 02:22:19 -07:00
|
|
|
port = c.Get(3).Uint()
|
|
|
|
pub = c.Get(4).Bytes()
|
|
|
|
)
|
2014-06-18 04:06:48 -07:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
// Check correctness of p2p protocol version
|
|
|
|
if p2pVersion != P2PVersion {
|
2014-10-20 02:53:11 -07:00
|
|
|
fmt.Println(p)
|
2014-09-10 02:22:19 -07:00
|
|
|
peerlogger.Debugf("Invalid P2P version. Require protocol %d, received %d\n", P2PVersion, p2pVersion)
|
|
|
|
p.Stop()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle the pub key (validation, uniqueness)
|
2014-09-10 02:39:11 -07:00
|
|
|
if len(pub) == 0 {
|
2014-06-23 04:54:10 -07:00
|
|
|
peerlogger.Warnln("Pubkey required, not supplied in handshake.")
|
2014-06-18 04:06:48 -07:00
|
|
|
p.Stop()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-09-24 02:55:02 -07:00
|
|
|
// Self connect detection
|
|
|
|
pubkey := p.ethereum.KeyManager().PublicKey()
|
|
|
|
if bytes.Compare(pubkey[1:], pub) == 0 {
|
|
|
|
p.Stop()
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-10-02 08:03:48 -07:00
|
|
|
// Check for blacklisting
|
|
|
|
for _, pk := range p.ethereum.blacklist {
|
|
|
|
if bytes.Compare(pk, pub) == 0 {
|
|
|
|
peerlogger.Debugf("Blacklisted peer tried to connect (%x...)\n", pubkey[0:4])
|
|
|
|
p.StopWithReason(DiscBadPeer)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-18 04:06:48 -07:00
|
|
|
usedPub := 0
|
|
|
|
// This peer is already added to the peerlist so we expect to find a double pubkey at least once
|
|
|
|
eachPeer(p.ethereum.Peers(), func(peer *Peer, e *list.Element) {
|
2014-09-10 02:22:19 -07:00
|
|
|
if bytes.Compare(pub, peer.pubkey) == 0 {
|
2014-06-18 04:06:48 -07:00
|
|
|
usedPub++
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
if usedPub > 0 {
|
2014-06-23 04:54:10 -07:00
|
|
|
peerlogger.Debugf("Pubkey %x found more then once. Already connected to client.", p.pubkey)
|
2014-06-18 04:06:48 -07:00
|
|
|
p.Stop()
|
|
|
|
return
|
|
|
|
}
|
2014-09-10 02:22:19 -07:00
|
|
|
p.pubkey = pub
|
2014-01-23 11:14:01 -08:00
|
|
|
|
|
|
|
// If this is an inbound connection send an ack back
|
|
|
|
if p.inbound {
|
2014-09-10 02:22:19 -07:00
|
|
|
p.port = uint16(port)
|
2014-02-13 06:12:16 -08:00
|
|
|
}
|
2014-09-24 02:55:02 -07:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
p.SetVersion(clientId)
|
2014-02-09 14:58:59 -08:00
|
|
|
|
2014-09-10 02:22:19 -07:00
|
|
|
p.versionKnown = true
|
2014-08-21 05:47:58 -07:00
|
|
|
|
2014-06-18 04:06:48 -07:00
|
|
|
p.ethereum.PushPeer(p)
|
2014-10-13 16:58:31 -07:00
|
|
|
p.ethereum.eventMux.Post(PeerListEvent{p.ethereum.Peers()})
|
2014-06-18 04:06:48 -07:00
|
|
|
|
2014-09-23 08:55:34 -07:00
|
|
|
p.protocolCaps = caps
|
2014-10-20 02:53:11 -07:00
|
|
|
|
|
|
|
it := caps.NewIterator()
|
2014-09-17 06:58:02 -07:00
|
|
|
var capsStrs []string
|
2014-10-20 02:53:11 -07:00
|
|
|
for it.Next() {
|
|
|
|
cap := it.Value().Get(0).Str()
|
|
|
|
ver := it.Value().Get(1).Uint()
|
2014-09-17 06:58:02 -07:00
|
|
|
switch cap {
|
2014-09-16 07:36:27 -07:00
|
|
|
case "eth":
|
2014-10-20 02:53:11 -07:00
|
|
|
if ver != ProtocolVersion {
|
2014-10-31 04:56:05 -07:00
|
|
|
loggerger.Warnf("Invalid protocol version %d. Disabling [eth]\n", ver)
|
2014-10-17 08:11:34 -07:00
|
|
|
continue
|
|
|
|
}
|
2014-09-16 07:36:27 -07:00
|
|
|
p.pushStatus()
|
|
|
|
}
|
2014-09-17 06:58:02 -07:00
|
|
|
|
2014-11-03 16:47:02 -08:00
|
|
|
capsStrs = append(capsStrs, fmt.Sprintf("%s/%d", cap, ver))
|
2014-09-16 07:36:27 -07:00
|
|
|
}
|
2014-09-17 06:58:02 -07:00
|
|
|
|
2014-10-31 04:56:05 -07:00
|
|
|
peerlogger.Infof("Added peer (%s) %d / %d (%v)\n", p.conn.RemoteAddr(), p.ethereum.Peers().Len(), p.ethereum.MaxPeers, capsStrs)
|
2014-09-17 06:58:02 -07:00
|
|
|
|
|
|
|
peerlogger.Debugln(p)
|
2014-02-13 06:12:16 -08:00
|
|
|
}
|
|
|
|
|
2014-09-23 08:55:34 -07:00
|
|
|
func (self *Peer) IsCap(cap string) bool {
|
|
|
|
capsIt := self.protocolCaps.NewIterator()
|
|
|
|
for capsIt.Next() {
|
|
|
|
if capsIt.Value().Str() == cap {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2014-09-26 04:45:26 -07:00
|
|
|
func (self *Peer) Caps() *ethutil.Value {
|
|
|
|
return self.protocolCaps
|
|
|
|
}
|
|
|
|
|
2014-02-13 06:12:16 -08:00
|
|
|
func (p *Peer) String() string {
|
|
|
|
var strBoundType string
|
|
|
|
if p.inbound {
|
|
|
|
strBoundType = "inbound"
|
|
|
|
} else {
|
|
|
|
strBoundType = "outbound"
|
|
|
|
}
|
|
|
|
var strConnectType string
|
|
|
|
if atomic.LoadInt32(&p.disconnect) == 0 {
|
|
|
|
strConnectType = "connected"
|
|
|
|
} else {
|
|
|
|
strConnectType = "disconnected"
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-01-30 14:48:52 -08:00
|
|
|
|
2014-11-07 03:18:48 -08:00
|
|
|
return fmt.Sprintf("[%s] (%s) %v %s", strConnectType, strBoundType, p.conn.RemoteAddr(), p.version)
|
2014-01-30 15:56:32 -08:00
|
|
|
|
2014-01-31 11:01:28 -08:00
|
|
|
}
|
2014-02-09 16:09:12 -08:00
|
|
|
|
2014-01-31 11:01:28 -08:00
|
|
|
func (p *Peer) RlpData() []interface{} {
|
2014-02-09 14:34:33 -08:00
|
|
|
return []interface{}{p.host, p.port, p.pubkey}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-05-01 13:13:59 -07:00
|
|
|
|
2014-10-08 03:00:03 -07:00
|
|
|
func packAddr(address, _port string) (host []byte, port uint16) {
|
|
|
|
p, _ := strconv.Atoi(_port)
|
|
|
|
port = uint16(p)
|
2014-05-01 13:13:59 -07:00
|
|
|
|
2014-10-08 03:00:03 -07:00
|
|
|
h := net.ParseIP(address)
|
|
|
|
if ip := h.To4(); ip != nil {
|
|
|
|
host = []byte(ip)
|
|
|
|
} else {
|
|
|
|
host = []byte(h)
|
|
|
|
}
|
|
|
|
|
|
|
|
return
|
2014-05-01 13:13:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func unpackAddr(value *ethutil.Value, p uint64) string {
|
2014-10-08 03:00:03 -07:00
|
|
|
host, _ := net.IP(value.Bytes()).MarshalText()
|
|
|
|
prt := strconv.Itoa(int(p))
|
|
|
|
|
|
|
|
return net.JoinHostPort(string(host), prt)
|
2014-05-01 13:13:59 -07:00
|
|
|
}
|