client: refactor decoder

(cherry picked from commit 3e201bd4491838bda026130eb2b93d58ef70db69)
2025-05-04 11:07:40 +08:00 · 2021-12-24 23:48:23 +08:00 · 2021-12-24 23:48:23 +08:00 · 723563415f
commit 723563415f
parent 9946b404ae
28 changed files with 197 additions and 220 deletions
--- a/client/_c2c_decoders.go
+++ b/client/_c2c_decoders.go
@ -5,7 +5,7 @@ import (
 	"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,
 	79: privateMessageDecoder, 97: privateMessageDecoder, 120: privateMessageDecoder,
 	132: privateMessageDecoder, 133: privateMessageDecoder, 166: privateMessageDecoder,
@ -13,21 +13,21 @@ var privateMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Incomi
 	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,
 }

-var troopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.IncomingPacketInfo){
+var troopSystemMsgDecoders = map[int32]func(*QQClient, *msg.Message, *network.Response){
 	35: troopSystemMessageDecoder, 37: troopSystemMessageDecoder,
 	45: troopSystemMessageDecoder, 46: troopSystemMessageDecoder, 84: troopSystemMessageDecoder,
 	86: troopSystemMessageDecoder, 87: troopSystemMessageDecoder,
 } // 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,
 	190: systemMessageDecoder, 191: systemMessageDecoder,
 } // 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,
 }
--- a/client/c2c_processor.go
+++ b/client/c2c_processor.go
@ -39,7 +39,7 @@ const (
 	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.PubAccountCookie = rsp.PubAccountCookie
 	// 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()) {
 				continue
 			}
