1 /*
2  * Copyright (c) 2020-2023 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_info_utils.h"
17 
18 #include "ability_info_utils.h"
19 #include "module_info_utils.h"
20 #include "securec.h"
21 
22 namespace OHOS {
23 const uint8_t GET_BUNDLE_WITH_ABILITIES = 1;
24 
FreeBundleInfos(BundleInfo * bundleInfos,uint32_t len)25 void BundleInfoUtils::FreeBundleInfos(BundleInfo *bundleInfos, uint32_t len)
26 {
27     if (bundleInfos == nullptr) {
28         return;
29     }
30     for (uint32_t i = 0; i < len; ++i) {
31         ClearBundleInfo(bundleInfos + i);
32     }
33     AdapterFree(bundleInfos);
34 }
35 
FreeBundleInfo(BundleInfo * bundleInfo)36 void BundleInfoUtils::FreeBundleInfo(BundleInfo *bundleInfo)
37 {
38     if (bundleInfo == nullptr) {
39         return;
40     }
41     ClearBundleInfo(bundleInfo);
42     AdapterFree(bundleInfo);
43 }
44 
CopyBundleInfo(int32_t flags,BundleInfo * des,BundleInfo src)45 void BundleInfoUtils::CopyBundleInfo(int32_t flags, BundleInfo *des, BundleInfo src)
46 {
47     if (des == nullptr) {
48         return;
49     }
50 
51     SetBundleInfoBundleName(des, src.bundleName);
52     SetBundleInfoLabel(des, src.label);
53     SetBundleInfoVersionName(des, src.versionName);
54     SetBundleInfoBigIconPath(des, src.bigIconPath);
55     SetBundleInfoCodePath(des, src.codePath);
56     SetBundleInfoDataPath(des, src.dataPath);
57     SetBundleInfoVendor(des, src.vendor);
58     SetBundleInfoModuleInfos(des, src.moduleInfos, src.numOfModule);
59     des->isSystemApp = src.isSystemApp;
60     des->versionCode = src.versionCode;
61     des->compatibleApi = src.compatibleApi;
62     des->targetApi = src.targetApi;
63     SetBundleInfoAppId(des, src.appId);
64 #ifdef OHOS_APPEXECFWK_BMS_BUNDLEMANAGER
65     des->isKeepAlive = src.isKeepAlive;
66     des->isNativeApp = src.isNativeApp;
67     des->uid = src.uid;
68     des->gid = src.gid;
69     if (flags == GET_BUNDLE_WITH_ABILITIES) {
70         SetBundleInfoAbilityInfos(des, src.abilityInfos, src.numOfAbility);
71     } else {
72         des->abilityInfos = nullptr;
73         des->numOfAbility = 0;
74     }
75 #else
76     SetBundleInfoSmallIconPath(des, src.smallIconPath);
77     if (flags == GET_BUNDLE_WITH_ABILITIES) {
78         if (src.abilityInfo != nullptr) {
79             SetBundleInfoAbilityInfo(des, *(src.abilityInfo));
80         }
81     } else {
82         des->abilityInfo = nullptr;
83     }
84 #endif
85 }
86 
CopyBundleInfoNoReplication(int32_t flags,BundleInfo * des,BundleInfo src)87 void BundleInfoUtils::CopyBundleInfoNoReplication(int32_t flags, BundleInfo *des, BundleInfo src)
88 {
89     if (des == nullptr) {
90         return;
91     }
92     des->bundleName = src.bundleName;
93     des->label = src.label;
94     des->versionName = src.versionName;
95     des->bigIconPath = src.bigIconPath;
96     des->codePath = src.codePath;
97     des->dataPath = src.dataPath;
98     des->vendor = src.vendor;
99     if (src.numOfModule != 0) {
100         des->numOfModule = src.numOfModule;
101         des->moduleInfos = src.moduleInfos;
102     }
103     des->isSystemApp = src.isSystemApp;
104     des->versionCode = src.versionCode;
105     des->compatibleApi = src.compatibleApi;
106     des->targetApi = src.targetApi;
107     des->appId = src.appId;
108 #ifdef OHOS_APPEXECFWK_BMS_BUNDLEMANAGER
109     des->isKeepAlive = src.isKeepAlive;
110     des->isNativeApp = src.isNativeApp;
111     des->uid = src.uid;
112     des->gid = src.gid;
113     if (flags == GET_BUNDLE_WITH_ABILITIES) {
114         SetBundleInfoAbilityInfos(des, src.abilityInfos, src.numOfAbility);
115     } else {
116         des->abilityInfos = nullptr;
117         des->numOfAbility = 0;
118     }
119 #else
120     des->smallIconPath = src.smallIconPath;
121     if (flags == GET_BUNDLE_WITH_ABILITIES) {
122         if (src.abilityInfo != nullptr) {
123             des->abilityInfo = src.abilityInfo;
124         }
125     } else {
126         des->abilityInfo = nullptr;
127     }
128 #endif
129 }
130 
SetBundleInfoBundleName(BundleInfo * bundleInfo,const char * bundleName)131 bool BundleInfoUtils::SetBundleInfoBundleName(BundleInfo *bundleInfo, const char *bundleName)
132 {
133     if (bundleInfo == nullptr || bundleName == nullptr) {
134         return false;
135     }
136 
137     AdapterFree(bundleInfo->bundleName);
138     bundleInfo->bundleName = Utils::Strdup(bundleName);
139     return bundleInfo->bundleName != nullptr;
140 }
141 
SetBundleInfoVendor(BundleInfo * bundleInfo,const char * vendor)142 bool BundleInfoUtils::SetBundleInfoVendor(BundleInfo *bundleInfo, const char *vendor)
143 {
144     if (bundleInfo == nullptr || vendor == nullptr) {
145         return false;
146     }
147 
148     AdapterFree(bundleInfo->vendor);
149     bundleInfo->vendor = Utils::Strdup(vendor);
150     return bundleInfo->vendor != nullptr;
151 }
152 
SetBundleInfoLabel(BundleInfo * bundleInfo,const char * label)153 bool BundleInfoUtils::SetBundleInfoLabel(BundleInfo *bundleInfo, const char *label)
154 {
155     if (bundleInfo == nullptr || label == nullptr) {
156         return false;
157     }
158 
159     AdapterFree(bundleInfo->label);
160     bundleInfo->label = Utils::Strdup(label);
161     return bundleInfo->label != nullptr;
162 }
163 
SetBundleInfoVersionName(BundleInfo * bundleInfo,const char * versionName)164 bool BundleInfoUtils::SetBundleInfoVersionName(BundleInfo *bundleInfo, const char *versionName)
165 {
166     if (bundleInfo == nullptr || versionName == nullptr) {
167         return false;
168     }
169 
170     AdapterFree(bundleInfo->versionName);
171     bundleInfo->versionName = Utils::Strdup(versionName);
172     return bundleInfo->versionName != nullptr;
173 }
174 
SetBundleInfoBigIconPath(BundleInfo * bundleInfo,const char * bigIconPath)175 bool BundleInfoUtils::SetBundleInfoBigIconPath(BundleInfo *bundleInfo, const char *bigIconPath)
176 {
177     if (bundleInfo == nullptr || bigIconPath == nullptr) {
178         return false;
179     }
180 
181     AdapterFree(bundleInfo->bigIconPath);
182     bundleInfo->bigIconPath = Utils::Strdup(bigIconPath);
183     return bundleInfo->bigIconPath != nullptr;
184 }
185 
SetBundleInfoCodePath(BundleInfo * bundleInfo,const char * codePath)186 bool BundleInfoUtils::SetBundleInfoCodePath(BundleInfo *bundleInfo, const char *codePath)
187 {
188     if (bundleInfo == nullptr || codePath == nullptr) {
189         return false;
190     }
191 
192     AdapterFree(bundleInfo->codePath);
193     bundleInfo->codePath = Utils::Strdup(codePath);
194     return bundleInfo->codePath != nullptr;
195 }
196 
SetBundleInfoDataPath(BundleInfo * bundleInfo,const char * dataPath)197 bool BundleInfoUtils::SetBundleInfoDataPath(BundleInfo *bundleInfo, const char *dataPath)
198 {
199     if (bundleInfo == nullptr || dataPath == nullptr) {
200         return false;
201     }
202 
203     AdapterFree(bundleInfo->dataPath);
204     bundleInfo->dataPath = Utils::Strdup(dataPath);
205     return bundleInfo->dataPath != nullptr;
206 }
207 
SetBundleInfoModuleInfos(BundleInfo * bundleInfo,const ModuleInfo * moduleInfos,uint32_t numOfModule)208 bool BundleInfoUtils::SetBundleInfoModuleInfos(BundleInfo *bundleInfo, const ModuleInfo *moduleInfos,
209     uint32_t numOfModule)
210 {
211     if (numOfModule == 0) {
212         return true;
213     }
214 
215     if (moduleInfos == nullptr || bundleInfo == nullptr) {
216         return false;
217     }
218 
219     bundleInfo->numOfModule = numOfModule;
220     bundleInfo->moduleInfos = reinterpret_cast<ModuleInfo *>(AdapterMalloc(sizeof(ModuleInfo) * numOfModule));
221     if (bundleInfo->moduleInfos == nullptr) {
222         return false;
223     }
224 
225     int32_t ret = memset_s(bundleInfo->moduleInfos, sizeof(ModuleInfo) * numOfModule, 0,
226         sizeof(ModuleInfo) * numOfModule);
227     if (ret != EOK) {
228         AdapterFree(bundleInfo->moduleInfos);
229         return false;
230     }
231 
232     for (uint32_t i = 0; i < numOfModule; i++) {
233         ModuleInfoUtils::CopyModuleInfo(bundleInfo->moduleInfos + i, moduleInfos[i]);
234     }
235     return true;
236 }
237 
ClearModuleInfos(ModuleInfo * moduleInfos,uint32_t numOfModule)238 void BundleInfoUtils::ClearModuleInfos(ModuleInfo *moduleInfos, uint32_t numOfModule)
239 {
240     if (moduleInfos == nullptr || numOfModule == 0) {
241         return;
242     }
243 
244     for (uint32_t i = 0; i < numOfModule; i++) {
245         ClearModuleInfo(moduleInfos + i);
246     }
247 }
248 
SetBundleInfoAppId(BundleInfo * bundleInfo,const char * appId)249 bool BundleInfoUtils::SetBundleInfoAppId(BundleInfo *bundleInfo, const char *appId)
250 {
251     if (bundleInfo == nullptr || appId == nullptr) {
252         return false;
253     }
254 
255     AdapterFree(bundleInfo->appId);
256     bundleInfo->appId = Utils::Strdup(appId);
257     return bundleInfo->appId != nullptr;
258 }
259 
260 #ifdef OHOS_APPEXECFWK_BMS_BUNDLEMANAGER
SetBundleInfoAbilityInfos(BundleInfo * bundleInfo,const AbilityInfo * abilityInfos,uint32_t numOfAbility)261 bool BundleInfoUtils::SetBundleInfoAbilityInfos(BundleInfo *bundleInfo, const AbilityInfo *abilityInfos,
262     uint32_t numOfAbility)
263 {
264     if (numOfAbility == 0) {
265         return true;
266     }
267 
268     if (abilityInfos == nullptr || bundleInfo == nullptr) {
269         return false;
270     }
271 
272     bundleInfo->numOfAbility = numOfAbility;
273     bundleInfo->abilityInfos = reinterpret_cast<AbilityInfo *>(AdapterMalloc(sizeof(AbilityInfo) * numOfAbility));
274     if (bundleInfo->abilityInfos == nullptr) {
275         return false;
276     }
277     int32_t ret = memset_s(bundleInfo->abilityInfos, sizeof(AbilityInfo) * numOfAbility, 0,
278         sizeof(AbilityInfo) * numOfAbility);
279     if (ret != EOK) {
280         AdapterFree(bundleInfo->abilityInfos);
281         return false;
282     }
283 
284     for (uint32_t i = 0; i < numOfAbility; i++) {
285         AbilityInfoUtils::CopyAbilityInfo(bundleInfo->abilityInfos + i, abilityInfos[i]);
286     }
287     return true;
288 }
289 
ClearAbilityInfos(AbilityInfo * abilityInfos,uint32_t numOfAbility)290 void BundleInfoUtils::ClearAbilityInfos(AbilityInfo *abilityInfos, uint32_t numOfAbility)
291 {
292     if (abilityInfos == nullptr || numOfAbility == 0) {
293         return;
294     }
295 
296     for (uint32_t i = 0; i < numOfAbility; i++) {
297         ClearAbilityInfo(abilityInfos + i);
298     }
299 }
300 #else
SetBundleInfoSmallIconPath(BundleInfo * bundleInfo,const char * smallIconPath)301 bool BundleInfoUtils::SetBundleInfoSmallIconPath(BundleInfo *bundleInfo, const char *smallIconPath)
302 {
303     if (bundleInfo == nullptr || smallIconPath == nullptr) {
304         return false;
305     }
306 
307     AdapterFree(bundleInfo->smallIconPath);
308     bundleInfo->smallIconPath = Utils::Strdup(smallIconPath);
309     return bundleInfo->smallIconPath != nullptr;
310 }
311 
SetBundleInfoAbilityInfo(BundleInfo * bundleInfo,const AbilityInfo & abilityInfo)312 bool BundleInfoUtils::SetBundleInfoAbilityInfo(BundleInfo *bundleInfo, const AbilityInfo &abilityInfo)
313 {
314     if (bundleInfo == nullptr) {
315         return false;
316     }
317 
318     ClearAbilityInfo(bundleInfo->abilityInfo);
319     AdapterFree(bundleInfo->abilityInfo);
320     bundleInfo->abilityInfo = reinterpret_cast<AbilityInfo *>(AdapterMalloc(sizeof(AbilityInfo)));
321     if (bundleInfo->abilityInfo == nullptr ||
322         memset_s(bundleInfo->abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo)) != EOK) {
323         AdapterFree(bundleInfo->abilityInfo);
324         return false;
325     }
326 
327     AbilityInfoUtils::CopyAbilityInfo(bundleInfo->abilityInfo, abilityInfo);
328     return true;
329 }
330 
331 #ifdef _MINI_BMS_PARSE_METADATA_
SetBundleInfoAbilityInfo(BundleInfo * bundleInfo,const AbilityInfo & abilityInfo,const BundleProfile & bundleProfile)332 bool BundleInfoUtils::SetBundleInfoAbilityInfo(BundleInfo *bundleInfo, const AbilityInfo &abilityInfo,
333     const BundleProfile &bundleProfile)
334 {
335     if (bundleInfo == nullptr) {
336         return false;
337     }
338     ClearAbilityInfo(bundleInfo->abilityInfo);
339     AdapterFree(bundleInfo->abilityInfo);
340     bundleInfo->abilityInfo = reinterpret_cast<AbilityInfo *>(AdapterMalloc(sizeof(AbilityInfo)));
341     if (bundleInfo->abilityInfo ==nullptr ||
342     memset_s(bundleInfo->abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo)) != EOK) {
343         AdapterFree(bundleInfo->abilityInfo);
344         return false;
345     }
346     AbilityInfoUtils::CopyAbilityInfo(bundleInfo->abilityInfo, abilityInfo);
347     AbilityInfoUtils::CopyBundleProfileToAbilityInfo(bundleInfo->abilityInfo, bundleProfile);
348     return true;
349 }
350 #endif
351 #endif
352 } // OHOS