shkong/MiraiGo
1
0
Fork 0
mirror of https://github.com/Mrs4s/MiraiGo.git synced 2025-05-04 19:17:38 +08:00
Code Issues Projects Releases Wiki Activity

client: refactor decoder

Browse Source 
(cherry picked from commit 3e201bd4491838bda026130eb2b93d58ef70db69)
This commit is contained in:
wdvxdr 2021-12-24 23:48:23 +08:00
parent 9946b404ae
commit 723563415f
No known key found for this signature in database
GPG Key ID: 703F8C071DE7A1B6
28 changed files with 197 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
client/_c2c_decoders.go
View File

@ -5,7 +5,7 @@ import (
"github.com/Mrs4s/MiraiGo/client/pb/msg" "github.com/Mrs4s/MiraiGo/client/pb/msg"
) )
var privateMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){ var privateMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
9: privateMessageDecoder, 10: privateMessageDecoder, 31: privateMessageDecoder, 9: privateMessageDecoder, 10: privateMessageDecoder, 31: privateMessageDecoder,
79: privateMessageDecoder, 97: privateMessageDecoder, 120: privateMessageDecoder, 79: privateMessageDecoder, 97: privateMessageDecoder, 120: privateMessageDecoder,
132: privateMessageDecoder, 133: privateMessageDecoder, 166: privateMessageDecoder, 132: privateMessageDecoder, 133: privateMessageDecoder, 166: privateMessageDecoder,
@ -13,21 +13,21 @@ var privateMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Incomi
208: privatePttDecoder, 208: privatePttDecoder,
} }
var nonSvcNotifyTroopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){ var nonSvcNotifyTroopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
36: troopSystemMessageDecoder, 85: troopSystemMessageDecoder, 36: troopSystemMessageDecoder, 85: troopSystemMessageDecoder,
} }
var troopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){ var troopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
35: troopSystemMessageDecoder, 37: troopSystemMessageDecoder, 35: troopSystemMessageDecoder, 37: troopSystemMessageDecoder,
45: troopSystemMessageDecoder, 46: troopSystemMessageDecoder, 84: troopSystemMessageDecoder, 45: troopSystemMessageDecoder, 46: troopSystemMessageDecoder, 84: troopSystemMessageDecoder,
86: troopSystemMessageDecoder, 87: troopSystemMessageDecoder, 86: troopSystemMessageDecoder, 87: troopSystemMessageDecoder,
} // IsSvcNotify } // IsSvcNotify
var sysMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){ var sysMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
187: systemMessageDecoder, 188: systemMessageDecoder, 189: systemMessageDecoder, 187: systemMessageDecoder, 188: systemMessageDecoder, 189: systemMessageDecoder,
190: systemMessageDecoder, 191: systemMessageDecoder, 190: systemMessageDecoder, 191: systemMessageDecoder,
} // IsSvcNotify } // IsSvcNotify
var otherDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){ var otherDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
33: troopAddMemberBroadcastDecoder, 529: msgType0x211Decoder, 33: troopAddMemberBroadcastDecoder, 529: msgType0x211Decoder,
} }

26
client/c2c_processor.go
View File

