1 /*
2  * Copyright (c) 2024 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 <cstdint>
17 #include <string>
18 
19 #include "bundle_manager_utils.h"
20 #include "ipc_skeleton.h"
21 #include "bundle_info.h"
22 #include "bundle_mgr_proxy.h"
23 #include "common_func.h"
24 #include "bundle_manager_convert.h"
25 #include "bundle_manager_log.h"
26 
27 namespace OHOS {
28 namespace CJSystemapi {
29 namespace BundleManager {
30 namespace Convert {
31 
MallocCString(const std::string & origin)32 char *MallocCString(const std::string &origin)
33 {
34     if (origin.empty()) {
35         return nullptr;
36     }
37     auto len = origin.length() + 1;
38     char* res = static_cast<char *>(malloc(sizeof(char) * len));
39     if (res == nullptr) {
40         LOGE("MallocCString malloc failed");
41         return nullptr;
42     }
43     return std::char_traits<char>::copy(res, origin.c_str(), len);
44 }
45 
ClearCharPointer(char ** ptr,int count)46 void ClearCharPointer(char** ptr, int count)
47 {
48     for (int i = 0; i < count; i++) {
49         free(ptr[i]);
50         ptr[i] = nullptr;
51     }
52 }
53 
ConvertArrString(std::vector<std::string> vecStr)54 CArrString ConvertArrString(std::vector<std::string> vecStr)
55 {
56     char **retValue = static_cast<char **>(malloc(sizeof(char *) * vecStr.size()));
57     if (retValue == nullptr) {
58         return {nullptr, 0};
59     }
60 
61     for (size_t i = 0; i < vecStr.size(); i++) {
62         retValue[i] = MallocCString(vecStr[i]);
63         if (retValue[i] == nullptr) {
64             ClearCharPointer(retValue, i);
65             free(retValue);
66             return {nullptr, 0};
67         }
68     }
69 
70     return {retValue, vecStr.size()};
71 }
72 
ConvertUsedScene(AppExecFwk::RequestPermissionUsedScene usedScence)73 RetUsedScene ConvertUsedScene(AppExecFwk::RequestPermissionUsedScene usedScence)
74 {
75     RetUsedScene uScene;
76     uScene.abilities = ConvertArrString(usedScence.abilities);
77     uScene.when = MallocCString(usedScence.when);
78     return uScene;
79 }
80 
ConvertMetadata(AppExecFwk::Metadata cdata)81 RetMetadata ConvertMetadata(AppExecFwk::Metadata cdata)
82 {
83     RetMetadata data;
84     data.name = MallocCString(cdata.name);
85     data.value = MallocCString(cdata.value);
86     data.resource = MallocCString(cdata.resource);
87     return data;
88 }
89 
ConvertResource(AppExecFwk::Resource cres)90 CResource ConvertResource(AppExecFwk::Resource cres)
91 {
92     CResource res;
93     res.bundleName = MallocCString(cres.bundleName);
94     res.moduleName = MallocCString(cres.moduleName);
95     res.id = cres.id;
96     return res;
97 }
98 
ConvertArrMetadata(std::vector<AppExecFwk::Metadata> cdata)99 CArrMetadata ConvertArrMetadata(std::vector<AppExecFwk::Metadata> cdata)
100 {
101     CArrMetadata data;
102     data.size = static_cast<int64_t>(cdata.size());
103     data.head = nullptr;
104     if (data.size > 0) {
105         RetMetadata *retValue = reinterpret_cast<RetMetadata *>(malloc(sizeof(RetMetadata) * data.size));
106         if (retValue != nullptr) {
107             for (int32_t i = 0; i < data.size; i++) {
108                 retValue[i] = ConvertMetadata(cdata[i]);
109             }
110             data.head = retValue;
111         } else {
112             LOGE("ConvertArrMetadata malloc failed");
113             return data;
114         }
115     }
116     return data;
117 }
118 
ConvertArrMoMeta(std::map<std::string,std::vector<AppExecFwk::Metadata>> metadata)119 CArrMoMeta ConvertArrMoMeta(std::map<std::string, std::vector<AppExecFwk::Metadata>> metadata)
120 {
121     CArrMoMeta arrMdata;
122     arrMdata.size = static_cast<int64_t>(metadata.size());
123     arrMdata.head = nullptr;
124     if (arrMdata.size > 0) {
125         ModuleMetadata* retValue = reinterpret_cast<ModuleMetadata *>(malloc(sizeof(ModuleMetadata) * arrMdata.size));
126         if (retValue != nullptr) {
127             int32_t i = 0;
128             for (const auto &item : metadata) {
129                 retValue[i].moduleName = MallocCString(item.first);
130                 retValue[i++].metadata = ConvertArrMetadata(item.second);
131             }
132         } else {
133             LOGE("ConvertArrMoMeta malloc failed");
134             return arrMdata;
135         }
136         arrMdata.head = retValue;
137     }
138     return arrMdata;
139 }
140 
141 
ConvertRequestPermission(AppExecFwk::RequestPermission requestPermission)142 RetReqPermissionDetail ConvertRequestPermission(AppExecFwk::RequestPermission requestPermission)
143 {
144     RetReqPermissionDetail reqPer;
145     reqPer.name = MallocCString(requestPermission.name);
146     reqPer.moduleName = MallocCString(requestPermission.moduleName);
147     reqPer.reason = MallocCString(requestPermission.reason);
148     reqPer.reasonId = requestPermission.reasonId;
149     reqPer.usedScence = ConvertUsedScene(requestPermission.usedScene);
150     return reqPer;
151 }
152 
ConvertApplicationInfo(AppExecFwk::ApplicationInfo cAppInfo)153 RetApplicationInfo ConvertApplicationInfo(AppExecFwk::ApplicationInfo cAppInfo)
154 {
155     RetApplicationInfo appInfo;
156     appInfo.name = MallocCString(cAppInfo.name);
157     appInfo.description = MallocCString(cAppInfo.description);
158     appInfo.descriptionId = cAppInfo.descriptionId;
159     appInfo.enabled = cAppInfo.enabled;
160     appInfo.label = MallocCString(cAppInfo.label);
161     appInfo.labelId = cAppInfo.labelId;
162     appInfo.icon = MallocCString(cAppInfo.iconPath);
163     appInfo.iconId = cAppInfo.iconId;
164     appInfo.process = MallocCString(cAppInfo.process);
165 
166     appInfo.permissions = ConvertArrString(cAppInfo.permissions);
167 
168     appInfo.codePath = MallocCString(cAppInfo.codePath);
169 
170     appInfo.metadataArray = ConvertArrMoMeta(cAppInfo.metadata);
171 
172     appInfo.removable = cAppInfo.removable;
173     appInfo.accessTokenId = cAppInfo.accessTokenId;
174     appInfo.uid = cAppInfo.uid;
175 
176     appInfo.iconResource = ConvertResource(cAppInfo.iconResource);
177     appInfo.labelResource = ConvertResource(cAppInfo.labelResource);
178     appInfo.descriptionResource = ConvertResource(cAppInfo.descriptionResource);
179 
180     appInfo.appDistributionType = MallocCString(cAppInfo.appDistributionType);
181     appInfo.appProvisionType = MallocCString(cAppInfo.appProvisionType);
182     appInfo.systemApp = cAppInfo.isSystemApp;
183     appInfo.bundleType = static_cast<int32_t>(cAppInfo.bundleType);
184     appInfo.debug = cAppInfo.debug;
185     appInfo.dataUnclearable = !cAppInfo.userDataClearable;
186     appInfo.cloudFileSyncEnabled = cAppInfo.cloudFileSyncEnabled;
187     return appInfo;
188 }
189 
ConvertExtensionAbilityInfo(AppExecFwk::ExtensionAbilityInfo extensionInfos)190 RetExtensionAbilityInfo ConvertExtensionAbilityInfo(AppExecFwk::ExtensionAbilityInfo extensionInfos)
191 {
192     RetExtensionAbilityInfo exInfo;
193     exInfo.bundleName = MallocCString(extensionInfos.bundleName);
194     exInfo.moduleName = MallocCString(extensionInfos.moduleName);
195     exInfo.name = MallocCString(extensionInfos.name);
196     exInfo.labelId = extensionInfos.labelId;
197     exInfo.descriptionId = extensionInfos.descriptionId;
198     exInfo.iconId = extensionInfos.iconId;
199     exInfo.exported = extensionInfos.visible;
200     exInfo.extensionAbilityType = static_cast<int32_t>(extensionInfos.type);
201     exInfo.permissions = ConvertArrString(extensionInfos.permissions);
202     exInfo.applicationInfo = ConvertApplicationInfo(extensionInfos.applicationInfo);
203     exInfo.metadata = ConvertArrMetadata(extensionInfos.metadata);
204     exInfo.enabled = extensionInfos.enabled;
205     exInfo.readPermission = MallocCString(extensionInfos.readPermission);
206     exInfo.writePermission = MallocCString(extensionInfos.writePermission);
207     exInfo.extensionAbilityTypeName = MallocCString(extensionInfos.extensionTypeName);
208     return exInfo;
209 }
210 
ConvertArrExtensionAbilityInfo(std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos)211 CArrRetExtensionAbilityInfo ConvertArrExtensionAbilityInfo(
212     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos)
213 {
214     CArrRetExtensionAbilityInfo exAbInfo;
215     exAbInfo.size = static_cast<int64_t>(extensionInfos.size());
216     exAbInfo.head = nullptr;
217     if (exAbInfo.size > 0) {
218         RetExtensionAbilityInfo *retValue = reinterpret_cast<RetExtensionAbilityInfo *>
219         (malloc(sizeof(RetExtensionAbilityInfo) * exAbInfo.size));
220         if (retValue != nullptr) {
221             for (int32_t i = 0; i < exAbInfo.size; i++) {
222                 retValue[i] = ConvertExtensionAbilityInfo(extensionInfos[i]);
223             }
224             exAbInfo.head = retValue;
225         } else {
226             LOGE("ConvertArrExtensionAbilityInfo malloc failed");
227             return exAbInfo;
228         }
229     }
230     return exAbInfo;
231 }
232 
ConvertSignatureInfo(AppExecFwk::SignatureInfo cSignatureInfo)233 RetSignatureInfo ConvertSignatureInfo(AppExecFwk::SignatureInfo cSignatureInfo)
234 {
235     RetSignatureInfo signatureInfo;
236     signatureInfo.appId = MallocCString(cSignatureInfo.appId);
237     signatureInfo.fingerprint = MallocCString(cSignatureInfo.fingerprint);
238     signatureInfo.appIdentifier = MallocCString(cSignatureInfo.appIdentifier);
239     return signatureInfo;
240 }
241 
ConvertAbilityInfo(AppExecFwk::AbilityInfo cAbilityInfos)242 RetAbilityInfo ConvertAbilityInfo(AppExecFwk::AbilityInfo cAbilityInfos)
243 {
244     RetAbilityInfo abInfo;
245     abInfo.bundleName = MallocCString(cAbilityInfos.bundleName);
246     abInfo.moduleName = MallocCString(cAbilityInfos.moduleName);
247     abInfo.name = MallocCString(cAbilityInfos.name);
248     abInfo.label = MallocCString(cAbilityInfos.label);
249     abInfo.labelId = cAbilityInfos.labelId;
250     abInfo.description = MallocCString(cAbilityInfos.description);
251     abInfo.descriptionId = cAbilityInfos.descriptionId;
252     abInfo.icon = MallocCString(cAbilityInfos.iconPath);
253     abInfo.iconId = cAbilityInfos.iconId;
254     abInfo.process = MallocCString(cAbilityInfos.process);
255     abInfo.exported = cAbilityInfos.visible;
256     abInfo.orientation = static_cast<int32_t>(cAbilityInfos.orientation);
257     abInfo.launchType = static_cast<int32_t>(cAbilityInfos.launchMode);
258     abInfo.permissions = ConvertArrString(cAbilityInfos.permissions);
259     abInfo.deviceTypes = ConvertArrString(cAbilityInfos.deviceTypes);
260     abInfo.applicationInfo = ConvertApplicationInfo(cAbilityInfos.applicationInfo);
261     abInfo.metadata = ConvertArrMetadata(cAbilityInfos.metadata);
262     abInfo.enabled = cAbilityInfos.enabled;
263 
264     abInfo.supportWindowModes.size = static_cast<int64_t>(cAbilityInfos.windowModes.size());
265     abInfo.supportWindowModes.head = nullptr;
266     if (abInfo.supportWindowModes.size > 0) {
267         int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * abInfo.supportWindowModes.size));
268         if (retValue != nullptr) {
269             for (int32_t i = 0; i < abInfo.supportWindowModes.size; i++) {
270                 retValue[i] = static_cast<int32_t>(cAbilityInfos.windowModes[i]);
271             }
272             abInfo.supportWindowModes.head = retValue;
273         } else {
274             LOGE("ConvertAbilityInfo malloc failed");
275             return abInfo;
276         }
277     }
278 
279     abInfo.windowSize.maxWindowRatio = cAbilityInfos.maxWindowRatio;
280     abInfo.windowSize.minWindowRatio = cAbilityInfos.minWindowRatio;
281     abInfo.windowSize.maxWindowWidth = cAbilityInfos.maxWindowWidth;
282     abInfo.windowSize.minWindowWidth = cAbilityInfos.minWindowWidth;
283     abInfo.windowSize.maxWindowHeight = cAbilityInfos.maxWindowHeight;
284     abInfo.windowSize.minWindowHeight = cAbilityInfos.minWindowHeight;
285     return abInfo;
286 }
287 
ConvertArrAbilityInfo(std::vector<AppExecFwk::AbilityInfo> abilityInfos)288 CArrRetAbilityInfo ConvertArrAbilityInfo(std::vector<AppExecFwk::AbilityInfo> abilityInfos)
289 {
290     CArrRetAbilityInfo abInfo;
291     abInfo.size = static_cast<int64_t>(abilityInfos.size());
292     abInfo.head = nullptr;
293     if (abInfo.size > 0) {
294         RetAbilityInfo *retValue = reinterpret_cast<RetAbilityInfo *>(malloc(sizeof(RetAbilityInfo) * abInfo.size));
295         if (retValue != nullptr) {
296             for (int32_t i = 0; i < abInfo.size; i++) {
297                 retValue[i] = ConvertAbilityInfo(abilityInfos[i]);
298             }
299             abInfo.head = retValue;
300         } else {
301             LOGE("ConvertArrAbilityInfo malloc failed");
302             return abInfo;
303         }
304     }
305     return abInfo;
306 }
307 
ConvertPreloadItem(std::vector<AppExecFwk::PreloadItem> preloads)308 CArrRetPreloadItem ConvertPreloadItem(std::vector<AppExecFwk::PreloadItem> preloads)
309 {
310     CArrRetPreloadItem pLoad;
311     pLoad.size = static_cast<int64_t>(preloads.size());
312     pLoad.head = nullptr;
313     if (pLoad.size > 0) {
314         RetPreloadItem *retValue = reinterpret_cast<RetPreloadItem *>(malloc(sizeof(RetPreloadItem) * pLoad.size));
315         if (retValue != nullptr) {
316             for (int32_t i = 0; i < pLoad.size; i++) {
317                 retValue[i].moduleName = MallocCString(preloads[i].moduleName);
318             }
319             pLoad.head = retValue;
320         } else {
321             LOGE("ConvertPreloadItem malloc failed");
322             return pLoad;
323         }
324     }
325     return pLoad;
326 }
327 
ConvertDependency(std::vector<AppExecFwk::Dependency> dependencies)328 CArrRetDependency ConvertDependency(std::vector<AppExecFwk::Dependency> dependencies)
329 {
330     CArrRetDependency dep;
331     dep.size = static_cast<int64_t>(dependencies.size());
332     dep.head = nullptr;
333     if (dep.size > 0) {
334         RetDependency *retValue = reinterpret_cast<RetDependency *>(malloc(sizeof(RetDependency) * dep.size));
335         if (retValue != nullptr) {
336             for (int32_t i = 0; i < dep.size; i++) {
337                 retValue[i].bundleName = MallocCString(dependencies[i].bundleName);
338                 retValue[i].moduleName = MallocCString(dependencies[i].moduleName);
339                 retValue[i].versionCode = dependencies[i].versionCode;
340             }
341             dep.head = retValue;
342         } else {
343             LOGE("ConvertDependency malloc failed");
344             return dep;
345         }
346     }
347     return dep;
348 }
349 
350 
ConvertHapModuleInfo(AppExecFwk::HapModuleInfo hapModuleInfo)351 RetHapModuleInfo ConvertHapModuleInfo(AppExecFwk::HapModuleInfo hapModuleInfo)
352 {
353     RetHapModuleInfo hapInfo;
354     hapInfo.name = MallocCString(hapModuleInfo.name);
355     hapInfo.icon = MallocCString(hapModuleInfo.iconPath);
356     hapInfo.iconId = hapModuleInfo.iconId;
357     hapInfo.label = MallocCString(hapModuleInfo.label);
358     hapInfo.labelId = hapModuleInfo.labelId;
359     hapInfo.description = MallocCString(hapModuleInfo.description);
360     hapInfo.descriptionId = hapModuleInfo.descriptionId;
361     hapInfo.mainElementName = MallocCString(hapModuleInfo.mainElementName);
362 
363     hapInfo.abilitiesInfo = ConvertArrAbilityInfo(hapModuleInfo.abilityInfos);
364 
365     hapInfo.extensionAbilitiesInfo = ConvertArrExtensionAbilityInfo(hapModuleInfo.extensionInfos);
366 
367     hapInfo.metadata = ConvertArrMetadata(hapModuleInfo.metadata);
368 
369     hapInfo.deviceTypes = ConvertArrString(hapModuleInfo.deviceTypes);
370 
371     hapInfo.installationFree = hapModuleInfo.installationFree;
372     hapInfo.hashValue = MallocCString(hapModuleInfo.hashValue);
373     hapInfo.moduleType = static_cast<int32_t>(hapModuleInfo.moduleType);
374 
375     hapInfo.preloads = ConvertPreloadItem(hapModuleInfo.preloads);
376 
377     hapInfo.dependencies = ConvertDependency(hapModuleInfo.dependencies);
378 
379     if (!hapModuleInfo.fileContextMenu.empty()) {
380         hapInfo.fileContextMenuConfig = MallocCString(hapModuleInfo.fileContextMenu);
381     } else {
382         hapInfo.fileContextMenuConfig = MallocCString("");
383     }
384     return hapInfo;
385 }
386 
ConvertArrHapInfo(std::vector<AppExecFwk::HapModuleInfo> hapModuleInfos)387 CArrHapInfo ConvertArrHapInfo(std::vector<AppExecFwk::HapModuleInfo> hapModuleInfos)
388 {
389     CArrHapInfo hapInfos;
390     hapInfos.size = static_cast<int64_t>(hapModuleInfos.size());
391     RetHapModuleInfo *retValue = reinterpret_cast<RetHapModuleInfo *>(malloc(sizeof(RetHapModuleInfo) * hapInfos.size));
392     if (retValue == nullptr) {
393         LOGE("ConvertArrHapInfo malloc failed");
394         hapInfos.head = nullptr;
395         return hapInfos;
396     }
397     for (int32_t i = 0; i < hapInfos.size; i++) {
398         retValue[i] = ConvertHapModuleInfo(hapModuleInfos[i]);
399     }
400     hapInfos.head = retValue;
401     return hapInfos;
402 }
403 
ConvertArrReqPerDetail(std::vector<AppExecFwk::RequestPermission> reqPermissionDetails)404 CArrReqPerDetail ConvertArrReqPerDetail(std::vector<AppExecFwk::RequestPermission> reqPermissionDetails)
405 {
406     CArrReqPerDetail perDetail;
407     perDetail.size = static_cast<int64_t>(reqPermissionDetails.size());
408     perDetail.head = nullptr;
409     if (perDetail.size > 0) {
410         RetReqPermissionDetail *retValue = reinterpret_cast<RetReqPermissionDetail *>
411                                             (malloc(sizeof(RetReqPermissionDetail) * perDetail.size));
412         if (retValue != nullptr) {
413             for (int32_t i = 0; i < perDetail.size; i++) {
414                 retValue[i] = ConvertRequestPermission(reqPermissionDetails[i]);
415             }
416             perDetail.head = retValue;
417         } else {
418             LOGE("ConvertArrReqPerDetail malloc failed");
419             return perDetail;
420         }
421     }
422     return perDetail;
423 }
424 
InitSignInfo()425 RetSignatureInfo InitSignInfo()
426 {
427     RetSignatureInfo signatureInfo = {nullptr, nullptr, nullptr};
428     return signatureInfo;
429 }
430 
InitApplicationInfo()431 RetApplicationInfo InitApplicationInfo()
432 {
433     RetApplicationInfo appInfo;
434     appInfo.name = nullptr;
435     appInfo.description = nullptr;
436     appInfo.descriptionId = 0;
437     appInfo.enabled = true;
438     appInfo.label = nullptr;
439     appInfo.labelId = 0;
440     appInfo.icon = nullptr;
441     appInfo.iconId = 0;
442     appInfo.process = nullptr;
443     appInfo.permissions = {nullptr, 0};
444     appInfo.codePath = nullptr;
445     appInfo.metadataArray = {nullptr, 0};
446     appInfo.removable = true;
447     appInfo.accessTokenId = 0;
448     appInfo.uid = -1;
449     appInfo.iconResource = {nullptr, nullptr, 0};
450     appInfo.labelResource = {nullptr, nullptr, 0};
451     appInfo.descriptionResource = {nullptr, nullptr, 0};
452     appInfo.appDistributionType = MallocCString("none");
453     appInfo.appProvisionType = MallocCString("release");
454     appInfo.systemApp = false;
455     appInfo.bundleType = 0;
456     appInfo.debug = false;
457     appInfo.dataUnclearable = false;
458     return appInfo;
459 }
460 
ConvertBundleInfo(AppExecFwk::BundleInfo cBundleInfo,int32_t flags)461 RetBundleInfo ConvertBundleInfo(AppExecFwk::BundleInfo cBundleInfo, int32_t flags)
462 {
463     RetBundleInfo bundleInfo;
464     bundleInfo.name = MallocCString(cBundleInfo.name);
465     bundleInfo.vendor = MallocCString(cBundleInfo.vendor);
466     bundleInfo.versionCode = cBundleInfo.versionCode;
467     bundleInfo.versionName = MallocCString(cBundleInfo.versionName);
468     bundleInfo.minCompatibleVersionCode = cBundleInfo.minCompatibleVersionCode;
469     bundleInfo.targetVersion = cBundleInfo.targetVersion;
470     if ((static_cast<uint32_t>(flags) &
471         static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
472         == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
473         bundleInfo.appInfo = ConvertApplicationInfo(cBundleInfo.applicationInfo);
474     } else {
475         bundleInfo.appInfo = InitApplicationInfo();
476     }
477 
478     bundleInfo.hapInfo = ConvertArrHapInfo(cBundleInfo.hapModuleInfos);
479     bundleInfo.perDetail = ConvertArrReqPerDetail(cBundleInfo.reqPermissionDetails);
480 
481     bundleInfo.state.size = static_cast<int64_t>(cBundleInfo.reqPermissionStates.size());
482     if (bundleInfo.state.size > 0) {
483         int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * bundleInfo.state.size));
484         if (retValue != nullptr) {
485             for (int32_t i = 0; i < bundleInfo.state.size; i++) {
486                 retValue[i] = static_cast<int32_t>(cBundleInfo.reqPermissionStates[i]);
487             }
488             bundleInfo.state.head = retValue;
489         } else {
490             LOGE("ConvertBundleInfo malloc failed");
491             bundleInfo.state.head = nullptr;
492             return bundleInfo;
493         }
494     }
495 
496     if ((static_cast<uint32_t>(flags) &
497         static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
498         == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
499         bundleInfo.signInfo = ConvertSignatureInfo(cBundleInfo.signatureInfo);
500     } else {
501         bundleInfo.signInfo = InitSignInfo();
502     }
503     bundleInfo.installTime = cBundleInfo.installTime;
504     bundleInfo.updateTime = cBundleInfo.updateTime;
505     bundleInfo.uid = cBundleInfo.uid;
506     return bundleInfo;
507 }
508 
509 } // Convert
510 } // BundleManager
511 } // CJSystemapi
512 } // OHOS