openharmony/bundlemanager_app_domain_verify
1
0
Fork 0
mirror of https://gitee.com/openharmony/bundlemanager_app_domain_verify synced 2025-02-10 19:02:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

增加网络检测

Browse Source 
Signed-off-by: woohoa <wanghuan36@huawei.com>
This commit is contained in:
15950533375 2024-09-06 11:24:44 +08:00
parent 880aceec78
commit c80acaca35
6 changed files with 112 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
etc/init/app_domain_verify_agent.cfg
View File

@ -21,7 +21,8 @@
"permission" : [
"ohos.permission.INTERNET",
"ohos.permission.MANAGE_SECURE_SETTINGS",
"ohos.permission.GET_BUNDLE_INFO"
"ohos.permission.GET_BUNDLE_INFO",
"ohos.permission.CONNECTIVITY_INTERNAL"
],
"secon" : "u:r:app_domain_verify_agent:s0",
"sandbox" : 0

1
services/BUILD.gn
View File

@ -161,6 +161,7 @@ ohos_shared_library("app_domain_verify_agent_service") {
"hisysevent:libhisysevent",
"ipc:ipc_core",
"json:nlohmann_json_static",
"netmanager_base:net_conn_manager_if",
"netstack:http_client",
"os_account:os_account_innerkits",
"preferences:native_preferences",

19
services/include/agent/core/app_domain_verify_agent_service.h
View File

@ -25,7 +25,8 @@
#include "i_app_domain_verify_mgr_service.h"
#include "app_domain_verify_task_mgr.h"
#include "dfx/app_domain_verify_hisysevent.h"
#include "event_handler.h"
#include "event_runner.h"
namespace OHOS {
namespace AppDomainVerify {
class AppDomainVerifyAgentService : public SystemAbility, public AppDomainVerifyAgentServiceStub {
@ -41,7 +42,6 @@ public:
protected:
void OnStart(const SystemAbilityOnDemandReason& startReason) override;
void OnStop() override;
int32_t OnIdle(const SystemAbilityOnDemandReason& idleReason) override;
void ExitIdleState() override;
void OnDump() override;
int Dump(int fd, const std::vector<std::u16string>& args) override;
@ -52,16 +52,19 @@ private:
const std::vector<InnerVerifyStatus>& statuses, int delaySeconds, TaskType type);
void ExecuteVerifyTask(
const AppVerifyBaseInfo& appVerifyBaseInfo, const std::vector<SkillUri>& skillUris, TaskType type);
bool IsIdle();
void UpdateWhiteList();
bool CanUnloadSa();
void OnDelayUnloadSA();
void PostDelayUnloadTask() override;
void DoSync(const TaskType& type);
bool IsIdle();
bool IsNetAvaliable();
void UnloadSa();
private:
std::shared_ptr<ffrt::queue> continuationHandler_;
std::shared_ptr<AppDomainVerifyExtensionMgr> appDomainVerifyExtMgr_;
std::shared_ptr<AppDomainVerifyTaskMgr> appDomainVerifyTaskMgr_;
bool IsInOOBE();
void DoSync(const TaskType& type);
bool ShouldRejectUnloadWhenOOBE();
std::shared_ptr<AppExecFwk::EventHandler> unloadHandler_;
std::shared_ptr<AppExecFwk::EventRunner> runner_;
};
} // namespace AppDomainVerify

6
services/include/agent/zidl/app_domain_verify_agent_service_stub.h
View File

@ -28,19 +28,15 @@ public:
AppDomainVerifyAgentServiceStub();
virtual ~AppDomainVerifyAgentServiceStub();
int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override;
void PostDelayUnloadTask();
protected:
virtual void PostDelayUnloadTask() = 0;
virtual void ExitIdleState() = 0;
private:
using ServiceFunc = int32_t (AppDomainVerifyAgentServiceStub::*)(MessageParcel& data, MessageParcel& reply);
int32_t OnSingleVerify(MessageParcel& data, MessageParcel& reply);
int32_t OnConvertToExplicitWant(MessageParcel& data, MessageParcel& reply);
private:
std::shared_ptr<AppExecFwk::EventHandler> unloadHandler_;
std::shared_ptr<AppExecFwk::EventRunner> runner_;
};
} // namespace AppDomainVerify
} // namespace OHOS

205
services/src/agent/core/app_domain_verify_agent_service.cpp
View File

