/
shared.go
110 lines (92 loc) · 2.21 KB
/
shared.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
package gobore
import (
"encoding/json"
"errors"
"io"
"net"
"time"
"go.uber.org/zap"
)
const (
controlPort = 16001
timeout = 3 * time.Second
)
type clientMessageType string
const (
clientMessageAuthenticate clientMessageType = "Authenticate"
clientMessageHello clientMessageType = "Hello"
clientMessageAccept clientMessageType = "Accept"
)
type clientMessage struct {
Type clientMessageType `json:"type"`
Authenticate string `json:"authenticate,omitempty"`
Hello uint16 `json:"hello,omitempty"`
Accept string `json:"accept,omitempty"`
}
type serverMessageType string
const (
serverMessageChallenge serverMessageType = "Challenge"
serverMessageHello serverMessageType = "Hello"
serverMessageConnection serverMessageType = "Connection"
serverMessageError serverMessageType = "Error"
)
type serverMessage struct {
Type serverMessageType `json:"type"`
Challenge string `json:"challenge,omitempty"`
Hello uint16 `json:"hello,omitempty"`
Connection string `json:"connection,omitempty"`
Error string `json:"error,omitempty"`
}
func proxy(ctlConn, dataConn net.Conn) {
go func() {
_, err := io.Copy(ctlConn, dataConn)
if err != nil {
zap.L().Error("Failed to Copy", zap.Error(err))
return
}
}()
_, err := io.Copy(dataConn, ctlConn)
if err != nil {
zap.L().Error("Failed to Copy", zap.Error(err))
}
return
}
func recvJson(r io.Reader, v interface{}) error {
buf := make([]byte, 4096)
for {
n, err := r.Read(buf)
if err != nil {
return err
}
zap.L().Debug("msg", zap.String("msg", string(buf[:n])))
err = json.Unmarshal(buf[:n], v)
if err != nil {
return err
}
return nil
}
}
func recvJsonWithTimeout(r io.Reader, v interface{}) error {
done := make(chan error)
go func() {
err := recvJson(r, v)
done <- err
}()
select {
case err := <-done:
return err
case <-time.After(timeout):
return errors.New("timed out waiting for initial message")
}
}
func sendJson(w io.Writer, msg interface{}) (err error) {
data, err := json.Marshal(msg)
if err != nil {
return err
}
_, err = w.Write(data)
if err != nil {
return err
}
return nil
}