go-ethereum/peer.go

258 lines
5.3 KiB
Go
Raw Normal View History

2014-01-09 16:15:51 -06:00
package main
import (
2014-01-12 09:50:33 -06:00
"github.com/ethereum/ethutil-go"
2014-01-12 10:19:14 -06:00
"github.com/ethereum/ethwire-go"
2014-01-11 08:27:08 -06:00
"log"
"net"
2014-01-12 15:14:19 -06:00
"sync/atomic"
"time"
2014-01-09 16:15:51 -06:00
)
2014-01-12 16:16:33 -06:00
const (
// The size of the output buffer for writing messages
2014-01-17 09:57:18 -06:00
outputBufferSize = 50
2014-01-12 16:16:33 -06:00
)
2014-01-09 16:15:51 -06:00
type Peer struct {
2014-01-11 08:27:08 -06:00
// Server interface
server *Server
// Net connection
conn net.Conn
// Output queue which is used to communicate and handle messages
2014-01-17 10:51:40 -06:00
outputQueue chan *ethwire.Msg
2014-01-11 08:27:08 -06:00
// Quit channel
quit chan bool
2014-01-12 15:14:19 -06:00
// Determines whether it's an inbound or outbound peer
inbound bool
// Flag for checking the peer's connectivity state
2014-01-17 09:57:18 -06:00
connected int32
2014-01-12 15:14:19 -06:00
disconnect int32
2014-01-12 16:46:03 -06:00
// Last known message send
2014-01-12 15:14:19 -06:00
lastSend time.Time
2014-01-12 16:46:03 -06:00
// 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.
2014-01-12 16:16:33 -06:00
versionKnown bool
2014-01-17 10:14:59 -06:00
// Last received pong message
lastPong int64
2014-01-09 16:15:51 -06:00
}
2014-01-12 09:50:33 -06:00
func NewPeer(conn net.Conn, server *Server, inbound bool) *Peer {
2014-01-11 08:27:08 -06:00
return &Peer{
2014-01-17 10:51:40 -06:00
outputQueue: make(chan *ethwire.Msg, outputBufferSize),
2014-01-11 08:27:08 -06:00
quit: make(chan bool),
2014-01-12 10:19:14 -06:00
server: server,
conn: conn,
inbound: inbound,
2014-01-12 15:14:19 -06:00
disconnect: 0,
connected: 1,
2014-01-11 08:27:08 -06:00
}
2014-01-09 16:15:51 -06:00
}
2014-01-12 15:14:19 -06:00
func NewOutboundPeer(addr string, server *Server) *Peer {
p := &Peer{
2014-01-17 10:51:40 -06:00
outputQueue: make(chan *ethwire.Msg, outputBufferSize),
2014-01-12 15:14:19 -06:00
quit: make(chan bool),
server: server,
inbound: false,
connected: 0,
disconnect: 1,
}
// Set up the connection in another goroutine so we don't block the main thread
go func() {
conn, err := net.Dial("tcp", addr)
if err != nil {
p.Stop()
}
p.conn = conn
// Atomically set the connection state
atomic.StoreInt32(&p.connected, 1)
atomic.StoreInt32(&p.disconnect, 0)
log.Println("Connected to peer ::", conn.RemoteAddr())
2014-01-12 16:16:33 -06:00
p.Start()
2014-01-12 15:14:19 -06:00
}()
return p
}
2014-01-09 16:15:51 -06:00
// Outputs any RLP encoded data to the peer
2014-01-17 10:51:40 -06:00
func (p *Peer) QueueMessage(msg *ethwire.Msg) {
2014-01-12 15:14:19 -06:00
p.outputQueue <- msg
}
2014-01-17 10:51:40 -06:00
func (p *Peer) writeMessage(msg *ethwire.Msg) {
2014-01-12 15:14:19 -06:00
// Ignore the write if we're not connected
if atomic.LoadInt32(&p.connected) != 1 {
return
}
2014-01-12 16:16:33 -06:00
if !p.versionKnown {
2014-01-17 09:57:18 -06:00
switch msg.Type {
case ethwire.MsgHandshakeTy: // Ok
2014-01-12 16:16:33 -06:00
default: // Anything but ack is allowed
return
}
}
2014-01-12 15:14:19 -06:00
err := ethwire.WriteMessage(p.conn, msg)
if err != nil {
log.Println("Can't send message:", err)
// Stop the client if there was an error writing to it
p.Stop()
return
}
2014-01-09 16:15:51 -06:00
}
2014-01-10 03:58:46 -06:00
// Outbound message handler. Outbound messages are handled here
2014-01-09 16:15:51 -06:00
func (p *Peer) HandleOutbound() {
2014-01-17 09:57:18 -06:00
// The ping timer. Makes sure that every 2 minutes a ping is send to the peer
2014-01-17 10:14:59 -06:00
tickleTimer := time.NewTicker(2 * time.Minute)
2014-01-09 16:15:51 -06:00
out:
2014-01-11 08:27:08 -06:00
for {
select {
// Main message queue. All outbound messages are processed through here
case msg := <-p.outputQueue:
2014-01-12 15:14:19 -06:00
p.writeMessage(msg)
2014-01-11 08:27:08 -06:00
2014-01-12 15:14:19 -06:00
p.lastSend = time.Now()
2014-01-17 09:57:18 -06:00
case <-tickleTimer.C:
2014-01-17 10:51:40 -06:00
p.writeMessage(&ethwire.Msg{Type: ethwire.MsgPingTy})
2014-01-17 09:57:18 -06:00
2014-01-11 08:27:08 -06:00
// Break out of the for loop if a quit message is posted
case <-p.quit:
break out
}
}
2014-01-12 15:14:19 -06:00
clean:
// This loop is for draining the output queue and anybody waiting for us
for {
select {
2014-01-17 09:57:18 -06:00
case <-p.outputQueue:
2014-01-12 15:14:19 -06:00
// TODO
default:
break clean
}
}
2014-01-09 16:15:51 -06:00
}
2014-01-10 03:58:46 -06:00
// Inbound handler. Inbound messages are received here and passed to the appropriate methods
2014-01-09 16:15:51 -06:00
func (p *Peer) HandleInbound() {
out:
2014-01-12 15:14:19 -06:00
for atomic.LoadInt32(&p.disconnect) == 0 {
2014-01-11 08:27:08 -06:00
// Wait for a message from the peer
msg, err := ethwire.ReadMessage(p.conn)
if err != nil {
log.Println(err)
break out
}
2014-01-12 09:50:33 -06:00
if Debug {
2014-01-17 09:57:18 -06:00
log.Printf("Received %s\n", msg.Type.String())
2014-01-12 09:50:33 -06:00
}
// TODO Hash data and check if for existence (= ignore)
2014-01-17 09:57:18 -06:00
switch msg.Type {
case ethwire.MsgHandshakeTy:
2014-01-12 09:50:33 -06:00
// Version message
2014-01-17 09:57:18 -06:00
p.handleHandshake(msg)
case ethwire.MsgBlockTy:
err := p.server.blockManager.ProcessBlock(ethutil.NewBlock(ethutil.Encode(msg.Data)))
2014-01-12 09:50:33 -06:00
if err != nil {
log.Println(err)
}
2014-01-17 09:57:18 -06:00
case ethwire.MsgTxTy:
case ethwire.MsgInvTy:
case ethwire.MsgGetPeersTy:
case ethwire.MsgPeersTy:
case ethwire.MsgPingTy:
2014-01-17 10:14:59 -06:00
// Respond back with pong
2014-01-17 10:51:40 -06:00
p.writeMessage(&ethwire.Msg{Type: ethwire.MsgPongTy})
2014-01-17 09:57:18 -06:00
case ethwire.MsgPongTy:
2014-01-17 10:14:59 -06:00
p.lastPong = time.Now().Unix()
2014-01-17 09:57:18 -06:00
/*
case "blockmine":
d, _ := ethutil.Decode(msg.Data, 0)
log.Printf("block mined %s\n", d)
*/
2014-01-12 09:50:33 -06:00
}
2014-01-11 08:27:08 -06:00
}
2014-01-12 15:14:19 -06:00
p.Stop()
2014-01-09 16:15:51 -06:00
}
func (p *Peer) Start() {
2014-01-12 09:50:33 -06:00
if !p.inbound {
2014-01-17 09:57:18 -06:00
err := p.pushHandshake()
2014-01-12 09:50:33 -06:00
if err != nil {
log.Printf("Peer can't send outbound version ack", err)
p.Stop()
}
}
2014-01-11 08:27:08 -06:00
// Run the outbound handler in a new goroutine
go p.HandleOutbound()
// Run the inbound handler in a new goroutine
go p.HandleInbound()
2014-01-09 16:15:51 -06:00
}
func (p *Peer) Stop() {
2014-01-12 15:14:19 -06:00
if atomic.AddInt32(&p.disconnect, 1) != 1 {
return
}
close(p.quit)
if atomic.LoadInt32(&p.connected) != 0 {
p.conn.Close()
}
2014-01-12 15:14:19 -06:00
log.Println("Peer shutdown")
}
2014-01-12 09:50:33 -06:00
2014-01-17 09:57:18 -06:00
func (p *Peer) pushHandshake() error {
msg := ethwire.NewMessage(ethwire.MsgHandshakeTy, ethutil.Encode([]interface{}{
1, 0, p.server.Nonce,
}))
2014-01-12 09:50:33 -06:00
p.QueueMessage(msg)
return nil
}
2014-01-17 10:51:40 -06:00
func (p *Peer) handleHandshake(msg *ethwire.Msg) {
2014-01-17 09:57:18 -06:00
c := ethutil.Conv(msg.Data)
// [PROTOCOL_VERSION, NETWORK_ID, CLIENT_ID]
if c.Get(2).AsUint() == p.server.Nonce {
//if msg.Nonce == p.server.Nonce {
2014-01-12 09:50:33 -06:00
log.Println("Peer connected to self, disconnecting")
p.Stop()
2014-01-12 16:16:33 -06:00
2014-01-12 09:50:33 -06:00
return
}
2014-01-12 16:16:33 -06:00
p.versionKnown = true
2014-01-12 09:50:33 -06:00
// If this is an inbound connection send an ack back
if p.inbound {
2014-01-17 09:57:18 -06:00
err := p.pushHandshake()
2014-01-12 09:50:33 -06:00
if err != nil {
log.Println("Peer can't send ack back")
p.Stop()
}
}
}