feat & fix: add video msg pack & upload, fix some bugs in uploading c2c elements

src/core/packet/highway/session.ts

@@ -8,9 +8,10 @@ import { HttpConn0x6ff_501Response } from "@/core/packet/proto/action/action";
 import { PacketHighwayClient } from "@/core/packet/highway/client";
 import { NTV2RichMediaResp } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaResp";
 import { OidbSvcTrpcTcpBaseRsp } from "@/core/packet/proto/oidb/OidbBase";
-import { PacketMsgPicElement } from "@/core/packet/msg/element";
+import { PacketMsgPicElement, PacketMsgVideoElement } from "@/core/packet/msg/element";
 import { NTV2RichMediaHighwayExt } from "@/core/packet/proto/highway/highway";
 import { int32ip2str, oidbIpv4s2HighwayIpv4s } from "@/core/packet/highway/utils";
+import { calculateSha1StreamBytes } from "@/core/packet/utils/crypto/hash";
 
 export const BlockSize = 1024 * 1024;
 
@@ -94,6 +95,17 @@ export class PacketHighwaySession {
         }
     }
 
+    async uploadVideo(peer: Peer, video: PacketMsgVideoElement): Promise<void> {
+        await this.checkAvailable();
+        if (peer.chatType === ChatType.KCHATTYPEGROUP) {
+            await this.uploadGroupVideoReq(Number(peer.peerUid), video);
+        } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
+            await this.uploadC2CVideoReq(peer.peerUid, video);
+        } else {
+            throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+        }
+    }
+
     private async uploadGroupImageReq(groupUin: number, img: PacketMsgPicElement): Promise<void> {
         const preReq = await this.packer.packUploadGroupImgReq(groupUin, img);
         const preRespRaw = await this.packetClient.sendPacket('OidbSvcTrpcTcp.0x11c4_100', preReq, true);
@@ -103,7 +115,7 @@ export class PacketHighwaySession {
         const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
         const ukey = preRespData.upload.uKey;
         if (ukey && ukey != "") {
-            this.logger.logDebug(`[Highway] get upload ukey: ${ukey}, need upload!`);
+            this.logger.logDebug(`[Highway] uploadGroupImageReq get upload ukey: ${ukey}, need upload!`);
             const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
             const sha1 = Buffer.from(index.info.fileSha1, 'hex');
             const md5 = Buffer.from(index.info.fileHash, 'hex');
@@ -121,13 +133,13 @@ export class PacketHighwaySession {
             });
             await this.packetHighwayClient.upload(
                 1004,
-                fs.createReadStream(img.path, { highWaterMark: BlockSize }),
+                fs.createReadStream(img.path, {highWaterMark: BlockSize}),
                 img.size,
                 md5,
                 extend
             );
         } else {
-            this.logger.logDebug(`[Highway] get upload invalid ukey ${ukey}, don't need upload!`);
+            this.logger.logDebug(`[Highway] uploadGroupImageReq get upload invalid ukey ${ukey}, don't need upload!`);
         }
         img.msgInfo = preRespData.upload.msgInfo;
         // img.groupPicExt = new NapProtoMsg(CustomFace).decode(preRespData.tcpUpload.compatQMsg)
@@ -142,7 +154,7 @@ export class PacketHighwaySession {
         const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
         const ukey = preRespData.upload.uKey;
         if (ukey && ukey != "") {
-            this.logger.logDebug(`[Highway] get upload ukey: ${ukey}, need upload!`);
+            this.logger.logDebug(`[Highway] uploadC2CImageReq get upload ukey: ${ukey}, need upload!`);
             const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
             const sha1 = Buffer.from(index.info.fileSha1, 'hex');
             const md5 = Buffer.from(index.info.fileHash, 'hex');
@@ -160,12 +172,145 @@ export class PacketHighwaySession {
             });
             await this.packetHighwayClient.upload(
                 1003,
-                fs.createReadStream(img.path, { highWaterMark: BlockSize }),
+                fs.createReadStream(img.path, {highWaterMark: BlockSize}),
                 img.size,
                 md5,
                 extend
             );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CImageReq get upload invalid ukey ${ukey}, don't need upload!`);
         }
         img.msgInfo = preRespData.upload.msgInfo;
     }
+
+    private async uploadGroupVideoReq(groupUin: number, video: PacketMsgVideoElement): Promise<void> {
+        const preReq = await this.packer.packUploadGroupVideoReq(groupUin, video);
+        const preRespRaw = await this.packetClient.sendPacket('OidbSvcTrpcTcp.0x11ea_100', preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload video ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: await calculateSha1StreamBytes(video.filePath!)
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1005,
+                fs.createReadStream(video.filePath!, {highWaterMark: BlockSize}),
+                +video.fileSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        const subFile = preRespData.upload.subFileInfos[0];
+        if (subFile.uKey && subFile.uKey != "") {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload video thumb ukey: ${subFile.uKey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[1].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: subFile.uKey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(subFile.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            });
+            await this.packetHighwayClient.upload(
+                1006,
+                fs.createReadStream(video.thumbPath!, {highWaterMark: BlockSize}),
+                +video.thumbSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload invalid thumb ukey ${subFile.uKey}, don't need upload!`);
+        }
+        video.msgInfo = preRespData.upload.msgInfo;
+    }
+
+    private async uploadC2CVideoReq(peerUid: string, video: PacketMsgVideoElement): Promise<void> {
+        const preReq = await this.packer.packUploadC2CVideoReq(peerUid, video);
+        const preRespRaw = await this.packetClient.sendPacket('OidbSvcTrpcTcp.0x11e9_100', preReq, true);
+        console.log(preRespRaw);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload video ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: await calculateSha1StreamBytes(video.filePath!)
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1001,
+                fs.createReadStream(video.filePath!, {highWaterMark: BlockSize}),
+                +video.fileSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        const subFile = preRespData.upload.subFileInfos[0];
+        if (subFile.uKey && subFile.uKey != "") {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload video thumb ukey: ${subFile.uKey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[1].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: subFile.uKey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(subFile.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            });
+            await this.packetHighwayClient.upload(
+                1002,
+                fs.createReadStream(video.thumbPath!, {highWaterMark: BlockSize}),
+                +video.thumbSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload invalid thumb ukey ${subFile.uKey}, don't need upload!`);
+        }
+        video.msgInfo = preRespData.upload.msgInfo;
+    }
 }