1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <memory>
17 #include <string>
18 #include <vector>
19 #include <thread>
20 
21 #include "app_domain_verify_agent_service.h"
22 #include "system_ability_definition.h"
23 #include "domain_url_util.h"
24 #include "bms/bundle_info_query.h"
25 #include "app_domain_verify_mgr_client.h"
26 #include "verify_task.h"
27 #include "iservice_registry.h"
28 
29 namespace OHOS {
30 namespace AppDomainVerify {
31 namespace {
32 #ifndef _TEST
33 constexpr int32_t DELAY_TIME = 180000;  // 3min = 3*60*1000
34 constexpr int MAX_DELAY_RETRY_CNT = 10;
35 #elif
36 constexpr int32_t DELAY_TIME = 60000;   // 1min = 60*1000 for test
37 constexpr int MAX_DELAY_RETRY_CNT = 3;  // 3 for test
38 #endif
39 std::atomic<int> retryCnt = 0;
40 std::atomic<bool> isDoSyncDone = false;
41 constexpr int32_t DUMP_SYSTEM_START_YEAR = 1900;
42 constexpr int32_t FORMAT_BLANK_SIZE = 32;
43 }
44 static const std::string TASK_ID = "unload";
45 using namespace NetManagerStandard;
46 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(new AppDomainVerifyAgentService());
47 
AppDomainVerifyAgentService()48 AppDomainVerifyAgentService::AppDomainVerifyAgentService() : SystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID, true)
49 {
50     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "new instance create.");
51     now = std::chrono::system_clock::now();
52     appDomainVerifyExtMgr_ = std::make_shared<AppDomainVerifyExtensionMgr>();
53     appDomainVerifyTaskMgr_ = AppDomainVerifyTaskMgr::GetInstance();
54     runner_ = AppExecFwk::EventRunner::Create("unload", AppExecFwk::ThreadMode::FFRT);
55     if (runner_ == nullptr) {
56         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "create runner failed.");
57         return;
58     }
59     unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
60 }
~AppDomainVerifyAgentService()61 AppDomainVerifyAgentService::~AppDomainVerifyAgentService()
62 {
63     AppDomainVerifyTaskMgr::DestroyInstance();
64     if (appDomainVerifyTaskMgr_ != nullptr) {
65         APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "appDomainVerifyTaskMgr_ reset.");
66         appDomainVerifyTaskMgr_ = nullptr;
67     }
68     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "instance dead.");
69 }
CompleteVerifyRefresh(const BundleVerifyStatusInfo & bundleVerifyStatusInfo,TaskType type)70 void AppDomainVerifyAgentService::CompleteVerifyRefresh(
71     const BundleVerifyStatusInfo& bundleVerifyStatusInfo, TaskType type)
72 {
73     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "%s called", __func__);
74     if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
75         appDomainVerifyExtMgr_->CompleteVerifyRefresh(bundleVerifyStatusInfo, type)) {
76         APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
77         return;
78     }
79     for (auto it = bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_.begin();
80          it != bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_.end(); it++) {
81         AppVerifyBaseInfo appVerifyBaseInfo;
82         appVerifyBaseInfo.bundleName = it->first;
83         if (appVerifyBaseInfo.appIdentifier.empty() &&
84             !BundleInfoQuery::GetBundleInfo(
85                 appVerifyBaseInfo.bundleName, appVerifyBaseInfo.appIdentifier, appVerifyBaseInfo.fingerprint)) {
86             APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "GetBundleInfo failed.");
87             // todo delete this bundleName or not
88             continue;
89         }
90         ExecuteVerifyTask(appVerifyBaseInfo, it->second, type);
91     }
92     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "%s call end", __func__);
93 }
ConvertToExplicitWant(OHOS::AAFwk::Want & implicitWant,sptr<IConvertCallback> & callback)94 void AppDomainVerifyAgentService::ConvertToExplicitWant(
95     OHOS::AAFwk::Want& implicitWant, sptr<IConvertCallback>& callback)
96 {
97     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "%s called", __func__);
98     if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
99         appDomainVerifyExtMgr_->ConvertToExplicitWant(implicitWant, callback)) {
100         APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
101         return;
102     }
103 
104     if (callback) {
105         callback->OnConvert(0, implicitWant);
106     }
107     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "%s called", __func__);
108 }
SingleVerify(const AppVerifyBaseInfo & appVerifyBaseInfo,const VerifyResultInfo & verifyResultInfo)109 void AppDomainVerifyAgentService::SingleVerify(
110     const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo)
111 {
112     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
113     ExecuteVerifyTask(appVerifyBaseInfo, verifyResultInfo, TaskType::IMMEDIATE_TASK);
114     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "call end");
115 }
116 
ExecuteVerifyTask(const AppVerifyBaseInfo & appVerifyBaseInfo,const VerifyResultInfo & verifyResultInfo,TaskType type)117 void AppDomainVerifyAgentService::ExecuteVerifyTask(
118     const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo, TaskType type)
119 {
120     if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
121         appDomainVerifyExtMgr_->SingleVerify(appVerifyBaseInfo, verifyResultInfo)) {
122         APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
123         return;
124     }
125 
126     auto task = std::make_shared<VerifyTask>(type, appVerifyBaseInfo, verifyResultInfo);
127     if (task->GetUriVerifyMap().empty()) {
128         APP_DOMAIN_VERIFY_HILOGW(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "no valid skillUris");
129         return;
130     }
131     task->Execute();
132 }
133 
QueryAndCompleteRefresh(TaskType type)134 void AppDomainVerifyAgentService::QueryAndCompleteRefresh(TaskType type)
135 {
136     BundleVerifyStatusInfo bundleVerifyStatusInfo;
137     if (AppDomainVerifyMgrClient::GetInstance()->QueryAllDomainVerifyStatus(bundleVerifyStatusInfo)) {
138         CompleteVerifyRefresh(bundleVerifyStatusInfo, type);
139         return;
140     }
141 }
142 
UpdateWhiteList()143 void AppDomainVerifyAgentService::UpdateWhiteList()
144 {
145     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
146     if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateWhiteList()) {
147         APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
148         return;
149     }
150 }
151 // sa_main进程统一调用
OnStart(const SystemAbilityOnDemandReason & startReason)152 void AppDomainVerifyAgentService::OnStart(const SystemAbilityOnDemandReason& startReason)
153 {
154     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnStart reason %{public}s, reasonId_:%{public}d",
155         startReason.GetName().c_str(), startReason.GetId());
156     PostDelayUnloadTask();
157     bool res = Publish(this);
158     if (!res) {
159         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "Publish failed");
160     }
161 }
162 
OnStop()163 void AppDomainVerifyAgentService::OnStop()
164 {
165     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
166 }
UnloadSa()167 void AppDomainVerifyAgentService::UnloadSa()
168 {
169     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa");
170     auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
171     if (samgrProxy == nullptr) {
172         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "get samgr failed");
173         return;
174     }
175     int32_t ret = samgrProxy->UnloadSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID);
176     if (ret != 0) {
177         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "remove system ability failed");
178         return;
179     }
180     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa done");
181 }
182 
IsIdle()183 bool AppDomainVerifyAgentService::IsIdle()
184 {
185     if (appDomainVerifyTaskMgr_ == nullptr) {
186         return true;
187     } else {
188         return appDomainVerifyTaskMgr_->IsIdle();
189     }
190 }
191 
DoSync(const TaskType & type)192 void AppDomainVerifyAgentService::DoSync(const TaskType& type)
193 {
194     QueryAndCompleteRefresh(type);
195     UpdateWhiteList();
196 }
197 
IsNetAvailable()198 bool AppDomainVerifyAgentService::IsNetAvailable()
199 {
200     bool isNetAvailable = false;
201     NetManagerStandard::NetConnClient::GetInstance().HasDefaultNet(isNetAvailable);
202     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsNetAvailable:%{public}d", isNetAvailable);
203     return isNetAvailable;
204 }
205 
DoSync()206 void AppDomainVerifyAgentService::DoSync()
207 {
208     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do sync");
209     if (!isDoSyncDone && IsNetAvailable()) {
210         APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "net connected, do sync once");
211         DoSync(BOOT_REFRESH_TASK);
212         isDoSyncDone = true;
213     }
214 }
215 
CanUnloadSa()216 bool AppDomainVerifyAgentService::CanUnloadSa()
217 {
218     auto reachedMaxCnt = (retryCnt >= MAX_DELAY_RETRY_CNT - 1);
219     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE,
220         "can unload? isDoSyncDone:%{public}d, retryCnt:%{public}d, IsIdle:%{public}d, reachedMaxCnt:%{public}d, "
221         "maxCnt:%{public}d",
222         isDoSyncDone.load(), retryCnt.load(), IsIdle(), reachedMaxCnt, MAX_DELAY_RETRY_CNT);
223     return (isDoSyncDone || reachedMaxCnt) && IsIdle();
224 }
225 
OnDelayUnloadSA()226 void AppDomainVerifyAgentService::OnDelayUnloadSA()
227 {
228     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task");
229     if (CanUnloadSa()) {
230         APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "can unload sa");
231         UnloadSa();
232         return;
233     }
234 
235     DoSync();
236     PostDelayUnloadTask();
237     retryCnt++;
238     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task, delay unload");
239 }
PostDelayUnloadTask()240 void AppDomainVerifyAgentService::PostDelayUnloadTask()
241 {
242     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
243     unloadHandler_->RemoveTask(TASK_ID);
244     unloadHandler_->PostTask([this] { OnDelayUnloadSA(); }, TASK_ID, DELAY_TIME);
245 }
246 
OnDump()247 void AppDomainVerifyAgentService::OnDump()
248 {
249     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnDump");
250 }
GetStatTime()251 std::string AppDomainVerifyAgentService::GetStatTime()
252 {
253     std::string startTime;
254     time_t tt = std::chrono::system_clock::to_time_t(now);
255     auto ptm = localtime(&tt);
256     if (ptm != nullptr) {
257         char date[FORMAT_BLANK_SIZE] = { 0 };
258         auto flag = sprintf_s(date, sizeof(date), "%04d-%02d-%02d  %02d:%02d:%02d",
259             (int)ptm->tm_year + DUMP_SYSTEM_START_YEAR, (int)ptm->tm_mon + 1, (int)ptm->tm_mday, (int)ptm->tm_hour,
260             (int)ptm->tm_min, (int)ptm->tm_sec);
261         if (flag < 0) {
262             return startTime;
263         }
264         startTime = date;
265     }
266     return startTime;
267 }
Dump(int fd,const std::vector<std::u16string> & args)268 int AppDomainVerifyAgentService::Dump(int fd, const std::vector<std::u16string>& args)
269 {
270     APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "Dump");
271     std::string dumpString{};
272     dumpString.append("Agent start time: ");
273     dumpString.append(GetStatTime());
274     dumpString.append("\n");
275     dumpString.append("TaskMgr state: ");
276     IsIdle() ? dumpString.append("idle.") : dumpString.append("running.");
277     dumpString.append("\n");
278     dumpString.append("isDoSyncDone:");
279     isDoSyncDone ? dumpString.append("true.") : dumpString.append("false.");
280     dumpString.append("\n");
281     dumpString.append("retryCnt:");
282     dumpString.append(std::to_string(retryCnt));
283     dumpString.append("\n");
284     dumpString.append("maxCnt:");
285     dumpString.append(std::to_string(MAX_DELAY_RETRY_CNT));
286     dumpString.append("\n");
287     (void)write(fd, dumpString.c_str(), dumpString.size());
288     return 0;
289 }
290 
291 }  // namespace AppDomainVerify
292 }  // namespace OHOS
293