diff --git a/bundle.json b/bundle.json index 0e8e8ca989fd994af7e18ff335df491217dfa6c5..30a6ef4f78ccc93a949d7a03f4049cbcd3ca5b13 100644 --- a/bundle.json +++ b/bundle.json @@ -31,7 +31,8 @@ "eventhandler", "common_event_service", "ability_base", - "sqlite" + "sqlite", + "relational_store" ], "third_party": [] }, diff --git a/services/sandbox_manager/BUILD.gn b/services/sandbox_manager/BUILD.gn index 5cbe5f13f2ebf51d9ff9d57fae4fb4dceb39e4d4..ce439b53917b352e1234d2c9884663c5eb7e9499 100644 --- a/services/sandbox_manager/BUILD.gn +++ b/services/sandbox_manager/BUILD.gn @@ -49,7 +49,9 @@ if (is_standard_system) { sources = [ "main/cpp/src/database/policy_field_const.cpp", - "main/cpp/src/database/sandbox_manager_db.cpp", + "main/cpp/src/database/sandbox_manager_rdb.cpp", + "main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp", + "main/cpp/src/database/sandbox_manager_rdb_utils.cpp", "main/cpp/src/mac/mac_adapter.cpp", "main/cpp/src/sensitive/sandbox_manager_event_subscriber.cpp", "main/cpp/src/service/policy_info_manager.cpp", @@ -76,6 +78,7 @@ if (is_standard_system) { "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "relational_store:native_rdb", "safwk:system_ability_fwk", "samgr:samgr_proxy", "sqlite:sqlite", diff --git a/services/sandbox_manager/main/cpp/include/database/sandbox_manager_db.h b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb.h similarity index 52% rename from services/sandbox_manager/main/cpp/include/database/sandbox_manager_db.h rename to services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb.h index fbf434e799bd312eb064808a537426d7b3f60984..969074f1bffd75e82e13e40e9d0a7bde21378f8b 100644 --- a/services/sandbox_manager/main/cpp/include/database/sandbox_manager_db.h +++ b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef SANDBOX_MANAGER_DB_H -#define SANDBOX_MANAGER_DB_H +#ifndef SANDBOX_MANAGER_RDB_H +#define SANDBOX_MANAGER_RDB_H #include #include @@ -25,27 +25,20 @@ #include "policy_field_const.h" #include "rwlock.h" #include "sqlite_helper.h" +#include "sandbox_manager_rdb_utils.h" namespace OHOS { namespace AccessControl { namespace SandboxManager { -class SandboxManagerDb : public SqliteHelper { +class SandboxManagerRdb { public: enum ExecuteResult { FAILURE = -1, SUCCESS }; static const std::string IGNORE; static const std::string REPLACE; - struct SqliteTable { - public: - std::string tableName_; - std::vector tableColumnNames_; - }; - enum DataType { - SANDBOX_MANAGER_PERSISTED_POLICY, - }; - static SandboxManagerDb &GetInstance(); + static SandboxManagerRdb &GetInstance(); - ~SandboxManagerDb() override; + virtual ~SandboxManagerRdb() = default; int32_t Add(const DataType type, const std::vector &values, const std::string &duplicateMode = IGNORE); @@ -58,34 +51,17 @@ public: int32_t Find(const DataType type, const GenericValues &conditions, const GenericValues &symbols, std::vector &results); - int32_t RefreshAll(const DataType type, const std::vector &values); - - void OnCreate() override; - void OnUpdate() override; - private: - int32_t CreatePersistedPolicyTable() const; - - std::string CreateInsertPrepareSqlCmd(const DataType type, const std::string &duplicateMode) const; - std::string CreateDeletePrepareSqlCmd( - const DataType type, const std::vector &columnNames = std::vector()) const; - std::string CreateUpdatePrepareSqlCmd(const DataType type, const std::vector &modifyColumns, - const std::vector &conditionColumns) const; - std::string CreateSelectPrepareSqlCmd(const DataType type, const std::vector &searchColumns, - const GenericValues &conditions) const; + SandboxManagerRdb(); + inline static int32_t GetConflictResolution(const std::string &duplicateMode, + NativeRdb::ConflictResolution &solution); + DISALLOW_COPY_AND_MOVE(SandboxManagerRdb); - SandboxManagerDb(); - DISALLOW_COPY_AND_MOVE(SandboxManagerDb); - - std::map dataTypeToSqlTable_; OHOS::Utils::RWLock rwLock_; - inline static const std::string PERSISTED_POLICY_TABLE = "persisted_policy_table"; - - inline static const std::string DATABASE_NAME = "sandbox_manager.db"; - inline static const std::string DATABASE_PATH = "/data/service/el1/public/sandbox_manager/"; + std::shared_ptr db_ = nullptr; static const int DATABASE_VERSION = 1; }; } // namespace SandboxManager } // namespace AccessControl } // namespace OHOS -#endif // SANDBOX_MANAGER_DB_H \ No newline at end of file +#endif // SANDBOX_MANAGER_RDB_H \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_open_callback.h b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_open_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..fc644c953c9ff59587f27d1fe62393e3e1e98d98 --- /dev/null +++ b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_open_callback.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SANDBOX_MANAGER_RDB_OPEN_CALLBACK_H +#define SANDBOX_MANAGER_RDB_OPEN_CALLBACK_H + +#include "rdb_open_callback.h" +#include "rdb_store.h" +#include "generic_values.h" +#include "sandbox_manager_rdb_utils.h" +#include "rwlock.h" + +namespace OHOS { +namespace AccessControl { +namespace SandboxManager { + +class SandboxManagerRdbOpenCallback : public NativeRdb::RdbOpenCallback { +public: + /** + * Called when the database associate with this RdbStore is created with the first time. + * This is where the creation of tables and insert the initial data of tables should happen. + * + * param store The RdbStore object. + */ + int32_t OnCreate(NativeRdb::RdbStore &rdbStore) override; + /** + * Called when the database associate whit this RdbStore needs to be upgrade. + * + * param store The RdbStore object. + * param oldVersion The old database version. + * param newVersion The new database version. + */ + int32_t OnUpgrade(NativeRdb::RdbStore &rdbStore, int32_t currentVersion, int32_t targetVersion) override; + +private: + int32_t CreatePersistedPolicyTable(NativeRdb::RdbStore &rdbStore, const std::string &tableName) const; + + OHOS::Utils::RWLock rwLock_; + inline static const std::string PERSISTED_POLICY_TABLE = "persisted_policy_table"; + + inline static const std::string DATABASE_NAME = "sandbox_manager.db"; + inline static const std::string DATABASE_PATH = "/data/service/el1/public/sandbox_manager/"; + inline static const std::string BACK_UP_RDB_NAME = "sandbox_manager_slave.db"; +}; +} // namespace SandboxManager +} // namespace AccessControl +} // namespace OHOS +#endif // SANDBOX_MANAGER_RDB_OPEN_CALLBACK_H \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_utils.h b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..9a25b4b5180ea77ff030a5e96c4dc0afa128cb64 --- /dev/null +++ b/services/sandbox_manager/main/cpp/include/database/sandbox_manager_rdb_utils.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SANDBOX_MANAGER_RDB_UTILS_H +#define SANDBOX_MANAGER_RDB_UTILS_H + +#include + +#include "generic_values.h" +#include "rdb_predicates.h" +#include "rdb_store.h" + +namespace OHOS { +namespace AccessControl { +namespace SandboxManager { + +enum DataType { + SANDBOX_MANAGER_PERSISTED_POLICY, +}; + +void GetTableNameByType(const DataType type, std::string &tableName); +void ToRdbValueBucket(const AccessControl::SandboxManager::GenericValues &value, NativeRdb::ValuesBucket &bucket); +void ToRdbValueBuckets(const std::vector& values, std::vector &buckets); +void ToRdbPredicates(const AccessControl::SandboxManager::GenericValues &conditionValue, + const AccessControl::SandboxManager::GenericValues &symbols, NativeRdb::RdbPredicates &predicates); +void ToRdbPredicates(const AccessControl::SandboxManager::GenericValues &conditionValue, + NativeRdb::RdbPredicates &predicates); +void ResultToGenericValues( + const std::shared_ptr &resultSet, AccessControl::SandboxManager::GenericValues &value); +} // namespace SandboxManager +} // namespace AccessControl +} // namespace OHOS +#endif // SANDBOX_MANAGER_RDB_UTILS_H \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/src/database/sandbox_manager_db.cpp b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_db.cpp deleted file mode 100644 index 5b3620005011ecdc35e8a3bf1b13a4f1da915be5..0000000000000000000000000000000000000000 --- a/services/sandbox_manager/main/cpp/src/database/sandbox_manager_db.cpp +++ /dev/null @@ -1,341 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "sandbox_manager_db.h" - -#include -#include -#include "policy_field_const.h" -#include "sandbox_manager_log.h" - -namespace OHOS { -namespace AccessControl { -namespace SandboxManager { -namespace { -static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, - ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerDb"}; -static const std::string INTEGER_STR = " integer not null,"; -static const std::string TEXT_STR = " text not null,"; -} - -const std::string SandboxManagerDb::IGNORE = "ignore"; -const std::string SandboxManagerDb::REPLACE = "replace"; - -SandboxManagerDb& SandboxManagerDb::GetInstance() -{ - static SandboxManagerDb instance; - return instance; -} - -SandboxManagerDb::~SandboxManagerDb() -{ - Close(); -} - -void SandboxManagerDb::OnCreate() -{ - SANDBOXMANAGER_LOG_INFO(LABEL, "%{public}s called.", __func__); - CreatePersistedPolicyTable(); -} - -void SandboxManagerDb::OnUpdate() -{ - SANDBOXMANAGER_LOG_INFO(LABEL, "%{public}s called.", __func__); -} - -SandboxManagerDb::SandboxManagerDb() : SqliteHelper(DATABASE_NAME, DATABASE_PATH, DATABASE_VERSION) -{ - SqliteTable persistedPolicyTable; - persistedPolicyTable.tableName_ = PERSISTED_POLICY_TABLE; - persistedPolicyTable.tableColumnNames_ = { - PolicyFiledConst::FIELD_TOKENID, PolicyFiledConst::FIELD_PATH, - PolicyFiledConst::FIELD_MODE, PolicyFiledConst::FIELD_DEPTH, - PolicyFiledConst::FIELD_FLAG - }; - - dataTypeToSqlTable_ = { - {SANDBOX_MANAGER_PERSISTED_POLICY, persistedPolicyTable}, - }; - - Open(); -} - -int32_t SandboxManagerDb::Add(const DataType type, const std::vector &values, - const std::string &duplicateMode) -{ - OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); - if ((duplicateMode != IGNORE) && (duplicateMode != REPLACE)) { - SANDBOXMANAGER_LOG_ERROR(LABEL, "Duplicate mode should be ignore or replace, input = %{public}s.", - duplicateMode.c_str()); - return FAILURE; - } - std::string prepareSql = CreateInsertPrepareSqlCmd(type, duplicateMode); - auto statement = Prepare(prepareSql); - BeginTransaction(); - bool isExecuteSuccessfully = true; - for (const auto& value : values) { - std::vector columnNames = value.GetAllKeys(); - for (const auto& columnName : columnNames) { - statement.Bind(columnName, value.Get(columnName)); - } - int ret = statement.Step(); - if (ret != Statement::State::DONE) { - SANDBOXMANAGER_LOG_ERROR(LABEL, "failed, errorMsg: %{public}s", SpitError().c_str()); - isExecuteSuccessfully = false; - } - statement.Reset(); - } - if (!isExecuteSuccessfully) { - SANDBOXMANAGER_LOG_ERROR(LABEL, "rollback transaction."); - RollbackTransaction(); - return FAILURE; - } - SANDBOXMANAGER_LOG_INFO(LABEL, "commit transaction."); - CommitTransaction(); - return SUCCESS; -} - -int32_t SandboxManagerDb::Remove(const DataType type, const GenericValues& conditions) -{ - OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); - std::vector columnNames = conditions.GetAllKeys(); - std::string prepareSql = CreateDeletePrepareSqlCmd(type, columnNames); - auto statement = Prepare(prepareSql); - for (const auto& columnName : columnNames) { - statement.Bind(columnName, conditions.Get(columnName)); - } - int ret = statement.Step(); - return (ret == Statement::State::DONE) ? SUCCESS : FAILURE; -} - -int32_t SandboxManagerDb::Modify(const DataType type, const GenericValues& modifyValues, - const GenericValues& conditions) -{ - OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); - std::vector modifyColumns = modifyValues.GetAllKeys(); - std::vector conditionColumns = conditions.GetAllKeys(); - std::string prepareSql = CreateUpdatePrepareSqlCmd(type, modifyColumns, conditionColumns); - auto statement = Prepare(prepareSql); - for (const auto& columnName : modifyColumns) { - statement.Bind(columnName, modifyValues.Get(columnName)); - } - for (const auto& columnName : conditionColumns) { - statement.Bind(columnName, conditions.Get(columnName)); - } - int ret = statement.Step(); - return (ret == Statement::State::DONE) ? SUCCESS : FAILURE; -} - -int32_t SandboxManagerDb::FindSubPath( - const DataType type, const std::string& filePath, std::vector& results) -{ - OHOS::Utils::UniqueReadGuard lock(this->rwLock_); - auto it = dataTypeToSqlTable_.find(type); - if (it == dataTypeToSqlTable_.end()) { - return FAILURE; - } - std::string sql = "select * from " + it->second.tableName_ + " where " + PolicyFiledConst::FIELD_PATH - + " like '" + filePath + "/%'" + " or " + PolicyFiledConst::FIELD_PATH + " = '" + filePath + "'"; - auto statement = Prepare(sql); - - while (statement.Step() == Statement::State::ROW) { - int32_t columnCount = statement.GetColumnCount(); - GenericValues value; - for (int32_t i = 0; i < columnCount; i++) { - value.Put(statement.GetColumnName(i), statement.GetValue(i, false)); - } - results.emplace_back(value); - } - return SUCCESS; -} - -int32_t SandboxManagerDb::Find(const DataType type, const GenericValues& conditions, - const GenericValues& symbols, std::vector& results) -{ - OHOS::Utils::UniqueReadGuard lock(this->rwLock_); - std::vector searchColumns = conditions.GetAllKeys(); - std::string prepareSql = CreateSelectPrepareSqlCmd(type, searchColumns, symbols); - auto statement = Prepare(prepareSql); - for (const auto& columnName : searchColumns) { - statement.Bind(columnName, conditions.Get(columnName)); - } - while (statement.Step() == Statement::State::ROW) { - int columnCount = statement.GetColumnCount(); - GenericValues value; - for (int i = 0; i < columnCount; i++) { - value.Put(statement.GetColumnName(i), statement.GetValue(i, false)); - } - results.emplace_back(value); - } - return SUCCESS; -} - -int32_t SandboxManagerDb::RefreshAll(const DataType type, const std::vector& values) -{ - OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); - std::string deleteSql = CreateDeletePrepareSqlCmd(type); - std::string insertSql = CreateInsertPrepareSqlCmd(type, IGNORE); - auto deleteStatement = Prepare(deleteSql); - auto insertStatement = Prepare(insertSql); - BeginTransaction(); - bool canCommit = deleteStatement.Step() == Statement::State::DONE; - for (const auto& value : values) { - std::vector columnNames = value.GetAllKeys(); - for (const auto& columnName : columnNames) { - insertStatement.Bind(columnName, value.Get(columnName)); - } - int ret = insertStatement.Step(); - if (ret != Statement::State::DONE) { - SANDBOXMANAGER_LOG_ERROR( - LABEL, "insert failed, errorMsg: %{public}s", SpitError().c_str()); - canCommit = false; - } - insertStatement.Reset(); - } - if (!canCommit) { - SANDBOXMANAGER_LOG_ERROR(LABEL, "rollback transaction."); - RollbackTransaction(); - return FAILURE; - } - SANDBOXMANAGER_LOG_INFO(LABEL, "commit transaction."); - CommitTransaction(); - return SUCCESS; -} - -std::string SandboxManagerDb::CreateInsertPrepareSqlCmd(const DataType type, - const std::string &duplicateMode) const -{ - auto it = dataTypeToSqlTable_.find(type); - if (it == dataTypeToSqlTable_.end()) { - return std::string(); - } - std::string sql = "insert or " + duplicateMode + " into " + it->second.tableName_ + " values("; - int i = 1; - for (const auto& columnName : it->second.tableColumnNames_) { - sql.append(":" + columnName); - if (i < static_cast(it->second.tableColumnNames_.size())) { - sql.append(","); - } - i += 1; - } - sql.append(")"); - return sql; -} - -std::string SandboxManagerDb::CreateDeletePrepareSqlCmd( - const DataType type, const std::vector& columnNames) const -{ - auto it = dataTypeToSqlTable_.find(type); - if (it == dataTypeToSqlTable_.end()) { - return std::string(); - } - std::string sql = "delete from " + it->second.tableName_ + " where 1 = 1"; - for (const auto& columnName : columnNames) { - sql.append(" and "); - sql.append(columnName + "=:" + columnName); - } - return sql; -} - -std::string SandboxManagerDb::CreateUpdatePrepareSqlCmd(const DataType type, - const std::vector& modifyColumns, const std::vector& conditionColumns) const -{ - if (modifyColumns.empty()) { - return std::string(); - } - - auto it = dataTypeToSqlTable_.find(type); - if (it == dataTypeToSqlTable_.end()) { - return std::string(); - } - - std::string sql = "update " + it->second.tableName_ + " set "; - int i = 1; - for (const auto& columnName : modifyColumns) { - sql.append(columnName + "=:" + columnName); - if (i < static_cast(modifyColumns.size())) { - sql.append(","); - } - i += 1; - } - - if (!conditionColumns.empty()) { - sql.append(" where 1 = 1"); - for (const auto& columnName : conditionColumns) { - sql.append(" and "); - sql.append(columnName + "=:" + columnName); - } - } - return sql; -} - -std::string SandboxManagerDb::CreateSelectPrepareSqlCmd(const DataType type, - const std::vector& searchColumns, const GenericValues& symbols) const -{ - auto it = dataTypeToSqlTable_.find(type); - if (it == dataTypeToSqlTable_.end()) { - return std::string(); - } - std::string sql = "select * from " + it->second.tableName_ + " where 1 = 1"; - for (const auto& columnName : searchColumns) { - sql.append(" and "); - std::string symbol = symbols.GetString(columnName); - std::string insertSql = columnName; - if (symbol.empty() || symbol== "=") { - insertSql += "=:"; - } else if (symbol == "<=") { - insertSql += "<=:"; - } else { - SANDBOXMANAGER_LOG_ERROR( - LABEL, "unknown symbol, input: %{public}s", symbol.c_str()); - return std::string(); - } - sql.append(insertSql + columnName); - } - return sql; -} - -int32_t SandboxManagerDb::CreatePersistedPolicyTable() const -{ - auto it = dataTypeToSqlTable_.find(DataType::SANDBOX_MANAGER_PERSISTED_POLICY); - if (it == dataTypeToSqlTable_.end()) { - return FAILURE; - } - std::string sql = "create table if not exists "; - sql.append(it->second.tableName_ + " (") - .append(PolicyFiledConst::FIELD_TOKENID) - .append(INTEGER_STR) - .append(PolicyFiledConst::FIELD_PATH) - .append(TEXT_STR) - .append(PolicyFiledConst::FIELD_MODE) - .append(INTEGER_STR) - .append(PolicyFiledConst::FIELD_DEPTH) - .append(INTEGER_STR) - .append(PolicyFiledConst::FIELD_FLAG) - .append(INTEGER_STR) - .append("primary key(") - .append(PolicyFiledConst::FIELD_TOKENID) - .append(",") - .append(PolicyFiledConst::FIELD_DEPTH) - .append(",") - .append(PolicyFiledConst::FIELD_PATH) - .append(",") - .append(PolicyFiledConst::FIELD_MODE) - .append("))"); - return ExecuteSql(sql); -} -} // namespace SANDBOXMANAGER -} // namespace Security -} // namespace OHOS \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb.cpp b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2895ded3f81a0ad8d9ea0c391153362f97d9a189 --- /dev/null +++ b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb.cpp @@ -0,0 +1,301 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sandbox_manager_rdb.h" + +#include +#include +#include +#include +#include "sandbox_manager_rdb_open_callback.h" +#include "sandbox_manager_rdb_utils.h" +#include "rdb_helper.h" +#include "policy_field_const.h" +#include "sandbox_manager_log.h" + +namespace OHOS { +namespace AccessControl { +namespace SandboxManager { +namespace { +static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, + ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerRdb"}; + +inline static const std::string DATABASE_NAME = "sandbox_manager.db"; +inline static const std::string DATABASE_PATH = "/data/service/el1/public/sandbox_manager/"; +inline static const std::string SANDBOX_MANAGER_SERVICE_NAME = "sandbox_manager_service"; +static std::mutex g_instanceMutex; +} + +const std::string SandboxManagerRdb::IGNORE = "ignore"; +const std::string SandboxManagerRdb::REPLACE = "replace"; + +SandboxManagerRdb& SandboxManagerRdb::GetInstance() +{ + static SandboxManagerRdb* instance = nullptr; + if (instance == nullptr) { + std::lock_guard lock(g_instanceMutex); + if (instance == nullptr) { + instance = new SandboxManagerRdb(); + } + } + return *instance; +} + +SandboxManagerRdb::SandboxManagerRdb() +{ + std::string dbPath = DATABASE_PATH; + dbPath.append(DATABASE_NAME); + NativeRdb::RdbStoreConfig config(dbPath); + config.SetSecurityLevel(NativeRdb::SecurityLevel::S1); + config.SetAllowRebuild(true); + // set Real-time dual-write backup database + config.SetHaMode(NativeRdb::HAMode::MAIN_REPLICA); + config.SetServiceName(std::string(SANDBOX_MANAGER_SERVICE_NAME)); + SandboxManagerRdbOpenCallback callback; + int32_t res = NativeRdb::E_OK; + // pragma user_version will done by rdb, they store path and db_ as pair in RdbStoreManager + SANDBOXMANAGER_LOG_DEBUG(LABEL, "ready to init db_."); + db_ = NativeRdb::RdbHelper::GetRdbStore(config, SandboxManagerRdb::DATABASE_VERSION, callback, res); + if ((res != NativeRdb::E_OK) || (db_ == nullptr)) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "GetRdbStore fail, error code:%{public}d", res); + return; + } + // Restore if needed + NativeRdb::RebuiltType rebuildType = NativeRdb::RebuiltType::NONE; + int32_t rebuildCode = db_->GetRebuilt(rebuildType); + SANDBOXMANAGER_LOG_INFO(LABEL, "rdb restore rebuildCode ret:%{public}d", rebuildCode); + if (rebuildType == NativeRdb::RebuiltType::REBUILT) { + SANDBOXMANAGER_LOG_INFO(LABEL, "start %{public}s restore ret %{public}d, type:%{public}d", + DATABASE_NAME.c_str(), + rebuildCode, + static_cast(rebuildType)); + int32_t restoreRet = db_->Restore(std::string(""), {}); + if (restoreRet != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "rdb restore failed ret:%{public}d", restoreRet); + } + } +} + +int32_t SandboxManagerRdb::GetConflictResolution(const std::string &duplicateMode, + NativeRdb::ConflictResolution &solution) +{ + if (duplicateMode == IGNORE) { + solution = NativeRdb::ConflictResolution::ON_CONFLICT_IGNORE; + return SUCCESS; + } + if (duplicateMode == REPLACE) { + solution = NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE; + return SUCCESS; + } + SANDBOXMANAGER_LOG_ERROR(LABEL, "Duplicate mode should be ignore or replace, input = %{public}s.", + duplicateMode.c_str()); + return FAILURE; +} + +int32_t SandboxManagerRdb::Add(const DataType type, const std::vector &values, + const std::string &duplicateMode) +{ + std::string tableName; + GetTableNameByType(type, tableName); + if (tableName.empty()) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "cannot find tableName by type:%{public}u, please check", type); + return FAILURE; + } + SANDBOXMANAGER_LOG_DEBUG(LABEL, "Add table name is : %{public}s", tableName.c_str()); + + NativeRdb::ConflictResolution solution; + int32_t res = GetConflictResolution(duplicateMode, solution); + if (res != SUCCESS) { + return FAILURE; + } + + OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); + if (db_ == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "db is null, open db first"); + return FAILURE; + } + db_->BeginTransaction(); + for (const auto& value : values) { + NativeRdb::ValuesBucket bucket; + ToRdbValueBucket(value, bucket); + if (bucket.IsEmpty()) { + continue; + } + int64_t rowId = -1; + res = db_->InsertWithConflictResolution(rowId, tableName, bucket, solution); + if (res != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to batch insert into table %{public}s, res is %{public}d.", + tableName.c_str(), res); + db_->RollBack(); + if (res != NativeRdb::E_SQLITE_CORRUPT) { + return FAILURE; + } + SANDBOXMANAGER_LOG_INFO(LABEL, "db corrupt detected, attempt to restore"); + int ret = db_->Restore(std::string(""), {}); + if (ret != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to restore from db, ret is %{public}d.", ret); + } + return FAILURE; + } + } + db_->Commit(); + return SUCCESS; +} + +int32_t SandboxManagerRdb::Remove(const DataType type, const GenericValues& conditions) +{ + std::string tableName; + GetTableNameByType(type, tableName); + if (tableName.empty()) { + return FAILURE; + } + SANDBOXMANAGER_LOG_DEBUG(LABEL, "Remove tableName: %{public}s", tableName.c_str()); + NativeRdb::RdbPredicates predicates(tableName); + ToRdbPredicates(conditions, predicates); + + int32_t deletedRows = 0; + OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); + if (db_ == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "db is null, open db first"); + return FAILURE; + } + int32_t res = db_->Delete(deletedRows, predicates); + if (res != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to delete record from table %{public}s, res is %{public}d.", + tableName.c_str(), res); + if (res != NativeRdb::E_SQLITE_CORRUPT) { + return FAILURE; + } + SANDBOXMANAGER_LOG_INFO(LABEL, "db corrupt detected, attempt to restore"); + int ret = db_->Restore(std::string(""), {}); + if (ret != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to restore from db, ret is %{public}d.", ret); + } + return FAILURE; + } + return SUCCESS; +} + +int32_t SandboxManagerRdb::Modify(const DataType type, const GenericValues& modifyValues, + const GenericValues& conditions) +{ + std::string tableName; + GetTableNameByType(type, tableName); + if (tableName.empty()) { + return FAILURE; + } + + NativeRdb::ValuesBucket bucket; + ToRdbValueBucket(modifyValues, bucket); + if (bucket.IsEmpty()) { + return FAILURE; + } + NativeRdb::RdbPredicates predicates(tableName); + ToRdbPredicates(conditions, predicates); + + int32_t changedRows = 0; + OHOS::Utils::UniqueWriteGuard lock(this->rwLock_); + if (db_ == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "db is null, open db first"); + return FAILURE; + } + int32_t res = db_->Update(changedRows, bucket, predicates); + if (res != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to update record from table %{public}s, res is %{public}d.", + tableName.c_str(), res); + if (res != NativeRdb::E_SQLITE_CORRUPT) { + return FAILURE; + } + SANDBOXMANAGER_LOG_INFO(LABEL, "db corrupt detected, attempt to restore"); + int ret = db_->Restore(std::string(""), {}); + if (ret != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to restore from db, ret is %{public}d.", ret); + } + return FAILURE; + } + return SUCCESS; +} + +int32_t SandboxManagerRdb::FindSubPath( + const DataType type, const std::string& filePath, std::vector& results) +{ + std::string tableName; + GetTableNameByType(type, tableName); + if (tableName.empty()) { + return FAILURE; + } + SANDBOXMANAGER_LOG_DEBUG(LABEL, "Find tableName: %{public}s", tableName.c_str()); + + OHOS::Utils::UniqueReadGuard lock(this->rwLock_); + std::vector bindArgs; + std::string like_arg_str = filePath + "/%"; + NativeRdb::ValueObject arg1(like_arg_str); + NativeRdb::ValueObject arg2(filePath); + bindArgs.push_back(arg1); + bindArgs.push_back(arg2); + std::string sql = "select * from " + tableName + " where " + PolicyFiledConst::FIELD_PATH + + " like ? or " + PolicyFiledConst::FIELD_PATH + " = ?"; + auto queryResultSet = db_->QuerySql(sql, bindArgs); + if (queryResultSet == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to find records from table %{public}s.", tableName.c_str()); + return FAILURE; + } + while (queryResultSet->GoToNextRow() == NativeRdb::E_OK) { + GenericValues value; + ResultToGenericValues(queryResultSet, value); + if (value.GetAllKeys().empty()) { + continue; + } + results.emplace_back(value); + } + return SUCCESS; +} + +int32_t SandboxManagerRdb::Find(const DataType type, const GenericValues& conditions, + const GenericValues& symbols, std::vector& results) +{ + std::string tableName; + GetTableNameByType(type, tableName); + if (tableName.empty()) { + return FAILURE; + } + SANDBOXMANAGER_LOG_DEBUG(LABEL, "Find tableName: %{public}s", tableName.c_str()); + NativeRdb::RdbPredicates predicates(tableName); + ToRdbPredicates(conditions, symbols, predicates); + + std::vector columns; // empty columns means query all columns + OHOS::Utils::UniqueReadGuard lock(this->rwLock_); + if (db_ == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "db is null, open db first"); + return FAILURE; + } + auto queryResultSet = db_->Query(predicates, columns); + if (queryResultSet == nullptr) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to find records from table %{public}s.", tableName.c_str()); + return FAILURE; + } + while (queryResultSet->GoToNextRow() == NativeRdb::E_OK) { + GenericValues value; + ResultToGenericValues(queryResultSet, value); + if (value.GetAllKeys().empty()) { + continue; + } + results.emplace_back(value); + } + return SUCCESS; +} +} // namespace SANDBOXMANAGER +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp new file mode 100644 index 0000000000000000000000000000000000000000..423b6f2b5eb6b9d66d5cc2bf04e42e1984c1e52f --- /dev/null +++ b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sandbox_manager_rdb_open_callback.h" + +#include +#include +#include +#include "sandbox_manager_log.h" +#include "policy_field_const.h" + +namespace OHOS { +namespace AccessControl { +namespace SandboxManager { +namespace { +static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, + ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerRdbCallback"}; + +constexpr const char *INTEGER_STR = " integer not null,"; +constexpr const char *TEXT_STR = " text not null,"; +} // namespace + +int32_t SandboxManagerRdbOpenCallback::OnCreate(NativeRdb::RdbStore &rdbStore) +{ + SANDBOXMANAGER_LOG_INFO(LABEL, "%{public}s called.", __func__); + SANDBOXMANAGER_LOG_INFO(LABEL, "DB OnCreate"); + int32_t res = CreatePersistedPolicyTable(rdbStore, PERSISTED_POLICY_TABLE); + if (res != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to create table PERSISTED_POLICY_TABLE"); + return res; + } + // Restore if back_db exist + std::string backupDbPath = DATABASE_PATH + BACK_UP_RDB_NAME; + if (access(backupDbPath.c_str(), NativeRdb::E_OK) == 0) { + SANDBOXMANAGER_LOG_INFO(LABEL, "backup db exist, need to restore"); + int32_t restoreRet = rdbStore.Restore(std::string(""), {}); + if (restoreRet != NativeRdb::E_OK) { + SANDBOXMANAGER_LOG_ERROR(LABEL, "rdb restore failed ret:%{public}d", restoreRet); + } + } + return NativeRdb::E_OK; +} + +int32_t SandboxManagerRdbOpenCallback::OnUpgrade( + NativeRdb::RdbStore &rdbStore, int32_t currentVersion, int32_t targetVersion) { return NativeRdb::E_OK; } + +int32_t SandboxManagerRdbOpenCallback::CreatePersistedPolicyTable(NativeRdb::RdbStore &rdbStore, + const std::string &tableName) const +{ + std::string sql = "create table if not exists "; + sql.append(tableName + " (") + .append(PolicyFiledConst::FIELD_TOKENID) + .append(INTEGER_STR) + .append(PolicyFiledConst::FIELD_PATH) + .append(TEXT_STR) + .append(PolicyFiledConst::FIELD_MODE) + .append(INTEGER_STR) + .append(PolicyFiledConst::FIELD_DEPTH) + .append(INTEGER_STR) + .append(PolicyFiledConst::FIELD_FLAG) + .append(INTEGER_STR) + .append("primary key(") + .append(PolicyFiledConst::FIELD_TOKENID) + .append(",") + .append(PolicyFiledConst::FIELD_DEPTH) + .append(",") + .append(PolicyFiledConst::FIELD_PATH) + .append(",") + .append(PolicyFiledConst::FIELD_MODE) + .append("))"); + return rdbStore.ExecuteSql(sql); +} +} // namespace SandboxManager +} // namespace AccessControl +} // namespace OHOS \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_utils.cpp b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a4f8215728d82adbb81815a8725069330f6ae1c3 --- /dev/null +++ b/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_utils.cpp @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sandbox_manager_rdb_utils.h" + +#include +#include "sandbox_manager_log.h" +#include "policy_field_const.h" +#include "rdb_helper.h" + +namespace OHOS { +namespace AccessControl { +namespace SandboxManager { +namespace { +static const std::vector g_StringTypeColumns = { + PolicyFiledConst::FIELD_PATH +}; + +static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, + ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerRdbUtils"}; + +static const std::map dataTypeToSqlTable_ = { + {SANDBOX_MANAGER_PERSISTED_POLICY, "persisted_policy_table"}, +}; +} // namespace + +void GetTableNameByType(const DataType type, std::string &tableName) +{ + auto it = dataTypeToSqlTable_.find(type); + if (it == dataTypeToSqlTable_.end()) { + return; + } + tableName = it->second; +} + +static bool IsColumnStringType(const std::string &column) +{ + return std::find(g_StringTypeColumns.begin(), g_StringTypeColumns.end(), column) != + g_StringTypeColumns.end(); +} + +void ToRdbValueBucket(const GenericValues &value, NativeRdb::ValuesBucket &bucket) +{ + std::vector columnNames = value.GetAllKeys(); + uint32_t size = columnNames.size(); + for (uint32_t i = 0; i < size; ++i) { + std::string column = columnNames[i]; + if (IsColumnStringType(column)) { + bucket.PutString(column, value.GetString(column)); + } else { + if (value.Get(column).GetType() == ValueType::TYPE_INT) { + bucket.PutInt(column, value.GetInt(column)); + } else { + bucket.PutLong(column, value.GetInt64(column)); + } + } + } +} + +void ToRdbValueBuckets(const std::vector& values, + std::vector &buckets) +{ + for (const auto& value : values) { + NativeRdb::ValuesBucket bucket; + ToRdbValueBucket(value, bucket); + if (bucket.IsEmpty()) { + continue; + } + buckets.emplace_back(bucket); + } +} + +static inline int64_t HandleValueToInt(const VariantValue &variantvalue) +{ + if (variantvalue.GetType() == ValueType::TYPE_INT) { + return variantvalue.GetInt(); + } else { + return variantvalue.GetInt64(); + } +} + +void ToRdbPredicates(const GenericValues &conditionValue, const GenericValues& symbols, + NativeRdb::RdbPredicates &predicates) +{ + std::vector columnNames = conditionValue.GetAllKeys(); + size_t size = columnNames.size(); + // size 0 is possible, maybe delete or query or update all records + for (uint32_t i = 0; i < size; ++i) { + std::string column = columnNames[i]; + if (IsColumnStringType(column)) { + std::string str = conditionValue.GetString(column); + predicates.EqualTo(column, conditionValue.GetString(column)); + } else { + int64_t value = HandleValueToInt(conditionValue.Get(column)); + std::string symbol = symbols.GetString(column); + if (symbol.empty() || symbol== "=") { + predicates.EqualTo(column, value); + } else if (symbol == "<=") { + predicates.LessThanOrEqualTo(column, value); + } else { + SANDBOXMANAGER_LOG_ERROR( + LABEL, "unknown symbol, input: %{public}s", symbol.c_str()); + return; + } + } + if (i != size - 1) { + predicates.And(); + } + } +} + +void ToRdbPredicates(const GenericValues &conditionValue, NativeRdb::RdbPredicates &predicates) +{ + std::vector columnNames = conditionValue.GetAllKeys(); + uint32_t size = columnNames.size(); + // size 0 is possible, maybe delete or query or update all records + for (uint32_t i = 0; i < size; ++i) { + std::string column = columnNames[i]; + if (IsColumnStringType(column)) { + std::string str = conditionValue.GetString(column); + predicates.EqualTo(column, conditionValue.GetString(column)); + } else { + int64_t value = HandleValueToInt(conditionValue.Get(column)); + predicates.EqualTo(column, value); + } + if (i != size - 1) { + predicates.And(); + } + } +} + +void ResultToGenericValues(const std::shared_ptr &resultSet, GenericValues &value) +{ + std::vector columnNames; + resultSet->GetAllColumnNames(columnNames); + uint64_t size = columnNames.size(); + for (uint64_t i = 0; i < size; ++i) { + std::string columnName = columnNames[i]; + int32_t columnIndex = 0; + resultSet->GetColumnIndex(columnName, columnIndex); + + NativeRdb::ColumnType type; + resultSet->GetColumnType(columnIndex, type); + + if (type == NativeRdb::ColumnType::TYPE_INTEGER) { + size_t type_size = 0; + resultSet->GetSize(columnIndex, type_size); + if (type_size == sizeof(int64_t)) { + int64_t data = 0; + resultSet->GetLong(columnIndex, data); + value.Put(columnName, data); + } else { + int32_t data = 0; + resultSet->GetInt(columnIndex, data); + value.Put(columnName, data); + } + } else if (type == NativeRdb::ColumnType::TYPE_STRING) { + std::string data; + resultSet->GetString(columnIndex, data); + value.Put(columnName, data); + } + } +} +} // namespace SandboxManager +} // namespace AccessControl +} // namespace OHOS \ No newline at end of file diff --git a/services/sandbox_manager/main/cpp/src/service/policy_info_manager.cpp b/services/sandbox_manager/main/cpp/src/service/policy_info_manager.cpp index c16b35f3b8de3d86d78c065e5080e09d3c9db75f..5ad9666d502d87783c6ad327b7db3bb051c838df 100644 --- a/services/sandbox_manager/main/cpp/src/service/policy_info_manager.cpp +++ b/services/sandbox_manager/main/cpp/src/service/policy_info_manager.cpp @@ -29,7 +29,7 @@ #include "policy_field_const.h" #include "policy_info.h" #include "sandbox_manager_const.h" -#include "sandbox_manager_db.h" +#include "sandbox_manager_rdb.h" #include "sandbox_manager_err_code.h" #include "sandbox_manager_log.h" @@ -50,7 +50,7 @@ PolicyInfoManager &PolicyInfoManager::GetInstance() void PolicyInfoManager::Init() { - SandboxManagerDb::GetInstance(); + SandboxManagerRdb::GetInstance(); macAdapter_.Init(); } @@ -100,8 +100,8 @@ int32_t PolicyInfoManager::CleanPersistPolicyByPath(const std::vector(flag)); addPolicyGeneric.emplace_back(condition); } - std::string duplicateMode = SandboxManagerDb::IGNORE; + std::string duplicateMode = SandboxManagerRdb::IGNORE; // replace duplicate policy when flag is 1 if (flag == 1) { - duplicateMode = SandboxManagerDb::REPLACE; + duplicateMode = SandboxManagerRdb::REPLACE; } - int32_t ret = SandboxManagerDb::GetInstance().Add( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, addPolicyGeneric, duplicateMode); - if (ret != SandboxManagerDb::SUCCESS) { + int32_t ret = SandboxManagerRdb::GetInstance().Add( + SANDBOX_MANAGER_PERSISTED_POLICY, addPolicyGeneric, duplicateMode); + if (ret != SandboxManagerRdb::SUCCESS) { SANDBOXMANAGER_LOG_ERROR(LABEL, "database operate error"); results.clear(); return SANDBOX_MANAGER_DB_ERR; @@ -313,9 +313,9 @@ int32_t PolicyInfoManager::RemovePolicy( GenericValues condition; TransferPolicyToGeneric(tokenId, policy[i], condition); - ret = SandboxManagerDb::GetInstance().Remove( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, condition); - if (ret != SandboxManagerDb::SUCCESS) { + ret = SandboxManagerRdb::GetInstance().Remove( + SANDBOX_MANAGER_PERSISTED_POLICY, condition); + if (ret != SandboxManagerRdb::SUCCESS) { SANDBOXMANAGER_LOG_ERROR(LABEL, "database operate error"); return SANDBOX_MANAGER_DB_ERR; } @@ -417,9 +417,9 @@ bool PolicyInfoManager::RemoveBundlePolicy(const uint32_t tokenId) GenericValues conditions; conditions.Put(PolicyFiledConst::FIELD_TOKENID, static_cast(tokenId)); // remove policys that have same tokenId - int32_t ret = SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + int32_t ret = SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, conditions); - if (ret != SandboxManagerDb::SUCCESS) { + if (ret != SandboxManagerRdb::SUCCESS) { SANDBOXMANAGER_LOG_ERROR(LABEL, "database operate error"); return false; } @@ -578,9 +578,9 @@ int32_t PolicyInfoManager::UnSetAllPolicyByToken(const uint32_t tokenId) int32_t PolicyInfoManager::RangeFind(const GenericValues &conditions, const GenericValues &symbols, std::vector &results) { - int32_t ret = SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + int32_t ret = SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, results); - if (ret != SandboxManagerDb::SUCCESS) { + if (ret != SandboxManagerRdb::SUCCESS) { SANDBOXMANAGER_LOG_ERROR(LABEL, "database operate error"); return SANDBOX_MANAGER_DB_ERR; } @@ -599,9 +599,9 @@ int32_t PolicyInfoManager::ExactFind(const uint32_t tokenId, const PolicyInfo &p TransferPolicyToGeneric(tokenId, policy, conditions); std::vector searchResults; - int32_t ret = SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + int32_t ret = SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, searchResults); - if (ret != SandboxManagerDb::SUCCESS) { + if (ret != SandboxManagerRdb::SUCCESS) { SANDBOXMANAGER_LOG_ERROR(LABEL, "database operate error"); return SANDBOX_MANAGER_DB_ERR; } diff --git a/services/sandbox_manager/test/BUILD.gn b/services/sandbox_manager/test/BUILD.gn index 9bf8b2fe4d2376ec012ba78a9604f86f49517cbe..2741586868a27e162224747fa74acbf49bb80a93 100644 --- a/services/sandbox_manager/test/BUILD.gn +++ b/services/sandbox_manager/test/BUILD.gn @@ -20,7 +20,9 @@ sandbox_manager_service_src = [ "../main/cpp/src/sensitive/sandbox_manager_event_subscriber.cpp", "../main/cpp/src/service/policy_info_manager.cpp", "../main/cpp/src/database/policy_field_const.cpp", - "../main/cpp/src/database/sandbox_manager_db.cpp", + "../main/cpp/src/database/sandbox_manager_rdb.cpp", + "../main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp", + "../main/cpp/src/database/sandbox_manager_rdb_utils.cpp", "../main/cpp/src/mac/mac_adapter.cpp", ] @@ -48,7 +50,7 @@ ohos_unittest("libsandbox_manager_service_standard_test") { sources = [ "unittest/policy_info_manager_test.cpp", - "unittest/sandbox_manager_db_test.cpp", + "unittest/sandbox_manager_rdb_test.cpp", "unittest/sandbox_manager_service_test.cpp", ] sources += sandbox_manager_service_src @@ -77,54 +79,14 @@ ohos_unittest("libsandbox_manager_service_standard_test") { "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "relational_store:native_rdb", "safwk:system_ability_fwk", "samgr:samgr_proxy", "sqlite:sqlite", ] } -ohos_unittest("libsandbox_manager_sqlite_mock_test") { - subsystem_name = "accesscontrol" - part_name = "sandbox_manager" - module_out_path = part_name + "/" + part_name - - include_dirs = [ - "${sandbox_manager_path}/frameworks/common/include", - "${sandbox_manager_path}/services/common/database/include", - "${sandbox_manager_path}/services/sandbox_manager/main/cpp/include/database", - "mock/include", - ] - - sources = [ - "${sandbox_manager_path}/services/common/database/src/generic_values.cpp", - "${sandbox_manager_path}/services/common/database/src/sqlite_helper.cpp", - "${sandbox_manager_path}/services/common/database/src/statement.cpp", - "${sandbox_manager_path}/services/common/database/src/variant_value.cpp", - "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/policy_field_const.cpp", - "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/sandbox_manager_db.cpp", - "mock/src/sqlite3sym.cpp", - "mock/src/sqlite_mock_test.cpp", - ] - - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - - configs = [ "${sandbox_manager_path}/config:coverage_flags" ] - - cflags_cc = [ "-DHILOG_ENABLE" ] - - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - ] -} - group("unittest") { testonly = true - deps = [ - ":libsandbox_manager_service_standard_test", - ":libsandbox_manager_sqlite_mock_test", - ] + deps = [ ":libsandbox_manager_service_standard_test" ] } diff --git a/services/sandbox_manager/test/mock/include/sqlite3sym.h b/services/sandbox_manager/test/mock/include/sqlite3sym.h deleted file mode 100644 index 1aa031d4679f31b708a9b0da6b568ae7132af0be..0000000000000000000000000000000000000000 --- a/services/sandbox_manager/test/mock/include/sqlite3sym.h +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef SQLITE3SYM_H -#define SQLITE3SYM_H -#include - -namespace OHOS { -namespace AccessControl { -namespace SandboxManager { -static const int32_t SQLITE_OK = 0; -static void (*SQLITE_TRANSIENT)(void *) = nullptr; - - -typedef int32_t sqlite3; -typedef int32_t sqlite3_stmt; -typedef int64_t sqlite_int64; - -enum SqliteEnum { - SQLITE_ROW, - SQLITE_DONE, - SQLITE_BUSY, - SQLITE_MISUSE, - SQLITE_INTEGER, - SQLITE_TEXT, -}; - -class SqliteMockInterface { -public: - virtual int32_t sqlite3_open(const char *filename, sqlite3 **ppDb); - virtual int32_t sqlite3_close(sqlite3 *db); - virtual int32_t sqlite3_exec(sqlite3 *db, const char *sql, int (*callback)(void*, int, char**, char**), - void *p, char **errmsg); - virtual int32_t sqlite3_prepare_v2(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, - const char **pzTail); - virtual int32_t sqlite3_finalize(sqlite3_stmt *pStmt); - virtual int32_t sqlite3_bind_text(sqlite3_stmt *pStmt, int i, const char *zData, int nData, - void (*xDel)(void *)); - virtual int32_t sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue); - virtual int32_t sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue); - virtual int32_t sqlite3_column_int(sqlite3_stmt *pStmt, int i); - virtual int32_t sqlite3_step(sqlite3_stmt *pStmt); - virtual int32_t sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName); - virtual int32_t sqlite3_reset(sqlite3_stmt *pStmt); - virtual int32_t sqlite3_column_count(sqlite3_stmt *pStmt); - virtual int32_t sqlite3_column_type(sqlite3_stmt *pStmt, int i); - virtual int64_t sqlite3_column_int64(sqlite3_stmt *pStmt, int i); - virtual const char* sqlite3_errmsg(sqlite3 *db); - virtual void sqlite3_free(void *p); - virtual const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int iCol); - virtual const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N); -}; - -class SqliteMocker : public SqliteMockInterface { -public: - SqliteMocker() = default; - virtual ~SqliteMocker() = default; - static SqliteMocker &GetInstance(); - MOCK_METHOD(int32_t, sqlite3_open, (const char *, sqlite3 **), (override)); - MOCK_METHOD(int32_t, sqlite3_close, (sqlite3 *), (override)); - MOCK_METHOD(int32_t, sqlite3_exec, (sqlite3 *, const char *, - int (*)(void*, int, char**, char**), void *, char **), (override)); - MOCK_METHOD(int32_t, sqlite3_prepare_v2, (sqlite3 *, const char *, int, - sqlite3_stmt **, const char **), (override)); - MOCK_METHOD(int32_t, sqlite3_finalize, (sqlite3_stmt *), (override)); - MOCK_METHOD(int32_t, sqlite3_bind_text, (sqlite3_stmt *, int, const char *, - int, void (*)(void*)), (override)); - MOCK_METHOD(int32_t, sqlite3_bind_int, (sqlite3_stmt *, int, int), (override)); - MOCK_METHOD(int32_t, sqlite3_bind_int64, (sqlite3_stmt *, int, - sqlite_int64), (override)); - MOCK_METHOD(int32_t, sqlite3_column_int, (sqlite3_stmt *, int), (override)); - MOCK_METHOD(int32_t, sqlite3_step, (sqlite3_stmt *), (override)); - MOCK_METHOD(int32_t, sqlite3_bind_parameter_index, (sqlite3_stmt *, - const char *), (override)); - MOCK_METHOD(int32_t, sqlite3_reset, (sqlite3_stmt *), (override)); - MOCK_METHOD(int32_t, sqlite3_column_count, (sqlite3_stmt *), (override)); - MOCK_METHOD(int32_t, sqlite3_column_type, (sqlite3_stmt *, int), (override)); - MOCK_METHOD(int64_t, sqlite3_column_int64, (sqlite3_stmt *, int), (override)); - MOCK_METHOD(const char*, sqlite3_errmsg, (sqlite3*), (override)); - MOCK_METHOD(void, sqlite3_free, (void*), (override)); - MOCK_METHOD(const unsigned char *, sqlite3_column_text, (sqlite3_stmt*, int), (override)); - MOCK_METHOD(const char *, sqlite3_column_name, (sqlite3_stmt *, int), (override)); -}; - -int32_t sqlite3_open(const char *filename, sqlite3 **ppDb); -int32_t sqlite3_close(sqlite3 *db); -int32_t sqlite3_exec(sqlite3 *db, const char *sql, int (*callback)(void*, int, char**, char**), - void *p, char **errmsg); -int32_t sqlite3_prepare_v2(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, - const char **pzTail); -int32_t sqlite3_finalize(sqlite3_stmt *pStmt); -int32_t sqlite3_bind_text(sqlite3_stmt *pStmt, int i, const char *zData, int nData, - void (*xDel)(void*)); -int32_t sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue); -int32_t sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue); -int32_t sqlite3_column_int(sqlite3_stmt *pStmt, int i); -int32_t sqlite3_step(sqlite3_stmt *pStmt); -int32_t sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName); -int32_t sqlite3_reset(sqlite3_stmt *pStmt); -int32_t sqlite3_column_count(sqlite3_stmt *pStmt); -int32_t sqlite3_column_type(sqlite3_stmt *pStmt, int i); -int64_t sqlite3_column_int64(sqlite3_stmt *pStmt, int i); -const char* sqlite3_errmsg(sqlite3 *db); -void sqlite3_free(void *p); -const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int iCol); -const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N); -} // namespace SandboxManager -} // namespace AccessControl -} // namespace OHOS -#endif // SQLITE3SYM_H \ No newline at end of file diff --git a/services/sandbox_manager/test/mock/src/sqlite3sym.cpp b/services/sandbox_manager/test/mock/src/sqlite3sym.cpp deleted file mode 100644 index 8b04fa5b31ab461d850cc36cb8b2686e44059b66..0000000000000000000000000000000000000000 --- a/services/sandbox_manager/test/mock/src/sqlite3sym.cpp +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "sqlite3sym.h" - -namespace OHOS { -namespace AccessControl { -namespace SandboxManager { -SqliteMocker &SqliteMocker::GetInstance() -{ - static SqliteMocker instance; - return instance; -} - -int32_t sqlite3_open(const char *filename, sqlite3 **ppDb) -{ - return SqliteMocker::GetInstance().sqlite3_open(filename, ppDb); -} - -int32_t sqlite3_close(sqlite3 *db) -{ - return SqliteMocker::GetInstance().sqlite3_close(db); -} - -int32_t sqlite3_exec(sqlite3 *db, const char *sql, int (*callback)(void*, int, char**, char**), void *p, char **errmsg) -{ - return SqliteMocker::GetInstance().sqlite3_exec(db, sql, callback, p, errmsg); -} - -int32_t sqlite3_prepare_v2(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, const char **pzTail) -{ - return SqliteMocker::GetInstance().sqlite3_prepare_v2(db, zSql, nByte, ppStmt, pzTail); -} - -int32_t sqlite3_finalize(sqlite3_stmt *pStmt) -{ - return SqliteMocker::GetInstance().sqlite3_finalize(pStmt); -} - -int32_t sqlite3_bind_text(sqlite3_stmt *pStmt, int i, const char *zData, int nData, void (*xDel)(void*)) -{ - return SqliteMocker::GetInstance().sqlite3_bind_text(pStmt, i, zData, nData, xDel); -} - -int32_t sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue) -{ - return SqliteMocker::GetInstance().sqlite3_bind_int(p, i, iValue); -} - -int32_t sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue) -{ - return SqliteMocker::GetInstance().sqlite3_bind_int64(pStmt, i, iValue); -} - -int32_t sqlite3_column_int(sqlite3_stmt *pStmt, int i) -{ - return SqliteMocker::GetInstance().sqlite3_column_int(pStmt, i); -} - -int32_t sqlite3_step(sqlite3_stmt *pStmt) -{ - return SqliteMocker::GetInstance().sqlite3_step(pStmt); -} - -int32_t sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName) -{ - return SqliteMocker::GetInstance().sqlite3_bind_parameter_index(pStmt, zName); -} - -int32_t sqlite3_reset(sqlite3_stmt *pStmt) -{ - return SqliteMocker::GetInstance().sqlite3_reset(pStmt); -} - -int32_t sqlite3_column_count(sqlite3_stmt *pStmt) -{ - return SqliteMocker::GetInstance().sqlite3_column_count(pStmt); -} - -int32_t sqlite3_column_type(sqlite3_stmt *pStmt, int i) -{ - return SqliteMocker::GetInstance().sqlite3_column_type(pStmt, i); -} - -int64_t sqlite3_column_int64(sqlite3_stmt *pStmt, int i) -{ - return SqliteMocker::GetInstance().sqlite3_column_int64(pStmt, i); -} - -const char* sqlite3_errmsg(sqlite3 *db) -{ - return SqliteMocker::GetInstance().sqlite3_errmsg(db); -} - -void sqlite3_free(void *p) -{ - return SqliteMocker::GetInstance().sqlite3_free(p); -} - -const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int iCol) -{ - return SqliteMocker::GetInstance().sqlite3_column_text(pStmt, iCol); -} - -const char *sqlite3_column_name(sqlite3_stmt *pStmt, int n) -{ - return SqliteMocker::GetInstance().sqlite3_column_name(pStmt, n); -} - -} // namespace SandboxManager -} // namespace AccessControl -} // namespace OHOS \ No newline at end of file diff --git a/services/sandbox_manager/test/mock/src/sqlite_mock_test.cpp b/services/sandbox_manager/test/mock/src/sqlite_mock_test.cpp deleted file mode 100644 index 5504c971d47888dd27db3b11854852ae03946b15..0000000000000000000000000000000000000000 --- a/services/sandbox_manager/test/mock/src/sqlite_mock_test.cpp +++ /dev/null @@ -1,448 +0,0 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include - -#define private public -#include "sandbox_manager_db.h" -#include "sqlite_helper.h" -#include "statement.h" -#include "variant_value.h" -#undef private - -using namespace testing::ext; -namespace OHOS { -namespace AccessControl { -namespace SandboxManager { -namespace { -static sqlite3 DEFAULT_DB = 0; -static const std::string DEFAULT_SQL = "test"; -const unsigned char *DEFAULT_UCHARP = reinterpret_cast(DEFAULT_SQL.c_str()); -const char *DEFAULT_CHARP = DEFAULT_SQL.c_str(); -} - -class SqliteMockTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - SqliteMocker *sqlMocker_ = nullptr; - - void SetUpDefaultMockSetting(); -}; - -void SqliteMockTest::SetUpTestCase(void) -{} - -void SqliteMockTest::TearDownTestCase(void) -{} - -void SqliteMockTest::SetUp(void) -{ - sqlMocker_ = &SqliteMocker::GetInstance(); - ASSERT_NE(nullptr, sqlMocker_); -} - -void SqliteMockTest::TearDown(void) -{} - -void SqliteMockTest::SetUpDefaultMockSetting() -{ - ASSERT_NE(nullptr, sqlMocker_); - // setup default mock setting - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_close(testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_exec(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_finalize(testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_text(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int(testing::_, testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int64(testing::_, testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_int(testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_parameter_index(testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_reset(testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_count(testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_type(testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_int64(testing::_, testing::_)).WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_errmsg(testing::_)).WillRepeatedly(testing::Return(DEFAULT_CHARP)); - EXPECT_CALL(*sqlMocker_, sqlite3_free(testing::_)).Times(testing::AtLeast(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_text(testing::_, testing::_)) - .WillRepeatedly(testing::Return(DEFAULT_UCHARP)); - EXPECT_CALL(*sqlMocker_, sqlite3_column_name(testing::_, testing::_)) - .WillRepeatedly(testing::Return(DEFAULT_CHARP)); -} - -/** - * @tc.name: SqliteMock001 - * @tc.desc: Test Statement::Bind err branch - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock001, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - Statement statement(&DEFAULT_DB, DEFAULT_SQL); - - statement.Bind(-1, ""); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_text(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(SQLITE_OK)); - statement.Bind(1, ""); - - int32_t val1 = 0; - statement.Bind(-1, val1); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int(testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(SQLITE_OK)); - statement.Bind(1, val1); - - int64_t val2 = 0; - statement.Bind(-1, val2); - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int64(testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(SQLITE_OK)); - statement.Bind(1, val2); - - EXPECT_CALL(*sqlMocker_, sqlite3_bind_text(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - statement.Bind(1, ""); - - int32_t val3 = 0; - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int(testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - statement.Bind(1, val3); - - int64_t val4 = 0; - EXPECT_CALL(*sqlMocker_, sqlite3_bind_int64(testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - statement.Bind(1, val4); -} - -/** - * @tc.name: SqliteMock002 - * @tc.desc: Test Statement::GetColumnInt64 - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock002, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - Statement statement(&DEFAULT_DB, DEFAULT_SQL); - - int64_t ret = 0xff; // test input - EXPECT_CALL(*sqlMocker_, sqlite3_column_int64(testing::_, testing::_)) - .WillOnce(testing::Return(ret)); - EXPECT_EQ(ret, statement.GetColumnInt64(0)); -} - -/** - * @tc.name: SqliteMock003 - * @tc.desc: Test Statement::Step - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock003, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - Statement statement(&DEFAULT_DB, DEFAULT_SQL); - - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)) - .WillOnce(testing::Return(SQLITE_ROW)); - EXPECT_EQ(Statement::State::ROW, statement.Step()); - - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)) - .WillOnce(testing::Return(SQLITE_DONE)); - EXPECT_EQ(Statement::State::DONE, statement.Step()); - - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)) - .WillOnce(testing::Return(SQLITE_BUSY)); - EXPECT_EQ(Statement::State::BUSY, statement.Step()); - - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)) - .WillOnce(testing::Return(SQLITE_MISUSE)); - EXPECT_EQ(Statement::State::MISUSE, statement.Step()); - - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)) - .WillOnce(testing::Return(-1)); - EXPECT_EQ(Statement::State::UNKNOWN, statement.Step()); -} - -/** - * @tc.name: SqliteMock004 - * @tc.desc: Test Statement::GetValue - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock004, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - Statement statement(&DEFAULT_DB, DEFAULT_SQL); - - EXPECT_CALL(*sqlMocker_, sqlite3_column_type(testing::_, testing::_)) - .WillOnce(testing::Return(SQLITE_INTEGER)); - int64_t ret = 0xff; // test input - EXPECT_CALL(*sqlMocker_, sqlite3_column_int64(testing::_, testing::_)) - .WillOnce(testing::Return(ret)); - VariantValue val1 = statement.GetValue(0, true); - EXPECT_EQ(ret, val1.GetInt64()); - - EXPECT_CALL(*sqlMocker_, sqlite3_column_type(testing::_, testing::_)) - .WillOnce(testing::Return(-1)); - VariantValue val2 = statement.GetValue(0, true); - EXPECT_EQ(-1, val2.GetInt64()); -} - -class SqliteHelperMocker : public SqliteHelper { -public: - SqliteHelperMocker(std::string dbName, std::string dbPath, int32_t version); - ~SqliteHelperMocker() = default; - - MOCK_METHOD(void, OnCreate, (), (override)); - MOCK_METHOD(void, OnUpdate, (), (override)); -}; - -SqliteHelperMocker::SqliteHelperMocker(std::string dbName, std::string dbPath, int32_t version) - : SqliteHelper(dbName, dbPath, version) -{} - -/** - * @tc.name: SqliteMock005 - * @tc.desc: Test SqliteHelper::SetVersion - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock005, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - SqliteHelperMocker mocker("", "", 0); - mocker.db_ = nullptr; - mocker.SetVersion(); - mocker.db_ = &DEFAULT_DB; - mocker.SetVersion(); -} - -/** - * @tc.name: SqliteMock006 - * @tc.desc: Test SqliteHelper::GetVersion - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock006, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker("", "", 0); - mocker.db_ = nullptr; - EXPECT_CALL(*sqlMocker_, sqlite3_prepare_v2(testing::_, testing::_, testing::_, testing::_, testing::_)) - .Times(0); - mocker.GetVersion(); -} - -/** - * @tc.name: SqliteMock007 - * @tc.desc: Test SqliteHelper::ExecuteSql, CommitTransaction, BeginTransaction - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock007, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker("", "", 0); - mocker.db_ = &DEFAULT_DB; - EXPECT_CALL(*sqlMocker_, sqlite3_exec(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - EXPECT_CALL(*sqlMocker_, sqlite3_free(testing::_)) - .Times(1); - mocker.ExecuteSql(DEFAULT_SQL); - - EXPECT_CALL(*sqlMocker_, sqlite3_exec(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - EXPECT_CALL(*sqlMocker_, sqlite3_free(testing::_)) - .Times(1); - mocker.CommitTransaction(); - - EXPECT_CALL(*sqlMocker_, sqlite3_exec(testing::_, testing::_, testing::_, testing::_, testing::_)) - .WillOnce(testing::Return(1)); - EXPECT_CALL(*sqlMocker_, sqlite3_free(testing::_)) - .Times(1); - mocker.BeginTransaction(); -} - -/** - * @tc.name: SqliteMock008 - * @tc.desc: Test SqliteHelper::Close - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock008, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker("", "", 0); - mocker.db_ = &DEFAULT_DB; - EXPECT_CALL(*sqlMocker_, sqlite3_close(testing::_)) - .WillOnce(testing::Return(1)); - mocker.Close(); -} - -/** - * @tc.name: SqliteMock009 - * @tc.desc: Test SqliteHelper::Close - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock009, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker1("", "", 0); - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)) - .Times(0); - mocker1.Open(); - - SqliteHelperMocker mocker2("test", "", 0); - mocker2.Open(); - - SqliteHelperMocker mocker3("test", "test", -1); - mocker3.Open(); - - mocker3.currentVersion_ = 0xff; // random test num - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)) - .WillOnce(testing::Return(1)); - mocker3.Open(); -} - -/** - * @tc.name: SqliteMock010 - * @tc.desc: Test SqliteHelper::Close - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock010, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker4("test", "test", 0xff); - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)) - .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&DEFAULT_DB), testing::Return(0))); - EXPECT_CALL(*sqlMocker_, sqlite3_column_int(testing::_, testing::_)).Times(testing::AnyNumber()) - .WillRepeatedly(testing::Return(0)); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(SQLITE_ROW)).WillRepeatedly(testing::Return(SQLITE_BUSY)); - EXPECT_CALL(mocker4, OnCreate()).Times(1); // call OnCreate - EXPECT_CALL(mocker4, OnUpdate()).Times(0); - mocker4.Open(); -} - -/** - * @tc.name: SqliteMock011 - * @tc.desc: Test SqliteHelper::Close - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock011, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker5("test", "test", 0xff); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(SQLITE_ROW)).WillRepeatedly(testing::Return(SQLITE_BUSY)); - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)) - .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&DEFAULT_DB), testing::Return(0))); - EXPECT_CALL(*sqlMocker_, sqlite3_column_int(testing::_, testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(1)); - EXPECT_CALL(mocker5, OnCreate()).Times(0); // not call OnCreate - EXPECT_CALL(mocker5, OnUpdate()).Times(1); // call OnUpdate - mocker5.Open(); -} - -/** - * @tc.name: SqliteMock012 - * @tc.desc: Test SqliteHelper::Close - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock012, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - SqliteHelperMocker mocker6("test", "test", 1); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(SQLITE_ROW)).WillRepeatedly(testing::Return(SQLITE_BUSY)); - EXPECT_CALL(*sqlMocker_, sqlite3_open(testing::_, testing::_)) - .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&DEFAULT_DB), testing::Return(0))); - EXPECT_CALL(*sqlMocker_, sqlite3_column_int(testing::_, testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(2)); // test: version > currentVersion_ - EXPECT_CALL(mocker6, OnCreate()).Times(0); // not call OnCreate - EXPECT_CALL(mocker6, OnUpdate()).Times(0); // not call OnUpdate - mocker6.Open(); -} - -/** - * @tc.name: SqliteMock013 - * @tc.desc: Test SandboxManagerDb::Add - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock013, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(SQLITE_ROW)).WillRepeatedly(testing::Return(SQLITE_BUSY)); - GenericValues val; - val.Put(PolicyFiledConst::FIELD_TOKENID, static_cast(1)); - val.Put(PolicyFiledConst::FIELD_PATH, "/user_grant/a"); - val.Put(PolicyFiledConst::FIELD_MODE, static_cast(0b01)); - val.Put(PolicyFiledConst::FIELD_DEPTH, static_cast(2)); // 2 means '/' included in path - val.Put(PolicyFiledConst::FIELD_FLAG, static_cast(0)); - - std::vector values = {val}; - EXPECT_EQ(SandboxManagerDb::ExecuteResult::FAILURE, SandboxManagerDb::GetInstance().Add( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, values)); -} - -/** - * @tc.name: SqliteMock014 - * @tc.desc: Test SandboxManagerDb::RefreshAll - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SqliteMockTest, SqliteMock014, TestSize.Level1) -{ - SetUpDefaultMockSetting(); - EXPECT_CALL(*sqlMocker_, sqlite3_step(testing::_)).Times(testing::AnyNumber()) - .WillOnce(testing::Return(SQLITE_DONE)).WillOnce(testing::Return(SQLITE_ROW)) - .WillRepeatedly(testing::Return(SQLITE_BUSY)); - GenericValues val; - val.Put(PolicyFiledConst::FIELD_TOKENID, static_cast(1)); - val.Put(PolicyFiledConst::FIELD_PATH, "/user_grant/a"); - val.Put(PolicyFiledConst::FIELD_MODE, static_cast(0b01)); - val.Put(PolicyFiledConst::FIELD_DEPTH, static_cast(2)); // 2 means '/' included in path - val.Put(PolicyFiledConst::FIELD_FLAG, static_cast(0)); - - std::vector values = {val}; - EXPECT_EQ(SandboxManagerDb::ExecuteResult::FAILURE, SandboxManagerDb::GetInstance().RefreshAll( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, values)); -} -} // SandboxManager -} // AccessControl -} // OHOS \ No newline at end of file diff --git a/services/sandbox_manager/test/unittest/policy_info_manager_test.cpp b/services/sandbox_manager/test/unittest/policy_info_manager_test.cpp index 2cab507a35e419c58ce6e3eae3da94e3d8d0c2ed..01758b61e120e093ab8ee592fab8df0ecc33b73e 100644 --- a/services/sandbox_manager/test/unittest/policy_info_manager_test.cpp +++ b/services/sandbox_manager/test/unittest/policy_info_manager_test.cpp @@ -30,7 +30,7 @@ #include "policy_info_manager.h" #undef private #include "sandbox_manager_const.h" -#include "sandbox_manager_db.h" +#include "sandbox_manager_rdb.h" #include "sandbox_manager_log.h" #include "sandbox_manager_err_code.h" @@ -49,21 +49,21 @@ public: }; static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { - LOG_CORE, ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerDbTest" + LOG_CORE, ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerRdbTest" }; void PolicyInfoManagerTest::SetUpTestCase(void) { // remove all in db GenericValues conditions; - SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, conditions); + SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, conditions); } void PolicyInfoManagerTest::TearDownTestCase(void) { // remove all in db GenericValues conditions; - SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, conditions); + SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, conditions); } void PolicyInfoManagerTest::SetUp(void) @@ -80,7 +80,7 @@ void PrintDbRecords() GenericValues conditions; GenericValues symbols; std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, dbResult)); for (size_t i = 0; i < dbResult.size(); i++) { int64_t tokenid; diff --git a/services/sandbox_manager/test/unittest/sandbox_manager_db_test.cpp b/services/sandbox_manager/test/unittest/sandbox_manager_rdb_test.cpp similarity index 53% rename from services/sandbox_manager/test/unittest/sandbox_manager_db_test.cpp rename to services/sandbox_manager/test/unittest/sandbox_manager_rdb_test.cpp index 66cf2e82d762fd171bf037e82a7995a497f672f7..c298393049cc8df5c9f8c7ab60b1b1d8581dba4a 100644 --- a/services/sandbox_manager/test/unittest/sandbox_manager_db_test.cpp +++ b/services/sandbox_manager/test/unittest/sandbox_manager_rdb_test.cpp @@ -21,7 +21,7 @@ #include "generic_values.h" #include "policy_field_const.h" #define private public -#include "sandbox_manager_db.h" +#include "sandbox_manager_rdb.h" #undef private #include "sandbox_manager_log.h" @@ -32,7 +32,7 @@ namespace OHOS { namespace AccessControl { namespace SandboxManager { -class SandboxManagerDbTest : public testing::Test { +class SandboxManagerRdbTest : public testing::Test { public: static void SetUpTestCase(void); static void TearDownTestCase(void); @@ -41,7 +41,7 @@ public: }; static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { - LOG_CORE, ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerDbTest" + LOG_CORE, ACCESSCONTROL_DOMAIN_SANDBOXMANAGER, "SandboxManagerRdbTest" }; void ResultLogDB(const GenericValues value) @@ -65,7 +65,7 @@ void ResultLogDB(const GenericValues value) GenericValues g_value1, g_value2, g_value3, g_value4, g_value5; -void SandboxManagerDbTest::SetUpTestCase(void) +void SandboxManagerRdbTest::SetUpTestCase(void) { g_value1.Put(PolicyFiledConst::FIELD_TOKENID, static_cast(1)); g_value1.Put(PolicyFiledConst::FIELD_PATH, "/user_grant/a"); @@ -98,52 +98,52 @@ void SandboxManagerDbTest::SetUpTestCase(void) g_value5.Put(PolicyFiledConst::FIELD_FLAG, static_cast(0)); } -void SandboxManagerDbTest::TearDownTestCase(void) +void SandboxManagerRdbTest::TearDownTestCase(void) {} -void SandboxManagerDbTest::SetUp(void) +void SandboxManagerRdbTest::SetUp(void) { GenericValues conditions; - SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, conditions); + SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, conditions); } -void SandboxManagerDbTest::TearDown(void) +void SandboxManagerRdbTest::TearDown(void) { GenericValues conditions; - SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, conditions); + SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, conditions); } /** - * @tc.name: SandboxManagerDbTest001 + * @tc.name: SandboxManagerRdbTest001 * @tc.desc: Test add func * @tc.type: FUNC * @tc.require: */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest001, TestSize.Level1) +HWTEST_F(SandboxManagerRdbTest, SandboxManagerRdbTest001, TestSize.Level1) { std::vector values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Add(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Add(SANDBOX_MANAGER_PERSISTED_POLICY, values)); GenericValues conditions; GenericValues symbols; std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, dbResult)); uint64_t sizeLimit = 5; EXPECT_EQ(sizeLimit, dbResult.size()); } /** - * @tc.name: SandboxManagerDbTest002 + * @tc.name: SandboxManagerRdbTest002 * @tc.desc: Test self-defined find func * @tc.type: FUNC * @tc.require: */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest002, TestSize.Level1) +HWTEST_F(SandboxManagerRdbTest, SandboxManagerRdbTest002, TestSize.Level1) { std::vector values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Add(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Add(SANDBOX_MANAGER_PERSISTED_POLICY, values)); // find token = 2, depth <= 1, g_value5 @@ -156,7 +156,7 @@ HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest002, TestSize.Level1) symbols.Put(PolicyFiledConst::FIELD_DEPTH, std::string("<=")); std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, dbResult)); SANDBOXMANAGER_LOG_INFO(LABEL, "dbResult:%{public}zu", dbResult.size()); @@ -183,39 +183,39 @@ HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest002, TestSize.Level1) } /** - * @tc.name: SandboxManagerDbTest001 + * @tc.name: SandboxManagerRdbTest001 * @tc.desc: Test remove func * @tc.type: FUNC * @tc.require: */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest003, TestSize.Level1) +HWTEST_F(SandboxManagerRdbTest, SandboxManagerRdbTest003, TestSize.Level1) { std::vector values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Add(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Add(SANDBOX_MANAGER_PERSISTED_POLICY, values)); - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, g_value1)); GenericValues conditions; GenericValues symbols; std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, dbResult)); uint64_t sizeLimit = 4; EXPECT_EQ(sizeLimit, dbResult.size()); } /** - * @tc.name: SandboxManagerDbTest001 + * @tc.name: SandboxManagerRdbTest001 * @tc.desc: Test remove func (not exist record) * @tc.type: FUNC * @tc.require: */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest004, TestSize.Level1) +HWTEST_F(SandboxManagerRdbTest, SandboxManagerRdbTest004, TestSize.Level1) { std::vector values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Add(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Add(SANDBOX_MANAGER_PERSISTED_POLICY, values)); GenericValues tmpValue; @@ -224,13 +224,13 @@ HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest004, TestSize.Level1) tmpValue.Put(PolicyFiledConst::FIELD_MODE, static_cast(0b11)); tmpValue.Put(PolicyFiledConst::FIELD_DEPTH, static_cast(3)); tmpValue.Put(PolicyFiledConst::FIELD_FLAG, static_cast(3)); - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Remove(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Remove(SANDBOX_MANAGER_PERSISTED_POLICY, tmpValue)); GenericValues conditions; GenericValues symbols; std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, conditions, symbols, dbResult)); uint64_t sizeLimit = 5; @@ -238,15 +238,15 @@ HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest004, TestSize.Level1) } /** - * @tc.name: SandboxManagerDbTest001 + * @tc.name: SandboxManagerRdbTest001 * @tc.desc: Test modify * @tc.type: FUNC * @tc.require: IMPORTANT: modify cannot change primary key (tokenid depth path) */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest005, TestSize.Level1) +HWTEST_F(SandboxManagerRdbTest, SandboxManagerRdbTest005, TestSize.Level1) { std::vector values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Add(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Add(SANDBOX_MANAGER_PERSISTED_POLICY, values)); GenericValues tmpValue; @@ -254,134 +254,26 @@ HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest005, TestSize.Level1) std::vector tmpdbResult; GenericValues symbols; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, g_value5, symbols, tmpdbResult)); uint64_t sizeLimit = 1; EXPECT_EQ(sizeLimit, tmpdbResult.size()); GenericValues condition; condition.Put(PolicyFiledConst::FIELD_TOKENID, static_cast(2)); condition.Put(PolicyFiledConst::FIELD_PATH, "/user_grant"); - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Modify(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Modify(SANDBOX_MANAGER_PERSISTED_POLICY, tmpValue, condition)); GenericValues conditions; std::vector dbResult; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().Find(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, + EXPECT_EQ(0, SandboxManagerRdb::GetInstance().Find(SANDBOX_MANAGER_PERSISTED_POLICY, tmpValue, symbols, dbResult)); EXPECT_EQ(sizeLimit, dbResult.size()); EXPECT_EQ(8, dbResult[0].GetInt(PolicyFiledConst::FIELD_DEPTH)); } - -/** - * @tc.name: SandboxManagerDbTest006 - * @tc.desc: Test remove func (not exist record) - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest006, TestSize.Level1) -{ - //db_ != nullptr - EXPECT_EQ(-1, SandboxManagerDb::GetInstance().RollbackTransaction()); - std::string sql = "PRAGMA user_version"; - EXPECT_NE(-1, SandboxManagerDb::GetInstance().ExecuteSql(sql)); - SandboxManagerDb::GetInstance().SpitError(); - - SandboxManagerDb::GetInstance().OnCreate(); - SandboxManagerDb::GetInstance().OnUpdate(); - std::vector values; - EXPECT_NE(-1, SandboxManagerDb::GetInstance().RefreshAll(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, - values)); - values = {g_value1, g_value2, g_value3, g_value4, g_value5}; - EXPECT_EQ(0, SandboxManagerDb::GetInstance().RefreshAll(SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, - values)); - SandboxManagerDb::GetInstance().Open(); - - //db_ = nullptr - SandboxManagerDb::GetInstance().Close(); - SandboxManagerDb::GetInstance().Close(); - EXPECT_EQ(-1, SandboxManagerDb::GetInstance().BeginTransaction()); - EXPECT_EQ(-1, SandboxManagerDb::GetInstance().CommitTransaction()); - EXPECT_EQ(-1, SandboxManagerDb::GetInstance().RollbackTransaction()); - EXPECT_EQ(-1, SandboxManagerDb::GetInstance().ExecuteSql(sql)); - SandboxManagerDb::GetInstance().SpitError(); - SandboxManagerDb::GetInstance().Open(); // recover -} - -/** - * @tc.name: SandboxManagerDbTest007 - * @tc.desc: Test when dataTypeToSqlTable_ nopt found - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest007, TestSize.Level1) -{ - std::map oldTable = - SandboxManagerDb::GetInstance().dataTypeToSqlTable_; - SandboxManagerDb::GetInstance().dataTypeToSqlTable_ = {}; - EXPECT_EQ(SandboxManagerDb::FAILURE, SandboxManagerDb::GetInstance().CreatePersistedPolicyTable()); - std::vector column; - GenericValues symbol; - std::string ret = SandboxManagerDb::GetInstance().CreateSelectPrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, column, symbol); - EXPECT_TRUE(ret.empty()); - - std::vector conditionColumns; - std::vector modifyColumns; - modifyColumns.emplace_back("test"); - ret = SandboxManagerDb::GetInstance().CreateUpdatePrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, modifyColumns, conditionColumns); - EXPECT_TRUE(ret.empty()); - - ret = SandboxManagerDb::GetInstance().CreateDeletePrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, conditionColumns); - EXPECT_TRUE(ret.empty()); - - ret = SandboxManagerDb::GetInstance().CreateInsertPrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, "ignore"); - EXPECT_TRUE(ret.empty()); - SandboxManagerDb::GetInstance().dataTypeToSqlTable_ = oldTable; -} - -/** - * @tc.name: SandboxManagerDbTest008 - * @tc.desc: Test when dataTypeToSqlTable_ nopt found - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest008, TestSize.Level1) -{ - std::vector column = {"test"}; // this is a test - GenericValues symbol; - symbol.Put("test", ">"); // unrecognize symbol - std::string ret = SandboxManagerDb::GetInstance().CreateSelectPrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, column, symbol); - EXPECT_TRUE(ret.empty()); -} - -/** - * @tc.name: SandboxManagerDbTest009 - * @tc.desc: Test when dataTypeToSqlTable_ nopt found - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(SandboxManagerDbTest, SandboxManagerDbTest009, TestSize.Level1) -{ - std::vector modifyColumns; - std::vector conditionColumns; - std::string ret = SandboxManagerDb::GetInstance().CreateUpdatePrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, modifyColumns, conditionColumns); - EXPECT_TRUE(ret.empty()); - - modifyColumns.emplace_back("test0"); - modifyColumns.emplace_back("test1"); - ret = SandboxManagerDb::GetInstance().CreateUpdatePrepareSqlCmd( - SandboxManagerDb::SANDBOX_MANAGER_PERSISTED_POLICY, modifyColumns, conditionColumns); - std::string ok = "update persisted_policy_table set test0=:test0,test1=:test1"; - EXPECT_EQ(ok, ret); -} } // SandboxManager } // AccessControl } // OHOS \ No newline at end of file diff --git a/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp b/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp index 3e0c93853c50a9a16ad17d3a607e114027eefe32..bc741fb24bc395fa2fe7c5321e0e3411f9f220ee 100644 --- a/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp +++ b/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp @@ -24,7 +24,7 @@ #include "policy_info_parcel.h" #include "policy_info_vector_parcel.h" #include "sandbox_manager_const.h" -#include "sandbox_manager_db.h" +#include "sandbox_manager_rdb.h" #include "sandbox_manager_err_code.h" #include "sandbox_manager_event_subscriber.h" #define private public diff --git a/test/fuzztest/services/sandbox_manager/sandbox_manager_service_fuzz.gni b/test/fuzztest/services/sandbox_manager/sandbox_manager_service_fuzz.gni index 93bf102b7b2a34afa80dde8c98cc93baa966f89c..814a51147a4d1a9c5a106566efd36fe3f0ea3836 100644 --- a/test/fuzztest/services/sandbox_manager/sandbox_manager_service_fuzz.gni +++ b/test/fuzztest/services/sandbox_manager/sandbox_manager_service_fuzz.gni @@ -31,7 +31,9 @@ sandbox_manager_sources = [ "${sandbox_manager_path}/services/common/database/src/statement.cpp", "${sandbox_manager_path}/services/common/database/src/variant_value.cpp", "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/policy_field_const.cpp", - "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/sandbox_manager_db.cpp", + "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb.cpp", + "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_open_callback.cpp", + "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/database/sandbox_manager_rdb_utils.cpp", "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/mac/mac_adapter.cpp", "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/sensitive/sandbox_manager_event_subscriber.cpp", "${sandbox_manager_path}/services/sandbox_manager/main/cpp/src/service/policy_info_manager.cpp", @@ -59,6 +61,7 @@ sandbox_manager_external_deps = [ "eventhandler:libeventhandler", "hilog:libhilog", "ipc:ipc_core", + "relational_store:native_rdb", "safwk:system_ability_fwk", "samgr:samgr_proxy", "sqlite:sqlite",