purgatory/pingtunnel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
esrrhs 2019-10-27 18:16:57 +08:00
parent 6ad90d18aa
commit 79a278a90f
5 changed files with 233 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
client.go
View File

@ -217,9 +217,10 @@ func (p *Client) AcceptTcpConn(conn *net.TCPConn) {
loggo.Info("client accept new local tcp %s %s", uuid, tcpsrcaddr.String()) loggo.Info("client accept new local tcp %s %s", uuid, tcpsrcaddr.String())
loggo.Info("start connect remote tcp %s %s", uuid, tcpsrcaddr.String()) loggo.Info("start connect remote tcp %s %s", uuid, tcpsrcaddr.String())
clientConn.fm.Connect()
startConnectTime := time.Now() startConnectTime := time.Now()
for { for {
if clientConn.fm.IsRemoteConnected() { if clientConn.fm.IsConnected() {
break break
} }
clientConn.fm.Update() clientConn.fm.Update()

166
framemgr.go
View File

@ -35,7 +35,7 @@ type FrameMgr struct {
reqmap map[int32]int64 reqmap map[int32]int64
sendmap map[int32]int64 sendmap map[int32]int64
remote_connected bool connected bool
} }
func NewFrameMgr(buffersize int, windowsize int, resend_timems int) *FrameMgr { func NewFrameMgr(buffersize int, windowsize int, resend_timems int) *FrameMgr {
@ -51,7 +51,7 @@ func NewFrameMgr(buffersize int, windowsize int, resend_timems int) *FrameMgr {
close: false, remoteclosed: false, closesend: false, close: false, remoteclosed: false, closesend: false,
lastPingTime: time.Now().UnixNano(), rttns: (int64)(resend_timems * 1000), lastPingTime: time.Now().UnixNano(), rttns: (int64)(resend_timems * 1000),
reqmap: make(map[int32]int64), sendmap: make(map[int32]int64), reqmap: make(map[int32]int64), sendmap: make(map[int32]int64),
remote_connected: false} connected: false}
return fm return fm
} }
@ -76,8 +76,6 @@ func (fm *FrameMgr) Update() {
fm.combineWindowToRecvBuffer() fm.combineWindowToRecvBuffer()
fm.tryConnect()
fm.calSendList() fm.calSendList()
fm.ping() fm.ping()
@ -85,10 +83,6 @@ func (fm *FrameMgr) Update() {
func (fm *FrameMgr) cutSendBufferToWindow() { func (fm *FrameMgr) cutSendBufferToWindow() {
if !fm.remote_connected {
return
}
sendall := false sendall := false
if fm.sendb.Size() < FRAME_MAX_SIZE { if fm.sendb.Size() < FRAME_MAX_SIZE {
@ -96,10 +90,13 @@ func (fm *FrameMgr) cutSendBufferToWindow() {
} }
for fm.sendb.Size() >= FRAME_MAX_SIZE && fm.sendwin.Len() < fm.windowsize { for fm.sendb.Size() >= FRAME_MAX_SIZE && fm.sendwin.Len() < fm.windowsize {
f := &Frame{Type: (int32)(Frame_DATA), Resend: false, Sendtime: 0, fd := &FrameData{Type: (int32)(FrameData_USER_DATA),
Id: (int32)(fm.sendid),
Data: make([]byte, FRAME_MAX_SIZE)} Data: make([]byte, FRAME_MAX_SIZE)}
fm.sendb.Read(f.Data) fm.sendb.Read(fd.Data)
f := &Frame{Type: (int32)(Frame_DATA),
Id: (int32)(fm.sendid),
Data: fd}
fm.sendid++ fm.sendid++
if fm.sendid >= FRAME_MAX_ID { if fm.sendid >= FRAME_MAX_ID {
@ -111,10 +108,13 @@ func (fm *FrameMgr) cutSendBufferToWindow() {
} }
if sendall && fm.sendb.Size() > 0 && fm.sendwin.Len() < fm.windowsize { if sendall && fm.sendb.Size() > 0 && fm.sendwin.Len() < fm.windowsize {
f := &Frame{Type: (int32)(Frame_DATA), Resend: false, Sendtime: 0, fd := &FrameData{Type: (int32)(FrameData_USER_DATA),
Id: (int32)(fm.sendid),
Data: make([]byte, fm.sendb.Size())} Data: make([]byte, fm.sendb.Size())}
fm.sendb.Read(f.Data) fm.sendb.Read(fd.Data)
f := &Frame{Type: (int32)(Frame_DATA),
Id: (int32)(fm.sendid),
Data: fd}
fm.sendid++ fm.sendid++
if fm.sendid >= FRAME_MAX_ID { if fm.sendid >= FRAME_MAX_ID {
@ -122,20 +122,22 @@ func (fm *FrameMgr) cutSendBufferToWindow() {
} }
fm.sendwin.PushBack(f) fm.sendwin.PushBack(f)
loggo.Debug("cut small frame push to send win %d %d %d", f.Id, len(f.Data), fm.sendwin.Len()) loggo.Debug("cut small frame push to send win %d %d %d", f.Id, len(f.Data.Data), fm.sendwin.Len())
} }
if fm.sendb.Empty() && fm.close && !fm.closesend && fm.sendwin.Len() < fm.windowsize { if fm.sendb.Empty() && fm.close && !fm.closesend && fm.sendwin.Len() < fm.windowsize {
f := &Frame{Type: (int32)(Frame_DATA), Resend: false, Sendtime: 0, fd := &FrameData{Type: (int32)(FrameData_CLOSE)}
f := &Frame{Type: (int32)(Frame_DATA),
Id: (int32)(fm.sendid), Id: (int32)(fm.sendid),
Data: make([]byte, 0)} Data: fd}
fm.sendwin.PushBack(f)
fm.sendid++ fm.sendid++
if fm.sendid >= FRAME_MAX_ID { if fm.sendid >= FRAME_MAX_ID {
fm.sendid = 0 fm.sendid = 0
} }
fm.sendwin.PushBack(f)
fm.closesend = true fm.closesend = true
loggo.Debug("close frame push to send win %d %d", f.Id, fm.sendwin.Len()) loggo.Debug("close frame push to send win %d %d", f.Id, fm.sendwin.Len())
} }
@ -143,10 +145,6 @@ func (fm *FrameMgr) cutSendBufferToWindow() {
func (fm *FrameMgr) calSendList() { func (fm *FrameMgr) calSendList() {
if !fm.remote_connected {
return
}
cur := time.Now().UnixNano() cur := time.Now().UnixNano()
for e := fm.sendwin.Front(); e != nil; e = e.Next() { for e := fm.sendwin.Front(); e != nil; e = e.Next() {
f := e.Value.(*Frame) f := e.Value.(*Frame)
@ -157,7 +155,7 @@ func (fm *FrameMgr) calSendList() {
fm.sendlist.PushBack(f) fm.sendlist.PushBack(f)
f.Resend = false f.Resend = false
fm.sendmap[f.Id] = cur fm.sendmap[f.Id] = cur
loggo.Debug("push frame to sendlist %d %d", f.Id, len(f.Data)) loggo.Debug("push frame to sendlist %d %d", f.Id, len(f.Data.Data))
} }
} }
} }
@ -194,17 +192,13 @@ func (fm *FrameMgr) preProcessRecvList() (map[int32]int, map[int32]int, map[int3
} }
} else if f.Type == (int32)(Frame_DATA) { } else if f.Type == (int32)(Frame_DATA) {
tmpackto[f.Id] = f tmpackto[f.Id] = f
loggo.Debug("recv data %d %d", f.Id, len(f.Data)) loggo.Debug("recv data %d %d", f.Id, len(f.Data.Data))
} else if f.Type == (int32)(Frame_PING) { } else if f.Type == (int32)(Frame_PING) {
fm.processPing(f) fm.processPing(f)
} else if f.Type == (int32)(Frame_PONG) { } else if f.Type == (int32)(Frame_PONG) {
fm.processPong(f) fm.processPong(f)
} else if f.Type == (int32)(Frame_REG) { } else {
fm.processReg(f) loggo.Error("error frame type %s", f.Type)
} else if f.Type == (int32)(Frame_REGACK) {
fm.processRegAck(f)
} else if f.Type == (int32)(Frame_REGAGAIN) {
fm.processRegAgain(f)
} }
} }
fm.recvlist.Init() fm.recvlist.Init()
@ -213,16 +207,12 @@ func (fm *FrameMgr) preProcessRecvList() (map[int32]int, map[int32]int, map[int3
func (fm *FrameMgr) processRecvList(tmpreq map[int32]int, tmpack map[int32]int, tmpackto map[int32]*Frame) { func (fm *FrameMgr) processRecvList(tmpreq map[int32]int, tmpack map[int32]int, tmpackto map[int32]*Frame) {
if !fm.remote_connected {
return
}
for id, _ := range tmpreq { for id, _ := range tmpreq {
for e := fm.sendwin.Front(); e != nil; e = e.Next() { for e := fm.sendwin.Front(); e != nil; e = e.Next() {
f := e.Value.(*Frame) f := e.Value.(*Frame)
if f.Id == id { if f.Id == id {
f.Resend = true f.Resend = true
loggo.Debug("choose resend win %d %d", f.Id, len(f.Data)) loggo.Debug("choose resend win %d %d", f.Id, len(f.Data.Data))
break break
} }
} }
@ -234,7 +224,7 @@ func (fm *FrameMgr) processRecvList(tmpreq map[int32]int, tmpack map[int32]int,
if f.Id == id { if f.Id == id {
fm.sendwin.Remove(e) fm.sendwin.Remove(e)
delete(fm.sendmap, f.Id) delete(fm.sendmap, f.Id)
loggo.Debug("remove send win %d %d", f.Id, len(f.Data)) loggo.Debug("remove send win %d %d", f.Id, len(f.Data.Data))
break break
} }
} }
@ -247,7 +237,7 @@ func (fm *FrameMgr) processRecvList(tmpreq map[int32]int, tmpack map[int32]int,
if fm.addToRecvWin(rf) { if fm.addToRecvWin(rf) {
tmp[index] = id tmp[index] = id
index++ index++
loggo.Debug("add data to win %d %d", rf.Id, len(rf.Data)) loggo.Debug("add data to win %d %d", rf.Id, len(rf.Data.Data))
} }
} }
if index > 0 { if index > 0 {
@ -273,7 +263,7 @@ func (fm *FrameMgr) addToRecvWin(rf *Frame) bool {
for e := fm.recvwin.Front(); e != nil; e = e.Next() { for e := fm.recvwin.Front(); e != nil; e = e.Next() {
f := e.Value.(*Frame) f := e.Value.(*Frame)
if f.Id == rf.Id { if f.Id == rf.Id {
loggo.Debug("recv frame ignore %d %d", f.Id, len(f.Data)) loggo.Debug("recv frame ignore %d %d", f.Id, len(f.Data.Data))
return true return true
} }
} }
@ -283,38 +273,58 @@ func (fm *FrameMgr) addToRecvWin(rf *Frame) bool {
loggo.Debug("start insert recv win %d %d %d", fm.recvid, rf.Id, f.Id) loggo.Debug("start insert recv win %d %d %d", fm.recvid, rf.Id, f.Id)
if fm.compareId((int)(rf.Id), (int)(f.Id)) < 0 { if fm.compareId((int)(rf.Id), (int)(f.Id)) < 0 {
fm.recvwin.InsertBefore(rf, e) fm.recvwin.InsertBefore(rf, e)
loggo.Debug("insert recv win %d %d before %d", rf.Id, len(rf.Data), f.Id) loggo.Debug("insert recv win %d %d before %d", rf.Id, len(rf.Data.Data), f.Id)
return true return true
} }
} }
fm.recvwin.PushBack(rf) fm.recvwin.PushBack(rf)
loggo.Debug("insert recv win last %d %d", rf.Id, len(rf.Data)) loggo.Debug("insert recv win last %d %d", rf.Id, len(rf.Data.Data))
return true return true
} }
func (fm *FrameMgr) combineWindowToRecvBuffer() { func (fm *FrameMgr) processRecvFrame(f *Frame) bool {
if f.Data.Type == (int32)(FrameData_USER_DATA) {
if !fm.remote_connected { left := fm.recvb.Capacity() - fm.recvb.Size()
return if left >= len(f.Data.Data) {
fm.recvb.Write(f.Data.Data)
loggo.Debug("combined recv frame to recv buffer %d %d",
f.Id, len(f.Data.Data))
return true
} }
} else if f.Data.Type == (int32)(FrameData_CLOSE) {
fm.remoteclosed = true
loggo.Debug("recv remote close frame %d", f.Id)
return true
} else if f.Data.Type == (int32)(FrameData_CONN) {
fm.sendConnectRsp()
fm.connected = true
loggo.Debug("recv remote conn frame %d", f.Id)
return true
} else if f.Data.Type == (int32)(FrameData_CONNRSP) {
fm.connected = true
loggo.Debug("recv remote conn rsp frame %d", f.Id)
return true
} else {
loggo.Error("recv frame type error %d", f.Data.Type)
return false
}
return false
}
func (fm *FrameMgr) combineWindowToRecvBuffer() {
for { for {
done := false done := false
for e := fm.recvwin.Front(); e != nil; e = e.Next() { for e := fm.recvwin.Front(); e != nil; e = e.Next() {
f := e.Value.(*Frame) f := e.Value.(*Frame)
if f.Id == (int32)(fm.recvid) { if f.Id == (int32)(fm.recvid) {
left := fm.recvb.Capacity() - fm.recvb.Size()
if left >= len(f.Data) {
if len(f.Data) == 0 {
fm.remoteclosed = true
loggo.Debug("recv remote close frame %d", f.Id)
}
fm.recvb.Write(f.Data)
fm.recvwin.Remove(e)
delete(fm.reqmap, f.Id) delete(fm.reqmap, f.Id)
if fm.processRecvFrame(f) {
fm.recvwin.Remove(e)
done = true done = true
loggo.Debug("combined recv frame to recv buffer %d %d", f.Id, len(f.Data)) loggo.Debug("process recv frame ok %d %d",
f.Id, len(f.Data.Data))
break break
} }
} }
@ -395,10 +405,6 @@ func (fm *FrameMgr) IsRemoteClosed() bool {
} }
func (fm *FrameMgr) ping() { func (fm *FrameMgr) ping() {
if !fm.remote_connected {
return
}
cur := time.Now().UnixNano() cur := time.Now().UnixNano()
if cur-fm.lastPingTime > (int64)(time.Second) { if cur-fm.lastPingTime > (int64)(time.Second) {
f := &Frame{Type: (int32)(Frame_PING), Resend: false, Sendtime: cur, f := &Frame{Type: (int32)(Frame_PING), Resend: false, Sendtime: cur,
@ -471,32 +477,38 @@ func (fm *FrameMgr) isIdOld(id int, maxid int) bool {
return false return false
} }
func (fm *FrameMgr) IsRemoteConnected() bool { func (fm *FrameMgr) IsConnected() bool {
return fm.remote_connected return fm.connected
} }
func (fm *FrameMgr) tryConnect() { func (fm *FrameMgr) Connect() {
if !fm.remote_connected { fd := &FrameData{Type: (int32)(FrameData_CONN)}
f := &Frame{Type: (int32)(Frame_REG)}
fm.sendlist.PushBack(f) f := &Frame{Type: (int32)(Frame_DATA),
loggo.Debug("try connect") Id: (int32)(fm.sendid),
} Data: fd}
fm.sendid++
if fm.sendid >= FRAME_MAX_ID {
fm.sendid = 0
} }
func (fm *FrameMgr) processReg(f *Frame) { fm.sendwin.PushBack(f)
rf := &Frame{Type: (int32)(Frame_REGACK)} loggo.Debug("start connect")
fm.sendlist.PushBack(rf)
loggo.Debug("recv reg ")
} }
func (fm *FrameMgr) processRegAck(f *Frame) { func (fm *FrameMgr) sendConnectRsp() {
rf := &Frame{Type: (int32)(Frame_REGAGAIN)} fd := &FrameData{Type: (int32)(FrameData_CONNRSP)}
fm.sendlist.PushBack(rf)
fm.remote_connected = true f := &Frame{Type: (int32)(Frame_DATA),
loggo.Debug("recv reg ack ") Id: (int32)(fm.sendid),
Data: fd}
fm.sendid++
if fm.sendid >= FRAME_MAX_ID {
fm.sendid = 0
} }
func (fm *FrameMgr) processRegAgain(f *Frame) { fm.sendwin.PushBack(f)
fm.remote_connected = true loggo.Debug("send connect rsp")
loggo.Debug("recv reg ack again ")
} }

153
msg.pb.go
View File

@ -48,6 +48,37 @@ func (MyMsg_TYPE) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_c06e4cca6c2cc899, []int{0, 0} return fileDescriptor_c06e4cca6c2cc899, []int{0, 0}
} }
type FrameData_TYPE int32
const (
FrameData_USER_DATA FrameData_TYPE = 0
FrameData_CONN FrameData_TYPE = 1
FrameData_CONNRSP FrameData_TYPE = 2
FrameData_CLOSE FrameData_TYPE = 3
)
var FrameData_TYPE_name = map[int32]string{
0: "USER_DATA",
1: "CONN",
2: "CONNRSP",
3: "CLOSE",
}
var FrameData_TYPE_value = map[string]int32{
"USER_DATA": 0,
"CONN": 1,
"CONNRSP": 2,
"CLOSE": 3,
}
func (x FrameData_TYPE) String() string {
return proto.EnumName(FrameData_TYPE_name, int32(x))
}
func (FrameData_TYPE) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_c06e4cca6c2cc899, []int{1, 0}
}
type Frame_TYPE int32 type Frame_TYPE int32
const ( const (
@ -56,9 +87,6 @@ const (
Frame_ACK Frame_TYPE = 2 Frame_ACK Frame_TYPE = 2
Frame_PING Frame_TYPE = 3 Frame_PING Frame_TYPE = 3
Frame_PONG Frame_TYPE = 4 Frame_PONG Frame_TYPE = 4
Frame_REG Frame_TYPE = 5
Frame_REGACK Frame_TYPE = 6
Frame_REGAGAIN Frame_TYPE = 7
) )
var Frame_TYPE_name = map[int32]string{ var Frame_TYPE_name = map[int32]string{
@ -67,9 +95,6 @@ var Frame_TYPE_name = map[int32]string{
2: "ACK", 2: "ACK",
3: "PING", 3: "PING",
4: "PONG", 4: "PONG",
5: "REG",
6: "REGACK",
7: "REGAGAIN",
} }
var Frame_TYPE_value = map[string]int32{ var Frame_TYPE_value = map[string]int32{
@ -78,9 +103,6 @@ var Frame_TYPE_value = map[string]int32{
"ACK": 2, "ACK": 2,
"PING": 3, "PING": 3,
"PONG": 4, "PONG": 4,
"REG": 5,
"REGACK": 6,
"REGAGAIN": 7,
} }
func (x Frame_TYPE) String() string { func (x Frame_TYPE) String() string {
@ -88,7 +110,7 @@ func (x Frame_TYPE) String() string {
} }
func (Frame_TYPE) EnumDescriptor() ([]byte, []int) { func (Frame_TYPE) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_c06e4cca6c2cc899, []int{1, 0} return fileDescriptor_c06e4cca6c2cc899, []int{2, 0}
} }
type MyMsg struct { type MyMsg struct {
@ -218,12 +240,59 @@ func (m *MyMsg) GetTimeout() int32 {
return 0 return 0
} }
type FrameData struct {
Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FrameData) Reset() { *m = FrameData{} }
func (m *FrameData) String() string { return proto.CompactTextString(m) }
func (*FrameData) ProtoMessage() {}
func (*FrameData) Descriptor() ([]byte, []int) {
return fileDescriptor_c06e4cca6c2cc899, []int{1}
}
func (m *FrameData) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FrameData.Unmarshal(m, b)
}
func (m *FrameData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FrameData.Marshal(b, m, deterministic)
}
func (m *FrameData) XXX_Merge(src proto.Message) {
xxx_messageInfo_FrameData.Merge(m, src)
}
func (m *FrameData) XXX_Size() int {
return xxx_messageInfo_FrameData.Size(m)
}
func (m *FrameData) XXX_DiscardUnknown() {
xxx_messageInfo_FrameData.DiscardUnknown(m)
}
var xxx_messageInfo_FrameData proto.InternalMessageInfo
func (m *FrameData) GetType() int32 {
if m != nil {
return m.Type
}
return 0
}
func (m *FrameData) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type Frame struct { type Frame struct {
Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
Resend bool `protobuf:"varint,2,opt,name=resend,proto3" json:"resend,omitempty"` Resend bool `protobuf:"varint,2,opt,name=resend,proto3" json:"resend,omitempty"`
Sendtime int64 `protobuf:"varint,3,opt,name=sendtime,proto3" json:"sendtime,omitempty"` Sendtime int64 `protobuf:"varint,3,opt,name=sendtime,proto3" json:"sendtime,omitempty"`
Id int32 `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"` Id int32 `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"`
Data []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"` Data *FrameData `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
Dataid []int32 `protobuf:"varint,6,rep,packed,name=dataid,proto3" json:"dataid,omitempty"` Dataid []int32 `protobuf:"varint,6,rep,packed,name=dataid,proto3" json:"dataid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
@ -234,7 +303,7 @@ func (m *Frame) Reset() { *m = Frame{} }
func (m *Frame) String() string { return proto.CompactTextString(m) } func (m *Frame) String() string { return proto.CompactTextString(m) }
func (*Frame) ProtoMessage() {} func (*Frame) ProtoMessage() {}
func (*Frame) Descriptor() ([]byte, []int) { func (*Frame) Descriptor() ([]byte, []int) {
return fileDescriptor_c06e4cca6c2cc899, []int{1} return fileDescriptor_c06e4cca6c2cc899, []int{2}
} }
func (m *Frame) XXX_Unmarshal(b []byte) error { func (m *Frame) XXX_Unmarshal(b []byte) error {
@ -283,7 +352,7 @@ func (m *Frame) GetId() int32 {
return 0 return 0
} }
func (m *Frame) GetData() []byte { func (m *Frame) GetData() *FrameData {
if m != nil { if m != nil {
return m.Data return m.Data
} }
@ -299,39 +368,43 @@ func (m *Frame) GetDataid() []int32 {
func init() { func init() {
proto.RegisterEnum("MyMsg_TYPE", MyMsg_TYPE_name, MyMsg_TYPE_value) proto.RegisterEnum("MyMsg_TYPE", MyMsg_TYPE_name, MyMsg_TYPE_value)
proto.RegisterEnum("FrameData_TYPE", FrameData_TYPE_name, FrameData_TYPE_value)
proto.RegisterEnum("Frame_TYPE", Frame_TYPE_name, Frame_TYPE_value) proto.RegisterEnum("Frame_TYPE", Frame_TYPE_name, Frame_TYPE_value)
proto.RegisterType((*MyMsg)(nil), "MyMsg") proto.RegisterType((*MyMsg)(nil), "MyMsg")
proto.RegisterType((*FrameData)(nil), "FrameData")
proto.RegisterType((*Frame)(nil), "Frame") proto.RegisterType((*Frame)(nil), "Frame")
} }
func init() { proto.RegisterFile("msg.proto", fileDescriptor_c06e4cca6c2cc899) } func init() { proto.RegisterFile("msg.proto", fileDescriptor_c06e4cca6c2cc899) }
var fileDescriptor_c06e4cca6c2cc899 = []byte{ var fileDescriptor_c06e4cca6c2cc899 = []byte{
// 407 bytes of a gzipped FileDescriptorProto // 448 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x92, 0xcd, 0x8e, 0xd3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xcb, 0x8e, 0xd3, 0x30,
0x14, 0x85, 0x71, 0x12, 0xa7, 0xe9, 0x9d, 0x32, 0xf2, 0x5c, 0x7e, 0x64, 0xb1, 0x8a, 0x2a, 0x21, 0x14, 0xc5, 0x79, 0xb4, 0xcd, 0x6d, 0x67, 0xe4, 0x31, 0x0f, 0x59, 0x2c, 0x50, 0x14, 0x09, 0x91,
0xb2, 0x81, 0x05, 0x3c, 0x41, 0x66, 0x28, 0x51, 0x85, 0x5a, 0x06, 0xab, 0x9b, 0x61, 0x33, 0xca, 0x0d, 0xb3, 0x18, 0x24, 0x58, 0x77, 0x3a, 0xa5, 0x1a, 0x41, 0x1f, 0xb8, 0x65, 0x01, 0x9b, 0x2a,
0x4c, 0x3c, 0x91, 0x05, 0x4e, 0xab, 0xc4, 0x15, 0x94, 0x77, 0xe2, 0x11, 0x78, 0x1d, 0x1e, 0x03, 0x33, 0xf1, 0x44, 0x16, 0xe3, 0xb4, 0x4a, 0x5c, 0x41, 0xf9, 0x27, 0x3e, 0x81, 0x6f, 0xe0, 0x8f,
0x21, 0xdf, 0xba, 0x95, 0x2a, 0x56, 0x3e, 0xe7, 0xde, 0x4f, 0xf5, 0xa9, 0x4f, 0x60, 0x6c, 0x87, 0x10, 0xf2, 0xad, 0x93, 0x22, 0xc1, 0xca, 0xe7, 0xdc, 0x7b, 0xe4, 0x73, 0x7d, 0x7c, 0x21, 0xd2,
0xf6, 0xcd, 0xa6, 0x5f, 0xbb, 0xf5, 0xf4, 0x6f, 0x04, 0x7c, 0xb1, 0x5b, 0x0c, 0x2d, 0x9e, 0x43, 0x75, 0x71, 0xbe, 0xad, 0x36, 0x66, 0x93, 0xfc, 0xf6, 0x20, 0x9c, 0xee, 0xa7, 0x75, 0xc1, 0x4e,
0x64, 0x1a, 0xc9, 0x72, 0x56, 0x8c, 0x55, 0x64, 0x1a, 0x44, 0x48, 0xdc, 0x6e, 0xa3, 0x65, 0x94, 0xc1, 0x53, 0x39, 0x27, 0x31, 0x49, 0x23, 0xe1, 0xa9, 0x9c, 0x31, 0x08, 0xcc, 0x7e, 0x2b, 0xb9,
0xb3, 0x82, 0x2b, 0xd2, 0xf8, 0x1c, 0x52, 0x57, 0xf7, 0xad, 0x76, 0x32, 0x26, 0x2e, 0x38, 0xcf, 0x17, 0x93, 0x34, 0x14, 0x88, 0xd9, 0x13, 0xe8, 0x98, 0xac, 0x2a, 0xa4, 0xe1, 0x3e, 0xea, 0x1c,
0x36, 0xb5, 0xab, 0x65, 0x92, 0xb3, 0x62, 0xa2, 0x48, 0x7b, 0xb6, 0xa7, 0x3b, 0x24, 0xcf, 0x59, 0xb3, 0xda, 0x3c, 0x33, 0x19, 0x0f, 0x62, 0x92, 0x0e, 0x04, 0x62, 0xab, 0xad, 0xd0, 0x83, 0x87,
0x71, 0xa1, 0x82, 0xc3, 0xa7, 0xc0, 0x6d, 0xdd, 0x9a, 0x7b, 0x99, 0xd2, 0x78, 0x6f, 0x50, 0x40, 0x31, 0x49, 0xcf, 0x84, 0x63, 0xec, 0x11, 0x84, 0x3a, 0x2b, 0xd4, 0x2d, 0xef, 0x60, 0xf9, 0x40,
0xfc, 0x55, 0xef, 0xe4, 0x88, 0x66, 0x5e, 0xa2, 0x84, 0x91, 0xbb, 0xdf, 0xd8, 0x75, 0xa3, 0x65, 0x18, 0x05, 0xff, 0x8b, 0xdc, 0xf3, 0x2e, 0xd6, 0x2c, 0x64, 0x1c, 0xba, 0xe6, 0x76, 0xab, 0x37,
0x46, 0x11, 0x0e, 0x16, 0x5f, 0x03, 0x06, 0x79, 0x7b, 0xb7, 0x7d, 0x78, 0xd0, 0xfd, 0x60, 0x7e, 0xb9, 0xe4, 0x3d, 0x1c, 0xa1, 0xa1, 0xec, 0x25, 0x30, 0x07, 0xd7, 0x37, 0xbb, 0xbb, 0x3b, 0x59,
0x6a, 0x39, 0x26, 0xe8, 0x22, 0x6c, 0x2e, 0x8f, 0x0b, 0x7c, 0x09, 0xe7, 0x07, 0xdc, 0xd6, 0x3f, 0xd5, 0xea, 0xbb, 0xe4, 0x11, 0x8a, 0xce, 0x5c, 0xe7, 0xb2, 0x6d, 0xb0, 0xe7, 0x70, 0xda, 0xc8,
0xbe, 0x9b, 0x4e, 0x02, 0xa1, 0x8f, 0xc3, 0x74, 0x41, 0x43, 0x7c, 0x0b, 0xcf, 0x0e, 0x58, 0xaf, 0x75, 0xf6, 0xed, 0xab, 0x2a, 0x39, 0xa0, 0xf4, 0xc4, 0x55, 0xa7, 0x58, 0x64, 0x17, 0xf0, 0xb8,
0x07, 0xdd, 0x35, 0xb7, 0xce, 0x58, 0x6d, 0x07, 0x79, 0x46, 0xf4, 0x93, 0xb0, 0x54, 0xb4, 0x5b, 0x91, 0x55, 0xb2, 0x96, 0x65, 0xbe, 0x36, 0x4a, 0x4b, 0x5d, 0xf3, 0x3e, 0xaa, 0x1f, 0xba, 0xa6,
0xd1, 0x8a, 0x32, 0x1a, 0xab, 0xd7, 0x5b, 0x27, 0x27, 0x21, 0xe3, 0xde, 0x4e, 0x5f, 0x41, 0xb2, 0xc0, 0xde, 0x0a, 0x5b, 0x38, 0xa3, 0xd2, 0x72, 0xb3, 0x33, 0x7c, 0xe0, 0x66, 0x3c, 0xd0, 0xe4,
0xba, 0xb9, 0x9e, 0x61, 0x06, 0xc9, 0xfb, 0x72, 0x55, 0x8a, 0x47, 0x5e, 0x5d, 0xcf, 0x97, 0x95, 0x05, 0x04, 0xab, 0x4f, 0x8b, 0x31, 0xeb, 0x41, 0x70, 0x35, 0x5c, 0x0d, 0xe9, 0x03, 0x8b, 0x16,
0x60, 0x78, 0x06, 0x7c, 0x51, 0x56, 0xf3, 0x2b, 0xf1, 0xeb, 0x77, 0x3c, 0xfd, 0xc3, 0x80, 0x7f, 0xd7, 0xb3, 0x09, 0x25, 0xac, 0x0f, 0xe1, 0x74, 0x38, 0xb9, 0x1e, 0xd1, 0x1f, 0x3f, 0xfd, 0xe4,
0xe8, 0x6b, 0xab, 0x8f, 0x0f, 0xce, 0x4e, 0x1f, 0x7c, 0x1f, 0x86, 0x6a, 0xc8, 0x54, 0x70, 0xf8, 0x1e, 0xa2, 0xb7, 0x55, 0xa6, 0xe5, 0x95, 0xcd, 0xac, 0xc9, 0x9c, 0xfc, 0x95, 0x79, 0x93, 0xad,
0x02, 0x32, 0x7f, 0xfa, 0xdb, 0xa8, 0x8a, 0x58, 0x1d, 0x7d, 0x28, 0x32, 0xa1, 0x5f, 0x09, 0x45, 0x77, 0xcc, 0x36, 0x79, 0xe3, 0x6e, 0x3f, 0x81, 0xe8, 0xe3, 0x72, 0x2c, 0xd6, 0x47, 0x8b, 0xd1,
0x52, 0x39, 0xfc, 0xb4, 0x1c, 0x7f, 0x9a, 0x46, 0xa6, 0x79, 0x5c, 0x70, 0x15, 0xdc, 0xf4, 0xe6, 0x7c, 0x36, 0x43, 0x8b, 0xae, 0x45, 0x62, 0xb9, 0xa0, 0x1e, 0x8b, 0x20, 0x1c, 0xbd, 0x9f, 0x2f,
0xbf, 0xd8, 0x23, 0x88, 0xd5, 0xec, 0xb3, 0x60, 0x5e, 0x94, 0x57, 0x1f, 0x45, 0x74, 0xfc, 0x23, 0xc7, 0xd4, 0x4f, 0x7e, 0x11, 0x08, 0xd1, 0xee, 0xbf, 0x56, 0xf6, 0xcb, 0xf0, 0x79, 0x68, 0xd6,
0x31, 0xa9, 0x4f, 0xcb, 0x4a, 0x24, 0x7b, 0xaa, 0x12, 0x1c, 0x01, 0x52, 0x35, 0xab, 0x3c, 0x98, 0x13, 0x8e, 0xb1, 0xa7, 0xd0, 0xb3, 0xa7, 0x7d, 0x1b, 0x7e, 0xbc, 0x2f, 0x5a, 0xee, 0xd6, 0x26,
0xe2, 0x04, 0x32, 0xaf, 0xab, 0x72, 0xbe, 0x14, 0xa3, 0xcb, 0xc9, 0x17, 0xd8, 0x98, 0xae, 0x75, 0xc0, 0x5b, 0xec, 0xda, 0x3c, 0x73, 0xe3, 0xda, 0x4f, 0xef, 0x5f, 0xc0, 0x79, 0xfb, 0xb8, 0xe3,
0xdb, 0xae, 0xd3, 0xdf, 0xee, 0x52, 0xfa, 0x18, 0xde, 0xfd, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x5a, 0xd8, 0x53, 0xe5, 0xbc, 0x13, 0xfb, 0x69, 0x28, 0x1c, 0x4b, 0x5e, 0xff, 0x13, 0x58, 0x17,
0xfd, 0x1d, 0x91, 0x8b, 0x02, 0x00, 0x00, 0x7c, 0x31, 0xfe, 0x40, 0x89, 0x05, 0xc3, 0xd1, 0x3b, 0xea, 0xb5, 0x11, 0xfa, 0x88, 0xe6, 0xb3,
0x09, 0x0d, 0x2e, 0x07, 0x9f, 0x61, 0xab, 0xca, 0xc2, 0xec, 0xca, 0x52, 0xde, 0xdf, 0x74, 0x70,
0xc7, 0x5e, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0xbe, 0x98, 0x97, 0x18, 0xe2, 0x02, 0x00, 0x00,
} }

16
msg.proto
View File

@ -22,6 +22,17 @@ message MyMsg {
int32 timeout = 12; int32 timeout = 12;
} }
message FrameData {
enum TYPE {
USER_DATA = 0;
CONN = 1;
CONNRSP = 2;
CLOSE = 3;
}
int32 type = 1;
bytes data = 2;
}
message Frame { message Frame {
enum TYPE { enum TYPE {
DATA = 0; DATA = 0;
@ -29,15 +40,12 @@ message Frame {
ACK = 2; ACK = 2;
PING = 3; PING = 3;
PONG = 4; PONG = 4;
REG = 5;
REGACK = 6;
REGAGAIN = 7;
} }
int32 type = 1; int32 type = 1;
bool resend = 2; bool resend = 2;
int64 sendtime = 3; int64 sendtime = 3;
int32 id = 4; int32 id = 4;
bytes data = 5; FrameData data = 5;
repeated int32 dataid = 6; repeated int32 dataid = 6;
} }

2
server.go
View File

@ -185,7 +185,7 @@ func (p *Server) RecvTCP(conn *ServerConn, id string, src *net.IPAddr) {
loggo.Info("start wait remote connect tcp %s %s", conn.id, conn.tcpaddrTarget.String()) loggo.Info("start wait remote connect tcp %s %s", conn.id, conn.tcpaddrTarget.String())
startConnectTime := time.Now() startConnectTime := time.Now()
for { for {
if conn.fm.IsRemoteConnected() { if conn.fm.IsConnected() {
break break
} }
conn.fm.Update() conn.fm.Update()