openharmony/bundlemanager_bundle_framework_lite
1
0
Fork 0
mirror of https://github.com/openharmony/bundlemanager_bundle_framework_lite.git synced 2026-07-19 12:13:04 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix problem

Browse Source 
Signed-off-by: shilei <shilei91@huawei.com>
Change-Id: Ic715851da296e542e157b91da9b3f3cb36a739e9
This commit is contained in:
shilei
2022-09-23 22:26:02 +08:00
parent 5ce94c53c5
commit 074f4a009c
5 changed files with 214 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frameworks/bundle_lite/include/bundle_callback_utils.h
+5
View File
@@ -72,4 +72,9 @@ struct ResultOfGetBundleSize {
uint8_t resultCode;
uint32_t bundleSize;
};
struct BasicInfo {
char *metaDataKey;
int32_t flags;
};
#endif // OHOS_BUNDLE_CALLBACK_UTILS_H
frameworks/bundle_lite/src/bundle_manager.cpp
+111 -1
View File
@@ -92,6 +92,7 @@ static uint8_t DeserializeInnerAbilityInfo(IOwner owner, IpcIo *reply)
static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply)
{
HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo start");
if ((reply == nullptr) || (owner == nullptr)) {
return OHOS_FAILURE;
}
@@ -112,14 +113,17 @@ static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply)
info->bundleInfo = OHOS::ConvertUtils::ConvertStringToBundleInfo(jsonStr, len);
if (info->bundleInfo == nullptr) {
info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
HILOG_ERROR(HILOG_MODULE_APP, "ConvertStringToBundleInfo failed");
return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
}
info->resultCode = resultCode;
HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo finished");
return resultCode;
}
static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply)
{
HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos start");
if ((reply == nullptr) || (owner == nullptr)) {
return OHOS_FAILURE;
}
@@ -145,6 +149,7 @@ static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply)
}
info->resultCode = resultCode;
HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos finished");
return resultCode;
}
@@ -276,6 +281,22 @@ static int Notify(IOwner owner, int code, IpcIo *reply)
case GET_BUNDLE_INFOS_BY_METADATA: {
return DeserializeInnerBundleInfos(owner, reply);
}
case GET_BUNDLE_INFO_LENGTH: {
ResultOfGetBundleInfos *resultOfGetBundleInfos = reinterpret_cast<ResultOfGetBundleInfos *>(owner);
uint8_t errCode;
ReadUint8(reply, &errCode);
if (errCode != ERR_OK) {
HILOG_INFO(HILOG_MODULE_APP, "BundleManager get bundleInfos length failed due to %{public}d", errCode);
resultOfGetBundleInfos->resultCode = errCode;
return errCode;
}
ReadInt32(reply, &(resultOfGetBundleInfos->length));
HILOG_INFO(HILOG_MODULE_APP, "BundleManager bundleInfo len is: %{public}d", resultOfGetBundleInfos->length);
break;
}
case GET_BUNDLE_INFO_BY_INDEX: {
return DeserializeInnerBundleInfo(owner, reply);
}
case GET_BUNDLENAME_FOR_UID: {
return DeserializeInnerBundleName(owner, reply);
}
@@ -557,6 +578,91 @@ static uint8_t ObtainInnerBundleInfos(const int flags, BundleInfo **bundleInfos,
return resultOfGetBundleInfos.resultCode;
}
static uint8_t ObtainBundleInfosOneByOne(BasicInfo basicInfo, int32_t len, uint8_t code, IClientProxy *bmsClient,
BundleInfo **bundleInfos)
{
if (bmsClient == nullptr || bundleInfos == nullptr) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne failed due to nullptr parma");
return ERR_APPEXECFWK_OBJECT_NULL;
}
for (int32_t i = 0; i < len; ++i) {
IpcIo innerIpcIo;
char data[MAX_IO_SIZE];
IpcIoInit(&innerIpcIo, data, MAX_IO_SIZE, 0);
WriteInt32(&innerIpcIo, static_cast<int32_t>(code));
if (code == GET_BUNDLE_INFOS) {
WriteInt32(&innerIpcIo, basicInfo.flags);
}
if (code == GET_BUNDLE_INFOS_BY_METADATA) {
WriteString(&innerIpcIo, basicInfo.metaDataKey);
}
WriteInt32(&innerIpcIo, i);
ResultOfGetBundleInfo resultOfGetBundleInfo;
resultOfGetBundleInfo.bundleInfo = nullptr;
int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_BY_INDEX, &innerIpcIo, &resultOfGetBundleInfo, Notify);
if (ret != OHOS_SUCCESS) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne invoke failed: %{public}d\n", ret);
return ERR_APPEXECFWK_INVOKE_ERROR;
}
OHOS::BundleInfoUtils::CopyBundleInfo(basicInfo.flags, *bundleInfos + i, *(resultOfGetBundleInfo.bundleInfo));
ClearBundleInfo(resultOfGetBundleInfo.bundleInfo);
AdapterFree(resultOfGetBundleInfo.bundleInfo);
}
return OHOS_SUCCESS;
}
static uint8_t ObtainBundleInfos(BasicInfo basicInfo, 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<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to permission denied");
return ERR_APPEXECFWK_PERMISSION_DENIED;
}
auto bmsClient = GetBmsClient();
if (bmsClient == nullptr) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to nullptr bms client");
return ERR_APPEXECFWK_OBJECT_NULL;
}
ResultOfGetBundleInfos resultOfGetBundleInfos;
resultOfGetBundleInfos.length = 0;
resultOfGetBundleInfos.bundleInfo = nullptr;
int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_LENGTH, ipcIo, &resultOfGetBundleInfos, Notify);
if (ret != OHOS_SUCCESS) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos 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 ObtainBundleInfos fail");
*bundleInfos = nullptr;
return resultOfGetBundleInfos.resultCode;
}
*bundleInfos = reinterpret_cast<BundleInfo *>(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;
}
uint8_t res = ObtainBundleInfosOneByOne(basicInfo, resultOfGetBundleInfos.length, code, bmsClient, bundleInfos);
if (res != OHOS_SUCCESS) {
HILOG_WARN(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos invoke failed: %{public}d\n", res);
}
*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)) {
@@ -569,8 +675,12 @@ uint8_t GetBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len)
IpcIo ipcIo;
char data[MAX_IO_SIZE];
IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
WriteInt32(&ipcIo, GET_BUNDLE_INFOS);
WriteInt32(&ipcIo, flags);
return ObtainInnerBundleInfos(flags, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
BasicInfo basicInfo;
basicInfo.flags = flags;
basicInfo.metaDataKey = nullptr;
return ObtainBundleInfos(basicInfo, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
}
uint32_t GetBundleSize(const char *bundleName)
interfaces/inner_api/bundlemgr_lite/bundle_inner_interface.h
+2
View File
@@ -41,6 +41,8 @@ enum BmsCmd {
GET_BUNDLE_INFOS_BY_METADATA,
CHECK_SYS_CAP,
GET_BUNDLE_SIZE,
GET_BUNDLE_INFO_LENGTH,
GET_BUNDLE_INFO_BY_INDEX,
GET_SYS_CAP,
BMS_INNER_BEGIN,
INSTALL = BMS_INNER_BEGIN, // bms install application
services/bundlemgr_lite/include/bundle_ms_feature.h
+3
View File
@@ -62,6 +62,9 @@ private:
static uint8_t HasSystemCapability(const uint8_t funcId, IpcIo *req, IpcIo *reply);
static uint8_t GetSystemAvailableCapabilities(const uint8_t funcId, IpcIo *req, IpcIo *reply);
static uint8_t GetInnerBundleSize(const uint8_t funcId, IpcIo *req, IpcIo *reply);
static uint8_t HandleGetBundleInfosByIndex(const uint8_t funcId, IpcIo *req, IpcIo *reply);
static uint8_t HandleGetBundleInfosLength(const uint8_t funcId, IpcIo *req, IpcIo *reply);
static BundleInfo *GetInnerBundleInfos(IpcIo *req, IpcIo *reply, int32_t *length);
Identity identity_;
static BundleInvokeType BundleMsInvokeFuc[BMS_INNER_BEGIN];
services/bundlemgr_lite/src/bundle_ms_feature.cpp
+93
View File
@@ -57,6 +57,8 @@ BundleInvokeType BundleMsFeature::BundleMsInvokeFuc[BMS_INNER_BEGIN] {
HandleGetBundleInfos,
HasSystemCapability,
GetInnerBundleSize,
HandleGetBundleInfosLength,
HandleGetBundleInfosByIndex,
GetSystemAvailableCapabilities,
};
@@ -562,4 +564,95 @@ uint8_t BundleMsFeature::GetBundleNameForUid(int32_t uid, char **bundleName)
}
return OHOS_SUCCESS;
}
BundleInfo *BundleMsFeature::GetInnerBundleInfos(IpcIo *req, IpcIo *reply, int32_t *length)
{
HILOG_INFO(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos start");
if ((req == nullptr) || (reply == nullptr)) {
return nullptr;
}
BundleInfo *bundleInfos = nullptr;
uint8_t errorCode = 0;
int32_t codeFlag = -1;
ReadInt32(req, &codeFlag);
if (codeFlag == GET_BUNDLE_INFOS) {
int32_t flag;
ReadInt32(req, &flag);
errorCode = GetBundleInfos(flag, &bundleInfos, length);
} else if (codeFlag == QUERY_KEEPALIVE_BUNDLE_INFOS) {
errorCode = QueryKeepAliveBundleInfos(&bundleInfos, length);
} else if (codeFlag == GET_BUNDLE_INFOS_BY_METADATA) {
size_t len = 0;
char *metaDataKey = reinterpret_cast<char *>(ReadString(req, &len));
if (metaDataKey == nullptr) {
return nullptr;
}
errorCode = GetBundleInfosByMetaData(metaDataKey, &bundleInfos, length);
} else {
return nullptr;
}
if (errorCode != OHOS_SUCCESS) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos failed with errorcode: %{public}d\n", errorCode);
BundleInfoUtils::FreeBundleInfos(bundleInfos, *length);
return nullptr;
}
HILOG_DEBUG(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos with length is: %{public}d\n", *length);
return bundleInfos;
}
uint8_t BundleMsFeature::HandleGetBundleInfosLength(const uint8_t funcId, IpcIo *req, IpcIo *reply)
{
HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosLength start");
if ((req == nullptr) || (reply == nullptr)) {
return ERR_APPEXECFWK_OBJECT_NULL;
}
int32_t lengthOfBundleInfo = 0;
BundleInfo *bundleInfos = GetInnerBundleInfos(req, reply, &lengthOfBundleInfo);
if (bundleInfos == nullptr) {
HILOG_ERROR(HILOG_MODULE_APP, "BundleMS bundleInfos is nullptr");
return ERR_APPEXECFWK_OBJECT_NULL;
}
WriteUint8(reply, static_cast<uint8_t>(OHOS_SUCCESS));
WriteInt32(reply, lengthOfBundleInfo);
BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosLength finished");
return OHOS_SUCCESS;
}
uint8_t BundleMsFeature::HandleGetBundleInfosByIndex(const uint8_t funcId, IpcIo *req, IpcIo *reply)
{
HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex start");
if ((req == nullptr) || (reply == nullptr)) {
return ERR_APPEXECFWK_OBJECT_NULL;
}
int32_t lengthOfBundleInfo = 0;
BundleInfo *bundleInfos = GetInnerBundleInfos(req, reply, &lengthOfBundleInfo);;
int32_t index = 0;
ReadInt32(req, &index);
HILOG_INFO(HILOG_MODULE_APP, "BundleMS index is : %{public}d\n", index);
char *str = ConvertUtils::ConvertBundleInfoToString(bundleInfos + index);
if (str == nullptr) {
BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
HILOG_ERROR(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex strs is nullptr");
return ERR_APPEXECFWK_SERIALIZATION_FAILED;
}
HILOG_DEBUG(HILOG_MODULE_APP, "BundleMS length of str is: %{public}d\n", static_cast<int32_t>(strlen(str)));
#ifdef __LINUX__
if (strlen(str) > MAX_IPC_STRING_LENGTH) {
BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
HILOG_ERROR(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex is too larger to be transformed by ipc");
cJSON_free(str);
return ERR_APPEXECFWK_SERIALIZATION_FAILED;
}
#endif
WriteUint8(reply, static_cast<uint8_t>(OHOS_SUCCESS));
WriteString(reply, str);
HILOG_INFO(HILOG_MODULE_APP, "BundleMS bundleInfo length is %{public}d of index %{public}d",
static_cast<int32_t>(strlen(str)), index);
BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
cJSON_free(str);
HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex finished");
return OHOS_SUCCESS;
}
} // namespace OHOS