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 
16 #include "bundle_parser.h"
17 
18 #include "appexecfwk_errors.h"
19 #include "bundle_extractor.h"
20 #include "bundle_info_creator.h"
21 #include "bundle_util.h"
22 #include "bundle_log.h"
23 #include "samgr_lite.h"
24 #include "securec.h"
25 #include "utils.h"
26 
27 #include <algorithm>
28 #include <map>
29 #include <regex>
30 #include <vector>
31 
32 namespace OHOS {
33 const std::map<std::string, AbilityType> ABILITY_TYPE_MAP = {{"page", PAGE}, {"service", SERVICE}};
34 const std::map<std::string, LaunchMode> LAUNCH_MODE_MAP = {{"singleton", SINGLETON}, {"standard", STANDARD}};
35 char g_sysCaps[MAX_SYSCAP_NUM][MAX_SYSCAP_NAME_LEN];
36 
ParseValue(const cJSON * object,const char * key,int32_t defaultValue)37 int32_t BundleParser::ParseValue(const cJSON *object, const char *key, int32_t defaultValue)
38 {
39     if (object == nullptr) {
40         return defaultValue;
41     }
42 
43     cJSON *son = nullptr;
44     son = cJSON_GetObjectItem(object, key);
45     if (!cJSON_IsNumber(son)) {
46         return defaultValue;
47     }
48     return son->valueint;
49 }
50 
ParseValue(const cJSON * object,const char * key)51 char *BundleParser::ParseValue(const cJSON *object, const char *key)
52 {
53     if (object == nullptr) {
54         return nullptr;
55     }
56 
57     cJSON *son = nullptr;
58     son = cJSON_GetObjectItem(object, key);
59     if (!cJSON_IsString(son)) {
60         return nullptr;
61     }
62     return son->valuestring;
63 }
64 
ParseValue(const cJSON * object,const char * key,cJSON * defaultValue)65 cJSON *BundleParser::ParseValue(const cJSON *object, const char *key, cJSON *defaultValue)
66 {
67     if (object == nullptr) {
68         return defaultValue;
69     }
70 
71     cJSON *son = nullptr;
72     son = cJSON_GetObjectItem(object, key);
73     if (cJSON_IsArray(son) || cJSON_IsObject(son)) {
74         return son;
75     }
76     return defaultValue;
77 }
78 
CheckBundleNameIsValid(const char * bundleName)79 bool BundleParser::CheckBundleNameIsValid(const char *bundleName)
80 {
81     if (bundleName == nullptr) {
82         return false;
83     }
84     std::string pattern { "([a-zA-Z0-9_]+\\.)+[a-zA-Z0-9_]+" };
85     std::regex re(pattern);
86     try {
87         if (!std::regex_match(bundleName, re)) {
88             return false;
89         }
90     } catch (std::regex_error &message) {
91         HILOG_ERROR(HILOG_MODULE_APP, "regex fail! message is %s", message.what());
92         return false;
93     } catch (std::out_of_range &message) {
94         HILOG_ERROR(HILOG_MODULE_APP, "regex out_of_range fail! message is %s", message.what());
95         return false;
96     } catch (std::runtime_error &message) {
97         HILOG_ERROR(HILOG_MODULE_APP, "regex runtime_error fail! message is %s", message.what());
98         return false;
99     }
100     return true;
101 }
102 
ParsePermissions(const cJSON * object,Permissions & permissions)103 uint8_t BundleParser::ParsePermissions(const cJSON *object, Permissions &permissions)
104 {
105     if (object == nullptr) {
106         return ERR_OK;
107     }
108 
109     if (object->type != cJSON_Array) {
110         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PERMISSIONS_ERROR;
111     }
112     permissions.permNum = cJSON_GetArraySize(object);
113     if (permissions.permNum == 0) {
114         return ERR_OK;
115     }
116 
117     permissions.permissionTrans = reinterpret_cast<PermissionTrans *>(AdapterMalloc(sizeof(PermissionTrans) *
118     permissions.permNum));
119 
120     if (permissions.permissionTrans == nullptr) {
121         HILOG_ERROR(HILOG_MODULE_APP, "malloc permissionTrans fail!");
122         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PERMISSIONS_ERROR;
123     }
124 
125     PermissionTrans *perms = permissions.permissionTrans;
126     cJSON *reqPermission = nullptr;
127     cJSON_ArrayForEach(reqPermission, object) {
128         if (!SetReqPermission(reqPermission, perms)) {
129             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PERMISSIONS_ERROR;
130         }
131         perms++;
132     }
133     return ERR_OK;
134 }
135 
SetReqPermission(const cJSON * object,PermissionTrans * permission)136 bool BundleParser::SetReqPermission(const cJSON *object, PermissionTrans *permission)
137 {
138     if ((object == nullptr) || (permission == nullptr)) {
139         return false;
140     }
141 
142     char *name = ParseValue(object, PROFILE_KEY_REQPERMISSIONS_NAME);
143     char *desc = ParseValue(object, PROFILE_KEY_REQPERMISSIONS_REASON);
144     if (name == nullptr || desc == nullptr) {
145         HILOG_ERROR(HILOG_MODULE_APP, "the value of name or desc is invalid!");
146         return false;
147     }
148 
149     if (IsPermissionValid(name) != 0) {
150         HILOG_ERROR(HILOG_MODULE_APP, "reqpermission is invalid!");
151         return false;
152     }
153 
154     if (strncpy_s(permission->name, sizeof(permission->name), name, strlen(name)) != EOK ||
155         strncpy_s(permission->desc, sizeof(permission->desc), desc, strlen(desc)) != EOK) {
156         HILOG_ERROR(HILOG_MODULE_APP, "SetReqPermission  strncpy name or desc fail!");
157         return false;
158     }
159 
160     cJSON *usedSceneObject = ParseValue(object, PROFILE_KEY_REQPERMISSIONS_USEDSCENE, nullptr);
161     char *when = ParseValue(usedSceneObject, PROFILE_KEY_REQPERMISSIONS_WHEN);
162     if (when == nullptr) {
163         HILOG_ERROR(HILOG_MODULE_APP, "the value of when is invalid!");
164         return false;
165     }
166     if (strcmp(when, GRANTTIME_INUSE) == 0) {
167         permission->when = INUSE;
168     } else if (strcmp(when, GRANTTIME_ALWAYS) == 0) {
169         permission->when = ALWAYS;
170     } else {
171         HILOG_ERROR(HILOG_MODULE_APP, "the type of when is invalid!");
172         return false;
173     }
174     return true;
175 }
176 
ParseBundleParam(const char * path,char ** bundleName,int32_t & versionCode)177 int8_t BundleParser::ParseBundleParam(const char *path, char **bundleName, int32_t &versionCode)
178 {
179     if (!BundleUtil::CheckRealPath(path)) {
180         return ERR_APPEXECFWK_INSTALL_FAILED_FILE_PATH_INVALID;
181     }
182 
183     if (!BundleUtil::EndWith(path, INSTALL_FILE_SUFFIX)) {
184         return ERR_APPEXECFWK_INSTALL_FAILED_INVALID_FILE_NAME;
185     }
186 
187     if (!BundleUtil::IsFile(path)) {
188         return ERR_APPEXECFWK_INSTALL_FAILED_FILE_NOT_EXISTS;
189     }
190     std::ostringstream profileStream;
191     if (BundleExtractor::ExtractHapProfile(path, profileStream) != ERR_OK) {
192         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
193     }
194     cJSON *root = cJSON_Parse(profileStream.str().c_str());
195     if (root == nullptr) {
196         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
197     }
198 
199     cJSON *appObject = cJSON_GetObjectItem(root, PROFILE_KEY_APP);
200     if (appObject == nullptr) {
201         cJSON_Delete(root);
202         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
203     }
204 
205     *bundleName = Utils::Strdup(ParseValue(appObject, PROFILE_KEY_BUNDLENAME));
206     if (*bundleName == nullptr) {
207         cJSON_Delete(root);
208         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_BUNDLENAME_ERROR;
209     }
210 
211     cJSON *object = ParseValue(appObject, PROFILE_KEY_VERSION, nullptr);
212     if (object == nullptr) {
213         cJSON_Delete(root);
214         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_VERSIONCODE_ERROR;
215     }
216 
217     versionCode = ParseValue(object, PROFILE_KEY_VERSION_CODE, -1);
218     if (versionCode == -1) {
219         cJSON_Delete(root);
220         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_VERSIONCODE_ERROR;
221     }
222     cJSON_Delete(root);
223     return 0;
224 }
225 
ParseHapProfile(const char * path)226 BundleInfo *BundleParser::ParseHapProfile(const char *path)
227 {
228     if (!BundleUtil::CheckRealPath(path)) {
229         return nullptr;
230     }
231 
232     std::string profilePath = path + std::string(PATH_SEPARATOR) + PROFILE_NAME;
233     cJSON *root = BundleUtil::GetJsonStream(profilePath.c_str());
234     if (root == nullptr) {
235         return nullptr;
236     }
237 
238     cJSON *appObject = cJSON_GetObjectItem(root, PROFILE_KEY_APP);
239     cJSON *configObject = cJSON_GetObjectItem(root, PROFILE_KEY_DEVICECONFIG);
240     cJSON *moduleObject = cJSON_GetObjectItem(root, PROFILE_KEY_MODULE);
241     if (appObject == nullptr || moduleObject == nullptr) {
242         cJSON_Delete(root);
243         return nullptr;
244     }
245 
246     BundleProfile bundleProfile;
247     if (memset_s(&bundleProfile, sizeof(BundleProfile), 0, sizeof(BundleProfile)) != EOK) {
248         cJSON_Delete(root);
249         return nullptr;
250     }
251 
252     BundleRes bundleRes = {
253         .bundleName = nullptr, .moduleDescriptionId = 0, .abilityRes = nullptr, .totalNumOfAbilityRes = 0
254     };
255     if (ParseJsonInfo(appObject, configObject, moduleObject, bundleProfile, bundleRes) != ERR_OK) {
256         FREE_BUNDLE_PROFILE(bundleProfile);
257         AdapterFree(bundleRes.abilityRes);
258         cJSON_Delete(root);
259         return nullptr;
260     }
261     std::string installDirPath;
262     std::string dataDirPath;
263     if (BundleUtil::StartWith(path, INSTALL_PATH)) {
264         installDirPath = INSTALL_PATH;
265         dataDirPath = DATA_PATH;
266     } else {
267         installDirPath = EXTEANAL_INSTALL_PATH;
268         dataDirPath = EXTEANAL_DATA_PATH;
269     }
270     BundleInfo *bundleInfo = BundleInfoCreator::CreateBundleInfo(bundleProfile, installDirPath, dataDirPath,
271         bundleRes);
272     FREE_BUNDLE_PROFILE(bundleProfile);
273     AdapterFree(bundleRes.abilityRes);
274     cJSON_Delete(root);
275     return bundleInfo;
276 }
277 
ParseHapProfile(const std::string & path,Permissions & permissions,BundleRes & bundleRes,BundleInfo ** bundleInfo)278 uint8_t BundleParser::ParseHapProfile(const std::string &path, Permissions &permissions, BundleRes &bundleRes,
279     BundleInfo **bundleInfo)
280 {
281     std::ostringstream profileStream;
282     uint8_t errorCode = BundleExtractor::ExtractHapProfile(path, profileStream);
283     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
284 
285     cJSON *root = cJSON_Parse(profileStream.str().c_str());
286     CHECK_IS_TRUE((root != nullptr), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR);
287 
288     cJSON *appObject = cJSON_GetObjectItem(root, PROFILE_KEY_APP);
289     cJSON *configObject = cJSON_GetObjectItem(root, PROFILE_KEY_DEVICECONFIG);
290     cJSON *moduleObject = cJSON_GetObjectItem(root, PROFILE_KEY_MODULE);
291     if (appObject == nullptr || moduleObject == nullptr) {
292         cJSON_Delete(root);
293         HILOG_ERROR(HILOG_MODULE_APP, "json file format is invalid!");
294         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
295     }
296 
297     BundleProfile bundleProfile;
298     if (memset_s(&bundleProfile, sizeof(BundleProfile), 0, sizeof(BundleProfile)) != EOK) {
299         cJSON_Delete(root);
300         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
301     }
302 
303     errorCode = ParseJsonInfo(appObject, configObject, moduleObject, bundleProfile, bundleRes);
304     CHECK_PARSE_RESULT(errorCode, root, bundleProfile);
305 
306     cJSON *object = ParseValue(moduleObject, PROFILE_KEY_REQPERMISSIONS, nullptr);
307     errorCode = ParsePermissions(object, permissions);
308     CHECK_PARSE_RESULT(errorCode, root, bundleProfile);
309 
310     errorCode = BundleInfoCreator::SaveBundleInfo(bundleProfile, bundleInfo);
311     CHECK_PARSE_RESULT(errorCode, root, bundleProfile);
312 
313     FREE_BUNDLE_PROFILE(bundleProfile);
314     cJSON_Delete(root);
315     return ERR_OK;
316 }
317 
ParseJsonInfo(const cJSON * appObject,const cJSON * configObject,const cJSON * moduleObject,BundleProfile & bundleProfile,BundleRes & bundleRes)318 uint8_t BundleParser::ParseJsonInfo(const cJSON *appObject, const cJSON *configObject, const cJSON *moduleObject,
319     BundleProfile &bundleProfile, BundleRes &bundleRes)
320 {
321     // parse app config
322     bundleProfile.bundleName = ParseValue(appObject, PROFILE_KEY_BUNDLENAME);
323     CHECK_NULL(bundleProfile.bundleName, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_BUNDLENAME_ERROR);
324     CHECK_IS_TRUE((strlen(bundleProfile.bundleName) >= MIN_BUNDLE_NAME_LEN) &&
325         (strlen(bundleProfile.bundleName) <= MAX_BUNDLE_NAME_LEN),
326         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_INVALID_BUNDLENAME_LENGTH);
327     // check bundleName
328     CHECK_IS_TRUE(CheckBundleNameIsValid(bundleProfile.bundleName),
329         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_INVALID_BUNDLENAME);
330 
331     if (cJSON_HasObjectItem(appObject, PROFILE_KEY_VENDOR)) {
332         bundleProfile.vendor = ParseValue(appObject, PROFILE_KEY_VENDOR);
333         CHECK_NULL(bundleProfile.vendor, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_VENDOR_ERROR);
334         CHECK_LENGTH(strlen(bundleProfile.vendor), MAX_VENDOR_LEN,
335             ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_VENDOR_LENGTH_ERROR);
336     }
337     // check version and versionName
338     cJSON *object = ParseValue(appObject, PROFILE_KEY_VERSION, nullptr);
339     bundleProfile.profileVersion.versionName = ParseValue(object, PROFILE_KEY_VERSION_NAME);
340     CHECK_NULL(bundleProfile.profileVersion.versionName, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_VERSIONNAME_ERROR);
341     CHECK_LENGTH(strlen(bundleProfile.profileVersion.versionName), MAX_VERSION_NAME_LEN,
342         ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_VERSIONNAME_LENGTH_ERROR);
343 
344     bundleProfile.profileVersion.versionCode = ParseValue(object, PROFILE_KEY_VERSION_CODE, -1);
345     CHECK_IS_TRUE((bundleProfile.profileVersion.versionCode >= 0),
346         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_VERSIONCODE_ERROR);
347     // check apiVersion
348     object = ParseValue(appObject, PROFILE_KEY_APIVERSION, nullptr);
349     CHECK_NULL(object, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_API_VERSION_ERROR);
350     bundleProfile.profileApiVersion.minApiVersion = ParseValue(object, PROFILE_KEY_APIVERSION_COMPATIBLE, -1);
351     CHECK_IS_TRUE((bundleProfile.profileApiVersion.minApiVersion >= 0),
352         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_API_VERSION_ERROR);
353     if (cJSON_HasObjectItem(object, PROFILE_KEY_APIVERSION_TARGET)) {
354         bundleProfile.profileApiVersion.maxApiVersion = ParseValue(object, PROFILE_KEY_APIVERSION_TARGET, -1);
355         CHECK_IS_TRUE((bundleProfile.profileApiVersion.maxApiVersion >= bundleProfile.profileApiVersion.minApiVersion),
356             ERR_APPEXECFWK_INSTALL_FAILED_PARSE_API_VERSION_ERROR);
357     }
358     // parse deviceConfig
359     uint8_t errorCode = ParseDeviceConfig(configObject, bundleProfile);
360     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
361     // parse moduleInfo
362     return ParseModuleInfo(moduleObject, bundleProfile, bundleRes);
363 }
364 
ParseDeviceConfig(const cJSON * configObject,BundleProfile & bundleProfile)365 uint8_t BundleParser::ParseDeviceConfig(const cJSON *configObject, BundleProfile &bundleProfile)
366 {
367     if (configObject == nullptr || configObject->type == cJSON_NULL) {
368         bundleProfile.isKeepAlive = false;
369         return ERR_OK;
370     }
371     CHECK_IS_TRUE(cJSON_IsObject(configObject), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICE_CONFIG_ERROR);
372 
373     cJSON *defaultObject = nullptr;
374     cJSON *smartVisionObject = nullptr;
375     if (cJSON_HasObjectItem(configObject, PROFILE_KEY_DEVICECONFIG_DEFAULT)) {
376         defaultObject = ParseValue(configObject, PROFILE_KEY_DEVICECONFIG_DEFAULT, nullptr);
377         CHECK_IS_TRUE(cJSON_IsObject(defaultObject), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICE_CONFIG_ERROR);
378     }
379     if (cJSON_HasObjectItem(configObject, DEFAULT_DEVICE_TYPE)) {
380         smartVisionObject = ParseValue(configObject, DEFAULT_DEVICE_TYPE, nullptr);
381         CHECK_IS_TRUE(cJSON_IsObject(smartVisionObject), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICE_CONFIG_ERROR);
382     }
383 
384     cJSON *object = nullptr;
385     if (cJSON_HasObjectItem(defaultObject, PROFILE_KEY_KEEPALIVE)) {
386         object = cJSON_GetObjectItem(defaultObject, PROFILE_KEY_KEEPALIVE);
387     }
388 
389     if (cJSON_HasObjectItem(smartVisionObject, PROFILE_KEY_KEEPALIVE)) {
390         object = cJSON_GetObjectItem(smartVisionObject, PROFILE_KEY_KEEPALIVE);
391     }
392 
393     if (object != nullptr && !cJSON_IsBool(object)) {
394         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_KEEPALIVE_ERROR;
395     }
396     bundleProfile.isKeepAlive = (object == nullptr) ? false : cJSON_IsTrue(object);
397     return ERR_OK;
398 }
399 
ParseModuleInfo(const cJSON * moduleObject,BundleProfile & bundleProfile,BundleRes & bundleRes)400 uint8_t BundleParser::ParseModuleInfo(const cJSON *moduleObject, BundleProfile &bundleProfile, BundleRes &bundleRes)
401 {
402     // parse module name
403     if (cJSON_HasObjectItem(moduleObject, PROFILE_KEY_MODULE_NAME)) {
404         bundleProfile.moduleInfo.name = ParseValue(moduleObject, PROFILE_KEY_MODULE_NAME);
405         CHECK_NULL(bundleProfile.moduleInfo.name, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_MODULENAME_ERROR);
406         CHECK_LENGTH(strlen(bundleProfile.moduleInfo.name), MAX_NAME_LEN,
407             ERR_APPEXECFWK_INSTALL_FAILED_PARSE_MODULENAME_ERROR);
408     }
409     // parse module description
410     uint8_t errorCode = ParseModuleDesc(moduleObject, bundleProfile, bundleRes);
411     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
412     // parse deviceType
413     errorCode = ParseDeviceType(moduleObject, bundleProfile);
414     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
415     // parse distro
416     cJSON *object = ParseValue(moduleObject, PROFILE_KEY_MODULE_DISTRO, nullptr);
417     CHECK_NULL(object, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DISTRO_ERROR);
418     cJSON *deliveryObject = cJSON_GetObjectItem(object, PROFILE_KEY_MODULE_DISTRO_DELIVERY);
419     CHECK_IS_TRUE(cJSON_IsBool(deliveryObject), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DISTRO_DELIVERY_ERROR);
420     bundleProfile.moduleInfo.isDeliveryInstall = cJSON_IsTrue(deliveryObject);
421 
422     bundleProfile.moduleInfo.moduleName = ParseValue(object, PROFILE_KEY_MODULE_DISTRO_MODULENAME);
423     CHECK_NULL(bundleProfile.moduleInfo.moduleName, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DISTRO_MODULENAME_ERROR);
424     CHECK_LENGTH(strlen(bundleProfile.moduleInfo.moduleName), MAX_MODULENAME_LEN,
425         ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_MODULENAME_LENGTH_ERROR);
426     CHECK_IS_TRUE((strstr(bundleProfile.moduleInfo.moduleName, "../") == nullptr),
427         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_INVALID_MODULENAME);
428 
429     bundleProfile.moduleInfo.moduleType = ParseValue(object, PROFILE_KEY_MODULE_DISTRO_MODULETYPE);
430     CHECK_NULL(bundleProfile.moduleInfo.moduleType, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DISTRO_MODULETYPE_ERROR);
431     bool result = ((strcmp(bundleProfile.moduleInfo.moduleType, MODULE_ENTRY) == 0) ||
432         (strcmp(bundleProfile.moduleInfo.moduleType, MODULE_FEATURE) == 0));
433     CHECK_IS_TRUE(result, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DISTRO_MODULETYPE_ERROR);
434     // parse metaData
435     errorCode = ParseModuleMetaData(moduleObject, bundleProfile);
436     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
437     // parse js config, if object is null or [], it means nativeApp, otherwise is js app
438     object = ParseValue(moduleObject, PROFILE_KEY_JS, nullptr);
439     bundleProfile.isNativeApp = ((object == nullptr) || (cJSON_IsArray(object) && cJSON_GetArraySize(object) == 0));
440     // parse abilityInfo
441     return ParseAbilityInfos(moduleObject, bundleProfile, bundleRes);
442 }
443 
ParseModuleDesc(const cJSON * moduleObject,BundleProfile & bundleProfile,BundleRes & bundleRes)444 uint8_t BundleParser::ParseModuleDesc(const cJSON *moduleObject, BundleProfile &bundleProfile, BundleRes &bundleRes)
445 {
446     if (!cJSON_HasObjectItem(moduleObject, PROFILE_KEY_MODULE_DESCRIPTION)) {
447         return ERR_OK;
448     }
449     bundleProfile.moduleInfo.description = ParseValue(moduleObject, PROFILE_KEY_MODULE_DESCRIPTION);
450     CHECK_NULL(bundleProfile.moduleInfo.description, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_MODULE_DESCRIPTION_ERROR);
451     if (BundleUtil::StartWith(bundleProfile.moduleInfo.description, DEFAULT_DESC_SETTING)) {
452         int32_t descId = ParseValue(moduleObject, MODULE_DES_ID, -1);
453         if (descId < 0) {
454             HILOG_ERROR(HILOG_MODULE_APP, "get module descriptionId fail!");
455             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_MODULE_DESCRIPTION_ERROR;
456         }
457         bundleRes.moduleDescriptionId = static_cast<uint32_t>(descId);
458     } else {
459         CHECK_LENGTH(strlen(bundleProfile.moduleInfo.description), MAX_DECRIPTION_LEN,
460             ERR_APPEXECFWK_INSTALL_FAILED_PARSE_MODULE_DESCRIPTION_ERROR);
461     }
462     return ERR_OK;
463 }
464 
ParseDeviceType(const cJSON * moduleObject,BundleProfile & bundleProfile)465 uint8_t BundleParser::ParseDeviceType(const cJSON *moduleObject, BundleProfile &bundleProfile)
466 {
467     cJSON *object = ParseValue(moduleObject, PROFILE_KEY_MODULE_DEVICETYPE, nullptr);
468     CHECK_IS_TRUE((cJSON_IsArray(object) && (cJSON_GetArraySize(object) <= DEVICE_TYPE_SIZE)),
469         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICETYPE_ERROR);
470 
471     bool isMatched = false;
472     cJSON *item = nullptr;
473     int32_t i = 0;
474     cJSON_ArrayForEach(item, object) {
475         CHECK_IS_TRUE((item->type == cJSON_String), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICETYPE_ERROR);
476         if (item->valuestring != nullptr && strcmp(item->valuestring, DEFAULT_DEVICE_TYPE) == 0) {
477             isMatched = true;
478         }
479         bundleProfile.moduleInfo.deviceType[i++] = item->valuestring;
480     }
481     CHECK_IS_TRUE(isMatched, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICETYPE_ERROR);
482     return ERR_OK;
483 }
484 
ParseModuleMetaData(const cJSON * moduleObject,BundleProfile & bundleProfile)485 uint8_t BundleParser::ParseModuleMetaData(const cJSON *moduleObject, BundleProfile &bundleProfile)
486 {
487     cJSON *object = ParseValue(moduleObject, PROFILE_KEY_MODULE_METADATA, nullptr);
488     // if no metadata, return ERR_OK
489     if (object == nullptr || object->type == cJSON_NULL) {
490         return ERR_OK;
491     }
492 
493     object = cJSON_GetObjectItem(object, PROFILE_KEY_MODULE_METADATA_CUSTOMIZEDATA);
494     if (object == nullptr || object->type == cJSON_NULL) {
495         return ERR_OK;
496     }
497     CHECK_IS_TRUE((cJSON_IsArray(object) && (cJSON_GetArraySize(object) <= METADATA_SIZE)),
498         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_METADATA_ERROR);
499 
500     cJSON *objectItem = nullptr;
501     int32_t i = 0;
502     cJSON_ArrayForEach(objectItem, object) {
503         bundleProfile.moduleInfo.metaData[i] = reinterpret_cast<MetaData *>
504             (AdapterMalloc(sizeof(MetaData)));
505         if (bundleProfile.moduleInfo.metaData[i] == nullptr ||
506             memset_s(bundleProfile.moduleInfo.metaData[i], sizeof(MetaData), 0, sizeof(MetaData)) != EOK) {
507             HILOG_ERROR(HILOG_MODULE_APP, "malloc metaData fail!");
508             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_METADATA_ERROR;
509         }
510         if (cJSON_HasObjectItem(objectItem, PROFILE_KEY_MODULE_METADATA_NAME)) {
511             bundleProfile.moduleInfo.metaData[i]->name = ParseValue(objectItem, PROFILE_KEY_MODULE_METADATA_NAME);
512             CHECK_NULL(bundleProfile.moduleInfo.metaData[i]->name,
513                 ERR_APPEXECFWK_INSTALL_FAILED_PARSE_METADATA_ERROR);
514             CHECK_LENGTH(strlen(bundleProfile.moduleInfo.metaData[i]->name), MAX_METADATA_NAME,
515                 ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_METADATA_NAME_LENGTH_ERROR);
516         }
517 
518         if (cJSON_HasObjectItem(objectItem, PROFILE_KEY_MODULE_METADATA_VALUE)) {
519             bundleProfile.moduleInfo.metaData[i]->value = ParseValue(objectItem, PROFILE_KEY_MODULE_METADATA_VALUE);
520             CHECK_NULL(bundleProfile.moduleInfo.metaData[i]->value,
521                 ERR_APPEXECFWK_INSTALL_FAILED_PARSE_METADATA_ERROR);
522             CHECK_LENGTH(strlen(bundleProfile.moduleInfo.metaData[i]->value), MAX_METADATA_VALUE,
523                 ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_METADATA_VALUE_LENGTH_ERROR);
524         }
525 
526         if (cJSON_HasObjectItem(objectItem, PROFILE_KEY_MODULE_METADATA_EXTRA)) {
527             bundleProfile.moduleInfo.metaData[i]->extra = ParseValue(objectItem, PROFILE_KEY_MODULE_METADATA_EXTRA);
528             CHECK_NULL(bundleProfile.moduleInfo.metaData[i]->extra,
529                 ERR_APPEXECFWK_INSTALL_FAILED_PARSE_METADATA_ERROR);
530         }
531         i++;
532     }
533     return ERR_OK;
534 }
535 
ParseAbilityInfos(const cJSON * moduleObject,BundleProfile & bundleProfile,BundleRes & bundleRes)536 uint8_t BundleParser::ParseAbilityInfos(const cJSON *moduleObject, BundleProfile &bundleProfile, BundleRes &bundleRes)
537 {
538     cJSON *abilityObjects = ParseValue(moduleObject, PROFILE_KEY_MODULE_ABILITIES, nullptr);
539     CHECK_IS_TRUE(cJSON_IsArray(abilityObjects), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITIES_ERROR);
540     if (cJSON_GetArraySize(abilityObjects) == 0) {
541         bundleProfile.numOfAbility = 0;
542         return ERR_OK;
543     }
544     // label can be null
545     cJSON *firstAbilityJson = cJSON_GetArrayItem(abilityObjects, 0);
546     if (cJSON_HasObjectItem(firstAbilityJson, PROFILE_KEY_MODULE_ABILITY_LABEL)) {
547         bundleProfile.label = ParseValue(firstAbilityJson, PROFILE_KEY_MODULE_ABILITY_LABEL);
548         CHECK_NULL(bundleProfile.label, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_LABEL_ERROR);
549         CHECK_LENGTH(strlen(bundleProfile.label), MAX_LABLE_LEN,
550             ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_LABEL_LENGTH_ERROR);
551     }
552     // iconPath can be null
553     if (cJSON_HasObjectItem(firstAbilityJson, PROFILE_KEY_MODULE_ABILITY_ICON)) {
554         bundleProfile.iconPath = ParseValue(firstAbilityJson, PROFILE_KEY_MODULE_ABILITY_ICON);
555         CHECK_NULL(bundleProfile.iconPath, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_ICONPATH_ERROR);
556     }
557     // parse every ability
558     return ParseAllAbilityInfo(abilityObjects, bundleProfile, bundleRes);
559 }
560 
CheckAbilityCapIsValid(AbilityInfo & abilityInfo,char sysCaps[][MAX_SYSCAP_NAME_LEN],int sysNum)561 bool BundleParser::CheckAbilityCapIsValid(AbilityInfo &abilityInfo, char sysCaps[][MAX_SYSCAP_NAME_LEN], int sysNum)
562 {
563     for (int32_t capIndex = 0; capIndex < abilityInfo.deviceCap.systemCapNum; capIndex++) {
564         SystemCapName &deviceCapName = abilityInfo.deviceCap.systemCapName[capIndex];
565         bool findSysCap = false;
566         for (int32_t sysIndex = 0; sysIndex < sysNum; sysIndex++) {
567             if (strcmp(deviceCapName.name, sysCaps[sysIndex]) == 0) {
568                 findSysCap = true;
569                 break;
570             }
571         }
572         if (!findSysCap) {
573             HILOG_ERROR(HILOG_MODULE_APP, "CheckDeviceCapIsValid fail not find syscap %{public}s",
574                 deviceCapName.name);
575             return false;
576         }
577     }
578     return true;
579 }
580 
CheckDeviceCapIsValid(BundleProfile & bundleInfo)581 uint8_t BundleParser::CheckDeviceCapIsValid(BundleProfile &bundleInfo)
582 {
583     if (bundleInfo.abilityInfos == nullptr || bundleInfo.numOfAbility == 0) {
584         HILOG_ERROR(HILOG_MODULE_APP, "CheckDeviceCapIsValid fail beacuse abilityInfos is nullptr!");
585         return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
586     }
587     int32_t sysNum = 0;
588     int32_t res = SAMGR_GetInstance()->GetSystemAvailableCapabilities(g_sysCaps, &sysNum);
589     if (res != ERR_OK) {
590         HILOG_ERROR(HILOG_MODULE_APP, "CheckDeviceCapIsValid fail beacuse system capabilities is nullptr!");
591         return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
592     }
593     for (int32_t abilityIndex = 0; abilityIndex < bundleInfo.numOfAbility; abilityIndex++) {
594         AbilityInfo &abilityInfo = bundleInfo.abilityInfos[abilityIndex];
595         if (abilityInfo.deviceCap.systemCapNum == 0 || abilityInfo.deviceCap.systemCapName == nullptr) {
596             continue;
597         }
598         if (!CheckAbilityCapIsValid(abilityInfo, g_sysCaps, sysNum)) {
599             HILOG_ERROR(HILOG_MODULE_APP, "CheckDeviceCapIsValid fail beacuse system capability is invalid");
600             return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
601         }
602     }
603     return ERR_OK;
604 }
605 
ParseAllAbilityInfo(const cJSON * abilityObjects,BundleProfile & bundleProfile,BundleRes & bundleRes)606 uint8_t BundleParser::ParseAllAbilityInfo(const cJSON *abilityObjects, BundleProfile &bundleProfile,
607     BundleRes &bundleRes)
608 {
609     bundleProfile.numOfAbility = cJSON_GetArraySize(abilityObjects);
610     bundleRes.totalNumOfAbilityRes = bundleProfile.numOfAbility;
611     if (bundleProfile.numOfAbility == 0) {
612         return ERR_OK;
613     }
614 
615     bundleRes.abilityRes = reinterpret_cast<AbilityRes *>(AdapterMalloc(sizeof(AbilityRes) *
616         bundleProfile.numOfAbility));
617     if (bundleRes.abilityRes == nullptr) {
618         HILOG_ERROR(HILOG_MODULE_APP, "abilityRes malloc fail!");
619         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITIES_ERROR;
620     }
621     int32_t ret = memset_s(bundleRes.abilityRes, sizeof(AbilityRes) * bundleProfile.numOfAbility, 0,
622         sizeof(AbilityRes) * bundleProfile.numOfAbility);
623     if (ret != EOK) {
624         HILOG_ERROR(HILOG_MODULE_APP, "abilityRes memset fail!");
625         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
626     }
627 
628     bundleProfile.abilityInfos = reinterpret_cast<AbilityInfo *>(AdapterMalloc(sizeof(AbilityInfo) *
629         bundleProfile.numOfAbility));
630     if (bundleProfile.abilityInfos == nullptr) {
631         HILOG_ERROR(HILOG_MODULE_APP, "abilityInfos malloc fail!");
632         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITIES_ERROR;
633     }
634 
635     ret = memset_s(bundleProfile.abilityInfos, sizeof(AbilityInfo) * bundleProfile.numOfAbility, 0,
636         sizeof(AbilityInfo) * bundleProfile.numOfAbility);
637     if (ret != EOK) {
638         HILOG_ERROR(HILOG_MODULE_APP, "abilityInfos memset fail!");
639         return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
640     }
641 
642     cJSON *object = nullptr;
643     int32_t i = 0;
644     cJSON_ArrayForEach(object, abilityObjects) {
645         bundleProfile.abilityInfos[i].moduleName = bundleProfile.moduleInfo.moduleName;
646         bundleProfile.abilityInfos[i].bundleName = bundleProfile.bundleName;
647         uint8_t errorCode = ParsePerAbilityInfo(object, bundleProfile, bundleRes.abilityRes[i], i);
648         CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
649         i++;
650     }
651     if (CheckDeviceCapIsValid(bundleProfile) != ERR_OK) {
652         HILOG_ERROR(HILOG_MODULE_APP, "CheckDeviceCapIsValid fail!");
653         return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICECAP_ERROR;
654     }
655     return ERR_OK;
656 }
657 
ParsePerAbilityInfo(const cJSON * abilityObjectItem,BundleProfile & bundleProfile,AbilityRes & abilityRes,uint32_t index)658 uint8_t BundleParser::ParsePerAbilityInfo(const cJSON *abilityObjectItem, BundleProfile &bundleProfile,
659     AbilityRes &abilityRes, uint32_t index)
660 {
661     bundleProfile.abilityInfos[index].name = ParseValue(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_NAME);
662     CHECK_NULL(bundleProfile.abilityInfos[index].name, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_NAME_ERROR);
663     CHECK_LENGTH(strlen(bundleProfile.abilityInfos[index].name), MAX_ABILITY_NAME_LEN,
664         ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_ABILITYNAME_LENGTH_ERROR);
665 
666     uint8_t errorCode = ParseAbilityDesc(abilityObjectItem, bundleProfile, abilityRes, index);
667     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
668 
669     errorCode = ParseAbilityIcon(abilityObjectItem, bundleProfile, abilityRes, index);
670     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
671 
672     errorCode = ParseAbilityLabel(abilityObjectItem, bundleProfile, abilityRes, index);
673     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
674 
675     errorCode = ParseAbilityType(abilityObjectItem, bundleProfile.abilityInfos[index]);
676     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
677 
678     errorCode = ParseAbilityLauchMode(abilityObjectItem, bundleProfile.abilityInfos[index]);
679     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
680 
681     errorCode = ParseAbilityVisible(abilityObjectItem, bundleProfile.abilityInfos[index]);
682     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
683 
684     errorCode = ParseAbilityDeviceCap(abilityObjectItem, bundleProfile.abilityInfos[index]);
685     CHECK_IS_TRUE((errorCode == ERR_OK), errorCode);
686     return ERR_OK;
687 }
688 
ParseAbilityDeviceCap(const cJSON * abilityObjectItem,AbilityInfo & abilityInfo)689 uint8_t BundleParser::ParseAbilityDeviceCap(const cJSON *abilityObjectItem, AbilityInfo &abilityInfo)
690 {
691     if (cJSON_HasObjectItem(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_DEVICE_CAP)) {
692         cJSON *object = ParseValue(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_DEVICE_CAP, nullptr);
693         CHECK_IS_TRUE(cJSON_IsArray(object), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICECAP_ERROR);
694         int32_t deviceCapSize = cJSON_GetArraySize(object);
695         if (deviceCapSize == 0) {
696             abilityInfo.deviceCap.systemCapNum = 0;
697             return ERR_OK;
698         }
699         abilityInfo.deviceCap.systemCapNum = deviceCapSize;
700         abilityInfo.deviceCap.systemCapName = reinterpret_cast<SystemCapName *>(AdapterMalloc(sizeof(SystemCapName) *
701             deviceCapSize));
702         if (abilityInfo.deviceCap.systemCapName == nullptr) {
703             HILOG_ERROR(HILOG_MODULE_APP, "malloc deviceCap fail!");
704             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICECAP_ERROR;
705         }
706         SystemCapName *deviceCapName = nullptr;
707         cJSON *deviceCapObject = nullptr;
708         for (int32_t index = 0; index < deviceCapSize; index++) {
709             deviceCapObject = cJSON_GetArrayItem(object, index);
710             if (deviceCapObject == nullptr) {
711                 continue;
712             }
713             deviceCapName = abilityInfo.deviceCap.systemCapName + index;
714             if ((deviceCapObject->valuestring != nullptr) &&
715                 (strncpy_s(deviceCapName->name, sizeof(deviceCapName->name),
716                 deviceCapObject->valuestring, strlen(deviceCapObject->valuestring)) != EOK)) {
717                 HILOG_ERROR(HILOG_MODULE_APP, "ParseAbilityDeviceCap strncpy deviceCap fail!");
718                 AdapterFree(abilityInfo.deviceCap.systemCapName);
719                 abilityInfo.deviceCap.systemCapNum = 0;
720                 return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_DEVICECAP_ERROR;
721             }
722         }
723     }
724     return ERR_OK;
725 }
726 
ParseAbilityDesc(const cJSON * abilityObject,BundleProfile & bundleProfile,AbilityRes & abilityRes,int32_t index)727 uint8_t BundleParser::ParseAbilityDesc(const cJSON *abilityObject, BundleProfile &bundleProfile,
728     AbilityRes &abilityRes, int32_t index)
729 {
730     if (!cJSON_HasObjectItem(abilityObject, PROFILE_KEY_MODULE_ABLLITY_DESCRIPTION)) {
731         return ERR_OK;
732     }
733     bundleProfile.abilityInfos[index].description = ParseValue(abilityObject,
734         PROFILE_KEY_MODULE_ABLLITY_DESCRIPTION);
735     CHECK_NULL(bundleProfile.abilityInfos[index].description,
736         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_DESCRIPTION_ERROR);
737     if (BundleUtil::StartWith(bundleProfile.abilityInfos[index].description, DEFAULT_DESC_SETTING)) {
738         int32_t descId = ParseValue(abilityObject, ABILITY_DES_ID, -1);
739         if (descId < 0) {
740             HILOG_ERROR(HILOG_MODULE_APP, "get ability descriptionId fail!");
741             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_DESCRIPTION_ERROR;
742         }
743         abilityRes.index = index;
744         abilityRes.descriptionId = static_cast<uint32_t>(descId);
745     } else {
746         CHECK_LENGTH(strlen(bundleProfile.abilityInfos[index].description), MAX_DECRIPTION_LEN,
747             ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_ABILITY_DESCRIPTION_LENGTH_ERROR);
748     }
749     return ERR_OK;
750 }
751 
ParseAbilityIcon(const cJSON * abilityObject,BundleProfile & bundleProfile,AbilityRes & abilityRes,int32_t index)752 uint8_t BundleParser::ParseAbilityIcon(const cJSON *abilityObject, BundleProfile &bundleProfile,
753     AbilityRes &abilityRes, int32_t index)
754 {
755     if (!cJSON_HasObjectItem(abilityObject, PROFILE_KEY_MODULE_ABILITY_ICON)) {
756         return ERR_OK;
757     }
758     bundleProfile.abilityInfos[index].iconPath = ParseValue(abilityObject, PROFILE_KEY_MODULE_ABILITY_ICON);
759     CHECK_NULL(bundleProfile.abilityInfos[index].iconPath,
760         ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_ICONPATH_ERROR);
761     if (BundleUtil::StartWith(bundleProfile.abilityInfos[index].iconPath, DEFAULT_ICON_SETTING_BEGIN)) {
762         int32_t iconId = ParseValue(abilityObject, ICON_ID, -1);
763         if (iconId < 0) {
764             HILOG_ERROR(HILOG_MODULE_APP, "get ability iconId fail!");
765             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_ICONPATH_ERROR;
766         }
767         abilityRes.index = index;
768         abilityRes.iconId = static_cast<uint32_t>(iconId);
769     }
770     return ERR_OK;
771 }
772 
ParseAbilityLabel(const cJSON * abilityObject,BundleProfile & bundleProfile,AbilityRes & abilityRes,int32_t index)773 uint8_t BundleParser::ParseAbilityLabel(const cJSON *abilityObject, BundleProfile &bundleProfile,
774     AbilityRes &abilityRes, int32_t index)
775 {
776     if (!cJSON_HasObjectItem(abilityObject, PROFILE_KEY_MODULE_ABILITY_LABEL)) {
777         return ERR_OK;
778     }
779     bundleProfile.abilityInfos[index].label = ParseValue(abilityObject, PROFILE_KEY_MODULE_ABILITY_LABEL);
780     CHECK_NULL(bundleProfile.abilityInfos[index].label, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_LABEL_ERROR);
781     if (BundleUtil::StartWith(bundleProfile.abilityInfos[index].label, DEFAULT_LABEL_SETTING)) {
782         int32_t labelId = ParseValue(abilityObject, LABEL_ID, -1);
783         if (labelId < 0) {
784             HILOG_ERROR(HILOG_MODULE_APP, "get ability labelId fail!");
785             return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_LABEL_ERROR;
786         }
787         abilityRes.index = index;
788         abilityRes.labelId = static_cast<uint32_t>(labelId);
789     } else {
790         CHECK_LENGTH(strlen(bundleProfile.abilityInfos[index].label), MAX_LABLE_LEN,
791             ERR_APPEXECFWK_INSTALL_FAILED_EXCEED_MAX_ABILITY_LABEL_LENGTH_ERROR);
792     }
793     return ERR_OK;
794 }
795 
ParseAbilityType(const cJSON * abilityObjectItem,AbilityInfo & abilityInfo)796 uint8_t BundleParser::ParseAbilityType(const cJSON *abilityObjectItem, AbilityInfo &abilityInfo)
797 {
798     char *abilityType = ParseValue(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_TYPE);
799     CHECK_NULL(abilityType, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_TYPE_ERROR);
800     auto iter = std::find_if(std::begin(ABILITY_TYPE_MAP), std::end(ABILITY_TYPE_MAP),
801         [&abilityType] (const auto &item) {
802             return item.first == std::string(abilityType);
803     });
804     if (iter != ABILITY_TYPE_MAP.end()) {
805         abilityInfo.abilityType = iter->second;
806         return ERR_OK;
807     }
808     abilityInfo.abilityType = UNKNOWN;
809     return ERR_OK;
810 }
811 
ParseAbilityLauchMode(const cJSON * abilityObjectItem,AbilityInfo & abilityInfo)812 uint8_t BundleParser::ParseAbilityLauchMode(const cJSON *abilityObjectItem, AbilityInfo &abilityInfo)
813 {
814     if (cJSON_HasObjectItem(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_LAUNCHTYPE)) {
815         char *launchMode = ParseValue(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_LAUNCHTYPE);
816         CHECK_NULL(launchMode, ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_LAUNCHTYPE_ERROR);
817         auto iter = std::find_if(std::begin(LAUNCH_MODE_MAP), std::end(LAUNCH_MODE_MAP),
818             [&launchMode] (const auto &item) {
819             return item.first == std::string(launchMode);
820         });
821         if (iter != LAUNCH_MODE_MAP.end()) {
822             abilityInfo.launchMode = iter->second;
823         }
824         abilityInfo.launchMode = SINGLETON;
825         return ERR_OK;
826     }
827     abilityInfo.launchMode = SINGLETON;
828     return ERR_OK;
829 }
830 
ParseAbilityVisible(const cJSON * abilityObjectItem,AbilityInfo & abilityInfo)831 uint8_t BundleParser::ParseAbilityVisible(const cJSON *abilityObjectItem, AbilityInfo &abilityInfo)
832 {
833     if (cJSON_HasObjectItem(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_VISIBLE)) {
834         cJSON *visibleObject = cJSON_GetObjectItem(abilityObjectItem, PROFILE_KEY_MODULE_ABILITY_VISIBLE);
835         CHECK_IS_TRUE(cJSON_IsBool(visibleObject), ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITY_VISIBLE_ERROR);
836         abilityInfo.isVisible = cJSON_IsTrue(visibleObject);
837     } else {
838         abilityInfo.isVisible = false;
839     }
840     return ERR_OK;
841 }
842 } // namespace OHOS