1 /*
2  * Copyright (c) 2020 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 #include "bundle_manager.h"
16 
17 #include "ability_info_utils.h"
18 #include "adapter.h"
19 #include "bundle_callback.h"
20 #include "bundle_callback_utils.h"
21 #include "bundle_info_utils.h"
22 #include "bundle_inner_interface.h"
23 #include "bundle_self_callback.h"
24 #include "convert_utils.h"
25 #include "iproxy_client.h"
26 #include "ipc_skeleton.h"
27 #include "bundle_log.h"
28 #include "ohos_types.h"
29 #include "pms_interface.h"
30 #include "samgr_lite.h"
31 #include "securec.h"
32 #include "want_utils.h"
33 
34 extern "C" {
35 constexpr static char PERMISSION_INSTALL_BUNDLE[] = "ohos.permission.INSTALL_BUNDLE";
36 constexpr static char PERMISSION_GET_BUNDLE_INFO[] = "ohos.permission.GET_BUNDLE_INFO";
37 constexpr static char PERMISSION_LISTEN_BUNDLE_CHANGE[] = "ohos.permission.LISTEN_BUNDLE_CHANGE";
38 constexpr static uint8_t MAX_BUNDLE_NAME = 128;
39 constexpr static uint8_t OBJECT_NUMBER_IN_WANT = 2;
40 #ifdef __LINUX__
41 constexpr static uint8_t OBJECT_NUMBER_IN_INSTALLATION = 1;
42 #else
43 constexpr static uint8_t OBJECT_NUMBER_IN_INSTALLATION = 2;
44 #endif
45 
RegisterCallback(BundleStatusCallback * bundleStatusCallback)46 int32_t RegisterCallback(BundleStatusCallback *bundleStatusCallback)
47 {
48     if ((bundleStatusCallback == nullptr) || (bundleStatusCallback->callBack == nullptr)) {
49         return ERR_APPEXECFWK_OBJECT_NULL;
50     }
51     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_LISTEN_BUNDLE_CHANGE)) != GRANTED) {
52         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager register callback failed due to permission denied");
53         return ERR_APPEXECFWK_PERMISSION_DENIED;
54     }
55 
56     return OHOS::BundleCallback::GetInstance().RegisterBundleStateCallback(bundleStatusCallback->callBack,
57         bundleStatusCallback->bundleName, bundleStatusCallback->data);
58 }
59 
UnregisterCallback()60 int32_t UnregisterCallback()
61 {
62     return OHOS::BundleCallback::GetInstance().UnregisterBundleStateCallback();
63 }
64 
DeserializeInnerAbilityInfo(IOwner owner,IpcIo * reply)65 static uint8_t DeserializeInnerAbilityInfo(IOwner owner, IpcIo *reply)
66 {
67     if ((reply == nullptr) || (owner == nullptr)) {
68         return OHOS_FAILURE;
69     }
70     uint8_t resultCode;
71     ReadUint8(reply, &resultCode);
72     ResultOfQueryAbilityInfo *info = reinterpret_cast<ResultOfQueryAbilityInfo *>(owner);
73     if (resultCode != ERR_OK) {
74         info->resultCode = resultCode;
75         return resultCode;
76     }
77     size_t len = 0;
78     char *jsonStr = reinterpret_cast<char *>(ReadString(reply, &len));
79     if (jsonStr == nullptr) {
80         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
81         HILOG_ERROR(HILOG_MODULE_APP, "AbilityInfo DeserializeAbilityInfo buff is empty!");
82         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
83     }
84     info->abilityInfo = OHOS::ConvertUtils::ConvertStringToAbilityInfo(jsonStr, len);
85     if (info->abilityInfo == nullptr) {
86         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
87         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
88     }
89     info->resultCode = resultCode;
90     return resultCode;
91 }
92 
DeserializeInnerBundleInfo(IOwner owner,IpcIo * reply)93 static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply)
94 {
95     HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo start");
96     if ((reply == nullptr) || (owner == nullptr)) {
97         return OHOS_FAILURE;
98     }
99     uint8_t resultCode;
100     ReadUint8(reply, &resultCode);
101     ResultOfGetBundleInfo *info = reinterpret_cast<ResultOfGetBundleInfo *>(owner);
102     if (resultCode != ERR_OK) {
103         info->resultCode = resultCode;
104         return resultCode;
105     }
106     size_t len = 0;
107     char *jsonStr = reinterpret_cast<char *>(ReadString(reply, &len));
108     if (jsonStr == nullptr) {
109         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
110         HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfo buff is empty!");
111         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
112     }
113     info->bundleInfo = OHOS::ConvertUtils::ConvertStringToBundleInfo(jsonStr, len);
114     if (info->bundleInfo == nullptr) {
115         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
116         HILOG_ERROR(HILOG_MODULE_APP, "ConvertStringToBundleInfo failed");
117         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
118     }
119     info->resultCode = resultCode;
120     HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo finished");
121     return resultCode;
122 }
123 
DeserializeInnerBundleInfos(IOwner owner,IpcIo * reply)124 static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply)
125 {
126     HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos start");
127     if ((reply == nullptr) || (owner == nullptr)) {
128         return OHOS_FAILURE;
129     }
130     uint8_t resultCode;
131     ReadUint8(reply, &resultCode);
132     ResultOfGetBundleInfos *info = reinterpret_cast<ResultOfGetBundleInfos *>(owner);
133     if (resultCode != ERR_OK) {
134         info->resultCode = resultCode;
135         return resultCode;
136     }
137 
138     ReadInt32(reply, &(info->length));
139     size_t len = 0;
140     char *jsonStr = reinterpret_cast<char*>(ReadString(reply, &len));
141     if (jsonStr == nullptr) {
142         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
143         HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfos buff is empty!");
144         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
145     }
146     if (!OHOS::ConvertUtils::ConvertStringToBundleInfos(jsonStr, &(info->bundleInfo), info->length, len)) {
147         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
148         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
149     }
150 
151     info->resultCode = resultCode;
152     HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos finished");
153     return resultCode;
154 }
155 
DeserializeInnerBundleName(IOwner owner,IpcIo * reply)156 static uint8_t DeserializeInnerBundleName(IOwner owner, IpcIo *reply)
157 {
158     if ((reply == nullptr) || (owner == nullptr)) {
159         return OHOS_FAILURE;
160     }
161     uint8_t resultCode;
162     ReadUint8(reply, &resultCode);
163     ResultOfGetBundleNameForUid *info = reinterpret_cast<ResultOfGetBundleNameForUid *>(owner);
164     if (resultCode != ERR_OK) {
165         info->resultCode = resultCode;
166         return resultCode;
167     }
168 
169     size_t length = 0;
170     char *bundleName = reinterpret_cast<char *>(ReadString(reply, &length));
171     if (bundleName == nullptr) {
172         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
173         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
174     }
175     if (length > MAX_BUNDLE_NAME) {
176         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
177         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
178     }
179     info->bundleName = reinterpret_cast<char *>(AdapterMalloc(length + 1));
180     if (info->bundleName == nullptr) {
181         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeInnerBundleName failed");
182         info->resultCode = ERR_APPEXECFWK_OBJECT_NULL;
183         return ERR_APPEXECFWK_OBJECT_NULL;
184     }
185     errno_t err = strncpy_s(info->bundleName, length + 1, bundleName, length);
186     if (err != EOK) {
187         AdapterFree(info->bundleName);
188         info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
189         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
190     }
191     info->length = length;
192     info->resultCode = resultCode;
193     return resultCode;
194 }
195 
DeserializeBundleSize(IOwner owner,IpcIo * reply)196 static uint8_t DeserializeBundleSize(IOwner owner, IpcIo *reply)
197 {
198     if ((reply == nullptr) || (owner == nullptr)) {
199         return OHOS_FAILURE;
200     }
201     uint8_t resultCode;
202     ReadUint8(reply, &resultCode);
203     ResultOfGetBundleSize *info = reinterpret_cast<ResultOfGetBundleSize *>(owner);
204     if (resultCode != ERR_OK) {
205         info->resultCode = resultCode;
206         return resultCode;
207     }
208     ReadUint32(reply, &(info->bundleSize));
209     info->resultCode = resultCode;
210     return resultCode;
211 }
212 
DeserializeSystemCapabilities(IOwner owner,IpcIo * reply)213 static uint8_t DeserializeSystemCapabilities(IOwner owner, IpcIo *reply)
214 {
215     if ((reply == nullptr) || (owner == nullptr)) {
216         return OHOS_FAILURE;
217     }
218     uint8_t resultCode;
219     ReadUint8(reply, &resultCode);
220     ResultOfGetSysCap *info = reinterpret_cast<ResultOfGetSysCap *>(owner);
221     if (resultCode != ERR_OK) {
222         info->resultCode = resultCode;
223         return resultCode;
224     }
225     int32_t sysCapCount;
226     ReadInt32(reply, &sysCapCount);
227     info->systemCap.systemCapName = reinterpret_cast<SystemCapName *>(AdapterMalloc(sizeof(SystemCapName) *
228         sysCapCount));
229     if (info->systemCap.systemCapName == nullptr) {
230         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeSystemCapabilities failed");
231         info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
232         return ERR_APPEXECFWK_OBJECT_NULL;
233     }
234     if (memset_s(info->systemCap.systemCapName, sizeof(SystemCapName) * sysCapCount,
235         0, sizeof(SystemCapName) * sysCapCount)) {
236         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeSystemCapabilities failed");
237         AdapterFree(info->systemCap.systemCapName);
238         info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
239         return ERR_APPEXECFWK_OBJECT_NULL;
240     }
241     for (int32_t index = 0; index < sysCapCount; index++) {
242         size_t sysCapNameLen;
243         char *sysCapName = reinterpret_cast<char *>(ReadString(reply, &sysCapNameLen));
244         errno_t err = strncpy_s(info->systemCap.systemCapName[index].name, MAX_SYSCAP_NAME_LEN,
245             sysCapName, sysCapNameLen);
246         if (err != EOK) {
247             AdapterFree(info->systemCap.systemCapName);
248             info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
249             return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
250         }
251     }
252     info->systemCap.systemCapNum = sysCapCount;
253     info->resultCode = resultCode;
254     return resultCode;
255 }
256 
Notify(IOwner owner,int code,IpcIo * reply)257 static int Notify(IOwner owner, int code, IpcIo *reply)
258 {
259     if ((reply == nullptr) || (owner == nullptr)) {
260         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Notify ipc is nullptr");
261         return OHOS_FAILURE;
262     }
263     uint8_t resultCode;
264     ReadUint8(reply, &resultCode);
265     switch (resultCode) {
266         case INSTALL:
267         case UNINSTALL: {
268             uint8_t *ret = reinterpret_cast<uint8_t *>(owner);
269             ReadUint8(reply, ret);
270             HILOG_INFO(HILOG_MODULE_APP, "BundleManager install or uninstall invoke return: %{public}d", *ret);
271             break;
272         }
273         case QUERY_ABILITY_INFO: {
274             return DeserializeInnerAbilityInfo(owner, reply);
275         }
276         case GET_BUNDLE_INFO: {
277             return DeserializeInnerBundleInfo(owner, reply);
278         }
279         case GET_BUNDLE_INFOS:
280         case QUERY_KEEPALIVE_BUNDLE_INFOS:
281         case GET_BUNDLE_INFOS_BY_METADATA: {
282             return DeserializeInnerBundleInfos(owner, reply);
283         }
284         case GET_BUNDLE_INFO_LENGTH: {
285             ResultOfGetBundleInfos *resultOfGetBundleInfos = reinterpret_cast<ResultOfGetBundleInfos *>(owner);
286             uint8_t errCode;
287             ReadUint8(reply, &errCode);
288             if (errCode != ERR_OK) {
289                 HILOG_INFO(HILOG_MODULE_APP, "BundleManager get bundleInfos length failed due to %{public}d", errCode);
290                 resultOfGetBundleInfos->resultCode = errCode;
291                 return errCode;
292             }
293             ReadInt32(reply, &(resultOfGetBundleInfos->length));
294             HILOG_INFO(HILOG_MODULE_APP, "BundleManager bundleInfo len is: %{public}d", resultOfGetBundleInfos->length);
295             break;
296         }
297         case GET_BUNDLE_INFO_BY_INDEX: {
298             return DeserializeInnerBundleInfo(owner, reply);
299         }
300         case GET_BUNDLENAME_FOR_UID: {
301             return DeserializeInnerBundleName(owner, reply);
302         }
303         case CHECK_SYS_CAP: {
304             uint8_t *ret = reinterpret_cast<uint8_t *>(owner);
305             ReadUint8(reply, ret);
306             HILOG_INFO(HILOG_MODULE_APP, "BundleManager HasSystemCapability invoke return: %{public}d", *ret);
307             break;
308         }
309         case GET_BUNDLE_SIZE: {
310             return DeserializeBundleSize(owner, reply);
311         }
312         case GET_SYS_CAP: {
313             return DeserializeSystemCapabilities(owner, reply);
314         }
315 #ifdef OHOS_DEBUG
316         case SET_EXTERNAL_INSTALL_MODE:
317         case SET_SIGN_DEBUG_MODE:
318         case SET_SIGN_MODE: {
319             uint8_t *ret = reinterpret_cast<uint8_t *>(owner);
320             ReadUint8(reply, ret);
321             break;
322         }
323 #endif
324         default: {
325             break;
326         }
327     }
328     return ERR_OK;
329 }
330 
GetBmsClient()331 static IClientProxy *GetBmsClient()
332 {
333     IClientProxy *bmsClient = nullptr;
334     IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(BMS_SERVICE, BMS_FEATURE);
335     if (iUnknown == nullptr) {
336         return nullptr;
337     }
338     int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, reinterpret_cast<void **>(&bmsClient));
339     if (result != 0) {
340         return nullptr;
341     }
342 
343     return bmsClient;
344 }
345 
GetBmsInnerClient()346 static IClientProxy *GetBmsInnerClient()
347 {
348     IClientProxy *bmsClient = nullptr;
349     IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(BMS_SERVICE, BMS_INNER_FEATURE);
350     if (iUnknown == nullptr) {
351         return nullptr;
352     }
353     int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, reinterpret_cast<void **>(&bmsClient));
354     if (result != 0) {
355         return nullptr;
356     }
357 
358     return bmsClient;
359 }
360 
Install(const char * hapPath,const InstallParam * installParam,InstallerCallback installerCallback)361 bool Install(const char *hapPath, const InstallParam *installParam, InstallerCallback installerCallback)
362 {
363     if ((hapPath == nullptr) || (installerCallback == nullptr) || (installParam == nullptr)) {
364         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to nullptr parameters");
365         return false;
366     }
367     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_INSTALL_BUNDLE)) != GRANTED) {
368         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to permission denied");
369         return false;
370     }
371     auto bmsInnerClient = GetBmsInnerClient();
372     if (bmsInnerClient == nullptr) {
373         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to nullptr bms client");
374         return false;
375     }
376 
377     IpcIo ipcIo;
378     char data[MAX_IO_SIZE];
379     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, OBJECT_NUMBER_IN_INSTALLATION);
380     WriteString(&ipcIo, hapPath);
381     const SvcIdentity *svc = OHOS::BundleSelfCallback::GetInstance().RegisterBundleSelfCallback(installerCallback);
382     if (svc == nullptr) {
383         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install svc is nullptr");
384         return false;
385     }
386     bool writeRemote = WriteRemoteObject(&ipcIo, svc);
387     if (!writeRemote) {
388         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install ipc failed");
389         return false;
390     }
391     WriteInt32(&ipcIo, installParam->installLocation);
392     HILOG_DEBUG(HILOG_MODULE_APP, "BMS client invoke install");
393     uint8_t result = 0;
394     int32_t ret = bmsInnerClient->Invoke(bmsInnerClient, INSTALL, &ipcIo, &result, Notify);
395     if (ret != OHOS_SUCCESS) {
396         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install invoke failed: %{public}d", ret);
397         return false;
398     }
399     return result == OHOS_SUCCESS;
400 }
401 
Uninstall(const char * bundleName,const InstallParam * installParam,InstallerCallback installerCallback)402 bool Uninstall(const char *bundleName, const InstallParam *installParam, InstallerCallback installerCallback)
403 {
404     // installParam is nullptr at present.
405     if ((bundleName == nullptr) || (installerCallback == nullptr) || (strlen(bundleName) >= MAX_BUNDLE_NAME) ||
406         (installParam == nullptr)) {
407         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to nullptr or invalid parameters");
408         return false;
409     }
410     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_INSTALL_BUNDLE)) != GRANTED) {
411         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to permission denied");
412         return false;
413     }
414     auto bmsInnerClient = GetBmsInnerClient();
415     if (bmsInnerClient == nullptr) {
416         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to nullptr bms client");
417         return false;
418     }
419 
420     const SvcIdentity *svc = OHOS::BundleSelfCallback::GetInstance().RegisterBundleSelfCallback(installerCallback);
421     if (svc == nullptr) {
422         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall svc is nullptr");
423         return false;
424     }
425     IpcIo ipcIo;
426     char data[MAX_IO_SIZE];
427     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 1);
428     WriteString(&ipcIo, bundleName);
429     bool writeRemote = WriteRemoteObject(&ipcIo, svc);
430     if (!writeRemote) {
431         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall ipc failed");
432         return false;
433     }
434     WriteBool(&ipcIo, installParam->keepData);
435     HILOG_DEBUG(HILOG_MODULE_APP, "BMS client invoke uninstall");
436     uint8_t result = 0;
437     int32_t ret = bmsInnerClient->Invoke(bmsInnerClient, UNINSTALL, &ipcIo, &result, Notify);
438     if (ret != OHOS_SUCCESS) {
439         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall invoke failed: %{public}d", ret);
440         return false;
441     }
442     return result == OHOS_SUCCESS;
443 }
444 
QueryAbilityInfo(const Want * want,AbilityInfo * abilityInfo)445 uint8_t QueryAbilityInfo(const Want *want, AbilityInfo *abilityInfo)
446 {
447     if ((want == nullptr) || (abilityInfo == nullptr)) {
448         return ERR_APPEXECFWK_OBJECT_NULL;
449     }
450     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
451         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager query AbilityInfo failed due to permission denied");
452         return ERR_APPEXECFWK_PERMISSION_DENIED;
453     }
454     auto bmsClient = GetBmsClient();
455     if (bmsClient == nullptr) {
456         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager query AbilityInfo failed due to nullptr bms client");
457         return ERR_APPEXECFWK_OBJECT_NULL;
458     }
459 
460     IpcIo ipcIo;
461     char data[MAX_IO_SIZE];
462     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, OBJECT_NUMBER_IN_WANT);
463     if (!SerializeWant(&ipcIo, want)) {
464         return ERR_APPEXECFWK_SERIALIZATION_FAILED;
465     }
466     ResultOfQueryAbilityInfo resultOfQueryAbilityInfo = { 0, nullptr };
467 
468     int32_t ret = bmsClient->Invoke(bmsClient, QUERY_ABILITY_INFO, &ipcIo, &resultOfQueryAbilityInfo, Notify);
469     if (ret != OHOS_SUCCESS) {
470         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager QueryAbilityInfo invoke failed: %{public}d", ret);
471         return ERR_APPEXECFWK_INVOKE_ERROR;
472     }
473 
474     if (resultOfQueryAbilityInfo.abilityInfo == nullptr) {
475         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager QueryAbilityInfo failed: %{public}d",
476             resultOfQueryAbilityInfo.resultCode);
477         return resultOfQueryAbilityInfo.resultCode;
478     }
479     if (resultOfQueryAbilityInfo.resultCode == ERR_OK) {
480         OHOS::AbilityInfoUtils::CopyAbilityInfo(abilityInfo, *(resultOfQueryAbilityInfo.abilityInfo));
481         ClearAbilityInfo(resultOfQueryAbilityInfo.abilityInfo);
482         AdapterFree(resultOfQueryAbilityInfo.abilityInfo);
483     }
484 
485     return resultOfQueryAbilityInfo.resultCode;
486 }
487 
GetBundleInfo(const char * bundleName,int32_t flags,BundleInfo * bundleInfo)488 uint8_t GetBundleInfo(const char *bundleName, int32_t flags, BundleInfo *bundleInfo)
489 {
490     if ((bundleName == nullptr) || (bundleInfo == nullptr)) {
491         return ERR_APPEXECFWK_OBJECT_NULL;
492     }
493     if (flags < 0 || flags > 1 || (strlen(bundleName) >= MAX_BUNDLE_NAME)) {
494         return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
495     }
496     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
497         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfo failed due to permission denied");
498         return ERR_APPEXECFWK_PERMISSION_DENIED;
499     }
500     auto bmsClient = GetBmsClient();
501     if (bmsClient == nullptr) {
502         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfo failed due to nullptr bms client");
503         return ERR_APPEXECFWK_OBJECT_NULL;
504     }
505 
506     IpcIo ipcIo;
507     char data[MAX_IO_SIZE];
508     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
509     WriteString(&ipcIo, bundleName);
510     WriteInt32(&ipcIo, flags);
511     ResultOfGetBundleInfo resultOfGetBundleInfo;
512     resultOfGetBundleInfo.bundleInfo = nullptr;
513     int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO, &ipcIo, &resultOfGetBundleInfo, Notify);
514     if (ret != OHOS_SUCCESS) {
515         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfo invoke failed: %{public}d", ret);
516         return ERR_APPEXECFWK_INVOKE_ERROR;
517     }
518     if (resultOfGetBundleInfo.bundleInfo == nullptr) {
519         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfo failed: %{public}d",
520             resultOfGetBundleInfo.resultCode);
521         return resultOfGetBundleInfo.resultCode;
522     }
523     if (resultOfGetBundleInfo.resultCode == ERR_OK) {
524         OHOS::BundleInfoUtils::CopyBundleInfo(flags, bundleInfo, *(resultOfGetBundleInfo.bundleInfo));
525         ClearBundleInfo(resultOfGetBundleInfo.bundleInfo);
526         AdapterFree(resultOfGetBundleInfo.bundleInfo);
527     }
528     return resultOfGetBundleInfo.resultCode;
529 }
530 
ObtainInnerBundleInfos(const int flags,BundleInfo ** bundleInfos,int32_t * len,uint8_t code,IpcIo * ipcIo)531 static uint8_t ObtainInnerBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len,
532     uint8_t code, IpcIo *ipcIo)
533 {
534     if ((bundleInfos == nullptr) || (len == nullptr) || (ipcIo == nullptr)) {
535         return ERR_APPEXECFWK_OBJECT_NULL;
536     }
537     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
538         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfos failed due to permission denied");
539         return ERR_APPEXECFWK_PERMISSION_DENIED;
540     }
541     auto bmsClient = GetBmsClient();
542     if (bmsClient == nullptr) {
543         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfos failed due to nullptr bms client");
544         return ERR_APPEXECFWK_OBJECT_NULL;
545     }
546 
547     ResultOfGetBundleInfos resultOfGetBundleInfos;
548     resultOfGetBundleInfos.length = 0;
549     resultOfGetBundleInfos.bundleInfo = nullptr;
550     int32_t ret = bmsClient->Invoke(bmsClient, code, ipcIo, &resultOfGetBundleInfos, Notify);
551     if (ret != OHOS_SUCCESS) {
552         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainInnerBundleInfo invoke failed: %{public}d\n", ret);
553         return ERR_APPEXECFWK_INVOKE_ERROR;
554     }
555 
556     if (resultOfGetBundleInfos.length == 0 || resultOfGetBundleInfos.resultCode != ERR_OK) {
557         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainInnerBundleInfo fail");
558         *bundleInfos = nullptr;
559         return resultOfGetBundleInfos.resultCode;
560     }
561 
562     *bundleInfos = reinterpret_cast<BundleInfo *>(AdapterMalloc(sizeof(BundleInfo) * resultOfGetBundleInfos.length));
563     if (*bundleInfos == nullptr) {
564         OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
565         return ERR_APPEXECFWK_OBJECT_NULL;
566     }
567     if (memset_s(*bundleInfos, sizeof(BundleInfo) * (resultOfGetBundleInfos.length), 0, sizeof(BundleInfo) *
568         (resultOfGetBundleInfos.length)) != EOK) {
569         AdapterFree(*bundleInfos);
570         OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
571         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
572     }
573     for (int32_t i = 0; i < resultOfGetBundleInfos.length; ++i) {
574         OHOS::BundleInfoUtils::CopyBundleInfo(flags, *bundleInfos + i, (resultOfGetBundleInfos.bundleInfo)[i]);
575     }
576     *len = resultOfGetBundleInfos.length;
577     OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
578     return resultOfGetBundleInfos.resultCode;
579 }
580 
ObtainBundleInfosOneByOne(BasicInfo basicInfo,int32_t len,uint8_t code,IClientProxy * bmsClient,BundleInfo ** bundleInfos)581 static uint8_t ObtainBundleInfosOneByOne(BasicInfo basicInfo, int32_t len, uint8_t code, IClientProxy *bmsClient,
582     BundleInfo **bundleInfos)
583 {
584     if (bmsClient == nullptr || bundleInfos == nullptr) {
585         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne failed due to nullptr parma");
586         return ERR_APPEXECFWK_OBJECT_NULL;
587     }
588     for (int32_t i = 0; i < len; ++i) {
589         IpcIo innerIpcIo;
590         char data[MAX_IO_SIZE];
591         IpcIoInit(&innerIpcIo, data, MAX_IO_SIZE, 0);
592         WriteInt32(&innerIpcIo, static_cast<int32_t>(code));
593         if (code == GET_BUNDLE_INFOS) {
594             WriteInt32(&innerIpcIo, basicInfo.flags);
595         }
596         if (code == GET_BUNDLE_INFOS_BY_METADATA) {
597             WriteString(&innerIpcIo, basicInfo.metaDataKey);
598         }
599         WriteInt32(&innerIpcIo, i);
600         ResultOfGetBundleInfo resultOfGetBundleInfo;
601         resultOfGetBundleInfo.bundleInfo = nullptr;
602         int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_BY_INDEX, &innerIpcIo,
603             &resultOfGetBundleInfo, Notify);
604         if (ret != OHOS_SUCCESS) {
605             HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne invoke failed: %{public}d", ret);
606             return ERR_APPEXECFWK_INVOKE_ERROR;
607         }
608         if (resultOfGetBundleInfo.bundleInfo == nullptr) {
609             HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne failed: %{public}d",
610                 resultOfGetBundleInfo.resultCode);
611             return resultOfGetBundleInfo.resultCode;
612         }
613         OHOS::BundleInfoUtils::CopyBundleInfo(basicInfo.flags, *bundleInfos + i, *(resultOfGetBundleInfo.bundleInfo));
614         ClearBundleInfo(resultOfGetBundleInfo.bundleInfo);
615         AdapterFree(resultOfGetBundleInfo.bundleInfo);
616     }
617     return OHOS_SUCCESS;
618 }
619 
ObtainBundleInfos(BasicInfo basicInfo,BundleInfo ** bundleInfos,int32_t * len,uint8_t code,IpcIo * ipcIo)620 static uint8_t ObtainBundleInfos(BasicInfo basicInfo, BundleInfo **bundleInfos, int32_t *len,
621     uint8_t code, IpcIo *ipcIo)
622 {
623     if ((bundleInfos == nullptr) || (len == nullptr) || (ipcIo == nullptr)) {
624         return ERR_APPEXECFWK_OBJECT_NULL;
625     }
626     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
627         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to permission denied");
628         return ERR_APPEXECFWK_PERMISSION_DENIED;
629     }
630     auto bmsClient = GetBmsClient();
631     if (bmsClient == nullptr) {
632         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to nullptr bms client");
633         return ERR_APPEXECFWK_OBJECT_NULL;
634     }
635 
636     ResultOfGetBundleInfos resultOfGetBundleInfos;
637     resultOfGetBundleInfos.length = 0;
638     resultOfGetBundleInfos.bundleInfo = nullptr;
639     int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_LENGTH, ipcIo, &resultOfGetBundleInfos, Notify);
640     if (ret != OHOS_SUCCESS) {
641         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos invoke failed: %{public}d\n", ret);
642         return ERR_APPEXECFWK_INVOKE_ERROR;
643     }
644 
645     if (resultOfGetBundleInfos.length == 0 || resultOfGetBundleInfos.resultCode != ERR_OK) {
646         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos fail");
647         *bundleInfos = nullptr;
648         return resultOfGetBundleInfos.resultCode;
649     }
650 
651     *bundleInfos = reinterpret_cast<BundleInfo *>(AdapterMalloc(sizeof(BundleInfo) * resultOfGetBundleInfos.length));
652     if (*bundleInfos == nullptr) {
653         OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
654         return ERR_APPEXECFWK_OBJECT_NULL;
655     }
656     if (memset_s(*bundleInfos, sizeof(BundleInfo) * (resultOfGetBundleInfos.length), 0, sizeof(BundleInfo) *
657         (resultOfGetBundleInfos.length)) != EOK) {
658         AdapterFree(*bundleInfos);
659         OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
660         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
661     }
662 
663     uint8_t res = ObtainBundleInfosOneByOne(basicInfo, resultOfGetBundleInfos.length, code, bmsClient, bundleInfos);
664     if (res != OHOS_SUCCESS) {
665         HILOG_WARN(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos invoke failed: %{public}d\n", res);
666     }
667     *len = resultOfGetBundleInfos.length;
668     OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
669     return res;
670 }
671 
GetBundleInfos(const int flags,BundleInfo ** bundleInfos,int32_t * len)672 uint8_t GetBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len)
673 {
674     if ((bundleInfos == nullptr) || (len == nullptr)) {
675         return ERR_APPEXECFWK_OBJECT_NULL;
676     }
677 
678     if (flags < 0 || flags > 1) {
679         return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR;
680     }
681     IpcIo ipcIo;
682     char data[MAX_IO_SIZE];
683     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
684 #ifdef __LINUX__
685     WriteInt32(&ipcIo, flags);
686     return ObtainInnerBundleInfos(flags, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
687 #else
688     WriteInt32(&ipcIo, GET_BUNDLE_INFOS);
689     WriteInt32(&ipcIo, flags);
690     BasicInfo basicInfo;
691     basicInfo.flags = flags;
692     basicInfo.metaDataKey = nullptr;
693     return ObtainBundleInfos(basicInfo, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
694 #endif
695 }
696 
GetBundleSize(const char * bundleName)697 uint32_t GetBundleSize(const char *bundleName)
698 {
699     if (bundleName == nullptr) {
700         return 0;
701     }
702     if (strlen(bundleName) >= MAX_BUNDLE_NAME) {
703         return 0;
704     }
705     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
706         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get bundle size failed due to permission denied");
707         return 0;
708     }
709     auto bmsClient = GetBmsClient();
710     if (bmsClient == nullptr) {
711         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get bundle size failed due to nullptr bms client");
712         return 0;
713     }
714 
715     IpcIo ipcIo;
716     char data[MAX_IO_SIZE];
717     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
718     WriteString(&ipcIo, bundleName);
719 
720     ResultOfGetBundleSize resultOfGetBundleSize;
721     int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_SIZE, &ipcIo, &resultOfGetBundleSize, Notify);
722     if (ret != OHOS_SUCCESS) {
723         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleSize invoke failed: %{public}d", ret);
724         return 0;
725     }
726     uint32_t bundleSize = resultOfGetBundleSize.bundleSize;
727     return bundleSize;
728 }
729 
QueryKeepAliveBundleInfos(BundleInfo ** bundleInfos,int32_t * len)730 uint8_t QueryKeepAliveBundleInfos(BundleInfo **bundleInfos, int32_t *len)
731 {
732     if ((bundleInfos == nullptr) || (len == nullptr)) {
733         return ERR_APPEXECFWK_OBJECT_NULL;
734     }
735     IpcIo ipcIo;
736     char data[MAX_IO_SIZE];
737     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
738     return ObtainInnerBundleInfos(0, bundleInfos, len, QUERY_KEEPALIVE_BUNDLE_INFOS, &ipcIo);
739 }
740 
GetBundleInfosByMetaData(const char * metaDataKey,BundleInfo ** bundleInfos,int32_t * len)741 uint8_t GetBundleInfosByMetaData(const char *metaDataKey, BundleInfo **bundleInfos, int32_t *len)
742 {
743     if ((metaDataKey == nullptr) || (bundleInfos == nullptr) || (len == nullptr)) {
744         return ERR_APPEXECFWK_OBJECT_NULL;
745     }
746     IpcIo ipcIo;
747     char data[MAX_IO_SIZE];
748     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
749     WriteString(&ipcIo, metaDataKey);
750     return ObtainInnerBundleInfos(0, bundleInfos, len, GET_BUNDLE_INFOS_BY_METADATA, &ipcIo);
751 }
752 
GetBundleNameForUid(int32_t uid,char ** bundleName)753 uint8_t GetBundleNameForUid(int32_t uid, char **bundleName)
754 {
755     if (bundleName == nullptr) {
756         return ERR_APPEXECFWK_OBJECT_NULL;
757     }
758     if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
759         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleName for uid failed due to permission denied");
760         return ERR_APPEXECFWK_PERMISSION_DENIED;
761     }
762     auto bmsClient = GetBmsClient();
763     if (bmsClient == nullptr) {
764         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleName for uid failed due to nullptr bms client");
765         return ERR_APPEXECFWK_OBJECT_NULL;
766     }
767 
768     IpcIo ipcIo;
769     char data[MAX_IO_SIZE];
770     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
771     WriteInt32(&ipcIo, uid);
772 
773     ResultOfGetBundleNameForUid resultOfGetBundleNameForUid;
774     resultOfGetBundleNameForUid.length = 0;
775     resultOfGetBundleNameForUid.bundleName = nullptr;
776     int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLENAME_FOR_UID, &ipcIo, &resultOfGetBundleNameForUid, Notify);
777     if (ret != OHOS_SUCCESS) {
778         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleNameForUid invoke failed: %{public}d\n", ret);
779         return ERR_APPEXECFWK_INVOKE_ERROR;
780     }
781     if (resultOfGetBundleNameForUid.bundleName == nullptr || resultOfGetBundleNameForUid.length == 0) {
782         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleNameForUid failed: %{public}d\n",
783             resultOfGetBundleNameForUid.resultCode);
784         return resultOfGetBundleNameForUid.resultCode;
785     }
786 
787     *bundleName = reinterpret_cast<char *>(AdapterMalloc(resultOfGetBundleNameForUid.length + 1));
788     if (*bundleName == nullptr) {
789         AdapterFree(resultOfGetBundleNameForUid.bundleName);
790         return ERR_APPEXECFWK_OBJECT_NULL;
791     }
792     errno_t err = strncpy_s(*bundleName, resultOfGetBundleNameForUid.length + 1,
793         resultOfGetBundleNameForUid.bundleName, resultOfGetBundleNameForUid.length);
794     AdapterFree(resultOfGetBundleNameForUid.bundleName);
795     if (err != EOK) {
796         AdapterFree(*bundleName);
797         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
798     }
799     return resultOfGetBundleNameForUid.resultCode;
800 }
801 
HasSystemCapability(const char * sysCapName)802 bool HasSystemCapability(const char *sysCapName)
803 {
804     if (sysCapName == nullptr || strlen(sysCapName) > MAX_SYSCAP_NAME_LEN) {
805         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability failed due to parameters is invalid");
806         return false;
807     }
808     auto bmsClient = GetBmsClient();
809     if (bmsClient == nullptr) {
810         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability failed due to nullptr bms client");
811         return false;
812     }
813     IpcIo ipcIo;
814     char data[MAX_IO_SIZE];
815     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
816     WriteString(&ipcIo, sysCapName);
817     uint8_t result = 0;
818     int32_t ret = bmsClient->Invoke(bmsClient, CHECK_SYS_CAP, &ipcIo, &result, Notify);
819     if (ret != OHOS_SUCCESS) {
820         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability invoke failed: %{public}d", ret);
821         return false;
822     }
823     return result == OHOS_SUCCESS;
824 }
825 
GetSystemAvailableCapabilities()826 SystemCapability *GetSystemAvailableCapabilities()
827 {
828     auto bmsClient = GetBmsClient();
829     if (bmsClient == nullptr) {
830         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities failed due to nullptr bms client");
831         return nullptr;
832     }
833     IpcIo ipcIo;
834     char data[MAX_IO_SIZE];
835     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
836     ResultOfGetSysCap resultOfGetSysCap;
837     resultOfGetSysCap.systemCap.systemCapNum = 0;
838     resultOfGetSysCap.systemCap.systemCapName = nullptr;
839     int32_t ret = bmsClient->Invoke(bmsClient, GET_SYS_CAP, &ipcIo, &resultOfGetSysCap, Notify);
840     if (ret != OHOS_SUCCESS) {
841         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities invoke failed: %{public}d\n", ret);
842         return nullptr;
843     }
844     if (resultOfGetSysCap.systemCap.systemCapNum == 0 || resultOfGetSysCap.resultCode != ERR_OK
845         || resultOfGetSysCap.systemCap.systemCapName == nullptr) {
846         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities fail");
847         return nullptr;
848     }
849     int32_t sysCapNum = resultOfGetSysCap.systemCap.systemCapNum;
850     SystemCapability *retSystemCap = reinterpret_cast<SystemCapability *>(AdapterMalloc(sizeof(SystemCapability)));
851     if (retSystemCap == nullptr) {
852         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities retSystemCap is null");
853         AdapterFree(resultOfGetSysCap.systemCap.systemCapName);
854         return nullptr;
855     }
856     if (memset_s(retSystemCap, sizeof(SystemCapability), 0, sizeof(SystemCapability)) != EOK) {
857         AdapterFree(resultOfGetSysCap.systemCap.systemCapName);
858         AdapterFree(retSystemCap);
859         return nullptr;
860     }
861     int32_t sysCapNameMem = sizeof(SystemCapName) * sysCapNum;
862     retSystemCap->systemCapName = reinterpret_cast<SystemCapName *>(AdapterMalloc(sysCapNameMem));
863     if (retSystemCap->systemCapName == nullptr) {
864         AdapterFree(resultOfGetSysCap.systemCap.systemCapName);
865         AdapterFree(retSystemCap);
866         return nullptr;
867     }
868     if (memset_s(retSystemCap->systemCapName, sysCapNameMem, 0, sysCapNameMem) != EOK) {
869         AdapterFree(resultOfGetSysCap.systemCap.systemCapName);
870         AdapterFree(retSystemCap->systemCapName);
871         AdapterFree(retSystemCap);
872         HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities memset error");
873         return nullptr;
874     }
875     for (int32_t index = 0; index < sysCapNum; index++) {
876         int32_t copyLen = strlen(resultOfGetSysCap.systemCap.systemCapName[index].name);
877         errno_t err = strncpy_s(retSystemCap->systemCapName[index].name, MAX_SYSCAP_NAME_LEN,
878             resultOfGetSysCap.systemCap.systemCapName[index].name, copyLen);
879         if (err != EOK) {
880             HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities strcpy error %{public}d", err);
881             AdapterFree(resultOfGetSysCap.systemCap.systemCapName);
882             AdapterFree(retSystemCap->systemCapName);
883             AdapterFree(retSystemCap);
884             return nullptr;
885         }
886     }
887     retSystemCap->systemCapNum = sysCapNum;
888     return retSystemCap;
889 }
890 
FreeSystemAvailableCapabilitiesInfo(SystemCapability * sysCap)891 void FreeSystemAvailableCapabilitiesInfo(SystemCapability *sysCap)
892 {
893     if (sysCap == nullptr) {
894         return;
895     }
896     if (sysCap->systemCapName != nullptr) {
897         AdapterFree(sysCap->systemCapName);
898     }
899     AdapterFree(sysCap);
900 }
901 }
902