aboutsummaryrefslogtreecommitdiffstats
path: root/wire/messaging.go
diff options
context:
space:
mode:
Diffstat (limited to 'wire/messaging.go')
-rw-r--r--wire/messaging.go179
1 files changed, 179 insertions, 0 deletions
diff --git a/wire/messaging.go b/wire/messaging.go
new file mode 100644
index 000000000..b919aa0f4
--- /dev/null
+++ b/wire/messaging.go
@@ -0,0 +1,179 @@
+// Package wire provides low level access to the Ethereum network and allows
+// you to broadcast data over the network.
+package wire
+
+import (
+ "bytes"
+ "fmt"
+ "net"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// Connection interface describing the methods required to implement the wire protocol.
+type Conn interface {
+ Write(typ MsgType, v ...interface{}) error
+ Read() *Msg
+}
+
+// The magic token which should be the first 4 bytes of every message and can be used as separator between messages.
+var MagicToken = []byte{34, 64, 8, 145}
+
+type MsgType byte
+
+const (
+ // 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.
+ MsgHandshakeTy = 0x00
+ MsgDiscTy = 0x01
+ MsgPingTy = 0x02
+ MsgPongTy = 0x03
+ MsgGetPeersTy = 0x04
+ MsgPeersTy = 0x05
+
+ MsgStatusTy = 0x10
+ //MsgGetTxsTy = 0x11
+ MsgTxTy = 0x12
+ MsgGetBlockHashesTy = 0x13
+ MsgBlockHashesTy = 0x14
+ MsgGetBlocksTy = 0x15
+ MsgBlockTy = 0x16
+ MsgNewBlockTy = 0x17
+)
+
+var msgTypeToString = map[MsgType]string{
+ MsgHandshakeTy: "Handshake",
+ MsgDiscTy: "Disconnect",
+ MsgPingTy: "Ping",
+ MsgPongTy: "Pong",
+ MsgGetPeersTy: "Get peers",
+ MsgStatusTy: "Status",
+ MsgPeersTy: "Peers",
+ MsgTxTy: "Transactions",
+ MsgBlockTy: "Blocks",
+ //MsgGetTxsTy: "Get Txs",
+ MsgGetBlockHashesTy: "Get block hashes",
+ MsgBlockHashesTy: "Block hashes",
+ MsgGetBlocksTy: "Get blocks",
+}
+
+func (mt MsgType) String() string {
+ return msgTypeToString[mt]
+}
+
+type Msg struct {
+ Type MsgType // Specifies how the encoded data should be interpreted
+ //Data []byte
+ Data *ethutil.Value
+}
+
+func NewMessage(msgType MsgType, data interface{}) *Msg {
+ return &Msg{
+ Type: msgType,
+ Data: ethutil.NewValue(data),
+ }
+}
+
+type Messages []*Msg
+
+// The basic message reader waits for data on the given connection, decoding
+// and doing a few sanity checks such as if there's a data type and
+// unmarhals the given data
+func ReadMessages(conn net.Conn) (msgs []*Msg, err error) {
+ // The recovering function in case anything goes horribly wrong
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("wire.ReadMessage error: %v", r)
+ }
+ }()
+
+ var (
+ buff []byte
+ messages [][]byte
+ msgLength int
+ )
+
+ for {
+ // Give buffering some time
+ conn.SetReadDeadline(time.Now().Add(5 * time.Millisecond))
+ // Create a new temporarily buffer
+ b := make([]byte, 1440)
+ n, _ := conn.Read(b)
+ if err != nil && n == 0 {
+ if err.Error() != "EOF" {
+ fmt.Println("err now", err)
+ return nil, err
+ } else {
+ break
+ }
+ }
+
+ if n == 0 && len(buff) == 0 {
+ // If there's nothing on the wire wait for a bit
+ time.Sleep(200 * time.Millisecond)
+
+ continue
+ }
+
+ buff = append(buff, b[:n]...)
+ if msgLength == 0 {
+ // Check if the received 4 first bytes are the magic token
+ if bytes.Compare(MagicToken, buff[:4]) != 0 {
+ return nil, fmt.Errorf("MagicToken mismatch. Received %v", buff[:4])
+ }
+
+ // Read the length of the message
+ msgLength = int(ethutil.BytesToNumber(buff[4:8]))
+
+ // Remove the token and length
+ buff = buff[8:]
+ }
+
+ if len(buff) >= msgLength {
+ messages = append(messages, buff[:msgLength])
+ buff = buff[msgLength:]
+ msgLength = 0
+
+ if len(buff) == 0 {
+ break
+ }
+ }
+ }
+
+ for _, m := range messages {
+ decoder := ethutil.NewValueFromBytes(m)
+ // Type of message
+ t := decoder.Get(0).Uint()
+ // Actual data
+ d := decoder.SliceFrom(1)
+
+ msgs = append(msgs, &Msg{Type: MsgType(t), Data: d})
+ }
+
+ return
+}
+
+// The basic message writer takes care of writing data over the given
+// connection and does some basic error checking
+func WriteMessage(conn net.Conn, msg *Msg) error {
+ var pack []byte
+
+ // Encode the type and the (RLP encoded) data for sending over the wire
+ encoded := ethutil.NewValue(append([]interface{}{byte(msg.Type)}, msg.Data.Slice()...)).Encode()
+ payloadLength := ethutil.NumberToBytes(uint32(len(encoded)), 32)
+
+ // Write magic token and payload length (first 8 bytes)
+ pack = append(MagicToken, payloadLength...)
+ pack = append(pack, encoded...)
+ //fmt.Printf("payload %v (%v) %q\n", msg.Type, conn.RemoteAddr(), encoded)
+
+ // Write to the connection
+ _, err := conn.Write(pack)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}