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 "convert_utils.h"
17 
18 #include "ability_info_utils.h"
19 #include "bundle_info_utils.h"
20 #include "bundle_log.h"
21 #include "module_info_utils.h"
22 #include "securec.h"
23 #include "utils.h"
24 
25 namespace OHOS {
26 // bundleInfo json key
27 const char BUNDLEINFO_JSON_KEY_SYSTEMAPP[] = "isSystemApp";
28 const char BUNDLEINFO_JSON_KEY_NATIVEAPP[] = "isNativeApp";
29 const char BUNDLEINFO_JSON_KEY_KEEPALIVE[] = "isKeepAlive";
30 const char BUNDLEINFO_JSON_KEY_VERSIONCODE[] = "versionCode";
31 const char BUNDLEINFO_JSON_KEY_UID[] = "uid";
32 const char BUNDLEINFO_JSON_KEY_GID[] = "gid";
33 const char BUNDLEINFO_JSON_KEY_VERSIONNAME[] = "versionName";
34 const char BUNDLEINFO_JSON_KEY_BUNDLENAME[] = "bundleName";
35 const char BUNDLEINFO_JSON_KEY_LABLE[] = "label";
36 const char BUNDLEINFO_JSON_KEY_ICONPATH[] = "iconPath";
37 const char BUNDLEINFO_JSON_KEY_CODEPATH[] = "codePath";
38 const char BUNDLEINFO_JSON_KEY_DATAPATH[] = "dataPath";
39 const char BUNDLEINFO_JSON_KEY_COMPATIBLEAPI[] = "compatibleApi";
40 const char BUNDLEINFO_JSON_KEY_TARGETAPI[] = "targetApi";
41 const char BUNDLEINFO_JSON_KEY_VENDOR[] = "vendor";
42 const char BUNDLEINFO_JSON_KEY_APPID[] = "appId";
43 const char BUNDLEINFO_JSON_KEY_NUMOFMODULE[] = "numOfModule";
44 const char BUNDLEINFO_JSON_KEY_MODULEINFOS[] = "moduleInfos";
45 const char BUNDLEINFO_JSON_KEY_NUMOFABILITY[] = "numOfAbility";
46 const char BUNDLEINFO_JSON_KEY_ABILITYINFOS[] = "abilityInfos";
47 // abilityInfo json key
48 const char ABILITYINFO_JSON_KEY_BUNDLENAME[] = "bundleName";
49 const char ABILITYINFO_JSON_KEY_NAME[] = "name";
50 const char ABILITYINFO_JSON_KEY_ABILITYTYPE[] = "abilityType";
51 const char ABILITYINFO_JSON_KEY_LAUNCHMODE[] = "launchMode";
52 const char ABILITYINFO_JSON_KEY_VISIBLE[] = "isVisible";
53 const char ABILITYINFO_JSON_KEY_MODULENAME[] = "moduleName";
54 const char ABILITYINFO_JSON_KEY_DESCRIPTION[] = "description";
55 const char ABILITYINFO_JSON_KEY_ICONPATH[] = "iconPath";
56 const char ABILITYINFO_JSON_KEY_DEVICEID[] = "deviceId";
57 const char ABILITYINFO_JSON_KEY_LABEL[] = "label";
58 // moduleInfo json key
59 const char MODULEINFO_JSON_KEY_NAME[] = "name";
60 const char MODULEINFO_JSON_KEY_DESCRIPTION[] = "description";
61 const char MODULEINFO_JSON_KEY_MODULENAME[] = "moduleName";
62 const char MODULEINFO_JSON_KEY_MODULETYPE[] = "moduleType";
63 const char MODULEINFO_JSON_KEY_DELIVERYINSTALL[] = "isDeliveryInstall";
64 const char MODULEINFO_JSON_KEY_DEVICETYPE[] = "deviceType";
65 const char MODULEINFO_JSON_KEY_METADATA[] = "metaData";
66 const char MODULEINFO_JSON_KEY_METADATA_NAME[] = "name";
67 const char MODULEINFO_JSON_KEY_METADATA_VALUE[] = "value";
68 const char MODULEINFO_JSON_KEY_METADATA_EXTRA[] = "extra";
69 
ConvertAbilityInfoToString(const AbilityInfo * abilityInfo)70 char *ConvertUtils::ConvertAbilityInfoToString(const AbilityInfo *abilityInfo)
71 {
72     if (abilityInfo == nullptr) {
73         return nullptr;
74     }
75     cJSON *root = GetJsonAbilityInfo(abilityInfo);
76     if (root == nullptr) {
77         return nullptr;
78     }
79     char *str = cJSON_PrintUnformatted(root);
80     cJSON_Delete(root);
81     return str;
82 }
83 
ConvertBundleInfoToString(const BundleInfo * bundleInfo)84 char *ConvertUtils::ConvertBundleInfoToString(const BundleInfo *bundleInfo)
85 {
86     if (bundleInfo == nullptr) {
87         return nullptr;
88     }
89     cJSON *root = GetJsonBundleInfo(bundleInfo);
90     if (root == nullptr) {
91         return nullptr;
92     }
93     char *str = cJSON_PrintUnformatted(root);
94     cJSON_Delete(root);
95     return str;
96 }
97 
ConvertBundleInfosToString(BundleInfo ** bundleInfo,uint32_t numOfBundleInfo)98 char *ConvertUtils::ConvertBundleInfosToString(BundleInfo **bundleInfo, uint32_t numOfBundleInfo)
99 {
100     if (bundleInfo == nullptr || numOfBundleInfo == 0) {
101         return nullptr;
102     }
103     cJSON *roots = GetJsonBundleInfos(bundleInfo, numOfBundleInfo);
104     if (roots == nullptr) {
105         return nullptr;
106     }
107     char *strs = cJSON_PrintUnformatted(roots);
108     cJSON_Delete(roots);
109     return strs;
110 }
111 
ConvertStringToAbilityInfo(const char * str,size_t buffSize)112 AbilityInfo *ConvertUtils::ConvertStringToAbilityInfo(const char *str, size_t buffSize)
113 {
114     if (str == nullptr) {
115         return nullptr;
116     }
117     AbilityInfo *abilityInfo = reinterpret_cast<AbilityInfo *>(AdapterMalloc(sizeof(AbilityInfo)));
118     if (abilityInfo == nullptr) {
119         return nullptr;
120     }
121     if (memset_s(abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo)) != EOK) {
122         AdapterFree(abilityInfo);
123         return nullptr;
124     }
125     cJSON *root = cJSON_ParseWithLength(str, buffSize);
126     if (root == nullptr) {
127         AdapterFree(abilityInfo);
128         return nullptr;
129     }
130     if (!ConvertJsonToAbilityInfo(root, abilityInfo)) {
131         ClearAbilityInfo(abilityInfo);
132         AdapterFree(abilityInfo);
133         cJSON_Delete(root);
134         return nullptr;
135     }
136     cJSON_Delete(root);
137     return abilityInfo;
138 }
139 
ConvertStringToBundleInfo(const char * str,size_t buffSize)140 BundleInfo *ConvertUtils::ConvertStringToBundleInfo(const char *str, size_t buffSize)
141 {
142     if (str == nullptr) {
143         return nullptr;
144     }
145     BundleInfo *bundleInfo = reinterpret_cast<BundleInfo *>(AdapterMalloc(sizeof(BundleInfo)));
146     if (bundleInfo == nullptr) {
147         return nullptr;
148     }
149     if (memset_s(bundleInfo, sizeof(BundleInfo), 0, sizeof(BundleInfo)) != EOK) {
150         AdapterFree(bundleInfo);
151         return nullptr;
152     }
153     cJSON *root = cJSON_ParseWithLength(str, buffSize);
154     if (root == nullptr) {
155         AdapterFree(bundleInfo);
156         return nullptr;
157     }
158 
159     if (!ConvertJsonToBundleInfo(root, bundleInfo)) {
160         BundleInfoUtils::FreeBundleInfo(bundleInfo);
161         cJSON_Delete(root);
162         return nullptr;
163     }
164     cJSON_Delete(root);
165     return bundleInfo;
166 }
167 
ConvertStringToBundleInfos(const char * strs,BundleInfo ** bundleInfo,uint32_t numOfBundleInfo,size_t buffSize)168 bool ConvertUtils::ConvertStringToBundleInfos(const char *strs, BundleInfo **bundleInfo, uint32_t numOfBundleInfo,
169     size_t buffSize)
170 {
171     if (strs == nullptr || bundleInfo == nullptr || numOfBundleInfo == 0) {
172         return false;
173     }
174     cJSON *roots = cJSON_ParseWithLength(strs, buffSize);
175     if (roots == nullptr) {
176         return false;
177     }
178 
179     if (!cJSON_IsArray(roots) || static_cast<uint32_t>(cJSON_GetArraySize(roots)) != numOfBundleInfo) {
180         cJSON_Delete(roots);
181         return false;
182     }
183 
184     *bundleInfo = reinterpret_cast<BundleInfo *>(AdapterMalloc(sizeof(BundleInfo) * numOfBundleInfo));
185     if (*bundleInfo == nullptr) {
186         cJSON_Delete(roots);
187         return false;
188     }
189     int32_t ret =
190         memset_s(*bundleInfo, sizeof(BundleInfo) * numOfBundleInfo, 0, sizeof(BundleInfo) * numOfBundleInfo);
191     if (ret != EOK) {
192         AdapterFree(*bundleInfo);
193         cJSON_Delete(roots);
194         return false;
195     }
196 
197     cJSON *item = nullptr;
198     uint32_t i = 0;
199     cJSON_ArrayForEach(item, roots) {
200         if (!ConvertJsonToBundleInfo(item, *bundleInfo + i)) {
201             BundleInfoUtils::FreeBundleInfos(*bundleInfo, numOfBundleInfo);
202             cJSON_Delete(roots);
203             return false;
204         }
205         i++;
206     }
207     cJSON_Delete(roots);
208     return true;
209 }
210 
GetJsonBundleInfo(const BundleInfo * bundleInfo)211 cJSON *ConvertUtils::GetJsonBundleInfo(const BundleInfo *bundleInfo)
212 {
213     if (bundleInfo == nullptr) {
214         return nullptr;
215     }
216     cJSON *root = cJSON_CreateObject();
217     if (root == nullptr) {
218         return nullptr;
219     }
220     if (!ConvertBundleInfoPartToJson(bundleInfo, root)) {
221         cJSON_Delete(root);
222         return nullptr;
223     }
224     // set moduleInfos in json
225     if (!ConvertModuleInfosToJson(bundleInfo, root)) {
226         cJSON_Delete(root);
227         return nullptr;
228     }
229     // set abilityInfos in json when is exists
230     if (!ConvertAbilityInfosToJson(bundleInfo, root)) {
231         cJSON_Delete(root);
232         return nullptr;
233     }
234     return root;
235 }
236 
ConvertBundleInfoPartToJson(const BundleInfo * bundleInfo,cJSON * root)237 bool ConvertUtils::ConvertBundleInfoPartToJson(const BundleInfo *bundleInfo, cJSON *root)
238 {
239     if (bundleInfo == nullptr || root == nullptr) {
240         return false;
241     }
242     // set mandatory fileds in json
243     if (cJSON_AddBoolToObject(root, BUNDLEINFO_JSON_KEY_SYSTEMAPP, bundleInfo->isSystemApp) == nullptr ||
244         cJSON_AddBoolToObject(root, BUNDLEINFO_JSON_KEY_NATIVEAPP, bundleInfo->isNativeApp) == nullptr ||
245         cJSON_AddBoolToObject(root, BUNDLEINFO_JSON_KEY_KEEPALIVE, bundleInfo->isKeepAlive) == nullptr ||
246         cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_VERSIONCODE, bundleInfo->versionCode) == nullptr ||
247         cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_UID, bundleInfo->uid) == nullptr ||
248         cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_GID, bundleInfo->gid) == nullptr ||
249         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_VERSIONNAME, bundleInfo->versionName) == nullptr ||
250         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_BUNDLENAME, bundleInfo->bundleName) == nullptr ||
251         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_CODEPATH, bundleInfo->codePath) == nullptr ||
252         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_DATAPATH, bundleInfo->dataPath) == nullptr ||
253         cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_COMPATIBLEAPI, bundleInfo->compatibleApi) == nullptr ||
254         cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_TARGETAPI, bundleInfo->targetApi) == nullptr ||
255         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_APPID, bundleInfo->appId) == nullptr) {
256         HILOG_ERROR(HILOG_MODULE_APP, "set mandatory fileds fail in bundleInfo json!");
257         return false;
258     }
259     // set optional field which is not nullptr in json
260     if ((bundleInfo->label != nullptr &&
261         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_LABLE, bundleInfo->label) == nullptr) ||
262         (bundleInfo->bigIconPath != nullptr &&
263         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_ICONPATH, bundleInfo->bigIconPath) == nullptr) ||
264         (bundleInfo->vendor != nullptr &&
265         cJSON_AddStringToObject(root, BUNDLEINFO_JSON_KEY_VENDOR, bundleInfo->vendor) == nullptr)) {
266         HILOG_ERROR(HILOG_MODULE_APP, "set optional filed fail which not nullptr in bundleInfo json!");
267         return false;
268     }
269     return true;
270 }
271 
ConvertModuleInfosToJson(const BundleInfo * bundleInfo,cJSON * root)272 bool ConvertUtils::ConvertModuleInfosToJson(const BundleInfo *bundleInfo, cJSON *root)
273 {
274     if (bundleInfo == nullptr || root == nullptr || bundleInfo->numOfModule <= 0) {
275         return false;
276     }
277 
278     cJSON *moduleInfosJson = GetJsonModuleInfos(bundleInfo->moduleInfos, bundleInfo->numOfModule);
279     if (moduleInfosJson == nullptr) {
280         HILOG_ERROR(HILOG_MODULE_APP, "get modulseInfos fail when convert moduleInfo to json!");
281         return false;
282     }
283 
284     if (cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_NUMOFMODULE, bundleInfo->numOfModule) == nullptr) {
285         cJSON_Delete(moduleInfosJson);
286         HILOG_ERROR(HILOG_MODULE_APP, "cJSON_AddNumberToObject fail when convert moduleInfo to json!");
287         return false;
288     }
289 
290     if (!cJSON_AddItemToObject(root, BUNDLEINFO_JSON_KEY_MODULEINFOS, moduleInfosJson)) {
291         cJSON_Delete(moduleInfosJson);
292         HILOG_ERROR(HILOG_MODULE_APP, "cJSON_AddItemToObject fail when convert moduleInfo to json!");
293         return false;
294     }
295     return true;
296 }
297 
ConvertAbilityInfosToJson(const BundleInfo * bundleInfo,cJSON * root)298 bool ConvertUtils::ConvertAbilityInfosToJson(const BundleInfo *bundleInfo, cJSON *root)
299 {
300     if (bundleInfo == nullptr || root == nullptr || bundleInfo->numOfAbility < 0) {
301         return false;
302     }
303 
304     if (bundleInfo->numOfAbility == 0) {
305         return true;
306     }
307 
308     cJSON *abilitysJson = GetJsonAbilityInfos(bundleInfo->abilityInfos, bundleInfo->numOfAbility);
309     if (abilitysJson == nullptr) {
310         HILOG_ERROR(HILOG_MODULE_APP, "get abilityInfos fail when convert abilityInfo to json!");
311         return false;
312     }
313     if (cJSON_AddNumberToObject(root, BUNDLEINFO_JSON_KEY_NUMOFABILITY, bundleInfo->numOfAbility) == nullptr) {
314         cJSON_Delete(abilitysJson);
315         HILOG_ERROR(HILOG_MODULE_APP, "cJSON_AddNumberToObject fail when convert abilityInfo to json!");
316         return false;
317     }
318     if (!cJSON_AddItemToObject(root, BUNDLEINFO_JSON_KEY_ABILITYINFOS, abilitysJson)) {
319         cJSON_Delete(abilitysJson);
320         HILOG_ERROR(HILOG_MODULE_APP, "cJSON_AddItemToObject fail when convert abilityInfo to json!");
321         return false;
322     }
323     return true;
324 }
325 
GetJsonBundleInfos(BundleInfo ** bundleInfo,uint32_t numOfBundleInfo)326 cJSON *ConvertUtils::GetJsonBundleInfos(BundleInfo **bundleInfo, uint32_t numOfBundleInfo)
327 {
328     if (bundleInfo == nullptr) {
329         return nullptr;
330     }
331     cJSON *roots = cJSON_CreateArray();
332     if (roots == nullptr) {
333         return nullptr;
334     }
335 
336     for (uint32_t i = 0; i < numOfBundleInfo; i++) {
337         cJSON *item = GetJsonBundleInfo(*bundleInfo + i);
338         if (item == nullptr) {
339             cJSON_Delete(roots);
340             return nullptr;
341         }
342         if (!cJSON_AddItemToArray(roots, item)) {
343             cJSON_Delete(item);
344             cJSON_Delete(roots);
345             return nullptr;
346         }
347     }
348     return roots;
349 }
350 
GetJsonModuleInfos(const ModuleInfo * moduleInfos,uint32_t numOfModule)351 cJSON *ConvertUtils::GetJsonModuleInfos(const ModuleInfo *moduleInfos, uint32_t numOfModule)
352 {
353     if (moduleInfos == nullptr) {
354         return nullptr;
355     }
356     cJSON *jsonModuleInfos = cJSON_CreateArray();
357     if (jsonModuleInfos == nullptr) {
358         return nullptr;
359     }
360     for (uint32_t index = 0; index < numOfModule; ++index) {
361         cJSON *moduleInfosItem = cJSON_CreateObject();
362         if (moduleInfosItem == nullptr) {
363             cJSON_Delete(jsonModuleInfos);
364             return nullptr;
365         }
366         // set mandatory fileds in json
367         if (cJSON_AddStringToObject(moduleInfosItem, MODULEINFO_JSON_KEY_MODULENAME,
368             moduleInfos[index].moduleName) == nullptr ||
369             cJSON_AddStringToObject(moduleInfosItem, MODULEINFO_JSON_KEY_MODULETYPE,
370             moduleInfos[index].moduleType) == nullptr ||
371             cJSON_AddBoolToObject(moduleInfosItem, MODULEINFO_JSON_KEY_DELIVERYINSTALL,
372             moduleInfos[index].isDeliveryInstall) == nullptr) {
373             HILOG_ERROR(HILOG_MODULE_APP, "set mandatory fileds fail in moduleInfo json!");
374             cJSON_Delete(moduleInfosItem);
375             cJSON_Delete(jsonModuleInfos);
376             return nullptr;
377         }
378         // set optional field which is not nullptr in json
379         if ((moduleInfos[index].name != nullptr && cJSON_AddStringToObject(moduleInfosItem,
380             MODULEINFO_JSON_KEY_NAME, moduleInfos[index].name) == nullptr) ||
381             (moduleInfos[index].description != nullptr && cJSON_AddStringToObject(moduleInfosItem,
382             ABILITYINFO_JSON_KEY_DESCRIPTION, moduleInfos[index].description) == nullptr)) {
383             HILOG_ERROR(HILOG_MODULE_APP, "set optional fileds fail in moduleInfo json!");
384             cJSON_Delete(moduleInfosItem);
385             cJSON_Delete(jsonModuleInfos);
386             return nullptr;
387         }
388         if (!ConvertModuleInfoMetaDataToJson(moduleInfos, index, moduleInfosItem)) {
389             cJSON_Delete(moduleInfosItem);
390             cJSON_Delete(jsonModuleInfos);
391             return nullptr;
392         }
393         if (!ConvertModuleInfoDeviceTypeToJson(moduleInfos, index, moduleInfosItem)) {
394             cJSON_Delete(moduleInfosItem);
395             cJSON_Delete(jsonModuleInfos);
396             return nullptr;
397         }
398         if (!cJSON_AddItemToArray(jsonModuleInfos, moduleInfosItem)) {
399             HILOG_ERROR(HILOG_MODULE_APP, "add moduleInfosItem in jsonModuleInfos fail!");
400             cJSON_Delete(moduleInfosItem);
401             cJSON_Delete(jsonModuleInfos);
402             return nullptr;
403         }
404     }
405     return jsonModuleInfos;
406 }
407 
ConvertModuleInfoMetaDataToJson(const ModuleInfo * moduleInfos,uint32_t index,cJSON * item)408 bool ConvertUtils::ConvertModuleInfoMetaDataToJson(const ModuleInfo *moduleInfos, uint32_t index, cJSON *item)
409 {
410     if (moduleInfos == nullptr || item == nullptr) {
411         return false;
412     }
413 
414     if (moduleInfos[index].metaData[0] == nullptr) {
415         return true;
416     }
417 
418     cJSON *metaDataJson = GetJsonModuleInfoMetaData(moduleInfos, index);
419     if (metaDataJson == nullptr) {
420         HILOG_ERROR(HILOG_MODULE_APP, "get metaDataJson fail in moduleInfo json when metaData is not null!");
421         return false;
422     }
423 
424     if (!cJSON_AddItemToObject(item, MODULEINFO_JSON_KEY_METADATA, metaDataJson)) {
425         HILOG_ERROR(HILOG_MODULE_APP, "set metaDataJson fail in moduleInfo json when metaData is not null!");
426         cJSON_Delete(metaDataJson);
427         return false;
428     }
429     return true;
430 }
431 
ConvertModuleInfoDeviceTypeToJson(const ModuleInfo * moduleInfos,uint32_t index,cJSON * item)432 bool ConvertUtils::ConvertModuleInfoDeviceTypeToJson(const ModuleInfo *moduleInfos, uint32_t index, cJSON *item)
433 {
434     if (moduleInfos == nullptr || item == nullptr) {
435         return false;
436     }
437 
438     if (moduleInfos[index].deviceType[0] == nullptr) {
439         HILOG_ERROR(HILOG_MODULE_APP, "deviceType is null!");
440         return false;
441     }
442 
443     cJSON *deviceTypeJson = GetJsonModuleInfoDeviceType(moduleInfos, index);
444     if (deviceTypeJson == nullptr) {
445         HILOG_ERROR(HILOG_MODULE_APP, "get deviceType fail in moduleInfo json when deviceType is not null!");
446         return false;
447     }
448 
449     if (!cJSON_AddItemToObject(item, MODULEINFO_JSON_KEY_DEVICETYPE, deviceTypeJson)) {
450         cJSON_Delete(deviceTypeJson);
451         HILOG_ERROR(HILOG_MODULE_APP, "set deviceType fail in moduleInfo json when deviceType is not null!");
452         return false;
453     }
454     return true;
455 }
456 
GetJsonModuleInfoMetaData(const ModuleInfo * moduleInfos,uint32_t index)457 cJSON *ConvertUtils::GetJsonModuleInfoMetaData(const ModuleInfo *moduleInfos, uint32_t index)
458 {
459     if (moduleInfos == nullptr) {
460         return nullptr;
461     }
462     cJSON *jsonMetaData = cJSON_CreateArray();
463     if (jsonMetaData == nullptr) {
464         return nullptr;
465     }
466     for (uint32_t metaDataIndex = 0; metaDataIndex < METADATA_SIZE; ++metaDataIndex) {
467         if (moduleInfos[index].metaData[metaDataIndex] == nullptr) {
468             break;
469         }
470         cJSON *metaDataItem = cJSON_CreateObject();
471         if (metaDataItem == nullptr) {
472             cJSON_Delete(jsonMetaData);
473             return nullptr;
474         }
475         if ((moduleInfos[index].metaData[metaDataIndex]->name != nullptr && cJSON_AddStringToObject(metaDataItem,
476             MODULEINFO_JSON_KEY_METADATA_NAME, moduleInfos[index].metaData[metaDataIndex]->name) == nullptr) ||
477             (moduleInfos[index].metaData[metaDataIndex]->value != nullptr && cJSON_AddStringToObject(metaDataItem,
478             MODULEINFO_JSON_KEY_METADATA_VALUE, moduleInfos[index].metaData[metaDataIndex]->value) == nullptr) ||
479             (moduleInfos[index].metaData[metaDataIndex]->extra != nullptr && cJSON_AddStringToObject(metaDataItem,
480             MODULEINFO_JSON_KEY_METADATA_EXTRA, moduleInfos[index].metaData[metaDataIndex]->extra) == nullptr) ||
481             !cJSON_AddItemToArray(jsonMetaData, metaDataItem)) {
482             cJSON_Delete(metaDataItem);
483             cJSON_Delete(jsonMetaData);
484             return nullptr;
485         }
486     }
487     return jsonMetaData;
488 }
489 
GetJsonModuleInfoDeviceType(const ModuleInfo * moduleInfos,uint32_t index)490 cJSON *ConvertUtils::GetJsonModuleInfoDeviceType(const ModuleInfo *moduleInfos, uint32_t index)
491 {
492     if (moduleInfos == nullptr) {
493         return nullptr;
494     }
495     cJSON *jsonDeviceType = cJSON_CreateArray();
496     if (jsonDeviceType == nullptr) {
497         return nullptr;
498     }
499     for (int32_t deviceTypeIndex = 0; deviceTypeIndex < DEVICE_TYPE_SIZE; ++deviceTypeIndex) {
500         if (moduleInfos[index].deviceType[deviceTypeIndex] == nullptr) {
501             break;
502         }
503         cJSON *object = cJSON_CreateString(moduleInfos[index].deviceType[deviceTypeIndex]);
504         if (object == nullptr) {
505             cJSON_Delete(jsonDeviceType);
506             return nullptr;
507         }
508         if (!cJSON_AddItemToArray(jsonDeviceType, object)) {
509             cJSON_Delete(object);
510             cJSON_Delete(jsonDeviceType);
511             return nullptr;
512         }
513     }
514     return jsonDeviceType;
515 }
516 
GetJsonAbilityInfos(const AbilityInfo * abilityInfos,uint32_t numOfAbility)517 cJSON *ConvertUtils::GetJsonAbilityInfos(const AbilityInfo *abilityInfos, uint32_t numOfAbility)
518 {
519     cJSON *jsonAbilityInfos = cJSON_CreateArray();
520     if (jsonAbilityInfos == nullptr) {
521         return nullptr;
522     }
523     for (uint32_t index = 0; index < numOfAbility; ++index) {
524         cJSON *item = GetJsonAbilityInfo(abilityInfos + index);
525         if (item == nullptr) {
526             cJSON_Delete(jsonAbilityInfos);
527             return nullptr;
528         }
529         if (!cJSON_AddItemToArray(jsonAbilityInfos, item)) {
530             cJSON_Delete(item);
531             cJSON_Delete(jsonAbilityInfos);
532             return nullptr;
533         }
534     }
535     return jsonAbilityInfos;
536 }
537 
GetJsonAbilityInfo(const AbilityInfo * abilityInfo)538 cJSON *ConvertUtils::GetJsonAbilityInfo(const AbilityInfo *abilityInfo)
539 {
540     cJSON *root = cJSON_CreateObject();
541     if (root == nullptr) {
542         return nullptr;
543     }
544     // set mandatory fileds in json
545     if (cJSON_AddBoolToObject(root, ABILITYINFO_JSON_KEY_VISIBLE, abilityInfo->isVisible) == nullptr ||
546         cJSON_AddNumberToObject(root, ABILITYINFO_JSON_KEY_ABILITYTYPE, abilityInfo->abilityType) == nullptr ||
547         cJSON_AddNumberToObject(root, ABILITYINFO_JSON_KEY_LAUNCHMODE, abilityInfo->launchMode) == nullptr ||
548         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_BUNDLENAME, abilityInfo->bundleName) == nullptr ||
549         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_MODULENAME, abilityInfo->moduleName) == nullptr ||
550         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_NAME, abilityInfo->name) == nullptr) {
551         HILOG_ERROR(HILOG_MODULE_APP, "set mandatory fileds fail in abilityInfo json!");
552         cJSON_Delete(root);
553         return nullptr;
554     }
555     // set optional fields in json
556     if ((abilityInfo->description != nullptr &&
557         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_DESCRIPTION, abilityInfo->description) == nullptr) ||
558         (abilityInfo->iconPath != nullptr &&
559         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_ICONPATH, abilityInfo->iconPath) == nullptr) ||
560         (abilityInfo->label != nullptr &&
561         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_LABEL, abilityInfo->label) == nullptr) ||
562         (abilityInfo->deviceId != nullptr &&
563         cJSON_AddStringToObject(root, ABILITYINFO_JSON_KEY_DEVICEID, abilityInfo->deviceId) == nullptr)) {
564         HILOG_ERROR(HILOG_MODULE_APP, "set optional fileds fail in abilityInfo json!");
565         cJSON_Delete(root);
566         return nullptr;
567     }
568     return root;
569 }
570 
ConvertJsonToBundleInfo(const cJSON * root,BundleInfo * bundleInfo)571 bool ConvertUtils::ConvertJsonToBundleInfo(const cJSON *root, BundleInfo *bundleInfo)
572 {
573     if (root == nullptr || bundleInfo == nullptr) {
574         return false;
575     }
576     cJSON *item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_SYSTEMAPP);
577     if (cJSON_IsBool(item)) {
578         bundleInfo->isSystemApp = cJSON_IsTrue(item);
579     }
580     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_NATIVEAPP);
581     if (cJSON_IsBool(item)) {
582         bundleInfo->isNativeApp = cJSON_IsTrue(item);
583     }
584     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_KEEPALIVE);
585     if (cJSON_IsBool(item)) {
586         bundleInfo->isKeepAlive = cJSON_IsTrue(item);
587     }
588     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_VERSIONCODE);
589     if (cJSON_IsNumber(item)) {
590         bundleInfo->versionCode = item->valueint;
591     }
592     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_UID);
593     if (cJSON_IsNumber(item)) {
594         bundleInfo->uid = item->valueint;
595     }
596     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_GID);
597     if (cJSON_IsNumber(item)) {
598         bundleInfo->gid = item->valueint;
599     }
600     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_COMPATIBLEAPI);
601     if (cJSON_IsNumber(item)) {
602         bundleInfo->compatibleApi = item->valueint;
603     }
604     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_TARGETAPI);
605     if (cJSON_IsNumber(item)) {
606         bundleInfo->targetApi = item->valueint;
607     }
608     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_VERSIONNAME);
609     if (!cJSON_IsString(item) || !BundleInfoUtils::SetBundleInfoVersionName(bundleInfo, item->valuestring)) {
610         return false;
611     }
612     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_BUNDLENAME);
613     if (!cJSON_IsString(item) || !BundleInfoUtils::SetBundleInfoBundleName(bundleInfo, item->valuestring)) {
614         return false;
615     }
616     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_LABLE);
617     if (cJSON_IsString(item) && !BundleInfoUtils::SetBundleInfoLabel(bundleInfo, item->valuestring)) {
618         return false;
619     }
620     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_ICONPATH);
621     if (cJSON_IsString(item) && !BundleInfoUtils::SetBundleInfoBigIconPath(bundleInfo, item->valuestring)) {
622         return false;
623     }
624     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_CODEPATH);
625     if (!cJSON_IsString(item) || !BundleInfoUtils::SetBundleInfoCodePath(bundleInfo, item->valuestring)) {
626         return false;
627     }
628     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_DATAPATH);
629     if (!cJSON_IsString(item) || !BundleInfoUtils::SetBundleInfoDataPath(bundleInfo, item->valuestring)) {
630         return false;
631     }
632     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_VENDOR);
633     if (cJSON_IsString(item) && !BundleInfoUtils::SetBundleInfoVendor(bundleInfo, item->valuestring)) {
634         return false;
635     }
636     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_APPID);
637     if (!cJSON_IsString(item) || !BundleInfoUtils::SetBundleInfoAppId(bundleInfo, item->valuestring)) {
638         return false;
639     }
640     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_NUMOFMODULE);
641     if (cJSON_IsNumber(item) && item->valueint > 0) {
642         bundleInfo->numOfModule = item->valueint;
643         if (!ConvertJsonToModuleInfos(cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_MODULEINFOS),
644             &(bundleInfo->moduleInfos), bundleInfo->numOfModule)) {
645             return false;
646         }
647     }
648     item = cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_NUMOFABILITY);
649     if (cJSON_IsNumber(item) && item->valueint > 0) {
650         bundleInfo->numOfAbility = item->valueint;
651         if (!ConvertJsonToAbilityInfos(cJSON_GetObjectItem(root, BUNDLEINFO_JSON_KEY_ABILITYINFOS),
652             &(bundleInfo->abilityInfos), bundleInfo->numOfAbility)) {
653             return false;
654         }
655     }
656     return true;
657 }
658 
ConvertJsonToMetaData(const cJSON * metaDataArray,MetaData ** metaData)659 bool ConvertUtils::ConvertJsonToMetaData(const cJSON *metaDataArray, MetaData **metaData)
660 {
661     if (metaData == nullptr || !cJSON_IsArray(metaDataArray) || cJSON_GetArraySize(metaDataArray) > METADATA_SIZE) {
662         return false;
663     }
664     ModuleInfoUtils::ClearModuleInfoMetaData(metaData, METADATA_SIZE);
665     cJSON *metaDataItem = nullptr;
666     uint32_t index = 0;
667     cJSON_ArrayForEach(metaDataItem, metaDataArray) {
668         metaData[index] = reinterpret_cast<MetaData *>(AdapterMalloc(sizeof(MetaData)));
669         if (metaData[index] == nullptr) {
670             return false;
671         }
672         int32_t ret = memset_s(metaData[index], sizeof(MetaData), 0, sizeof(MetaData));
673         if (ret != EOK) {
674             AdapterFree(metaData[index]);
675             return false;
676         }
677         cJSON *item = cJSON_GetObjectItem(metaDataItem, MODULEINFO_JSON_KEY_METADATA_NAME);
678         if (cJSON_IsString(item) && (metaData[index]->name = Utils::Strdup(item->valuestring)) == nullptr) {
679             return false;
680         }
681         item = cJSON_GetObjectItem(metaDataItem, MODULEINFO_JSON_KEY_METADATA_VALUE);
682         if (cJSON_IsString(item) && (metaData[index]->value = Utils::Strdup(item->valuestring)) == nullptr) {
683             return false;
684         }
685         item = cJSON_GetObjectItem(metaDataItem, MODULEINFO_JSON_KEY_METADATA_EXTRA);
686         if (cJSON_IsString(item) && (metaData[index]->extra = Utils::Strdup(item->valuestring)) == nullptr) {
687             return false;
688         }
689         ++index;
690     }
691     return true;
692 }
693 
ConvertJsonToDeviceType(const cJSON * deviceTypeArray,char ** deviceType)694 bool ConvertUtils::ConvertJsonToDeviceType(const cJSON *deviceTypeArray, char **deviceType)
695 {
696     if (deviceType == nullptr || !cJSON_IsArray(deviceTypeArray) ||
697         cJSON_GetArraySize(deviceTypeArray) > DEVICE_TYPE_SIZE) {
698         return false;
699     }
700     ModuleInfoUtils::ClearModuleInfoDeviceType(deviceType, DEVICE_TYPE_SIZE);
701     cJSON *deviceTypeItem = nullptr;
702     uint32_t index = 0;
703     cJSON_ArrayForEach(deviceTypeItem, deviceTypeArray) {
704         if (!cJSON_IsString(deviceTypeItem)) {
705             return false;
706         }
707         deviceType[index] = Utils::Strdup(deviceTypeItem->valuestring);
708         if (deviceType[index] == nullptr) {
709             return false;
710         }
711         ++index;
712     }
713     return true;
714 }
715 
ConvertJsonToModuleInfos(const cJSON * moduleArray,ModuleInfo ** moduleInfos,uint32_t numOfModule)716 bool ConvertUtils::ConvertJsonToModuleInfos(const cJSON *moduleArray, ModuleInfo **moduleInfos, uint32_t numOfModule)
717 {
718     if (moduleInfos == nullptr || !cJSON_IsArray(moduleArray) || numOfModule == 0 ||
719         static_cast<uint32_t>(cJSON_GetArraySize(moduleArray)) != numOfModule) {
720         return false;
721     }
722 
723     *moduleInfos = reinterpret_cast<ModuleInfo*>(AdapterMalloc(sizeof(ModuleInfo) * numOfModule));
724     if (*moduleInfos == nullptr) {
725         return false;
726     }
727 
728     int32_t ret = memset_s(*moduleInfos, sizeof(ModuleInfo) * numOfModule, 0, sizeof(ModuleInfo) * numOfModule);
729     if (ret != EOK) {
730         AdapterFree(*moduleInfos);
731         return false;
732     }
733     cJSON *moduleItem = nullptr;
734     uint32_t index = 0;
735     cJSON_ArrayForEach(moduleItem, moduleArray) {
736         cJSON *item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_NAME);
737         if (cJSON_IsString(item) && !ModuleInfoUtils::SetModuleInfoName(*moduleInfos + index, item->valuestring)) {
738             return false;
739         }
740         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_DESCRIPTION);
741         if (cJSON_IsString(item) &&
742             !ModuleInfoUtils::SetModuleInfoDescription(*moduleInfos + index, item->valuestring)) {
743             return false;
744         }
745         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_MODULENAME);
746         if (!cJSON_IsString(item) ||
747             !ModuleInfoUtils::SetModuleInfoModuleName(*moduleInfos + index, item->valuestring)) {
748             return false;
749         }
750         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_MODULETYPE);
751         if (!cJSON_IsString(item) ||
752             !ModuleInfoUtils::SetModuleInfoModuleType(*moduleInfos + index, item->valuestring)) {
753             return false;
754         }
755         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_DELIVERYINSTALL);
756         if (cJSON_IsBool(item)) {
757             (*moduleInfos + index)->isDeliveryInstall = cJSON_IsTrue(item);
758         }
759         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_METADATA);
760         if (cJSON_IsArray(item) && !ConvertJsonToMetaData(item, (*moduleInfos + index)->metaData)) {
761             return false;
762         }
763         item = cJSON_GetObjectItem(moduleItem, MODULEINFO_JSON_KEY_DEVICETYPE);
764         if (!cJSON_IsArray(item) || !ConvertJsonToDeviceType(item, (*moduleInfos + index)->deviceType)) {
765             return false;
766         }
767     }
768     return true;
769 }
770 
ConvertJsonToAbilityInfo(const cJSON * root,AbilityInfo * abilityInfo)771 bool ConvertUtils::ConvertJsonToAbilityInfo(const cJSON *root, AbilityInfo *abilityInfo)
772 {
773     if (root == nullptr || abilityInfo == nullptr) {
774         return false;
775     }
776 
777     cJSON *item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_BUNDLENAME);
778     if (!cJSON_IsString(item) || !AbilityInfoUtils::SetAbilityInfoBundleName(abilityInfo, item->valuestring)) {
779         return false;
780     }
781     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_NAME);
782     if (!cJSON_IsString(item) || !AbilityInfoUtils::SetAbilityInfoName(abilityInfo, item->valuestring)) {
783         return false;
784     }
785     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_ABILITYTYPE);
786     if (cJSON_IsNumber(item)) {
787         abilityInfo->abilityType = AbilityType(item->valueint);
788     }
789     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_LAUNCHMODE);
790     if (cJSON_IsNumber(item)) {
791         abilityInfo->launchMode = LaunchMode(item->valueint);
792     }
793     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_VISIBLE);
794     abilityInfo->isVisible = cJSON_IsTrue(item);
795     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_MODULENAME);
796     if (!cJSON_IsString(item) || !AbilityInfoUtils::SetAbilityInfoModuleName(abilityInfo, item->valuestring)) {
797         return false;
798     }
799     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_DESCRIPTION);
800     if (cJSON_IsString(item) && !AbilityInfoUtils::SetAbilityInfoDescription(abilityInfo, item->valuestring)) {
801         return false;
802     }
803     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_ICONPATH);
804     if (cJSON_IsString(item) && !AbilityInfoUtils::SetAbilityInfoIconPath(abilityInfo, item->valuestring)) {
805         return false;
806     }
807     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_DEVICEID);
808     if (cJSON_IsString(item) && !AbilityInfoUtils::SetAbilityInfoDeviceId(abilityInfo, item->valuestring)) {
809         return false;
810     }
811     item = cJSON_GetObjectItem(root, ABILITYINFO_JSON_KEY_LABEL);
812     if (cJSON_IsString(item) && !AbilityInfoUtils::SetAbilityInfoLabel(abilityInfo, item->valuestring)) {
813         return false;
814     }
815     return true;
816 }
817 
ConvertJsonToAbilityInfos(const cJSON * abilityArray,AbilityInfo ** abilityInfos,uint32_t numOfAbility)818 bool ConvertUtils::ConvertJsonToAbilityInfos(const cJSON *abilityArray, AbilityInfo **abilityInfos,
819     uint32_t numOfAbility)
820 {
821     if (abilityInfos == nullptr || !cJSON_IsArray(abilityArray) || numOfAbility == 0 ||
822         static_cast<uint32_t>(cJSON_GetArraySize(abilityArray)) != numOfAbility) {
823         return false;
824     }
825 
826     *abilityInfos = reinterpret_cast<AbilityInfo*>(AdapterMalloc(sizeof(AbilityInfo) * numOfAbility));
827     if (*abilityInfos == nullptr) {
828         return false;
829     }
830 
831     int32_t ret = memset_s(*abilityInfos, sizeof(AbilityInfo) * numOfAbility, 0,
832         sizeof(AbilityInfo) * numOfAbility);
833     if (ret != EOK) {
834         AdapterFree(*abilityInfos);
835         *abilityInfos = nullptr;
836         return false;
837     }
838 
839     cJSON *arrayItem = nullptr;
840     uint32_t index = 0;
841     cJSON_ArrayForEach(arrayItem, abilityArray) {
842         if (!ConvertJsonToAbilityInfo(arrayItem, *abilityInfos + index)) {
843             return false;
844         }
845         ++index;
846     }
847     return true;
848 }
849 } // OHOS