diff --git a/BUILD.gn b/BUILD.gn index f6e0977..520ab4d 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -23,6 +23,7 @@ group("app_domain_verify_packages") { "frameworks/common:app_domain_verify_frameworks_common", "frameworks/extension:app_domain_verify_extension_framework", "frameworks/verifier:app_domain_verify_agent_verifier", + "frameworks/app_details_rdb:app_domain_verify_app_details_rdb", "interfaces/inner_api/client:app_domain_verify_agent_client", "interfaces/inner_api/client:app_domain_verify_mgr_client", "interfaces/inner_api/common:app_domain_verify_common", diff --git a/app_domain_verify.gni b/app_domain_verify.gni index 3c8701f..32e7473 100644 --- a/app_domain_verify.gni +++ b/app_domain_verify.gni @@ -39,4 +39,7 @@ app_domain_verify_frameworks_common_path = app_domain_verify_frameworks_verifier_path = "${app_domain_verify_root_path}/frameworks/verifier" +app_domain_verify_frameworks_app_details_rdb_path = + "${app_domain_verify_root_path}/frameworks/app_details_rdb" + app_domain_verify_test_path = "${app_domain_verify_root_path}/test/unittest" diff --git a/bundle.json b/bundle.json index 58f3140..34c079f 100644 --- a/bundle.json +++ b/bundle.json @@ -133,6 +133,17 @@ ], "header_base": "//foundation/bundlemanager/app_domain_verify/frameworks/verifier/include" } + }, + { + "name": "//foundation/bundlemanager/app_domain_verify/frameworks/app_details_rdb:app_domain_verify_app_details_rdb", + "header": { + "header_files": [ + "app_details_rdb_data_define.h", + "app_details_rdb_data_manager.h", + "app_details_rdb_open_callback.h" + ], + "header_base": "//foundation/bundlemanager/app_domain_verify/frameworks/app_details_rdb/include" + } } ], "test": [ diff --git a/frameworks/app_details_rdb/BUILD.gn b/frameworks/app_details_rdb/BUILD.gn new file mode 100644 index 0000000..05afe21 --- /dev/null +++ b/frameworks/app_details_rdb/BUILD.gn @@ -0,0 +1,76 @@ +# 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. + +import("//build/ohos.gni") +import("//foundation/bundlemanager/app_domain_verify/app_domain_verify.gni") + +config("app_domain_verify_app_details_rdb_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${app_domain_verify_frameworks_common_path}/include" + ] + configs = [ "//build/config/compiler:exceptions" ] + ldflags = [ "-Wl,--exclude-libs=ALL" ] + cflags = [ + "-fdata-sections", + "-ffunction-sections", + "-fstack-protector-strong", + "-D_FORTIFY_SOURCE=2", + "-Os", + ] + + cflags_cc = [ "-Os" ] +} + +ohos_shared_library("app_domain_verify_app_details_rdb") { + branch_protector_ret = "pac_ret" + sources = [ + "src/app_details_rdb_data_manager.cpp", + "src/app_details_rdb_open_callback.cpp", + "src/app_details_meta_item.cpp", + "src/app_details_rdb_item.cpp" + ] + public_configs = [ ":app_domain_verify_app_details_rdb_config" ] + + external_deps = [ + "ability_base:base", + "ability_base:want", + "ability_runtime:ability_manager", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "curl:curl_shared", + "eventhandler:libeventhandler", + "ffrt:libffrt", + "hilog:libhilog", + "hisysevent:libhisysevent", + "ipc:ipc_core", + "json:nlohmann_json_static", + "netstack:http_client", + "os_account:os_account_innerkits", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + defines = [] + if (build_variant == "user") { + defines += [ "IS_RELEASE_VERSION" ] + } + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + subsystem_name = "bundlemanager" + part_name = "app_domain_verify" +} diff --git a/frameworks/app_details_rdb/appdetailsrdb.versionscript b/frameworks/app_details_rdb/appdetailsrdb.versionscript new file mode 100644 index 0000000..251a3e3 --- /dev/null +++ b/frameworks/app_details_rdb/appdetailsrdb.versionscript @@ -0,0 +1,19 @@ +# 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. + +1.0 { + global: + *; + local: + *; +}; \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_base_item.h b/frameworks/app_details_rdb/include/app_details_base_item.h new file mode 100644 index 0000000..c6f68df --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_base_item.h @@ -0,0 +1,33 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_BASE_ITEM_H +#define APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_BASE_ITEM_H +#include +#include +#include "rdb_store.h" + +namespace OHOS { +namespace AppDomainVerify { +using namespace NativeRdb; +class AppDetailsBaseItem { +public: + virtual ~AppDetailsBaseItem() = default; + virtual bool GetRdbItem(std::shared_ptr& retSet) = 0; + virtual void AddRdbItemToBucket(NativeRdb::ValuesBucket& bucket) = 0; +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_meta_item.h b/frameworks/app_details_rdb/include/app_details_meta_item.h new file mode 100644 index 0000000..53baedd --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_meta_item.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_META_ITEM_H +#define APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_META_ITEM_H +#include "app_details_base_item.h" +namespace OHOS { +namespace AppDomainVerify { +class MetaItem : public AppDetailsBaseItem { +public: + bool GetRdbItem(std::shared_ptr& retSet) override; + void AddRdbItemToBucket(NativeRdb::ValuesBucket& bucket) override; +public: + std::string tableName; + std::string tableVersion; + std::string tableExtInfo; + std::string updateTime; +}; +} +} + + +#endif \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_rdb_const_define.h b/frameworks/app_details_rdb/include/app_details_rdb_const_define.h new file mode 100644 index 0000000..e57fea5 --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_rdb_const_define.h @@ -0,0 +1,57 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_CONST_DEFINE_H +#define APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_CONST_DEFINE_H +#include +#include + +namespace OHOS { +namespace AppDomainVerify { + +const std::string DETAILS_ID = "ID"; +const std::string DETAILS_SCHEME = "SCHEME"; +const std::string DETAILS_DOMAIN = "DOMAIN"; +const std::string DETAILS_PATH_TYPE = "PATH_TYPE"; +const std::string DETAILS_PATH = "PATH"; +const std::string DETAILS_BUNDLE_NAME = "BUNDLE_NAME"; +const int32_t DETAILS_ID_INDEX = 0; +const int32_t DETAILS_SCHEME_INDEX = 1; +const int32_t DETAILS_DOMAIN_INDEX = 2; +const int32_t DETAILS_PATH_TYPE_INDEX = 3; +const int32_t DETAILS_PATH_INDEX = 4; +const int32_t DETAILS_BUNDLE_NAME_INDEX = 5; + +const std::string META_TABLE_NAME = "TABLE_NAME"; +const std::string META_TABLE_VERSION = "TABLE_VERSION"; +const std::string META_TABLE_EXT_INFO = "TABLE_EXT_INFO"; +const std::string META_UPDATE_TIME = "UPDATE_TIME"; +const int32_t META_TABLE_NAME_INDEX = 0; +const int32_t META_TABLE_VERSION_INDEX = 1; +const int32_t META_TABLE_EXT_INFO_INDEX = 2; +const int32_t META_UPDATE_TIME_INDEX = 3; + +constexpr int32_t CLOSE_DELAY_TIME_S = 20000; // 20s +const std::string CLOSE_TASK_ID = "closeRdb"; +const std::string APP_DETAILS_TABLE = "APP_DETAILS"; +const std::string META_DATA = "META_DATA"; +const std::string APP_DETAILS_RDB_PATH = "/data/service/el1/public/app_domain_verify_agent_service/"; +const std::string APP_DETAILS_RDB_NAME = "appDetails.db"; +const int APP_DETAILS_RDB_VERSION = 1; + +} +} + +#endif \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_rdb_data_define.h b/frameworks/app_details_rdb/include/app_details_rdb_data_define.h new file mode 100644 index 0000000..cbe0bc4 --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_rdb_data_define.h @@ -0,0 +1,42 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_INCLUDE_RDB_DATA_DEFINE_H +#define APP_DOMAIN_VERIFY_SERVICE_INCLUDE_RDB_DATA_DEFINE_H +#include +#include +#include "app_details_base_item.h" +#include "app_details_meta_item.h" +#include "app_details_rdb_item.h" + +namespace OHOS { +namespace AppDomainVerify { +using TransCallback = std::function; +const static std::string PATH = "path"; +const static std::string PATH_START_WITH = "pathStartWith"; +const static std::string PATH_REGEX = "pathRegex"; + +struct RdbConfigInfo { + std::string rdbPath; + std::string rdbName; + int version = 0; + bool fileCreated = true; +}; + + +} +} + +#endif // APP_DOMAIN_VERIFY_SERVICE_INCLUDE_RDB_DATA_MANAGER_H \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_rdb_data_manager.h b/frameworks/app_details_rdb/include/app_details_rdb_data_manager.h new file mode 100644 index 0000000..b7578b0 --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_rdb_data_manager.h @@ -0,0 +1,62 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_INCLUDE_APP_DETAILS_RDB_DATA_MANAGER_H +#define APP_DOMAIN_VERIFY_SERVICE_INCLUDE_APP_DETAILS_RDB_DATA_MANAGER_H + +#include +#include "cpp/mutex.h" +#include "event_handler.h" +#include "rdb_store.h" +#include "values_bucket.h" +#include "app_details_rdb_data_define.h" +#include "ffrt.h" + +namespace OHOS { +namespace AppDomainVerify { +using RdbForEachRetCb = std::function retSet)>; +class AppDetailsRdbDataMgr : public std::enable_shared_from_this { +public: + AppDetailsRdbDataMgr(bool createFile); + AppDetailsRdbDataMgr(const RdbConfigInfo& info); + virtual ~AppDetailsRdbDataMgr(); + bool ExecWithTrans(TransCallback cb); + bool InsertDataBatch(const std::string& tableName, std::vector& itemVec); + bool QueryDataByDomain(const std::string& tableName, + const std::string& domain, std::vector& itemVec); + bool UpdateMetaData(std::vector& item); + bool QueryMetaData(const std::string& tableName, MetaItem& info); + bool CreateMetaData(); + bool CreateTable(const std::string& tableName); + bool DeleteTable(const std::string& tableName); + bool RenameTable(const std::string& oldName, const std::string& newName); + std::string GetDbVersion(); +private: + void PostDelayCloseTask(int32_t delayTime); + bool Query(const NativeRdb::AbsRdbPredicates& predicates, + const std::vector& columns, RdbForEachRetCb cb); + bool CheckRdbReturnIfOk(int errcode); + std::shared_ptr GetRdbStore(); +private: + ffrt::mutex mtx_; + std::shared_ptr rdbStore_; + RdbConfigInfo conf_; + std::shared_ptr closeHandler_; + std::shared_ptr runner_; +}; + +} // namespace AppDomainVerify +} // namespace OHOS +#endif diff --git a/frameworks/app_details_rdb/include/app_details_rdb_item.h b/frameworks/app_details_rdb/include/app_details_rdb_item.h new file mode 100644 index 0000000..49ac740 --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_rdb_item.h @@ -0,0 +1,38 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_RDB_ITEM_H +#define APP_DOMAIN_VERIFY_SERVICE_APP_DETAILS_RDB_ITEM_H +#include +#include "app_details_base_item.h" +namespace OHOS { +namespace AppDomainVerify { +class AppDetailsRdbItem :public AppDetailsBaseItem { +public: + bool GetRdbItem(std::shared_ptr& retSet) override; + void AddRdbItemToBucket(NativeRdb::ValuesBucket& bucket) override; +public: + std::string id; + std::string scheme; + std::string domain; + std::string pathType; + std::string path; + std::string bundleName; +}; +} +} + + +#endif \ No newline at end of file diff --git a/frameworks/app_details_rdb/include/app_details_rdb_open_callback.h b/frameworks/app_details_rdb/include/app_details_rdb_open_callback.h new file mode 100644 index 0000000..de4b0db --- /dev/null +++ b/frameworks/app_details_rdb/include/app_details_rdb_open_callback.h @@ -0,0 +1,38 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_SERVICE_INCLUDE_APP_DETAILS_RDB_OPEN_CALLBACK_H +#define APP_DOMAIN_VERIFY_SERVICE_INCLUDE_APP_DETAILS_RDB_OPEN_CALLBACK_H + +#include "app_details_rdb_data_define.h" +#include "rdb_errno.h" +#include "rdb_open_callback.h" + +namespace OHOS { +namespace AppDomainVerify { +class AppDetailsRdbOpenCallback : public NativeRdb::RdbOpenCallback { +public: + AppDetailsRdbOpenCallback(const RdbConfigInfo &rdbConfig); + int32_t OnCreate(NativeRdb::RdbStore &rdbStore) override; + int32_t OnUpgrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion) override; + int32_t OnDowngrade(NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion) override; + int32_t OnOpen(NativeRdb::RdbStore &rdbStore) override; + int32_t onCorruption(std::string databaseFile) override; +private: + RdbConfigInfo m_conf; +}; +} // namespace AppDomainVerify +} // namespace OHOS +#endif // APP_DOMAIN_VERIFY_SERVICE_INCLUDE_APP_DETAILS_RDB_OPEN_CALLBACK_H diff --git a/frameworks/app_details_rdb/src/app_details_meta_item.cpp b/frameworks/app_details_rdb/src/app_details_meta_item.cpp new file mode 100644 index 0000000..fdcaab9 --- /dev/null +++ b/frameworks/app_details_rdb/src/app_details_meta_item.cpp @@ -0,0 +1,55 @@ +/* + * 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 "app_details_meta_item.h" +#include "app_details_rdb_const_define.h" + +namespace OHOS { +namespace AppDomainVerify { + +bool MetaItem::GetRdbItem(std::shared_ptr &retSet) +{ + int errCode = NativeRdb::E_OK; + errCode = retSet->GetString(META_TABLE_NAME_INDEX, tableName); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(META_TABLE_VERSION_INDEX, tableVersion); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(META_TABLE_EXT_INFO_INDEX, tableExtInfo); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(META_UPDATE_TIME_INDEX, updateTime); + if (errCode != NativeRdb::E_OK) { + return false; + } + return true; +}; + +void MetaItem::AddRdbItemToBucket(NativeRdb::ValuesBucket &bucket) +{ + bucket.PutString(META_TABLE_NAME, tableName); + bucket.PutString(META_TABLE_VERSION, tableVersion); + bucket.PutString(META_TABLE_EXT_INFO, tableExtInfo); + bucket.PutString(META_UPDATE_TIME, updateTime); +}; + + + +} +} diff --git a/frameworks/app_details_rdb/src/app_details_rdb_data_manager.cpp b/frameworks/app_details_rdb/src/app_details_rdb_data_manager.cpp new file mode 100644 index 0000000..3f3c701 --- /dev/null +++ b/frameworks/app_details_rdb/src/app_details_rdb_data_manager.cpp @@ -0,0 +1,352 @@ +/* + * 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 "app_details_rdb_data_manager.h" +#include "app_details_base_item.h" +#include "app_details_meta_item.h" +#include "app_details_rdb_data_define.h" +#include "app_details_rdb_item.h" +#include "app_details_rdb_open_callback.h" +#include "app_domain_verify_hilog.h" +#include "cpp/mutex.h" +#include "rdb_errno.h" +#include "rdb_store.h" +#include "values_bucket.h" +#include "rdb_helper.h" +#include +#include +#include +#include +#include "app_details_rdb_const_define.h" + +namespace OHOS { +namespace AppDomainVerify { +AppDetailsRdbDataMgr::AppDetailsRdbDataMgr(bool isCreated) +{ + conf_.rdbName = APP_DETAILS_RDB_NAME; + conf_.rdbPath = APP_DETAILS_RDB_PATH; + conf_.version = APP_DETAILS_RDB_VERSION; + conf_.fileCreated = isCreated; +}; + +AppDetailsRdbDataMgr::AppDetailsRdbDataMgr(const RdbConfigInfo& info) +{ + conf_ = info; +}; + +AppDetailsRdbDataMgr::~AppDetailsRdbDataMgr() +{ + closeHandler_->RemoveTask(CLOSE_TASK_ID); +}; + +bool AppDetailsRdbDataMgr::ExecWithTrans(TransCallback cb) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call"); + auto rdbStore = GetRdbStore(); + auto ret = rdbStore->BeginTransaction(); + if (ret != NativeRdb::E_OK) { + return false; + } + if (cb()) { + ret = rdbStore->Commit(); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "commit err:%{public}d", ret); + return false; + } + return true; + } + ret = rdbStore->RollBack(); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "roll err:%{public}d.", ret); + } + return false; +} + +bool AppDetailsRdbDataMgr::QueryDataByDomain(const std::string& tableName, const std::string &domain, std::vector &itemVec) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call."); + NativeRdb::AbsRdbPredicates absRdbPred(tableName); + absRdbPred.EqualTo(DETAILS_DOMAIN, domain); + std::vector columns = {}; + RdbForEachRetCb eachCb = [&itemVec](std::shared_ptr retSet)->bool { + AppDetailsRdbItem item; + if (!item.GetRdbItem(retSet)) { + return false; + } + itemVec.emplace_back(item); + return true; + }; + return Query(absRdbPred, columns, eachCb); +} + +void AppDetailsRdbDataMgr::PostDelayCloseTask(int32_t delayTime) +{ + if (runner_ == nullptr) { + runner_ = AppExecFwk::EventRunner::Create("closeRdb", AppExecFwk::ThreadMode::FFRT); + } + if (closeHandler_ == nullptr) { + closeHandler_ = std::make_shared(runner_); + } + if (closeHandler_ == nullptr) { + return; + } + std::weak_ptr weakPtr = shared_from_this(); + auto task = [weakPtr]() { + auto appDetailsRdbMgr = weakPtr.lock(); + if (appDetailsRdbMgr != nullptr) { + std::lock_guard lock(appDetailsRdbMgr->mtx_); + appDetailsRdbMgr->rdbStore_ = nullptr; + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "rdb close"); + } + return; + }; + closeHandler_->RemoveTask(CLOSE_TASK_ID); + closeHandler_->PostTask(task, CLOSE_TASK_ID, delayTime); + return; +} + +bool AppDetailsRdbDataMgr::InsertDataBatch(const std::string& tableName, std::vector& infoVec) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + std::vector rows; + for (auto& info : infoVec) { + NativeRdb::ValuesBucket valuesBucket; + info.AddRdbItemToBucket(valuesBucket); + rows.emplace_back(valuesBucket); + } + int64_t num = 0; + return CheckRdbReturnIfOk(rdbStore_->BatchInsert(num, tableName, rows)); +}; + +bool AppDetailsRdbDataMgr::CreateMetaData() +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + std::string sql = "CREATE TABLE IF NOT EXISTS " + META_DATA + + "(" + "TABLE_NAME TEXT NOT NULL PRIMARY KEY," + "TABLE_VERSION TEXT," + "TABLE_EXT_INFO TEXT," + "UPDATE_TIME TEXT" + ");"; + auto ret = rdbStore->ExecuteSql(sql); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "exec sql fail. ret:%{public}d", ret); + return false; + } + return true; +}; + +bool AppDetailsRdbDataMgr::UpdateMetaData(std::vector &itemVec) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + for (auto&item : itemVec) { + NativeRdb::ValuesBucket valuesBucket; + item.AddRdbItemToBucket(valuesBucket); + int64_t rowId = 0; + auto ret = rdbStore->InsertWithConflictResolution( + rowId, META_DATA, valuesBucket, + NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE); + if (ret != NativeRdb::E_OK) { + return CheckRdbReturnIfOk(ret); + } + } + return true; +}; + +bool AppDetailsRdbDataMgr::QueryMetaData(const std::string &tableName, MetaItem &info) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call."); + NativeRdb::AbsRdbPredicates absRdbPred(META_DATA); + absRdbPred.EqualTo(META_TABLE_NAME, tableName); + std::vector columns = {}; + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + std::vector itemVec; + RdbForEachRetCb eachCb = [&itemVec](std::shared_ptr retSet)->bool { + MetaItem item; + if (!item.GetRdbItem(retSet)) { + return false; + } + itemVec.emplace_back(item); + return true; + }; + + if(Query(absRdbPred, columns, eachCb)) { + info = itemVec.front(); + return true; + }; + return false; +}; + +bool AppDetailsRdbDataMgr::CreateTable(const std::string &tableName) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + std::string sql = "CREATE TABLE IF NOT EXISTS " + tableName + + " (" + "ID TEXT NOT NULL PRIMARY KEY," + "SCHEME TEXT," + "DOMAIN TEXT," + "PATH_TYPE TEXT," + "PATH TEXT," + "BUNDLE_NAME TEXT" + + " );"; + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + auto ret = rdbStore->ExecuteSql(sql); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "exec sql fail. ret:%{public}d", ret); + return false; + } + return true; +}; + +bool AppDetailsRdbDataMgr::DeleteTable(const std::string &tableName) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "Called"); + std::string sql = "DROP TABLE IF EXISTS " + tableName + ";"; + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "Get rdbStore fail."); + return false; + } + auto ret = rdbStore->ExecuteSql(sql); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "Exec sql fail. ret:%{public}d", ret); + return false; + } + return true; +}; + +std::string AppDetailsRdbDataMgr::GetDbVersion() +{ + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return ""; + } + int version = -1; + rdbStore->GetVersion(version); + if (version != -1) { + return std::to_string(version); + } + return ""; +}; + +bool AppDetailsRdbDataMgr::RenameTable(const std::string &oldName, const std::string &newName) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + std::string sql = "ALTER TABLE " + oldName + " RENAME TO " + newName + ";"; + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore fail."); + return false; + } + auto ret = rdbStore->ExecuteSql(sql); + if (ret != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "exec sql fail. ret:%{public}d", ret); + return false; + } + return true; +}; + +std::shared_ptr AppDetailsRdbDataMgr::GetRdbStore() +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + std::lock_guard lock(mtx_); + if (rdbStore_ != nullptr) { + return rdbStore_; + } + NativeRdb::RdbStoreConfig rdbStoreConfig(conf_.rdbPath + conf_.rdbName); + rdbStoreConfig.SetCreateNecessary(conf_.fileCreated); + rdbStoreConfig.SetSecurityLevel(NativeRdb::SecurityLevel::S1); + int32_t errCode = NativeRdb::E_OK; + AppDetailsRdbOpenCallback appDomainVerifyRdbOpenCallback(conf_); + rdbStore_ = NativeRdb::RdbHelper::GetRdbStore( + rdbStoreConfig, conf_.version, appDomainVerifyRdbOpenCallback, errCode); + if (errCode == NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "get rdbStore success."); + PostDelayCloseTask(CLOSE_DELAY_TIME_S); + } + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "end, errCode:%{public}d", errCode); + return rdbStore_; +}; + +bool AppDetailsRdbDataMgr::CheckRdbReturnIfOk(int errcode) +{ + if (errcode != NativeRdb::E_OK) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "rdb failed, ret: %{public}d", errcode); + return false; + } + return true; +} + +bool AppDetailsRdbDataMgr::Query(const NativeRdb::AbsRdbPredicates& predicates, + const std::vector& columns, RdbForEachRetCb cb) +{ + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + auto rdbStore = GetRdbStore(); + if (!rdbStore) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "rdb store is null"); + return false; + } + auto absSharedResultSet = rdbStore->Query(predicates, columns); + if (absSharedResultSet == nullptr) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "rdbStore query absSharedResultSet failed"); + return false; + } + auto guard = std::unique_ptr>( + nullptr, [&](void*){ absSharedResultSet->Close(); } + ); + if (!absSharedResultSet->HasBlock()) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "absSharedResultSet has no block"); + return false; + } + if (CheckRdbReturnIfOk(absSharedResultSet->GoToFirstRow())) { + do { + if(!cb(absSharedResultSet)) { + return false; + } + } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK); + } else { + APP_DOMAIN_VERIFY_HILOGW(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "GoToFirstRow fail, seems rdb table empty"); + return false; + } + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end"); + return true; +}; + +} +} diff --git a/frameworks/app_details_rdb/src/app_details_rdb_item.cpp b/frameworks/app_details_rdb/src/app_details_rdb_item.cpp new file mode 100644 index 0000000..9945751 --- /dev/null +++ b/frameworks/app_details_rdb/src/app_details_rdb_item.cpp @@ -0,0 +1,64 @@ +/* + * 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 "app_details_rdb_item.h" +#include "app_details_rdb_const_define.h" +#include "rdb_errno.h" +namespace OHOS { +namespace AppDomainVerify { + +bool AppDetailsRdbItem::GetRdbItem(std::shared_ptr &retSet) +{ + int errCode = NativeRdb::E_OK; + errCode = retSet->GetString(DETAILS_ID_INDEX, id); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(DETAILS_SCHEME_INDEX, scheme); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(DETAILS_DOMAIN_INDEX, domain); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(DETAILS_PATH_TYPE_INDEX, pathType); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(DETAILS_PATH_INDEX, path); + if (errCode != NativeRdb::E_OK) { + return false; + } + errCode = retSet->GetString(DETAILS_BUNDLE_NAME_INDEX, bundleName); + if (errCode != NativeRdb::E_OK) { + return false; + } + return true; +}; + +void AppDetailsRdbItem::AddRdbItemToBucket(NativeRdb::ValuesBucket &bucket) +{ + bucket.PutString(DETAILS_ID, id); + bucket.PutString(DETAILS_SCHEME, scheme); + bucket.PutString(DETAILS_DOMAIN, domain); + bucket.PutString(DETAILS_PATH_TYPE, pathType); + bucket.PutString(DETAILS_PATH, path); + bucket.PutString(DETAILS_BUNDLE_NAME, bundleName); +} + + +} +} \ No newline at end of file diff --git a/frameworks/app_details_rdb/src/app_details_rdb_open_callback.cpp b/frameworks/app_details_rdb/src/app_details_rdb_open_callback.cpp new file mode 100644 index 0000000..2eb358a --- /dev/null +++ b/frameworks/app_details_rdb/src/app_details_rdb_open_callback.cpp @@ -0,0 +1,55 @@ +/* + * 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 "app_details_rdb_open_callback.h" +#include "app_details_rdb_data_define.h" +#include "app_domain_verify_hilog.h" +#include "rdb_errno.h" + +namespace OHOS { +namespace AppDomainVerify { +AppDetailsRdbOpenCallback::AppDetailsRdbOpenCallback(const RdbConfigInfo& conf) + : m_conf(conf) +{ +} + +int32_t AppDetailsRdbOpenCallback::OnCreate(NativeRdb::RdbStore& rdbStore) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "RdbStore OnCreate"); + return NativeRdb::E_OK; +} +int32_t AppDetailsRdbOpenCallback::OnUpgrade(NativeRdb::RdbStore& rdbStore, int currentVersion, int targetVersion) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, + "OnUpgrade currentVersion: %{public}d, targetVersion: %{public}d", currentVersion, targetVersion); + return NativeRdb::E_OK; +} +int32_t AppDetailsRdbOpenCallback::OnDowngrade( + NativeRdb::RdbStore& rdbStore, int currentVersion, int targetVersion) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, + "OnDowngrade currentVersion: %{plubic}d, targetVersion: %{plubic}d", currentVersion, targetVersion); + return NativeRdb::E_OK; +} +int32_t AppDetailsRdbOpenCallback::OnOpen(NativeRdb::RdbStore& rdbStore) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "RdbStore OnOpen"); + return NativeRdb::E_OK; +} +int32_t AppDetailsRdbOpenCallback::onCorruption(std::string databaseFile) +{ + return NativeRdb::E_OK; +} +} // namespace AppDomainVerify +} // namespace OHOS diff --git a/frameworks/common/include/app_domain_verify_parcel_util.h b/frameworks/common/include/app_domain_verify_parcel_util.h index a161380..08d5872 100644 --- a/frameworks/common/include/app_domain_verify_parcel_util.h +++ b/frameworks/common/include/app_domain_verify_parcel_util.h @@ -18,7 +18,7 @@ #include "app_domain_verify_hilog.h" #include "comm_define.h" #include "string_ex.h" - +namespace OHOS::AppDomainVerify { #define WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(type, parcel, data) \ do { \ if (!(parcel).Write##type(data)) { \ @@ -58,7 +58,7 @@ return false; \ } \ } while (0) - +} #define MAX_PARCEL_ARRAY_SIZE (99) namespace OHOS::AppDomainVerify { template diff --git a/frameworks/common/include/utils/lru_cache_util.h b/frameworks/common/include/utils/lru_cache_util.h new file mode 100644 index 0000000..cc89e67 --- /dev/null +++ b/frameworks/common/include/utils/lru_cache_util.h @@ -0,0 +1,93 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_APP_DETAILS_LRU_H +#define APP_DOMAIN_VERIFY_APP_DETAILS_LRU_H + +#include +#include +#include +#include +#include + +namespace OHOS { +namespace AppDomainVerify { +template +class LruCacheUtil { +public: + LruCacheUtil() = default; + LruCacheUtil(int maxCap):maxCap_(maxCap){}; + bool SetMaxCap(int cap); + bool Get(const K& key, V& value); + void Put(const K& key, const V& value); + void Clear(); + bool IsEmpty(); +private: + std::atomic maxCap_ = 10; + std::list> m_cache; + std::unordered_map>::iterator> lruMap_; +}; + +template +bool LruCacheUtil::SetMaxCap(int cap) { + maxCap_ = cap; +}; + +template +bool LruCacheUtil::Get(const K& key, V& value) { + if (lruMap_.find(key) == lruMap_.end()) { + return false; + } + value = lruMap_[key]->second; + m_cache.erase(lruMap_[key]); + m_cache.push_front({key, value}); + lruMap_[key] = m_cache.begin(); + return true; +}; + +template +void LruCacheUtil::Put(const K& key, const V& value) { + auto iter = lruMap_.find(key); + if (iter != lruMap_.end()) { + V val = lruMap_[key]->second; + m_cache.erase(iter->second); + m_cache.push_front({key, val}); + lruMap_[key] = m_cache.begin(); + return; + } + if (lruMap_.size() == maxCap_) { + lruMap_.erase(m_cache.back().first); + m_cache.pop_back(); + } + m_cache.push_front({key, value}); + lruMap_[key] = m_cache.begin(); + return; +}; + +template +void LruCacheUtil::Clear() { + m_cache.clear(); + lruMap_.clear(); +}; + +template +bool LruCacheUtil::IsEmpty() { + return lruMap_.empty(); +}; + +} +} + +#endif \ No newline at end of file diff --git a/frameworks/extension/include/app_domain_verify_agent_ext.h b/frameworks/extension/include/app_domain_verify_agent_ext.h index e461a85..dd29f4b 100644 --- a/frameworks/extension/include/app_domain_verify_agent_ext.h +++ b/frameworks/extension/include/app_domain_verify_agent_ext.h @@ -38,6 +38,7 @@ public: const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo); virtual ErrorCode ConvertToExplicitWant(OHOS::AAFwk::Want& implicitWant, sptr& callback); virtual ErrorCode UpdateWhiteList(); + virtual ErrorCode UpdateAppDetails(); }; } } diff --git a/frameworks/extension/include/app_domain_verify_extension_mgr.h b/frameworks/extension/include/app_domain_verify_extension_mgr.h index 4088556..1bb9523 100644 --- a/frameworks/extension/include/app_domain_verify_extension_mgr.h +++ b/frameworks/extension/include/app_domain_verify_extension_mgr.h @@ -38,6 +38,7 @@ public: ErrorCode SingleVerify(const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo); ErrorCode ConvertToExplicitWant(OHOS::AAFwk::Want& implicitWant, sptr& callback); ErrorCode UpdateWhiteList(); + ErrorCode UpdateAppDetails(); protected: virtual bool Init(); diff --git a/frameworks/extension/src/app_domain_verify_agent_ext.cpp b/frameworks/extension/src/app_domain_verify_agent_ext.cpp index 84e4775..7de28df 100644 --- a/frameworks/extension/src/app_domain_verify_agent_ext.cpp +++ b/frameworks/extension/src/app_domain_verify_agent_ext.cpp @@ -14,6 +14,7 @@ */ #include "app_domain_verify_agent_ext.h" +#include "app_domain_verify_error.h" namespace OHOS { namespace AppDomainVerify { @@ -35,5 +36,9 @@ ErrorCode AppDomainVerifyAgentExt::UpdateWhiteList() { return ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND; } +ErrorCode AppDomainVerifyAgentExt::UpdateAppDetails() +{ + return ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND; +} } } \ No newline at end of file diff --git a/frameworks/extension/src/app_domain_verify_extension_mgr.cpp b/frameworks/extension/src/app_domain_verify_extension_mgr.cpp index ab14a8d..fc1e5ed 100644 --- a/frameworks/extension/src/app_domain_verify_extension_mgr.cpp +++ b/frameworks/extension/src/app_domain_verify_extension_mgr.cpp @@ -16,6 +16,7 @@ #include #include #include +#include "app_domain_verify_error.h" #include "app_domain_verify_extension_mgr.h" #include "app_domain_verify_hilog.h" #include "app_domain_verify_extension_register.h" @@ -140,5 +141,21 @@ ErrorCode AppDomainVerifyExtensionMgr::UpdateWhiteList() UNIVERSAL_ERROR_EVENT(GET_EXT_FAULT); return ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND; } + +ErrorCode AppDomainVerifyExtensionMgr::UpdateAppDetails() +{ + if (Init()) { + std::string verifierExtName = APP_DOMAIN_VERIFY_AGENT_EXT_NAME; + auto appDomainVerifierExt = GetAppDomainVerifyExt(verifierExtName); + if (appDomainVerifierExt != nullptr) { + return std::static_pointer_cast(appDomainVerifierExt) + ->UpdateAppDetails(); + } + APP_DOMAIN_VERIFY_HILOGE( + APP_DOMAIN_VERIFY_MODULE_EXTENSION, "get verifierExt: %{public}s failed.", verifierExtName.c_str()); + return ErrorCode::E_EXTENSIONS_INTERNAL_ERROR; + } + return ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND; +} } } \ No newline at end of file diff --git a/interfaces/inner_api/client/include/app_domain_verify_mgr_client.h b/interfaces/inner_api/client/include/app_domain_verify_mgr_client.h index 1186d17..46036a5 100644 --- a/interfaces/inner_api/client/include/app_domain_verify_mgr_client.h +++ b/interfaces/inner_api/client/include/app_domain_verify_mgr_client.h @@ -24,6 +24,7 @@ #include "i_app_domain_verify_mgr_service.h" #include "skill_uri.h" #include "domain_verify_status.h" +#include "want.h" namespace OHOS { namespace AppDomainVerify { @@ -130,6 +131,15 @@ public: */ int QueryAssociatedBundleNames(const std::string& domain, std::vector& bundleNames); + /** + * QueryAppDetailsWant + * @descrition query app details as want. + * @param link uri. + * @param want appdetails want. + * @return int result of query. + */ + int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want); + /** * GetDeferredLink * @descrition get deferred link for app. diff --git a/interfaces/inner_api/client/src/app_domain_verify_agent_client.cpp b/interfaces/inner_api/client/src/app_domain_verify_agent_client.cpp index 15e9aa0..376aca0 100644 --- a/interfaces/inner_api/client/src/app_domain_verify_agent_client.cpp +++ b/interfaces/inner_api/client/src/app_domain_verify_agent_client.cpp @@ -12,6 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include "app_domain_verify_hilog.h" #include "if_system_ability_manager.h" #include "iservice_registry.h" #include "system_ability_definition.h" diff --git a/interfaces/inner_api/client/src/app_domain_verify_mgr_client.cpp b/interfaces/inner_api/client/src/app_domain_verify_mgr_client.cpp index 415371a..fbc60e6 100644 --- a/interfaces/inner_api/client/src/app_domain_verify_mgr_client.cpp +++ b/interfaces/inner_api/client/src/app_domain_verify_mgr_client.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include "app_domain_verify_hilog.h" #include "if_system_ability_manager.h" #include "iservice_registry.h" #include "app_domain_verify_mgr_client.h" @@ -290,6 +291,17 @@ void AppDomainVerifyMgrClient::UpdateWhiteListUrls(const std::vector autoLock(proxyLock_); + if (IsServiceAvailable()) { + return appDomainVerifyMgrServiceProxy_->QueryAppDetailsWant(link, want); + } + return CommonErrorCode::E_INTERNAL_ERR; +} + int AppDomainVerifyMgrClient::QueryAssociatedDomains(const std::string& bundleName, std::vector& domains) { APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called"); diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 00a186c..38fafff 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -19,7 +19,7 @@ config("app_domain_verify_mgr_napi_config") { "include", "${app_domain_verify_client_path}/include", "${app_domain_verify_common_path}/include", - "${app_domain_verify_common_path}/include/zidl", + "${app_domain_verify_common_path}/include/zidl" ] configs = [ "//build/config/compiler:exceptions" ] ldflags = [ "-Wl,--exclude-libs=ALL" ] @@ -53,6 +53,7 @@ ohos_shared_library("appdomainverify_napi") { ] external_deps = [ "ability_base:want", + "ability_runtime:napi_common", "bundle_framework:appexecfwk_base", "c_utils:utils", "hiappevent:hiappevent_innerapi", diff --git a/services/BUILD.gn b/services/BUILD.gn index 4e39d3e..717b5f2 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -23,6 +23,7 @@ config("app_domain_verify_service_config") { "include/manager/rdb", "include/manager/zidl", "include/manager/permission", + "include/manager/filter", "include/manager/deferred_link", "include/agent/core", "${app_domain_verify_common_path}/include", @@ -32,6 +33,7 @@ config("app_domain_verify_service_config") { "${app_domain_verify_frameworks_common_path}/include/bms", "${app_domain_verify_frameworks_common_path}/include/config", "${app_domain_verify_frameworks_common_path}/include/dfx", + "//foundation/bundlemanager/app_domain_verify/frameworks/app_details_rdb/include" ] configs = [ "//build/config/compiler:exceptions" ] ldflags = [ "-Wl,--exclude-libs=ALL" ] @@ -56,7 +58,9 @@ ohos_shared_library("app_domain_verify_mgr_service") { "${app_domain_verify_frameworks_common_path}/src/bms/bundle_info_query.cpp", "${app_domain_verify_frameworks_common_path}/src/config/white_list_config_mgr.cpp", "${app_domain_verify_frameworks_common_path}/src/utils/domain_url_util.cpp", + "src/manager/core/app_details_data_mgr.cpp", "src/manager/core/app_domain_verify_data_mgr.cpp", + "src/manager/filter/app_details_filter.cpp", "src/manager/core/app_domain_verify_mgr_service.cpp", "src/manager/deferred_link/ability_filter.cpp", "src/manager/deferred_link/deferred_link_mgr.cpp", @@ -71,6 +75,7 @@ ohos_shared_library("app_domain_verify_mgr_service") { deps = [ "${app_domain_verify_client_path}:app_domain_verify_agent_client", "${app_domain_verify_common_path}:app_domain_verify_common", + "${app_domain_verify_frameworks_app_details_rdb_path}:app_domain_verify_app_details_rdb" ] defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ] if (build_variant == "user") { @@ -117,6 +122,7 @@ config("app_domain_verify_agent_service_config") { "include/manager/core", "include/manager/zidl", "include/manager/rdb", + "include/manager/filter", "${app_domain_verify_common_path}/include", "${app_domain_verify_common_path}/include/zidl", "${app_domain_verify_frameworks_common_path}/include", @@ -125,6 +131,7 @@ config("app_domain_verify_agent_service_config") { "${app_domain_verify_frameworks_common_path}/include/config", "${app_domain_verify_frameworks_extension_path}/include", "${app_domain_verify_frameworks_verifier_path}/include", + "${app_domain_verify_frameworks_app_details_rdb_path}/include", "${app_domain_verify_frameworks_common_path}/include/dfx", ] configs = [ "//build/config/compiler:exceptions" ] @@ -162,6 +169,7 @@ ohos_shared_library("app_domain_verify_agent_service") { "${app_domain_verify_frameworks_common_path}:app_domain_verify_frameworks_common", "${app_domain_verify_frameworks_extension_path}:app_domain_verify_extension_framework", "${app_domain_verify_frameworks_verifier_path}:app_domain_verify_agent_verifier", + "${app_domain_verify_frameworks_app_details_rdb_path}:app_domain_verify_app_details_rdb" ] external_deps = [ diff --git a/services/include/agent/core/agent_interface_code.h b/services/include/agent/core/agent_interface_code.h index 0ff5c82..8157b63 100644 --- a/services/include/agent/core/agent_interface_code.h +++ b/services/include/agent/core/agent_interface_code.h @@ -18,7 +18,7 @@ namespace OHOS { namespace AppDomainVerify { enum AgentInterfaceCode { SINGLE_VERIFY = 0, - CONVERT_TO_EXPLICIT_WANT = 1, + CONVERT_TO_EXPLICIT_WANT = 1 }; } } // namespace OHOS diff --git a/services/include/agent/core/app_domain_verify_agent_service.h b/services/include/agent/core/app_domain_verify_agent_service.h index 5d4cabe..2cb40fd 100644 --- a/services/include/agent/core/app_domain_verify_agent_service.h +++ b/services/include/agent/core/app_domain_verify_agent_service.h @@ -42,7 +42,6 @@ public: API_EXPORT void SingleVerify( const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo &verifyResultInfo) override; API_EXPORT void ConvertToExplicitWant(OHOS::AAFwk::Want& implicitWant, sptr& callback) override; - protected: void OnStart(const SystemAbilityOnDemandReason& startReason) override; void OnStop() override; @@ -55,6 +54,7 @@ private: void ExecuteVerifyTask( const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo &verifyResultInfo, TaskType type); void UpdateWhiteList(); + void UpdateAppDetails(); void OnDelayUnloadSA(); void PostDelayUnloadTask(); void DoSync(const TaskType& type); diff --git a/services/include/manager/core/app_details_data_mgr.h b/services/include/manager/core/app_details_data_mgr.h new file mode 100644 index 0000000..f2bab2b --- /dev/null +++ b/services/include/manager/core/app_details_data_mgr.h @@ -0,0 +1,52 @@ +/* + * 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. + */ +#ifndef APP_DOMAIN_VERIFY_APP_DETAILS_DATA_MGR_H +#define APP_DOMAIN_VERIFY_APP_DETAILS_DATA_MGR_H + +#include "cpp/mutex.h" +#include "lru_cache_util.h" +#include "filter_define.h" +#include "app_details_filter.h" +#include "app_details_rdb_data_manager.h" +#include "want.h" +#include +#include +#include + +namespace OHOS { +namespace AppDomainVerify { +enum AppDetailsCode { + QUERY_SUCC, + QUERY_FAIL +}; + +class AppDetailsDataMgr { +public: + AppDetailsDataMgr(); + virtual ~AppDetailsDataMgr(); + int QueryAppDetailsWant(const std::string& url, AAFwk::Want& want); +private: + bool QueryAppDetailsWantByCache(const std::string& url, AAFwk::Want& want); + bool QueryAppDetailsWantByRdb(const std::string& url, AAFwk::Want& want); + void AddInfoToWant(AAFwk::Want& want, const std::string& bundleName); + std::shared_ptr> lruCache_; + std::shared_ptr rdbMgr_; + std::shared_ptr detailsFilter_; + int64_t cacheBeginTime_ = 0; + std::string agWantUrl_; +}; +} // namespace AppDomainVerify +} // namespace OHOS +#endif // APP_DETAILS_DATA_MGR_H \ No newline at end of file diff --git a/services/include/manager/core/app_domain_verify_mgr_interface_code.h b/services/include/manager/core/app_domain_verify_mgr_interface_code.h index 00a3c7a..a2372c0 100644 --- a/services/include/manager/core/app_domain_verify_mgr_interface_code.h +++ b/services/include/manager/core/app_domain_verify_mgr_interface_code.h @@ -28,7 +28,8 @@ enum AppDomainVerifyMgrInterfaceCode { UPDATE_WHITE_LIST_URLS = 8, QUERY_ASSOCIATED_DOMAINS = 9, QUERY_ASSOCIATED_BUNDLE_NAMES = 10, - GET_DEFERRED_LINK = 11 + GET_DEFERRED_LINK = 11, + QUERY_APP_DETAILS_WANT = 12 }; } } // namespace OHOS diff --git a/services/include/manager/core/app_domain_verify_mgr_service.h b/services/include/manager/core/app_domain_verify_mgr_service.h index 17ff6af..91d02ce 100644 --- a/services/include/manager/core/app_domain_verify_mgr_service.h +++ b/services/include/manager/core/app_domain_verify_mgr_service.h @@ -16,6 +16,7 @@ #ifndef APP_DOMAIN_VERIFY_MGR_SERVICE_H #define APP_DOMAIN_VERIFY_MGR_SERVICE_H +#include "app_details_data_mgr.h" #include "app_domain_verify_mgr_service_stub.h" #include "inner_verify_status.h" #include "skill_uri.h" @@ -53,6 +54,7 @@ public: API_EXPORT int QueryAssociatedBundleNames( const std::string& domain, std::vector& bundleNames) override; API_EXPORT int GetDeferredLink(std::string& link) override; + API_EXPORT int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want) override; protected: void OnDump() override; @@ -71,6 +73,7 @@ private: private: std::shared_ptr dataManager_ = nullptr; + std::shared_ptr appDetailsDataMgr_ = nullptr; bool InitConfigMgr(); std::shared_ptr whiteListConfigMgr_; std::mutex initConfigMutex_; diff --git a/services/include/manager/core/i_app_domain_verify_mgr_service.h b/services/include/manager/core/i_app_domain_verify_mgr_service.h index 9d7f09b..53716d1 100644 --- a/services/include/manager/core/i_app_domain_verify_mgr_service.h +++ b/services/include/manager/core/i_app_domain_verify_mgr_service.h @@ -44,6 +44,7 @@ public: virtual int QueryAssociatedDomains(const std::string& bundleName, std::vector& domains) = 0; virtual int QueryAssociatedBundleNames(const std::string& domain, std::vector& bundleNames) = 0; virtual int GetDeferredLink(std::string& link) = 0; + virtual int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want) = 0; DECLARE_INTERFACE_DESCRIPTOR(u"ohos.appDomainVerify.IAppDomainVerifyMgrService"); }; } // namespace AppDomainVerify diff --git a/services/include/manager/filter/app_details_filter.h b/services/include/manager/filter/app_details_filter.h new file mode 100644 index 0000000..82dc05a --- /dev/null +++ b/services/include/manager/filter/app_details_filter.h @@ -0,0 +1,31 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_APP_DETAILS_FILTER_H +#define APP_DOMAIN_VERIFY_APP_DETAILS_FILTER_H + +#include "filter_define.h" +#include "want.h" +#include + +namespace OHOS { +namespace AppDomainVerify { + class AppDetailsFilter { + public: + bool Filter(const std::vector& input, std::vector& dest, const std::string& url); + }; +} +} +#endif \ No newline at end of file diff --git a/services/include/manager/filter/filter_define.h b/services/include/manager/filter/filter_define.h new file mode 100644 index 0000000..de8e354 --- /dev/null +++ b/services/include/manager/filter/filter_define.h @@ -0,0 +1,31 @@ +/* + * 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. + */ + +#ifndef APP_DOMAIN_VERIFY_FILTER_DEFINE_H +#define APP_DOMAIN_VERIFY_FILTER_DEFINE_H + +#include "skill.h" +#include "want.h" +#include + +namespace OHOS { +namespace AppDomainVerify { + struct AppDetailInfo { + std::string m_bundleName; + AppExecFwk::SkillUri m_skillUri; + }; +} +} +#endif \ No newline at end of file diff --git a/services/include/manager/zidl/app_domain_verify_mgr_service_proxy.h b/services/include/manager/zidl/app_domain_verify_mgr_service_proxy.h index 55d5f70..e9c23c2 100644 --- a/services/include/manager/zidl/app_domain_verify_mgr_service_proxy.h +++ b/services/include/manager/zidl/app_domain_verify_mgr_service_proxy.h @@ -18,6 +18,7 @@ #include "i_app_domain_verify_mgr_service.h" #include "iremote_proxy.h" +#include "want.h" namespace OHOS { namespace AppDomainVerify { @@ -42,6 +43,7 @@ public: int QueryAssociatedDomains(const std::string& bundleName, std::vector& domains) override; int QueryAssociatedBundleNames(const std::string& domain, std::vector& bundleNames) override; int GetDeferredLink(std::string& link) override; + int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want) override; private: static inline BrokerDelegator delegator_; }; diff --git a/services/include/manager/zidl/app_domain_verify_mgr_service_stub.h b/services/include/manager/zidl/app_domain_verify_mgr_service_stub.h index 6a481ed..54c7f79 100644 --- a/services/include/manager/zidl/app_domain_verify_mgr_service_stub.h +++ b/services/include/manager/zidl/app_domain_verify_mgr_service_stub.h @@ -21,6 +21,7 @@ #include "iremote_stub.h" #include "event_handler.h" #include "event_runner.h" +#include "message_parcel.h" namespace OHOS { namespace AppDomainVerify { @@ -44,6 +45,7 @@ private: int32_t OnQueryAssociatedDomains(MessageParcel& data, MessageParcel& reply); int32_t OnQueryAssociatedBundleNames(MessageParcel& data, MessageParcel& reply); int32_t OnGetDeferredLink(MessageParcel& data, MessageParcel& reply); + int32_t OnQueryAppDetailsWant(MessageParcel& data, MessageParcel& reply); }; } // namespace AppDomainVerify } // namespace OHOS diff --git a/services/src/agent/core/app_domain_verify_agent_service.cpp b/services/src/agent/core/app_domain_verify_agent_service.cpp index c68790e..3b9f24c 100644 --- a/services/src/agent/core/app_domain_verify_agent_service.cpp +++ b/services/src/agent/core/app_domain_verify_agent_service.cpp @@ -149,6 +149,16 @@ void AppDomainVerifyAgentService::UpdateWhiteList() return; } } + +void AppDomainVerifyAgentService::UpdateAppDetails() +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called"); + if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateAppDetails()) { + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end"); + return; + } +} + // sa_main进程统一调用 void AppDomainVerifyAgentService::OnStart(const SystemAbilityOnDemandReason& startReason) { @@ -194,6 +204,7 @@ void AppDomainVerifyAgentService::DoSync(const TaskType& type) { QueryAndCompleteRefresh(type); UpdateWhiteList(); + UpdateAppDetails(); } bool AppDomainVerifyAgentService::IsNetAvailable() @@ -288,6 +299,5 @@ int AppDomainVerifyAgentService::Dump(int fd, const std::vector& (void)write(fd, dumpString.c_str(), dumpString.size()); return 0; } - } // namespace AppDomainVerify } // namespace OHOS diff --git a/services/src/manager/core/app_details_data_mgr.cpp b/services/src/manager/core/app_details_data_mgr.cpp new file mode 100644 index 0000000..e4b70dd --- /dev/null +++ b/services/src/manager/core/app_details_data_mgr.cpp @@ -0,0 +1,126 @@ +/* + * 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 "app_details_data_mgr.h" +#include "app_details_filter.h" +#include "app_details_meta_item.h" +#include "app_details_rdb_data_define.h" +#include "app_details_rdb_const_define.h" +#include "app_details_rdb_data_manager.h" +#include "comm_define.h" +#include "domain_url_util.h" +#include "app_domain_verify_hilog.h" +#include "filter_define.h" +#include "lru_cache_util.h" +#include "skill.h" +#include "want.h" +#include +#include +#include +namespace OHOS { +namespace AppDomainVerify { +const static std::string OHOS_WANT_ACTION_APPDETAILS = "ohos.want.action.appdetails"; +const static int64_t CACHE_TIME_S = 3000; +const static int MAX_CACHE_CNT = 10; +AppDetailsDataMgr::AppDetailsDataMgr() +{ + lruCache_ = std::make_shared>(MAX_CACHE_CNT); + rdbMgr_ = std::make_shared(false); +}; + +AppDetailsDataMgr::~AppDetailsDataMgr() +{}; + +int AppDetailsDataMgr::QueryAppDetailsWant(const std::string &url, AAFwk::Want& want) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call, url:%{public}s", url.c_str()); + if (QueryAppDetailsWantByCache(url, want)) { + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "query success from cache"); + return QUERY_SUCC; + } + if (QueryAppDetailsWantByRdb(url, want)) { + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "query success from rdb"); + return QUERY_SUCC; + } + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "query fail."); + return QUERY_FAIL; +}; + +bool AppDetailsDataMgr::QueryAppDetailsWantByCache(const std::string& url, AAFwk::Want& want) +{ + int64_t currTime = std::chrono::time_point_cast(std::chrono::system_clock::now()) + .time_since_epoch() + .count(); + if (currTime - cacheBeginTime_ > CACHE_TIME_S) { + cacheBeginTime_ = currTime; + lruCache_->Clear(); + return false; + } + std::string value; + if (lruCache_->Get(url, value)) { + AddInfoToWant(want, value); + return true; + } + return false; +}; + +bool AppDetailsDataMgr::QueryAppDetailsWantByRdb(const std::string& url, AAFwk::Want& want) +{ + std::vector rdbDetails; + std::string domain = UrlUtil::GetHost(url); + if (!rdbMgr_->QueryDataByDomain(APP_DETAILS_TABLE, domain, rdbDetails)) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_EXTENSION, "query fail."); + return false; + } + std::vector appDetails; + std::vector appDetailsRet; + for (auto& detail : rdbDetails) { + AppDetailInfo info; + info.m_bundleName = detail.bundleName; + info.m_skillUri.host = detail.domain; + info.m_skillUri.scheme = detail.scheme; + if (detail.pathType == PATH) { + info.m_skillUri.path = detail.path; + } + if (detail.pathType == PATH_START_WITH) { + info.m_skillUri.pathStartWith = detail.path; + } + if (detail.pathType == PATH_REGEX) { + info.m_skillUri.pathRegex = detail.path; + } + appDetails.emplace_back(info); + } + if (!detailsFilter_->Filter(appDetails, appDetailsRet, url)) { + return false; + } + AddInfoToWant(want, appDetailsRet.front().m_bundleName); + lruCache_->Put(url, appDetailsRet.front().m_bundleName); + return true; +}; + +void AppDetailsDataMgr::AddInfoToWant(AAFwk::Want& want, const std::string& bundleName) +{ + MetaItem info; + if (agWantUrl_.empty()) { + rdbMgr_->QueryMetaData(APP_DETAILS_TABLE, info); + agWantUrl_ = info.tableExtInfo; + } + want.SetAction(OHOS_WANT_ACTION_APPDETAILS); + want.SetUri(agWantUrl_ + bundleName); + return; +}; + +} +} \ No newline at end of file diff --git a/services/src/manager/core/app_domain_verify_mgr_service.cpp b/services/src/manager/core/app_domain_verify_mgr_service.cpp index 32ad619..9f90585 100644 --- a/services/src/manager/core/app_domain_verify_mgr_service.cpp +++ b/services/src/manager/core/app_domain_verify_mgr_service.cpp @@ -17,6 +17,7 @@ #include #include #include +#include "app_details_data_mgr.h" #include "ipc_skeleton.h" #include "app_domain_verify_mgr_service.h" #include "system_ability_definition.h" @@ -36,7 +37,9 @@ AppDomainVerifyMgrService::AppDomainVerifyMgrService() : SystemAbility(APP_DOMAI { APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "new instance create."); dataManager_ = std::make_shared(); + appDetailsDataMgr_ = std::make_shared(); } + AppDomainVerifyMgrService::~AppDomainVerifyMgrService() { APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "instance dead."); @@ -225,6 +228,12 @@ int AppDomainVerifyMgrService::QueryAssociatedBundleNames( return dataManager_->QueryAssociatedBundleNames(domain, bundleNames) ? E_OK : E_INTERNAL_ERR; } +int AppDomainVerifyMgrService::QueryAppDetailsWant(const std::string& url, AAFwk::Want& want) +{ + APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + return appDetailsDataMgr_->QueryAppDetailsWant(url, want); +} + bool AppDomainVerifyMgrService::IsWantImplicit(const OHOS::AAFwk::Want& want) { auto element = want.GetElement(); diff --git a/services/src/manager/filter/app_details_filter.cpp b/services/src/manager/filter/app_details_filter.cpp new file mode 100644 index 0000000..930a6ce --- /dev/null +++ b/services/src/manager/filter/app_details_filter.cpp @@ -0,0 +1,48 @@ +/* + * 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 "app_details_filter.h" +#include "skill.h" +#include "want.h" +#include "app_domain_verify_hilog.h" + +namespace OHOS { +namespace AppDomainVerify { +constexpr const static char *ENTITY_SYSTEM_BROWSABLE = "entity.system.browsable"; +constexpr const static char *WANT_ACTION_VIEWDATA = "ohos.want.action.viewData"; +bool AppDetailsFilter::Filter(const std::vector& input, std::vector& dest, const std::string& url) +{ + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "start filer"); + AAFwk::Want want; + want.SetAction(WANT_ACTION_VIEWDATA); + want.SetEntities({ENTITY_SYSTEM_BROWSABLE}); + want.SetUri(url); + AppExecFwk::Skill skill; + skill.actions.push_back(WANT_ACTION_VIEWDATA); + skill.entities.push_back(ENTITY_SYSTEM_BROWSABLE); + for (auto&info : input) { + skill.uris.push_back(info.m_skillUri); + } + size_t index = 0; + bool ret = skill.Match(want, index); + if (!ret) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "skill match fail."); + return false; + } + dest.clear(); + dest.push_back(input[index]); + return true; +} +} +} diff --git a/services/src/manager/zidl/app_domain_verify_mgr_service_proxy.cpp b/services/src/manager/zidl/app_domain_verify_mgr_service_proxy.cpp index 3cc9579..3d07c5e 100644 --- a/services/src/manager/zidl/app_domain_verify_mgr_service_proxy.cpp +++ b/services/src/manager/zidl/app_domain_verify_mgr_service_proxy.cpp @@ -16,6 +16,7 @@ #include "app_domain_verify_mgr_interface_code.h" #include "system_ability_definition.h" #include "app_domain_verify_parcel_util.h" +#include "want.h" namespace OHOS { namespace AppDomainVerify { @@ -345,5 +346,35 @@ int AppDomainVerifyMgrServiceProxy::GetDeferredLink(std::string& link) APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end"); return result; } + +int AppDomainVerifyMgrServiceProxy::QueryAppDetailsWant(const std::string &url, AAFwk::Want& want) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called"); + MessageParcel data; + MessageParcel reply; + MessageOption option; + WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor()); + WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, url); + WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, data, &want); + int32_t error = Remote()->SendRequest( + AppDomainVerifyMgrInterfaceCode::QUERY_APP_DETAILS_WANT, data, reply, option); + if (error != ERR_NONE) { + APP_DOMAIN_VERIFY_HILOGE( + APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAppDetailsWant failed, error: %d", error); + } + int32_t result = reply.ReadInt32(); + if (result != 0) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result); + return result; + } + AppExecFwk::Want* wantPtr = reply.ReadParcelable(); + if (wantPtr == nullptr) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "recv want fail"); + return result; + } + want = *wantPtr; + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end"); + return result; +} } // namespace AppDomainVerify } // namespace OHOS diff --git a/services/src/manager/zidl/app_domain_verify_mgr_service_stub.cpp b/services/src/manager/zidl/app_domain_verify_mgr_service_stub.cpp index 4a4987a..b12d0b9 100644 --- a/services/src/manager/zidl/app_domain_verify_mgr_service_stub.cpp +++ b/services/src/manager/zidl/app_domain_verify_mgr_service_stub.cpp @@ -20,6 +20,7 @@ #include "app_domain_verify_parcel_util.h" #include "iservice_registry.h" #include "system_ability_definition.h" +#include "want.h" namespace OHOS { namespace AppDomainVerify { @@ -68,6 +69,8 @@ int32_t AppDomainVerifyMgrServiceStub::OnRemoteRequest( return OnQueryAssociatedBundleNames(data, reply); case static_cast(AppDomainVerifyMgrInterfaceCode::GET_DEFERRED_LINK): return OnGetDeferredLink(data, reply); + case static_cast(AppDomainVerifyMgrInterfaceCode::QUERY_APP_DETAILS_WANT): + return OnQueryAppDetailsWant(data, reply); default: APP_DOMAIN_VERIFY_HILOGW( APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "receive unknown code, code = %{public}d", code); @@ -276,5 +279,23 @@ int32_t AppDomainVerifyMgrServiceStub::OnGetDeferredLink(MessageParcel& data, Me APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end"); return ERR_OK; } + +int32_t AppDomainVerifyMgrServiceStub::OnQueryAppDetailsWant(MessageParcel& data, MessageParcel& reply) +{ + APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called"); + AAFwk::Want want; + std::string url; + READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url); + AAFwk::Want* wantPtr = data.ReadParcelable(); + if (!wantPtr) { + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed."); + return ERR_INVALID_VALUE; + } + int ret = QueryAppDetailsWant(url, *wantPtr); + WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, ret); + WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, wantPtr); + return ERR_OK; +} + } // namespace AppDomainVerify } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 39d6cb2..9f9f4e2 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -29,6 +29,7 @@ group("app_domain_verify_unit_test") { "frameworks_common/bms_test:app_domain_verify_bms_test", "frameworks_common/config_test:app_domain_verify_config_test", "frameworks_common/httpsession_test:app_domain_verify_httpsession_test", + "frameworks_common/utils_test:lru_cache_util_test", "moduletest:app_domain_verify_module_test", "services/ability_filter_test:ability_filter_test", "services/app_domain_verify_agent_service_test:app_domain_verify_agent_service_test", @@ -36,6 +37,8 @@ group("app_domain_verify_unit_test") { "services/app_domain_verify_mgr_service_test:app_domain_verify_mgr_service_test", "services/app_domain_verify_rdb_test:app_domain_verify_rdb_test", "services/deferred_link_test:deferred_link_test", + "services/app_domain_verify_filter_test:app_domain_verify_filter_test", + "app_details_rdb:app_details_rdb_data_manager_test", "verifier:app_domain_verify_agent_verifier_test", ] } diff --git a/test/unittest/app_details_rdb/BUILD.gn b/test/unittest/app_details_rdb/BUILD.gn new file mode 100644 index 0000000..e62f4a4 --- /dev/null +++ b/test/unittest/app_details_rdb/BUILD.gn @@ -0,0 +1,72 @@ +# 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. + +import("//build/test.gni") +import("//foundation/bundlemanager/app_domain_verify/app_domain_verify.gni") + +config("module_private_config") { + visibility = [ ":*" ] + configs = [ "//build/config/compiler:exceptions" ] + include_dirs = [ + "${app_domain_verify_frameworks_app_details_rdb_path}/include/", + "${app_domain_verify_service_path}/include/manager/core/", + "${app_domain_verify_service_path}/include/manager/filter" + ] +} + +module_output_path = "app_domain_verify/app_domain_verify" +ohos_unittest("app_details_rdb_data_manager_test") { + module_out_path = module_output_path + + sources = [ + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_meta_item.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_item.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_data_manager.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_open_callback.cpp", + "${app_domain_verify_service_path}/src/manager/core/app_details_data_mgr.cpp", + "${app_domain_verify_service_path}/src/manager/filter/app_details_filter.cpp", + "app_details_rdb_data_manager_test.cpp", + ] + + configs = [ ":module_private_config" ] + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "eventhandler:libeventhandler", + "hilog:libhilog", + "hisysevent:libhisysevent", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_core", + "netstack:http_client", + "os_account:os_account_innerkits", + "relational_store:native_rdb", + "samgr:samgr_proxy", + "ffrt:libffrt", + ] + + defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ] + deps = [ + "${app_domain_verify_client_path}:app_domain_verify_agent_client", + "${app_domain_verify_client_path}:app_domain_verify_mgr_client", + "${app_domain_verify_common_path}:app_domain_verify_common", + "${app_domain_verify_frameworks_common_path}:app_domain_verify_frameworks_common", + "${app_domain_verify_frameworks_common_path}:app_domain_verify_frameworks_common", + "${app_domain_verify_frameworks_extension_path}:app_domain_verify_extension_framework", + "${app_domain_verify_frameworks_verifier_path}:app_domain_verify_agent_verifier", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} diff --git a/test/unittest/app_details_rdb/app_details_rdb_data_manager_test.cpp b/test/unittest/app_details_rdb/app_details_rdb_data_manager_test.cpp new file mode 100644 index 0000000..b46418a --- /dev/null +++ b/test/unittest/app_details_rdb/app_details_rdb_data_manager_test.cpp @@ -0,0 +1,289 @@ +/* + * 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 "app_details_meta_item.h" +#include "app_details_rdb_item.h" +#include "cpp/condition_variable.h" +#include "cpp/mutex.h" +#include "cpp/task.h" +#include "skill.h" +#include "gtest/gtest.h" +#include +#include +#include +#include +#include +#include +#include +#include "app_domain_verify_hilog.h" +#define private public +#define protected public +#include "app_details_rdb_data_manager.h" +#undef private +#undef protected + +namespace OHOS::AppDomainVerify { +using namespace testing; +using namespace testing::ext; +class AppDetailsRdbMgrTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static std::string rdbName; + static std::string rdbPath; + static int rdbVersion; +}; + +std::string AppDetailsRdbMgrTest::rdbName = "test.db"; +std::string AppDetailsRdbMgrTest::rdbPath = "/data/test/"; +int AppDetailsRdbMgrTest::rdbVersion = 1; + +void AppDetailsRdbMgrTest::SetUpTestCase(void) +{ +} + +void AppDetailsRdbMgrTest::TearDownTestCase(void) +{ +} + +void AppDetailsRdbMgrTest::SetUp(void) +{ +} + +void AppDetailsRdbMgrTest::TearDown(void) +{ + std::vector tmpFileVec = { + rdbPath + rdbName, + rdbPath + rdbName + "-shm", + rdbPath + rdbName + "-wal" + }; + for (auto& filePath : tmpFileVec) { + (void)remove(filePath.c_str()); + } +} + +/** + * @tc.name: AppDetailsRdbMgrTest001 + * @tc.desc: test table op + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest001, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + bool ret = rdbMgr->DeleteTable("app_details"); + ASSERT_TRUE(ret); + ret = rdbMgr->CreateTable("app_details"); + ASSERT_TRUE(ret); + ret = rdbMgr->CreateTable("app_details_tmp"); + ASSERT_TRUE(ret); + ret = rdbMgr->DeleteTable("app_details_del"); + ASSERT_TRUE(ret); + ret = rdbMgr->RenameTable("app_details", "app_details_del"); + ASSERT_TRUE(ret); + ret = rdbMgr->DeleteTable("app_details_del"); + ASSERT_TRUE(ret); + ret = rdbMgr->DeleteTable("app_details_tmp"); + ASSERT_TRUE(ret); +} + + +/** + * @tc.name: AppDetailsRdbMgrTest002 + * @tc.desc: test insert del query op + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest002, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + bool ret = rdbMgr->DeleteTable("app_details"); + ASSERT_TRUE(ret); + ret = rdbMgr->CreateTable("app_details"); + ASSERT_TRUE(ret); + std::vector itemVec; + AppDetailsRdbItem item; + item.id = "111"; + item.scheme = "https"; + item.domain = "www.test.com"; + item.pathType = "path"; + item.path = "test"; + item.bundleName = "com.huawei.bundleNameTest"; + itemVec.push_back(item); + ret = rdbMgr->InsertDataBatch("app_details", itemVec); + ASSERT_TRUE(ret); + std::vector itemRetVec; + ret = rdbMgr->QueryDataByDomain("app_details", item.domain, itemRetVec); + ASSERT_TRUE(ret); + ASSERT_TRUE(itemRetVec.size() != 0); + auto rdbitem = itemRetVec[0]; + ASSERT_EQ(rdbitem.bundleName, item.bundleName); + ret = rdbMgr->DeleteTable("app_details"); + ASSERT_TRUE(ret); +} + + +/** + * @tc.name: AppDetailsRdbMgrTest003 + * @tc.desc: test meta data + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest003, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + bool ret = rdbMgr->CreateMetaData(); + ASSERT_TRUE(ret); + ret = rdbMgr->CreateMetaData(); + ASSERT_TRUE(ret); + MetaItem item; + item.tableExtInfo = "tableExtInfo"; + item.tableName = "app_details"; + item.tableVersion = "1.0"; + item.updateTime = "111111"; + std::vector itemVec; + itemVec.push_back(item); + ret = rdbMgr->UpdateMetaData(itemVec); + ASSERT_TRUE(ret); + ret = rdbMgr->DeleteTable("META_DATA"); + ASSERT_TRUE(ret); +} + +/** + * @tc.name: AppDetailsRdbMgrTest004 + * @tc.desc: test transaction + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest004, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + auto ret = rdbMgr->CreateTable("app_details"); + std::vector itemVec; + AppDetailsRdbItem item; + item.id = "111"; + item.scheme = "https"; + item.domain = "www.test.com"; + item.pathType = "path"; + item.path = "test"; + item.bundleName = "com.huawei.bundleNameTest"; + itemVec.push_back(item); + ret = rdbMgr->InsertDataBatch("app_details", itemVec); + ASSERT_TRUE(ret); + bool retFlag = rdbMgr->ExecWithTrans([&]()->bool { + auto ret = rdbMgr->DeleteTable("app_details"); + return false; + }); + ASSERT_FALSE(retFlag); + std::vector result; + ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result); + ASSERT_TRUE(ret); + retFlag = rdbMgr->ExecWithTrans([&]()->bool { + auto ret = rdbMgr->DeleteTable("app_details"); + return true; + }); + ASSERT_TRUE(retFlag); + result.clear(); + ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result); + ASSERT_FALSE(ret); +} + +/** + * @tc.name: AppDetailsRdbMgrTest005 + * @tc.desc: test delayClose + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest005, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + auto rdbStore = rdbMgr->GetRdbStore(); + ASSERT_TRUE(rdbStore != nullptr); + rdbMgr->PostDelayCloseTask(100); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + ASSERT_TRUE(rdbMgr->rdbStore_ == nullptr); +} + +/** + * @tc.name: AppDetailsRdbMgrTest006 + * @tc.desc: test trans for muti table + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest006, TestSize.Level0) +{ + RdbConfigInfo info; + info.rdbName = AppDetailsRdbMgrTest::rdbName; + info.rdbPath = AppDetailsRdbMgrTest::rdbPath; + info.version = AppDetailsRdbMgrTest::rdbVersion; + auto rdbMgr = std::make_shared(info); + auto ret = rdbMgr->CreateTable("app_details"); + rdbMgr->closeHandler_->RemoveTask("closeRdb"); + std::vector itemVec; + AppDetailsRdbItem item; + item.id = "111"; + item.scheme = "https"; + item.domain = "www.test.com"; + item.pathType = "path"; + item.path = "test"; + item.bundleName = "com.huawei.bundleNameTest"; + itemVec.push_back(item); + ret = rdbMgr->InsertDataBatch("app_details", itemVec); + std::vector result; + std::atomic_bool checkFlag = false; + std::binary_semaphore sem(0); + ffrt::mutex mtx; + ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result); + ASSERT_TRUE(ret); + ASSERT_TRUE(result.size() != 0); + auto task = [&](){ + rdbMgr->ExecWithTrans([&]()->bool { + sem.acquire(); + checkFlag = true; + return true; + }); + return; + }; + rdbMgr->closeHandler_->PostTask(task, "closeRdb", 0); + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + bool flag = rdbMgr->rdbStore_->IsInTransaction(); + ASSERT_TRUE(flag); + ASSERT_FALSE(checkFlag); + APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "sart query test"); + result.clear(); + ASSERT_TRUE(result.size() == 0); + ret = rdbMgr->QueryDataByDomain("app_details", "www.baidu.com", result); + ASSERT_TRUE(result.size() != 0); + sem.release(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + ASSERT_TRUE(checkFlag); +} +} \ No newline at end of file diff --git a/test/unittest/frameworks_common/utils_test/BUILD.gn b/test/unittest/frameworks_common/utils_test/BUILD.gn new file mode 100644 index 0000000..7196961 --- /dev/null +++ b/test/unittest/frameworks_common/utils_test/BUILD.gn @@ -0,0 +1,40 @@ +# 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. + +import("//build/test.gni") +import("//foundation/bundlemanager/app_domain_verify/app_domain_verify.gni") + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${app_domain_verify_frameworks_common_path}/include/utils" + ] +} + +module_output_path = "app_domain_verify/app_domain_verify" + +ohos_unittest("lru_cache_util_test") { + module_out_path = module_output_path + + sources = [ + "lru_cache_util_test.cpp", + ] + configs = [ ":module_private_config" ] + + defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} diff --git a/test/unittest/frameworks_common/utils_test/lru_cache_util_test.cpp b/test/unittest/frameworks_common/utils_test/lru_cache_util_test.cpp new file mode 100644 index 0000000..f142680 --- /dev/null +++ b/test/unittest/frameworks_common/utils_test/lru_cache_util_test.cpp @@ -0,0 +1,75 @@ +/* + * 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 "gtest/gtest.h" +#include +#include +#define private public +#define protected public +#include "lru_cache_util.h" +#undef private +#undef protected + +namespace OHOS::AppDomainVerify { +using namespace testing; +using namespace testing::ext; +class LruCacheUtilTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void LruCacheUtilTest::SetUpTestCase(void) +{ +} + +void LruCacheUtilTest::TearDownTestCase(void) +{ +} + +void LruCacheUtilTest::SetUp(void) +{ +} + +void LruCacheUtilTest::TearDown(void) +{ +} + +/** + * @tc.name: LruCacheUtilTest001 + * @tc.desc: fundation function test example string + * @tc.type: FUNC + */ +HWTEST_F(LruCacheUtilTest, LruCacheUtilTest001, TestSize.Level0) +{ + auto lruCache = LruCacheUtil(); + for (int i = 0; i < 11; i ++) { + lruCache.Put(std::to_string(i), std::to_string(i)); + } + std::string value; + ASSERT_FALSE(lruCache.Get("0", value)); + ASSERT_TRUE(lruCache.Get("1", value)); + ASSERT_EQ(value.compare("1"), 0); + for (int i = 0; i < 3; i++) { + lruCache.Put(std::to_string(i + 11), std::to_string(i + 11)); + } + ASSERT_TRUE(lruCache.Get("1", value)); + ASSERT_EQ(value.compare("1"), 0); + lruCache.Clear(); + ASSERT_FALSE(lruCache.Get("1", value)); +} + +} \ No newline at end of file diff --git a/test/unittest/mock/include/mock_verify_mgr.h b/test/unittest/mock/include/mock_verify_mgr.h index 8324c12..da475a2 100644 --- a/test/unittest/mock/include/mock_verify_mgr.h +++ b/test/unittest/mock/include/mock_verify_mgr.h @@ -77,6 +77,10 @@ public: { return true; } + virtual int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want) override + { + return true; + } MOCK_METHOD4(SendRequest, int(uint32_t, MessageParcel&, MessageParcel&, MessageOption&)); MOCK_METHOD(sptr, AsObject, (), (override)); }; @@ -138,6 +142,11 @@ public: { return true; } + virtual int QueryAppDetailsWant(const std::string& link, AAFwk::Want& want) override + { + return true; + } + }; } // namespace AppDomainVerify } // namespace OHOS diff --git a/test/unittest/services/app_domain_verify_filter_test/BUILD.gn b/test/unittest/services/app_domain_verify_filter_test/BUILD.gn new file mode 100644 index 0000000..5ac1ce5 --- /dev/null +++ b/test/unittest/services/app_domain_verify_filter_test/BUILD.gn @@ -0,0 +1,64 @@ +# 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. + +import("//build/test.gni") +import("//foundation/bundlemanager/app_domain_verify/app_domain_verify.gni") + +config("module_private_config") { + visibility = [ ":*" ] + configs = [ "//build/config/compiler:exceptions" ] + include_dirs = [ + "${app_domain_verify_service_path}/include/manager/filter", + "${app_domain_verify_service_path}/include/manager/constant", + ] +} + +module_output_path = "app_domain_verify/app_domain_verify" +ohos_unittest("app_domain_verify_filter_test") { + module_out_path = module_output_path + + sources = [ + "${app_domain_verify_service_path}/src/manager/filter/app_details_filter.cpp", + "app_domain_verify_app_details_filter_test.cpp", + ] + configs = [ ":module_private_config" ] + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "eventhandler:libeventhandler", + "hilog:libhilog", + "hisysevent:libhisysevent", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_core", + "netstack:http_client", + "os_account:os_account_innerkits", + "relational_store:native_rdb", + "samgr:samgr_proxy", + ] + + defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ] + deps = [ + "${app_domain_verify_client_path}:app_domain_verify_agent_client", + "${app_domain_verify_client_path}:app_domain_verify_mgr_client", + "${app_domain_verify_common_path}:app_domain_verify_common", + "${app_domain_verify_frameworks_common_path}:app_domain_verify_frameworks_common", + "${app_domain_verify_frameworks_common_path}:app_domain_verify_frameworks_common", + "${app_domain_verify_frameworks_extension_path}:app_domain_verify_extension_framework", + "${app_domain_verify_frameworks_verifier_path}:app_domain_verify_agent_verifier", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} diff --git a/test/unittest/services/app_domain_verify_filter_test/app_domain_verify_app_details_filter_test.cpp b/test/unittest/services/app_domain_verify_filter_test/app_domain_verify_app_details_filter_test.cpp new file mode 100644 index 0000000..207faf5 --- /dev/null +++ b/test/unittest/services/app_domain_verify_filter_test/app_domain_verify_app_details_filter_test.cpp @@ -0,0 +1,131 @@ +/* + * 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 "filter_define.h" +#include "app_details_filter.h" +#include "skill.h" +#include "gtest/gtest.h" +#include +#include +#define private public +#define protected public +#include "lru_cache_util.h" +#undef private +#undef protected + +namespace OHOS::AppDomainVerify { +using namespace testing; +using namespace testing::ext; +class AppDetailsFilterTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AppDetailsFilterTest::SetUpTestCase(void) +{ +} + +void AppDetailsFilterTest::TearDownTestCase(void) +{ +} + +void AppDetailsFilterTest::SetUp(void) +{ +} + +void AppDetailsFilterTest::TearDown(void) +{ +} + +/** + * @tc.name: AppDetailsFilterTest001 + * @tc.desc: test path match + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsFilterTest, AppDetailsFilterTest001, TestSize.Level0) +{ + AppDetailsFilter filter; + std::vector filterVec; + AppDetailInfo info; + info.m_skillUri.scheme = "https"; + info.m_skillUri.host = "www.example.com"; + info.m_skillUri.path = "test"; + info.m_bundleName = "com.example.bundleName"; + filterVec.emplace_back(std::move(info)); + std::vector resultVec; + auto ret = filter.Filter(filterVec, resultVec, "https://www.example.com/test"); + ASSERT_TRUE(ret); + ASSERT_TRUE(resultVec.size() == 1); + ASSERT_TRUE(resultVec[0].m_bundleName.compare("com.example.bundleName") == 0); + resultVec.clear(); + filterVec[0].m_skillUri.path = "111"; + ret = filter.Filter(filterVec, resultVec, "https://www.example.com/test"); + ASSERT_FALSE(ret); +} + +/** + * @tc.name: AppDetailsFilterTest002 + * @tc.desc: test path match + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsFilterTest, AppDetailsFilterTest002, TestSize.Level0) +{ + AppDetailsFilter filter; + std::vector filterVec; + AppDetailInfo info; + info.m_skillUri.scheme = "https"; + info.m_skillUri.host = "www.example.com"; + info.m_skillUri.pathStartWith = "test"; + info.m_bundleName = "com.example.bundleName"; + filterVec.emplace_back(std::move(info)); + std::vector resultVec; + auto ret = filter.Filter(filterVec, resultVec, "https://www.example.com/testhappy"); + ASSERT_TRUE(ret); + ASSERT_TRUE(resultVec.size() == 1); + ASSERT_EQ(resultVec[0].m_bundleName.compare("com.example.bundleName"), 0); + resultVec.clear(); + filterVec[0].m_skillUri.path = "111"; + ret = filter.Filter(filterVec, resultVec, "https://www.example.com/tes"); + ASSERT_FALSE(ret); +} + +/** + * @tc.name: AppDetailsFilterTest003 + * @tc.desc: test regex match + * @tc.type: FUNC + */ +HWTEST_F(AppDetailsFilterTest, AppDetailsFilterTest003, TestSize.Level0) +{ + AppDetailsFilter filter; + std::vector filterVec; + AppDetailInfo info; + info.m_skillUri.scheme = "https"; + info.m_skillUri.host = "www.example.com"; + info.m_skillUri.pathRegex = "[0-9]*"; + info.m_bundleName = "com.example.bundleName"; + filterVec.emplace_back(std::move(info)); + std::vector resultVec; + auto ret = filter.Filter(filterVec, resultVec, "https://www.example.com/1223"); + ASSERT_TRUE(ret); + ASSERT_TRUE(resultVec.size() == 1); + ASSERT_EQ(resultVec[0].m_bundleName.compare("com.example.bundleName"), 0); + ret = filter.Filter(filterVec, resultVec, "https://www.example.com/xxx"); + ASSERT_FALSE(ret); +} + + +} \ No newline at end of file diff --git a/test/unittest/services/app_domain_verify_mgr_service_test/BUILD.gn b/test/unittest/services/app_domain_verify_mgr_service_test/BUILD.gn index 3bb0cb1..78d5c02 100644 --- a/test/unittest/services/app_domain_verify_mgr_service_test/BUILD.gn +++ b/test/unittest/services/app_domain_verify_mgr_service_test/BUILD.gn @@ -29,12 +29,14 @@ config("module_private_config") { "${app_domain_verify_service_path}/include/manager/zidl", "${app_domain_verify_service_path}/include/manager/permission", "${app_domain_verify_service_path}/include/manager/deferred_link", + "${app_domain_verify_service_path}/include/manager/filter", "${app_domain_verify_common_path}/include", "${app_domain_verify_frameworks_common_path}/include", "${app_domain_verify_frameworks_common_path}/include/utils", "${app_domain_verify_frameworks_extension_path}/include", "${app_domain_verify_test_path}/mock/include", "${app_domain_verify_frameworks_common_path}/include/dfx", + "${app_domain_verify_frameworks_app_details_rdb_path}/include" ] } @@ -45,12 +47,18 @@ ohos_unittest("app_domain_verify_mgr_service_test") { sources = [ "${app_domain_verify_service_path}/src/manager/core/app_domain_verify_data_mgr.cpp", "${app_domain_verify_service_path}/src/manager/core/app_domain_verify_mgr_service.cpp", + "${app_domain_verify_service_path}/src/manager/core/app_details_data_mgr.cpp", + "${app_domain_verify_service_path}/src/manager/filter/app_details_filter.cpp", "${app_domain_verify_service_path}/src/manager/deferred_link/ability_filter.cpp", "${app_domain_verify_service_path}/src/manager/deferred_link/deferred_link_mgr.cpp", "${app_domain_verify_service_path}/src/manager/permission/permission_manager.cpp", "${app_domain_verify_service_path}/src/manager/rdb/app_domain_verify_rdb_data_manager.cpp", "${app_domain_verify_service_path}/src/manager/rdb/app_domain_verify_rdb_open_callback.cpp", "${app_domain_verify_service_path}/src/manager/rdb/rdb_migrate_mgr.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_meta_item.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_item.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_data_manager.cpp", + "${app_domain_verify_frameworks_app_details_rdb_path}/src/app_details_rdb_open_callback.cpp", "${app_domain_verify_service_path}/src/manager/zidl/app_domain_verify_mgr_service_proxy.cpp", "${app_domain_verify_service_path}/src/manager/zidl/app_domain_verify_mgr_service_stub.cpp", "${app_domain_verify_test_path}/mock/src/mock_access_token.cpp",