From ed8c4cd9c401a69e0db361b98badfdd88a0c818f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E6=99=9F=E9=92=B0?= Date: Tue, 4 Mar 2025 10:34:25 +0800 Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81x=E8=A7=A3=E5=8E=8B=E5=92=8C?= =?UTF-8?q?=E5=8F=8C=E5=88=B0=E5=8D=95=E6=8C=89=E7=85=A7rp=E8=A7=A3?= =?UTF-8?q?=E5=8E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张晟钰 --- .../native/backup_ext/include/ext_extension.h | 5 +- .../native/backup_ext/include/tar_file.h | 2 + .../native/backup_ext/include/untar_file.h | 19 ++ .../native/backup_ext/src/ext_extension.cpp | 31 ++- .../backup_ext/src/sub_ext_extension.cpp | 30 +++ .../native/backup_ext/src/untar_file.cpp | 235 +++++++++++++++--- .../backup_ext/ext_extension_test.cpp | 23 -- .../backup_ext/untar_file_sup_test.cpp | 77 +++++- 8 files changed, 347 insertions(+), 75 deletions(-) diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h index db933dad2..8caec03df 100644 --- a/frameworks/native/backup_ext/include/ext_extension.h +++ b/frameworks/native/backup_ext/include/ext_extension.h @@ -336,7 +336,10 @@ private: void ClearNoPermissionFiles(TarMap &pkgInfo, vector &noPermissionFiles); std::function ReportOnProcessResultCallback(wptr obj, BackupRestoreScenario scenario); - + bool IfCloudSpecialRestore(std::string tarName); + ErrCode CloudSpecialRestore(std::string tarName, std::string untarPath, off_t tarFileSize); + void GetTarIncludes(const string &tarName, unordered_map &infos); + void DeleteIndexAndRpFile(); private: std::shared_mutex lock_; std::shared_ptr extension_; diff --git a/frameworks/native/backup_ext/include/tar_file.h b/frameworks/native/backup_ext/include/tar_file.h index a728e4d4a..680401b99 100644 --- a/frameworks/native/backup_ext/include/tar_file.h +++ b/frameworks/native/backup_ext/include/tar_file.h @@ -56,6 +56,8 @@ const char AREGTYPE = '\0'; // regular file const char SYMTYPE = '2'; // reserved const char DIRTYPE = '5'; // directory const char GNUTYPE_LONGNAME = 'L'; +const char EXTENSION_HEADER = 'x'; +const uint32_t OTHER_HEADER = 78; const int ERR_NO_PERMISSION = 13; } // namespace diff --git a/frameworks/native/backup_ext/include/untar_file.h b/frameworks/native/backup_ext/include/untar_file.h index e08be8853..bf8861282 100644 --- a/frameworks/native/backup_ext/include/untar_file.h +++ b/frameworks/native/backup_ext/include/untar_file.h @@ -191,6 +191,25 @@ private: bool DealFileTag(ErrFileInfo &errFileInfo, FileStatInfo &info, bool &isFilter, const std::string &tmpFullPath); + std::tuple ParsePaxBlock(); + + void CheckLongName(std::string longName, FileStatInfo &info); + + std::tuple GetLongName(uint32_t recLen, uint32_t allLen); + + std::tuple MatchIncrementalScenario(bool isFilter, ErrFileInfo &errFileInfo, + std::string tmpFullPath, char typeFlag, FileStatInfo &info); + + void MatchAregType(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter); + + void MatchDirType(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter); + + void MatchGnuTypeLongName(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter); + + void MatchExtHeader(bool &isRightRes, FileStatInfo &info, bool &isFilter); + + void MatchDefault(bool &isRightRes, FileStatInfo &info); + private: std::string rootPath_ {}; diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp index 1119285af..b83bec5aa 100644 --- a/frameworks/native/backup_ext/src/ext_extension.cpp +++ b/frameworks/native/backup_ext/src/ext_extension.cpp @@ -313,7 +313,7 @@ static tuple GetIncreFileHandleForSpecialVersion(co "GetIncreFileHandleForSpecialVersion", "CommonFile", GetAnonyPath(path)}; HiAudit::GetInstance(false).Write(auditLog); } - string reportName = path + BConstants::BLANK_REPORT_NAME; + string reportName = GetReportFileName(fileName); UniqueFd reportFd(open(reportName.data(), O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)); if (reportFd < 0) { HILOGE("Failed to open report file = %{private}s, err = %{public}d", reportName.c_str(), errno); @@ -904,7 +904,7 @@ int BackupExtExtension::DoRestore(const string &fileName, const off_t fileSize) return ERR_OK; } -static void GetTarIncludes(const string &tarName, unordered_map &infos) +void BackupExtExtension::GetTarIncludes(const string &tarName, unordered_map &infos) { // 获取简报文件内容 string reportName = GetReportFileName(tarName); @@ -1089,6 +1089,11 @@ void BackupExtExtension::RestoreBigFilesForSpecialCloneCloud(const ExtManageInfo errFileInfos_[fileName].emplace_back(errno); HILOGE("Failed to change the file time. %{public}s , %{public}d", GetAnonyPath(fileName).c_str(), errno); } + // 删除大文件的rp文件 + string reportPath = GetReportFileName(fileName); + if (!RemoveFile(reportPath)) { + HILOGE("Failed to delete backup report %{public}s, err = %{public}d", GetAnonyPath(reportPath).c_str(), errno); + } } ErrCode BackupExtExtension::RestoreTarForSpecialCloneCloud(const ExtManageInfo &item) @@ -1117,6 +1122,10 @@ ErrCode BackupExtExtension::RestoreTarForSpecialCloneCloud(const ExtManageInfo & HILOGE("Check spec tarfile path : %{public}s err, path is forbidden", GetAnonyPath(untarPath).c_str()); return ERR_INVALID_VALUE; } + if (IfCloudSpecialRestore(tarName)) { + auto ret = CloudSpecialRestore(tarName, untarPath, item.sta.st_size); + return ret; + } auto [err, fileInfos, errInfos] = UntarFile::GetInstance().UnPacket(tarName, untarPath); if (isDebug_) { endFileInfos_.merge(fileInfos); @@ -1126,9 +1135,7 @@ ErrCode BackupExtExtension::RestoreTarForSpecialCloneCloud(const ExtManageInfo & HILOGE("File soft links are forbidden"); return BError(BError::Codes::EXT_FORBID_BACKUP_RESTORE).GetCode(); } - if (!RemoveFile(tarName)) { - HILOGE("Failed to delete the backup tar %{public}s", tarName.c_str()); - } + DeleteBackupIncrementalTars(tarName); if (err != ERR_OK) { HILOGE("Failed to untar file = %{public}s, err = %{public}d", tarName.c_str(), err); return err; @@ -1175,9 +1182,7 @@ ErrCode BackupExtExtension::RestoreFilesForSpecialCloneCloud() } } } - if (!RemoveFile(INDEX_FILE_RESTORE)) { - HILOGE("Failed to delete the backup index %{public}s", INDEX_FILE_RESTORE.c_str()); - } + DeleteIndexAndRpFile(); auto endTime = std::chrono::system_clock::now(); radarRestoreInfo_.totalFileSpendTime = std::chrono::duration_cast(endTime - startTime).count(); @@ -1186,6 +1191,16 @@ ErrCode BackupExtExtension::RestoreFilesForSpecialCloneCloud() return ERR_OK; } +void BackupExtExtension::DeleteIndexAndRpFile() +{ + if (!RemoveFile(INDEX_FILE_RESTORE)) { + HILOGE("Failed to delete the backup index %{public}s", INDEX_FILE_RESTORE.c_str()); + } + string reportManagePath = GetReportFileName(INDEX_FILE_RESTORE); // GetIncrementalFileHandle创建的空fd + if (!RemoveFile(reportManagePath)) { + HILOGE("Failed to delete the backup report index %{public}s", reportManagePath.c_str()); + } +} static bool RestoreBigFilePrecheck(string &fileName, const string &path, const string &hashName, const string &filePath) { if (filePath.empty()) { diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp index 24e2a9c11..08c511353 100644 --- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp +++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp @@ -1357,4 +1357,34 @@ void BackupExtExtension::CompareFiles(vector &allFiles, } } } + +bool BackupExtExtension::IfCloudSpecialRestore(string tarName) +{ + unordered_map result; + GetTarIncludes(tarName, result); + if (result.empty()) { + HILOGI("is not CloudSpecialRestore"); + return false; + } + HILOGI("is CloudSpecialRestore"); + return true; +} + +ErrCode BackupExtExtension::CloudSpecialRestore(string tarName, string untarPath, off_t tarFileSize) +{ + unordered_map result; + GetTarIncludes(tarName, result); + if (isDebug_) { + FillEndFileInfos(untarPath, result); + } + auto unPacketRes = UntarFile::GetInstance().IncrementalUnPacket(tarName, untarPath, result); + ErrCode err = ERR_OK; + err = std::get(unPacketRes); + if (int tmpErr = DealIncreUnPacketResult(tarFileSize, tarName, unPacketRes); tmpErr != ERR_OK) { + return BError(BError::Codes::EXT_FORBID_BACKUP_RESTORE).GetCode(); + } + HILOGI("Application recovered successfully, package path is %{public}s", tarName.c_str()); + DeleteBackupIncrementalTars(tarName); + return err; +} } // namespace OHOS::FileManagement::Backup diff --git a/frameworks/native/backup_ext/src/untar_file.cpp b/frameworks/native/backup_ext/src/untar_file.cpp index 76181b091..e26217589 100644 --- a/frameworks/native/backup_ext/src/untar_file.cpp +++ b/frameworks/native/backup_ext/src/untar_file.cpp @@ -327,51 +327,90 @@ std::tuple UntarFile::ParseIncrementalTarFile(con return {ret, fileInfos, errFileInfo}; } +void UntarFile::MatchAregType(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter) +{ + info.fullPath = GenRealPath(rootPath_, info.fullPath); + if (BDir::CheckFilePathInvalid(info.fullPath)) { + HILOGE("Check file path : %{public}s err, path is forbidden", GetAnonyPath(info.fullPath).c_str()); + isRightRes = false; + return; + } + errFileInfo = ParseRegularFile(info); + isFilter = false; +} + +void UntarFile::MatchDirType(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter) +{ + info.fullPath = GenRealPath(rootPath_, info.fullPath); + if (BDir::CheckFilePathInvalid(info.fullPath)) { + HILOGE("Check file path : %{public}s err, path is forbidden", GetAnonyPath(info.fullPath).c_str()); + isRightRes = false; + return; + } + errFileInfo = CreateDir(info.fullPath, info.mode); + isFilter = false; +} + +void UntarFile::MatchGnuTypeLongName(bool &isRightRes, FileStatInfo &info, ErrFileInfo &errFileInfo, bool &isFilter) +{ + auto result = ReadLongName(info); + if (BDir::CheckFilePathInvalid(info.fullPath) || BDir::CheckFilePathInvalid(info.longName)) { + HILOGE("Check file path : %{public}s or long name : %{public}s err, path is forbidden", + GetAnonyPath(info.fullPath).c_str(), GetAnonyPath(info.longName).c_str()); + isRightRes = false; + return; + } + errFileInfo = std::get(result); + isFilter = true; + isRightRes = (std::get(result) == ERR_OK) ? true : false; +} + +void UntarFile::MatchExtHeader(bool &isRightRes, FileStatInfo &info, bool &isFilter) +{ + auto [err, LongName] = ParsePaxBlock(); + if (err != ERR_OK) { + isRightRes = false; + return; + } + CheckLongName(LongName, info); + isFilter = true; +} + +void UntarFile::MatchDefault(bool &isRightRes, FileStatInfo &info) +{ + if (fseeko(tarFilePtr_, tarFileBlockCnt_ * BLOCK_SIZE, SEEK_CUR) != 0) { + HILOGE("Failed to fseeko of %{private}s, err = %{public}d", info.fullPath.c_str(), errno); + isRightRes = false; + } +} + tuple UntarFile::ParseFileByTypeFlag(char typeFlag, FileStatInfo &info) { HILOGD("untar file: %{public}s, rootPath: %{public}s", GetAnonyPath(info.fullPath).c_str(), rootPath_.c_str()); bool isFilter = true; ErrFileInfo errFileInfo; + bool isRightRes = true; switch (typeFlag) { case REGTYPE: case AREGTYPE: - info.fullPath = GenRealPath(rootPath_, info.fullPath); - if (BDir::CheckFilePathInvalid(info.fullPath)) { - HILOGE("Check file path : %{public}s err, path is forbidden", GetAnonyPath(info.fullPath).c_str()); - return {DEFAULT_ERR, true, {{info.fullPath, {DEFAULT_ERR}}}}; - } - errFileInfo = ParseRegularFile(info); - isFilter = false; + MatchAregType(isRightRes, info, errFileInfo, isFilter); break; case SYMTYPE: break; case DIRTYPE: - info.fullPath = GenRealPath(rootPath_, info.fullPath); - if (BDir::CheckFilePathInvalid(info.fullPath)) { - HILOGE("Check file path : %{public}s err, path is forbidden", GetAnonyPath(info.fullPath).c_str()); - return {DEFAULT_ERR, true, {{info.fullPath, {DEFAULT_ERR}}}}; - } - errFileInfo = CreateDir(info.fullPath, info.mode); - isFilter = false; + MatchDirType(isRightRes, info, errFileInfo, isFilter); break; - case GNUTYPE_LONGNAME: { - auto result = ReadLongName(info); - if (BDir::CheckFilePathInvalid(info.fullPath) || BDir::CheckFilePathInvalid(info.longName)) { - HILOGE("Check file path : %{public}s or long name : %{public}s err, path is forbidden", - GetAnonyPath(info.fullPath).c_str(), GetAnonyPath(info.longName).c_str()); - return {DEFAULT_ERR, true, {{info.fullPath, {DEFAULT_ERR}}}}; - } - errFileInfo = std::get(result); - return {std::get(result), isFilter, errFileInfo}; + case GNUTYPE_LONGNAME: + MatchGnuTypeLongName(isRightRes, info, errFileInfo, isFilter); break; - } - default: { - if (fseeko(tarFilePtr_, tarFileBlockCnt_ * BLOCK_SIZE, SEEK_CUR) != 0) { - HILOGE("Failed to fseeko of %{private}s, err = %{public}d", info.fullPath.c_str(), errno); - return {-1, true, errFileInfo}; - } + case EXTENSION_HEADER: + MatchExtHeader(isRightRes, info, isFilter); break; - } + default: + MatchDefault(isRightRes, info); + } + if (!isRightRes) { + return {DEFAULT_ERR, true, {{info.fullPath, {DEFAULT_ERR}}}}; } return {0, isFilter, errFileInfo}; } @@ -399,14 +438,9 @@ bool UntarFile::DealFileTag(ErrFileInfo &errFileInfo, return true; } - -std::tuple UntarFile::ParseIncrementalFileByTypeFlag(char typeFlag, FileStatInfo &info) +std::tuple UntarFile::MatchIncrementalScenario(bool isFilter, ErrFileInfo &errFileInfo, + string tmpFullPath, char typeFlag, FileStatInfo &info) { - HILOGD("untar file: %{public}s, rootPath: %{public}s", GetAnonyPath(info.fullPath).c_str(), rootPath_.c_str()); - string tmpFullPath = info.fullPath; - bool isFilter = true; - ErrFileInfo errFileInfo; - RTrimNull(tmpFullPath); switch (typeFlag) { case REGTYPE: case AREGTYPE: { @@ -435,6 +469,15 @@ std::tuple UntarFile::ParseIncrementalFileByTypeFlag(cha return {std::get(result), isFilter, std::get(result)}; break; } + case EXTENSION_HEADER: { // pax x header + auto [err, LongName] = ParsePaxBlock(); + if (err == ERR_OK) { + CheckLongName(LongName, info); + return {err, true, errFileInfo}; + } + return {err, isFilter, {{info.fullPath, {DEFAULT_ERR}}}}; + break; + } default: { if (fseeko(tarFilePtr_, tarFileBlockCnt_ * BLOCK_SIZE, SEEK_CUR) != 0) { HILOGE("Failed to fseeko of %{private}s, err = %{public}d", info.fullPath.c_str(), errno); @@ -443,10 +486,19 @@ std::tuple UntarFile::ParseIncrementalFileByTypeFlag(cha break; } } - return {0, isFilter, errFileInfo}; } +std::tuple UntarFile::ParseIncrementalFileByTypeFlag(char typeFlag, FileStatInfo &info) +{ + HILOGD("untar file: %{public}s, rootPath: %{public}s", GetAnonyPath(info.fullPath).c_str(), rootPath_.c_str()); + string tmpFullPath = info.fullPath; + bool isFilter = true; + ErrFileInfo errFileInfo; + RTrimNull(tmpFullPath); + return MatchIncrementalScenario(isFilter, errFileInfo, tmpFullPath, typeFlag, info); +} + ErrFileInfo UntarFile::ParseRegularFile(FileStatInfo &info) { ErrFileInfo errFileInfo; @@ -578,7 +630,7 @@ FILE *UntarFile::CreateFile(string &filePath) } uint32_t len = filePath.length(); - HILOGW("Failed to open file %{public}d, %{public}s, err = %{public}d, Will create dir", len, + HILOGW("Failed to open file %{public}d, %{public}s, err = %{public}d, Will create", len, GetAnonyPath(filePath).c_str(), errno); size_t pos = filePath.rfind('/'); if (pos == string::npos) { @@ -600,4 +652,109 @@ FILE *UntarFile::CreateFile(string &filePath) return f; } +std::tuple UntarFile::ParsePaxBlock() +{ + int err = DEFAULT_ERR; + char block[BLOCK_SIZE] = {0}; + auto readCnt = fread(block, 1, BLOCK_SIZE, tarFilePtr_); + if (readCnt < BLOCK_SIZE) { + HILOGE("Parsing tar file completed, read data count is less then block size."); + return {err, ""}; + } + string content(block, BLOCK_SIZE); + string longName = ""; + size_t pos = 0; + uint32_t recLen = 0; + uint32_t allLen = 0; + bool isLongName = false; + while (pos < BLOCK_SIZE) { + size_t lenEnd = content.find(' ', pos); + if (lenEnd == string::npos) { + err = ERR_OK; + break; + } + string pathLen = content.substr(pos, lenEnd - pos); + recLen = std::atoi(pathLen.c_str()); + allLen = recLen + OTHER_HEADER; + if (allLen > BLOCK_SIZE) { + isLongName = true; + break; + } + string kvPair = content.substr(lenEnd + 1, recLen - (lenEnd - pos + 1)); + size_t eqPos = kvPair.find('='); + if (eqPos == string::npos) { + break; + } + string key = kvPair.substr(0, eqPos); + string value = kvPair.substr(eqPos + 1); + if (key == "path") { + longName = value; + err = ERR_OK; + } + pos += recLen; + } + if (isLongName) { + HILOGI("is long name"); + return GetLongName(recLen, allLen); + } + return {err, longName}; +} + +void UntarFile::CheckLongName(std::string longName, FileStatInfo &info) +{ + if (!longName.empty() && longName.back() == '\n') { + longName.pop_back(); + info.longName = longName; + } +} + +std::tuple UntarFile::GetLongName(uint32_t recLen, uint32_t allLen) +{ + int err = DEFAULT_ERR; + off_t curPos = ftello(tarFilePtr_); + if (fseeko(tarFilePtr_, curPos - BLOCK_SIZE, SEEK_SET) != 0) { + HILOGE("fseeko failed"); + return {err, ""}; + } + double result = static_cast(allLen) / BLOCK_SIZE; + auto ret = static_cast(std::ceil(result)); + auto curSize = ret * BLOCK_SIZE; + char *block = new char[curSize]; + if (memset_s(block, curSize, 0, curSize) != EOK) { + delete[] block; + return {err, ""}; + } + auto readCnt = fread(block, 1, curSize, tarFilePtr_); + if (readCnt < curSize) { + HILOGE("Parsing tar file completed, read data count is less then block size."); + delete[] block; + return {err, ""}; + } + string content(block, curSize); + string longName = ""; + size_t pos = 0; + while (pos < curSize) { + size_t lenEnd = content.find(' ', pos); + if (lenEnd == string::npos) { + err = ERR_OK; + break; + } + string pathLen = content.substr(pos, lenEnd - pos); + int recLen = std::atoi(pathLen.c_str()); + string KvPair = content.substr(lenEnd + 1, recLen - (lenEnd - pos + 1)); + size_t eqPos = KvPair.find('='); + if (eqPos == string::npos) { + break; + } + string key = KvPair.substr(0, eqPos); + string value = KvPair.substr(eqPos + 1); + if (key == "path") { + longName = value; + err = ERR_OK; + } + pos += recLen; + } + delete[] block; + return {err, longName}; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_ext/ext_extension_test.cpp b/tests/unittests/backup_ext/ext_extension_test.cpp index f4d66f998..204661ec8 100644 --- a/tests/unittests/backup_ext/ext_extension_test.cpp +++ b/tests/unittests/backup_ext/ext_extension_test.cpp @@ -222,29 +222,6 @@ HWTEST_F(ExtExtensionTest, Ext_Extension_Test_0302, testing::ext::TestSize.Level GTEST_LOG_(INFO) << "ExtExtensionTest-end Ext_Extension_Test_0302"; } -/** - * @tc.number: SUB_Ext_Extension_0400 - * @tc.name: Ext_Extension_Test_0400 - * @tc.desc: 测试打开失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9P3Y3 - */ -HWTEST_F(ExtExtensionTest, Ext_Extension_Test_0400, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionTest-begin Ext_Extension_Test_0400"; - try { - string tarName = " "; - unordered_map infos; - GetTarIncludes(tarName, infos); - EXPECT_EQ(infos.size(), 0); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionTest-an exception occurred by construction."; - } - GTEST_LOG_(INFO) << "ExtExtensionTest-end Ext_Extension_Test_0400"; -} /** * @tc.number: SUB_Ext_Extension_0500 diff --git a/tests/unittests/backup_ext/untar_file_sup_test.cpp b/tests/unittests/backup_ext/untar_file_sup_test.cpp index ba695a52c..942314413 100644 --- a/tests/unittests/backup_ext/untar_file_sup_test.cpp +++ b/tests/unittests/backup_ext/untar_file_sup_test.cpp @@ -884,7 +884,7 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0100, testing::ext::TestS string sum = "01647"; TarHeader header; - header.typeFlag = 'x'; + header.typeFlag = 'y'; memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length()); memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length()); EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM)); @@ -894,7 +894,7 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0100, testing::ext::TestS return BLOCK_SIZE; }))).WillOnce(Return(0)); tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath); - EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_EQ(ret, 0); EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0)); @@ -911,6 +911,40 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0100, testing::ext::TestS GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseTarFile_0100"; } +/** + * @tc.number: SUB_Untar_File_ParseTarFile_0200 + * @tc.name: SUB_Untar_File_ParseTarFile_0200 + * @tc.desc: 测试 ParseTarFile 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseTarFile_0200"; + try { + string rootPath; + string sum = "01647"; + TarHeader header; + header.typeFlag = 'x'; + memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length()); + memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length()); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) { + memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header)); + return BLOCK_SIZE; + }))).WillOnce(Return(0)).WillOnce(Return(0)); + auto [ret, info, err] = UntarFile::GetInstance().ParseTarFile(rootPath); + EXPECT_EQ(ret, DEFAULT_ERR); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseTarFile."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseTarFile_0200"; +} + /** * @tc.number: SUB_Untar_File_ParseIncrementalTarFile_0100 * @tc.name: SUB_Untar_File_ParseIncrementalTarFile_0100 @@ -945,7 +979,7 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0100, testing: string sum = "01647"; TarHeader header; - header.typeFlag = 'x'; + header.typeFlag = 'y'; memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length()); memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length()); EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM)); @@ -955,7 +989,7 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0100, testing: return BLOCK_SIZE; }))).WillOnce(Return(0)); tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath); - EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_EQ(ret, 0); EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0)); @@ -972,6 +1006,41 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0100, testing: GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseIncrementalTarFile_0100"; } +/** + * @tc.number: SUB_Untar_File_ParseIncrementalTarFile_0200 + * @tc.name: SUB_Untar_File_ParseIncrementalTarFile_0200 + * @tc.desc: 测试 ParseIncrementalTarFile 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseIncrementalTarFile_0200"; + try { + string rootPath; + string sum = "01647"; + TarHeader header; + header.typeFlag = 'x'; + memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length()); + memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length()); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) { + memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header)); + return BLOCK_SIZE; + }))).WillOnce(Return(0)).WillOnce(Return(0)); + auto [ret, info, err] = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath); + EXPECT_EQ(ret, DEFAULT_ERR); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalTarFile."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseIncrementalTarFile_0200"; +} + /** * @tc.number: SUB_Untar_File_HandleTarBuffer_0100 * @tc.name: SUB_Untar_File_HandleTarBuffer_0100 -- Gitee