Public Release

header.go

@@ -0,0 +1,188 @@
+package nebula
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+//Version 1 header:
+// 0                                                                       31
+// |-----------------------------------------------------------------------|
+// | Version (uint4) | Type (uint4) |  Subtype (uint8) | Reserved (uint16) | 32
+// |-----------------------------------------------------------------------|
+// |                        Remote index (uint32)                          | 64
+// |-----------------------------------------------------------------------|
+// |                           Message counter                             | 96
+// |                               (uint64)                                | 128
+// |-----------------------------------------------------------------------|
+// |                               payload...                              |
+
+const (
+	Version   uint8 = 1
+	HeaderLen       = 16
+)
+
+type NebulaMessageType uint8
+type NebulaMessageSubType uint8
+
+const (
+	handshake   NebulaMessageType = 0
+	message     NebulaMessageType = 1
+	recvError   NebulaMessageType = 2
+	lightHouse  NebulaMessageType = 3
+	test        NebulaMessageType = 4
+	closeTunnel NebulaMessageType = 5
+
+	//TODO These are deprecated as of 06/12/2018 - NB
+	testRemote      NebulaMessageType = 6
+	testRemoteReply NebulaMessageType = 7
+)
+
+var typeMap = map[NebulaMessageType]string{
+	handshake:   "handshake",
+	message:     "message",
+	recvError:   "recvError",
+	lightHouse:  "lightHouse",
+	test:        "test",
+	closeTunnel: "closeTunnel",
+
+	//TODO These are deprecated as of 06/12/2018 - NB
+	testRemote:      "testRemote",
+	testRemoteReply: "testRemoteReply",
+}
+
+const (
+	testRequest NebulaMessageSubType = 0
+	testReply   NebulaMessageSubType = 1
+)
+
+var eHeaderTooShort = errors.New("header is too short")
+
+var subTypeTestMap = map[NebulaMessageSubType]string{
+	testRequest: "testRequest",
+	testReply:   "testReply",
+}
+
+var subTypeNoneMap = map[NebulaMessageSubType]string{0: "none"}
+
+var subTypeMap = map[NebulaMessageType]*map[NebulaMessageSubType]string{
+	message:     &subTypeNoneMap,
+	recvError:   &subTypeNoneMap,
+	lightHouse:  &subTypeNoneMap,
+	test:        &subTypeTestMap,
+	closeTunnel: &subTypeNoneMap,
+	handshake: {
+		handshakeIXPSK0: "ix_psk0",
+	},
+	//TODO: these are deprecated
+	testRemote:      &subTypeNoneMap,
+	testRemoteReply: &subTypeNoneMap,
+}
+
+type Header struct {
+	Version        uint8
+	Type           NebulaMessageType
+	Subtype        NebulaMessageSubType
+	Reserved       uint16
+	RemoteIndex    uint32
+	MessageCounter uint64
+}
+
+// HeaderEncode uses the provided byte array to encode the provided header values into.
+// Byte array must be capped higher than HeaderLen or this will panic
+func HeaderEncode(b []byte, v uint8, t uint8, st uint8, ri uint32, c uint64) []byte {
+	b = b[:HeaderLen]
+	b[0] = byte(v<<4 | (t & 0x0f))
+	b[1] = byte(st)
+	binary.BigEndian.PutUint16(b[2:4], 0)
+	binary.BigEndian.PutUint32(b[4:8], ri)
+	binary.BigEndian.PutUint64(b[8:16], c)
+	return b
+}
+
+// String creates a readable string representation of a header
+func (h *Header) String() string {
+	if h == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("ver=%d type=%s subtype=%s reserved=%#x remoteindex=%v messagecounter=%v",
+		h.Version, h.TypeName(), h.SubTypeName(), h.Reserved, h.RemoteIndex, h.MessageCounter)
+}
+
+// MarshalJSON creates a json string representation of a header
+func (h *Header) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m{
+		"version":        h.Version,
+		"type":           h.TypeName(),
+		"subType":        h.SubTypeName(),
+		"reserved":       h.Reserved,
+		"remoteIndex":    h.RemoteIndex,
+		"messageCounter": h.MessageCounter,
+	})
+}
+
+// Encode turns header into bytes
+func (h *Header) Encode(b []byte) ([]byte, error) {
+	if h == nil {
+		return nil, errors.New("nil header")
+	}
+
+	return HeaderEncode(b, h.Version, uint8(h.Type), uint8(h.Subtype), h.RemoteIndex, h.MessageCounter), nil
+}
+
+// Parse is a helper function to parses given bytes into new Header struct
+func (h *Header) Parse(b []byte) error {
+	if len(b) < HeaderLen {
+		return eHeaderTooShort
+	}
+	// get upper 4 bytes
+	h.Version = uint8((b[0] >> 4) & 0x0f)
+	// get lower 4 bytes
+	h.Type = NebulaMessageType(b[0] & 0x0f)
+	h.Subtype = NebulaMessageSubType(b[1])
+	h.Reserved = binary.BigEndian.Uint16(b[2:4])
+	h.RemoteIndex = binary.BigEndian.Uint32(b[4:8])
+	h.MessageCounter = binary.BigEndian.Uint64(b[8:16])
+	return nil
+}
+
+// TypeName will transform the headers message type into a human string
+func (h *Header) TypeName() string {
+	return TypeName(h.Type)
+}
+
+// TypeName will transform a nebula message type into a human string
+func TypeName(t NebulaMessageType) string {
+	if n, ok := typeMap[t]; ok {
+		return n
+	}
+
+	return "unknown"
+}
+
+// SubTypeName will transform the headers message sub type into a human string
+func (h *Header) SubTypeName() string {
+	return SubTypeName(h.Type, h.Subtype)
+}
+
+// SubTypeName will transform a nebula message sub type into a human string
+func SubTypeName(t NebulaMessageType, s NebulaMessageSubType) string {
+	if n, ok := subTypeMap[t]; ok {
+		if x, ok := (*n)[s]; ok {
+			return x
+		}
+	}
+
+	return "unknown"
+}
+
+// NewHeader turns bytes into a header
+func NewHeader(b []byte) (*Header, error) {
+	h := new(Header)
+	if err := h.Parse(b); err != nil {
+		return nil, err
+	}
+	return h, nil
+}