/
connection.go
128 lines (105 loc) · 2.5 KB
/
connection.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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package main
import (
"github.com/KingsEpic/kinglib"
// "bufio"
"bytes"
"encoding/gob"
"fmt"
"reflect"
// "io"
// "log"
"net"
)
var connection *Connection
type Connection struct {
NetConn net.Conn
Decoder *gob.Decoder
Encoder *gob.Encoder
Outgoing chan interface{}
Quit chan bool
recv_buffer_decoder *gob.Decoder
recv_buffer_encoder *gob.Encoder
recv_buffer *bytes.Buffer
send_buffer_decoder *gob.Decoder
send_buffer_encoder *gob.Encoder
send_buffer *bytes.Buffer
}
func (c *Connection) Init() {
c.send_buffer = new(bytes.Buffer)
c.recv_buffer = new(bytes.Buffer)
c.send_buffer_decoder = gob.NewDecoder(c.send_buffer)
c.send_buffer_encoder = gob.NewEncoder(c.send_buffer)
c.recv_buffer_decoder = gob.NewDecoder(c.recv_buffer)
c.recv_buffer_encoder = gob.NewEncoder(c.recv_buffer)
c.Quit = make(chan bool)
c.Outgoing = make(chan interface{}, 1000)
}
func (c *Connection) DecodeData(data []byte, i interface{}) {
c.recv_buffer.Write(data)
c.recv_buffer_decoder.Decode(i)
c.recv_buffer.Reset()
}
func (c *Connection) reader() {
for {
packet := &kinglib.Packet{}
err := c.Decoder.Decode(packet)
if err != nil {
fmt.Printf("Error decoding: %s\n", err)
break
}
packets <- packet
}
c.Quit <- true
}
func (c *Connection) writer() {
Loop:
for {
select {
case obj := <-c.Outgoing:
c.send_buffer.Reset()
p := kinglib.Packet{}
st := kinglib.GetSubType(obj)
p.SubType = st
if p.SubType != 0 {
c.send_buffer_encoder.Encode(obj)
p.Data = c.send_buffer.Bytes()
err := c.Encoder.Encode(p)
if err != nil {
fmt.Printf("Error encoding: %s\n", err)
break Loop
}
// fmt.Printf("Sending %d\n", atcount)
// atcount++
} else {
fmt.Printf("Unknown object type, could not send message: %v", reflect.TypeOf(obj).String())
}
case <-c.Quit:
break Loop
}
}
}
func (c *Connection) SendGob(obj interface{}) {
c.Outgoing <- obj
}
func (c *Connection) HandleConnection() {
go c.reader()
c.writer()
// TODO: cleaner handling of killed connections.
// connection = nil
}
func connect() error {
tcpAddr, err := net.ResolveTCPAddr("tcp4", m.Address)
if err != nil {
// log.Fatal("Could not resovle address: ", err)
return err
}
conn, err := net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
return err
// log.Fatal("Connection err", err)
}
connection = &Connection{NetConn: conn, Decoder: gob.NewDecoder(conn), Encoder: gob.NewEncoder(conn)}
connection.Init()
go connection.HandleConnection()
return nil
}