-
Notifications
You must be signed in to change notification settings - Fork 1
/
message.go
111 lines (88 loc) · 2.32 KB
/
message.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// Copyright 2020 Condensat Tech. All rights reserved.
// Use of this source code is governed by a MIT
// license that can be found in the LICENSE file.
package messaging
import (
"bytes"
"encoding/gob"
"errors"
"github.com/emef/bitfield"
)
type MessageFlag uint32
const (
CurrentVersion = "1.0"
flagCompressed MessageFlag = 0
flagEncrypted MessageFlag = 1
flagSigned MessageFlag = 2
)
var (
ErrNoData = errors.New("No Data")
ErrInvalidMessage = errors.New("Invalid Message")
ErrOperationNotPermited = errors.New("Operation Not Permited")
)
// Message used for all communication between components
type Message struct {
Version string // Version for compatibility
From string `json:",omitempty"` // From is the public key of sender
Data []byte `json:",omitempty"` // Data payload
Flags uint `json:",omitempty"` // Flags for Compressed, Encrypted, Signed
Error string `json:",omitempty"` // Error in message processing
}
func NewMessage() *Message {
return &Message{
Version: CurrentVersion,
}
}
func (m *Message) SetCompressed(compressed bool) {
m.setFlag(flagCompressed, compressed)
}
func (m *Message) SetEncrypted(encrypted bool) {
m.setFlag(flagEncrypted, encrypted)
}
func (m *Message) SetSigned(signed bool) {
m.setFlag(flagSigned, signed)
}
func (m *Message) IsCompressed() bool {
return m.getFlag(flagCompressed)
}
func (m *Message) IsEncrypted() bool {
return m.getFlag(flagEncrypted)
}
func (m *Message) IsSigned() bool {
return m.getFlag(flagSigned)
}
// Encode return bytes from Message. Encoded with gob
func (m *Message) Encode() ([]byte, error) {
buffer := new(bytes.Buffer)
enc := gob.NewEncoder(buffer)
err := enc.Encode(m)
if err != nil {
return nil, err
}
return buffer.Bytes(), nil
}
// Decode return Message from bytes. Decoded with gob
func (m *Message) Decode(data []byte) error {
buffer := bytes.NewReader(data)
dec := gob.NewDecoder(buffer)
err := dec.Decode(m)
if err != nil {
return err
}
return nil
}
func (m *Message) getFlag(flag MessageFlag) bool {
b := bitfield.NewFromUint32(uint32(m.Flags))
f := uint32(flag)
return b.Test(f)
}
func (m *Message) setFlag(flag MessageFlag, enable bool) {
b := bitfield.NewFromUint32(uint32(m.Flags))
f := uint32(flag)
if enable {
b.Set(f)
} else {
b.Clear(f)
}
m.Flags = uint(b.ToUint32Safe())
}