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 "app_domain_verify_mgr_service_stub.h"
18 #include "sa_interface/app_domain_verify_mgr_interface_code.h"
19 #include "errors.h"
20 #include "app_domain_verify_parcel_util.h"
21 #include "iservice_registry.h"
22 #include "system_ability_definition.h"
23 #include "want.h"
24
25 namespace OHOS {
26 namespace AppDomainVerify {
27 namespace {
28 const std::string TASK_ID = "unload";
29 }
AppDomainVerifyMgrServiceStub()30 AppDomainVerifyMgrServiceStub::AppDomainVerifyMgrServiceStub()
31 {
32 }
~AppDomainVerifyMgrServiceStub()33 AppDomainVerifyMgrServiceStub::~AppDomainVerifyMgrServiceStub()
34 {
35 }
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)36 int32_t AppDomainVerifyMgrServiceStub::OnRemoteRequest(
37 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
38 {
39 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "onRemoteRequest##code = %{public}u", code);
40 std::u16string myDescripter = AppDomainVerifyMgrServiceStub::GetDescriptor();
41 std::u16string remoteDescripter = data.ReadInterfaceToken();
42 if (myDescripter != remoteDescripter) {
43 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "end##descriptor checked fail");
44 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
45 }
46
47 switch (code) {
48 case static_cast<uint32_t>(static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_VERIFY_STATUS)):
49 return OnQueryDomainVerifyStatus(data, reply);
50 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::VERIFY_DOMAIN):
51 return OnVerifyDomain(data, reply);
52 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::CLEAR_DOMAIN_VERIFY_RESULT):
53 return OnClearDomainVerifyStatus(data, reply);
54 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::FILTER_ABILITIES):
55 return OnFilterAbilities(data, reply);
56 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ALL_VERIFY_STATUS):
57 return OnQueryAllDomainVerifyStatus(data, reply);
58 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::SAVE_VERIFY_STATUS):
59 return OnSaveDomainVerifyStatus(data, reply);
60 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::IS_ATOMIC_SERVICE_URL):
61 return OnIsAtomicServiceUrl(data, reply);
62 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::CONVERT_TO_EXPLICIT_WANT):
63 return OnConvertToExplicitWant(data, reply);
64 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::UPDATE_WHITE_LIST_URLS):
65 return OnUpdateWhiteListUrls(data, reply);
66 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_DOMAINS):
67 return OnQueryAssociatedDomains(data, reply);
68 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_BUNDLE_NAMES):
69 return OnQueryAssociatedBundleNames(data, reply);
70 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::GET_DEFERRED_LINK):
71 return OnGetDeferredLink(data, reply);
72 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_APP_DETAILS_WANT):
73 return OnQueryAppDetailsWant(data, reply);
74 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::IS_SHORT_URL):
75 return OnIsShortUrl(data, reply);
76 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::CONVERT_FROM_SHORT_URL):
77 return OnConvertFromShortUrl(data, reply);
78 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ABILITY_INFOS):
79 return OnQueryAbilityInfos(data, reply);
80 default:
81 APP_DOMAIN_VERIFY_HILOGW(
82 APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "receive unknown code, code = %{public}d", code);
83 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
84 }
85 }
86
OnVerifyDomain(MessageParcel & data,MessageParcel & reply)87 int32_t AppDomainVerifyMgrServiceStub::OnVerifyDomain(MessageParcel& data, MessageParcel& reply)
88 {
89 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
90 std::string appIdentifier = data.ReadString();
91 std::string bundleName = data.ReadString();
92 std::string fingerprint = data.ReadString();
93 int32_t size = data.ReadInt32();
94 if (IsInvalidParcelArraySize(size)) {
95 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
96 return false;
97 }
98 std::vector<SkillUri> skillUris;
99 for (int32_t i = 0; i < size; i++) {
100 std::unique_ptr<SkillUri> info(data.ReadParcelable<SkillUri>());
101 if (!info) {
102 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable skillUri failed.");
103 return ERR_INVALID_VALUE;
104 }
105 skillUris.emplace_back(*info);
106 }
107
108 VerifyDomain(appIdentifier, bundleName, fingerprint, skillUris);
109 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
110 return ERR_OK;
111 }
112
OnClearDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)113 int32_t AppDomainVerifyMgrServiceStub::OnClearDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
114 {
115 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
116 std::string appIdentifier = data.ReadString();
117 std::string bundleName = data.ReadString();
118 bool status = ClearDomainVerifyStatus(appIdentifier, bundleName);
119
120 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
121 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
122 return ERR_OK;
123 }
124
OnFilterAbilities(MessageParcel & data,MessageParcel & reply)125 int32_t AppDomainVerifyMgrServiceStub::OnFilterAbilities(MessageParcel& data, MessageParcel& reply)
126 {
127 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
128 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
129 OHOS::AAFwk::Want want;
130 if (!w) {
131 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
132 return ERR_INVALID_VALUE;
133 }
134 want = *w;
135 std::vector<OHOS::AppExecFwk::AbilityInfo> originAbilityInfos;
136 int32_t size = data.ReadInt32();
137 if (IsInvalidParcelArraySize(size)) {
138 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
139 return false;
140 }
141 for (int32_t i = 0; i < size; i++) {
142 std::unique_ptr<OHOS::AppExecFwk::AbilityInfo> info(data.ReadParcelable<OHOS::AppExecFwk::AbilityInfo>());
143 if (!info) {
144 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable abilityInfo failed.");
145 return ERR_INVALID_VALUE;
146 }
147 originAbilityInfos.emplace_back(*info);
148 }
149 std::vector<OHOS::AppExecFwk::AbilityInfo> filtedAbilityInfos;
150 bool status = FilterAbilities(want, originAbilityInfos, filtedAbilityInfos);
151 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
152 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, filtedAbilityInfos.size());
153 for (auto& it : filtedAbilityInfos) {
154 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &it);
155 }
156 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
157 return ERR_OK;
158 }
159
OnQueryDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)160 int32_t AppDomainVerifyMgrServiceStub::OnQueryDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
161 {
162 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
163 std::string bundleName = data.ReadString();
164 DomainVerifyStatus domainVerificationState;
165 bool status = QueryDomainVerifyStatus(bundleName, domainVerificationState);
166 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
167 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, domainVerificationState);
168 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
169 return ERR_OK;
170 }
171
OnQueryAllDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)172 int32_t AppDomainVerifyMgrServiceStub::OnQueryAllDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
173 {
174 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
175 BundleVerifyStatusInfo bundleVerifyStatusInfo;
176 bool status = QueryAllDomainVerifyStatus(bundleVerifyStatusInfo);
177 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
178 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &bundleVerifyStatusInfo);
179 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
180 return ERR_OK;
181 }
182
OnSaveDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)183 int32_t AppDomainVerifyMgrServiceStub::OnSaveDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
184 {
185 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
186 std::string bundleName = data.ReadString();
187 std::unique_ptr<VerifyResultInfo> verifyResultInfo(data.ReadParcelable<VerifyResultInfo>());
188 if (verifyResultInfo == nullptr) {
189 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "verifyResultInfo null");
190 return ERR_INVALID_VALUE;
191 }
192 bool status = SaveDomainVerifyStatus(bundleName, *verifyResultInfo);
193 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
194 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
195 return ERR_OK;
196 }
OnIsAtomicServiceUrl(MessageParcel & data,MessageParcel & reply)197 int32_t AppDomainVerifyMgrServiceStub::OnIsAtomicServiceUrl(MessageParcel& data, MessageParcel& reply)
198 {
199 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
200 std::string url = data.ReadString();
201 bool status = IsAtomicServiceUrl(url);
202 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
203 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
204 return ERR_OK;
205 }
OnUpdateWhiteListUrls(MessageParcel & data,MessageParcel & reply)206 int32_t AppDomainVerifyMgrServiceStub::OnUpdateWhiteListUrls(MessageParcel& data, MessageParcel& reply)
207 {
208 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
209 uint32_t size = data.ReadUint32();
210 if (IsInvalidParcelArraySize(size)) {
211 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
212 return false;
213 }
214 std::vector<std::string> urls;
215 for (uint32_t i = 0; i < size; i++) {
216 auto url = data.ReadString();
217 urls.emplace_back(url);
218 }
219 UpdateWhiteListUrls(urls);
220 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
221 return 0;
222 }
OnConvertToExplicitWant(MessageParcel & data,MessageParcel & reply)223 int32_t AppDomainVerifyMgrServiceStub::OnConvertToExplicitWant(MessageParcel& data, MessageParcel& reply)
224 {
225 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
226 OHOS::AAFwk::Want want;
227 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
228 if (!w) {
229 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
230 return ERR_INVALID_VALUE;
231 }
232 want = *w;
233 sptr<IRemoteObject> object = data.ReadRemoteObject();
234 if (object == nullptr) {
235 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read failed");
236 return ERR_INVALID_VALUE;
237 }
238 sptr<IConvertCallback> cleanCacheCallback = iface_cast<IConvertCallback>(object);
239 ConvertToExplicitWant(want, cleanCacheCallback);
240 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
241 return ERR_OK;
242 }
OnQueryAssociatedDomains(MessageParcel & data,MessageParcel & reply)243 int32_t AppDomainVerifyMgrServiceStub::OnQueryAssociatedDomains(MessageParcel& data, MessageParcel& reply)
244 {
245 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
246 std::string bundleName;
247 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
248
249 std::vector<std::string> domains;
250 int ret = QueryAssociatedDomains(bundleName, domains);
251
252 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
253 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, domains.size());
254 for (const auto& i : domains) {
255 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, i);
256 }
257 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
258 return ERR_OK;
259 }
OnQueryAssociatedBundleNames(MessageParcel & data,MessageParcel & reply)260 int32_t AppDomainVerifyMgrServiceStub::OnQueryAssociatedBundleNames(MessageParcel& data, MessageParcel& reply)
261 {
262 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
263 std::string domain;
264 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, domain);
265 std::vector<std::string> bundleNames;
266
267 int ret = QueryAssociatedBundleNames(domain, bundleNames);
268
269 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
270 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, bundleNames.size());
271 for (const auto& i : bundleNames) {
272 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, i);
273 }
274 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
275 return ERR_OK;
276 }
OnGetDeferredLink(MessageParcel & data,MessageParcel & reply)277 int32_t AppDomainVerifyMgrServiceStub::OnGetDeferredLink(MessageParcel& data, MessageParcel& reply)
278 {
279 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
280 std::string link;
281 int ret = GetDeferredLink(link);
282
283 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
284 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, link);
285 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
286 return ERR_OK;
287 }
288
OnQueryAppDetailsWant(MessageParcel & data,MessageParcel & reply)289 int32_t AppDomainVerifyMgrServiceStub::OnQueryAppDetailsWant(MessageParcel& data, MessageParcel& reply)
290 {
291 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
292 AAFwk::Want want;
293 std::string url;
294 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
295 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
296 if (!w) {
297 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
298 return ERR_INVALID_VALUE;
299 }
300 want = *w;
301 int ret = QueryAppDetailsWant(url, want);
302 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, ret);
303 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &want);
304 return ERR_OK;
305 }
OnIsShortUrl(MessageParcel & data,MessageParcel & reply)306 int32_t AppDomainVerifyMgrServiceStub::OnIsShortUrl(MessageParcel& data, MessageParcel& reply)
307 {
308 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
309 std::string url = data.ReadString();
310 bool status = IsAtomicServiceUrl(url);
311 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
312 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
313 return ERR_OK;
314 }
OnConvertFromShortUrl(MessageParcel & data,MessageParcel & reply)315 int32_t AppDomainVerifyMgrServiceStub::OnConvertFromShortUrl(MessageParcel& data, MessageParcel& reply)
316 {
317 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
318 OHOS::AAFwk::Want want;
319 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
320 if (!w) {
321 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
322 return ERR_INVALID_VALUE;
323 }
324 want = *w;
325 sptr<IRemoteObject> object = data.ReadRemoteObject();
326 if (object == nullptr) {
327 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read failed");
328 return ERR_INVALID_VALUE;
329 }
330 sptr<IConvertCallback> cleanCacheCallback = iface_cast<IConvertCallback>(object);
331 ConvertToExplicitWant(want, cleanCacheCallback);
332 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
333 return ERR_OK;
334 }
OnQueryAbilityInfos(MessageParcel & data,MessageParcel & reply)335 int32_t AppDomainVerifyMgrServiceStub::OnQueryAbilityInfos(MessageParcel& data, MessageParcel& reply)
336 {
337 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
338 std::string url;
339 bool withDefault{ false };
340 bool findDefault{ false };
341 READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, url);
342 READ_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, data, withDefault);
343 std::vector<OHOS::AppExecFwk::AbilityInfo> abilityInfos;
344 bool status = QueryAbilityInfos(url, withDefault, abilityInfos, findDefault);
345 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
346 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, abilityInfos.size());
347 for (auto& it : abilityInfos) {
348 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &it);
349 }
350 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, findDefault);
351 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
352 return ERR_OK;
353 }
354
355 } // namespace AppDomainVerify
356 } // namespace OHOS