1 /*
2 * Copyright (c) 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 "extension_ability_info.h"
17
18 #include <fcntl.h>
19 #include <string>
20 #include <unistd.h>
21
22 #include "bundle_constants.h"
23 #include "json_util.h"
24 #include "nlohmann/json.hpp"
25 #include "parcel_macro.h"
26 #include "string_ex.h"
27
28 namespace OHOS {
29 namespace AppExecFwk {
30 namespace {
31 const std::string NAME = "name";
32 const std::string SRC_ENTRANCE = "srcEntrance";
33 const std::string ICON = "icon";
34 const std::string ICON_ID = "iconId";
35 const std::string LABEL = "label";
36 const std::string LABEL_ID = "labelId";
37 const std::string DESCRIPTION = "description";
38 const std::string DESCRIPTION_ID = "descriptionId";
39 const std::string PRIORITY = "priority";
40 const std::string TYPE = "type";
41 const std::string PERMISSIONS = "permissions";
42 const std::string READ_PERMISSION = "readPermission";
43 const std::string WRITE_PERMISSION = "writePermission";
44 const std::string URI = "uri";
45 const std::string VISIBLE = "visible";
46 const std::string META_DATA = "metadata";
47 const std::string RESOURCE_PATH = "resourcePath";
48 const std::string ENABLED = "enabled";
49 const std::string PROCESS = "process";
50 const std::string COMPILE_MODE = "compileMode";
51 const std::string UID = "uid";
52 const size_t ABILITY_CAPACITY = 10240; // 10K
53
54 const std::unordered_map<std::string, ExtensionAbilityType> EXTENSION_TYPE_MAP = {
55 { "form", ExtensionAbilityType::FORM },
56 { "workScheduler", ExtensionAbilityType::WORK_SCHEDULER },
57 { "inputMethod", ExtensionAbilityType::INPUTMETHOD },
58 { "service", ExtensionAbilityType::SERVICE },
59 { "accessibility", ExtensionAbilityType::ACCESSIBILITY },
60 { "dataShare", ExtensionAbilityType::DATASHARE },
61 { "fileShare", ExtensionAbilityType::FILESHARE },
62 { "staticSubscriber", ExtensionAbilityType::STATICSUBSCRIBER },
63 { "wallpaper", ExtensionAbilityType::WALLPAPER },
64 { "backup", ExtensionAbilityType::BACKUP },
65 { "window", ExtensionAbilityType::WINDOW },
66 { "enterpriseAdmin", ExtensionAbilityType::ENTERPRISE_ADMIN },
67 { "fileAccess", ExtensionAbilityType::FILEACCESS_EXTENSION },
68 { "thumbnail", ExtensionAbilityType::THUMBNAIL },
69 { "preview", ExtensionAbilityType::PREVIEW },
70 { "print", ExtensionAbilityType::PRINT },
71 { "share", ExtensionAbilityType::SHARE },
72 { "push", ExtensionAbilityType::PUSH },
73 { "driver", ExtensionAbilityType::DRIVER },
74 { "action", ExtensionAbilityType::ACTION },
75 { "appAccountAuthorization", ExtensionAbilityType::APP_ACCOUNT_AUTHORIZATION },
76 { "ui", ExtensionAbilityType::UI },
77 { "sysDialog/userAuth", ExtensionAbilityType::SYSDIALOG_USERAUTH },
78 { "sysDialog/common", ExtensionAbilityType::SYSDIALOG_COMMON },
79 { "sysPicker/mediaControl", ExtensionAbilityType::SYSPICKER_MEDIACONTROL },
80 { "sysDialog/atomicServicePanel", ExtensionAbilityType::SYSDIALOG_ATOMICSERVICEPANEL },
81 { "sysDialog/power", ExtensionAbilityType::SYSDIALOG_POWER },
82 { "sysPicker/share", ExtensionAbilityType::SYSPICKER_SHARE },
83 { "hms/account", ExtensionAbilityType::HMS_ACCOUNT },
84 { "sys/commonUI", ExtensionAbilityType::SYS_COMMON_UI }
85 };
86 }; // namespace
87
ReadFromParcel(Parcel & parcel)88 bool ExtensionAbilityInfo::ReadFromParcel(Parcel &parcel)
89 {
90 bundleName = Str16ToStr8(parcel.ReadString16());
91 moduleName = Str16ToStr8(parcel.ReadString16());
92 name = Str16ToStr8(parcel.ReadString16());
93 srcEntrance = Str16ToStr8(parcel.ReadString16());
94 icon = Str16ToStr8(parcel.ReadString16());
95 iconId = parcel.ReadInt32();
96 label = Str16ToStr8(parcel.ReadString16());
97 labelId = parcel.ReadInt32();
98 description = Str16ToStr8(parcel.ReadString16());
99 descriptionId = parcel.ReadInt32();
100 priority = parcel.ReadInt32();
101 int32_t permissionsSize;
102 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissionsSize);
103 CONTAINER_SECURITY_VERIFY(parcel, permissionsSize, &permissions);
104 for (auto i = 0; i < permissionsSize; i++) {
105 permissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
106 }
107 readPermission = Str16ToStr8(parcel.ReadString16());
108 writePermission = Str16ToStr8(parcel.ReadString16());
109 uri = Str16ToStr8(parcel.ReadString16());
110 type = static_cast<ExtensionAbilityType>(parcel.ReadInt32());
111 visible = parcel.ReadBool();
112
113 int32_t metadataSize;
114 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadataSize);
115 CONTAINER_SECURITY_VERIFY(parcel, metadataSize, &metadata);
116 for (auto i = 0; i < metadataSize; i++) {
117 std::unique_ptr<Metadata> meta(parcel.ReadParcelable<Metadata>());
118 if (!meta) {
119 APP_LOGE("ReadParcelable<Metadata> failed");
120 return false;
121 }
122 metadata.emplace_back(*meta);
123 }
124
125 std::unique_ptr<ApplicationInfo> appInfo(parcel.ReadParcelable<ApplicationInfo>());
126 if (!appInfo) {
127 APP_LOGE("ReadParcelable<ApplicationInfo> failed");
128 return false;
129 }
130 applicationInfo = *appInfo;
131
132 resourcePath = Str16ToStr8(parcel.ReadString16());
133 hapPath = Str16ToStr8(parcel.ReadString16());
134 enabled = parcel.ReadBool();
135 process = Str16ToStr8(parcel.ReadString16());
136 compileMode = static_cast<CompileMode>(parcel.ReadInt32());
137 uid = parcel.ReadInt32();
138 int32_t skillUriSize;
139 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUriSize);
140 CONTAINER_SECURITY_VERIFY(parcel, skillUriSize, &skillUri);
141 for (auto i = 0; i < skillUriSize; i++) {
142 SkillUriForAbilityAndExtension stctUri;
143 stctUri.scheme = Str16ToStr8(parcel.ReadString16());
144 stctUri.host = Str16ToStr8(parcel.ReadString16());
145 stctUri.port = Str16ToStr8(parcel.ReadString16());
146 stctUri.path = Str16ToStr8(parcel.ReadString16());
147 stctUri.pathStartWith = Str16ToStr8(parcel.ReadString16());
148 stctUri.pathRegex = Str16ToStr8(parcel.ReadString16());
149 stctUri.type = Str16ToStr8(parcel.ReadString16());
150 skillUri.emplace_back(stctUri);
151 }
152 return true;
153 }
154
Unmarshalling(Parcel & parcel)155 ExtensionAbilityInfo *ExtensionAbilityInfo::Unmarshalling(Parcel &parcel)
156 {
157 ExtensionAbilityInfo *info = new (std::nothrow) ExtensionAbilityInfo();
158 if (info && !info->ReadFromParcel(parcel)) {
159 APP_LOGW("read from parcel failed");
160 delete info;
161 info = nullptr;
162 }
163 return info;
164 }
165
Marshalling(Parcel & parcel) const166 bool ExtensionAbilityInfo::Marshalling(Parcel &parcel) const
167 {
168 CHECK_PARCEL_CAPACITY(parcel, ABILITY_CAPACITY);
169 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
170 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
171 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
172 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcEntrance));
173 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(icon));
174 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, iconId);
175 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
176 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, labelId);
177 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
178 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, descriptionId);
179 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, priority);
180 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissions.size());
181 for (auto &permission : permissions) {
182 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(permission));
183 }
184 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(readPermission));
185 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(writePermission));
186 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri));
187 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(type));
188 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible);
189 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadata.size());
190 for (auto &mete : metadata) {
191 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &mete);
192 }
193 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &applicationInfo);
194 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(resourcePath));
195 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapPath));
196 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enabled);
197 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(process));
198 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(compileMode));
199 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uid);
200 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUri.size());
201 for (auto &uri : skillUri) {
202 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.scheme));
203 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.host));
204 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.port));
205 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.path));
206 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathStartWith));
207 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathRegex));
208 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.type));
209 }
210 return true;
211 }
212
to_json(nlohmann::json & jsonObject,const ExtensionAbilityInfo & extensionInfo)213 void to_json(nlohmann::json &jsonObject, const ExtensionAbilityInfo &extensionInfo)
214 {
215 APP_LOGD("ExtensionAbilityInfo to_json begin");
216 jsonObject = nlohmann::json {
217 {Constants::BUNDLE_NAME, extensionInfo.bundleName},
218 {Constants::MODULE_NAME, extensionInfo.moduleName},
219 {NAME, extensionInfo.name},
220 {SRC_ENTRANCE, extensionInfo.srcEntrance},
221 {ICON, extensionInfo.icon},
222 {ICON_ID, extensionInfo.iconId},
223 {LABEL, extensionInfo.label},
224 {LABEL_ID, extensionInfo.labelId},
225 {DESCRIPTION, extensionInfo.description},
226 {DESCRIPTION_ID, extensionInfo.descriptionId},
227 {PRIORITY, extensionInfo.priority},
228 {TYPE, extensionInfo.type},
229 {READ_PERMISSION, extensionInfo.readPermission},
230 {WRITE_PERMISSION, extensionInfo.writePermission},
231 {URI, extensionInfo.uri},
232 {PERMISSIONS, extensionInfo.permissions},
233 {VISIBLE, extensionInfo.visible},
234 {META_DATA, extensionInfo.metadata},
235 {RESOURCE_PATH, extensionInfo.resourcePath},
236 {Constants::HAP_PATH, extensionInfo.hapPath},
237 {ENABLED, extensionInfo.enabled},
238 {PROCESS, extensionInfo.process},
239 {COMPILE_MODE, extensionInfo.compileMode},
240 {UID, extensionInfo.uid}
241 };
242 }
243
from_json(const nlohmann::json & jsonObject,ExtensionAbilityInfo & extensionInfo)244 void from_json(const nlohmann::json &jsonObject, ExtensionAbilityInfo &extensionInfo)
245 {
246 APP_LOGD("ExtensionAbilityInfo from_json begin");
247 const auto &jsonObjectEnd = jsonObject.end();
248 int32_t parseResult = ERR_OK;
249 GetValueIfFindKey<std::string>(jsonObject,
250 jsonObjectEnd,
251 Constants::BUNDLE_NAME,
252 extensionInfo.bundleName,
253 JsonType::STRING,
254 false,
255 parseResult,
256 ArrayType::NOT_ARRAY);
257 GetValueIfFindKey<std::string>(jsonObject,
258 jsonObjectEnd,
259 Constants::MODULE_NAME,
260 extensionInfo.moduleName,
261 JsonType::STRING,
262 false,
263 parseResult,
264 ArrayType::NOT_ARRAY);
265 GetValueIfFindKey<std::string>(jsonObject,
266 jsonObjectEnd,
267 NAME,
268 extensionInfo.name,
269 JsonType::STRING,
270 false,
271 parseResult,
272 ArrayType::NOT_ARRAY);
273 GetValueIfFindKey<std::string>(jsonObject,
274 jsonObjectEnd,
275 SRC_ENTRANCE,
276 extensionInfo.srcEntrance,
277 JsonType::STRING,
278 false,
279 parseResult,
280 ArrayType::NOT_ARRAY);
281 GetValueIfFindKey<std::string>(jsonObject,
282 jsonObjectEnd,
283 ICON,
284 extensionInfo.icon,
285 JsonType::STRING,
286 false,
287 parseResult,
288 ArrayType::NOT_ARRAY);
289 GetValueIfFindKey<int32_t>(jsonObject,
290 jsonObjectEnd,
291 ICON_ID,
292 extensionInfo.iconId,
293 JsonType::NUMBER,
294 false,
295 parseResult,
296 ArrayType::NOT_ARRAY);
297 GetValueIfFindKey<std::string>(jsonObject,
298 jsonObjectEnd,
299 LABEL,
300 extensionInfo.label,
301 JsonType::STRING,
302 false,
303 parseResult,
304 ArrayType::NOT_ARRAY);
305 GetValueIfFindKey<int32_t>(jsonObject,
306 jsonObjectEnd,
307 LABEL_ID,
308 extensionInfo.labelId,
309 JsonType::NUMBER,
310 false,
311 parseResult,
312 ArrayType::NOT_ARRAY);
313 GetValueIfFindKey<std::string>(jsonObject,
314 jsonObjectEnd,
315 DESCRIPTION,
316 extensionInfo.description,
317 JsonType::STRING,
318 false,
319 parseResult,
320 ArrayType::NOT_ARRAY);
321 GetValueIfFindKey<int32_t>(jsonObject,
322 jsonObjectEnd,
323 DESCRIPTION_ID,
324 extensionInfo.descriptionId,
325 JsonType::NUMBER,
326 false,
327 parseResult,
328 ArrayType::NOT_ARRAY);
329 GetValueIfFindKey<int32_t>(jsonObject,
330 jsonObjectEnd,
331 PRIORITY,
332 extensionInfo.priority,
333 JsonType::NUMBER,
334 false,
335 parseResult,
336 ArrayType::NOT_ARRAY);
337 GetValueIfFindKey<ExtensionAbilityType>(jsonObject,
338 jsonObjectEnd,
339 TYPE,
340 extensionInfo.type,
341 JsonType::NUMBER,
342 false,
343 parseResult,
344 ArrayType::NOT_ARRAY);
345 GetValueIfFindKey<std::string>(jsonObject,
346 jsonObjectEnd,
347 READ_PERMISSION,
348 extensionInfo.readPermission,
349 JsonType::STRING,
350 false,
351 parseResult,
352 ArrayType::NOT_ARRAY);
353 GetValueIfFindKey<std::string>(jsonObject,
354 jsonObjectEnd,
355 WRITE_PERMISSION,
356 extensionInfo.writePermission,
357 JsonType::STRING,
358 false,
359 parseResult,
360 ArrayType::NOT_ARRAY);
361 GetValueIfFindKey<std::string>(jsonObject,
362 jsonObjectEnd,
363 URI,
364 extensionInfo.uri,
365 JsonType::STRING,
366 false,
367 parseResult,
368 ArrayType::NOT_ARRAY);
369 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
370 jsonObjectEnd,
371 PERMISSIONS,
372 extensionInfo.permissions,
373 JsonType::ARRAY,
374 false,
375 parseResult,
376 ArrayType::STRING);
377 GetValueIfFindKey<bool>(jsonObject,
378 jsonObjectEnd,
379 VISIBLE,
380 extensionInfo.visible,
381 JsonType::BOOLEAN,
382 false,
383 parseResult,
384 ArrayType::NOT_ARRAY);
385 GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
386 jsonObjectEnd,
387 META_DATA,
388 extensionInfo.metadata,
389 JsonType::ARRAY,
390 false,
391 parseResult,
392 ArrayType::OBJECT);
393 GetValueIfFindKey<std::string>(jsonObject,
394 jsonObjectEnd,
395 RESOURCE_PATH,
396 extensionInfo.resourcePath,
397 JsonType::STRING,
398 false,
399 parseResult,
400 ArrayType::NOT_ARRAY);
401 GetValueIfFindKey<std::string>(jsonObject,
402 jsonObjectEnd,
403 Constants::HAP_PATH,
404 extensionInfo.hapPath,
405 JsonType::STRING,
406 false,
407 parseResult,
408 ArrayType::NOT_ARRAY);
409 GetValueIfFindKey<bool>(jsonObject,
410 jsonObjectEnd,
411 ENABLED,
412 extensionInfo.enabled,
413 JsonType::BOOLEAN,
414 false,
415 parseResult,
416 ArrayType::NOT_ARRAY);
417 GetValueIfFindKey<std::string>(jsonObject,
418 jsonObjectEnd,
419 PROCESS,
420 extensionInfo.process,
421 JsonType::STRING,
422 false,
423 parseResult,
424 ArrayType::NOT_ARRAY);
425 GetValueIfFindKey<CompileMode>(jsonObject,
426 jsonObjectEnd,
427 COMPILE_MODE,
428 extensionInfo.compileMode,
429 JsonType::NUMBER,
430 false,
431 parseResult,
432 ArrayType::NOT_ARRAY);
433 GetValueIfFindKey<int32_t>(jsonObject,
434 jsonObjectEnd,
435 UID,
436 extensionInfo.uid,
437 JsonType::NUMBER,
438 false,
439 parseResult,
440 ArrayType::NOT_ARRAY);
441 if (parseResult != ERR_OK) {
442 APP_LOGE("ExtensionAbilityInfo from_json error, error code : %{public}d", parseResult);
443 }
444 }
445
ConvertToExtensionAbilityType(const std::string & type)446 ExtensionAbilityType ConvertToExtensionAbilityType(const std::string &type)
447 {
448 if (EXTENSION_TYPE_MAP.find(type) != EXTENSION_TYPE_MAP.end()) {
449 return EXTENSION_TYPE_MAP.at(type);
450 }
451
452 return ExtensionAbilityType::UNSPECIFIED;
453 }
454
ConvertToExtensionTypeName(ExtensionAbilityType type)455 std::string ConvertToExtensionTypeName(ExtensionAbilityType type)
456 {
457 for (const auto &[key, val] : EXTENSION_TYPE_MAP) {
458 if (val == type) {
459 return key;
460 }
461 }
462
463 return "Unspecified";
464 }
465 } // namespace AppExecFwk
466 } // namespace OHOS