From 5dd8b49ca8419c793c93073c0f195f6fba29eb6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E5=8D=8E?= Date: Fri, 16 Jul 2021 09:20:59 +0000 Subject: [PATCH] =?UTF-8?q?CI=E6=B5=8B=E8=AF=95=E5=8D=95=EF=BC=8C=E8=AF=B7?= =?UTF-8?q?=E5=8B=BF=E5=90=88=E5=85=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test07160716.c | 783 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 783 insertions(+) create mode 100644 test07160716.c diff --git a/test07160716.c b/test07160716.c new file mode 100644 index 000000000..d3644c53e --- /dev/null +++ b/test07160716.c @@ -0,0 +1,783 @@ +#include "bundle_manager.h" + +#include "ability_info_utils.h" +#include "adapter.h" +#include "bundle_callback.h" +#include "bundle_callback_utils.h" +#include "bundle_info_utils.h" +#include "bundle_inner_interface.h" +#include "bundle_self_callback.h" +#include "convert_utils.h" +#include "iproxy_client.h" +#include "liteipc_adapter.h" +#include "log.h" +#include "ohos_types.h" +#include "pms_interface.h" +#include "samgr_lite.h" +#include "securec.h" +#include "want_utils.h" + +extern "C" { +constexpr static char PERMISSION_INSTALL_BUNDLE[] = "ohos.permission.INSTALL_BUNDLE"; +constexpr static char PERMISSION_GET_BUNDLE_INFO[] = "ohos.permission.GET_BUNDLE_INFO"; +constexpr static char PERMISSION_LISTEN_BUNDLE_CHANGE[] = "ohos.permission.LISTEN_BUNDLE_CHANGE"; +constexpr static uint8_t MAX_BUNDLE_NAME = 128; +constexpr static uint8_t OBJECT_NUMBER_IN_WANT = 2; +#ifdef __LINUX__ +constexpr static uint8_t OBJECT_NUMBER_IN_INSTALLATION = 1; +#else +constexpr static uint8_t OBJECT_NUMBER_IN_INSTALLATION = 2; +#endif + +int32 RegisterCallback(BundleStatusCallback *bundleStatusCallback) +{ + if ((bundleStatusCallback == nullptr) || (bundleStatusCallback->callBack == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (CheckSelfPermission(static_cast(PERMISSION_LISTEN_BUNDLE_CHANGE)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager register callback failed due to permission denied"); + return ERR_APPEXECFWK_PERMISSION_DENIED; + } + + return OHOS::BundleCallback::GetInstance().RegisterBundleStateCallback(bundleStatusCallback->callBack, + bundleStatusCallback->bundleName, bundleStatusCallback->data); +} + +int32 UnregisterCallback() +{ + return OHOS::BundleCallback::GetInstance().UnregisterBundleStateCallback(); +} + +static uint8_t DeserializeInnerAbilityInfo(IOwner owner, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + return OHOS_FAILURE; + } + uint8_t resultCode = IpcIoPopUint8(reply); + ResultOfQueryAbilityInfo *info = reinterpret_cast(owner); + if (resultCode != ERR_OK) { + info->resultCode = resultCode; + return resultCode; + } +#ifdef __LINUX__ + size_t len = 0; + char *jsonStr = reinterpret_cast(IpcIoPopString(reply, &len)); + if (jsonStr == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "AbilityInfo DeserializeAbilityInfo buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + info->abilityInfo = OHOS::ConvertUtils::ConvertStringToAbilityInfo(jsonStr, len); +#else + BuffPtr *buff = IpcIoPopDataBuff(reply); + if (buff == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "AbilityInfo DeserializeAbilityInfo buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + char* jsonStr = reinterpret_cast(buff->buff); + info->abilityInfo = OHOS::ConvertUtils::ConvertStringToAbilityInfo(jsonStr, buff->buffSz); + FreeBuffer(NULL, buff->buff); +#endif + if (info->abilityInfo == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + info->resultCode = resultCode; + return resultCode; +} + +static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + return OHOS_FAILURE; + } + uint8_t resultCode = IpcIoPopUint8(reply); + ResultOfGetBundleInfo *info = reinterpret_cast(owner); + if (resultCode != ERR_OK) { + info->resultCode = resultCode; + return resultCode; + } +#ifdef __LINUX__ + size_t len = 0; + char *jsonStr = reinterpret_cast(IpcIoPopString(reply, &len)); + if (jsonStr == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfo buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + info->bundleInfo = OHOS::ConvertUtils::ConvertStringToBundleInfo(jsonStr, len); +#else + BuffPtr *buff = IpcIoPopDataBuff(reply); + if (buff == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfo buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + char* jsonStr = reinterpret_cast(buff->buff); + info->bundleInfo = OHOS::ConvertUtils::ConvertStringToBundleInfo(jsonStr, buff->buffSz); + FreeBuffer(NULL, buff->buff); +#endif + if (info->bundleInfo == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + info->resultCode = resultCode; + return resultCode; +} + +static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + return OHOS_FAILURE; + } + uint8_t resultCode = IpcIoPopUint8(reply); + ResultOfGetBundleInfos *info = reinterpret_cast(owner); + if (resultCode != ERR_OK) { + info->resultCode = resultCode; + return resultCode; + } + + info->length = IpcIoPopInt32(reply); +#ifdef __LINUX__ + size_t len = 0; + char *jsonStr = reinterpret_cast(IpcIoPopString(reply, &len)); + if (jsonStr == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfos buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + if (!OHOS::ConvertUtils::ConvertStringToBundleInfos(jsonStr, &(info->bundleInfo), info->length, len)) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } +#else + BuffPtr *buff = IpcIoPopDataBuff(reply); + if (buff == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + HILOG_ERROR(HILOG_MODULE_APP, "BundleInfo DeserializeBundleInfos buff is empty!"); + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + char *jsonStr = reinterpret_cast(buff->buff); + if (!OHOS::ConvertUtils::ConvertStringToBundleInfos(jsonStr, &(info->bundleInfo), info->length, + buff->buffSz)) { + FreeBuffer(NULL, buff->buff); + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + FreeBuffer(NULL, buff->buff); +#endif + info->resultCode = resultCode; + return resultCode; +} + +static uint8_t DeserializeInnerBundleName(IOwner owner, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + return OHOS_FAILURE; + } + uint8_t resultCode = IpcIoPopUint8(reply); + ResultOfGetBundleNameForUid *info = reinterpret_cast(owner); + if (resultCode != ERR_OK) { + info->resultCode = resultCode; + return resultCode; + } + + size_t length = 0; + char *bundleName = reinterpret_cast(IpcIoPopString(reply, &length)); + if (bundleName == nullptr) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + if (length < 0 || length > MAX_BUNDLE_NAME) { + info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED; + return ERR_APPEXECFWK_DESERIALIZATION_FAILED; + } + info->bundleName = reinterpret_cast(AdapterMalloc(length + 1)); + if (info->bundleName == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeInnerBundleName failed"); + info->resultCode = ERR_APPEXECFWK_OBJECT_NULL; + return ERR_APPEXECFWK_OBJECT_NULL; + } + errno_t err = strncpy_s(info->bundleName, length + 1, bundleName, length); + if (err != EOK) { + AdapterFree(info->bundleName); + info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + } + info->length = length; + info->resultCode = resultCode; + return resultCode; +} + +static uint8_t DeserializeSystemCapabilities(IOwner owner, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + return OHOS_FAILURE; + } + uint8_t resultCode = IpcIoPopUint8(reply); + ResultOfGetSysCap *info = reinterpret_cast(owner); + if (resultCode != ERR_OK) { + info->resultCode = resultCode; + return resultCode; + } + int32_t sysCapCount = IpcIoPopInt32(reply); + info->systemCap.systemCapName = reinterpret_cast(AdapterMalloc(sizeof(SystemCapName) * + sysCapCount)); + if (info->systemCap.systemCapName == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeSystemCapabilities failed"); + info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (memset_s(info->systemCap.systemCapName, sizeof(SystemCapName) * sysCapCount, + 0, sizeof(SystemCapName) * sysCapCount)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager DeserializeSystemCapabilities failed"); + AdapterFree(info->systemCap.systemCapName); + info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + return ERR_APPEXECFWK_OBJECT_NULL; + } + for (int32_t index = 0; index < sysCapCount; index++) { + size_t sysCapNameLen; + char *sysCapName = reinterpret_cast(IpcIoPopString(reply, &sysCapNameLen)); + errno_t err = strncpy_s(info->systemCap.systemCapName[index].name, MAX_SYSCAP_NAME_LEN, + sysCapName, sysCapNameLen); + if (err != EOK) { + AdapterFree(info->systemCap.systemCapName); + info->resultCode = ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + } + } + info->systemCap.systemCapNum = sysCapCount; + info->resultCode = resultCode; + return resultCode; +} + +static int Notify(IOwner owner, int code, IpcIo *reply) +{ + if ((reply == nullptr) || (owner == nullptr)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Notify ipc is nullptr"); + return OHOS_FAILURE; + } + switch (IpcIoPopUint8(reply)) { + case INSTALL: + case UNINSTALL: { + uint8_t *ret = reinterpret_cast(owner); + *ret = IpcIoPopUint8(reply); + HILOG_INFO(HILOG_MODULE_APP, "BundleManager install or uninstall invoke return: %{public}d", *ret); + break; + } + case QUERY_ABILITY_INFO: { + return DeserializeInnerAbilityInfo(owner, reply); + } + case GET_BUNDLE_INFO: { + return DeserializeInnerBundleInfo(owner, reply); + } + case GET_BUNDLE_INFOS: + case QUERY_KEEPALIVE_BUNDLE_INFOS: + case GET_BUNDLE_INFOS_BY_METADATA: { + return DeserializeInnerBundleInfos(owner, reply); + } + case GET_BUNDLENAME_FOR_UID: { + return DeserializeInnerBundleName(owner, reply); + } + case CHECK_SYS_CAP: { + uint8_t *ret = reinterpret_cast(owner); + *ret = IpcIoPopUint8(reply); + HILOG_INFO(HILOG_MODULE_APP, "BundleManager HasSystemCapability invoke return: %{public}d", *ret); + break; + } + case GET_SYS_CAP: { + return DeserializeSystemCapabilities(owner, reply); + } +#ifdef OHOS_DEBUG + case SET_EXTERNAL_INSTALL_MODE: + case SET_SIGN_DEBUG_MODE: + case SET_SIGN_MODE: { + uint8_t *ret = reinterpret_cast(owner); + *ret = IpcIoPopUint8(reply); + break; + } +#endif + default: { + break; + } + } + return ERR_OK; +} + +static IClientProxy *GetBmsClient() +{ + IClientProxy *bmsClient = nullptr; + IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(BMS_SERVICE, BMS_FEATURE); + if (iUnknown == nullptr) { + return nullptr; + } + int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, reinterpret_cast(&bmsClient)); + if (result != 0) { + return nullptr; + } + + return bmsClient; +} + +static IClientProxy *GetBmsInnerClient() +{ + IClientProxy *bmsClient = nullptr; + IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(BMS_SERVICE, BMS_INNER_FEATURE); + if (iUnknown == nullptr) { + return nullptr; + } + int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, reinterpret_cast(&bmsClient)); + if (result != 0) { + return nullptr; + } + + return bmsClient; +} + +bool Install(const char *hapPath, const InstallParam *installParam, InstallerCallback installerCallback) +{ + if ((hapPath == nullptr) || (installerCallback == nullptr) || (installParam == nullptr)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to nullptr parameters"); + return false; + } + if (CheckSelfPermission(static_cast(PERMISSION_INSTALL_BUNDLE)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to permission denied"); + return false; + } + auto bmsInnerClient = GetBmsInnerClient(); + if (bmsInnerClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager install failed due to nullptr bms client"); + return false; + } + + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, OBJECT_NUMBER_IN_INSTALLATION); +#ifdef __LINUX__ + IpcIoPushString(&ipcIo, hapPath); +#else + BuffPtr dataBuff = { + .buffSz = strlen(hapPath) + 1, // include \0 + .buff = const_cast(hapPath) + }; + IpcIoPushDataBuff(&ipcIo, &dataBuff); +#endif + const SvcIdentity *svc = OHOS::BundleSelfCallback::GetInstance().RegisterBundleSelfCallback(installerCallback); + if (svc == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install svc is nullptr"); + return false; + } + IpcIoPushSvc(&ipcIo, svc); + IpcIoPushInt32(&ipcIo, installParam->installLocation); + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install ipc failed"); + return false; + } + HILOG_DEBUG(HILOG_MODULE_APP, "BMS client invoke install"); + uint8_t result = 0; + int32_t ret = bmsInnerClient->Invoke(bmsInnerClient, INSTALL, &ipcIo, &result, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Install invoke failed: %{public}d", ret); + return false; + } + return result == OHOS_SUCCESS; +} + +bool Uninstall(const char *bundleName, const InstallParam *installParam, InstallerCallback installerCallback) +{ + // installParam is nullptr at present. + if ((bundleName == nullptr) || (installerCallback == nullptr) || (strlen(bundleName) >= MAX_BUNDLE_NAME) || + (installParam == nullptr)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to nullptr or invalid parameters"); + return false; + } + if (CheckSelfPermission(static_cast(PERMISSION_INSTALL_BUNDLE)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to permission denied"); + return false; + } + auto bmsInnerClient = GetBmsInnerClient(); + if (bmsInnerClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager uninstall failed due to nullptr bms client"); + return false; + } + + const SvcIdentity *svc = OHOS::BundleSelfCallback::GetInstance().RegisterBundleSelfCallback(installerCallback); + if (svc == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall svc is nullptr"); + return false; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 1); + IpcIoPushString(&ipcIo, bundleName); + IpcIoPushSvc(&ipcIo, svc); + IpcIoPushBool(&ipcIo, installParam->keepData); + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall ipc failed"); + return false; + } + HILOG_DEBUG(HILOG_MODULE_APP, "BMS client invoke uninstall"); + uint8_t result = 0; + int32_t ret = bmsInnerClient->Invoke(bmsInnerClient, UNINSTALL, &ipcIo, &result, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager Uninstall invoke failed: %{public}d", ret); + return false; + } + return result == OHOS_SUCCESS; +} + +uint8_t QueryAbilityInfo(const Want *want, AbilityInfo *abilityInfo) +{ + if ((want == nullptr) || (abilityInfo == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (CheckSelfPermission(static_cast(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager query AbilityInfo failed due to permission denied"); + return ERR_APPEXECFWK_PERMISSION_DENIED; + } + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager query AbilityInfo failed due to nullptr bms client"); + return ERR_APPEXECFWK_OBJECT_NULL; + } + + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, OBJECT_NUMBER_IN_WANT); + if (!SerializeWant(&ipcIo, want)) { + return ERR_APPEXECFWK_SERIALIZATION_FAILED; + } + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager QueryAbilityInfo ipc failed"); + return ERR_APPEXECFWK_SERIALIZATION_FAILED; + } + ResultOfQueryAbilityInfo resultOfQueryAbilityInfo = { 0, nullptr }; + + int32_t ret = bmsClient->Invoke(bmsClient, QUERY_ABILITY_INFO, &ipcIo, &resultOfQueryAbilityInfo, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager QueryAbilityInfo invoke failed: %{public}d", ret); + return ERR_APPEXECFWK_INVOKE_ERROR; + } + + if (resultOfQueryAbilityInfo.abilityInfo == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager QueryAbilityInfo failed: %{public}d", + resultOfQueryAbilityInfo.resultCode); + return resultOfQueryAbilityInfo.resultCode; + } + if (resultOfQueryAbilityInfo.resultCode == ERR_OK) { + OHOS::AbilityInfoUtils::CopyAbilityInfo(abilityInfo, *(resultOfQueryAbilityInfo.abilityInfo)); + ClearAbilityInfo(resultOfQueryAbilityInfo.abilityInfo); + AdapterFree(resultOfQueryAbilityInfo.abilityInfo); + } + + return resultOfQueryAbilityInfo.resultCode; +} + +uint8_t GetBundleInfo(const char *bundleName, int32_t flags, BundleInfo *bundleInfo) +{ + if ((bundleName == nullptr) || (bundleInfo == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (flags < 0 || flags > 1 || (strlen(bundleName) >= MAX_BUNDLE_NAME)) { + return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR; + } + if (CheckSelfPermission(static_cast(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfo failed due to permission denied"); + return ERR_APPEXECFWK_PERMISSION_DENIED; + } + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfo failed due to nullptr bms client"); + return ERR_APPEXECFWK_OBJECT_NULL; + } + + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + IpcIoPushString(&ipcIo, bundleName); + IpcIoPushInt32(&ipcIo, flags); + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfo ipc failed"); + return ERR_APPEXECFWK_SERIALIZATION_FAILED; + } + ResultOfGetBundleInfo resultOfGetBundleInfo; + resultOfGetBundleInfo.bundleInfo = nullptr; + int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO, &ipcIo, &resultOfGetBundleInfo, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfo invoke failed: %{public}d", ret); + return ERR_APPEXECFWK_INVOKE_ERROR; + } + if (resultOfGetBundleInfo.bundleInfo == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfo failed: %{public}d", + resultOfGetBundleInfo.resultCode); + return resultOfGetBundleInfo.resultCode; + } + if (resultOfGetBundleInfo.resultCode == ERR_OK) { + OHOS::BundleInfoUtils::CopyBundleInfo(flags, bundleInfo, *(resultOfGetBundleInfo.bundleInfo)); + ClearBundleInfo(resultOfGetBundleInfo.bundleInfo); + AdapterFree(resultOfGetBundleInfo.bundleInfo); + } + return resultOfGetBundleInfo.resultCode; +} + +static uint8_t ObtainInnerBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len, + uint8_t code, IpcIo *ipcIo) +{ + if ((bundleInfos == nullptr) || (len == nullptr) || (ipcIo == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (CheckSelfPermission(static_cast(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfos failed due to permission denied"); + return ERR_APPEXECFWK_PERMISSION_DENIED; + } + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleInfos failed due to nullptr bms client"); + return ERR_APPEXECFWK_OBJECT_NULL; + } + + if (!IpcIoAvailable(ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleInfos ipc failed"); + return ERR_APPEXECFWK_SERIALIZATION_FAILED; + } + ResultOfGetBundleInfos resultOfGetBundleInfos; + resultOfGetBundleInfos.length = 0; + resultOfGetBundleInfos.bundleInfo = nullptr; + int32_t ret = bmsClient->Invoke(bmsClient, code, ipcIo, &resultOfGetBundleInfos, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainInnerBundleInfo invoke failed: %{public}d\n", ret); + return ERR_APPEXECFWK_INVOKE_ERROR; + } + + if (resultOfGetBundleInfos.length == 0 || resultOfGetBundleInfos.resultCode != ERR_OK) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainInnerBundleInfo fail"); + *bundleInfos = nullptr; + return resultOfGetBundleInfos.resultCode; + } + + *bundleInfos = reinterpret_cast(AdapterMalloc(sizeof(BundleInfo) * resultOfGetBundleInfos.length)); + if (*bundleInfos == nullptr) { + OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length); + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (memset_s(*bundleInfos, sizeof(BundleInfo) * (resultOfGetBundleInfos.length), 0, sizeof(BundleInfo) * + (resultOfGetBundleInfos.length)) != EOK) { + AdapterFree(*bundleInfos); + OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length); + return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + } + for (int32_t i = 0; i < resultOfGetBundleInfos.length; ++i) { + OHOS::BundleInfoUtils::CopyBundleInfo(flags, *bundleInfos + i, (resultOfGetBundleInfos.bundleInfo)[i]); + } + *len = resultOfGetBundleInfos.length; + OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length); + return resultOfGetBundleInfos.resultCode; +} + +uint8_t GetBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len) +{ + if ((bundleInfos == nullptr) || (len == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + + if (flags < 0 || flags > 1) { + return ERR_APPEXECFWK_QUERY_PARAMETER_ERROR; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + IpcIoPushInt32(&ipcIo, flags); + return ObtainInnerBundleInfos(flags, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo); +} + +uint8_t QueryKeepAliveBundleInfos(BundleInfo **bundleInfos, int32_t *len) +{ + if ((bundleInfos == nullptr) || (len == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + return ObtainInnerBundleInfos(0, bundleInfos, len, QUERY_KEEPALIVE_BUNDLE_INFOS, &ipcIo); +} + +uint8_t GetBundleInfosByMetaData(const char *metaDataKey, BundleInfo **bundleInfos, int32_t *len) +{ + if ((metaDataKey == nullptr) || (bundleInfos == nullptr) || (len == nullptr)) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + IpcIoPushString(&ipcIo, metaDataKey); + return ObtainInnerBundleInfos(0, bundleInfos, len, GET_BUNDLE_INFOS_BY_METADATA, &ipcIo); +} + +uint8_t GetBundleNameForUid(int32_t uid, char **bundleName) +{ + if (bundleName == nullptr) { + return ERR_APPEXECFWK_OBJECT_NULL; + } + if (CheckSelfPermission(static_cast(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleName for uid failed due to permission denied"); + return ERR_APPEXECFWK_PERMISSION_DENIED; + } + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager get BundleName for uid failed due to nullptr bms client"); + return ERR_APPEXECFWK_OBJECT_NULL; + } + + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + IpcIoPushInt32(&ipcIo, uid); + + ResultOfGetBundleNameForUid resultOfGetBundleNameForUid; + resultOfGetBundleNameForUid.length = 0; + resultOfGetBundleNameForUid.bundleName = nullptr; + int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLENAME_FOR_UID, &ipcIo, &resultOfGetBundleNameForUid, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleNameForUid invoke failed: %{public}d\n", ret); + return ERR_APPEXECFWK_INVOKE_ERROR; + } + if (resultOfGetBundleNameForUid.bundleName == nullptr || resultOfGetBundleNameForUid.length == 0) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetBundleNameForUid failed: %{public}d\n", + resultOfGetBundleNameForUid.resultCode); + return resultOfGetBundleNameForUid.resultCode; + } + + *bundleName = reinterpret_cast(AdapterMalloc(resultOfGetBundleNameForUid.length + 1)); + if (*bundleName == nullptr) { + AdapterFree(resultOfGetBundleNameForUid.bundleName); + return ERR_APPEXECFWK_OBJECT_NULL; + } + errno_t err = strncpy_s(*bundleName, resultOfGetBundleNameForUid.length + 1, + resultOfGetBundleNameForUid.bundleName, resultOfGetBundleNameForUid.length); + AdapterFree(resultOfGetBundleNameForUid.bundleName); + if (err != EOK) { + return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR; + } + return resultOfGetBundleNameForUid.resultCode; +} + +bool HasSystemCapability(const char *sysCapName) +{ + if (sysCapName == nullptr || strlen(sysCapName) > MAX_SYSCAP_NAME_LEN) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability failed due to parameters is invalid"); + return false; + } + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability failed due to nullptr bms client"); + return false; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + IpcIoPushString(&ipcIo, sysCapName); + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability ipc failed"); + return false; + } + uint8_t result = 0; + int32_t ret = bmsClient->Invoke(bmsClient, CHECK_SYS_CAP, &ipcIo, &result, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager HasSystemCapability invoke failed: %{public}d", ret); + return false; + } + return result == OHOS_SUCCESS; +} + +SystemCapability *GetSystemAvailableCapabilities() +{ + auto bmsClient = GetBmsClient(); + if (bmsClient == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities failed due to nullptr bms client"); + return nullptr; + } + IpcIo ipcIo; + char data[IPC_IO_DATA_MAX]; + IpcIoInit(&ipcIo, data, IPC_IO_DATA_MAX, 0); + if (!IpcIoAvailable(&ipcIo)) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities ipc failed"); + return nullptr; + } + ResultOfGetSysCap resultOfGetSysCap; + resultOfGetSysCap.systemCap.systemCapNum = 0; + resultOfGetSysCap.systemCap.systemCapName = nullptr; + int32_t ret = bmsClient->Invoke(bmsClient, GET_SYS_CAP, &ipcIo, &resultOfGetSysCap, Notify); + if (ret != OHOS_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities invoke failed: %{public}d\n", ret); + return nullptr; + } + if (resultOfGetSysCap.systemCap.systemCapNum == 0 || resultOfGetSysCap.resultCode != ERR_OK + || resultOfGetSysCap.systemCap.systemCapName == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities fail"); + return nullptr; + } + int32_t sysCapNum = resultOfGetSysCap.systemCap.systemCapNum; + SystemCapability *retSystemCap = reinterpret_cast(AdapterMalloc(sizeof(SystemCapability))); + if (retSystemCap == nullptr) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities retSystemCap is null"); + AdapterFree(resultOfGetSysCap.systemCap.systemCapName); + return nullptr; + } + if (memset_s(retSystemCap, sizeof(SystemCapability), 0, sizeof(SystemCapability)) != EOK) { + AdapterFree(resultOfGetSysCap.systemCap.systemCapName); + AdapterFree(retSystemCap); + return nullptr; + } + int32_t sysCapNameMem = sizeof(SystemCapName) * sysCapNum; + retSystemCap->systemCapName = reinterpret_cast(AdapterMalloc(sysCapNameMem)); + if (retSystemCap->systemCapName == nullptr) { + AdapterFree(resultOfGetSysCap.systemCap.systemCapName); + AdapterFree(retSystemCap); + return nullptr; + } + if (memset_s(retSystemCap->systemCapName, sysCapNameMem, 0, sysCapNameMem) != EOK) { + AdapterFree(resultOfGetSysCap.systemCap.systemCapName); + AdapterFree(retSystemCap->systemCapName); + AdapterFree(retSystemCap); + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities memset error"); + return nullptr; + } + for (int32_t index = 0; index < sysCapNum; index++) { + int32_t copyLen = strlen(resultOfGetSysCap.systemCap.systemCapName[index].name); + errno_t err = strncpy_s(retSystemCap->systemCapName[index].name, MAX_SYSCAP_NAME_LEN, + resultOfGetSysCap.systemCap.systemCapName[index].name, copyLen); + if (err != EOK) { + HILOG_ERROR(HILOG_MODULE_APP, "BundleManager GetSystemAvailableCapabilities strcpy error %{public}d", err); + AdapterFree(resultOfGetSysCap.systemCap.systemCapName); + AdapterFree(retSystemCap->systemCapName); + AdapterFree(retSystemCap); + return nullptr; + } + } + retSystemCap->systemCapNum = sysCapNum; + return retSystemCap; +} + +void FreeSystemAvailableCapabilitiesInfo(SystemCapability *sysCap) +{ + if (sysCap == nullptr) { + return; + } + if (sysCap->systemCapName != nullptr) { + AdapterFree(sysCap->systemCapName); + } + AdapterFree(sysCap); +} +} + + + + + + + + + + + -- Gitee