-			c.commMsgProcessor(pMsg, info)
+			c.commMsgProcessor(pMsg, resp)
 		}
 	}
 	if delItems != nil {
@ -73,11 +73,11 @@ func (c *QQClient) c2cMessageSyncProcessor(rsp *msg.GetMessageResponse, info *ne
 	if rsp.GetSyncFlag() != msg.SyncFlag_STOP {
 		c.Debug("continue sync with flag: %v", rsp.SyncFlag)
 		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())
 	if _, ok := c.msgSvcCache.GetAndUpdate(strKey, time.Hour); ok {
 		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
 	}
 	c.lastC2CMsgTime = int64(pMsg.Head.GetMsgTime())
-	if info.Params.Bool("init") {
+	if resp.Params.Bool("init") {
 		return
 	}
 	if decoder, _ := peekC2CDecoder(pMsg.Head.GetMsgType()); decoder != nil {
-		decoder(c, pMsg, info)
+		decoder(c, pMsg, resp)
 	} else {
 		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() {
 	case 11, 175: // friend msg
 		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 {
 		return
 	}
@ -138,7 +138,7 @@ func privatePttDecoder(c *QQClient, pMsg *msg.Message, _ *network.IncomingPacket
 	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 {
 		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()
 	defer groupJoinLock.Unlock()
 	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()
 	_ = 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 {
 		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 {
 		tempSessionDecoder(c, pMsg, info)
 	}
--- a/client/c2c_switch.go
+++ b/client/c2c_switch.go
@ -16,7 +16,7 @@ const (
 	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 {
 	case 9:
 		return privateMessageDecoder, privateMsgDecoders
--- a/client/client.go
+++ b/client/client.go
@ -116,7 +116,7 @@ func (h *handlerInfo) getParams() network.RequestParams {
 	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.exchange_emp":                         decodeExchangeEmpResponse,
 	"wtlogin.trans_emp":                            decodeTransEmpResponse,
@ -435,7 +435,7 @@ func (c *QQClient) init(tokenLogin bool) error {
 		_, _ = c.sendAndWait(c.buildConnKeyRequestPacket()) // big data key 如果等待 config push 的话时间来不及
 	}
 	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()
 	return nil
 }
--- a/client/decoders.go
+++ b/client/decoders.go
@ -32,8 +32,8 @@ var (
 )

 // wtlogin.login
-func decodeLoginResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
-	reader := binary.NewReader(payload)
+func decodeLoginResponse(c *QQClient, resp *network.Response) (interface{}, error) {
+	reader := binary.NewReader(resp.Body)
 	reader.ReadUInt16() // sub command
 	t := reader.ReadByte()
 	reader.ReadUInt16()
@ -180,9 +180,9 @@ func decodeLoginResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []b
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	svcRsp := &jce.SvcRespRegister{}
@ -197,8 +197,8 @@ func decodeClientRegisterResponse(c *QQClient, _ *network.IncomingPacketInfo, pa
 }

 // wtlogin.exchange_emp
-func decodeExchangeEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
-	reader := binary.NewReader(payload)
+func decodeExchangeEmpResponse(c *QQClient, resp *network.Response) (interface{}, error) {
+	reader := binary.NewReader(resp.Body)
 	cmd := reader.ReadUInt16()
 	t := reader.ReadByte()
 	reader.ReadUInt16()
@ -217,11 +217,11 @@ func decodeExchangeEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, paylo
 }

 // wtlogin.trans_emp
-func decodeTransEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
-	if len(payload) < 48 {
+func decodeTransEmpResponse(c *QQClient, resp *network.Response) (interface{}, error) {
+	if len(resp.Body) < 48 {
 		return nil, errors.New("missing payload length")
 	}
-	reader := binary.NewReader(payload)
+	reader := binary.NewReader(resp.Body)
 	reader.ReadBytes(5) // trans req head
 	reader.ReadByte()
 	reader.ReadUInt16()
@ -300,9 +300,9 @@ func decodeTransEmpResponse(c *QQClient, _ *network.IncomingPacketInfo, payload
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	r := jce.NewJceReader(data.Map["PushReq"]["ConfigPush.PushReq"][1:])
@ -370,20 +370,20 @@ func decodePushReqPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []b
 }

 // 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{}
-	err := proto.Unmarshal(payload, &rsp)
+	err := proto.Unmarshal(resp.Body, &rsp)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
 	}
-	c.c2cMessageSyncProcessor(&rsp, info)
+	c.c2cMessageSyncProcessor(&rsp, resp)
 	return nil, nil
 }

 // 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.ReadFrom(jce.NewJceReader(payload[4:]))
+	request.ReadFrom(jce.NewJceReader(resp.Body[4:]))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	if len(data.Map) == 0 {
@ -408,9 +408,9 @@ func decodeSvcNotify(c *QQClient, _ *network.IncomingPacketInfo, payload []byte)
 }

 // SummaryCard.ReqSummaryCard
-func decodeSummaryCardResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeSummaryCardResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	rsp := func() *jce.JceReader {
@ -456,9 +456,9 @@ func decodeSummaryCardResponse(_ *QQClient, _ *network.IncomingPacketInfo, paylo
 }

 // friendlist.getFriendGroupList
-func decodeFriendGroupListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeFriendGroupListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion3{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	r := jce.NewJceReader(data.Map["FLRESP"][1:])
@ -481,9 +481,9 @@ func decodeFriendGroupListResponse(_ *QQClient, _ *network.IncomingPacketInfo, p
 }

 // friendlist.delFriend
-func decodeFriendDeleteResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeFriendDeleteResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion3{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	r := jce.NewJceReader(data.Map["DFRESP"][1:])
@ -494,9 +494,9 @@ func decodeFriendDeleteResponse(_ *QQClient, _ *network.IncomingPacketInfo, payl
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion3{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	r := jce.NewJceReader(data.Map["GetTroopListRespV2"][1:])
@ -526,9 +526,9 @@ func decodeGroupListResponse(c *QQClient, _ *network.IncomingPacketInfo, payload
 }

 // friendlist.GetTroopMemberListReq
-func decodeGroupMemberListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupMemberListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion3{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	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
-func decodeGroupMemberInfoResponse(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupMemberInfoResponse(c *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	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
-func decodeOffPicUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeOffPicUpResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if rsp.GetFailMsg() != nil {
@ -633,9 +633,9 @@ func decodeOffPicUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload
 }

 // OnlinePush.PbPushTransMsg
-func decodeOnlinePushTransPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeOnlinePushTransPacket(c *QQClient, resp *network.Response) (interface{}, error) {
 	info := msg.TransMsgInfo{}
-	err := proto.Unmarshal(payload, &info)
+	err := proto.Unmarshal(resp.Body, &info)
 	if err != nil {
 		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
-func decodeSystemMsgFriendPacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeSystemMsgFriendPacket(c *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(rsp.Friendmsgs) == 0 {
@ -758,9 +758,9 @@ func decodeSystemMsgFriendPacket(c *QQClient, _ *network.IncomingPacketInfo, pay
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	r := jce.NewJceReader(data.Map["req_PushForceOffline"]["PushNotifyPack.RequestPushForceOffline"][1:])
@ -771,7 +771,7 @@ func decodeForceOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, payloa
 }

 // StatSvc.ReqMSFOffline
-func decodeMSFOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, _ []byte) (interface{}, error) {
+func decodeMSFOfflinePacket(c *QQClient, _ *network.Response) (interface{}, error) {
 	// c.lastLostMsg = "服务器端强制下线."
 	c.Disconnect()
 	// 这个decoder不能消耗太多时间, event另起线程处理
@ -780,10 +780,10 @@ func decodeMSFOfflinePacket(c *QQClient, _ *network.IncomingPacketInfo, _ []byte
 }

 // OidbSvc.0xd79
-func decodeWordSegmentation(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeWordSegmentation(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	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")
 }

-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))
 	if err != nil {
 		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 {
 		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
 }

 /* unused
 // LightAppSvc.mini_app_info.GetAppInfoById
-func decodeAppInfoResponse(_ *QQClient, _ *incomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeAppInfoResponse(_ *QQClient, _ *incomingPacketInfo) (interface{}, error) {
 	pkg := qweb.QWebRsp{}
 	rsp := qweb.GetAppInfoByIdRsp{}
 	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
 }
--- a/client/face.go
+++ b/client/face.go
@ -41,9 +41,9 @@ func (c *QQClient) buildFaceroamRequestPacket() (uint16, []byte) {
 	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{}
-	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")
 	}
 	if rsp.RspUserInfo == nil {
--- a/client/group_file.go
+++ b/client/group_file.go
@ -440,10 +440,10 @@ func (c *QQClient) buildGroupFileDeleteReqPacket(groupCode int64, parentFolderId
 	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{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -453,10 +453,10 @@ func decodeOIDB6d81Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
 }

 // OidbSvc.0x6d6_2
-func decodeOIDB6d62Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeOIDB6d62Response(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	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
 }

-func decodeOIDB6d63Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeOIDB6d63Response(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -485,10 +485,10 @@ func decodeOIDB6d63Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
 	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{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
@ -497,10 +497,10 @@ func decodeOIDB6d60Response(_ *QQClient, _ *network.IncomingPacketInfo, payload
 	return rsp.UploadFileRsp, nil
 }

-func decodeOIDB6d7Response(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeOIDB6d7Response(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
--- a/client/group_info.go
+++ b/client/group_info.go
@ -188,9 +188,9 @@ func (c *QQClient) buildGroupSearchPacket(keyword string) (uint16, []byte) {
 }

 // SummaryCard.ReqSearch
-func decodeGroupSearchResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupSearchResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	if len(data.Map["RespHead"]["SummaryCard.RespHead"]) > 20 {
@ -226,10 +226,10 @@ func decodeGroupSearchResponse(_ *QQClient, _ *network.IncomingPacketInfo, paylo
 }

 // 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{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
--- a/client/group_msg.go
+++ b/client/group_msg.go
@ -81,7 +81,7 @@ func (c *QQClient) SendGroupForwardMessage(groupCode int64, m *message.ForwardEl
 // GetGroupMessages 从服务器获取历史信息
 func (c *QQClient) GetGroupMessages(groupCode, beginSeq, endSeq int64) ([]*message.GroupMessage, error) {
 	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 {
 		return nil, err
 	}
@ -297,9 +297,9 @@ func (c *QQClient) buildAtAllRemainRequestPacket(groupCode int64) (uint16, []byt
 }

 // OnlinePush.PbPushGroupMsg
-func decodeGroupMessagePacket(c *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupMessagePacket(c *QQClient, resp *network.Response) (interface{}, error) {
 	pkt := msg.PushMessagePacket{}
-	err := proto.Unmarshal(payload, &pkt)
+	err := proto.Unmarshal(resp.Body, &pkt)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
 	}
@ -338,9 +338,9 @@ func decodeGroupMessagePacket(c *QQClient, _ *network.IncomingPacketInfo, payloa
 	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{}
-	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")
 	}
 	switch rsp.GetResult() {
@ -353,9 +353,9 @@ func decodeMsgSendResponse(c *QQClient, _ *network.IncomingPacketInfo, payload [
 	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{}
-	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")
 	}
 	if rsp.GetResult() != 0 {
@ -367,7 +367,7 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
 		if m.Head.FromUin == nil {
 			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 {
 				c.Debug("build fragmented message from history")
 				i := m.Head.GetMsgSeq() - m.Content.GetPkgNum()
@ -375,7 +375,7 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
 				for {
 					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))
-					data, err := c.sendAndWait(seq, pkt, network.RequestParams{"raw": true})
+					data, err := c.sendAndWaitParams(seq, pkt, network.RequestParams{"raw": true})
 					if err != nil {
 						return nil, errors.Wrap(err, "build fragmented message error")
 					}
@ -402,10 +402,10 @@ func decodeGetGroupMsgResponse(c *QQClient, info *network.IncomingPacketInfo, pa
 	return ret, nil
 }

-func decodeAtAllRemainResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeAtAllRemainResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	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
-func decodeEssenceMsgResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeEssenceMsgResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil {
--- a/client/guild.go
+++ b/client/guild.go
@ -738,9 +738,9 @@ func (c *QQClient) buildSyncChannelFirstViewPacket() (uint16, []byte) {
 	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)
-	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")
 	}
 	if len(firstViewMsg.GuildNodes) > 0 {
--- a/client/guild_eventflow.go
+++ b/client/guild_eventflow.go
@ -27,9 +27,9 @@ type tipsPushInfo struct {
 	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)
-	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")
 	}
 	if push.GetCompressFlag() == 1 && len(push.CompressMsg) > 0 {
--- a/client/guild_msg.go
+++ b/client/guild_msg.go
@ -291,9 +291,9 @@ func decodeGuildMessageEmojiReactions(content *channel.ChannelMsgContent) (r []*
 	return
 }

-func decodeGuildImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGuildImageStoreResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(body.TryupImgRsp) == 0 {
--- a/client/image.go
+++ b/client/image.go
@ -338,9 +338,9 @@ func (c *QQClient) buildImageOcrRequestPacket(url, md5 string, size, weight, hei
 }

 // ImgStore.GroupPicUp
-func decodeGroupImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupImageStoreResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkt := cmd0x388.D388RspBody{}
-	err := proto.Unmarshal(payload, &pkt)
+	err := proto.Unmarshal(resp.Body, &pkt)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshal protobuf message")
 	}
@ -365,9 +365,9 @@ func decodeGroupImageStoreResponse(_ *QQClient, _ *network.IncomingPacketInfo, p
 	}, nil
 }

-func decodeGroupImageDownloadResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupImageDownloadResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(pkt.GetimgUrlRsp) == 0 {
@ -380,10 +380,10 @@ func decodeGroupImageDownloadResponse(_ *QQClient, _ *network.IncomingPacketInfo
 }

 // OidbSvc.0xe07_0
-func decodeImageOcrResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeImageOcrResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
--- a/client/internal/network/packet.go
+++ b/client/internal/network/packet.go
@ -1,11 +1,5 @@
 package network

-type IncomingPacketInfo struct {
-	CommandName string
-	SequenceId  uint16
-	Params      RequestParams
-}
-
 type RequestParams map[string]interface{}

 func (p RequestParams) Bool(k string) bool {
--- a/client/internal/network/response.go
+++ b/client/internal/network/response.go
@ -9,15 +9,11 @@ import (
 )

 type Response struct {
-	Type        RequestType
-	EncryptType EncryptType
 	SequenceID  int32
-	Uin         int64
 	CommandName string
 	Body        []byte

-	Message string
-
+	Params RequestParams
 	// Request is the original request that obtained this response.
 	// Request *Request
 }
@ -28,19 +24,19 @@ var (
 	ErrInvalidPacketType = errors.New("invalid packet type")
 )

-func (t *Transport) ReadResponse(head []byte) (*Response, error) {
-	resp := new(Response)
+func (t *Transport) ReadRequest(head []byte) (*Request, error) {
+	req := new(Request)
 	r := binary.NewReader(head)
-	resp.Type = RequestType(r.ReadInt32())
-	if resp.Type != RequestTypeLogin && resp.Type != RequestTypeSimple {
-		return resp, ErrInvalidPacketType
+	req.Type = RequestType(r.ReadInt32())
+	if req.Type != RequestTypeLogin && req.Type != RequestTypeSimple {
+		return req, ErrInvalidPacketType
 	}
-	resp.EncryptType = EncryptType(r.ReadByte())
+	req.EncryptType = EncryptType(r.ReadByte())
 	_ = r.ReadByte() // 0x00?

-	resp.Uin, _ = strconv.ParseInt(r.ReadString(), 10, 64)
+	req.Uin, _ = strconv.ParseInt(r.ReadString(), 10, 64)
 	body := r.ReadAvailable()
-	switch resp.EncryptType {
+	switch req.EncryptType {
 	case EncryptTypeNoEncrypt:
 		// nothing to do
 	case EncryptTypeD2Key:
@ -48,11 +44,11 @@ func (t *Transport) ReadResponse(head []byte) (*Response, error) {
 	case EncryptTypeEmptyKey:
 		body = binary.NewTeaCipher(emptyKey).Decrypt(body)
 	}
-	err := t.readSSOFrame(resp, body)
-	return resp, err
+	err := t.readSSOFrame(req, body)
+	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)
 	headLen := reader.ReadInt32()
 	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))
-	resp.SequenceID = head.ReadInt32()
-	switch retCode := head.ReadInt32(); retCode {
+	req.SequenceID = head.ReadInt32()
+	retCode := head.ReadInt32()
+	message := head.ReadString()
+	switch retCode {
 	case 0:
 		// ok
 	case -10008:
-		return errors.WithStack(ErrSessionExpired)
+		return errors.WithMessage(ErrSessionExpired, message)
 	default:
-		return errors.Errorf("return code unsuccessful: %d", retCode)
+		return errors.Errorf("return code unsuccessful: %d message: %s", retCode, message)
 	}
-	resp.Message = head.ReadString()
-	resp.CommandName = head.ReadString()
-	if resp.CommandName == "Heartbeat.Alive" {
+	req.CommandName = head.ReadString()
+	if req.CommandName == "Heartbeat.Alive" {
 		return nil
 	}
 	_ = head.ReadInt32Bytes() // session id
@ -87,6 +84,6 @@ func (t *Transport) readSSOFrame(resp *Response, payload []byte) error {
 	case 1:
 		body = binary.ZlibUncompress(body)
 	}
-	resp.Body = body
+	req.Body = body
 	return nil
 }
--- a/client/multimsg.go
+++ b/client/multimsg.go
@ -45,9 +45,9 @@ func (c *QQClient) buildMultiApplyUpPacket(data, hash []byte, buType int32, grou
 }

 // MultiMsg.ApplyUp
-func decodeMultiApplyUpResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeMultiApplyUpResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(body.MultimsgApplyupRsp) == 0 {
@ -85,9 +85,9 @@ func (c *QQClient) buildMultiApplyDownPacket(resID string) (uint16, []byte) {
 }

 // MultiMsg.ApplyDown
-func decodeMultiApplyDownResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeMultiApplyDownResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(body.MultimsgApplydownRsp) == 0 {
--- a/client/network.go
+++ b/client/network.go
@ -10,7 +10,6 @@ import (

 	"github.com/Mrs4s/MiraiGo/client/internal/network"
 	"github.com/Mrs4s/MiraiGo/client/internal/oicq"
-	"github.com/Mrs4s/MiraiGo/internal/packets"
 	"github.com/Mrs4s/MiraiGo/message"
 	"github.com/Mrs4s/MiraiGo/utils"
 )
@ -147,25 +146,24 @@ func (c *QQClient) Disconnect() {
 	c.TCP.Close()
 }

+func (c *QQClient) sendAndWait(seq uint16, pkt []byte) (interface{}, error) {
+	return c.sendAndWaitParams(seq, pkt, nil)
+}
+
 // 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 {
 		Response interface{}
 		Error    error
 	}
 	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) {
 		ch <- T{
 			Response: i,
 			Error:    err,
 		}
-	}, params: p, dynamic: false})
+	}, params: params, dynamic: false})

 	err := c.sendPacket(pkt)
 	if err != nil {
@ -292,8 +290,7 @@ func (c *QQClient) netLoop() {
 			continue
 		}
 		data, _ := c.TCP.ReadBytes(int(l) - 4)
-		resp, err := c.transport.ReadResponse(data)
-		// pkt, err := packets.ParseIncomingPacket(data, c.sig.D2Key)
+		req, err := c.transport.ReadRequest(data)
 		if err != nil {
 			c.Error("parse incoming packet error: %v", err)
 			if errors.Is(err, network.ErrSessionExpired) || errors.Is(err, network.ErrPacketDropped) {
@ -307,8 +304,8 @@ func (c *QQClient) netLoop() {
 			}
 			continue
 		}
-		if resp.EncryptType == network.EncryptTypeEmptyKey {
-			m, err := c.oicq.Unmarshal(resp.Body)
+		if req.EncryptType == network.EncryptTypeEmptyKey {
+			m, err := c.oicq.Unmarshal(req.Body)
 			if err != nil {
 				c.Error("decrypt payload error: %v", err)
 				if errors.Is(err, oicq.ErrUnknownFlag) {
@ -316,50 +313,47 @@ func (c *QQClient) netLoop() {
 				}
 				continue
 			}
-			resp.Body = m.Body
+			req.Body = m.Body
 		}
 		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)
-		pkt := &packets.IncomingPacket{
-			SequenceId:  uint16(resp.SequenceID),
-			CommandName: resp.CommandName,
-			Payload:     resp.Body,
-		}
-		go func(pkt *packets.IncomingPacket) {
+		go func(req *network.Request) {
 			defer func() {
 				if pan := recover(); pan != nil {
-					c.Error("panic on decoder %v : %v\n%s", pkt.CommandName, pan, debug.Stack())
-					c.Dump("packet decode error: %v - %v", pkt.Payload, pkt.CommandName, pan)
+					c.Error("panic on decoder %v : %v\n%s", req.CommandName, pan, debug.Stack())
+					c.Dump("packet decode error: %v - %v", req.Body, req.CommandName, pan)
 				}
 			}()
-
-			if decoder, ok := decoders[pkt.CommandName]; ok {
+			if decoder, ok := decoders[req.CommandName]; ok {
 				// found predefined decoder
-				info, ok := c.handlers.LoadAndDelete(pkt.SequenceId)
+				info, ok := c.handlers.LoadAndDelete(uint16(req.SequenceID))
 				var decoded interface{}
-				decoded = pkt.Payload
+				decoded = req.Body
 				if info == nil || !info.dynamic {
-					decoded, err = decoder(c, &network.IncomingPacketInfo{
-						SequenceId:  pkt.SequenceId,
-						CommandName: pkt.CommandName,
+					resp := network.Response{
+						SequenceID:  req.SequenceID,
+						CommandName: req.CommandName,
 						Params:      info.getParams(),
-					}, pkt.Payload)
+						Body:        req.Body,
+						// Request:     nil,
+					}
+					decoded, err = decoder(c, &resp)
 					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 {
 					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)
 				}
-			} 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
-				f.fun(pkt.Payload, nil)
+				f.fun(req.Body, nil)
 			} 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)
 	}
 }
--- a/client/offline_file.go
+++ b/client/offline_file.go
@ -33,9 +33,9 @@ func (c *QQClient) buildOfflineFileDownloadRequestPacket(uuid []byte) (uint16, [
 	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{}
-	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)
 		return nil, errors.Wrap(err, "unmarshal cmd0x346 rsp body error")
 	}
--- a/client/online_push.go
+++ b/client/online_push.go
@ -23,15 +23,15 @@ var msg0x210Decoders = map[int64]func(*QQClient, []byte) error{
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	jr := jce.NewJceReader(data.Map["req"]["OnlinePushPack.SvcReqPushMsg"][1:])
 	uin := jr.ReadInt64(0)
 	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 {
 		k := fmt.Sprintf("%v%v%v", m.MsgSeq, m.MsgTime, m.MsgUid)
 		if _, ok := c.onlinePushCache.Get(k); ok {
--- a/client/ptt.go
+++ b/client/ptt.go
@ -337,9 +337,9 @@ func (c *QQClient) buildC2CPttStoreBDHExt(target int64, md5 []byte, size, voiceL
 }

 // PttCenterSvr.ShortVideoDownReq
-func decodePttShortVideoDownResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodePttShortVideoDownResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if rsp.PttShortVideoDownloadRsp == nil || rsp.PttShortVideoDownloadRsp.DownloadAddr == nil {
@ -349,9 +349,9 @@ func decodePttShortVideoDownResponse(_ *QQClient, _ *network.IncomingPacketInfo,
 }

 // PttCenterSvr.GroupShortVideoUpReq
-func decodeGroupShortVideoUploadResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeGroupShortVideoUploadResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if rsp.PttShortVideoUploadRsp == nil {
--- a/client/qidian.go
+++ b/client/qidian.go
@ -152,9 +152,9 @@ func (c *QQClient) bigDataRequest(subCmd uint32, req proto.Message) ([]byte, err
 	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{}
-	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")
 	}
 	if rsp.SubcmdLoginProcessCompleteRspBody == nil {
@ -168,9 +168,9 @@ func decodeLoginExtraResponse(c *QQClient, _ *network.IncomingPacketInfo, payloa
 	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{}
-	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")
 	}
 	if c.QiDian == nil {
--- a/client/recall.go
+++ b/client/recall.go
@ -92,9 +92,9 @@ func (c *QQClient) buildPrivateRecallPacket(uin, ts int64, msgSeq, random int32)
 	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{}
-	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")
 	}
 	if len(rsp.C2CWithDraw) > 0 {
--- a/client/security.go
+++ b/client/security.go
@ -48,10 +48,10 @@ func (c *QQClient) buildUrlCheckRequest(url string) (uint16, []byte) {
 	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{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, rsp); err != nil {
--- a/client/sync.go
+++ b/client/sync.go
@ -285,9 +285,9 @@ func (c *QQClient) buildPrivateMsgReadedPacket(uin, time int64) (uint16, []byte)
 }

 // StatSvc.GetDevLoginInfo
-func decodeDevListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeDevListResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	request := &jce.RequestPacket{}
-	request.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	rsp := jce.NewJceReader(data.Map["SvcRspGetDevLoginInfo"]["QQService.SvcRspGetDevLoginInfo"][1:])
@ -307,9 +307,9 @@ func decodeDevListResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload [
 }

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	reader := jce.NewJceReader(data.Map["SvcRespParam"]["RegisterProxySvcPack.SvcRespParam"][1:])
@ -352,9 +352,9 @@ func decodePushParamPacket(c *QQClient, _ *network.IncomingPacketInfo, payload [
 }

 // 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{}
-	if err := proto.Unmarshal(payload, rsp); err != nil {
+	if err := proto.Unmarshal(resp.Body, rsp); err != nil {
 		return nil, err
 	}
 	ret := &sessionSyncEvent{
@ -389,26 +389,26 @@ func decodeMsgSyncResponse(c *QQClient, info *network.IncomingPacketInfo, payloa
 	if len(rsp.C2CMsg) > 4 {
 		c2cRsp := &msg.GetMessageResponse{}
 		if proto.Unmarshal(rsp.C2CMsg[4:], c2cRsp) == nil {
-			c.c2cMessageSyncProcessor(c2cRsp, info)
+			c.c2cMessageSyncProcessor(c2cRsp, resp)
 		}
 	}
 	return ret, nil
 }

 // 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{}
-	if err := proto.Unmarshal(payload, &m); err != nil {
+	if err := proto.Unmarshal(resp.Body, &m); err != nil {
 		return nil, err
 	}
-	_ = c.sendPacket(c.buildDeleteOnlinePushPacket(c.Uin, m.GetSvrip(), m.GetPushToken(), info.SequenceId, nil))
-	c.commMsgProcessor(m.Msg, info)
+	_ = c.sendPacket(c.buildDeleteOnlinePushPacket(c.Uin, m.GetSvrip(), m.GetPushToken(), uint16(resp.SequenceID), nil))
+	c.commMsgProcessor(m.Msg, resp)
 	return nil, nil
 }

-func decodeMsgReadedResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeMsgReadedResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	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")
 	}
 	if len(rsp.GrpReadReport) > 0 {
@ -420,9 +420,9 @@ func decodeMsgReadedResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload
 var loginNotifyLock sync.Mutex

 // 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.ReadFrom(jce.NewJceReader(payload))
+	request.ReadFrom(jce.NewJceReader(resp.Body))
 	data := &jce.RequestDataVersion2{}
 	data.ReadFrom(jce.NewJceReader(request.SBuffer))
 	reader := jce.NewJceReader(data.Map["SvcReqMSFLoginNotify"]["QQService.SvcReqMSFLoginNotify"][1:])
--- a/client/system_msg.go
+++ b/client/system_msg.go
@ -190,9 +190,9 @@ func (c *QQClient) buildSystemMsgFriendActionPacket(reqID, requester int64, acce
 }

 // 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{}
-	if err := proto.Unmarshal(payload, &rsp); err != nil {
+	if err := proto.Unmarshal(resp.Body, &rsp); err != nil {
 		return nil, err
 	}
 	ret := &GroupSystemMessages{}
--- a/client/translate.go
+++ b/client/translate.go
@ -41,10 +41,10 @@ func (c *QQClient) Translate(src, dst, text string) (string, error) {
 }

 // OidbSvc.0x990
-func decodeTranslateResponse(_ *QQClient, _ *network.IncomingPacketInfo, payload []byte) (interface{}, error) {
+func decodeTranslateResponse(_ *QQClient, resp *network.Response) (interface{}, error) {
 	pkg := oidb.OIDBSSOPkg{}
 	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")
 	}
 	if err := proto.Unmarshal(pkg.Bodybuffer, &rsp); err != nil {
--- a/internal/generator/c2c_switcher/c2c_switcher.go
+++ b/internal/generator/c2c_switcher/c2c_switcher.go
@ -27,7 +27,7 @@ const (
 {{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 {
 {{range .Decoders}}	case {{.Id}}:
 		return {{.Func}}, {{.DecoderType}}
--- a/internal/packets/global.go
+++ b/internal/packets/global.go
@ -4,14 +4,6 @@ import (
 	"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 {
 	return binary.NewWriterF(func(w *binary.Writer) {
 		w.WriteByte(2)