1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstring> 17 #include <gtest/gtest.h> 18 #include <iostream> 19 #include <memory> 20 #include "log.h" 21 #include "packages_info.h" 22 #include "pkg_algorithm.h" 23 #include "pkg_gzipfile.h" 24 #include "pkg_lz4file.h" 25 #include "pkg_manager.h" 26 #include "pkg_manager_impl.h" 27 #include "pkg_test.h" 28 #include "pkg_upgradefile.h" 29 #include "pkg_utils.h" 30 #include "pkg_zipfile.h" 31 #include "securec.h" 32 33 using namespace std; 34 using namespace Hpackage; 35 using namespace Updater; 36 using namespace testing::ext; 37 38 namespace UpdaterUt { 39 constexpr uint32_t MAX_FILE_NAME = 256; 40 constexpr uint32_t CENTRAL_SIGNATURE = 0x02014b50; 41 42 class TestFile : public PkgFile { 43 public: TestFile(PkgManager::PkgManagerPtr pkgManager,PkgStreamPtr stream)44 explicit TestFile(PkgManager::PkgManagerPtr pkgManager, PkgStreamPtr stream) 45 : PkgFile(pkgManager, stream, PKG_TYPE_MAX) {} 46 ~TestFile()47 virtual ~TestFile() {} 48 AddEntry(const PkgManager::FileInfoPtr file,const PkgStreamPtr inStream)49 virtual int32_t AddEntry(const PkgManager::FileInfoPtr file, const PkgStreamPtr inStream) 50 { 51 PkgFile::GetPkgInfo(); 52 PkgFile::AddPkgEntry(inStream->GetFileName()); 53 return 0; 54 } 55 SavePackage(size_t & offset)56 virtual int32_t SavePackage(size_t &offset) 57 { 58 return 0; 59 } 60 LoadPackage(std::vector<std::string> & fileNames,VerifyFunction verify=nullptr)61 virtual int32_t LoadPackage(std::vector<std::string>& fileNames, VerifyFunction verify = nullptr) 62 { 63 return 0; 64 } 65 }; 66 67 class PkgPackageTest : public PkgTest { 68 public: PkgPackageTest()69 PkgPackageTest() {} ~PkgPackageTest()70 ~PkgPackageTest() override {} 71 TestPkgFile()72 int TestPkgFile() 73 { 74 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 75 if (pkgManager_ == nullptr) { 76 return PKG_SUCCESS; 77 } 78 PkgManager::StreamPtr stream = nullptr; 79 std::string packagePath = TEST_PATH_TO; 80 packagePath += testPackageName; 81 int ret = pkgManager_->CreatePkgStream(stream, packagePath, 0, PkgStream::PkgStreamType_Read); 82 auto file = std::make_unique<Lz4PkgFile>(pkgManager_, PkgStreamImpl::ConvertPkgStream(stream)); 83 EXPECT_NE(file, nullptr); 84 constexpr uint32_t lz4NodeId = 100; 85 auto entry = std::make_unique<Lz4FileEntry>(file.get(), lz4NodeId); 86 EXPECT_NE(entry, nullptr); 87 88 EXPECT_NE(((PkgEntryPtr)entry.get())->GetPkgFile(), nullptr); 89 FileInfo fileInfo; 90 ret = entry->Init(&fileInfo, PkgStreamImpl::ConvertPkgStream(stream)); 91 EXPECT_EQ(ret, 0); 92 return 0; 93 } 94 TestPkgFileInvalid()95 int TestPkgFileInvalid() 96 { 97 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 98 if (pkgManager_ == nullptr) { 99 return PKG_SUCCESS; 100 } 101 PkgManager::StreamPtr stream = nullptr; 102 std::string packagePath = TEST_PATH_TO; 103 packagePath += testPackageName; 104 int ret = pkgManager_->CreatePkgStream(stream, packagePath, 0, PkgStream::PkgStreamType_Read); 105 FileInfo fileInfo; 106 std::unique_ptr<TestFile> file = std::make_unique<TestFile>(pkgManager_, 107 PkgStreamImpl::ConvertPkgStream(stream)); 108 EXPECT_NE(file, nullptr); 109 ret = file->AddEntry(&fileInfo, PkgStreamImpl::ConvertPkgStream(stream)); 110 EXPECT_EQ(ret, 0); 111 size_t offset = 0; 112 ret = file->SavePackage(offset); 113 EXPECT_EQ(ret, 0); 114 return 0; 115 } 116 TestBigZipEntry()117 int TestBigZipEntry() 118 { 119 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 120 EXPECT_NE(pkgManager_, nullptr); 121 PkgManager::StreamPtr stream = nullptr; 122 std::string packagePath = TEST_PATH_TO; 123 uint32_t zipNodeId = 100; 124 packagePath += testPackageName; 125 pkgManager_->CreatePkgStream(stream, packagePath, 0, PkgStream::PkgStreamType_Read); 126 EXPECT_NE(stream, nullptr); 127 std::unique_ptr<TestFile> file = std::make_unique<TestFile>(pkgManager_, 128 PkgStreamImpl::ConvertPkgStream(stream)); 129 EXPECT_NE(file, nullptr); 130 std::unique_ptr<ZipFileEntry> entry = std::make_unique<ZipFileEntry>(file.get(), zipNodeId); 131 EXPECT_NE(entry, nullptr); 132 133 string name = "TestBigZip"; 134 uint16_t extraSize = 20; 135 size_t offsetHalfWord = 2; 136 size_t offsetWord = 4; 137 size_t offset4Words = 16; 138 size_t offset3Words = 12; 139 int32_t buffLen = MAX_FILE_NAME + sizeof(LocalFileHeader) + sizeof(DataDescriptor) + 140 sizeof(CentralDirEntry) + offsetWord + offset4Words; 141 std::vector<uint8_t> buff(buffLen); 142 CentralDirEntry* centralDir = (CentralDirEntry *)buff.data(); 143 (void)memset_s(centralDir, sizeof(CentralDirEntry), 0, sizeof(CentralDirEntry)); 144 centralDir->signature = CENTRAL_SIGNATURE; 145 centralDir->compressionMethod = PKG_COMPRESS_METHOD_ZIP; 146 centralDir->compressedSize = UINT_MAX; 147 centralDir->uncompressedSize = UINT_MAX; 148 centralDir->nameSize = name.length(); 149 centralDir->extraSize = extraSize; 150 int ret = memcpy_s(buff.data() + sizeof(CentralDirEntry), name.length(), name.c_str(), name.length()); 151 EXPECT_EQ(ret, 0); 152 WriteLE16(buff.data() + sizeof(CentralDirEntry) + name.length(), 1); 153 WriteLE16(buff.data() + sizeof(CentralDirEntry) + name.length() + offsetHalfWord, offset4Words); 154 size_t giantNumber = 100000; 155 size_t size = UINT_MAX + giantNumber; 156 WriteLE64(buff.data() + sizeof(CentralDirEntry) + name.length() + offsetWord, size); 157 WriteLE64(buff.data() + sizeof(CentralDirEntry) + name.length() + offset3Words, size); 158 size_t decodeLen = 0; 159 PkgBuffer buffer(buff); 160 entry->DecodeCentralDirEntry(nullptr, buffer, 0, decodeLen); 161 return 0; 162 } 163 WriteLE64(uint8_t * buff,size_t size) const164 void WriteLE64(uint8_t *buff, size_t size) const 165 { 166 *reinterpret_cast<size_t *>(buff) = size; 167 } 168 TestPackageInfoFail()169 int TestPackageInfoFail() 170 { 171 PkgManager::PkgManagerPtr manager = PkgManager::GetPackageInstance(); 172 PackagesInfoPtr pkginfomanager = PackagesInfo::GetPackagesInfoInstance(); 173 std::vector<std::string> target; 174 std::vector<std::string> tmp; 175 176 target = pkginfomanager->GetOTAVersion(nullptr, "", ""); 177 EXPECT_EQ(target, tmp); 178 target = pkginfomanager->GetOTAVersion(manager, "", ""); 179 EXPECT_EQ(target, tmp); 180 target = pkginfomanager->GetBoardID(nullptr, "", ""); 181 EXPECT_EQ(target, tmp); 182 target = pkginfomanager->GetBoardID(manager, "", ""); 183 EXPECT_EQ(target, tmp); 184 185 bool ret = pkginfomanager->IsAllowRollback(); 186 EXPECT_EQ(ret, false); 187 PackagesInfo::ReleasePackagesInfoInstance(pkginfomanager); 188 return 0; 189 } 190 TestUpdaterPreProcess()191 int TestUpdaterPreProcess() 192 { 193 PkgManager::PkgManagerPtr pkgManager = PkgManager::GetPackageInstance(); 194 std::string packagePath = "/data/updater/package/test_package.zip"; 195 std::vector<std::string> components; 196 int32_t ret = pkgManager->LoadPackage(packagePath, Utils::GetCertName(), components); 197 EXPECT_EQ(ret, PKG_SUCCESS); 198 199 PackagesInfoPtr pkginfomanager = PackagesInfo::GetPackagesInfoInstance(); 200 std::vector<std::string> result; 201 std::vector<std::string> targetVersions = pkginfomanager->GetOTAVersion( 202 pkgManager, "/version_list", "/data/updater/package/"); 203 EXPECT_NE(targetVersions, result); 204 205 std::vector<std::string> boardIdList = pkginfomanager->GetBoardID(pkgManager, "/board_list", ""); 206 EXPECT_NE(boardIdList, result); 207 PackagesInfo::ReleasePackagesInfoInstance(pkginfomanager); 208 return 0; 209 } 210 }; 211 212 HWTEST_F(PkgPackageTest, TestUpdaterPreProcess, TestSize.Level1) 213 { 214 PkgPackageTest test; 215 EXPECT_EQ(0, test.TestUpdaterPreProcess()); 216 } 217 218 HWTEST_F(PkgPackageTest, TestPackageInfoFail, TestSize.Level1) 219 { 220 PkgPackageTest test; 221 EXPECT_EQ(0, test.TestPackageInfoFail()); 222 } 223 224 HWTEST_F(PkgPackageTest, TestPkgFile, TestSize.Level1) 225 { 226 PkgPackageTest test; 227 EXPECT_EQ(0, test.TestPkgFile()); 228 } 229 230 HWTEST_F(PkgPackageTest, TestPkgFileInvalid, TestSize.Level1) 231 { 232 PkgPackageTest test; 233 EXPECT_EQ(0, test.TestPkgFileInvalid()); 234 } 235 236 HWTEST_F(PkgPackageTest, TestBigZip, TestSize.Level1) 237 { 238 PkgPackageTest test; 239 EXPECT_EQ(0, test.TestBigZipEntry()); 240 } 241 } 242