@ -39,7 +39,7 @@ const (
AddressBookSource // 来自通讯录 AddressBookSource // 来自通讯录
) )
func (c *QQClient) c2cMessageSyncProcessor(rsp *msg.GetMessageResponse, info *network.IncomingPacketInfo) { func (c *QQClient) c2cMessageSyncProcessor(rsp *msg.GetMessageResponse, resp *network.Response) {
c.sig.SyncCookie = rsp.SyncCookie c.sig.SyncCookie = rsp.SyncCookie
c.sig.PubAccountCookie = rsp.PubAccountCookie c.sig.PubAccountCookie = rsp.PubAccountCookie
// c.msgCtrlBuf = rsp.MsgCtrlBuf // c.msgCtrlBuf = rsp.MsgCtrlBuf
@ -64,7 +64,7 @@ func (c *QQClient) c2cMessageSyncProcessor(rsp *msg.GetMessageResponse, info *ne
if (int64(pairMsg.GetLastReadTime()) & 4294967295) > int64(pMsg.Head.GetMsgTime()) { if (int64(pairMsg.GetLastReadTime()) & 4294967295) > int64(pMsg.Head.GetMsgTime()) {
continue continue
} }
c.commMsgProcessor(pMsg, info) c.commMsgProcessor(pMsg, resp)
} }
} }
if delItems != nil { if delItems != nil {
@ -73,11 +73,11 @@ func (c *QQClient) c2cMessageSyncProcessor(rsp *msg.GetMessageResponse, info *ne
if rsp.GetSyncFlag() != msg.SyncFlag_STOP { if rsp.GetSyncFlag() != msg.SyncFlag_STOP {
c.Debug("continue sync with flag: %v", rsp.SyncFlag) c.Debug("continue sync with flag: %v", rsp.SyncFlag)
seq, pkt := c.buildGetMessageRequestPacket(rsp.GetSyncFlag(), time.Now().Unix()) seq, pkt := c.buildGetMessageRequestPacket(rsp.GetSyncFlag(), time.Now().Unix())
_, _ = c.sendAndWait(seq, pkt, info.Params) _, _ = c.sendAndWaitParams(seq, pkt, resp.Params)
} }
} }
func (c *QQClient) commMsgProcessor(pMsg *msg.Message, info *network.IncomingPacketInfo) { func (c *QQClient) commMsgProcessor(pMsg *msg.Message, resp *network.Response) {
strKey := fmt.Sprintf("%d%d%d%d", pMsg.Head.GetFromUin(), pMsg.Head.GetToUin(), pMsg.Head.GetMsgSeq(), pMsg.Head.GetMsgUid()) strKey := fmt.Sprintf("%d%d%d%d", pMsg.Head.GetFromUin(), pMsg.Head.GetToUin(), pMsg.Head.GetMsgSeq(), pMsg.Head.GetMsgUid())
if _, ok := c.msgSvcCache.GetAndUpdate(strKey, time.Hour); ok { if _, ok := c.msgSvcCache.GetAndUpdate(strKey, time.Hour); ok {
c.Debug("c2c msg %v already exists in cache. skip.", pMsg.Head.GetMsgUid()) c.Debug("c2c msg %v already exists in cache. skip.", pMsg.Head.GetMsgUid())
@ -89,17 +89,17 @@ func (c *QQClient) commMsgProcessor(pMsg *msg.Message, info *network.IncomingPac
return return
} }
c.lastC2CMsgTime = int64(pMsg.Head.GetMsgTime()) c.lastC2CMsgTime = int64(pMsg.Head.GetMsgTime())
if info.Params.Bool("init") { if resp.Params.Bool("init") {
return return
} }
if decoder, _ := peekC2CDecoder(pMsg.Head.GetMsgType()); decoder != nil { if decoder, _ := peekC2CDecoder(pMsg.Head.GetMsgType()); decoder != nil {
decoder(c, pMsg, info) decoder(c, pMsg, resp)
} else { } else {
c.Debug("unknown msg type on c2c processor: %v - %v", pMsg.Head.GetMsgType(), pMsg.Head.GetC2CCmd()) c.Debug("unknown msg type on c2c processor: %v - %v", pMsg.Head.GetMsgType(), pMsg.Head.GetC2CCmd())
} }
} }
func privateMessageDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacketInfo) { func privateMessageDecoder(c *QQClient, pMsg *msg.Message, _ *network.Response) {
switch pMsg.Head.GetC2CCmd() { switch pMsg.Head.GetC2CCmd() {
case 11, 175: // friend msg case 11, 175: // friend msg
if pMsg.Head.GetFromUin() == c.Uin { if pMsg.Head.GetFromUin() == c.Uin {
@ -127,7 +127,7 @@ func privateMessageDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPa
} }
} }
func privatePttDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacketInfo) { func privatePttDecoder(c *QQClient, pMsg *msg.Message, _ *network.Response) {
if pMsg.Body == nil || pMsg.Body.RichText == nil || pMsg.Body.RichText.Ptt == nil { if pMsg.Body == nil || pMsg.Body.RichText == nil || pMsg.Body.RichText.Ptt == nil {
return return
} }
@ -138,7 +138,7 @@ func privatePttDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacket
c.dispatchPrivateMessage(c.parsePrivateMessage(pMsg)) c.dispatchPrivateMessage(c.parsePrivateMessage(pMsg))
} }
func tempSessionDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacketInfo) { func tempSessionDecoder(c *QQClient, pMsg *msg.Message, _ *network.Response) {
if pMsg.Head.C2CTmpMsgHead == nil || pMsg.Body == nil { if pMsg.Head.C2CTmpMsgHead == nil || pMsg.Body == nil {
return return
} }
@ -199,7 +199,7 @@ func tempSessionDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacke
} }
} }
func troopAddMemberBroadcastDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacketInfo) { func troopAddMemberBroadcastDecoder(c *QQClient, pMsg *msg.Message, resp *network.Response) {
groupJoinLock.Lock() groupJoinLock.Lock()
defer groupJoinLock.Unlock() defer groupJoinLock.Unlock()
group := c.FindGroupByUin(pMsg.Head.GetFromUin()) group := c.FindGroupByUin(pMsg.Head.GetFromUin())
@ -226,12 +226,12 @@ func troopAddMemberBroadcastDecoder(c *QQClient, pMsg *msg.Message, _ *network.I
} }
} }
func systemMessageDecoder(c *QQClient, _ *msg.Message, _ *network.IncomingPacketInfo) { func systemMessageDecoder(c *QQClient, _ *msg.Message, _ *network.Response) {
_, pkt := c.buildSystemMsgNewFriendPacket() _, pkt := c.buildSystemMsgNewFriendPacket()
_ = c.sendPacket(pkt) _ = c.sendPacket(pkt)
} }
func troopSystemMessageDecoder(c *QQClient, pMsg *msg.Message, info *network.IncomingPacketInfo) { func troopSystemMessageDecoder(c *QQClient, pMsg *msg.Message, info *network.Response) {
if !info.Params.Bool("used_reg_proxy") && pMsg.Head.GetMsgType() != 85 && pMsg.Head.GetMsgType() != 36 { if !info.Params.Bool("used_reg_proxy") && pMsg.Head.GetMsgType() != 85 && pMsg.Head.GetMsgType() != 36 {
c.exceptAndDispatchGroupSysMsg() c.exceptAndDispatchGroupSysMsg()
} }
@ -246,7 +246,7 @@ func troopSystemMessageDecoder(c *QQClient, pMsg *msg.Message, info *network.Inc
} }
} }
func msgType0x211Decoder(c *QQClient, pMsg *msg.Message, info *network.IncomingPacketInfo) { func msgType0x211Decoder(c *QQClient, pMsg *msg.Message, info *network.Response) {
if pMsg.Head.GetC2CCmd() == 6 || pMsg.Head.C2CTmpMsgHead != nil { if pMsg.Head.GetC2CCmd() == 6 || pMsg.Head.C2CTmpMsgHead != nil {
tempSessionDecoder(c, pMsg, info) tempSessionDecoder(c, pMsg, info)
} }

2
client/c2c_switch.go
View File

@ -16,7 +16,7 @@ const (
troopSystemMsgDecoders troopSystemMsgDecoders
) )
func peekC2CDecoder(msgType int32) (decoder func(*QQClient, *msg.Message, *network.IncomingPacketInfo), decoderType uint8) { func peekC2CDecoder(msgType int32) (decoder func(*QQClient, *msg.Message, *network.Response), decoderType uint8) {
switch msgType { switch msgType {
case 9: case 9:
return privateMessageDecoder, privateMsgDecoders return privateMessageDecoder, privateMsgDecoders

4
client/client.go
View File

@ -116,7 +116,7 @@ func (h *handlerInfo) getParams() network.RequestParams {
return h.params return h.params
} }
var decoders = map[string]func(*QQClient, *network.IncomingPacketInfo, []byte) (interface{}, error){ var decoders = map[string]func(*QQClient, *network.Response) (interface{}, error){
"wtlogin.login": decodeLoginResponse, "wtlogin.login": decodeLoginResponse,
"wtlogin.exchange_emp": decodeExchangeEmpResponse, "wtlogin.exchange_emp": decodeExchangeEmpResponse,
"wtlogin.trans_emp": decodeTransEmpResponse, "wtlogin.trans_emp": decodeTransEmpResponse,
@ -435,7 +435,7 @@ func (c *QQClient) init(tokenLogin bool) error {
_, _ = c.sendAndWait(c.buildConnKeyRequestPacket()) // big data key 如果等待 config push 的话时间来不及 _, _ = c.sendAndWait(c.buildConnKeyRequestPacket()) // big data key 如果等待 config push 的话时间来不及
} }
seq, pkt := c.buildGetMessageRequestPacket(msg.SyncFlag_START, time.Now().Unix()) seq, pkt := c.buildGetMessageRequestPacket(msg.SyncFlag_START, time.Now().Unix())
_, _ = c.sendAndWait(seq, pkt, network.RequestParams{"used_reg_proxy": true, "init": true}) _, _ = c.sendAndWaitParams(seq, pkt, network.RequestParams{"used_reg_proxy": true, "init": true})
c.syncChannelFirstView() c.syncChannelFirstView()
return nil return nil
} }

86
client/decoders.go
View File

@ -32,8 +32,8 @@ var (
) )
// wtlogin.login // wtlogin.login
func decodeLoginResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeLoginResponse(c *QQClient, resp *network.Response) (interface{}, error) {
reader := binary.NewReader(payload) reader := binary.NewReader(resp.Body)
reader.ReadUInt16() // sub command reader.ReadUInt16() // sub command
t := reader.ReadByte() t := reader.ReadByte()
reader.ReadUInt16() reader.ReadUInt16()
@ -180,9 +180,9 @@ func decodeLoginResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []b
} }
// StatSvc.register // StatSvc.register
func decodeClientRegisterResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeClientRegisterResponse(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
svcRsp := &jce.SvcRespRegister{} svcRsp := &jce.SvcRespRegister{}
@ -197,8 +197,8 @@ func decodeClientRegisterResponse(c *QQClient, _ *network.IncomingPacketInfo, pa
} }
// wtlogin.exchange_emp // wtlogin.exchange_emp
func decodeExchangeEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeExchangeEmpResponse(c *QQClient, resp *network.Response) (interface{}, error) {
reader := binary.NewReader(payload) reader := binary.NewReader(resp.Body)
cmd := reader.ReadUInt16() cmd := reader.ReadUInt16()
t := reader.ReadByte() t := reader.ReadByte()
reader.ReadUInt16() reader.ReadUInt16()
@ -217,11 +217,11 @@ func decodeExchangeEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, paylo
} }
// wtlogin.trans_emp // wtlogin.trans_emp
func decodeTransEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeTransEmpResponse(c *QQClient, resp *network.Response) (interface{}, error) {
if len(payload) < 48 { if len(resp.Body) < 48 {
return nil, errors.New("missing payload length") return nil, errors.New("missing payload length")
} }
reader := binary.NewReader(payload) reader := binary.NewReader(resp.Body)
reader.ReadBytes(5) // trans req head reader.ReadBytes(5) // trans req head
reader.ReadByte() reader.ReadByte()
reader.ReadUInt16() reader.ReadUInt16()
@ -300,9 +300,9 @@ func decodeTransEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload
} }
// ConfigPushSvc.PushReq // ConfigPushSvc.PushReq
func decodePushReqPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodePushReqPacket(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["PushReq"]["ConfigPush.PushReq"][1:]) r := jce.NewJceReader(data.Map["PushReq"]["ConfigPush.PushReq"][1:])
@ -370,20 +370,20 @@ func decodePushReqPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []b
} }
// MessageSvc.PbGetMsg // MessageSvc.PbGetMsg
func decodeMessageSvcPacket(c *QQClient, info *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMessageSvcPacket(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := msg.GetMessageResponse{} rsp := msg.GetMessageResponse{}
err := proto.Unmarshal(payload, &rsp) err := proto.Unmarshal(resp.Body, &rsp)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
c.c2cMessageSyncProcessor(&rsp, info) c.c2cMessageSyncProcessor(&rsp, resp)
return nil, nil return nil, nil
} }
// MessageSvc.PushNotify // MessageSvc.PushNotify
func decodeSvcNotify(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeSvcNotify(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload[4:])) request.ReadFrom(jce.NewJceReader(resp.Body[4:]))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
if len(data.Map) == 0 { if len(data.Map) == 0 {
@ -408,9 +408,9 @@ func decodeSvcNotify(c *QQClient, _ *network.IncomingPacketInfo, payload []byte)
} }
// SummaryCard.ReqSummaryCard // SummaryCard.ReqSummaryCard
func decodeSummaryCardResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeSummaryCardResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
rsp := func() *jce.JceReader { rsp := func() *jce.JceReader {
@ -456,9 +456,9 @@ func decodeSummaryCardResponse(_ *QQClient, _ *network.IncomingPacketInfo, paylo
} }
// friendlist.getFriendGroupList // friendlist.getFriendGroupList
func decodeFriendGroupListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeFriendGroupListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion3{} data := &jce.RequestDataVersion3{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["FLRESP"][1:]) r := jce.NewJceReader(data.Map["FLRESP"][1:])
@ -481,9 +481,9 @@ func decodeFriendGroupListResponse(_ *QQClient, _ *network.IncomingPacketInfo, p
} }
// friendlist.delFriend // friendlist.delFriend
func decodeFriendDeleteResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeFriendDeleteResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion3{} data := &jce.RequestDataVersion3{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["DFRESP"][1:]) r := jce.NewJceReader(data.Map["DFRESP"][1:])
@ -494,9 +494,9 @@ func decodeFriendDeleteResponse(_ *QQClient, _ *network.IncomingPacketInfo, payl
} }
// friendlist.GetTroopListReqV2 // friendlist.GetTroopListReqV2
func decodeGroupListResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupListResponse(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion3{} data := &jce.RequestDataVersion3{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["GetTroopListRespV2"][1:]) r := jce.NewJceReader(data.Map["GetTroopListRespV2"][1:])
@ -526,9 +526,9 @@ func decodeGroupListResponse(c *QQClient, _ *network.IncomingPacketInfo, payload
} }
// friendlist.GetTroopMemberListReq // friendlist.GetTroopMemberListReq
func decodeGroupMemberListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupMemberListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion3{} data := &jce.RequestDataVersion3{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["GTMLRESP"][1:]) r := jce.NewJceReader(data.Map["GTMLRESP"][1:])
@ -562,9 +562,9 @@ func decodeGroupMemberListResponse(_ *QQClient, _ *network.IncomingPacketInfo, p
} }
// group_member_card.get_group_member_card_info // group_member_card.get_group_member_card_info
func decodeGroupMemberInfoResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupMemberInfoResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := pb.GroupMemberRspBody{} rsp := pb.GroupMemberRspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.MemInfo == nil || (rsp.MemInfo.Nick == nil && rsp.MemInfo.Age == 0) { if rsp.MemInfo == nil || (rsp.MemInfo.Nick == nil && rsp.MemInfo.Age == 0) {
@ -595,9 +595,9 @@ func decodeGroupMemberInfoResponse(c *QQClient, _ *network.IncomingPacketInfo, p
} }
// LongConn.OffPicUp // LongConn.OffPicUp
func decodeOffPicUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOffPicUpResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
rsp := cmd0x352.RspBody{} rsp := cmd0x352.RspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.GetFailMsg() != nil { if rsp.GetFailMsg() != nil {
@ -633,9 +633,9 @@ func decodeOffPicUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload
} }
// OnlinePush.PbPushTransMsg // OnlinePush.PbPushTransMsg
func decodeOnlinePushTransPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOnlinePushTransPacket(c *QQClient, resp *network.Response) (interface{}, error) {
info := msg.TransMsgInfo{} info := msg.TransMsgInfo{}
err := proto.Unmarshal(payload, &info) err := proto.Unmarshal(resp.Body, &info)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
@ -736,9 +736,9 @@ func decodeOnlinePushTransPacket(c *QQClient, _ *network.IncomingPacketInfo, pay
} }
// ProfileService.Pb.ReqSystemMsgNew.Friend // ProfileService.Pb.ReqSystemMsgNew.Friend
func decodeSystemMsgFriendPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeSystemMsgFriendPacket(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := structmsg.RspSystemMsgNew{} rsp := structmsg.RspSystemMsgNew{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(rsp.Friendmsgs) == 0 { if len(rsp.Friendmsgs) == 0 {
@ -758,9 +758,9 @@ func decodeSystemMsgFriendPacket(c *QQClient, _ *network.IncomingPacketInfo, pay
} }
// MessageSvc.PushForceOffline // MessageSvc.PushForceOffline
func decodeForceOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeForceOfflinePacket(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
r := jce.NewJceReader(data.Map["req_PushForceOffline"]["PushNotifyPack.RequestPushForceOffline"][1:]) r := jce.NewJceReader(data.Map["req_PushForceOffline"]["PushNotifyPack.RequestPushForceOffline"][1:])
@ -771,7 +771,7 @@ func decodeForceOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, payloa
} }
// StatSvc.ReqMSFOffline // StatSvc.ReqMSFOffline
func decodeMSFOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, _ []byte) (interface{}, error) { func decodeMSFOfflinePacket(c *QQClient, _ *network.Response) (interface{}, error) {
// c.lastLostMsg = "服务器端强制下线." // c.lastLostMsg = "服务器端强制下线."
c.Disconnect() c.Disconnect()
// 这个decoder不能消耗太多时间, event另起线程处理 // 这个decoder不能消耗太多时间, event另起线程处理
@ -780,10 +780,10 @@ func decodeMSFOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, _ []byte
} }
// OidbSvc.0xd79 // OidbSvc.0xd79
func decodeWordSegmentation(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeWordSegmentation(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := &oidb.D79RspBody{} rsp := &oidb.D79RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil {
@ -795,7 +795,7 @@ func decodeWordSegmentation(_ *QQClient, _ *network.IncomingPacketInfo, payload
return nil, errors.New("no word received") return nil, errors.New("no word received")
} }
func decodeSidExpiredPacket(c *QQClient, i *network.IncomingPacketInfo, _ []byte) (interface{}, error) { func decodeSidExpiredPacket(c *QQClient, resp *network.Response) (interface{}, error) {
_, err := c.sendAndWait(c.buildRequestChangeSigPacket(3554528)) _, err := c.sendAndWait(c.buildRequestChangeSigPacket(3554528))
if err != nil { if err != nil {
return nil, errors.Wrap(err, "resign client error") return nil, errors.Wrap(err, "resign client error")
@ -803,13 +803,13 @@ func decodeSidExpiredPacket(c *QQClient, i *network.IncomingPacketInfo, _ []byte
if err = c.registerClient(); err != nil { if err = c.registerClient(); err != nil {
return nil, errors.Wrap(err, "register error") return nil, errors.Wrap(err, "register error")
} }
_ = c.sendPacket(c.uniPacketWithSeq(i.SequenceId, "OnlinePush.SidTicketExpired", EmptyBytes)) _ = c.sendPacket(c.uniPacketWithSeq(uint16(resp.SequenceID), "OnlinePush.SidTicketExpired", EmptyBytes))
return nil, nil return nil, nil
} }
/* unused /* unused
// LightAppSvc.mini_app_info.GetAppInfoById // LightAppSvc.mini_app_info.GetAppInfoById
func decodeAppInfoResponse(_ *QQClient, _ *incomingPacketInfo, payload []byte) (interface{}, error) { func decodeAppInfoResponse(_ *QQClient, _ *incomingPacketInfo) (interface{}, error) {
pkg := qweb.QWebRsp{} pkg := qweb.QWebRsp{}
rsp := qweb.GetAppInfoByIdRsp{} rsp := qweb.GetAppInfoByIdRsp{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(payload, &pkg); err != nil {
@ -825,6 +825,6 @@ func decodeAppInfoResponse(_ *QQClient, _ *incomingPacketInfo, payload []byte) (
} }
*/ */
func ignoreDecoder(_ *QQClient, _ *network.IncomingPacketInfo, _ []byte) (interface{}, error) { func ignoreDecoder(_ *QQClient, _ *network.Response) (interface{}, error) {
return nil, nil return nil, nil
} }

4
client/face.go
View File

@ -41,9 +41,9 @@ func (c *QQClient) buildFaceroamRequestPacket() (uint16, []byte) {
return c.uniPacket("Faceroam.OpReq", payload) return c.uniPacket("Faceroam.OpReq", payload)
} }
func decodeFaceroamResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeFaceroamResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := faceroam.FaceroamRspBody{} rsp := faceroam.FaceroamRspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.RspUserInfo == nil { if rsp.RspUserInfo == nil {

20
client/group_file.go
View File

@ -440,10 +440,10 @@ func (c *QQClient) buildGroupFileDeleteReqPacket(groupCode int64, parentFolderId
return c.uniPacket("OidbSvc.0x6d6_3", payload) return c.uniPacket("OidbSvc.0x6d6_3", payload)
} }
func decodeOIDB6d81Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOIDB6d81Response(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D6D8RspBody{} rsp := oidb.D6D8RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -453,10 +453,10 @@ func decodeOIDB6d81Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
} }
// OidbSvc.0x6d6_2 // OidbSvc.0x6d6_2
func decodeOIDB6d62Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOIDB6d62Response(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D6D6RspBody{} rsp := oidb.D6D6RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -470,10 +470,10 @@ func decodeOIDB6d62Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
return fmt.Sprintf("http://%s/ftn_handler/%s/", ip, url), nil return fmt.Sprintf("http://%s/ftn_handler/%s/", ip, url), nil
} }
func decodeOIDB6d63Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOIDB6d63Response(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D6D6RspBody{} rsp := oidb.D6D6RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -485,10 +485,10 @@ func decodeOIDB6d63Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
return rsp.DeleteFileRsp.GetClientWording(), nil return rsp.DeleteFileRsp.GetClientWording(), nil
} }
func decodeOIDB6d60Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOIDB6d60Response(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D6D6RspBody{} rsp := oidb.D6D6RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -497,10 +497,10 @@ func decodeOIDB6d60Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
return rsp.UploadFileRsp, nil return rsp.UploadFileRsp, nil
} }
func decodeOIDB6d7Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOIDB6d7Response(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D6D7RspBody{} rsp := oidb.D6D7RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {

8
client/group_info.go
View File

@ -188,9 +188,9 @@ func (c *QQClient) buildGroupSearchPacket(keyword string) (uint16, []byte) {
} }
// SummaryCard.ReqSearch // SummaryCard.ReqSearch
func decodeGroupSearchResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupSearchResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
if len(data.Map["RespHead"]["SummaryCard.RespHead"]) > 20 { if len(data.Map["RespHead"]["SummaryCard.RespHead"]) > 20 {
@ -226,10 +226,10 @@ func decodeGroupSearchResponse(_ *QQClient, _ *network.IncomingPacketInfo, paylo
} }
// OidbSvc.0x88d_0 // OidbSvc.0x88d_0
func decodeGroupInfoResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupInfoResponse(c *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D88DRspBody{} rsp := oidb.D88DRspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {

26
client/group_msg.go
View File

@ -81,7 +81,7 @@ func (c *QQClient) SendGroupForwardMessage(groupCode int64, m *message.ForwardEl
// GetGroupMessages 从服务器获取历史信息 // GetGroupMessages 从服务器获取历史信息
func (c *QQClient) GetGroupMessages(groupCode, beginSeq, endSeq int64) ([]*message.GroupMessage, error) { func (c *QQClient) GetGroupMessages(groupCode, beginSeq, endSeq int64) ([]*message.GroupMessage, error) {
seq, pkt := c.buildGetGroupMsgRequest(groupCode, beginSeq, endSeq) seq, pkt := c.buildGetGroupMsgRequest(groupCode, beginSeq, endSeq)
i, err := c.sendAndWait(seq, pkt, network.RequestParams{"raw": false}) i, err := c.sendAndWaitParams(seq, pkt, network.RequestParams{"raw": false})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -297,9 +297,9 @@ func (c *QQClient) buildAtAllRemainRequestPacket(groupCode int64) (uint16, []byt
} }
// OnlinePush.PbPushGroupMsg // OnlinePush.PbPushGroupMsg
func decodeGroupMessagePacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupMessagePacket(c *QQClient, resp *network.Response) (interface{}, error) {
pkt := msg.PushMessagePacket{} pkt := msg.PushMessagePacket{}
err := proto.Unmarshal(payload, &pkt) err := proto.Unmarshal(resp.Body, &pkt)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
@ -338,9 +338,9 @@ func decodeGroupMessagePacket(c *QQClient, _ *network.IncomingPacketInfo, payloa
return nil, nil return nil, nil
} }
func decodeMsgSendResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMsgSendResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := msg.SendMessageResponse{} rsp := msg.SendMessageResponse{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
switch rsp.GetResult() { switch rsp.GetResult() {
@ -353,9 +353,9 @@ func decodeMsgSendResponse(c *QQClient, _ *network.IncomingPacketInfo, payload [
return nil, nil return nil, nil
} }
func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGetGroupMsgResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := msg.GetGroupMsgResp{} rsp := msg.GetGroupMsgResp{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.GetResult() != 0 { if rsp.GetResult() != 0 {
@ -367,7 +367,7 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
if m.Head.FromUin == nil { if m.Head.FromUin == nil {
continue continue
} }
if m.Content != nil && m.Content.GetPkgNum() > 1 && !info.Params.Bool("raw") { if m.Content != nil && m.Content.GetPkgNum() > 1 && !resp.Params.Bool("raw") {
if m.Content.GetPkgIndex() == 0 { if m.Content.GetPkgIndex() == 0 {
c.Debug("build fragmented message from history") c.Debug("build fragmented message from history")
i := m.Head.GetMsgSeq() - m.Content.GetPkgNum() i := m.Head.GetMsgSeq() - m.Content.GetPkgNum()
@ -375,7 +375,7 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
for { for {
end := int32(math.Min(float64(i+19), float64(m.Head.GetMsgSeq()+m.Content.GetPkgNum()))) end := int32(math.Min(float64(i+19), float64(m.Head.GetMsgSeq()+m.Content.GetPkgNum())))
seq, pkt := c.buildGetGroupMsgRequest(m.Head.GroupInfo.GetGroupCode(), int64(i), int64(end)) seq, pkt := c.buildGetGroupMsgRequest(m.Head.GroupInfo.GetGroupCode(), int64(i), int64(end))
data, err := c.sendAndWait(seq, pkt, network.RequestParams{"raw": true}) data, err := c.sendAndWaitParams(seq, pkt, network.RequestParams{"raw": true})
if err != nil { if err != nil {
return nil, errors.Wrap(err, "build fragmented message error") return nil, errors.Wrap(err, "build fragmented message error")
} }
@ -402,10 +402,10 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
return ret, nil return ret, nil
} }
func decodeAtAllRemainResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeAtAllRemainResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.D8A7RspBody{} rsp := oidb.D8A7RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -598,10 +598,10 @@ func (c *QQClient) buildEssenceMsgOperatePacket(groupCode int64, msgSeq, msgRand
} }
// OidbSvc.0xeac_1/2 // OidbSvc.0xeac_1/2
func decodeEssenceMsgResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeEssenceMsgResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := &oidb.EACRspBody{} rsp := &oidb.EACRspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil {

4
client/guild.go
View File

@ -738,9 +738,9 @@ func (c *QQClient) buildSyncChannelFirstViewPacket() (uint16, []byte) {
return c.uniPacket("trpc.group_pro.synclogic.SyncLogic.SyncFirstView", payload) return c.uniPacket("trpc.group_pro.synclogic.SyncLogic.SyncFirstView", payload)
} }
func decodeGuildPushFirstView(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGuildPushFirstView(c *QQClient, resp *network.Response) (interface{}, error) {
firstViewMsg := new(channel.FirstViewMsg) firstViewMsg := new(channel.FirstViewMsg)
if err := proto.Unmarshal(payload, firstViewMsg); err != nil { if err := proto.Unmarshal(resp.Body, firstViewMsg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(firstViewMsg.GuildNodes) > 0 { if len(firstViewMsg.GuildNodes) > 0 {

4
client/guild_eventflow.go
View File

@ -27,9 +27,9 @@ type tipsPushInfo struct {
ChannelId uint64 ChannelId uint64
} }
func decodeGuildEventFlowPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGuildEventFlowPacket(c *QQClient, resp *network.Response) (interface{}, error) {
push := new(channel.MsgOnlinePush) push := new(channel.MsgOnlinePush)
if err := proto.Unmarshal(payload, push); err != nil { if err := proto.Unmarshal(resp.Body, push); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if push.GetCompressFlag() == 1 && len(push.CompressMsg) > 0 { if push.GetCompressFlag() == 1 && len(push.CompressMsg) > 0 {

4
client/guild_msg.go
View File

@ -291,9 +291,9 @@ func decodeGuildMessageEmojiReactions(content *channel.ChannelMsgContent) (r []*
return return
} }
func decodeGuildImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGuildImageStoreResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
body := new(cmd0x388.D388RspBody) body := new(cmd0x388.D388RspBody)
if err := proto.Unmarshal(payload, body); err != nil { if err := proto.Unmarshal(resp.Body, body); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(body.TryupImgRsp) == 0 { if len(body.TryupImgRsp) == 0 {

12
client/image.go
View File

@ -338,9 +338,9 @@ func (c *QQClient) buildImageOcrRequestPacket(url, md5 string, size, weight, hei
} }
// ImgStore.GroupPicUp // ImgStore.GroupPicUp
func decodeGroupImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupImageStoreResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkt := cmd0x388.D388RspBody{} pkt := cmd0x388.D388RspBody{}
err := proto.Unmarshal(payload, &pkt) err := proto.Unmarshal(resp.Body, &pkt)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
@ -365,9 +365,9 @@ func decodeGroupImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, p
}, nil }, nil
} }
func decodeGroupImageDownloadResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupImageDownloadResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkt := cmd0x388.D388RspBody{} pkt := cmd0x388.D388RspBody{}
if err := proto.Unmarshal(payload, &pkt); err != nil { if err := proto.Unmarshal(resp.Body, &pkt); err != nil {
return nil, errors.Wrap(err, "unmarshal protobuf message error") return nil, errors.Wrap(err, "unmarshal protobuf message error")
} }
if len(pkt.GetimgUrlRsp) == 0 { if len(pkt.GetimgUrlRsp) == 0 {
@ -380,10 +380,10 @@ func decodeGroupImageDownloadResponse(_ *QQClient, _ *network.IncomingPacketInfo
} }
// OidbSvc.0xe07_0 // OidbSvc.0xe07_0
func decodeImageOcrResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeImageOcrResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.DE07RspBody{} rsp := oidb.DE07RspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {

6
client/internal/network/packet.go
View File

@ -1,11 +1,5 @@
package network package network
type IncomingPacketInfo struct {
CommandName string
SequenceId uint16
Params RequestParams
}
type RequestParams map[string]interface{} type RequestParams map[string]interface{}
func (p RequestParams) Bool(k string) bool { func (p RequestParams) Bool(k string) bool {

45
client/internal/network/response.go
View File

@ -9,15 +9,11 @@ import (
) )
type Response struct { type Response struct {
Type RequestType
EncryptType EncryptType
SequenceID int32 SequenceID int32
Uin int64
CommandName string CommandName string
Body []byte Body []byte
Message string Params RequestParams
// Request is the original request that obtained this response. // Request is the original request that obtained this response.
// Request *Request // Request *Request
} }
@ -28,19 +24,19 @@ var (
ErrInvalidPacketType = errors.New("invalid packet type") ErrInvalidPacketType = errors.New("invalid packet type")
) )
func (t *Transport) ReadResponse(head []byte) (*Response, error) { func (t *Transport) ReadRequest(head []byte) (*Request, error) {
resp := new(Response) req := new(Request)
r := binary.NewReader(head) r := binary.NewReader(head)
resp.Type = RequestType(r.ReadInt32()) req.Type = RequestType(r.ReadInt32())
if resp.Type != RequestTypeLogin && resp.Type != RequestTypeSimple { if req.Type != RequestTypeLogin && req.Type != RequestTypeSimple {
return resp, ErrInvalidPacketType return req, ErrInvalidPacketType
} }
resp.EncryptType = EncryptType(r.ReadByte()) req.EncryptType = EncryptType(r.ReadByte())
_ = r.ReadByte() // 0x00? _ = r.ReadByte() // 0x00?
resp.Uin, _ = strconv.ParseInt(r.ReadString(), 10, 64) req.Uin, _ = strconv.ParseInt(r.ReadString(), 10, 64)
body := r.ReadAvailable() body := r.ReadAvailable()
switch resp.EncryptType { switch req.EncryptType {
case EncryptTypeNoEncrypt: case EncryptTypeNoEncrypt:
// nothing to do // nothing to do
case EncryptTypeD2Key: case EncryptTypeD2Key:
@ -48,11 +44,11 @@ func (t *Transport) ReadResponse(head []byte) (*Response, error) {
case EncryptTypeEmptyKey: case EncryptTypeEmptyKey:
body = binary.NewTeaCipher(emptyKey).Decrypt(body) body = binary.NewTeaCipher(emptyKey).Decrypt(body)
} }
err := t.readSSOFrame(resp, body) err := t.readSSOFrame(req, body)
return resp, err return req, err
} }
func (t *Transport) readSSOFrame(resp *Response, payload []byte) error { func (t *Transport) readSSOFrame(req *Request, payload []byte) error {
reader := binary.NewReader(payload) reader := binary.NewReader(payload)
headLen := reader.ReadInt32() headLen := reader.ReadInt32()
if headLen-4 > int32(reader.Len()) { if headLen-4 > int32(reader.Len()) {
@ -60,18 +56,19 @@ func (t *Transport) readSSOFrame(resp *Response, payload []byte) error {
} }
head := binary.NewReader(reader.ReadBytes(int(headLen) - 4)) head := binary.NewReader(reader.ReadBytes(int(headLen) - 4))
resp.SequenceID = head.ReadInt32() req.SequenceID = head.ReadInt32()
switch retCode := head.ReadInt32(); retCode { retCode := head.ReadInt32()
message := head.ReadString()
switch retCode {
case 0: case 0:
// ok // ok
case -10008: case -10008:
return errors.WithStack(ErrSessionExpired) return errors.WithMessage(ErrSessionExpired, message)
default: default:
return errors.Errorf("return code unsuccessful: %d", retCode) return errors.Errorf("return code unsuccessful: %d message: %s", retCode, message)
} }
resp.Message = head.ReadString() req.CommandName = head.ReadString()
resp.CommandName = head.ReadString() if req.CommandName == "Heartbeat.Alive" {
if resp.CommandName == "Heartbeat.Alive" {
return nil return nil
} }
_ = head.ReadInt32Bytes() // session id _ = head.ReadInt32Bytes() // session id
@ -87,6 +84,6 @@ func (t *Transport) readSSOFrame(resp *Response, payload []byte) error {
case 1: case 1:
body = binary.ZlibUncompress(body) body = binary.ZlibUncompress(body)
} }
resp.Body = body req.Body = body
return nil return nil
} }

8
client/multimsg.go
View File

@ -45,9 +45,9 @@ func (c *QQClient) buildMultiApplyUpPacket(data, hash []byte, buType int32, grou
} }
// MultiMsg.ApplyUp // MultiMsg.ApplyUp
func decodeMultiApplyUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMultiApplyUpResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
body := multimsg.MultiRspBody{} body := multimsg.MultiRspBody{}
if err := proto.Unmarshal(payload, &body); err != nil { if err := proto.Unmarshal(resp.Body, &body); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(body.MultimsgApplyupRsp) == 0 { if len(body.MultimsgApplyupRsp) == 0 {
@ -85,9 +85,9 @@ func (c *QQClient) buildMultiApplyDownPacket(resID string) (uint16, []byte) {
} }
// MultiMsg.ApplyDown // MultiMsg.ApplyDown
func decodeMultiApplyDownResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMultiApplyDownResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
body := multimsg.MultiRspBody{} body := multimsg.MultiRspBody{}
if err := proto.Unmarshal(payload, &body); err != nil { if err := proto.Unmarshal(resp.Body, &body); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(body.MultimsgApplydownRsp) == 0 { if len(body.MultimsgApplydownRsp) == 0 {

66
client/network.go
View File

@ -10,7 +10,6 @@ import (
"github.com/Mrs4s/MiraiGo/client/internal/network" "github.com/Mrs4s/MiraiGo/client/internal/network"
"github.com/Mrs4s/MiraiGo/client/internal/oicq" "github.com/Mrs4s/MiraiGo/client/internal/oicq"
"github.com/Mrs4s/MiraiGo/internal/packets"
"github.com/Mrs4s/MiraiGo/message" "github.com/Mrs4s/MiraiGo/message"
"github.com/Mrs4s/MiraiGo/utils" "github.com/Mrs4s/MiraiGo/utils"
) )
@ -147,25 +146,24 @@ func (c *QQClient) Disconnect() {
c.TCP.Close() c.TCP.Close()
} }
func (c *QQClient) sendAndWait(seq uint16, pkt []byte) (interface{}, error) {
return c.sendAndWaitParams(seq, pkt, nil)
}
// sendAndWait 向服务器发送一个数据包, 并等待返回 // sendAndWait 向服务器发送一个数据包, 并等待返回
func (c *QQClient) sendAndWait(seq uint16, pkt []byte, params ...network.RequestParams) (interface{}, error) { func (c *QQClient) sendAndWaitParams(seq uint16, pkt []byte, params network.RequestParams) (interface{}, error) {
type T struct { type T struct {
Response interface{} Response interface{}
Error error Error error
} }
ch := make(chan T, 1) ch := make(chan T, 1)
var p network.RequestParams
if len(params) != 0 {
p = params[0]
}
c.handlers.Store(seq, &handlerInfo{fun: func(i interface{}, err error) { c.handlers.Store(seq, &handlerInfo{fun: func(i interface{}, err error) {
ch <- T{ ch <- T{
Response: i, Response: i,
Error: err, Error: err,
} }
}, params: p, dynamic: false}) }, params: params, dynamic: false})
err := c.sendPacket(pkt) err := c.sendPacket(pkt)
if err != nil { if err != nil {
@ -292,8 +290,7 @@ func (c *QQClient) netLoop() {
continue continue
} }
data, _ := c.TCP.ReadBytes(int(l) - 4) data, _ := c.TCP.ReadBytes(int(l) - 4)
resp, err := c.transport.ReadResponse(data) req, err := c.transport.ReadRequest(data)
// pkt, err := packets.ParseIncomingPacket(data, c.sig.D2Key)
if err != nil { if err != nil {
c.Error("parse incoming packet error: %v", err) c.Error("parse incoming packet error: %v", err)
if errors.Is(err, network.ErrSessionExpired) || errors.Is(err, network.ErrPacketDropped) { if errors.Is(err, network.ErrSessionExpired) || errors.Is(err, network.ErrPacketDropped) {
@ -307,8 +304,8 @@ func (c *QQClient) netLoop() {
} }
continue continue
} }
if resp.EncryptType == network.EncryptTypeEmptyKey { if req.EncryptType == network.EncryptTypeEmptyKey {
m, err := c.oicq.Unmarshal(resp.Body) m, err := c.oicq.Unmarshal(req.Body)
if err != nil { if err != nil {
c.Error("decrypt payload error: %v", err) c.Error("decrypt payload error: %v", err)
if errors.Is(err, oicq.ErrUnknownFlag) { if errors.Is(err, oicq.ErrUnknownFlag) {
@ -316,50 +313,47 @@ func (c *QQClient) netLoop() {
} }
continue continue
} }
resp.Body = m.Body req.Body = m.Body
} }
errCount = 0 errCount = 0
c.Debug("rev pkt: %v seq: %v", resp.CommandName, resp.SequenceID) c.Debug("rev pkt: %v seq: %v", req.CommandName, req.SequenceID)
c.stat.PacketReceived.Add(1) c.stat.PacketReceived.Add(1)
pkt := &packets.IncomingPacket{ go func(req *network.Request) {
SequenceId: uint16(resp.SequenceID),
CommandName: resp.CommandName,
Payload: resp.Body,
}
go func(pkt *packets.IncomingPacket) {
defer func() { defer func() {
if pan := recover(); pan != nil { if pan := recover(); pan != nil {
c.Error("panic on decoder %v : %v\n%s", pkt.CommandName, pan, debug.Stack()) c.Error("panic on decoder %v : %v\n%s", req.CommandName, pan, debug.Stack())
c.Dump("packet decode error: %v - %v", pkt.Payload, pkt.CommandName, pan) c.Dump("packet decode error: %v - %v", req.Body, req.CommandName, pan)
} }
}() }()
if decoder, ok := decoders[req.CommandName]; ok {
if decoder, ok := decoders[pkt.CommandName]; ok {
// found predefined decoder // found predefined decoder
info, ok := c.handlers.LoadAndDelete(pkt.SequenceId) info, ok := c.handlers.LoadAndDelete(uint16(req.SequenceID))
var decoded interface{} var decoded interface{}
decoded = pkt.Payload decoded = req.Body
if info == nil || !info.dynamic { if info == nil || !info.dynamic {
decoded, err = decoder(c, &network.IncomingPacketInfo{ resp := network.Response{
SequenceId: pkt.SequenceId, SequenceID: req.SequenceID,
CommandName: pkt.CommandName, CommandName: req.CommandName,
Params: info.getParams(), Params: info.getParams(),
}, pkt.Payload) Body: req.Body,
// Request: nil,
}
decoded, err = decoder(c, &resp)
if err != nil { if err != nil {
c.Debug("decode pkt %v error: %+v", pkt.CommandName, err) c.Debug("decode req %v error: %+v", req.CommandName, err)
} }
} }
if ok { if ok {
info.fun(decoded, err) info.fun(decoded, err)
} else if f, ok := c.waiters.Load(pkt.CommandName); ok { // 在不存在handler的情况下触发wait } else if f, ok := c.waiters.Load(req.CommandName); ok { // 在不存在handler的情况下触发wait
f.(func(interface{}, error))(decoded, err) f.(func(interface{}, error))(decoded, err)
} }
} else if f, ok := c.handlers.LoadAndDelete(pkt.SequenceId); ok { } else if f, ok := c.handlers.LoadAndDelete(uint16(req.SequenceID)); ok {
// does not need decoder // does not need decoder
f.fun(pkt.Payload, nil) f.fun(req.Body, nil)
} else { } else {
c.Debug("Unhandled Command: %s\nSeq: %d\nThis message can be ignored.", pkt.CommandName, pkt.SequenceId) c.Debug("Unhandled Command: %s\nSeq: %d\nThis message can be ignored.", req.CommandName, req.SequenceID)
} }
}(pkt) }(req)
} }
} }

4
client/offline_file.go
View File

@ -33,9 +33,9 @@ func (c *QQClient) buildOfflineFileDownloadRequestPacket(uuid []byte) (uint16, [
return seq, packet return seq, packet
} }
func decodeOfflineFileDownloadResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOfflineFileDownloadResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := cmd0x346.C346RspBody{} rsp := cmd0x346.C346RspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
c.Error("unmarshal cmd0x346 rsp body error: %v", err) c.Error("unmarshal cmd0x346 rsp body error: %v", err)
return nil, errors.Wrap(err, "unmarshal cmd0x346 rsp body error") return nil, errors.Wrap(err, "unmarshal cmd0x346 rsp body error")
} }

6
client/online_push.go
View File

@ -23,15 +23,15 @@ var msg0x210Decoders = map[int64]func(*QQClient, []byte) error{
} }
// OnlinePush.ReqPush // OnlinePush.ReqPush
func decodeOnlinePushReqPacket(c *QQClient, info *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeOnlinePushReqPacket(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
jr := jce.NewJceReader(data.Map["req"]["OnlinePushPack.SvcReqPushMsg"][1:]) jr := jce.NewJceReader(data.Map["req"]["OnlinePushPack.SvcReqPushMsg"][1:])
uin := jr.ReadInt64(0) uin := jr.ReadInt64(0)
msgInfos := jr.ReadPushMessageInfos(2) msgInfos := jr.ReadPushMessageInfos(2)
_ = c.sendPacket(c.buildDeleteOnlinePushPacket(uin, 0, nil, info.SequenceId, msgInfos)) _ = c.sendPacket(c.buildDeleteOnlinePushPacket(uin, 0, nil, uint16(resp.SequenceID), msgInfos))
for _, m := range msgInfos { for _, m := range msgInfos {
k := fmt.Sprintf("%v%v%v", m.MsgSeq, m.MsgTime, m.MsgUid) k := fmt.Sprintf("%v%v%v", m.MsgSeq, m.MsgTime, m.MsgUid)
if _, ok := c.onlinePushCache.Get(k); ok { if _, ok := c.onlinePushCache.Get(k); ok {

8
client/ptt.go
View File

@ -337,9 +337,9 @@ func (c *QQClient) buildC2CPttStoreBDHExt(target int64, md5 []byte, size, voiceL
} }
// PttCenterSvr.ShortVideoDownReq // PttCenterSvr.ShortVideoDownReq
func decodePttShortVideoDownResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodePttShortVideoDownResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
rsp := pttcenter.ShortVideoRspBody{} rsp := pttcenter.ShortVideoRspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.PttShortVideoDownloadRsp == nil || rsp.PttShortVideoDownloadRsp.DownloadAddr == nil { if rsp.PttShortVideoDownloadRsp == nil || rsp.PttShortVideoDownloadRsp.DownloadAddr == nil {
@ -349,9 +349,9 @@ func decodePttShortVideoDownResponse(_ *QQClient, _ *network.IncomingPacketInfo,
} }
// PttCenterSvr.GroupShortVideoUpReq // PttCenterSvr.GroupShortVideoUpReq
func decodeGroupShortVideoUploadResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeGroupShortVideoUploadResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
rsp := pttcenter.ShortVideoRspBody{} rsp := pttcenter.ShortVideoRspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.PttShortVideoUploadRsp == nil { if rsp.PttShortVideoUploadRsp == nil {

8
client/qidian.go
View File

@ -152,9 +152,9 @@ func (c *QQClient) bigDataRequest(subCmd uint32, req proto.Message) ([]byte, err
return tea.Decrypt(payload), nil return tea.Decrypt(payload), nil
} }
func decodeLoginExtraResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeLoginExtraResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := cmd0x3f6.C3F6RspBody{} rsp := cmd0x3f6.C3F6RspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if rsp.SubcmdLoginProcessCompleteRspBody == nil { if rsp.SubcmdLoginProcessCompleteRspBody == nil {
@ -168,9 +168,9 @@ func decodeLoginExtraResponse(c *QQClient, _ *network.IncomingPacketInfo, payloa
return nil, nil return nil, nil
} }
func decodeConnKeyResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeConnKeyResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := cmd0x6ff.C501RspBody{} rsp := cmd0x6ff.C501RspBody{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if c.QiDian == nil { if c.QiDian == nil {

4
client/recall.go
View File

@ -92,9 +92,9 @@ func (c *QQClient) buildPrivateRecallPacket(uin, ts int64, msgSeq, random int32)
return c.uniPacket("PbMessageSvc.PbMsgWithDraw", payload) return c.uniPacket("PbMessageSvc.PbMsgWithDraw", payload)
} }
func decodeMsgWithDrawResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMsgWithDrawResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
rsp := msg.MsgWithDrawResp{} rsp := msg.MsgWithDrawResp{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(rsp.C2CWithDraw) > 0 { if len(rsp.C2CWithDraw) > 0 {

4
client/security.go
View File

@ -48,10 +48,10 @@ func (c *QQClient) buildUrlCheckRequest(url string) (uint16, []byte) {
return c.uniPacket("OidbSvc.0xbcb_0", payload) return c.uniPacket("OidbSvc.0xbcb_0", payload)
} }
func decodeUrlCheckResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeUrlCheckResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := &oidb.OIDBSSOPkg{} pkg := &oidb.OIDBSSOPkg{}
rsp := &oidb.DBCBRspBody{} rsp := &oidb.DBCBRspBody{}
if err := proto.Unmarshal(payload, pkg); err != nil { if err := proto.Unmarshal(resp.Body, pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil {

30
client/sync.go
View File

@ -285,9 +285,9 @@ func (c *QQClient) buildPrivateMsgReadedPacket(uin, time int64) (uint16, []byte)
} }
// StatSvc.GetDevLoginInfo // StatSvc.GetDevLoginInfo
func decodeDevListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeDevListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
rsp := jce.NewJceReader(data.Map["SvcRspGetDevLoginInfo"]["QQService.SvcRspGetDevLoginInfo"][1:]) rsp := jce.NewJceReader(data.Map["SvcRspGetDevLoginInfo"]["QQService.SvcRspGetDevLoginInfo"][1:])
@ -307,9 +307,9 @@ func decodeDevListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload [
} }
// RegPrxySvc.PushParam // RegPrxySvc.PushParam
func decodePushParamPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodePushParamPacket(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
reader := jce.NewJceReader(data.Map["SvcRespParam"]["RegisterProxySvcPack.SvcRespParam"][1:]) reader := jce.NewJceReader(data.Map["SvcRespParam"]["RegisterProxySvcPack.SvcRespParam"][1:])
@ -352,9 +352,9 @@ func decodePushParamPacket(c *QQClient, _ *network.IncomingPacketInfo, payload [
} }
// RegPrxySvc.PbSyncMsg // RegPrxySvc.PbSyncMsg
func decodeMsgSyncResponse(c *QQClient, info *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMsgSyncResponse(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := &msf.SvcRegisterProxyMsgResp{} rsp := &msf.SvcRegisterProxyMsgResp{}
if err := proto.Unmarshal(payload, rsp); err != nil { if err := proto.Unmarshal(resp.Body, rsp); err != nil {
return nil, err return nil, err
} }
ret := &sessionSyncEvent{ ret := &sessionSyncEvent{
@ -389,26 +389,26 @@ func decodeMsgSyncResponse(c *QQClient, info *network.IncomingPacketInfo, payloa
if len(rsp.C2CMsg) > 4 { if len(rsp.C2CMsg) > 4 {
c2cRsp := &msg.GetMessageResponse{} c2cRsp := &msg.GetMessageResponse{}
if proto.Unmarshal(rsp.C2CMsg[4:], c2cRsp) == nil { if proto.Unmarshal(rsp.C2CMsg[4:], c2cRsp) == nil {
c.c2cMessageSyncProcessor(c2cRsp, info) c.c2cMessageSyncProcessor(c2cRsp, resp)
} }
} }
return ret, nil return ret, nil
} }
// OnlinePush.PbC2CMsgSync // OnlinePush.PbC2CMsgSync
func decodeC2CSyncPacket(c *QQClient, info *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeC2CSyncPacket(c *QQClient, resp *network.Response) (interface{}, error) {
m := msg.PbPushMsg{} m := msg.PbPushMsg{}
if err := proto.Unmarshal(payload, &m); err != nil { if err := proto.Unmarshal(resp.Body, &m); err != nil {
return nil, err return nil, err
} }
_ = c.sendPacket(c.buildDeleteOnlinePushPacket(c.Uin, m.GetSvrip(), m.GetPushToken(), info.SequenceId, nil)) _ = c.sendPacket(c.buildDeleteOnlinePushPacket(c.Uin, m.GetSvrip(), m.GetPushToken(), uint16(resp.SequenceID), nil))
c.commMsgProcessor(m.Msg, info) c.commMsgProcessor(m.Msg, resp)
return nil, nil return nil, nil
} }
func decodeMsgReadedResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeMsgReadedResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
rsp := msg.PbMsgReadedReportResp{} rsp := msg.PbMsgReadedReportResp{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if len(rsp.GrpReadReport) > 0 { if len(rsp.GrpReadReport) > 0 {
@ -420,9 +420,9 @@ func decodeMsgReadedResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload
var loginNotifyLock sync.Mutex var loginNotifyLock sync.Mutex
// StatSvc.SvcReqMSFLoginNotify // StatSvc.SvcReqMSFLoginNotify
func decodeLoginNotifyPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeLoginNotifyPacket(c *QQClient, resp *network.Response) (interface{}, error) {
request := &jce.RequestPacket{} request := &jce.RequestPacket{}
request.ReadFrom(jce.NewJceReader(payload)) request.ReadFrom(jce.NewJceReader(resp.Body))
data := &jce.RequestDataVersion2{} data := &jce.RequestDataVersion2{}
data.ReadFrom(jce.NewJceReader(request.SBuffer)) data.ReadFrom(jce.NewJceReader(request.SBuffer))
reader := jce.NewJceReader(data.Map["SvcReqMSFLoginNotify"]["QQService.SvcReqMSFLoginNotify"][1:]) reader := jce.NewJceReader(data.Map["SvcReqMSFLoginNotify"]["QQService.SvcReqMSFLoginNotify"][1:])

4
client/system_msg.go
View File

@ -190,9 +190,9 @@ func (c *QQClient) buildSystemMsgFriendActionPacket(reqID, requester int64, acce
} }
// ProfileService.Pb.ReqSystemMsgNew.Group // ProfileService.Pb.ReqSystemMsgNew.Group
func decodeSystemMsgGroupPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeSystemMsgGroupPacket(c *QQClient, resp *network.Response) (interface{}, error) {
rsp := structmsg.RspSystemMsgNew{} rsp := structmsg.RspSystemMsgNew{}
if err := proto.Unmarshal(payload, &rsp); err != nil { if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
return nil, err return nil, err
} }
ret := &GroupSystemMessages{} ret := &GroupSystemMessages{}

4
client/translate.go
View File

@ -41,10 +41,10 @@ func (c *QQClient) Translate(src, dst, text string) (string, error) {
} }
// OidbSvc.0x990 // OidbSvc.0x990
func decodeTranslateResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) { func decodeTranslateResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
pkg := oidb.OIDBSSOPkg{} pkg := oidb.OIDBSSOPkg{}
rsp := oidb.TranslateRspBody{} rsp := oidb.TranslateRspBody{}
if err := proto.Unmarshal(payload, &pkg); err != nil { if err := proto.Unmarshal(resp.Body, &pkg); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal protobuf message") return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
} }
if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil { if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {

2
internal/generator/c2c_switcher/c2c_switcher.go
View File

@ -27,7 +27,7 @@ const (
{{end}} {{end}}
) )
func peekC2CDecoder(msgType int32) (decoder func(*QQClient, *msg.Message, *network.IncomingPacketInfo), decoderType uint8) { func peekC2CDecoder(msgType int32) (decoder func(*QQClient, *msg.Message, *network.Response), decoderType uint8) {
switch msgType { switch msgType {
{{range .Decoders}} case {{.Id}}: {{range .Decoders}} case {{.Id}}:
return {{.Func}}, {{.DecoderType}} return {{.Func}}, {{.DecoderType}}

8
internal/packets/global.go
View File

@ -4,14 +4,6 @@ import (
"github.com/Mrs4s/MiraiGo/binary" "github.com/Mrs4s/MiraiGo/binary"
) )
type IncomingPacket struct {
SequenceId uint16
Flag2 byte
CommandName string
SessionId []byte
Payload []byte
}
func BuildCode2DRequestPacket(seq uint32, j uint64, cmd uint16, bodyFunc func(writer *binary.Writer)) []byte { func BuildCode2DRequestPacket(seq uint32, j uint64, cmd uint16, bodyFunc func(writer *binary.Writer)) []byte {
return binary.NewWriterF(func(w *binary.Writer) { return binary.NewWriterF(func(w *binary.Writer) {
w.WriteByte(2) w.WriteByte(2)