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
|
package core
import (
"encoding/binary"
"fmt"
"io"
"log"
"net"
"time"
)
func Send(conn net.Conn, dataType DataType, data Marshaler) error {
packet := []any{uint8(dataType)}
packet = append(packet, data.Marshal()...)
for _, v := range packet {
err := binary.Write(conn, binary.BigEndian, v)
if err != nil {
return fmt.Errorf("cannot send: %v", err)
}
}
return nil
}
func Read(r io.Reader) (any, error) {
dType, err := ReadDataType(r)
if err != nil {
return nil, fmt.Errorf("cannot read data type", err)
}
switch dType {
case TypeUnknown:
return nil, fmt.Errorf("cannot read data type 0x00 (TypeUnknown)")
case TypeHandshake:
return ReadHandshake(r)
case TypePing:
return Ping{}, nil
case TypePong:
return ReadPong(r)
case TypeTest:
return ReadTest(r)
default:
return nil, fmt.Errorf("unsupported type: %v", dType)
}
}
func Loop(conn net.Conn) error {
for {
d, err := Read(conn)
if err != nil {
return fmt.Errorf("cannot read data: %v", err)
}
if err := handleEvent(d, conn); err != nil {
return fmt.Errorf("cannot handle event: %v", err)
}
}
}
func handleEvent(data any, conn net.Conn) error {
switch v := data.(type) {
case Handshake:
case Ping:
log.Print("received ping")
return Send(conn, TypePong, Pong{time.Now()})
case Pong:
log.Print("received pong ", v.Timestamp)
case Test:
default:
return fmt.Errorf("unknown type")
}
return nil
}
|
