1 /*
2 * Copyright (c) 2021-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 "bundle_mgr_host_impl.h"
17
18 #include <dirent.h>
19 #include <future>
20 #include <set>
21 #include <string>
22
23 #include "app_log_wrapper.h"
24 #include "app_privilege_capability.h"
25 #include "bundle_mgr_service.h"
26 #include "bundle_parser.h"
27 #include "bundle_permission_mgr.h"
28 #include "bundle_sandbox_app_helper.h"
29 #include "bundle_util.h"
30 #include "bundle_verify_mgr.h"
31 #include "directory_ex.h"
32 #ifdef DISTRIBUTED_BUNDLE_FRAMEWORK
33 #include "distributed_bms_proxy.h"
34 #endif
35 #include "element_name.h"
36 #include "if_system_ability_manager.h"
37 #include "installd_client.h"
38 #include "ipc_skeleton.h"
39 #include "iservice_registry.h"
40 #include "json_serializer.h"
41 #include "system_ability_definition.h"
42
43 namespace OHOS {
44 namespace AppExecFwk {
GetApplicationInfo(const std::string & appName,const ApplicationFlag flag,const int userId,ApplicationInfo & appInfo)45 bool BundleMgrHostImpl::GetApplicationInfo(
46 const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo)
47 {
48 return GetApplicationInfo(appName, static_cast<int32_t>(flag), userId, appInfo);
49 }
50
GetApplicationInfo(const std::string & appName,int32_t flags,int32_t userId,ApplicationInfo & appInfo)51 bool BundleMgrHostImpl::GetApplicationInfo(
52 const std::string &appName, int32_t flags, int32_t userId, ApplicationInfo &appInfo)
53 {
54 APP_LOGD("start GetApplicationInfo, bundleName : %{public}s, flags : %{public}d, userId : %{public}d",
55 appName.c_str(), flags, userId);
56 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
57 APP_LOGD("non-system app calling system api");
58 return true;
59 }
60 if (!VerifyQueryPermission(appName)) {
61 APP_LOGE("verify permission failed");
62 return false;
63 }
64 APP_LOGD("verify permission success, begin to GetApplicationInfo");
65 auto dataMgr = GetDataMgrFromService();
66 if (dataMgr == nullptr) {
67 APP_LOGE("DataMgr is nullptr");
68 return false;
69 }
70 return dataMgr->GetApplicationInfo(appName, flags, userId, appInfo);
71 }
72
GetApplicationInfoV9(const std::string & appName,int32_t flags,int32_t userId,ApplicationInfo & appInfo)73 ErrCode BundleMgrHostImpl::GetApplicationInfoV9(
74 const std::string &appName, int32_t flags, int32_t userId, ApplicationInfo &appInfo)
75 {
76 APP_LOGD("start GetApplicationInfoV9, bundleName : %{public}s, flags : %{public}d, userId : %{public}d",
77 appName.c_str(), flags, userId);
78 if (!VerifySystemApi()) {
79 APP_LOGE("non-system app calling system api");
80 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
81 }
82 if (!VerifyQueryPermission(appName)) {
83 APP_LOGE("verify permission failed");
84 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
85 }
86 APP_LOGD("verify permission success, bgein to GetApplicationInfoV9");
87 auto dataMgr = GetDataMgrFromService();
88 if (dataMgr == nullptr) {
89 APP_LOGE("DataMgr is nullptr");
90 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
91 }
92 return dataMgr->GetApplicationInfoV9(appName, flags, userId, appInfo);
93 }
94
GetApplicationInfos(const ApplicationFlag flag,const int userId,std::vector<ApplicationInfo> & appInfos)95 bool BundleMgrHostImpl::GetApplicationInfos(
96 const ApplicationFlag flag, const int userId, std::vector<ApplicationInfo> &appInfos)
97 {
98 return GetApplicationInfos(static_cast<int32_t>(flag), userId, appInfos);
99 }
100
GetApplicationInfos(int32_t flags,int32_t userId,std::vector<ApplicationInfo> & appInfos)101 bool BundleMgrHostImpl::GetApplicationInfos(
102 int32_t flags, int32_t userId, std::vector<ApplicationInfo> &appInfos)
103 {
104 APP_LOGD("start GetApplicationInfos, flags : %{public}d, userId : %{public}d", flags, userId);
105 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
106 APP_LOGD("non-system app calling system api");
107 return true;
108 }
109 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
110 APP_LOGE("verify permission failed");
111 return false;
112 }
113 APP_LOGD("verify permission success, begin to GetApplicationInfos");
114 auto dataMgr = GetDataMgrFromService();
115 if (dataMgr == nullptr) {
116 APP_LOGE("DataMgr is nullptr");
117 return false;
118 }
119 return dataMgr->GetApplicationInfos(flags, userId, appInfos);
120 }
121
GetApplicationInfosV9(int32_t flags,int32_t userId,std::vector<ApplicationInfo> & appInfos)122 ErrCode BundleMgrHostImpl::GetApplicationInfosV9(
123 int32_t flags, int32_t userId, std::vector<ApplicationInfo> &appInfos)
124 {
125 APP_LOGD("start GetApplicationInfosV9, flags : %{public}d, userId : %{public}d", flags, userId);
126 if (!VerifySystemApi()) {
127 APP_LOGE("non-system app calling system api");
128 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
129 }
130 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
131 APP_LOGE("verify permission failed");
132 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
133 }
134 APP_LOGD("verify permission success, begin to GetApplicationInfosV9");
135 auto dataMgr = GetDataMgrFromService();
136 if (dataMgr == nullptr) {
137 APP_LOGE("DataMgr is nullptr");
138 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
139 }
140 return dataMgr->GetApplicationInfosV9(flags, userId, appInfos);
141 }
142
GetBundleInfo(const std::string & bundleName,const BundleFlag flag,BundleInfo & bundleInfo,int32_t userId)143 bool BundleMgrHostImpl::GetBundleInfo(
144 const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId)
145 {
146 return GetBundleInfo(bundleName, static_cast<int32_t>(flag), bundleInfo, userId);
147 }
148
GetBundleInfo(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId)149 bool BundleMgrHostImpl::GetBundleInfo(
150 const std::string &bundleName, int32_t flags, BundleInfo &bundleInfo, int32_t userId)
151 {
152 APP_LOGD("start GetBundleInfo, bundleName : %{public}s, flags : %{public}d, userId : %{public}d",
153 bundleName.c_str(), flags, userId);
154 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
155 APP_LOGD("non-system app calling system api");
156 return true;
157 }
158 if (!VerifyQueryPermission(bundleName)) {
159 APP_LOGE("verify permission failed");
160 return false;
161 }
162 APP_LOGD("verify permission success, begin to GetBundleInfo");
163 auto dataMgr = GetDataMgrFromService();
164 if (dataMgr == nullptr) {
165 APP_LOGE("DataMgr is nullptr");
166 return false;
167 }
168 return dataMgr->GetBundleInfo(bundleName, flags, bundleInfo, userId);
169 }
170
GetBundleInfoV9(const std::string & bundleName,int32_t flags,BundleInfo & bundleInfo,int32_t userId)171 ErrCode BundleMgrHostImpl::GetBundleInfoV9(
172 const std::string &bundleName, int32_t flags, BundleInfo &bundleInfo, int32_t userId)
173 {
174 APP_LOGD("start GetBundleInfoV9, bundleName : %{public}s, flags : %{public}d, userId : %{public}d",
175 bundleName.c_str(), flags, userId);
176 if (!VerifySystemApi()) {
177 APP_LOGE("non-system app calling system api");
178 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
179 }
180 if (!VerifyQueryPermission(bundleName)) {
181 APP_LOGE("verify permission failed");
182 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
183 }
184 APP_LOGD("verify permission success, begin to GetBundleInfoV9");
185 auto dataMgr = GetDataMgrFromService();
186 if (dataMgr == nullptr) {
187 APP_LOGE("DataMgr is nullptr");
188 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
189 }
190 return dataMgr->GetBundleInfoV9(bundleName, flags, bundleInfo, userId);
191 }
192
GetBundleInfoForSelf(int32_t flags,BundleInfo & bundleInfo)193 ErrCode BundleMgrHostImpl::GetBundleInfoForSelf(int32_t flags, BundleInfo &bundleInfo)
194 {
195 auto uid = IPCSkeleton::GetCallingUid();
196 int32_t userId = uid / Constants::BASE_USER_RANGE;
197 std::string bundleName;
198 bool ret = GetBundleNameForUid(uid, bundleName);
199 if (!ret) {
200 APP_LOGE("GetBundleNameForUid failed");
201 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
202 }
203 auto dataMgr = GetDataMgrFromService();
204 if (dataMgr == nullptr) {
205 APP_LOGE("DataMgr is nullptr");
206 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
207 }
208 return dataMgr->GetBundleInfoV9(bundleName, flags, bundleInfo, userId);
209 }
210
GetBundlePackInfo(const std::string & bundleName,const BundlePackFlag flag,BundlePackInfo & bundlePackInfo,int32_t userId)211 ErrCode BundleMgrHostImpl::GetBundlePackInfo(
212 const std::string &bundleName, const BundlePackFlag flag, BundlePackInfo &bundlePackInfo, int32_t userId)
213 {
214 return GetBundlePackInfo(bundleName, static_cast<int32_t>(flag), bundlePackInfo, userId);
215 }
216
GetBundlePackInfo(const std::string & bundleName,int32_t flags,BundlePackInfo & bundlePackInfo,int32_t userId)217 ErrCode BundleMgrHostImpl::GetBundlePackInfo(
218 const std::string &bundleName, int32_t flags, BundlePackInfo &bundlePackInfo, int32_t userId)
219 {
220 // check permission
221 if (!VerifySystemApi()) {
222 APP_LOGE("non-system app calling system api");
223 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
224 }
225 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
226 APP_LOGE("SetModuleUpgradeFlag failed due to lack of permission");
227 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
228 }
229 auto dataMgr = GetDataMgrFromService();
230 if (dataMgr == nullptr) {
231 APP_LOGE("DataMgr is nullptr");
232 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
233 }
234 return dataMgr->GetBundlePackInfo(bundleName, flags, bundlePackInfo, userId);
235 }
236
GetBundleUserInfo(const std::string & bundleName,int32_t userId,InnerBundleUserInfo & innerBundleUserInfo)237 bool BundleMgrHostImpl::GetBundleUserInfo(
238 const std::string &bundleName, int32_t userId, InnerBundleUserInfo &innerBundleUserInfo)
239 {
240 auto dataMgr = GetDataMgrFromService();
241 if (dataMgr == nullptr) {
242 APP_LOGE("DataMgr is nullptr");
243 return false;
244 }
245 return dataMgr->GetInnerBundleUserInfoByUserId(bundleName, userId, innerBundleUserInfo);
246 }
247
GetBundleUserInfos(const std::string & bundleName,std::vector<InnerBundleUserInfo> & innerBundleUserInfos)248 bool BundleMgrHostImpl::GetBundleUserInfos(
249 const std::string &bundleName, std::vector<InnerBundleUserInfo> &innerBundleUserInfos)
250 {
251 auto dataMgr = GetDataMgrFromService();
252 if (dataMgr == nullptr) {
253 APP_LOGE("DataMgr is nullptr");
254 return false;
255 }
256 return dataMgr->GetInnerBundleUserInfos(bundleName, innerBundleUserInfos);
257 }
258
GetBundleInfos(const BundleFlag flag,std::vector<BundleInfo> & bundleInfos,int32_t userId)259 bool BundleMgrHostImpl::GetBundleInfos(const BundleFlag flag, std::vector<BundleInfo> &bundleInfos, int32_t userId)
260 {
261 return GetBundleInfos(static_cast<int32_t>(flag), bundleInfos, userId);
262 }
263
GetBundleInfos(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId)264 bool BundleMgrHostImpl::GetBundleInfos(int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId)
265 {
266 APP_LOGD("start GetBundleInfos, flags : %{public}d, userId : %{public}d", flags, userId);
267 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
268 APP_LOGD("non-system app calling system api");
269 return true;
270 }
271 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
272 APP_LOGE("verify permission failed");
273 return false;
274 }
275 APP_LOGD("verify permission success, begin to GetBundleInfos");
276 auto dataMgr = GetDataMgrFromService();
277 if (dataMgr == nullptr) {
278 APP_LOGE("DataMgr is nullptr");
279 return false;
280 }
281 return dataMgr->GetBundleInfos(flags, bundleInfos, userId);
282 }
283
GetBundleInfosV9(int32_t flags,std::vector<BundleInfo> & bundleInfos,int32_t userId)284 ErrCode BundleMgrHostImpl::GetBundleInfosV9(int32_t flags, std::vector<BundleInfo> &bundleInfos, int32_t userId)
285 {
286 APP_LOGD("start GetBundleInfosV9, flags : %{public}d, userId : %{public}d", flags, userId);
287 if (!VerifySystemApi()) {
288 APP_LOGE("non-system app calling system api");
289 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
290 }
291 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
292 APP_LOGE("verify permission failed");
293 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
294 }
295 APP_LOGD("verify permission success, begin to GetBundleInfosV9");
296 auto dataMgr = GetDataMgrFromService();
297 if (dataMgr == nullptr) {
298 APP_LOGE("DataMgr is nullptr");
299 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
300 }
301 return dataMgr->GetBundleInfosV9(flags, bundleInfos, userId);
302 }
303
GetBundleNameForUid(const int uid,std::string & bundleName)304 bool BundleMgrHostImpl::GetBundleNameForUid(const int uid, std::string &bundleName)
305 {
306 APP_LOGD("start GetBundleNameForUid, uid : %{public}d", uid);
307 auto dataMgr = GetDataMgrFromService();
308 if (dataMgr == nullptr) {
309 APP_LOGE("DataMgr is nullptr");
310 return false;
311 }
312 return dataMgr->GetBundleNameForUid(uid, bundleName);
313 }
314
GetBundlesForUid(const int uid,std::vector<std::string> & bundleNames)315 bool BundleMgrHostImpl::GetBundlesForUid(const int uid, std::vector<std::string> &bundleNames)
316 {
317 APP_LOGD("start GetBundlesForUid, uid : %{public}d", uid);
318 if (!BundlePermissionMgr::IsNativeTokenType()) {
319 APP_LOGE("verify token type failed");
320 return false;
321 }
322 auto dataMgr = GetDataMgrFromService();
323 if (dataMgr == nullptr) {
324 APP_LOGE("DataMgr is nullptr");
325 return false;
326 }
327 return dataMgr->GetBundlesForUid(uid, bundleNames);
328 }
329
GetNameForUid(const int uid,std::string & name)330 ErrCode BundleMgrHostImpl::GetNameForUid(const int uid, std::string &name)
331 {
332 APP_LOGD("start GetNameForUid, uid : %{public}d", uid);
333 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
334 APP_LOGE("non-system app calling system api");
335 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
336 }
337 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
338 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
339 APP_LOGE("verify query permission failed");
340 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
341 }
342 auto dataMgr = GetDataMgrFromService();
343 if (dataMgr == nullptr) {
344 APP_LOGE("DataMgr is nullptr");
345 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
346 }
347 return dataMgr->GetNameForUid(uid, name);
348 }
349
GetBundleGids(const std::string & bundleName,std::vector<int> & gids)350 bool BundleMgrHostImpl::GetBundleGids(const std::string &bundleName, std::vector<int> &gids)
351 {
352 APP_LOGD("start GetBundleGids, bundleName : %{public}s", bundleName.c_str());
353 if (!BundlePermissionMgr::IsNativeTokenType()) {
354 APP_LOGE("verify token type failed");
355 return false;
356 }
357 auto dataMgr = GetDataMgrFromService();
358 if (dataMgr == nullptr) {
359 APP_LOGE("DataMgr is nullptr");
360 return false;
361 }
362 return dataMgr->GetBundleGids(bundleName, gids);
363 }
364
GetBundleGidsByUid(const std::string & bundleName,const int & uid,std::vector<int> & gids)365 bool BundleMgrHostImpl::GetBundleGidsByUid(const std::string &bundleName, const int &uid, std::vector<int> &gids)
366 {
367 APP_LOGD("start GetBundleGidsByUid, bundleName : %{public}s, uid : %{public}d", bundleName.c_str(), uid);
368 auto dataMgr = GetDataMgrFromService();
369 if (dataMgr == nullptr) {
370 APP_LOGE("DataMgr is nullptr");
371 return false;
372 }
373 return dataMgr->GetBundleGidsByUid(bundleName, uid, gids);
374 }
375
CheckIsSystemAppByUid(const int uid)376 bool BundleMgrHostImpl::CheckIsSystemAppByUid(const int uid)
377 {
378 APP_LOGD("start CheckIsSystemAppByUid, uid : %{public}d", uid);
379 auto dataMgr = GetDataMgrFromService();
380 if (dataMgr == nullptr) {
381 APP_LOGE("DataMgr is nullptr");
382 return false;
383 }
384 return dataMgr->CheckIsSystemAppByUid(uid);
385 }
386
GetBundleInfosByMetaData(const std::string & metaData,std::vector<BundleInfo> & bundleInfos)387 bool BundleMgrHostImpl::GetBundleInfosByMetaData(const std::string &metaData, std::vector<BundleInfo> &bundleInfos)
388 {
389 APP_LOGD("start GetBundleInfosByMetaData, metaData : %{public}s", metaData.c_str());
390 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
391 APP_LOGE("verify permission failed");
392 return false;
393 }
394 auto dataMgr = GetDataMgrFromService();
395 if (dataMgr == nullptr) {
396 APP_LOGE("DataMgr is nullptr");
397 return false;
398 }
399 return dataMgr->GetBundleInfosByMetaData(metaData, bundleInfos);
400 }
401
QueryAbilityInfo(const Want & want,AbilityInfo & abilityInfo)402 bool BundleMgrHostImpl::QueryAbilityInfo(const Want &want, AbilityInfo &abilityInfo)
403 {
404 return QueryAbilityInfo(want, GET_ABILITY_INFO_WITH_APPLICATION, Constants::UNSPECIFIED_USERID, abilityInfo);
405 }
406
407 #ifdef BUNDLE_FRAMEWORK_FREE_INSTALL
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,const sptr<IRemoteObject> & callBack)408 bool BundleMgrHostImpl::QueryAbilityInfo(const Want &want, int32_t flags, int32_t userId,
409 AbilityInfo &abilityInfo, const sptr<IRemoteObject> &callBack)
410 {
411 if (!BundlePermissionMgr::VerifyCallingUid()) {
412 APP_LOGE("QueryAbilityInfo verify failed.");
413 return false;
414 }
415 auto connectAbilityMgr = GetConnectAbilityMgrFromService();
416 if (connectAbilityMgr == nullptr) {
417 APP_LOGE("connectAbilityMgr is nullptr");
418 return false;
419 }
420 return connectAbilityMgr->QueryAbilityInfo(want, flags, userId, abilityInfo, callBack);
421 }
422
SilentInstall(const Want & want,int32_t userId,const sptr<IRemoteObject> & callBack)423 bool BundleMgrHostImpl::SilentInstall(const Want &want, int32_t userId, const sptr<IRemoteObject> &callBack)
424 {
425 APP_LOGD("SilentInstall in");
426 auto connectMgr = GetConnectAbilityMgrFromService();
427 if (connectMgr == nullptr) {
428 APP_LOGE("connectMgr is nullptr");
429 return false;
430 }
431 return connectMgr->SilentInstall(want, userId, callBack);
432 }
433
UpgradeAtomicService(const Want & want,int32_t userId)434 void BundleMgrHostImpl::UpgradeAtomicService(const Want &want, int32_t userId)
435 {
436 if (!BundlePermissionMgr::VerifyCallingUid()) {
437 APP_LOGE("UpgradeAtomicService verify failed.");
438 return;
439 }
440 auto connectAbilityMgr = GetConnectAbilityMgrFromService();
441 if (connectAbilityMgr == nullptr) {
442 APP_LOGE("connectAbilityMgr is nullptr");
443 return;
444 }
445 connectAbilityMgr->UpgradeAtomicService(want, userId);
446 }
447
CheckAbilityEnableInstall(const Want & want,int32_t missionId,int32_t userId,const sptr<IRemoteObject> & callback)448 bool BundleMgrHostImpl::CheckAbilityEnableInstall(
449 const Want &want, int32_t missionId, int32_t userId, const sptr<IRemoteObject> &callback)
450 {
451 if (!BundlePermissionMgr::IsNativeTokenType()) {
452 APP_LOGE("verify token type failed");
453 return false;
454 }
455 auto elementName = want.GetElement();
456 if (elementName.GetDeviceID().empty() || elementName.GetBundleName().empty() ||
457 elementName.GetAbilityName().empty()) {
458 APP_LOGE("check ability install parameter is invalid");
459 return false;
460 }
461 auto bundleDistributedManager = DelayedSingleton<BundleMgrService>::GetInstance()->GetBundleDistributedManager();
462 if (bundleDistributedManager == nullptr) {
463 APP_LOGE("bundleDistributedManager failed");
464 return false;
465 }
466 return bundleDistributedManager->CheckAbilityEnableInstall(want, missionId, userId, callback);
467 }
468
ProcessPreload(const Want & want)469 void BundleMgrHostImpl::ProcessPreload(const Want &want)
470 {
471 if (!BundlePermissionMgr::VerifyPreload(want)) {
472 APP_LOGE("ProcessPreload verify failed.");
473 return;
474 }
475 APP_LOGD("begin to process preload.");
476 auto connectAbilityMgr = GetConnectAbilityMgrFromService();
477 if (connectAbilityMgr == nullptr) {
478 APP_LOGE("connectAbilityMgr is nullptr");
479 return;
480 }
481 connectAbilityMgr->ProcessPreload(want);
482 }
483 #endif
484
QueryAbilityInfo(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo)485 bool BundleMgrHostImpl::QueryAbilityInfo(const Want &want, int32_t flags, int32_t userId, AbilityInfo &abilityInfo)
486 {
487 APP_LOGD("start QueryAbilityInfo, flags : %{public}d, userId : %{public}d", flags, userId);
488 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
489 APP_LOGD("non-system app calling system api");
490 return true;
491 }
492 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
493 APP_LOGE("verify permission failed");
494 return false;
495 }
496 APP_LOGD("verify permission success, begin to QueryAbilityInfo");
497 auto dataMgr = GetDataMgrFromService();
498 if (dataMgr == nullptr) {
499 APP_LOGE("DataMgr is nullptr");
500 return false;
501 }
502 return dataMgr->QueryAbilityInfo(want, flags, userId, abilityInfo);
503 }
504
QueryAbilityInfos(const Want & want,std::vector<AbilityInfo> & abilityInfos)505 bool BundleMgrHostImpl::QueryAbilityInfos(const Want &want, std::vector<AbilityInfo> &abilityInfos)
506 {
507 return QueryAbilityInfos(
508 want, GET_ABILITY_INFO_WITH_APPLICATION, Constants::UNSPECIFIED_USERID, abilityInfos);
509 }
510
QueryAbilityInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos)511 bool BundleMgrHostImpl::QueryAbilityInfos(
512 const Want &want, int32_t flags, int32_t userId, std::vector<AbilityInfo> &abilityInfos)
513 {
514 APP_LOGD("start QueryAbilityInfos, flags : %{public}d, userId : %{public}d", flags, userId);
515 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
516 APP_LOGD("non-system app calling system api");
517 return true;
518 }
519 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
520 APP_LOGE("verify permission failed");
521 return false;
522 }
523 APP_LOGD("verify permission success, begin to QueryAbilityInfos");
524 auto dataMgr = GetDataMgrFromService();
525 if (dataMgr == nullptr) {
526 APP_LOGE("DataMgr is nullptr");
527 return false;
528 }
529 return dataMgr->QueryAbilityInfos(want, flags, userId, abilityInfos);
530 }
531
QueryAbilityInfosV9(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos)532 ErrCode BundleMgrHostImpl::QueryAbilityInfosV9(
533 const Want &want, int32_t flags, int32_t userId, std::vector<AbilityInfo> &abilityInfos)
534 {
535 APP_LOGD("start QueryAbilityInfosV9, flags : %{public}d, userId : %{public}d", flags, userId);
536 if (!VerifySystemApi()) {
537 APP_LOGE("non-system app calling system api");
538 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
539 }
540 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
541 APP_LOGE("verify permission failed");
542 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
543 }
544 APP_LOGD("verify permission success, begin to QueryAbilityInfosV9");
545 auto dataMgr = GetDataMgrFromService();
546 if (dataMgr == nullptr) {
547 APP_LOGE("DataMgr is nullptr");
548 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
549 }
550 return dataMgr->QueryAbilityInfosV9(want, flags, userId, abilityInfos);
551 }
552
QueryAllAbilityInfos(const Want & want,int32_t userId,std::vector<AbilityInfo> & abilityInfos)553 bool BundleMgrHostImpl::QueryAllAbilityInfos(const Want &want, int32_t userId, std::vector<AbilityInfo> &abilityInfos)
554 {
555 APP_LOGD("start QueryAllAbilityInfos, userId : %{public}d", userId);
556 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
557 APP_LOGD("non-system app calling system api");
558 return true;
559 }
560 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
561 APP_LOGE("verify permission failed");
562 return false;
563 }
564 APP_LOGD("verify permission success, begin to QueryAllAbilityInfos");
565 auto dataMgr = GetDataMgrFromService();
566 if (dataMgr == nullptr) {
567 APP_LOGE("DataMgr is nullptr");
568 return false;
569 }
570 return dataMgr->QueryLauncherAbilityInfos(want, userId, abilityInfos);
571 }
572
QueryAbilityInfoByUri(const std::string & abilityUri,AbilityInfo & abilityInfo)573 bool BundleMgrHostImpl::QueryAbilityInfoByUri(const std::string &abilityUri, AbilityInfo &abilityInfo)
574 {
575 APP_LOGD("start QueryAbilityInfoByUri, uri : %{private}s", abilityUri.c_str());
576 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
577 APP_LOGE("non-system app calling system api");
578 return true;
579 }
580 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
581 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
582 APP_LOGE("verify query permission failed");
583 return false;
584 }
585 auto dataMgr = GetDataMgrFromService();
586 if (dataMgr == nullptr) {
587 APP_LOGE("DataMgr is nullptr");
588 return false;
589 }
590 return dataMgr->QueryAbilityInfoByUri(abilityUri, Constants::UNSPECIFIED_USERID, abilityInfo);
591 }
592
QueryAbilityInfosByUri(const std::string & abilityUri,std::vector<AbilityInfo> & abilityInfos)593 bool BundleMgrHostImpl::QueryAbilityInfosByUri(const std::string &abilityUri, std::vector<AbilityInfo> &abilityInfos)
594 {
595 APP_LOGD("start QueryAbilityInfosByUri, uri : %{private}s", abilityUri.c_str());
596 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
597 APP_LOGD("non-system app calling system api");
598 return true;
599 }
600 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
601 APP_LOGE("verify permission failed");
602 return false;
603 }
604 auto dataMgr = GetDataMgrFromService();
605 if (dataMgr == nullptr) {
606 APP_LOGE("DataMgr is nullptr");
607 return false;
608 }
609 return dataMgr->QueryAbilityInfosByUri(abilityUri, abilityInfos);
610 }
611
QueryAbilityInfoByUri(const std::string & abilityUri,int32_t userId,AbilityInfo & abilityInfo)612 bool BundleMgrHostImpl::QueryAbilityInfoByUri(
613 const std::string &abilityUri, int32_t userId, AbilityInfo &abilityInfo)
614 {
615 APP_LOGD("start QueryAbilityInfoByUri, uri : %{private}s, userId : %{public}d", abilityUri.c_str(), userId);
616 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
617 APP_LOGE("non-system app calling system api");
618 return true;
619 }
620 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
621 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
622 APP_LOGE("verify query permission failed");
623 return false;
624 }
625 auto dataMgr = GetDataMgrFromService();
626 if (dataMgr == nullptr) {
627 APP_LOGE("DataMgr is nullptr");
628 return false;
629 }
630 return dataMgr->QueryAbilityInfoByUri(abilityUri, userId, abilityInfo);
631 }
632
QueryKeepAliveBundleInfos(std::vector<BundleInfo> & bundleInfos)633 bool BundleMgrHostImpl::QueryKeepAliveBundleInfos(std::vector<BundleInfo> &bundleInfos)
634 {
635 auto dataMgr = GetDataMgrFromService();
636 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
637 APP_LOGE("verify permission failed");
638 return false;
639 }
640 if (dataMgr == nullptr) {
641 APP_LOGE("DataMgr is nullptr");
642 return false;
643 }
644 return dataMgr->QueryKeepAliveBundleInfos(bundleInfos);
645 }
646
GetAbilityLabel(const std::string & bundleName,const std::string & abilityName)647 std::string BundleMgrHostImpl::GetAbilityLabel(const std::string &bundleName, const std::string &abilityName)
648 {
649 APP_LOGD("start GetAbilityLabel, bundleName : %{public}s, abilityName : %{public}s",
650 bundleName.c_str(), abilityName.c_str());
651 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
652 APP_LOGD("non-system app calling system api");
653 return Constants::EMPTY_STRING;
654 }
655 if (!VerifyQueryPermission(bundleName)) {
656 APP_LOGE("verify permission failed");
657 return Constants::EMPTY_STRING;
658 }
659 auto dataMgr = GetDataMgrFromService();
660 if (dataMgr == nullptr) {
661 APP_LOGE("DataMgr is nullptr");
662 return Constants::EMPTY_STRING;
663 }
664 std::string label;
665 ErrCode ret = dataMgr->GetAbilityLabel(bundleName, Constants::EMPTY_STRING, abilityName, label);
666 if (ret != ERR_OK) {
667 return Constants::EMPTY_STRING;
668 }
669 return label;
670 }
671
GetAbilityLabel(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,std::string & label)672 ErrCode BundleMgrHostImpl::GetAbilityLabel(const std::string &bundleName, const std::string &moduleName,
673 const std::string &abilityName, std::string &label)
674 {
675 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
676 APP_LOGE("non-system app calling system api");
677 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
678 }
679 if (!VerifyQueryPermission(bundleName)) {
680 APP_LOGE("verify permission failed");
681 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
682 }
683 auto dataMgr = GetDataMgrFromService();
684 if (dataMgr == nullptr) {
685 APP_LOGE("DataMgr is nullptr");
686 return ERR_APPEXECFWK_SERVICE_NOT_READY;
687 }
688 return dataMgr->GetAbilityLabel(bundleName, moduleName, abilityName, label);
689 }
690
GetBundleArchiveInfo(const std::string & hapFilePath,const BundleFlag flag,BundleInfo & bundleInfo)691 bool BundleMgrHostImpl::GetBundleArchiveInfo(
692 const std::string &hapFilePath, const BundleFlag flag, BundleInfo &bundleInfo)
693 {
694 return GetBundleArchiveInfo(hapFilePath, static_cast<int32_t>(flag), bundleInfo);
695 }
696
GetBundleArchiveInfo(const std::string & hapFilePath,int32_t flags,BundleInfo & bundleInfo)697 bool BundleMgrHostImpl::GetBundleArchiveInfo(
698 const std::string &hapFilePath, int32_t flags, BundleInfo &bundleInfo)
699 {
700 APP_LOGD("start GetBundleArchiveInfo, hapFilePath : %{public}s, flags : %{public}d", hapFilePath.c_str(), flags);
701 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
702 APP_LOGD("non-system app calling system api");
703 return true;
704 }
705 if (hapFilePath.find(Constants::SANDBOX_DATA_PATH) == std::string::npos) {
706 std::string realPath;
707 auto ret = BundleUtil::CheckFilePath(hapFilePath, realPath);
708 if (ret != ERR_OK) {
709 APP_LOGE("GetBundleArchiveInfo file path %{private}s invalid", hapFilePath.c_str());
710 return false;
711 }
712
713 InnerBundleInfo info;
714 BundleParser bundleParser;
715 ret = bundleParser.Parse(realPath, info);
716 if (ret != ERR_OK) {
717 APP_LOGE("parse bundle info failed, error: %{public}d", ret);
718 return false;
719 }
720 APP_LOGD("verify permission success, begin to GetBundleArchiveInfo");
721 info.GetBundleInfo(flags, bundleInfo, Constants::NOT_EXIST_USERID);
722 return true;
723 } else {
724 return GetBundleArchiveInfoBySandBoxPath(hapFilePath, flags, bundleInfo) == ERR_OK;
725 }
726 }
727
GetBundleArchiveInfoV9(const std::string & hapFilePath,int32_t flags,BundleInfo & bundleInfo)728 ErrCode BundleMgrHostImpl::GetBundleArchiveInfoV9(
729 const std::string &hapFilePath, int32_t flags, BundleInfo &bundleInfo)
730 {
731 APP_LOGD("start GetBundleArchiveInfoV9, hapFilePath : %{public}s, flags : %{public}d", hapFilePath.c_str(), flags);
732 if (!VerifySystemApi()) {
733 APP_LOGE("non-system app calling system api");
734 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
735 }
736 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
737 APP_LOGE("verify permission failed");
738 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
739 }
740 if (hapFilePath.find(Constants::SANDBOX_DATA_PATH) == 0) {
741 APP_LOGD("sandbox path");
742 return GetBundleArchiveInfoBySandBoxPath(hapFilePath, flags, bundleInfo, true);
743 }
744 std::string realPath;
745 ErrCode ret = BundleUtil::CheckFilePath(hapFilePath, realPath);
746 if (ret != ERR_OK) {
747 APP_LOGE("GetBundleArchiveInfoV9 file path %{private}s invalid", hapFilePath.c_str());
748 return ERR_BUNDLE_MANAGER_INVALID_HAP_PATH;
749 }
750 InnerBundleInfo info;
751 BundleParser bundleParser;
752 ret = bundleParser.Parse(realPath, info);
753 if (ret != ERR_OK) {
754 APP_LOGE("parse bundle info failed, error: %{public}d", ret);
755 return ERR_BUNDLE_MANAGER_INVALID_HAP_PATH;
756 }
757 info.GetBundleInfoV9(flags, bundleInfo, Constants::NOT_EXIST_USERID);
758 return ERR_OK;
759 }
760
GetBundleArchiveInfoBySandBoxPath(const std::string & hapFilePath,int32_t flags,BundleInfo & bundleInfo,bool fromV9)761 ErrCode BundleMgrHostImpl::GetBundleArchiveInfoBySandBoxPath(const std::string &hapFilePath,
762 int32_t flags, BundleInfo &bundleInfo, bool fromV9)
763 {
764 std::string bundleName;
765 int32_t apiVersion = fromV9 ? Constants::INVALID_API_VERSION : Constants::API_VERSION_NINE;
766 if (!VerifySystemApi(apiVersion)) {
767 APP_LOGE("non-system app calling system api");
768 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
769 }
770 if (!ObtainCallingBundleName(bundleName)) {
771 APP_LOGE("get calling bundleName failed");
772 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
773 }
774 std::string hapRealPath;
775 if (!BundleUtil::RevertToRealPath(hapFilePath, bundleName, hapRealPath)) {
776 APP_LOGE("GetBundleArchiveInfo RevertToRealPath failed");
777 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
778 }
779 std::string tempHapPath = Constants::BUNDLE_MANAGER_SERVICE_PATH +
780 Constants::PATH_SEPARATOR + std::to_string(BundleUtil::GetCurrentTime());
781 if (!BundleUtil::CreateDir(tempHapPath)) {
782 APP_LOGE("GetBundleArchiveInfo make temp dir failed");
783 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
784 }
785 std::string hapName = hapFilePath.substr(hapFilePath.find_last_of("//") + 1);
786 std::string tempHapFile = tempHapPath + Constants::PATH_SEPARATOR + hapName;
787 if (InstalldClient::GetInstance()->CopyFile(hapRealPath, tempHapFile) != ERR_OK) {
788 APP_LOGE("GetBundleArchiveInfo copy hap file failed");
789 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
790 }
791 std::string realPath;
792 auto ret = BundleUtil::CheckFilePath(tempHapFile, realPath);
793 if (ret != ERR_OK) {
794 APP_LOGE("CheckFilePath failed");
795 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
796 }
797 InnerBundleInfo info;
798 BundleParser bundleParser;
799 ret = bundleParser.Parse(realPath, info);
800 if (ret != ERR_OK) {
801 APP_LOGE("parse bundle info failed, error: %{public}d", ret);
802 BundleUtil::DeleteDir(tempHapPath);
803 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
804 }
805 BundleUtil::DeleteDir(tempHapPath);
806 APP_LOGD("verify permission success, begin to GetBundleArchiveInfo");
807 if (fromV9) {
808 info.GetBundleInfoV9(flags, bundleInfo, Constants::NOT_EXIST_USERID);
809 } else {
810 info.GetBundleInfo(flags, bundleInfo, Constants::NOT_EXIST_USERID);
811 }
812 return ERR_OK;
813 }
814
GetHapModuleInfo(const AbilityInfo & abilityInfo,HapModuleInfo & hapModuleInfo)815 bool BundleMgrHostImpl::GetHapModuleInfo(const AbilityInfo &abilityInfo, HapModuleInfo &hapModuleInfo)
816 {
817 APP_LOGD("start GetHapModuleInfo");
818 return GetHapModuleInfo(abilityInfo, Constants::UNSPECIFIED_USERID, hapModuleInfo);
819 }
820
GetHapModuleInfo(const AbilityInfo & abilityInfo,int32_t userId,HapModuleInfo & hapModuleInfo)821 bool BundleMgrHostImpl::GetHapModuleInfo(const AbilityInfo &abilityInfo, int32_t userId, HapModuleInfo &hapModuleInfo)
822 {
823 APP_LOGD("start GetHapModuleInfo with userId: %{public}d", userId);
824 if (!VerifyQueryPermission(abilityInfo.bundleName)) {
825 APP_LOGE("verify permission failed");
826 return false;
827 }
828 if (abilityInfo.bundleName.empty() || abilityInfo.package.empty()) {
829 APP_LOGE("fail to GetHapModuleInfo due to params empty");
830 return false;
831 }
832 auto dataMgr = GetDataMgrFromService();
833 if (dataMgr == nullptr) {
834 APP_LOGE("DataMgr is nullptr");
835 return false;
836 }
837 return dataMgr->GetHapModuleInfo(abilityInfo, hapModuleInfo, userId);
838 }
839
GetLaunchWantForBundle(const std::string & bundleName,Want & want,int32_t userId)840 ErrCode BundleMgrHostImpl::GetLaunchWantForBundle(const std::string &bundleName, Want &want, int32_t userId)
841 {
842 APP_LOGD("start GetLaunchWantForBundle, bundleName : %{public}s", bundleName.c_str());
843 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
844 APP_LOGE("non-system app calling system api");
845 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
846 }
847 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
848 APP_LOGE("verify permission failed");
849 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
850 }
851
852 APP_LOGD("verify permission success, begin to GetLaunchWantForBundle");
853 auto dataMgr = GetDataMgrFromService();
854 if (dataMgr == nullptr) {
855 APP_LOGE("DataMgr is nullptr");
856 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
857 }
858
859 return dataMgr->GetLaunchWantForBundle(bundleName, want, userId);
860 }
861
CheckPublicKeys(const std::string & firstBundleName,const std::string & secondBundleName)862 int BundleMgrHostImpl::CheckPublicKeys(const std::string &firstBundleName, const std::string &secondBundleName)
863 {
864 APP_LOGD("start CheckPublicKeys, firstBundleName : %{public}s, secondBundleName : %{public}s",
865 firstBundleName.c_str(), secondBundleName.c_str());
866 if (!BundlePermissionMgr::IsNativeTokenType()) {
867 APP_LOGE("verify token type failed");
868 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
869 }
870 auto dataMgr = GetDataMgrFromService();
871 if (dataMgr == nullptr) {
872 APP_LOGE("DataMgr is nullptr");
873 return false;
874 }
875 return dataMgr->CheckPublicKeys(firstBundleName, secondBundleName);
876 }
877
GetPermissionDef(const std::string & permissionName,PermissionDef & permissionDef)878 ErrCode BundleMgrHostImpl::GetPermissionDef(const std::string &permissionName, PermissionDef &permissionDef)
879 {
880 if (!VerifySystemApi()) {
881 APP_LOGE("non-system app calling system api");
882 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
883 }
884 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
885 APP_LOGE("verify GET_BUNDLE_INFO_PRIVILEGED failed");
886 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
887 }
888 if (permissionName.empty()) {
889 APP_LOGW("fail to GetPermissionDef due to params empty");
890 return ERR_BUNDLE_MANAGER_QUERY_PERMISSION_DEFINE_FAILED;
891 }
892 return BundlePermissionMgr::GetPermissionDef(permissionName, permissionDef);
893 }
894
HasSystemCapability(const std::string & capName)895 bool BundleMgrHostImpl::HasSystemCapability(const std::string &capName)
896 {
897 return true;
898 }
899
GetSystemAvailableCapabilities(std::vector<std::string> & systemCaps)900 bool BundleMgrHostImpl::GetSystemAvailableCapabilities(std::vector<std::string> &systemCaps)
901 {
902 return true;
903 }
904
IsSafeMode()905 bool BundleMgrHostImpl::IsSafeMode()
906 {
907 return true;
908 }
909
CleanBundleCacheFiles(const std::string & bundleName,const sptr<ICleanCacheCallback> & cleanCacheCallback,int32_t userId)910 ErrCode BundleMgrHostImpl::CleanBundleCacheFiles(
911 const std::string &bundleName, const sptr<ICleanCacheCallback> &cleanCacheCallback,
912 int32_t userId)
913 {
914 if (userId == Constants::UNSPECIFIED_USERID) {
915 userId = BundleUtil::GetUserIdByCallingUid();
916 }
917
918 APP_LOGD("start CleanBundleCacheFiles, bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
919 if (!VerifySystemApi()) {
920 APP_LOGE("non-system app calling system api");
921 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
922 }
923 if (userId < 0) {
924 APP_LOGE("userId is invalid");
925 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
926 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
927 }
928
929 if (bundleName.empty() || !cleanCacheCallback) {
930 APP_LOGE("the cleanCacheCallback is nullptr or bundleName empty");
931 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
932 return ERR_BUNDLE_MANAGER_PARAM_ERROR;
933 }
934
935 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_REMOVECACHEFILE)) {
936 APP_LOGE("ohos.permission.REMOVE_CACHE_FILES permission denied");
937 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
938 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
939 }
940
941 ApplicationInfo applicationInfo;
942 auto dataMgr = GetDataMgrFromService();
943 if (dataMgr == nullptr) {
944 APP_LOGE("DataMgr is nullptr");
945 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
946 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
947 }
948
949 auto ret = dataMgr->GetApplicationInfoV9(bundleName,
950 static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_DISABLE), userId, applicationInfo);
951 if (ret != ERR_OK) {
952 APP_LOGE("can not get application info of %{public}s", bundleName.c_str());
953 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
954 return ret;
955 }
956
957 if (applicationInfo.isSystemApp && !applicationInfo.userDataClearable) {
958 APP_LOGE("can not clean cacheFiles of %{public}s due to userDataClearable is false", bundleName.c_str());
959 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, true);
960 return ERR_BUNDLE_MANAGER_CAN_NOT_CLEAR_USER_DATA;
961 }
962
963 CleanBundleCacheTask(bundleName, cleanCacheCallback, dataMgr, userId);
964 return ERR_OK;
965 }
966
CleanBundleCacheTask(const std::string & bundleName,const sptr<ICleanCacheCallback> & cleanCacheCallback,const std::shared_ptr<BundleDataMgr> & dataMgr,int32_t userId)967 void BundleMgrHostImpl::CleanBundleCacheTask(const std::string &bundleName,
968 const sptr<ICleanCacheCallback> &cleanCacheCallback,
969 const std::shared_ptr<BundleDataMgr> &dataMgr,
970 int32_t userId)
971 {
972 std::vector<std::string> rootDir;
973 for (const auto &el : Constants::BUNDLE_EL) {
974 std::string dataDir = Constants::BUNDLE_APP_DATA_BASE_DIR + el +
975 Constants::PATH_SEPARATOR + std::to_string(userId) + Constants::BASE + bundleName;
976 rootDir.emplace_back(dataDir);
977 }
978
979 auto cleanCache = [bundleName, userId, rootDir, dataMgr, cleanCacheCallback, this]() {
980 std::vector<std::string> caches;
981 for (const auto &st : rootDir) {
982 std::vector<std::string> cache;
983 if (InstalldClient::GetInstance()->GetBundleCachePath(st, cache) != ERR_OK) {
984 APP_LOGW("GetBundleCachePath failed, path: %{public}s", st.c_str());
985 }
986 std::copy(cache.begin(), cache.end(), std::back_inserter(caches));
987 }
988
989 bool succeed = true;
990 if (!caches.empty()) {
991 for (const auto& cache : caches) {
992 ErrCode ret = InstalldClient::GetInstance()->CleanBundleDataDir(cache);
993 if (ret != ERR_OK) {
994 APP_LOGE("CleanBundleDataDir failed, path: %{private}s", cache.c_str());
995 succeed = false;
996 }
997 }
998 }
999 EventReport::SendCleanCacheSysEvent(bundleName, userId, true, !succeed);
1000 APP_LOGD("CleanBundleCacheFiles with succeed %{public}d", succeed);
1001 cleanCacheCallback->OnCleanCacheFinished(succeed);
1002 InnerBundleUserInfo innerBundleUserInfo;
1003 if (!this->GetBundleUserInfo(bundleName, userId, innerBundleUserInfo)) {
1004 APP_LOGW("Get calling userInfo in bundle(%{public}s) failed", bundleName.c_str());
1005 return;
1006 }
1007 NotifyBundleEvents installRes = {
1008 .bundleName = bundleName,
1009 .resultCode = ERR_OK,
1010 .type = NotifyType::BUNDLE_CACHE_CLEARED,
1011 .uid = innerBundleUserInfo.uid,
1012 .accessTokenId = innerBundleUserInfo.accessTokenId
1013 };
1014 NotifyBundleStatus(installRes);
1015 };
1016 handler_->PostTask(cleanCache);
1017 }
1018
CleanBundleDataFiles(const std::string & bundleName,const int userId)1019 bool BundleMgrHostImpl::CleanBundleDataFiles(const std::string &bundleName, const int userId)
1020 {
1021 APP_LOGD("start CleanBundleDataFiles, bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
1022 if (!VerifySystemApi()) {
1023 APP_LOGE("ohos.permission.REMOVE_CACHE_FILES system api denied");
1024 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1025 return false;
1026 }
1027 if (bundleName.empty() || userId < 0) {
1028 APP_LOGE("the bundleName empty or invalid userid");
1029 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1030 return false;
1031 }
1032 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_REMOVECACHEFILE)) {
1033 APP_LOGE("ohos.permission.REMOVE_CACHE_FILES permission denied");
1034 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1035 return false;
1036 }
1037 ApplicationInfo applicationInfo;
1038 if (GetApplicationInfoV9(bundleName, static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_DISABLE),
1039 userId, applicationInfo) != ERR_OK) {
1040 APP_LOGE("can not get application info of %{public}s", bundleName.c_str());
1041 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1042 return false;
1043 }
1044
1045 if (applicationInfo.isSystemApp && !applicationInfo.userDataClearable) {
1046 APP_LOGE("can not clean dataFiles of %{public}s due to userDataClearable is false", bundleName.c_str());
1047 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1048 return false;
1049 }
1050
1051 InnerBundleUserInfo innerBundleUserInfo;
1052 if (!GetBundleUserInfo(bundleName, userId, innerBundleUserInfo)) {
1053 APP_LOGE("%{public}s, userId:%{public}d, GetBundleUserInfo failed", bundleName.c_str(), userId);
1054 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1055 return false;
1056 }
1057
1058 if (BundlePermissionMgr::ClearUserGrantedPermissionState(applicationInfo.accessTokenId)) {
1059 APP_LOGE("%{public}s, ClearUserGrantedPermissionState failed", bundleName.c_str());
1060 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1061 return false;
1062 }
1063
1064 if (InstalldClient::GetInstance()->RemoveBundleDataDir(bundleName, userId) != ERR_OK) {
1065 APP_LOGE("%{public}s, RemoveBundleDataDir failed", bundleName.c_str());
1066 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1067 return false;
1068 }
1069
1070 if (InstalldClient::GetInstance()->CreateBundleDataDir(bundleName, userId, innerBundleUserInfo.uid,
1071 innerBundleUserInfo.uid, GetAppPrivilegeLevel(bundleName, userId))) {
1072 APP_LOGE("%{public}s, CreateBundleDataDir failed", bundleName.c_str());
1073 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, true);
1074 return false;
1075 }
1076
1077 EventReport::SendCleanCacheSysEvent(bundleName, userId, false, false);
1078 return true;
1079 }
1080
RegisterBundleStatusCallback(const sptr<IBundleStatusCallback> & bundleStatusCallback)1081 bool BundleMgrHostImpl::RegisterBundleStatusCallback(const sptr<IBundleStatusCallback> &bundleStatusCallback)
1082 {
1083 APP_LOGD("start RegisterBundleStatusCallback");
1084 if ((!bundleStatusCallback) || (bundleStatusCallback->GetBundleName().empty())) {
1085 APP_LOGE("the bundleStatusCallback is nullptr or bundleName empty");
1086 return false;
1087 }
1088 // check permission
1089 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::LISTEN_BUNDLE_CHANGE)) {
1090 APP_LOGE("register bundle status callback failed due to lack of permission");
1091 return false;
1092 }
1093
1094 auto dataMgr = GetDataMgrFromService();
1095 if (dataMgr == nullptr) {
1096 APP_LOGE("DataMgr is nullptr");
1097 return false;
1098 }
1099 return dataMgr->RegisterBundleStatusCallback(bundleStatusCallback);
1100 }
1101
RegisterBundleEventCallback(const sptr<IBundleEventCallback> & bundleEventCallback)1102 bool BundleMgrHostImpl::RegisterBundleEventCallback(const sptr<IBundleEventCallback> &bundleEventCallback)
1103 {
1104 APP_LOGD("begin to RegisterBundleEventCallback");
1105 if (bundleEventCallback == nullptr) {
1106 APP_LOGE("bundleEventCallback is null");
1107 return false;
1108 }
1109 if (IPCSkeleton::GetCallingUid() != Constants::FOUNDATION_UID) {
1110 APP_LOGE("verify calling uid failed");
1111 return false;
1112 }
1113 auto dataMgr = GetDataMgrFromService();
1114 if (dataMgr == nullptr) {
1115 APP_LOGE("DataMgr is nullptr");
1116 return false;
1117 }
1118 return dataMgr->RegisterBundleEventCallback(bundleEventCallback);
1119 }
1120
UnregisterBundleEventCallback(const sptr<IBundleEventCallback> & bundleEventCallback)1121 bool BundleMgrHostImpl::UnregisterBundleEventCallback(const sptr<IBundleEventCallback> &bundleEventCallback)
1122 {
1123 APP_LOGD("begin to UnregisterBundleEventCallback");
1124 if (bundleEventCallback == nullptr) {
1125 APP_LOGE("bundleEventCallback is null");
1126 return false;
1127 }
1128 if (IPCSkeleton::GetCallingUid() != Constants::FOUNDATION_UID) {
1129 APP_LOGE("verify calling uid failed");
1130 return false;
1131 }
1132 auto dataMgr = GetDataMgrFromService();
1133 if (dataMgr == nullptr) {
1134 APP_LOGE("DataMgr is nullptr");
1135 return false;
1136 }
1137 return dataMgr->UnregisterBundleEventCallback(bundleEventCallback);
1138 }
1139
ClearBundleStatusCallback(const sptr<IBundleStatusCallback> & bundleStatusCallback)1140 bool BundleMgrHostImpl::ClearBundleStatusCallback(const sptr<IBundleStatusCallback> &bundleStatusCallback)
1141 {
1142 APP_LOGD("start ClearBundleStatusCallback");
1143 if (!bundleStatusCallback) {
1144 APP_LOGE("the bundleStatusCallback is nullptr");
1145 return false;
1146 }
1147
1148 // check permission
1149 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::LISTEN_BUNDLE_CHANGE)) {
1150 APP_LOGE("register bundle status callback failed due to lack of permission");
1151 return false;
1152 }
1153
1154 auto dataMgr = GetDataMgrFromService();
1155 if (dataMgr == nullptr) {
1156 APP_LOGE("DataMgr is nullptr");
1157 return false;
1158 }
1159 return dataMgr->ClearBundleStatusCallback(bundleStatusCallback);
1160 }
1161
UnregisterBundleStatusCallback()1162 bool BundleMgrHostImpl::UnregisterBundleStatusCallback()
1163 {
1164 APP_LOGD("start UnregisterBundleStatusCallback");
1165 // check permission
1166 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::LISTEN_BUNDLE_CHANGE)) {
1167 APP_LOGE("register bundle status callback failed due to lack of permission");
1168 return false;
1169 }
1170
1171 auto dataMgr = GetDataMgrFromService();
1172 if (dataMgr == nullptr) {
1173 APP_LOGE("DataMgr is nullptr");
1174 return false;
1175 }
1176 return dataMgr->UnregisterBundleStatusCallback();
1177 }
1178
DumpInfos(const DumpFlag flag,const std::string & bundleName,int32_t userId,std::string & result)1179 bool BundleMgrHostImpl::DumpInfos(
1180 const DumpFlag flag, const std::string &bundleName, int32_t userId, std::string &result)
1181 {
1182 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1183 APP_LOGE("verify permission failed");
1184 return false;
1185 }
1186 bool ret = false;
1187 switch (flag) {
1188 case DumpFlag::DUMP_BUNDLE_LIST: {
1189 ret = DumpAllBundleInfoNames(userId, result);
1190 break;
1191 }
1192 case DumpFlag::DUMP_BUNDLE_INFO: {
1193 ret = DumpBundleInfo(bundleName, userId, result);
1194 break;
1195 }
1196 case DumpFlag::DUMP_SHORTCUT_INFO: {
1197 ret = DumpShortcutInfo(bundleName, userId, result);
1198 break;
1199 }
1200 default:
1201 APP_LOGE("dump flag error");
1202 return false;
1203 }
1204 return ret;
1205 }
1206
DumpAllBundleInfoNames(int32_t userId,std::string & result)1207 bool BundleMgrHostImpl::DumpAllBundleInfoNames(int32_t userId, std::string &result)
1208 {
1209 APP_LOGD("DumpAllBundleInfoNames begin");
1210 if (userId != Constants::ALL_USERID) {
1211 return DumpAllBundleInfoNamesByUserId(userId, result);
1212 }
1213
1214 auto userIds = GetExistsCommonUserIs();
1215 for (auto userId : userIds) {
1216 DumpAllBundleInfoNamesByUserId(userId, result);
1217 }
1218
1219 APP_LOGD("DumpAllBundleInfoNames success");
1220 return true;
1221 }
1222
DumpAllBundleInfoNamesByUserId(int32_t userId,std::string & result)1223 bool BundleMgrHostImpl::DumpAllBundleInfoNamesByUserId(int32_t userId, std::string &result)
1224 {
1225 APP_LOGI("DumpAllBundleInfoNamesByUserId begin");
1226 auto dataMgr = GetDataMgrFromService();
1227 if (dataMgr == nullptr) {
1228 APP_LOGE("DataMgr is nullptr");
1229 return false;
1230 }
1231
1232 std::vector<std::string> bundleNames;
1233 if (!dataMgr->GetBundleList(bundleNames, userId)) {
1234 APP_LOGE("get bundle list failed by userId(%{public}d)", userId);
1235 return false;
1236 }
1237
1238 result.append("ID: ");
1239 result.append(std::to_string(userId));
1240 result.append(":\n");
1241 for (const auto &name : bundleNames) {
1242 result.append("\t");
1243 result.append(name);
1244 result.append("\n");
1245 }
1246 APP_LOGI("DumpAllBundleInfoNamesByUserId successfully");
1247 return true;
1248 }
1249
DumpBundleInfo(const std::string & bundleName,int32_t userId,std::string & result)1250 bool BundleMgrHostImpl::DumpBundleInfo(
1251 const std::string &bundleName, int32_t userId, std::string &result)
1252 {
1253 APP_LOGD("DumpBundleInfo begin");
1254 std::vector<InnerBundleUserInfo> innerBundleUserInfos;
1255 if (userId == Constants::ALL_USERID) {
1256 if (!GetBundleUserInfos(bundleName, innerBundleUserInfos)) {
1257 APP_LOGE("get all userInfos in bundle(%{public}s) failed", bundleName.c_str());
1258 return false;
1259 }
1260 userId = innerBundleUserInfos.begin()->bundleUserInfo.userId;
1261 } else {
1262 InnerBundleUserInfo innerBundleUserInfo;
1263 if (!GetBundleUserInfo(bundleName, userId, innerBundleUserInfo)) {
1264 APP_LOGI("get userInfo in bundle(%{public}s) failed", bundleName.c_str());
1265 }
1266 innerBundleUserInfos.emplace_back(innerBundleUserInfo);
1267 }
1268
1269 BundleInfo bundleInfo;
1270 if (!GetBundleInfo(bundleName,
1271 BundleFlag::GET_BUNDLE_WITH_ABILITIES |
1272 BundleFlag::GET_BUNDLE_WITH_REQUESTED_PERMISSION |
1273 BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO |
1274 BundleFlag::GET_BUNDLE_WITH_HASH_VALUE, bundleInfo, userId)) {
1275 APP_LOGE("get bundleInfo(%{public}s) failed", bundleName.c_str());
1276 return false;
1277 }
1278
1279 result.append(bundleName);
1280 result.append(":\n");
1281 nlohmann::json jsonObject = bundleInfo;
1282 jsonObject.erase("abilityInfos");
1283 jsonObject.erase("extensionAbilityInfo");
1284 for (auto &hapModule : jsonObject["hapModuleInfos"]) {
1285 for (auto &ability : hapModule["abilityInfos"]) {
1286 ability.erase("applicationInfo");
1287 }
1288 for (auto &extension : hapModule["extensionInfos"]) {
1289 extension.erase("applicationInfo");
1290 }
1291 }
1292 jsonObject["userInfo"] = innerBundleUserInfos;
1293 result.append(jsonObject.dump(Constants::DUMP_INDENT));
1294 result.append("\n");
1295 APP_LOGI("DumpBundleInfo success with bundleName %{public}s", bundleName.c_str());
1296 return true;
1297 }
1298
DumpShortcutInfo(const std::string & bundleName,int32_t userId,std::string & result)1299 bool BundleMgrHostImpl::DumpShortcutInfo(
1300 const std::string &bundleName, int32_t userId, std::string &result)
1301 {
1302 APP_LOGD("DumpShortcutInfo begin");
1303 std::vector<ShortcutInfo> shortcutInfos;
1304 if (userId == Constants::ALL_USERID) {
1305 std::vector<InnerBundleUserInfo> innerBundleUserInfos;
1306 if (!GetBundleUserInfos(bundleName, innerBundleUserInfos)) {
1307 APP_LOGE("get all userInfos in bundle(%{public}s) failed", bundleName.c_str());
1308 return false;
1309 }
1310 userId = innerBundleUserInfos.begin()->bundleUserInfo.userId;
1311 }
1312
1313 if (!GetShortcutInfos(bundleName, userId, shortcutInfos)) {
1314 APP_LOGE("get all shortcut info by bundle(%{public}s) failed", bundleName.c_str());
1315 return false;
1316 }
1317
1318 result.append("shortcuts");
1319 result.append(":\n");
1320 for (const auto &info : shortcutInfos) {
1321 result.append("\"shortcut\"");
1322 result.append(":\n");
1323 nlohmann::json jsonObject = info;
1324 result.append(jsonObject.dump(Constants::DUMP_INDENT));
1325 result.append("\n");
1326 }
1327 APP_LOGD("DumpShortcutInfo success with bundleName %{public}s", bundleName.c_str());
1328 return true;
1329 }
1330
IsModuleRemovable(const std::string & bundleName,const std::string & moduleName,bool & isRemovable)1331 ErrCode BundleMgrHostImpl::IsModuleRemovable(const std::string &bundleName, const std::string &moduleName,
1332 bool &isRemovable)
1333 {
1334 // check permission
1335 if (!VerifySystemApi()) {
1336 APP_LOGE("non-system app calling system api");
1337 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1338 }
1339 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1340 APP_LOGE("IsModuleRemovable failed due to lack of permission");
1341 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1342 }
1343 auto dataMgr = GetDataMgrFromService();
1344 if (dataMgr == nullptr) {
1345 APP_LOGE("DataMgr is nullptr");
1346 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
1347 }
1348 return dataMgr->IsModuleRemovable(bundleName, moduleName, isRemovable);
1349 }
1350
SetModuleRemovable(const std::string & bundleName,const std::string & moduleName,bool isEnable)1351 bool BundleMgrHostImpl::SetModuleRemovable(const std::string &bundleName, const std::string &moduleName, bool isEnable)
1352 {
1353 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1354 APP_LOGE("SetModuleRemovable failed due to lack of permission");
1355 return false;
1356 }
1357 auto dataMgr = GetDataMgrFromService();
1358 if (dataMgr == nullptr) {
1359 APP_LOGE("DataMgr is nullptr");
1360 return false;
1361 }
1362 return dataMgr->SetModuleRemovable(bundleName, moduleName, isEnable);
1363 }
1364
GetModuleUpgradeFlag(const std::string & bundleName,const std::string & moduleName)1365 bool BundleMgrHostImpl::GetModuleUpgradeFlag(const std::string &bundleName, const std::string &moduleName)
1366 {
1367 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE)) {
1368 APP_LOGE("GetModuleUpgradeFlag failed due to lack of permission");
1369 return false;
1370 }
1371 auto dataMgr = GetDataMgrFromService();
1372 if (dataMgr == nullptr) {
1373 APP_LOGE("DataMgr is nullptr");
1374 return false;
1375 }
1376 return dataMgr->GetModuleUpgradeFlag(bundleName, moduleName);
1377 }
1378
SetModuleUpgradeFlag(const std::string & bundleName,const std::string & moduleName,int32_t upgradeFlag)1379 ErrCode BundleMgrHostImpl::SetModuleUpgradeFlag(const std::string &bundleName,
1380 const std::string &moduleName, int32_t upgradeFlag)
1381 {
1382 // check permission
1383 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1384 APP_LOGE("non-system app calling system api");
1385 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1386 }
1387 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE)) {
1388 APP_LOGE("SetModuleUpgradeFlag failed due to lack of permission");
1389 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1390 }
1391 auto dataMgr = GetDataMgrFromService();
1392 if (dataMgr == nullptr) {
1393 APP_LOGE("DataMgr is nullptr");
1394 return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR;
1395 }
1396 return dataMgr->SetModuleUpgradeFlag(bundleName, moduleName, upgradeFlag);
1397 }
1398
IsApplicationEnabled(const std::string & bundleName,bool & isEnable)1399 ErrCode BundleMgrHostImpl::IsApplicationEnabled(const std::string &bundleName, bool &isEnable)
1400 {
1401 APP_LOGD("start IsApplicationEnabled, bundleName : %{public}s", bundleName.c_str());
1402 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1403 APP_LOGE("non-system app calling system api");
1404 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1405 }
1406 auto dataMgr = GetDataMgrFromService();
1407 if (dataMgr == nullptr) {
1408 APP_LOGE("DataMgr is nullptr");
1409 return ERR_APPEXECFWK_SERVICE_NOT_READY;
1410 }
1411 return dataMgr->IsApplicationEnabled(bundleName, isEnable);
1412 }
1413
SetApplicationEnabled(const std::string & bundleName,bool isEnable,int32_t userId)1414 ErrCode BundleMgrHostImpl::SetApplicationEnabled(const std::string &bundleName, bool isEnable, int32_t userId)
1415 {
1416 APP_LOGD("SetApplicationEnabled begin");
1417 if (userId == Constants::UNSPECIFIED_USERID) {
1418 userId = BundleUtil::GetUserIdByCallingUid();
1419 }
1420 if (!VerifySystemApi()) {
1421 APP_LOGE("non-system app calling system api");
1422 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1423 }
1424 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_CHANGE_ABILITY_ENABLED_STATE)) {
1425 APP_LOGE("verify permission failed");
1426 EventReport::SendComponentStateSysEvent(bundleName, "", userId, isEnable, true);
1427 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1428 }
1429 APP_LOGD("verify permission success, begin to SetApplicationEnabled");
1430 auto dataMgr = GetDataMgrFromService();
1431 if (dataMgr == nullptr) {
1432 APP_LOGE("DataMgr is nullptr");
1433 EventReport::SendComponentStateSysEvent(bundleName, "", userId, isEnable, true);
1434 return ERR_APPEXECFWK_SERVICE_NOT_READY;
1435 }
1436
1437 auto ret = dataMgr->SetApplicationEnabled(bundleName, isEnable, userId);
1438 if (ret != ERR_OK) {
1439 APP_LOGE("Set application(%{public}s) enabled value faile.", bundleName.c_str());
1440 EventReport::SendComponentStateSysEvent(bundleName, "", userId, isEnable, true);
1441 return ret;
1442 }
1443
1444 EventReport::SendComponentStateSysEvent(bundleName, "", userId, isEnable, false);
1445 InnerBundleUserInfo innerBundleUserInfo;
1446 if (!GetBundleUserInfo(bundleName, userId, innerBundleUserInfo)) {
1447 APP_LOGE("Get calling userInfo in bundle(%{public}s) failed", bundleName.c_str());
1448 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1449 }
1450
1451 NotifyBundleEvents installRes = {
1452 .bundleName = bundleName,
1453 .resultCode = ERR_OK,
1454 .type = NotifyType::APPLICATION_ENABLE,
1455 .uid = innerBundleUserInfo.uid,
1456 .accessTokenId = innerBundleUserInfo.accessTokenId
1457 };
1458 NotifyBundleStatus(installRes);
1459 APP_LOGD("SetApplicationEnabled finish");
1460 return ERR_OK;
1461 }
1462
IsAbilityEnabled(const AbilityInfo & abilityInfo,bool & isEnable)1463 ErrCode BundleMgrHostImpl::IsAbilityEnabled(const AbilityInfo &abilityInfo, bool &isEnable)
1464 {
1465 APP_LOGD("start IsAbilityEnabled");
1466 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1467 APP_LOGE("non-system app calling system api");
1468 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1469 }
1470 auto dataMgr = GetDataMgrFromService();
1471 if (dataMgr == nullptr) {
1472 APP_LOGE("DataMgr is nullptr");
1473 return ERR_APPEXECFWK_SERVICE_NOT_READY;
1474 }
1475 return dataMgr->IsAbilityEnabled(abilityInfo, isEnable);
1476 }
1477
SetAbilityEnabled(const AbilityInfo & abilityInfo,bool isEnabled,int32_t userId)1478 ErrCode BundleMgrHostImpl::SetAbilityEnabled(const AbilityInfo &abilityInfo, bool isEnabled, int32_t userId)
1479 {
1480 APP_LOGD("start SetAbilityEnabled");
1481 if (userId == Constants::UNSPECIFIED_USERID) {
1482 userId = BundleUtil::GetUserIdByCallingUid();
1483 }
1484 if (!VerifySystemApi()) {
1485 APP_LOGE("non-system app calling system api");
1486 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1487 }
1488 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_CHANGE_ABILITY_ENABLED_STATE)) {
1489 APP_LOGE("verify permission failed");
1490 EventReport::SendComponentStateSysEvent(
1491 abilityInfo.bundleName, abilityInfo.name, userId, isEnabled, true);
1492 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1493 }
1494
1495 APP_LOGD("verify permission success, begin to SetAbilityEnabled");
1496 auto dataMgr = GetDataMgrFromService();
1497 if (dataMgr == nullptr) {
1498 APP_LOGE("DataMgr is nullptr");
1499 EventReport::SendComponentStateSysEvent(
1500 abilityInfo.bundleName, abilityInfo.name, userId, isEnabled, true);
1501 return ERR_APPEXECFWK_SERVICE_NOT_READY;
1502 }
1503 auto ret = dataMgr->SetAbilityEnabled(abilityInfo, isEnabled, userId);
1504 if (ret != ERR_OK) {
1505 APP_LOGE("Set ability(%{public}s) enabled value failed.", abilityInfo.bundleName.c_str());
1506 EventReport::SendComponentStateSysEvent(
1507 abilityInfo.bundleName, abilityInfo.name, userId, isEnabled, true);
1508 return ret;
1509 }
1510
1511 EventReport::SendComponentStateSysEvent(
1512 abilityInfo.bundleName, abilityInfo.name, userId, isEnabled, false);
1513 InnerBundleUserInfo innerBundleUserInfo;
1514 if (!GetBundleUserInfo(abilityInfo.bundleName, userId, innerBundleUserInfo)) {
1515 APP_LOGE("Get calling userInfo in bundle(%{public}s) failed", abilityInfo.bundleName.c_str());
1516 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1517 }
1518
1519 NotifyBundleEvents installRes = {
1520 .bundleName = abilityInfo.bundleName,
1521 .abilityName = abilityInfo.name,
1522 .resultCode = ERR_OK,
1523 .type = NotifyType::APPLICATION_ENABLE,
1524 .uid = innerBundleUserInfo.uid,
1525 .accessTokenId = innerBundleUserInfo.accessTokenId,
1526 };
1527 NotifyBundleStatus(installRes);
1528 return ERR_OK;
1529 }
1530
GetBundleInstaller()1531 sptr<IBundleInstaller> BundleMgrHostImpl::GetBundleInstaller()
1532 {
1533 APP_LOGD("start GetBundleInstaller");
1534 if (!VerifySystemApi()) {
1535 APP_LOGE("non-system app calling system api");
1536 return nullptr;
1537 }
1538 return DelayedSingleton<BundleMgrService>::GetInstance()->GetBundleInstaller();
1539 }
1540
GetBundleUserMgr()1541 sptr<IBundleUserMgr> BundleMgrHostImpl::GetBundleUserMgr()
1542 {
1543 int32_t callingUid = IPCSkeleton::GetCallingUid();
1544 if (callingUid != Constants::ACCOUNT_UID) {
1545 APP_LOGE("invalid calling uid %{public}d to GetbundleUserMgr", callingUid);
1546 return nullptr;
1547 }
1548 return DelayedSingleton<BundleMgrService>::GetInstance()->GetBundleUserMgr();
1549 }
1550
GetAllFormsInfo(std::vector<FormInfo> & formInfos)1551 bool BundleMgrHostImpl::GetAllFormsInfo(std::vector<FormInfo> &formInfos)
1552 {
1553 APP_LOGD("start GetAllFormsInfo");
1554 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1555 APP_LOGE("verify permission failed");
1556 return false;
1557 }
1558 auto dataMgr = GetDataMgrFromService();
1559 if (dataMgr == nullptr) {
1560 APP_LOGE("DataMgr is nullptr");
1561 return false;
1562 }
1563 return dataMgr->GetAllFormsInfo(formInfos);
1564 }
1565
GetFormsInfoByApp(const std::string & bundleName,std::vector<FormInfo> & formInfos)1566 bool BundleMgrHostImpl::GetFormsInfoByApp(const std::string &bundleName, std::vector<FormInfo> &formInfos)
1567 {
1568 APP_LOGD("start GetFormsInfoByApp, bundleName : %{public}s", bundleName.c_str());
1569 if (!VerifyQueryPermission(bundleName)) {
1570 APP_LOGE("verify permission failed");
1571 return false;
1572 }
1573 auto dataMgr = GetDataMgrFromService();
1574 if (dataMgr == nullptr) {
1575 APP_LOGE("DataMgr is nullptr");
1576 return false;
1577 }
1578 return dataMgr->GetFormsInfoByApp(bundleName, formInfos);
1579 }
1580
GetFormsInfoByModule(const std::string & bundleName,const std::string & moduleName,std::vector<FormInfo> & formInfos)1581 bool BundleMgrHostImpl::GetFormsInfoByModule(
1582 const std::string &bundleName, const std::string &moduleName, std::vector<FormInfo> &formInfos)
1583 {
1584 APP_LOGD("start GetFormsInfoByModule, bundleName : %{public}s, moduleName : %{public}s",
1585 bundleName.c_str(), moduleName.c_str());
1586 if (!VerifyQueryPermission(bundleName)) {
1587 APP_LOGE("verify permission failed");
1588 return false;
1589 }
1590 auto dataMgr = GetDataMgrFromService();
1591 if (dataMgr == nullptr) {
1592 APP_LOGE("DataMgr is nullptr");
1593 return false;
1594 }
1595 return dataMgr->GetFormsInfoByModule(bundleName, moduleName, formInfos);
1596 }
1597
GetShortcutInfos(const std::string & bundleName,std::vector<ShortcutInfo> & shortcutInfos)1598 bool BundleMgrHostImpl::GetShortcutInfos(
1599 const std::string &bundleName, std::vector<ShortcutInfo> &shortcutInfos)
1600 {
1601 return GetShortcutInfos(bundleName, Constants::UNSPECIFIED_USERID, shortcutInfos);
1602 }
1603
GetShortcutInfos(const std::string & bundleName,int32_t userId,std::vector<ShortcutInfo> & shortcutInfos)1604 bool BundleMgrHostImpl::GetShortcutInfos(
1605 const std::string &bundleName, int32_t userId, std::vector<ShortcutInfo> &shortcutInfos)
1606 {
1607 APP_LOGD("start GetShortcutInfos, bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
1608 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1609 APP_LOGD("non-system app calling system api");
1610 return true;
1611 }
1612 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1613 APP_LOGE("verify permission failed");
1614 return false;
1615 }
1616 APP_LOGD("verify permission success, begin to GetShortcutInfos");
1617 auto dataMgr = GetDataMgrFromService();
1618 if (dataMgr == nullptr) {
1619 APP_LOGE("DataMgr is nullptr");
1620 return false;
1621 }
1622 return dataMgr->GetShortcutInfos(bundleName, userId, shortcutInfos);
1623 }
1624
GetShortcutInfoV9(const std::string & bundleName,std::vector<ShortcutInfo> & shortcutInfos)1625 ErrCode BundleMgrHostImpl::GetShortcutInfoV9(const std::string &bundleName, std::vector<ShortcutInfo> &shortcutInfos)
1626 {
1627 if (!VerifySystemApi()) {
1628 APP_LOGE("non-system app calling system api");
1629 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1630 }
1631 if (!VerifyPrivilegedPermission(bundleName)) {
1632 APP_LOGE("verify permission failed");
1633 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1634 }
1635 auto dataMgr = GetDataMgrFromService();
1636 if (dataMgr == nullptr) {
1637 APP_LOGE("DataMgr is nullptr");
1638 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
1639 }
1640 return dataMgr->GetShortcutInfoV9(bundleName, Constants::UNSPECIFIED_USERID, shortcutInfos);
1641 }
1642
GetAllCommonEventInfo(const std::string & eventKey,std::vector<CommonEventInfo> & commonEventInfos)1643 bool BundleMgrHostImpl::GetAllCommonEventInfo(const std::string &eventKey,
1644 std::vector<CommonEventInfo> &commonEventInfos)
1645 {
1646 APP_LOGD("start GetAllCommonEventInfo, eventKey : %{public}s", eventKey.c_str());
1647 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1648 APP_LOGE("verify permission failed");
1649 return false;
1650 }
1651 auto dataMgr = GetDataMgrFromService();
1652 if (dataMgr == nullptr) {
1653 APP_LOGE("DataMgr is nullptr");
1654 return false;
1655 }
1656 return dataMgr->GetAllCommonEventInfo(eventKey, commonEventInfos);
1657 }
1658
GetDistributedBundleInfo(const std::string & networkId,const std::string & bundleName,DistributedBundleInfo & distributedBundleInfo)1659 bool BundleMgrHostImpl::GetDistributedBundleInfo(const std::string &networkId, const std::string &bundleName,
1660 DistributedBundleInfo &distributedBundleInfo)
1661 {
1662 APP_LOGD("start GetDistributedBundleInfo, bundleName : %{public}s", bundleName.c_str());
1663 #ifdef DISTRIBUTED_BUNDLE_FRAMEWORK
1664 if (!VerifyQueryPermission(bundleName)) {
1665 APP_LOGE("verify permission failed");
1666 return false;
1667 }
1668 auto distributedBundleMgr = GetDistributedBundleMgrService();
1669 if (distributedBundleMgr == nullptr) {
1670 APP_LOGE("DistributedBundleMgrService is nullptr");
1671 return false;
1672 }
1673 return distributedBundleMgr->GetDistributedBundleInfo(networkId, bundleName, distributedBundleInfo);
1674 #else
1675 APP_LOGW("DISTRIBUTED_BUNDLE_FRAMEWORK is false");
1676 return false;
1677 #endif
1678 }
1679
QueryExtensionAbilityInfos(const Want & want,const int32_t & flag,const int32_t & userId,std::vector<ExtensionAbilityInfo> & extensionInfos)1680 bool BundleMgrHostImpl::QueryExtensionAbilityInfos(const Want &want, const int32_t &flag, const int32_t &userId,
1681 std::vector<ExtensionAbilityInfo> &extensionInfos)
1682 {
1683 APP_LOGD("QueryExtensionAbilityInfos without type begin");
1684 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1685 APP_LOGD("non-system app calling system api");
1686 return true;
1687 }
1688 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
1689 APP_LOGE("verify permission failed");
1690 return false;
1691 }
1692 APP_LOGD("want uri is %{private}s", want.GetUriString().c_str());
1693 auto dataMgr = GetDataMgrFromService();
1694 if (dataMgr == nullptr) {
1695 APP_LOGE("DataMgr is nullptr");
1696 return false;
1697 }
1698 bool ret = dataMgr->QueryExtensionAbilityInfos(want, flag, userId, extensionInfos);
1699 if (!ret) {
1700 APP_LOGE("QueryExtensionAbilityInfos is failed");
1701 return false;
1702 }
1703 if (extensionInfos.empty()) {
1704 APP_LOGE("no valid extension info can be inquired");
1705 return false;
1706 }
1707 return true;
1708 }
1709
QueryExtensionAbilityInfosV9(const Want & want,int32_t flags,int32_t userId,std::vector<ExtensionAbilityInfo> & extensionInfos)1710 ErrCode BundleMgrHostImpl::QueryExtensionAbilityInfosV9(const Want &want, int32_t flags, int32_t userId,
1711 std::vector<ExtensionAbilityInfo> &extensionInfos)
1712 {
1713 APP_LOGD("QueryExtensionAbilityInfosV9 without type begin");
1714 if (!VerifySystemApi()) {
1715 APP_LOGE("non-system app calling system api");
1716 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1717 }
1718 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
1719 APP_LOGE("verify permission failed");
1720 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1721 }
1722 APP_LOGD("want uri is %{private}s", want.GetUriString().c_str());
1723 auto dataMgr = GetDataMgrFromService();
1724 if (dataMgr == nullptr) {
1725 APP_LOGE("DataMgr is nullptr");
1726 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
1727 }
1728 ErrCode ret = dataMgr->QueryExtensionAbilityInfosV9(want, flags, userId, extensionInfos);
1729 if (ret != ERR_OK) {
1730 APP_LOGE("QueryExtensionAbilityInfosV9 is failed");
1731 return ret;
1732 }
1733 if (extensionInfos.empty()) {
1734 APP_LOGE("no valid extension info can be inquired");
1735 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
1736 }
1737 return ERR_OK;
1738 }
1739
QueryExtensionAbilityInfos(const Want & want,const ExtensionAbilityType & extensionType,const int32_t & flag,const int32_t & userId,std::vector<ExtensionAbilityInfo> & extensionInfos)1740 bool BundleMgrHostImpl::QueryExtensionAbilityInfos(const Want &want, const ExtensionAbilityType &extensionType,
1741 const int32_t &flag, const int32_t &userId, std::vector<ExtensionAbilityInfo> &extensionInfos)
1742 {
1743 APP_LOGD("QueryExtensionAbilityInfos begin");
1744 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1745 APP_LOGD("non-system app calling system api");
1746 return true;
1747 }
1748 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
1749 APP_LOGE("verify permission failed");
1750 return false;
1751 }
1752 auto dataMgr = GetDataMgrFromService();
1753 if (dataMgr == nullptr) {
1754 APP_LOGE("DataMgr is nullptr");
1755 return false;
1756 }
1757 std::vector<ExtensionAbilityInfo> infos;
1758 bool ret = dataMgr->QueryExtensionAbilityInfos(want, flag, userId, infos);
1759 if (!ret) {
1760 APP_LOGE("QueryExtensionAbilityInfos is failed");
1761 return false;
1762 }
1763 for_each(infos.begin(), infos.end(), [&extensionType, &extensionInfos](const auto &info)->decltype(auto) {
1764 APP_LOGD("QueryExtensionAbilityInfos extensionType is %{public}d, info.type is %{public}d",
1765 static_cast<int32_t>(extensionType), static_cast<int32_t>(info.type));
1766 if (extensionType == info.type) {
1767 extensionInfos.emplace_back(info);
1768 }
1769 });
1770 if (extensionInfos.empty()) {
1771 APP_LOGE("no valid extension info can be inquired");
1772 return false;
1773 }
1774 return true;
1775 }
1776
QueryExtensionAbilityInfosV9(const Want & want,const ExtensionAbilityType & extensionType,int32_t flags,int32_t userId,std::vector<ExtensionAbilityInfo> & extensionInfos)1777 ErrCode BundleMgrHostImpl::QueryExtensionAbilityInfosV9(const Want &want, const ExtensionAbilityType &extensionType,
1778 int32_t flags, int32_t userId, std::vector<ExtensionAbilityInfo> &extensionInfos)
1779 {
1780 APP_LOGD("QueryExtensionAbilityInfosV9 begin");
1781 if (!VerifySystemApi()) {
1782 APP_LOGE("non-system app calling system api");
1783 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
1784 }
1785 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
1786 APP_LOGE("verify permission failed");
1787 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
1788 }
1789 auto dataMgr = GetDataMgrFromService();
1790 if (dataMgr == nullptr) {
1791 APP_LOGE("DataMgr is nullptr");
1792 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
1793 }
1794 std::vector<ExtensionAbilityInfo> infos;
1795 ErrCode ret = dataMgr->QueryExtensionAbilityInfosV9(want, flags, userId, infos);
1796 if (ret != ERR_OK) {
1797 APP_LOGE("QueryExtensionAbilityInfosV9 is failed");
1798 return ret;
1799 }
1800 for_each(infos.begin(), infos.end(), [&extensionType, &extensionInfos](const auto &info)->decltype(auto) {
1801 APP_LOGD("QueryExtensionAbilityInfosV9 extensionType is %{public}d, info.type is %{public}d",
1802 static_cast<int32_t>(extensionType), static_cast<int32_t>(info.type));
1803 if (extensionType == info.type) {
1804 extensionInfos.emplace_back(info);
1805 }
1806 });
1807 if (extensionInfos.empty()) {
1808 APP_LOGE("no valid extension info can be inquired");
1809 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
1810 }
1811 return ERR_OK;
1812 }
1813
QueryExtensionAbilityInfos(const ExtensionAbilityType & extensionType,const int32_t & userId,std::vector<ExtensionAbilityInfo> & extensionInfos)1814 bool BundleMgrHostImpl::QueryExtensionAbilityInfos(const ExtensionAbilityType &extensionType, const int32_t &userId,
1815 std::vector<ExtensionAbilityInfo> &extensionInfos)
1816 {
1817 APP_LOGD("QueryExtensionAbilityInfos with type begin");
1818 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1819 APP_LOGD("non-system app calling system api");
1820 return true;
1821 }
1822 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1823 APP_LOGE("verify permission failed");
1824 return false;
1825 }
1826 auto dataMgr = GetDataMgrFromService();
1827 if (dataMgr == nullptr) {
1828 APP_LOGE("DataMgr is nullptr");
1829 return false;
1830 }
1831 bool ret = dataMgr->QueryExtensionAbilityInfos(extensionType, userId, extensionInfos);
1832 if (!ret) {
1833 APP_LOGE("QueryExtensionAbilityInfos is failed");
1834 return false;
1835 }
1836
1837 if (extensionInfos.empty()) {
1838 APP_LOGE("no valid extension info can be inquired");
1839 return false;
1840 }
1841 return true;
1842 }
1843
GetDataMgrFromService()1844 const std::shared_ptr<BundleDataMgr> BundleMgrHostImpl::GetDataMgrFromService()
1845 {
1846 return DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
1847 }
1848
1849 #ifdef DISTRIBUTED_BUNDLE_FRAMEWORK
GetDistributedBundleMgrService()1850 const OHOS::sptr<IDistributedBms> BundleMgrHostImpl::GetDistributedBundleMgrService()
1851 {
1852 auto saMgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1853 if (saMgr == nullptr) {
1854 APP_LOGE("saMgr is nullptr");
1855 return nullptr;
1856 }
1857 OHOS::sptr<OHOS::IRemoteObject> remoteObject =
1858 saMgr->CheckSystemAbility(OHOS::DISTRIBUTED_BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
1859 return OHOS::iface_cast<IDistributedBms>(remoteObject);
1860 }
1861 #endif
1862
1863 #ifdef BUNDLE_FRAMEWORK_FREE_INSTALL
GetConnectAbilityMgrFromService()1864 const std::shared_ptr<BundleConnectAbilityMgr> BundleMgrHostImpl::GetConnectAbilityMgrFromService()
1865 {
1866 return DelayedSingleton<BundleMgrService>::GetInstance()->GetConnectAbility();
1867 }
1868 #endif
1869
GetExistsCommonUserIs()1870 std::set<int32_t> BundleMgrHostImpl::GetExistsCommonUserIs()
1871 {
1872 std::set<int32_t> userIds;
1873 auto dataMgr = GetDataMgrFromService();
1874 if (dataMgr == nullptr) {
1875 APP_LOGE("Get dataMgr shared_ptr nullptr");
1876 return userIds;
1877 }
1878
1879 for (auto userId : dataMgr->GetAllUser()) {
1880 if (userId >= Constants::START_USERID) {
1881 userIds.insert(userId);
1882 }
1883 }
1884 return userIds;
1885 }
1886
VerifyQueryPermission(const std::string & queryBundleName)1887 bool BundleMgrHostImpl::VerifyQueryPermission(const std::string &queryBundleName)
1888 {
1889 std::string callingBundleName;
1890 bool ret = GetBundleNameForUid(IPCSkeleton::GetCallingUid(), callingBundleName);
1891 APP_LOGD("callingBundleName : %{public}s", callingBundleName.c_str());
1892 if (ret && (queryBundleName == callingBundleName)) {
1893 APP_LOGD("query own info, verify success");
1894 return true;
1895 }
1896 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
1897 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1898 APP_LOGE("verify query permission failed");
1899 return false;
1900 }
1901 APP_LOGD("verify query permission successfully");
1902 return true;
1903 }
1904
VerifyPrivilegedPermission(const std::string & queryBundleName)1905 bool BundleMgrHostImpl::VerifyPrivilegedPermission(const std::string &queryBundleName)
1906 {
1907 std::string callingBundleName;
1908 bool ret = GetBundleNameForUid(IPCSkeleton::GetCallingUid(), callingBundleName);
1909 APP_LOGD("callingBundleName : %{public}s", callingBundleName.c_str());
1910 if (ret && (queryBundleName == callingBundleName)) {
1911 APP_LOGD("query own info, verify success");
1912 return true;
1913 }
1914 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1915 APP_LOGE("verify query permission failed");
1916 return false;
1917 }
1918 APP_LOGD("verify query permission successfully");
1919 return true;
1920 }
1921
GetAppPrivilegeLevel(const std::string & bundleName,int32_t userId)1922 std::string BundleMgrHostImpl::GetAppPrivilegeLevel(const std::string &bundleName, int32_t userId)
1923 {
1924 APP_LOGD("start GetAppPrivilegeLevel");
1925 if (!VerifyQueryPermission(bundleName)) {
1926 APP_LOGE("verify permission failed");
1927 return Constants::EMPTY_STRING;
1928 }
1929 auto dataMgr = GetDataMgrFromService();
1930 if (dataMgr == nullptr) {
1931 APP_LOGE("DataMgr is nullptr");
1932 return Constants::EMPTY_STRING;
1933 }
1934 return dataMgr->GetAppPrivilegeLevel(bundleName, userId);
1935 }
1936
VerifyCallingPermission(const std::string & permission)1937 bool BundleMgrHostImpl::VerifyCallingPermission(const std::string &permission)
1938 {
1939 APP_LOGD("VerifyCallingPermission begin");
1940 return BundlePermissionMgr::VerifyCallingPermission(permission);
1941 }
1942
GetAccessibleAppCodePaths(int32_t userId)1943 std::vector<std::string> BundleMgrHostImpl::GetAccessibleAppCodePaths(int32_t userId)
1944 {
1945 APP_LOGD("GetAccessibleAppCodePaths begin");
1946 if (!BundlePermissionMgr::IsNativeTokenType()) {
1947 APP_LOGE("verify token type failed");
1948 std::vector<std::string> vec;
1949 return vec;
1950 }
1951 auto dataMgr = GetDataMgrFromService();
1952 if (dataMgr == nullptr) {
1953 APP_LOGE("DataMgr is nullptr");
1954 std::vector<std::string> vec;
1955 return vec;
1956 }
1957
1958 return dataMgr->GetAccessibleAppCodePaths(userId);
1959 }
1960
QueryExtensionAbilityInfoByUri(const std::string & uri,int32_t userId,ExtensionAbilityInfo & extensionAbilityInfo)1961 bool BundleMgrHostImpl::QueryExtensionAbilityInfoByUri(const std::string &uri, int32_t userId,
1962 ExtensionAbilityInfo &extensionAbilityInfo)
1963 {
1964 APP_LOGD("uri : %{private}s, userId : %{public}d", uri.c_str(), userId);
1965 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
1966 APP_LOGE("non-system app calling system api");
1967 return true;
1968 }
1969 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
1970 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1971 APP_LOGE("verify query permission failed");
1972 return false;
1973 }
1974 auto dataMgr = GetDataMgrFromService();
1975 if (dataMgr == nullptr) {
1976 APP_LOGE("DataMgr is nullptr");
1977 return false;
1978 }
1979 return dataMgr->QueryExtensionAbilityInfoByUri(uri, userId, extensionAbilityInfo);
1980 }
1981
GetAppIdByBundleName(const std::string & bundleName,const int userId)1982 std::string BundleMgrHostImpl::GetAppIdByBundleName(const std::string &bundleName, const int userId)
1983 {
1984 APP_LOGD("bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
1985 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO) &&
1986 !BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
1987 APP_LOGE("verify query permission failed");
1988 return Constants::EMPTY_STRING;
1989 }
1990 auto dataMgr = GetDataMgrFromService();
1991 if (dataMgr == nullptr) {
1992 APP_LOGE("DataMgr is nullptr");
1993 return Constants::EMPTY_STRING;
1994 }
1995 BundleInfo bundleInfo;
1996 bool ret = dataMgr->GetBundleInfo(bundleName, GET_BUNDLE_DEFAULT, bundleInfo, userId);
1997 if (!ret) {
1998 APP_LOGE("get bundleInfo failed");
1999 return Constants::EMPTY_STRING;
2000 }
2001 APP_LOGD("appId is %{private}s", bundleInfo.appId.c_str());
2002 return bundleInfo.appId;
2003 }
2004
GetAppType(const std::string & bundleName)2005 std::string BundleMgrHostImpl::GetAppType(const std::string &bundleName)
2006 {
2007 APP_LOGD("bundleName : %{public}s", bundleName.c_str());
2008 if (!VerifyQueryPermission(bundleName)) {
2009 APP_LOGE("verify permission failed");
2010 return Constants::EMPTY_STRING;
2011 }
2012 auto dataMgr = GetDataMgrFromService();
2013 if (dataMgr == nullptr) {
2014 APP_LOGE("DataMgr is nullptr");
2015 return Constants::EMPTY_STRING;
2016 }
2017 BundleInfo bundleInfo;
2018 bool ret = dataMgr->GetBundleInfo(bundleName, GET_BUNDLE_DEFAULT, bundleInfo, Constants::UNSPECIFIED_USERID);
2019 if (!ret) {
2020 APP_LOGE("get bundleInfo failed");
2021 return Constants::EMPTY_STRING;
2022 }
2023 bool isSystemApp = bundleInfo.applicationInfo.isSystemApp;
2024 std::string appType = isSystemApp ? Constants::SYSTEM_APP : Constants::THIRD_PARTY_APP;
2025 APP_LOGD("appType is %{public}s", appType.c_str());
2026 return appType;
2027 }
2028
GetUidByBundleName(const std::string & bundleName,const int userId)2029 int BundleMgrHostImpl::GetUidByBundleName(const std::string &bundleName, const int userId)
2030 {
2031 APP_LOGD("bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
2032 if (!BundlePermissionMgr::IsNativeTokenType()) {
2033 APP_LOGE("verify token type failed");
2034 return Constants::INVALID_UID;
2035 }
2036 auto dataMgr = GetDataMgrFromService();
2037 if (dataMgr == nullptr) {
2038 APP_LOGE("DataMgr is nullptr");
2039 return Constants::INVALID_UID;
2040 }
2041 std::vector<BundleInfo> bundleInfos;
2042 int32_t uid = Constants::INVALID_UID;
2043 bool ret = dataMgr->GetBundleInfos(GET_BUNDLE_DEFAULT, bundleInfos, userId);
2044 if (ret) {
2045 for (auto bundleInfo : bundleInfos) {
2046 if (bundleInfo.name == bundleName) {
2047 uid = bundleInfo.uid;
2048 break;
2049 }
2050 }
2051 APP_LOGD("get bundle uid success");
2052 } else {
2053 APP_LOGE("can not get bundleInfo's uid");
2054 }
2055 APP_LOGD("uid is %{public}d", uid);
2056 return uid;
2057 }
2058
GetUidByDebugBundleName(const std::string & bundleName,const int userId)2059 int BundleMgrHostImpl::GetUidByDebugBundleName(const std::string &bundleName, const int userId)
2060 {
2061 APP_LOGD("bundleName : %{public}s, userId : %{public}d", bundleName.c_str(), userId);
2062 auto dataMgr = GetDataMgrFromService();
2063 if (dataMgr == nullptr) {
2064 APP_LOGE("DataMgr is nullptr");
2065 return Constants::INVALID_UID;
2066 }
2067 ApplicationInfo appInfo;
2068 int32_t uid = Constants::INVALID_UID;
2069 bool ret = dataMgr->GetApplicationInfo(bundleName, GET_BUNDLE_DEFAULT, userId, appInfo);
2070 if (ret && appInfo.debug) {
2071 uid = appInfo.uid;
2072 APP_LOGD("get debug bundle uid success, uid is %{public}d", uid);
2073 } else {
2074 APP_LOGE("can not get bundleInfo's uid");
2075 }
2076 return uid;
2077 }
2078
GetAbilityInfo(const std::string & bundleName,const std::string & abilityName,AbilityInfo & abilityInfo)2079 bool BundleMgrHostImpl::GetAbilityInfo(
2080 const std::string &bundleName, const std::string &abilityName, AbilityInfo &abilityInfo)
2081 {
2082 APP_LOGD("start GetAbilityInfo, bundleName : %{public}s, abilityName : %{public}s",
2083 bundleName.c_str(), abilityName.c_str());
2084 ElementName elementName("", bundleName, abilityName);
2085 Want want;
2086 want.SetElement(elementName);
2087 return QueryAbilityInfo(want, abilityInfo);
2088 }
2089
GetAbilityInfo(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,AbilityInfo & abilityInfo)2090 bool BundleMgrHostImpl::GetAbilityInfo(
2091 const std::string &bundleName, const std::string &moduleName,
2092 const std::string &abilityName, AbilityInfo &abilityInfo)
2093 {
2094 APP_LOGD("start GetAbilityInfo, bundleName : %{public}s, moduleName : %{public}s, abilityName : %{public}s",
2095 bundleName.c_str(), moduleName.c_str(), abilityName.c_str());
2096 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
2097 APP_LOGD("non-system app calling system api");
2098 return true;
2099 }
2100 ElementName elementName("", bundleName, abilityName, moduleName);
2101 Want want;
2102 want.SetElement(elementName);
2103 return QueryAbilityInfo(want, abilityInfo);
2104 }
2105
ImplicitQueryInfoByPriority(const Want & want,int32_t flags,int32_t userId,AbilityInfo & abilityInfo,ExtensionAbilityInfo & extensionInfo)2106 bool BundleMgrHostImpl::ImplicitQueryInfoByPriority(const Want &want, int32_t flags, int32_t userId,
2107 AbilityInfo &abilityInfo, ExtensionAbilityInfo &extensionInfo)
2108 {
2109 APP_LOGD("start ImplicitQueryInfoByPriority, flags : %{public}d, userId : %{public}d", flags, userId);
2110 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
2111 APP_LOGD("non-system app calling system api");
2112 return true;
2113 }
2114 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
2115 APP_LOGE("verify permission failed");
2116 return false;
2117 }
2118 auto dataMgr = GetDataMgrFromService();
2119 if (dataMgr == nullptr) {
2120 APP_LOGE("DataMgr is nullptr");
2121 return false;
2122 }
2123 return dataMgr->ImplicitQueryInfoByPriority(want, flags, userId, abilityInfo, extensionInfo);
2124 }
2125
ImplicitQueryInfos(const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos,std::vector<ExtensionAbilityInfo> & extensionInfos)2126 bool BundleMgrHostImpl::ImplicitQueryInfos(const Want &want, int32_t flags, int32_t userId,
2127 std::vector<AbilityInfo> &abilityInfos, std::vector<ExtensionAbilityInfo> &extensionInfos)
2128 {
2129 APP_LOGD("begin to ImplicitQueryInfos, flags : %{public}d, userId : %{public}d", flags, userId);
2130 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
2131 APP_LOGD("non-system app calling system api");
2132 return true;
2133 }
2134 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
2135 APP_LOGE("verify permission failed");
2136 return false;
2137 }
2138 auto dataMgr = GetDataMgrFromService();
2139 if (dataMgr == nullptr) {
2140 APP_LOGE("DataMgr is nullptr");
2141 return false;
2142 }
2143 return dataMgr->ImplicitQueryInfos(want, flags, userId, abilityInfos, extensionInfos);
2144 }
2145
Dump(int fd,const std::vector<std::u16string> & args)2146 int BundleMgrHostImpl::Dump(int fd, const std::vector<std::u16string> &args)
2147 {
2148 std::string result;
2149 std::vector<std::string> argsStr;
2150 for (auto item : args) {
2151 argsStr.emplace_back(Str16ToStr8(item));
2152 }
2153
2154 if (!DelayedSingleton<BundleMgrService>::GetInstance()->Hidump(argsStr, result)) {
2155 APP_LOGE("Hidump error");
2156 return ERR_APPEXECFWK_HIDUMP_ERROR;
2157 }
2158
2159 int ret = dprintf(fd, "%s\n", result.c_str());
2160 if (ret < 0) {
2161 APP_LOGE("dprintf error");
2162 return ERR_APPEXECFWK_HIDUMP_ERROR;
2163 }
2164
2165 return ERR_OK;
2166 }
2167
GetAllDependentModuleNames(const std::string & bundleName,const std::string & moduleName,std::vector<std::string> & dependentModuleNames)2168 bool BundleMgrHostImpl::GetAllDependentModuleNames(const std::string &bundleName, const std::string &moduleName,
2169 std::vector<std::string> &dependentModuleNames)
2170 {
2171 APP_LOGD("GetAllDependentModuleNames: bundleName: %{public}s, moduleName: %{public}s",
2172 bundleName.c_str(), moduleName.c_str());
2173 if (!VerifyQueryPermission(bundleName)) {
2174 APP_LOGE("verify permission failed");
2175 return false;
2176 }
2177 auto dataMgr = GetDataMgrFromService();
2178 if (dataMgr == nullptr) {
2179 APP_LOGE("DataMgr is nullptr");
2180 return false;
2181 }
2182 return dataMgr->GetAllDependentModuleNames(bundleName, moduleName, dependentModuleNames);
2183 }
2184
GetSandboxBundleInfo(const std::string & bundleName,int32_t appIndex,int32_t userId,BundleInfo & info)2185 ErrCode BundleMgrHostImpl::GetSandboxBundleInfo(
2186 const std::string &bundleName, int32_t appIndex, int32_t userId, BundleInfo &info)
2187 {
2188 APP_LOGD("start GetSandboxBundleInfo, bundleName : %{public}s, appindex : %{public}d, userId : %{public}d",
2189 bundleName.c_str(), appIndex, userId);
2190 // check bundle name
2191 if (bundleName.empty()) {
2192 APP_LOGE("GetSandboxBundleInfo failed due to empty bundleName");
2193 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
2194 }
2195 // check appIndex
2196 if (appIndex <= Constants::INITIAL_APP_INDEX || appIndex > Constants::MAX_APP_INDEX) {
2197 APP_LOGE("the appIndex %{public}d is invalid", appIndex);
2198 return ERR_APPEXECFWK_SANDBOX_INSTALL_PARAM_ERROR;
2199 }
2200 if (!VerifyQueryPermission(bundleName)) {
2201 APP_LOGE("verify permission failed");
2202 return ERR_APPEXECFWK_PERMISSION_DENIED;
2203 }
2204 auto dataMgr = GetDataMgrFromService();
2205 if (dataMgr == nullptr) {
2206 APP_LOGE("DataMgr is nullptr");
2207 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
2208 }
2209 auto sandboxAppHelper = dataMgr->GetSandboxAppHelper();
2210 if (sandboxAppHelper == nullptr) {
2211 APP_LOGE("sandboxAppHelper is nullptr");
2212 return ERR_APPEXECFWK_SANDBOX_INSTALL_INTERNAL_ERROR;
2213 }
2214 int32_t requestUserId = dataMgr->GetUserId(userId);
2215 if (requestUserId == Constants::INVALID_USERID) {
2216 return ERR_APPEXECFWK_SANDBOX_QUERY_INVALID_USER_ID;
2217 }
2218 return sandboxAppHelper->GetSandboxAppBundleInfo(bundleName, appIndex, requestUserId, info);
2219 }
2220
SetDisposedStatus(const std::string & bundleName,int32_t status)2221 bool BundleMgrHostImpl::SetDisposedStatus(const std::string &bundleName, int32_t status)
2222 {
2223 APP_LOGD("SetDisposedStatus: bundleName: %{public}s, status: %{public}d", bundleName.c_str(), status);
2224 // check permission
2225 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_MANAGE_DISPOSED_APP_STATUS)) {
2226 APP_LOGE("SetDisposedStatus bundleName: %{public}s failed due to lack of permission", bundleName.c_str());
2227 return false;
2228 }
2229 auto dataMgr = GetDataMgrFromService();
2230 if (dataMgr == nullptr) {
2231 APP_LOGE("DataMgr is nullptr");
2232 return false;
2233 }
2234 return dataMgr->SetDisposedStatus(bundleName, status);
2235 }
2236
GetDisposedStatus(const std::string & bundleName)2237 int32_t BundleMgrHostImpl::GetDisposedStatus(const std::string &bundleName)
2238 {
2239 APP_LOGD("GetDisposedStatus: bundleName: %{public}s", bundleName.c_str());
2240 // check permission
2241 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_MANAGE_DISPOSED_APP_STATUS)) {
2242 APP_LOGE("GetDisposedStatus bundleName: %{public}s failed due to lack of permission", bundleName.c_str());
2243 return Constants::DEFAULT_DISPOSED_STATUS;
2244 }
2245 auto dataMgr = GetDataMgrFromService();
2246 if (dataMgr == nullptr) {
2247 APP_LOGE("DataMgr is nullptr");
2248 return Constants::DEFAULT_DISPOSED_STATUS;
2249 }
2250 return dataMgr->GetDisposedStatus(bundleName);
2251 }
2252
ObtainCallingBundleName(std::string & bundleName)2253 bool BundleMgrHostImpl::ObtainCallingBundleName(std::string &bundleName)
2254 {
2255 bool ret = GetBundleNameForUid(IPCSkeleton::GetCallingUid(), bundleName);
2256 if (!ret) {
2257 APP_LOGE("query calling bundle name failed");
2258 return false;
2259 }
2260 APP_LOGD("calling bundleName is : %{public}s", bundleName.c_str());
2261 return ret;
2262 }
2263
GetBundleStats(const std::string & bundleName,int32_t userId,std::vector<int64_t> & bundleStats)2264 bool BundleMgrHostImpl::GetBundleStats(const std::string &bundleName, int32_t userId,
2265 std::vector<int64_t> &bundleStats)
2266 {
2267 if (!VerifyQueryPermission(bundleName)) {
2268 APP_LOGE("verify permission failed");
2269 return false;
2270 }
2271 auto dataMgr = GetDataMgrFromService();
2272 if (dataMgr == nullptr) {
2273 APP_LOGE("DataMgr is nullptr");
2274 return false;
2275 }
2276 return dataMgr->GetBundleStats(bundleName, userId, bundleStats);
2277 }
2278
GetStringById(const std::string & bundleName,const std::string & moduleName,uint32_t resId,int32_t userId,const std::string & localeInfo)2279 std::string BundleMgrHostImpl::GetStringById(const std::string &bundleName, const std::string &moduleName,
2280 uint32_t resId, int32_t userId, const std::string &localeInfo)
2281 {
2282 if (!BundlePermissionMgr::IsNativeTokenType()) {
2283 APP_LOGE("verify token type failed");
2284 return Constants::EMPTY_STRING;
2285 }
2286 auto dataMgr = GetDataMgrFromService();
2287 if (dataMgr == nullptr) {
2288 APP_LOGE("DataMgr is nullptr");
2289 return Constants::EMPTY_STRING;
2290 }
2291 return dataMgr->GetStringById(bundleName, moduleName, resId, userId, localeInfo);
2292 }
2293
GetIconById(const std::string & bundleName,const std::string & moduleName,uint32_t resId,uint32_t density,int32_t userId)2294 std::string BundleMgrHostImpl::GetIconById(
2295 const std::string &bundleName, const std::string &moduleName, uint32_t resId, uint32_t density, int32_t userId)
2296 {
2297 if (!BundlePermissionMgr::IsNativeTokenType()) {
2298 APP_LOGE("verify token type failed");
2299 return Constants::EMPTY_STRING;
2300 }
2301 auto dataMgr = GetDataMgrFromService();
2302 if (dataMgr == nullptr) {
2303 APP_LOGE("DataMgr is nullptr");
2304 return Constants::EMPTY_STRING;
2305 }
2306 return dataMgr->GetIconById(bundleName, moduleName, resId, density, userId);
2307 }
2308
GetUdidByNetworkId(const std::string & networkId,std::string & udid)2309 int32_t BundleMgrHostImpl::GetUdidByNetworkId(const std::string &networkId, std::string &udid)
2310 {
2311 #ifdef DEVICE_MANAGER_ENABLE
2312 if (!BundlePermissionMgr::VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
2313 APP_LOGE("verify permission failed");
2314 return -1;
2315 }
2316 auto deviceManager = DelayedSingleton<BundleMgrService>::GetInstance()->GetDeviceManager();
2317 if (deviceManager == nullptr) {
2318 APP_LOGE("deviceManager is nullptr");
2319 return -1;
2320 }
2321 return deviceManager->GetUdidByNetworkId(networkId, udid);
2322 #else
2323 APP_LOGW("deviceManager is unable");
2324 return -1;
2325 #endif
2326 }
2327
2328 #ifdef BUNDLE_FRAMEWORK_DEFAULT_APP
GetDefaultAppProxy()2329 sptr<IDefaultApp> BundleMgrHostImpl::GetDefaultAppProxy()
2330 {
2331 return DelayedSingleton<BundleMgrService>::GetInstance()->GetDefaultAppProxy();
2332 }
2333 #endif
2334
2335 #ifdef BUNDLE_FRAMEWORK_APP_CONTROL
GetAppControlProxy()2336 sptr<IAppControlMgr> BundleMgrHostImpl::GetAppControlProxy()
2337 {
2338 return DelayedSingleton<BundleMgrService>::GetInstance()->GetAppControlProxy();
2339 }
2340 #endif
2341
GetQuickFixManagerProxy()2342 sptr<IQuickFixManager> BundleMgrHostImpl::GetQuickFixManagerProxy()
2343 {
2344 #ifdef BUNDLE_FRAMEWORK_QUICK_FIX
2345 return DelayedSingleton<BundleMgrService>::GetInstance()->GetQuickFixManagerProxy();
2346 #else
2347 return nullptr;
2348 #endif
2349 }
2350
GetSandboxAbilityInfo(const Want & want,int32_t appIndex,int32_t flags,int32_t userId,AbilityInfo & info)2351 ErrCode BundleMgrHostImpl::GetSandboxAbilityInfo(const Want &want, int32_t appIndex, int32_t flags, int32_t userId,
2352 AbilityInfo &info)
2353 {
2354 APP_LOGD("start GetSandboxAbilityInfo appIndex : %{public}d, userId : %{public}d", appIndex, userId);
2355 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
2356 APP_LOGE("verify permission failed");
2357 return ERR_APPEXECFWK_PERMISSION_DENIED;
2358 }
2359 auto dataMgr = GetDataMgrFromService();
2360 if (dataMgr == nullptr) {
2361 APP_LOGE("DataMgr is nullptr");
2362 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2363 }
2364
2365 if (!dataMgr->QueryAbilityInfo(want, flags, userId, info, appIndex)) {
2366 APP_LOGE("query ability info failed");
2367 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2368 }
2369 return ERR_OK;
2370 }
2371
GetSandboxExtAbilityInfos(const Want & want,int32_t appIndex,int32_t flags,int32_t userId,std::vector<ExtensionAbilityInfo> & infos)2372 ErrCode BundleMgrHostImpl::GetSandboxExtAbilityInfos(const Want &want, int32_t appIndex, int32_t flags,
2373 int32_t userId, std::vector<ExtensionAbilityInfo> &infos)
2374 {
2375 APP_LOGD("start GetSandboxExtAbilityInfos appIndex : %{public}d, userId : %{public}d", appIndex, userId);
2376 if (!VerifyQueryPermission(want.GetElement().GetBundleName())) {
2377 APP_LOGE("verify permission failed");
2378 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
2379 }
2380 auto dataMgr = GetDataMgrFromService();
2381 if (dataMgr == nullptr) {
2382 APP_LOGE("DataMgr is nullptr");
2383 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2384 }
2385
2386 if (!dataMgr->QueryExtensionAbilityInfos(want, flags, userId, infos, appIndex)) {
2387 APP_LOGE("query extension ability info failed");
2388 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2389 }
2390 return ERR_OK;
2391 }
2392
GetSandboxHapModuleInfo(const AbilityInfo & abilityInfo,int32_t appIndex,int32_t userId,HapModuleInfo & info)2393 ErrCode BundleMgrHostImpl::GetSandboxHapModuleInfo(const AbilityInfo &abilityInfo, int32_t appIndex, int32_t userId,
2394 HapModuleInfo &info)
2395 {
2396 APP_LOGD("start GetSandboxHapModuleInfo appIndex : %{public}d, userId : %{public}d", appIndex, userId);
2397 if (!VerifyQueryPermission(abilityInfo.bundleName)) {
2398 APP_LOGE("verify permission failed");
2399 return false;
2400 }
2401 auto dataMgr = GetDataMgrFromService();
2402 if (dataMgr == nullptr) {
2403 APP_LOGE("DataMgr is nullptr");
2404 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2405 }
2406 auto sandboxAppHelper = dataMgr->GetSandboxAppHelper();
2407 if (sandboxAppHelper == nullptr) {
2408 APP_LOGE("sandboxAppHelper is nullptr");
2409 return ERR_APPEXECFWK_SANDBOX_QUERY_INTERNAL_ERROR;
2410 }
2411 int32_t requestUserId = dataMgr->GetUserId(userId);
2412 if (requestUserId == Constants::INVALID_USERID) {
2413 return ERR_APPEXECFWK_SANDBOX_QUERY_INVALID_USER_ID;
2414 }
2415 return sandboxAppHelper->GetSandboxHapModuleInfo(abilityInfo, appIndex, requestUserId, info);
2416 }
2417
GetMediaData(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,std::unique_ptr<uint8_t[]> & mediaDataPtr,size_t & len,int32_t userId)2418 ErrCode BundleMgrHostImpl::GetMediaData(const std::string &bundleName, const std::string &moduleName,
2419 const std::string &abilityName, std::unique_ptr<uint8_t[]> &mediaDataPtr, size_t &len, int32_t userId)
2420 {
2421 if (!VerifySystemApi(Constants::API_VERSION_NINE)) {
2422 APP_LOGE("non-system app calling system api");
2423 return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED;
2424 }
2425 if (!VerifyQueryPermission(bundleName)) {
2426 APP_LOGE("verify permission failed");
2427 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
2428 }
2429 auto dataMgr = GetDataMgrFromService();
2430 if (dataMgr == nullptr) {
2431 APP_LOGE("DataMgr is nullptr");
2432 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2433 }
2434 return dataMgr->GetMediaData(bundleName, moduleName, abilityName, mediaDataPtr, len, userId);
2435 }
2436
NotifyBundleStatus(const NotifyBundleEvents & installRes)2437 void BundleMgrHostImpl::NotifyBundleStatus(const NotifyBundleEvents &installRes)
2438 {
2439 std::shared_ptr<BundleCommonEventMgr> commonEventMgr = std::make_shared<BundleCommonEventMgr>();
2440 commonEventMgr->NotifyBundleStatus(installRes, nullptr);
2441 }
2442
SetDebugMode(bool isDebug)2443 ErrCode BundleMgrHostImpl::SetDebugMode(bool isDebug)
2444 {
2445 int32_t callingUid = IPCSkeleton::GetCallingUid();
2446 if (callingUid != Constants::ROOT_UID && callingUid != Constants::BMS_UID) {
2447 APP_LOGE("invalid calling uid %{public}d to set debug mode", callingUid);
2448 return ERR_BUNDLEMANAGER_SET_DEBUG_MODE_UID_CHECK_FAILED;
2449 }
2450 if (isDebug) {
2451 BundleVerifyMgr::EnableDebug();
2452 } else {
2453 BundleVerifyMgr::DisableDebug();
2454 }
2455 return ERR_OK;
2456 }
2457
VerifySystemApi(int32_t beginApiVersion)2458 bool BundleMgrHostImpl::VerifySystemApi(int32_t beginApiVersion)
2459 {
2460 APP_LOGD("begin to verify system app");
2461 return BundlePermissionMgr::VerifySystemApp(beginApiVersion);
2462 }
2463
GetProvisionMetadata(const std::string & bundleName,int32_t userId,std::vector<Metadata> & provisionMetadatas)2464 ErrCode BundleMgrHostImpl::GetProvisionMetadata(const std::string &bundleName, int32_t userId,
2465 std::vector<Metadata> &provisionMetadatas)
2466 {
2467 if (!VerifyQueryPermission(bundleName)) {
2468 APP_LOGE("verify permission failed");
2469 return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
2470 }
2471 auto dataMgr = GetDataMgrFromService();
2472 if (dataMgr == nullptr) {
2473 APP_LOGE("DataMgr is nullptr");
2474 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2475 }
2476 return dataMgr->GetProvisionMetadata(bundleName, userId, provisionMetadatas);
2477 }
2478 } // namespace AppExecFwk
2479 } // namespace OHOS
2480