mirrors2/hk4e
1
0
Fork 0
mirror of https://github.com/FlourishingWorld/hk4e.git synced 2026-02-04 15:32:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

格式化代码

Browse Source
This commit is contained in:
huangxiaolei
2022-12-19 13:40:04 +08:00
parent f773ba8df7
commit 58b2df2bc6
92 changed files with 682 additions and 626 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
gate/net/forward.go
View File

@@ -5,6 +5,11 @@ import (
"encoding/base64"
"encoding/binary"
"fmt"
"math/rand"
"strconv"
"strings"
"time"
"hk4e/dispatch/controller"
"hk4e/gate/kcp"
"hk4e/pkg/endec"
@@ -13,10 +18,6 @@ import (
"hk4e/pkg/random"
"hk4e/protocol/cmd"
"hk4e/protocol/proto"
"math/rand"
"strconv"
"strings"
"time"
)
const (
@@ -32,7 +33,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
headMeta := session.headMeta
connState := session.connState
if protoMsg.HeadMessage == nil {
logger.LOG.Error("recv null head msg: %v", protoMsg)
logger.Error("recv null head msg: %v", protoMsg)
}
headMeta.seq = protoMsg.HeadMessage.ClientSequenceId
// gate本地处理的请求
@@ -77,7 +78,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
netMsg.EventId = cmd.UserLoginNotify
netMsg.ClientSeq = headMeta.seq
k.netMsgInput <- netMsg
logger.LOG.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
logger.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
case cmd.SetPlayerBornDataReq:
// 玩家注册请求
if connState != ConnAlive {
@@ -106,7 +107,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
return
}
pingReq := protoMsg.PayloadMessage.(*proto.PingReq)
logger.LOG.Debug("user ping req, data: %v", pingReq.String())
logger.Debug("user ping req, data: %v", pingReq.String())
// 返回数据到客户端
// TODO 记录客户端最后一次ping时间做超时下线处理
pingRsp := new(proto.PingRsp)
@@ -124,7 +125,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
netMsg.ClientTime = pingReq.ClientTime
k.netMsgInput <- netMsg
// RTT
logger.LOG.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
logger.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
// 客户端往返时延通知
rtt := session.conn.GetSRTT()
// 通知GS玩家客户端往返时延
@@ -151,7 +152,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
// 从GS接收消息
func (k *KcpConnectManager) sendMsgHandle() {
logger.LOG.Debug("send msg handle start")
logger.Debug("send msg handle start")
kcpRawSendChanMap := make(map[uint64]chan *ProtoMsg)
userIdConvMap := make(map[uint32]uint64)
sendToClientFn := func(protoMsg *ProtoMsg) {
@@ -161,10 +162,10 @@ func (k *KcpConnectManager) sendMsgHandle() {
select {
case kcpRawSendChan <- protoMsg:
default:
logger.LOG.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
logger.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
}
} else {
logger.LOG.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
logger.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
}
}
for {
@@ -181,7 +182,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
case netMsg := <-k.netMsgOutput:
convId, exist := userIdConvMap[netMsg.UserId]
if !exist {
logger.LOG.Error("can not find convId by userId")
logger.Error("can not find convId by userId")
continue
}
if netMsg.EventId == cmd.NormalMsg {
@@ -192,7 +193,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
protoMsg.PayloadMessage = netMsg.PayloadMessage
sendToClientFn(protoMsg)
} else {
logger.LOG.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
logger.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
}
}
}
@@ -213,11 +214,11 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
AccountToken: req.AccountToken,
}, "")
if err != nil {
logger.LOG.Error("verify token error: %v", err)
logger.Error("verify token error: %v", err)
return nil
}
if !tokenVerifyRsp.Valid {
logger.LOG.Error("token error")
logger.Error("token error")
return nil
}
// comboToken验证成功
@@ -273,38 +274,38 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
split := strings.Split(addr, ":")
rsp.ClientIpStr = split[0]
if req.GetKeyId() != 0 {
logger.LOG.Debug("do hk4e 2.8 rsa logic")
logger.Debug("do hk4e 2.8 rsa logic")
keyId := strconv.Itoa(int(req.GetKeyId()))
encPubPrivKey, exist := k.encRsaKeyMap[keyId]
if !exist {
logger.LOG.Error("can not found key id: %v", keyId)
logger.Error("can not found key id: %v", keyId)
return
}
pubKey, err := endec.RsaParsePubKeyByPrivKey(encPubPrivKey)
if err != nil {
logger.LOG.Error("parse rsa pub key error: %v", err)
logger.Error("parse rsa pub key error: %v", err)
return nil
}
signPrivkey, err := endec.RsaParsePrivKey(k.signRsaKey)
if err != nil {
logger.LOG.Error("parse rsa priv key error: %v", err)
logger.Error("parse rsa priv key error: %v", err)
return nil
}
clientSeedBase64 := req.GetClientRandKey()
clientSeedEnc, err := base64.StdEncoding.DecodeString(clientSeedBase64)
if err != nil {
logger.LOG.Error("parse client seed base64 error: %v", err)
logger.Error("parse client seed base64 error: %v", err)
return nil
}
clientSeed, err := endec.RsaDecrypt(clientSeedEnc, signPrivkey)
if err != nil {
logger.LOG.Error("rsa dec error: %v", err)
logger.Error("rsa dec error: %v", err)
return rsp
}
clientSeedUint64 := uint64(0)
err = binary.Read(bytes.NewReader(clientSeed), binary.BigEndian, &clientSeedUint64)
if err != nil {
logger.LOG.Error("parse client seed to uint64 error: %v", err)
logger.Error("parse client seed to uint64 error: %v", err)
return rsp
}
timeRand := random.GetTimeRand()
@@ -315,18 +316,18 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
seedBuf := new(bytes.Buffer)
err = binary.Write(seedBuf, binary.BigEndian, seedUint64)
if err != nil {
logger.LOG.Error("conv seed uint64 to bytes error: %v", err)
logger.Error("conv seed uint64 to bytes error: %v", err)
return rsp
}
seed := seedBuf.Bytes()
seedEnc, err := endec.RsaEncrypt(seed, pubKey)
if err != nil {
logger.LOG.Error("rsa enc error: %v", err)
logger.Error("rsa enc error: %v", err)
return rsp
}
seedSign, err := endec.RsaSign(seed, signPrivkey)
if err != nil {
logger.LOG.Error("rsa sign error: %v", err)
logger.Error("rsa sign error: %v", err)
return rsp
}
rsp.KeyId = req.KeyId
@@ -337,7 +338,7 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
}
func (k *KcpConnectManager) playerLogin(req *proto.PlayerLoginReq, session *Session) (rsp *proto.PlayerLoginRsp) {
logger.LOG.Debug("player login, info: %v", req.String())
logger.Debug("player login, info: %v", req.String())
// TODO 验证token
session.connState = ConnAlive
// 返回响应

50
gate/net/kcp_connect_manager.go
View File

@@ -3,19 +3,19 @@ package net
import (
"bytes"
"encoding/binary"
"hk4e/common/region"
"hk4e/dispatch/controller"
"hk4e/pkg/httpclient"
"hk4e/protocol/cmd"
"hk4e/protocol/proto"
"strconv"
"sync"
"time"
"hk4e/common/config"
"hk4e/common/region"
"hk4e/dispatch/controller"
"hk4e/gate/kcp"
"hk4e/pkg/httpclient"
"hk4e/pkg/logger"
"hk4e/pkg/random"
"hk4e/protocol/cmd"
"hk4e/protocol/proto"
)
type KcpConnectManager struct {
@@ -63,15 +63,15 @@ func (k *KcpConnectManager) Start() {
// key
dispatchEc2bSeedRsp, err := httpclient.Get[controller.DispatchEc2bSeedRsp]("http://127.0.0.1:8080/dispatch/ec2b/seed", "")
if err != nil {
logger.LOG.Error("get dispatch ec2b seed error: %v", err)
logger.Error("get dispatch ec2b seed error: %v", err)
return
}
dispatchEc2bSeed, err := strconv.ParseUint(dispatchEc2bSeedRsp.Seed, 10, 64)
if err != nil {
logger.LOG.Error("parse dispatch ec2b seed error: %v", err)
logger.Error("parse dispatch ec2b seed error: %v", err)
return
}
logger.LOG.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
logger.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
gateDispatchEc2b := random.NewEc2b()
gateDispatchEc2b.SetSeed(dispatchEc2bSeed)
k.dispatchKey = gateDispatchEc2b.XorKey()
@@ -79,7 +79,7 @@ func (k *KcpConnectManager) Start() {
port := strconv.Itoa(int(config.CONF.Hk4e.KcpPort))
listener, err := kcp.ListenWithOptions(config.CONF.Hk4e.KcpAddr+":"+port, nil, 0, 0)
if err != nil {
logger.LOG.Error("listen kcp err: %v", err)
logger.Error("listen kcp err: %v", err)
return
}
go k.enetHandle(listener)
@@ -89,11 +89,11 @@ func (k *KcpConnectManager) Start() {
}
func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
logger.LOG.Debug("accept handle start")
logger.Debug("accept handle start")
for {
conn, err := listener.AcceptKCP()
if err != nil {
logger.LOG.Error("accept kcp err: %v", err)
logger.Error("accept kcp err: %v", err)
return
}
if k.openState == false {
@@ -103,7 +103,7 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
conn.SetACKNoDelay(true)
conn.SetWriteDelay(false)
convId := conn.GetConv()
logger.LOG.Debug("client connect, convId: %v", convId)
logger.Debug("client connect, convId: %v", convId)
kcpRawSendChan := make(chan *ProtoMsg, 1000)
session := &Session{
conn: conn,
@@ -129,12 +129,12 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
}
func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
logger.LOG.Debug("enet handle start")
logger.Debug("enet handle start")
// conv短时间内唯一生成
convGenMap := make(map[uint64]int64)
for {
enetNotify := <-listener.EnetNotify
logger.LOG.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
logger.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
switch enetNotify.ConnType {
case kcp.ConnEnetSyn:
if enetNotify.EnetType == kcp.EnetClientConnectKey {
@@ -156,7 +156,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
}
}
k.sessionMapLock.RUnlock()
logger.LOG.Info("clean dead conv list: %v", delConvList)
logger.Info("clean dead conv list: %v", delConvList)
// 生成没用过的conv
var conv uint64
for {
@@ -182,7 +182,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
case kcp.ConnEnetFin:
session := k.GetSessionByConvId(enetNotify.ConvId)
if session == nil {
logger.LOG.Error("session not exist, convId: %v", enetNotify.ConvId)
logger.Error("session not exist, convId: %v", enetNotify.ConvId)
continue
}
session.conn.SendEnetNotify(&kcp.Enet{
@@ -218,7 +218,7 @@ type Session struct {
}
func (k *KcpConnectManager) recvHandle(session *Session) {
logger.LOG.Debug("recv handle start")
logger.Debug("recv handle start")
// 接收
conn := session.conn
convId := conn.GetConv()
@@ -229,7 +229,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
_ = conn.SetReadDeadline(time.Now().Add(time.Second * 15))
recvLen, err := conn.Read(recvBuf)
if err != nil {
logger.LOG.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
logger.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
k.closeKcpConn(session, kcp.EnetServerKick)
break
}
@@ -246,7 +246,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
now := time.Now().UnixNano()
if now-pktFreqLimitTimer > int64(time.Second) {
if pktFreqLimitCounter > 100 {
logger.LOG.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
logger.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
break
} else {
@@ -267,7 +267,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
}
func (k *KcpConnectManager) sendHandle(session *Session) {
logger.LOG.Debug("send handle start")
logger.Debug("send handle start")
// 发送
conn := session.conn
convId := conn.GetConv()
@@ -276,20 +276,20 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
for {
protoMsg, ok := <-session.kcpRawSendChan
if !ok {
logger.LOG.Error("exit send loop, send chan close, convId: %v", convId)
logger.Error("exit send loop, send chan close, convId: %v", convId)
k.closeKcpConn(session, kcp.EnetServerKick)
break
}
kcpMsg := k.protoEncode(protoMsg)
if kcpMsg == nil {
logger.LOG.Error("decode kcp msg is nil, convId: %v", convId)
logger.Error("decode kcp msg is nil, convId: %v", convId)
continue
}
bin := k.encodePayloadToBin(kcpMsg, session.xorKey)
_ = conn.SetWriteDeadline(time.Now().Add(time.Second * 5))
_, err := conn.Write(bin)
if err != nil {
logger.LOG.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
logger.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
k.closeKcpConn(session, kcp.EnetServerKick)
break
}
@@ -298,7 +298,7 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
now := time.Now().UnixNano()
if now-pktFreqLimitTimer > int64(time.Second) {
if pktFreqLimitCounter > 100 {
logger.LOG.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
logger.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
break
} else {
@@ -336,7 +336,7 @@ func (k *KcpConnectManager) closeKcpConn(session *Session, enetType uint32) {
netMsg.UserId = session.userId
netMsg.EventId = cmd.UserOfflineNotify
k.netMsgInput <- netMsg
logger.LOG.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
logger.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
k.destroySessionChan <- session
}

28
gate/net/kcp_endecode.go
View File

@@ -42,12 +42,12 @@ func (k *KcpConnectManager) decodeBinToPayload(data []byte, convId uint64, kcpMs
func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[]*KcpMsg) {
// 长度太短
if len(data) < 12 {
logger.LOG.Debug("packet len less 12 byte")
logger.Debug("packet len less 12 byte")
return
}
// 头部幻数错误
if data[0] != 0x45 || data[1] != 0x67 {
logger.LOG.Error("packet head magic 0x4567 error")
logger.Error("packet head magic 0x4567 error")
return
}
// 协议号
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
var cmdId int64
err := binary.Read(cmdIdBuffer, binary.BigEndian, &cmdId)
if err != nil {
logger.LOG.Error("packet cmd id parse fail: %v", err)
logger.Error("packet cmd id parse fail: %v", err)
return
}
// 头部长度
@@ -69,7 +69,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
var headLen int64
err = binary.Read(headLenBuffer, binary.BigEndian, &headLen)
if err != nil {
logger.LOG.Error("packet head len parse fail: %v", err)
logger.Error("packet head len parse fail: %v", err)
return
}
// proto长度
@@ -82,17 +82,17 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
var protoLen int64
err = binary.Read(protoLenBuffer, binary.BigEndian, &protoLen)
if err != nil {
logger.LOG.Error("packet proto len parse fail: %v", err)
logger.Error("packet proto len parse fail: %v", err)
return
}
// 检查最小长度
if len(data) < int(headLen+protoLen)+12 {
logger.LOG.Error("packet len error")
logger.Error("packet len error")
return
}
// 尾部幻数错误
if data[headLen+protoLen+10] != 0x89 || data[headLen+protoLen+11] != 0xAB {
logger.LOG.Error("packet tail magic 0x89AB error")
logger.Error("packet tail magic 0x89AB error")
return
}
// 判断是否有不止一个包
@@ -108,10 +108,10 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
kcpMsg := new(KcpMsg)
kcpMsg.ConvId = convId
kcpMsg.CmdId = uint16(cmdId)
//kcpMsg.HeadData = make([]byte, len(headData))
//copy(kcpMsg.HeadData, headData)
//kcpMsg.ProtoData = make([]byte, len(protoData))
//copy(kcpMsg.ProtoData, protoData)
// kcpMsg.HeadData = make([]byte, len(headData))
// copy(kcpMsg.HeadData, headData)
// kcpMsg.ProtoData = make([]byte, len(protoData))
// copy(kcpMsg.ProtoData, protoData)
kcpMsg.HeadData = headData
kcpMsg.ProtoData = protoData
*kcpMsgList = append(*kcpMsgList, kcpMsg)
@@ -136,7 +136,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
cmdIdBuffer := bytes.NewBuffer([]byte{})
err := binary.Write(cmdIdBuffer, binary.BigEndian, kcpMsg.CmdId)
if err != nil {
logger.LOG.Error("cmd id encode err: %v", err)
logger.Error("cmd id encode err: %v", err)
return nil
}
bin[2] = (cmdIdBuffer.Bytes())[0]
@@ -145,7 +145,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
headLenBuffer := bytes.NewBuffer([]byte{})
err = binary.Write(headLenBuffer, binary.BigEndian, uint16(len(kcpMsg.HeadData)))
if err != nil {
logger.LOG.Error("head len encode err: %v", err)
logger.Error("head len encode err: %v", err)
return nil
}
bin[4] = (headLenBuffer.Bytes())[0]
@@ -154,7 +154,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
protoLenBuffer := bytes.NewBuffer([]byte{})
err = binary.Write(protoLenBuffer, binary.BigEndian, uint32(len(kcpMsg.ProtoData)))
if err != nil {
logger.LOG.Error("proto len encode err: %v", err)
logger.Error("proto len encode err: %v", err)
return nil
}
bin[6] = (protoLenBuffer.Bytes())[0]

17
gate/net/kcp_event.go
View File

@@ -1,9 +1,10 @@
package net
import (
"reflect"
"hk4e/gate/kcp"
"hk4e/pkg/logger"
"reflect"
)
const (
@@ -30,22 +31,22 @@ func (k *KcpConnectManager) GetKcpEventOutputChan() chan *KcpEvent {
}
func (k *KcpConnectManager) eventHandle() {
logger.LOG.Debug("event handle start")
logger.Debug("event handle start")
// 事件处理
for {
event := <-k.kcpEventInput
logger.LOG.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
logger.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
switch event.EventId {
case KcpConnForceClose:
// 强制关闭某个连接
session := k.GetSessionByConvId(event.ConvId)
if session == nil {
logger.LOG.Error("session not exist, convId: %v", event.ConvId)
logger.Error("session not exist, convId: %v", event.ConvId)
continue
}
reason, ok := event.EventMessage.(uint32)
if !ok {
logger.LOG.Error("event KcpConnForceClose msg type error")
logger.Error("event KcpConnForceClose msg type error")
continue
}
session.conn.SendEnetNotify(&kcp.Enet{
@@ -53,16 +54,16 @@ func (k *KcpConnectManager) eventHandle() {
EnetType: reason,
})
_ = session.conn.Close()
logger.LOG.Info("conn has been force close, convId: %v", event.ConvId)
logger.Info("conn has been force close, convId: %v", event.ConvId)
case KcpAllConnForceClose:
// 强制关闭所有连接
k.closeAllKcpConn()
logger.LOG.Info("all conn has been force close")
logger.Info("all conn has been force close")
case KcpGateOpenState:
// 改变网关开放状态
openState, ok := event.EventMessage.(bool)
if !ok {
logger.LOG.Error("event KcpGateOpenState msg type error")
logger.Error("event KcpGateOpenState msg type error")
continue
}
k.openState = openState

26
gate/net/proto_endecode.go
View File

@@ -30,7 +30,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
headMsg := new(proto.PacketHead)
err := pb.Unmarshal(kcpMsg.HeadData, headMsg)
if err != nil {
logger.LOG.Error("unmarshal head data err: %v", err)
logger.Error("unmarshal head data err: %v", err)
return protoMsgList
}
protoMsg.HeadMessage = headMsg
@@ -41,7 +41,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
protoMessageList := make([]*ProtoMessage, 0)
k.protoDecodePayloadLoop(kcpMsg.CmdId, kcpMsg.ProtoData, &protoMessageList)
if len(protoMessageList) == 0 {
logger.LOG.Error("decode proto object is nil")
logger.Error("decode proto object is nil")
return protoMsgList
}
if kcpMsg.CmdId == cmd.UnionCmdNotify {
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
if msg.PayloadMessage != nil {
cmdName = string(msg.PayloadMessage.ProtoReflect().Descriptor().FullName())
}
logger.LOG.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
logger.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
}
} else {
protoMsg.PayloadMessage = protoMessageList[0].message
@@ -67,7 +67,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
if protoMsg.PayloadMessage != nil {
cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
}
logger.LOG.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
logger.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
}
return protoMsgList
}
@@ -75,14 +75,14 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
func (k *KcpConnectManager) protoDecodePayloadLoop(cmdId uint16, protoData []byte, protoMessageList *[]*ProtoMessage) {
protoObj := k.decodePayloadToProto(cmdId, protoData)
if protoObj == nil {
logger.LOG.Error("decode proto object is nil")
logger.Error("decode proto object is nil")
return
}
if cmdId == cmd.UnionCmdNotify {
// 处理聚合消息
unionCmdNotify, ok := protoObj.(*proto.UnionCmdNotify)
if !ok {
logger.LOG.Error("parse union cmd error")
logger.Error("parse union cmd error")
return
}
for _, unionCmd := range unionCmdNotify.GetCmdList() {
@@ -100,7 +100,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
if protoMsg.PayloadMessage != nil {
cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
}
logger.LOG.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
logger.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
kcpMsg = new(KcpMsg)
kcpMsg.ConvId = protoMsg.ConvId
kcpMsg.CmdId = protoMsg.CmdId
@@ -108,7 +108,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
if protoMsg.HeadMessage != nil {
headData, err := pb.Marshal(protoMsg.HeadMessage)
if err != nil {
logger.LOG.Error("marshal head data err: %v", err)
logger.Error("marshal head data err: %v", err)
return nil
}
kcpMsg.HeadData = headData
@@ -119,11 +119,11 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
if protoMsg.PayloadMessage != nil {
cmdId, protoData := k.encodeProtoToPayload(protoMsg.PayloadMessage)
if cmdId == 0 || protoData == nil {
logger.LOG.Error("encode proto data is nil")
logger.Error("encode proto data is nil")
return nil
}
if cmdId != 65535 && cmdId != protoMsg.CmdId {
logger.LOG.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
logger.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
return nil
}
kcpMsg.ProtoData = protoData
@@ -136,12 +136,12 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
func (k *KcpConnectManager) decodePayloadToProto(cmdId uint16, protoData []byte) (protoObj pb.Message) {
protoObj = k.cmdProtoMap.GetProtoObjByCmdId(cmdId)
if protoObj == nil {
logger.LOG.Error("get new proto object is nil")
logger.Error("get new proto object is nil")
return nil
}
err := pb.Unmarshal(protoData, protoObj)
if err != nil {
logger.LOG.Error("unmarshal proto data err: %v", err)
logger.Error("unmarshal proto data err: %v", err)
return nil
}
return protoObj
@@ -152,7 +152,7 @@ func (k *KcpConnectManager) encodeProtoToPayload(protoObj pb.Message) (cmdId uin
var err error = nil
protoData, err = pb.Marshal(protoObj)
if err != nil {
logger.LOG.Error("marshal proto object err: %v", err)
logger.Error("marshal proto object err: %v", err)
return 0, nil
}
return cmdId, protoData