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 #include "app_domain_verify_error.h"
29 #include "permission_manager.h"
30
31 namespace OHOS {
32 namespace AppDomainVerify {
33 namespace {
34 #ifndef _TEST
35 constexpr int32_t DELAY_TIME = 180000; // 3min = 3*60*1000
36 constexpr int MAX_DELAY_RETRY_CNT = 10;
37 #elif
38 constexpr int32_t DELAY_TIME = 60000; // 1min = 60*1000 for test
39 constexpr int MAX_DELAY_RETRY_CNT = 3; // 3 for test
40 #endif
41 std::atomic<int> retryCnt = 0;
42 std::atomic<bool> isDoSyncDone = false;
43 constexpr int32_t DUMP_SYSTEM_START_YEAR = 1900;
44 constexpr int32_t FORMAT_BLANK_SIZE = 32;
45 constexpr const char* LOOP_EVENT = "loopevent";
46 }
47 static const std::string TASK_ID = "unload";
48 static const std::string UPDATE_DETAILS_TASK_ID = "udpateDetails";
49 using namespace NetManagerStandard;
50 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(new AppDomainVerifyAgentService());
51
AppDomainVerifyAgentService()52 AppDomainVerifyAgentService::AppDomainVerifyAgentService() : SystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID, true)
53 {
54 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "new instance create.");
55 now = std::chrono::system_clock::now();
56 appDomainVerifyExtMgr_ = std::make_shared<AppDomainVerifyExtensionMgr>();
57 appDomainVerifyTaskMgr_ = AppDomainVerifyTaskMgr::GetInstance();
58 runner_ = AppExecFwk::EventRunner::Create("unload", AppExecFwk::ThreadMode::FFRT);
59 if (runner_ == nullptr) {
60 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "create runner failed.");
61 return;
62 }
63 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
64 }
~AppDomainVerifyAgentService()65 AppDomainVerifyAgentService::~AppDomainVerifyAgentService()
66 {
67 AppDomainVerifyTaskMgr::DestroyInstance();
68 if (appDomainVerifyTaskMgr_ != nullptr) {
69 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "appDomainVerifyTaskMgr_ reset.");
70 appDomainVerifyTaskMgr_ = nullptr;
71 }
72 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "instance dead.");
73 }
CompleteVerifyRefresh(const BundleVerifyStatusInfo & bundleVerifyStatusInfo,TaskType type)74 void AppDomainVerifyAgentService::CompleteVerifyRefresh(
75 const BundleVerifyStatusInfo& bundleVerifyStatusInfo, TaskType type)
76 {
77 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
78 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
79 appDomainVerifyExtMgr_->CompleteVerifyRefresh(bundleVerifyStatusInfo, type)) {
80 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
81 return;
82 }
83 for (auto it = bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_.begin();
84 it != bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_.end(); it++) {
85 AppVerifyBaseInfo appVerifyBaseInfo;
86 appVerifyBaseInfo.bundleName = it->first;
87 if (appVerifyBaseInfo.appIdentifier.empty() &&
88 !BundleInfoQuery::GetBundleInfo(
89 appVerifyBaseInfo.bundleName, appVerifyBaseInfo.appIdentifier, appVerifyBaseInfo.fingerprint)) {
90 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "GetBundleInfo failed.");
91 // todo delete this bundleName or not
92 continue;
93 }
94 ExecuteVerifyTask(appVerifyBaseInfo, it->second, type);
95 }
96 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "call end");
97 }
ConvertToExplicitWant(OHOS::AAFwk::Want & implicitWant,sptr<IConvertCallback> & callback)98 void AppDomainVerifyAgentService::ConvertToExplicitWant(
99 OHOS::AAFwk::Want& implicitWant, sptr<IConvertCallback>& callback)
100 {
101 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
102 if (PermissionManager::IsSACall()) {
103 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "no sa call");
104 return;
105 }
106 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
107 appDomainVerifyExtMgr_->ConvertToExplicitWant(implicitWant, callback)) {
108 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
109 return;
110 }
111
112 if (callback) {
113 callback->OnConvert(0, implicitWant);
114 }
115 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
116 }
SingleVerify(const AppVerifyBaseInfo & appVerifyBaseInfo,const VerifyResultInfo & verifyResultInfo)117 void AppDomainVerifyAgentService::SingleVerify(
118 const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo)
119 {
120 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
121 if (PermissionManager::IsSACall()) {
122 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "no sa call");
123 return;
124 }
125 ExecuteVerifyTask(appVerifyBaseInfo, verifyResultInfo, TaskType::IMMEDIATE_TASK);
126 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "call end");
127 }
128
ExecuteVerifyTask(const AppVerifyBaseInfo & appVerifyBaseInfo,const VerifyResultInfo & verifyResultInfo,TaskType type)129 void AppDomainVerifyAgentService::ExecuteVerifyTask(
130 const AppVerifyBaseInfo& appVerifyBaseInfo, const VerifyResultInfo& verifyResultInfo, TaskType type)
131 {
132 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND !=
133 appDomainVerifyExtMgr_->SingleVerify(appVerifyBaseInfo, verifyResultInfo)) {
134 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
135 return;
136 }
137
138 auto task = std::make_shared<VerifyTask>(type, appVerifyBaseInfo, verifyResultInfo);
139 if (task->GetUriVerifyMap().empty()) {
140 APP_DOMAIN_VERIFY_HILOGW(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "no valid skillUris");
141 return;
142 }
143 task->Execute();
144 }
145
QueryAndCompleteRefresh(TaskType type)146 void AppDomainVerifyAgentService::QueryAndCompleteRefresh(TaskType type)
147 {
148 BundleVerifyStatusInfo bundleVerifyStatusInfo;
149 if (AppDomainVerifyMgrClient::GetInstance()->QueryAllDomainVerifyStatus(bundleVerifyStatusInfo)) {
150 CompleteVerifyRefresh(bundleVerifyStatusInfo, type);
151 return;
152 }
153 UNIVERSAL_ERROR_EVENT(GET_DATE_IN_BOOT_FAULT);
154 }
155
UpdateWhiteList()156 void AppDomainVerifyAgentService::UpdateWhiteList()
157 {
158 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
159 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateWhiteList()) {
160 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
161 return;
162 }
163 }
164
UpdateAppDetails()165 void AppDomainVerifyAgentService::UpdateAppDetails()
166 {
167 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
168 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->UpdateAppDetails()) {
169 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
170 return;
171 }
172 }
CommonTransact(uint32_t opcode,const std::string & request,std::string & response)173 int AppDomainVerifyAgentService::CommonTransact(uint32_t opcode, const std::string& request, std::string& response)
174 {
175 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
176 if (ErrorCode::E_EXTENSIONS_LIB_NOT_FOUND != appDomainVerifyExtMgr_->CommonTransact(opcode, request, response)) {
177 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "extension call end");
178 return ErrorCode::E_INTERNAL_ERR;
179 }
180 return ErrorCode::E_OK;
181 }
182 // sa_main进程统一调用
OnStart(const SystemAbilityOnDemandReason & startReason)183 void AppDomainVerifyAgentService::OnStart(const SystemAbilityOnDemandReason& startReason)
184 {
185 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnStart reason %{public}s, reasonId_:%{public}d",
186 startReason.GetName().c_str(), startReason.GetId());
187 PostDelayUnloadTask();
188 bool res = Publish(this);
189 if (!res) {
190 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "Publish failed");
191 }
192 if (startReason.GetName() == LOOP_EVENT) {
193 DoLoopStart();
194 }
195 }
196
OnStop()197 void AppDomainVerifyAgentService::OnStop()
198 {
199 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
200 }
UnloadSa()201 void AppDomainVerifyAgentService::UnloadSa()
202 {
203 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa");
204 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
205 if (samgrProxy == nullptr) {
206 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "get samgr failed");
207 return;
208 }
209 int32_t ret = samgrProxy->UnloadSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID);
210 if (ret != 0) {
211 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "remove system ability failed");
212 return;
213 }
214 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do unload sa done");
215 }
216
IsIdle()217 bool AppDomainVerifyAgentService::IsIdle()
218 {
219 if (appDomainVerifyTaskMgr_ == nullptr) {
220 return true;
221 } else {
222 return appDomainVerifyTaskMgr_->IsIdle();
223 }
224 }
225
DoSync(const TaskType & type)226 void AppDomainVerifyAgentService::DoSync(const TaskType& type)
227 {
228 QueryAndCompleteRefresh(type);
229 UpdateAppDetails();
230 }
DoLoopStart()231 void AppDomainVerifyAgentService::DoLoopStart()
232 {
233 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
234 UpdateWhiteList();
235 }
236
IsNetAvailable()237 bool AppDomainVerifyAgentService::IsNetAvailable()
238 {
239 bool isNetAvailable = false;
240 NetManagerStandard::NetConnClient::GetInstance().HasDefaultNet(isNetAvailable);
241 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "IsNetAvailable:%{public}d", isNetAvailable);
242 return isNetAvailable;
243 }
244
DoSync()245 void AppDomainVerifyAgentService::DoSync()
246 {
247 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "do sync");
248 if (!isDoSyncDone && IsNetAvailable()) {
249 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "net connected, do sync once");
250 DoSync(BOOT_REFRESH_TASK);
251 isDoSyncDone = true;
252 }
253 }
254
CanUnloadSa()255 bool AppDomainVerifyAgentService::CanUnloadSa()
256 {
257 auto reachedMaxCnt = (retryCnt >= MAX_DELAY_RETRY_CNT - 1);
258 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE,
259 "can unload? isDoSyncDone:%{public}d, retryCnt:%{public}d, IsIdle:%{public}d, reachedMaxCnt:%{public}d, "
260 "maxCnt:%{public}d",
261 isDoSyncDone.load(), retryCnt.load(), IsIdle(), reachedMaxCnt, MAX_DELAY_RETRY_CNT);
262 return (isDoSyncDone || reachedMaxCnt) && IsIdle();
263 }
264
OnDelayUnloadSA()265 void AppDomainVerifyAgentService::OnDelayUnloadSA()
266 {
267 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task");
268 if (CanUnloadSa()) {
269 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "can unload sa");
270 UnloadSa();
271 return;
272 }
273
274 DoSync();
275 PostDelayUnloadTask();
276 retryCnt++;
277 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "on unload task, delay unload");
278 }
PostDelayUnloadTask()279 void AppDomainVerifyAgentService::PostDelayUnloadTask()
280 {
281 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "called");
282 unloadHandler_->RemoveTask(TASK_ID);
283 unloadHandler_->PostTask([this] { OnDelayUnloadSA(); }, TASK_ID, DELAY_TIME);
284 }
285
OnDump()286 void AppDomainVerifyAgentService::OnDump()
287 {
288 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "OnDump");
289 }
GetStatTime()290 std::string AppDomainVerifyAgentService::GetStatTime()
291 {
292 std::string startTime;
293 time_t tt = std::chrono::system_clock::to_time_t(now);
294 auto ptm = localtime(&tt);
295 if (ptm != nullptr) {
296 char date[FORMAT_BLANK_SIZE] = { 0 };
297 auto flag = sprintf_s(date, sizeof(date), "%04d-%02d-%02d %02d:%02d:%02d",
298 (int)ptm->tm_year + DUMP_SYSTEM_START_YEAR, (int)ptm->tm_mon + 1, (int)ptm->tm_mday, (int)ptm->tm_hour,
299 (int)ptm->tm_min, (int)ptm->tm_sec);
300 if (flag < 0) {
301 return startTime;
302 }
303 startTime = date;
304 }
305 return startTime;
306 }
Dump(int fd,const std::vector<std::u16string> & args)307 int AppDomainVerifyAgentService::Dump(int fd, const std::vector<std::u16string>& args)
308 {
309 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_SERVICE, "Dump");
310 std::string dumpString{};
311 dumpString.append("Agent start time: ");
312 dumpString.append(GetStatTime());
313 dumpString.append("\n");
314 dumpString.append("TaskMgr state: ");
315 IsIdle() ? dumpString.append("idle.") : dumpString.append("running.");
316 dumpString.append("\n");
317 dumpString.append("isDoSyncDone:");
318 isDoSyncDone ? dumpString.append("true.") : dumpString.append("false.");
319 dumpString.append("\n");
320 dumpString.append("retryCnt:");
321 dumpString.append(std::to_string(retryCnt));
322 dumpString.append("\n");
323 dumpString.append("maxCnt:");
324 dumpString.append(std::to_string(MAX_DELAY_RETRY_CNT));
325 dumpString.append("\n");
326 (void)write(fd, dumpString.c_str(), dumpString.size());
327 return 0;
328 }
329
330 } // namespace AppDomainVerify
331 } // namespace OHOS
332