path: root/peer.go

package main

import (
    "github.com/ethereum/ethwire-go"
    "github.com/ethereum/ethutil-go"
    "log"
    "net"
)

type Peer struct {
    // Server interface
    server *Server
    // Net connection
    conn net.Conn
    // Output queue which is used to communicate and handle messages
    outputQueue chan *ethwire.InOutMsg
    // Quit channel
    quit chan bool

    inbound bool // Determines whether it's an inbound or outbound peer
}

func NewPeer(conn net.Conn, server *Server, inbound bool) *Peer {
    return &Peer{
        outputQueue: make(chan *ethwire.InOutMsg, 1), // Buffered chan of 1 is enough
        quit:        make(chan bool),
        server: server,
        conn:   conn,
        inbound: inbound,
    }
}

// Outputs any RLP encoded data to the peer
func (p *Peer) QueueMessage(msg *ethwire.InOutMsg) {
    p.outputQueue <- msg//ethwire.InOutMsg{MsgType: msgType, Nonce: ethutil.RandomUint64(), Data: data}
}

// Outbound message handler. Outbound messages are handled here
func (p *Peer) HandleOutbound() {
out:
    for {
        select {
        // Main message queue. All outbound messages are processed through here
        case msg := <-p.outputQueue:
            // TODO Message checking and handle accordingly
            err := ethwire.WriteMessage(p.conn, msg)
            if err != nil {
                log.Println(err)

                // Stop the client if there was an error writing to it
                p.Stop()
            }

        // Break out of the for loop if a quit message is posted
        case <-p.quit:
            break out
        }
    }
}

// Inbound handler. Inbound messages are received here and passed to the appropriate methods
func (p *Peer) HandleInbound() {
    defer p.Stop()

out:
    for {
        // Wait for a message from the peer
        msg, err := ethwire.ReadMessage(p.conn)
        if err != nil {
            log.Println(err)

            break out
        }

        if Debug {
            log.Printf("Received %s\n", msg.MsgType)
        }

        // TODO Hash data and check if for existence (= ignore)

        switch msg.MsgType {
        case "verack":
            // Version message
            p.handleVersionAck(msg)
        case "block":
            err := p.server.blockManager.ProcessBlock(ethutil.NewBlock(msg.Data))
            if err != nil {
                log.Println(err)
            }
        }
    }

    // Notify the out handler we're quiting
    p.quit <- true
}

func (p *Peer) Start() {
    if !p.inbound {
        err := p.pushVersionAck()
        if err != nil {
            log.Printf("Peer can't send outbound version ack", err)

            p.Stop()
        }
    }

    // Run the outbound handler in a new goroutine
    go p.HandleOutbound()
    // Run the inbound handler in a new goroutine
    go p.HandleInbound()
}

func (p *Peer) Stop() {
    p.conn.Close()

    p.quit <- true
}

func (p *Peer) pushVersionAck() error {
    msg := ethwire.NewMessage("verack", p.server.Nonce, []byte("01"))

    p.QueueMessage(msg)

    return nil
}

func (p *Peer) handleVersionAck(msg *ethwire.InOutMsg) {
    // Detect self connect
    if msg.Nonce == p.server.Nonce {
        log.Println("Peer connected to self, disconnecting")

        p.Stop()
        return
    }

    log.Println("mnonce", msg.Nonce, "snonce", p.server.Nonce)

    // If this is an inbound connection send an ack back
    if p.inbound {
        err := p.pushVersionAck()
        if err != nil {
            log.Println("Peer can't send ack back")

            p.Stop()
        }
    }
}