@ -24,24 +24,34 @@
#include "bms/bundle_info_query.h"
#include "app_domain_verify_mgr_client.h"
#include "verify_task.h"
#include "setting_data_share_helper.h"
#include "os_account_manager.h"
#include "net_conn_client.h"
#include "iservice_registry.h"
namespace OHOS {
namespace AppDomainVerify {
namespace {
constexpr int32_t DELAY_TIME = 300000; // 5min = 5*60*1000
std::atomic<int> retryCnt = 0;
std::atomic<bool> isDoSyncDone = false;
constexpr int MAX_NET_RETRY_CNT = 3;
}
static const std::string TASK_ID = "unload";
static const std::string BOOT_COMPLETED_EVENT = "usual.event.BOOT_COMPLETED";
static const std::string LOOP_EVENT = "loopevent";
static std::atomic<bool> needCheckOOBE = false;
const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(new AppDomainVerifyAgentService());
constexpr int32_t UNLOAD_IMMEDIATELY = 0;
constexpr int32_t UNLOAD_DELAY_TIME = 120000; // 2min
const std::string BOOT_COMPLETED_EVENT = "usual.event.BOOT_COMPLETED";
const std::string LOOP_EVENT = "loopevent";
AppDomainVerifyAgentService::AppDomainVerifyAgentService() : SystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID, true)
{
APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "new instance create.");
appDomainVerifyExtMgr_ = std::make_shared<AppDomainVerifyExtensionMgr>();
appDomainVerifyTaskMgr_ = AppDomainVerifyTaskMgr::GetInstance();
APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "new instance create.");
runner_ = AppExecFwk::EventRunner::Create("unload", AppExecFwk::ThreadMode::FFRT);
if (runner_ == nullptr) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "create runner failed.");
return;
}
unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
}
AppDomainVerifyAgentService::~AppDomainVerifyAgentService()
{
@ -135,90 +145,38 @@ void AppDomainVerifyAgentService::QueryAndCompleteRefresh(
CompleteVerifyRefresh(bundleVerifyStatusInfo, statuses, delaySeconds, type);
}
}
void AppDomainVerifyAgentService::UpdateWhiteList()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateWhiteList()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
return;
}
}
// sa_main进程统一调用
void AppDomainVerifyAgentService::OnStart(const SystemAbilityOnDemandReason& startReason)
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnStart reason %{public}s, reasonId_:%{public}d",
startReason.GetName().c_str(), startReason.GetId());
if (continuationHandler_ == nullptr) {
continuationHandler_ = std::make_shared<ffrt::queue>("VerifyServiceContinuationMgr");
}
if (startReason.GetName() == BOOT_COMPLETED_EVENT || startReason.GetName() == LOOP_EVENT) {
TaskType type = startReason.GetName() == BOOT_COMPLETED_EVENT ?
TaskType::BOOT_REFRESH_TASK :
TaskType::SCHEDULE_REFRESH_TASK;
DoSync(type);
}
AppDomainVerifyAgentServiceStub::PostDelayUnloadTask();
PostDelayUnloadTask();
bool res = Publish(this);
if (!res) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "Publish failed");
} else {
if (IsInOOBE()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnStart is in OOBE, needDoSync.");
needCheckOOBE = true;
}
}
}
void AppDomainVerifyAgentService::DoSync(const TaskType& type)
{
auto func = [this, type]() {
QueryAndCompleteRefresh(
std::vector<InnerVerifyStatus>{ UNKNOWN, STATE_FAIL, FAILURE_REDIRECT, FAILURE_CLIENT_ERROR,
FAILURE_REJECTED_BY_SERVER, FAILURE_HTTP_UNKNOWN, FAILURE_TIMEOUT, FAILURE_CONFIG },
0, type);
};
auto updateWhiteListFunc = [this]() { UpdateWhiteList(); };
continuationHandler_->submit(updateWhiteListFunc);
continuationHandler_->submit(func);
}
void AppDomainVerifyAgentService::OnStop()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "%s called", __func__);
}
bool AppDomainVerifyAgentService::ShouldRejectUnloadWhenOOBE()
{
if (needCheckOOBE) {
if (IsInOOBE()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle is in OOBE, delay unload.");
needCheckOOBE = true;
return true;
}
DoSync(EnumTaskType::BOOT_REFRESH_TASK);
needCheckOOBE = false;
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle do sync submit, delay unload once.");
return true;
} else {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle no need check oobe status.");
return false;
}
}
int32_t AppDomainVerifyAgentService::OnIdle(const SystemAbilityOnDemandReason& idleReason)
{
APP_DOMAIN_VERIFY_HILOGI(
APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle reason:%{public}s", idleReason.GetName().c_str());
if (ShouldRejectUnloadWhenOOBE()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle oobe, delay unload");
return UNLOAD_DELAY_TIME;
}
if (IsIdle()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle unload immediately");
return UNLOAD_IMMEDIATELY;
} else {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnIdle delay unload");
return UNLOAD_DELAY_TIME;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
}
void AppDomainVerifyAgentService::ExitIdleState()
void AppDomainVerifyAgentService::DoSync(const TaskType& type)
{
CancelIdle();
QueryAndCompleteRefresh(std::vector<InnerVerifyStatus>{ UNKNOWN, STATE_FAIL, FAILURE_REDIRECT, FAILURE_CLIENT_ERROR,
FAILURE_REJECTED_BY_SERVER, FAILURE_HTTP_UNKNOWN, FAILURE_TIMEOUT, FAILURE_CONFIG },
0, type);
UpdateWhiteList();
}
bool AppDomainVerifyAgentService::IsIdle()
{
if (appDomainVerifyTaskMgr_ == nullptr) {
@ -228,14 +186,74 @@ bool AppDomainVerifyAgentService::IsIdle()
}
}
void AppDomainVerifyAgentService::UpdateWhiteList()
bool AppDomainVerifyAgentService::IsNetAvaliable()
{
bool IsNetAvailable = false;
NetManagerStandard::NetConnClient::GetInstance().HasDefaultNet(IsNetAvailable);
return IsNetAvailable;
}
bool AppDomainVerifyAgentService::CanUnloadSa()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateWhiteList()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
// 尝试进行最大次数的有网络同步操作
if (!isDoSyncDone && retryCnt++ < MAX_NET_RETRY_CNT) {
if (IsNetAvaliable()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "net avaliable, do sync");
DoSync(BOOT_REFRESH_TASK);
isDoSyncDone = true;
} else {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "net un avaliable, retry and delay");
return false;
}
}
// 还需要判断是否有网络任务
if (IsIdle()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "task idle");
return true;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "task not idle");
return false;
}
void AppDomainVerifyAgentService::UnloadSa()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa");
auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (samgrProxy == nullptr) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "get samgr failed");
return;
}
int32_t ret = samgrProxy->UnloadSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID);
if (ret != 0) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "remove system ability failed");
return;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa done");
}
void AppDomainVerifyAgentService::OnDelayUnloadSA()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task");
if (!CanUnloadSa()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "can not unload sa, delay unload");
unloadHandler_->RemoveTask(TASK_ID);
unloadHandler_->PostTask([this] { PostDelayUnloadTask(); }, TASK_ID, DELAY_TIME);
return;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task, do unload");
UnloadSa();
}
void AppDomainVerifyAgentService::PostDelayUnloadTask()
{
APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
unloadHandler_->RemoveTask(TASK_ID);
unloadHandler_->PostTask([this] { OnDelayUnloadSA(); }, TASK_ID, DELAY_TIME);
}
void AppDomainVerifyAgentService::ExitIdleState()
{
CancelIdle();
}
void AppDomainVerifyAgentService::OnDump()
{
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnDump");
@ -251,35 +269,6 @@ int AppDomainVerifyAgentService::Dump(int fd, const std::vector<std::u16string>&
(void)write(fd, dumpString.c_str(), dumpString.size());
return 0;
}
bool AppDomainVerifyAgentService::IsInOOBE()
{
auto datashareHelper = SettingsDataShareHelper::GetInstance();
std::string device_provisioned{ "0" };
OHOS::Uri uri(
"datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=device_provisioned");
int resp = datashareHelper->Query(uri, "device_provisioned", device_provisioned);
if (resp == 0 && (device_provisioned == "0" || device_provisioned.empty())) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsInOOBE: device_provisioned = 0");
return true;
}
std::string user_setup_complete{ "1" };
std::vector<int> activedOsAccountIds;
OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
if (activedOsAccountIds.empty()) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsInOOBE: activedOsAccountIds is empty");
return false;
}
int userId = activedOsAccountIds[0];
OHOS::Uri uri_setup("datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_" +
std::to_string(userId) + "?Proxy=true&key=user_setup_complete");
int resp_userSetup = datashareHelper->Query(uri_setup, "user_setup_complete", user_setup_complete);
if (resp_userSetup == 0 && (user_setup_complete == "0" || user_setup_complete.empty())) {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsInOOBE: user_setup_complete = 0");
return true;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsInOOBE: complete");
return false;
}
} // namespace AppDomainVerify
} // namespace OHOS

31
services/src/agent/zidl/app_domain_verify_agent_service_stub.cpp
View File

@ -105,37 +105,6 @@ int32_t AppDomainVerifyAgentServiceStub::OnConvertToExplicitWant(MessageParcel&
APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
return ERR_OK;
}
void AppDomainVerifyAgentServiceStub::PostDelayUnloadTask()
{
APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
if (runner_ == nullptr) {
runner_ = AppExecFwk::EventRunner::Create("unload", AppExecFwk::ThreadMode::FFRT);
}
if (unloadHandler_ == nullptr) {
unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
}
if (unloadHandler_ == nullptr) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "unloadHandler init failed!");
return;
}
auto task = [this]() {
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload task");
auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (samgrProxy == nullptr) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "get samgr failed");
return;
}
int32_t ret = samgrProxy->UnloadSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID);
if (ret != 0) {
APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "remove system ability failed");
return;
}
APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload task done");
};
unloadHandler_->RemoveTask(TASK_ID);
unloadHandler_->PostTask(task, TASK_ID, DELAY_TIME);
}
} // namespace AppDomainVerify
} // namespace OHOS