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

internal/oicq: reduce lambda

Browse Source
This commit is contained in:
wdvxdr 2021-12-24 14:22:10 +08:00
parent cf864799cb
commit 254eef3a5a
No known key found for this signature in database
GPG Key ID: 703F8C071DE7A1B6
4 changed files with 76 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
binary/writer.go
View File

@ -55,8 +55,8 @@ func (w *Writer) WriteHex(h string) {
w.Write(b) w.Write(b)
} }
func (w *Writer) WriteByte(b byte) error { func (w *Writer) WriteByte(b byte) {
return (*bytes.Buffer)(w).WriteByte(b) (*bytes.Buffer)(w).WriteByte(b)
} }
func (w *Writer) WriteUInt16(v uint16) { func (w *Writer) WriteUInt16(v uint16) {

2
client/global.go
View File

@ -330,7 +330,7 @@ func (c *QQClient) packOIDBPackageProto(cmd, serviceType int32, msg proto.Messag
return c.packOIDBPackage(cmd, serviceType, b) return c.packOIDBPackage(cmd, serviceType, b)
} }
func (c *QQClient) unpackOIDBPackage(buff []byte, payload proto.Message) error { func unpackOIDBPackage(buff []byte, payload proto.Message) error {
pkg := new(oidb.OIDBSSOPkg) pkg := new(oidb.OIDBSSOPkg)
if err := proto.Unmarshal(buff, pkg); err != nil { if err := proto.Unmarshal(buff, pkg); err != nil {
return errors.Wrap(err, "failed to unmarshal protobuf message") return errors.Wrap(err, "failed to unmarshal protobuf message")

18
client/guild.go
View File

@ -192,7 +192,7 @@ func (s *GuildService) GetUserProfile(tinyId uint64) (*GuildUserProfile, error)
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xfc9Rsp) body := new(channel.ChannelOidb0Xfc9Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
// todo: 解析个性档案 // todo: 解析个性档案
@ -231,7 +231,7 @@ func (s *GuildService) FetchGuildMemberListWithRole(guildId, channelId uint64, s
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xf5BRsp) body := new(channel.ChannelOidb0Xf5BRsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
var ret []*GuildMemberInfo var ret []*GuildMemberInfo
@ -286,7 +286,7 @@ func (s *GuildService) FetchGuildMemberProfileInfo(guildId, tinyId uint64) (*Gui
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xf88Rsp) body := new(channel.ChannelOidb0Xf88Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
roles, err := s.fetchMemberRoles(guildId, tinyId) roles, err := s.fetchMemberRoles(guildId, tinyId)
@ -311,7 +311,7 @@ func (s *GuildService) GetGuildRoles(guildId uint64) ([]*GuildRole, error) {
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0X1019Rsp) body := new(channel.ChannelOidb0X1019Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
roles := make([]*GuildRole, 0, len(body.GetRoles())) roles := make([]*GuildRole, 0, len(body.GetRoles()))
@ -351,7 +351,7 @@ func (s *GuildService) CreateGuildRole(guildId uint64, name string, color uint32
return 0, errors.Wrap(err, "send packet error") return 0, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0X1016Rsp) body := new(channel.ChannelOidb0X1016Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return 0, errors.Wrap(err, "decode packet error") return 0, errors.Wrap(err, "decode packet error")
} }
return body.GetRoleId(), nil return body.GetRoleId(), nil
@ -434,7 +434,7 @@ func (s *GuildService) FetchGuestGuild(guildId uint64) (*GuildMeta, error) {
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xf57Rsp) body := new(channel.ChannelOidb0Xf57Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
return &GuildMeta{ return &GuildMeta{
@ -463,7 +463,7 @@ func (s *GuildService) FetchChannelList(guildId uint64) (r []*ChannelInfo, e err
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xf5DRsp) body := new(channel.ChannelOidb0Xf5DRsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
for _, info := range body.Rsp.Channels { for _, info := range body.Rsp.Channels {
@ -479,7 +479,7 @@ func (s *GuildService) FetchChannelInfo(guildId, channelId uint64) (*ChannelInfo
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0Xf55Rsp) body := new(channel.ChannelOidb0Xf55Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
return convertChannelInfo(body.Info), nil return convertChannelInfo(body.Info), nil
@ -632,7 +632,7 @@ func (s *GuildService) fetchMemberRoles(guildId uint64, tinyId uint64) ([]*Guild
return nil, errors.Wrap(err, "send packet error") return nil, errors.Wrap(err, "send packet error")
} }
body := new(channel.ChannelOidb0X1017Rsp) body := new(channel.ChannelOidb0X1017Rsp)
if err = s.c.unpackOIDBPackage(rsp, body); err != nil { if err = unpackOIDBPackage(rsp, body); err != nil {
return nil, errors.Wrap(err, "decode packet error") return nil, errors.Wrap(err, "decode packet error")
} }
p1 := body.GetP1() p1 := body.GetP1()

134
client/internal/network/transport.go
View File

@ -20,42 +20,35 @@ type Transport struct {
} }
func (t *Transport) packBody(req *Request, w *binary.Writer) { func (t *Transport) packBody(req *Request, w *binary.Writer) {
w.WriteIntLvPacket(4, func(writer *binary.Writer) { pos := w.FillUInt32()
if req.Type == RequestTypeLogin { if req.Type == RequestTypeLogin {
writer.WriteUInt32(uint32(req.SequenceID)) w.WriteUInt32(uint32(req.SequenceID))
writer.WriteUInt32(t.Version.AppId) w.WriteUInt32(t.Version.AppId)
writer.WriteUInt32(t.Version.SubAppId) w.WriteUInt32(t.Version.SubAppId)
writer.Write([]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00}) w.Write([]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00})
tgt := t.Sig.TGT tgt := t.Sig.TGT
if len(tgt) == 0 || len(tgt) == 4 { if len(tgt) == 0 || len(tgt) == 4 {
writer.WriteUInt32(0x04) w.WriteUInt32(0x04)
} else { } else {
writer.WriteUInt32(uint32(len(tgt) + 4)) w.WriteUInt32(uint32(len(tgt) + 4))
writer.Write(tgt) w.Write(tgt)
}
} }
writer.WriteString(req.CommandName) }
writer.WriteIntLvPacket(4, func(w *binary.Writer) { w.WriteString(req.CommandName)
w.Write(t.Sig.OutPacketSessionID) w.WriteUInt32(uint32(len(t.Sig.OutPacketSessionID) + 4))
}) w.Write(t.Sig.OutPacketSessionID)
// writer.WriteUInt32(uint32(len(t.Sig.OutPacketSessionID) + 4)) if req.Type == RequestTypeLogin {
// w.Write(t.Sig.OutPacketSessionID) w.WriteString(t.Device.IMEI)
if req.Type == RequestTypeLogin { w.WriteUInt32(0x04)
writer.WriteString(t.Device.IMEI)
writer.WriteUInt32(0x04)
{
writer.WriteUInt16(uint16(len(t.Sig.Ksid)) + 2)
writer.Write(t.Sig.Ksid)
}
}
writer.WriteUInt32(0x04)
})
w.WriteIntLvPacket(4, func(w *binary.Writer) { w.WriteUInt16(uint16(len(t.Sig.Ksid)) + 2)
w.Write(req.Body) w.Write(t.Sig.Ksid)
}) }
// w.WriteUInt32(uint32(len(req.Body) + 4)) w.WriteUInt32(0x04)
// w.Write(req.Body) w.WriteUInt32At(pos, uint32(w.Len()-pos))
w.WriteUInt32(uint32(len(req.Body) + 4))
w.Write(req.Body)
} }
// PackPacket packs a packet. // PackPacket packs a packet.
@ -65,43 +58,44 @@ func (t *Transport) PackPacket(req *Request) []byte {
req.EncryptType = EncryptTypeEmptyKey req.EncryptType = EncryptTypeEmptyKey
} }
return binary.NewWriterF(func(w *binary.Writer) { w := binary.SelectWriter()
pos := w.FillUInt32() defer binary.PutWriter(w)
// vvv w.Write(head) vvv
w.WriteUInt32(uint32(req.Type)) pos := w.FillUInt32()
w.WriteByte(byte(req.EncryptType)) // vvv w.Write(head) vvv
switch req.Type { w.WriteUInt32(uint32(req.Type))
case RequestTypeLogin: w.WriteByte(byte(req.EncryptType))
switch req.EncryptType { switch req.Type {
case EncryptTypeD2Key: case RequestTypeLogin:
w.WriteUInt32(uint32(len(t.Sig.D2) + 4)) switch req.EncryptType {
w.Write(t.Sig.D2) case EncryptTypeD2Key:
default: w.WriteUInt32(uint32(len(t.Sig.D2) + 4))
w.WriteUInt32(4) w.Write(t.Sig.D2)
} default:
case RequestTypeSimple: w.WriteUInt32(4)
w.WriteUInt32(uint32(req.SequenceID))
} }
w.WriteByte(0x00) case RequestTypeSimple:
w.WriteString(strconv.FormatInt(req.Uin, 10)) w.WriteUInt32(uint32(req.SequenceID))
// ^^^ w.Write(head) ^^^ }
w.Write(binary.NewWriterF(func(w *binary.Writer) { w.WriteByte(0x00)
// encrypt body w.WriteString(strconv.FormatInt(req.Uin, 10))
switch req.EncryptType { // ^^^ w.Write(head) ^^^
case EncryptTypeD2Key:
wt, cl := binary.OpenWriterF(func(w *binary.Writer) { t.packBody(req, w) }) w2 := binary.SelectWriter()
w.EncryptAndWrite(t.Sig.D2Key, wt) t.packBody(req, w2)
cl() body := w2.Bytes()
case EncryptTypeEmptyKey: // encrypt body
wt, cl := binary.OpenWriterF(func(w *binary.Writer) { t.packBody(req, w) }) switch req.EncryptType {
w.EncryptAndWrite(emptyKey, wt) case EncryptTypeD2Key:
cl() body = binary.NewTeaCipher(t.Sig.D2Key).Encrypt(body)
default: case EncryptTypeEmptyKey:
t.packBody(req, w) body = binary.NewTeaCipher(emptyKey).Encrypt(body)
} }
})) w.Write(body)
w.WriteUInt32At(pos, uint32(w.Len())) binary.PutWriter(w2)
})
w.WriteUInt32At(pos, uint32(w.Len()))
return append([]byte(nil), w.Bytes()...)
} }
func (t *Transport) parse(head []byte) *Request { func (t *Transport) parse(head []byte) *Request {