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 "service_info.h"
17
18 #include "parcel_macro.h"
19 #include "string_ex.h"
20
21 namespace OHOS {
22 namespace AbilityRuntime {
23 constexpr int32_t CYCLE_LIMIT = 1000;
ReadFromParcel(Parcel & parcel)24 bool AppInfo::ReadFromParcel(Parcel &parcel)
25 {
26 bundleName = Str16ToStr8(parcel.ReadString16());
27 iconId = parcel.ReadInt32();
28 labelId = parcel.ReadInt32();
29 descriptionId = parcel.ReadInt32();
30 return true;
31 }
32
Marshalling(Parcel & parcel) const33 bool AppInfo::Marshalling(Parcel &parcel) const
34 {
35 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
36 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, iconId);
37 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, labelId);
38 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, descriptionId);
39 return true;
40 }
41
Unmarshalling(Parcel & parcel)42 AppInfo *AppInfo::Unmarshalling(Parcel &parcel)
43 {
44 AppInfo *info = new (std::nothrow) AppInfo();
45 if (info && !info->ReadFromParcel(parcel)) {
46 APP_LOGW("read from parcel failed");
47 delete info;
48 info = nullptr;
49 }
50 return info;
51 }
52
ReadFromParcel(Parcel & parcel)53 bool BusinessAbilityFilter::ReadFromParcel(Parcel &parcel)
54 {
55 businessType = static_cast<BusinessType>(parcel.ReadInt32());
56 mimeType = Str16ToStr8(parcel.ReadString16());
57 uri = Str16ToStr8(parcel.ReadString16());
58 return true;
59 }
60
Marshalling(Parcel & parcel) const61 bool BusinessAbilityFilter::Marshalling(Parcel &parcel) const
62 {
63 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(businessType));
64 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mimeType));
65 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri));
66 return true;
67 }
68
Unmarshalling(Parcel & parcel)69 BusinessAbilityFilter *BusinessAbilityFilter::Unmarshalling(Parcel &parcel)
70 {
71 BusinessAbilityFilter *filter = new (std::nothrow) BusinessAbilityFilter();
72 if (filter && !filter->ReadFromParcel(parcel)) {
73 APP_LOGW("read from parcel failed");
74 delete filter;
75 filter = nullptr;
76 }
77 return filter;
78 }
79
ReadFromParcel(Parcel & parcel)80 bool BusinessAbilityInfo::ReadFromParcel(Parcel &parcel)
81 {
82 std::unique_ptr<AppInfo> app(parcel.ReadParcelable<AppInfo>());
83 if (!app) {
84 APP_LOGE("ReadParcelable<AppInfo> failed");
85 return false;
86 }
87 appInfo = *app;
88 bundleName = Str16ToStr8(parcel.ReadString16());
89 moduleName = Str16ToStr8(parcel.ReadString16());
90 abilityName = Str16ToStr8(parcel.ReadString16());
91 businessType = static_cast<BusinessType>(parcel.ReadInt32());
92 iconId = parcel.ReadInt32();
93 labelId = parcel.ReadInt32();
94 descriptionId = parcel.ReadInt32();
95
96 int32_t size;
97 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, size);
98 CONTAINER_SECURITY_VERIFY(parcel, size, &permissions);
99 if (size > CYCLE_LIMIT) {
100 APP_LOGE("size is too large.");
101 return false;
102 }
103 for (int32_t i = 0; i < size; i++) {
104 permissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
105 }
106
107 return true;
108 }
109
Marshalling(Parcel & parcel) const110 bool BusinessAbilityInfo::Marshalling(Parcel &parcel) const
111 {
112 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &appInfo);
113 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
114 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
115 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(abilityName));
116 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(businessType));
117 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, iconId);
118 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, labelId);
119 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, descriptionId);
120 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissions.size());
121 for (auto &permission : permissions) {
122 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(permission));
123 }
124 return true;
125 }
126
Unmarshalling(Parcel & parcel)127 BusinessAbilityInfo *BusinessAbilityInfo::Unmarshalling(Parcel &parcel)
128 {
129 BusinessAbilityInfo *info = new (std::nothrow) BusinessAbilityInfo();
130 if (info && !info->ReadFromParcel(parcel)) {
131 APP_LOGW("read from parcel failed");
132 delete info;
133 info = nullptr;
134 }
135 return info;
136 }
137
ReadFromParcel(Parcel & parcel)138 bool PurposeInfo::ReadFromParcel(Parcel &parcel)
139 {
140 std::unique_ptr<AppInfo> app(parcel.ReadParcelable<AppInfo>());
141 if (!app) {
142 APP_LOGE("ReadParcelable<AppInfo> failed");
143 return false;
144 }
145 appInfo = *app;
146 purposeName = Str16ToStr8(parcel.ReadString16());
147 bundleName = Str16ToStr8(parcel.ReadString16());
148 moduleName = Str16ToStr8(parcel.ReadString16());
149 abilityName = Str16ToStr8(parcel.ReadString16());
150 cardName = Str16ToStr8(parcel.ReadString16());
151 int32_t supportDimensionSize;
152 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportDimensionSize);
153 CONTAINER_SECURITY_VERIFY(parcel, supportDimensionSize, &supportDimensions);
154 if (supportDimensionSize > CYCLE_LIMIT) {
155 APP_LOGE("supportDimensionSize is too large.");
156 return false;
157 }
158 for (int32_t i = 0; i < supportDimensionSize; i++) {
159 supportDimensions.emplace_back(parcel.ReadInt32());
160 }
161 componentType = static_cast<ComponentType>(parcel.ReadInt32());
162 return true;
163 }
164
Marshalling(Parcel & parcel) const165 bool PurposeInfo::Marshalling(Parcel &parcel) const
166 {
167 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &appInfo);
168 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(purposeName));
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(abilityName));
172 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(cardName));
173 const auto supportDimensionSize = static_cast<int32_t>(supportDimensions.size());
174 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportDimensionSize);
175 for (auto i = 0; i < supportDimensionSize; i++) {
176 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportDimensions[i]);
177 }
178 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(componentType));
179 return true;
180 }
181
Unmarshalling(Parcel & parcel)182 PurposeInfo *PurposeInfo::Unmarshalling(Parcel &parcel)
183 {
184 PurposeInfo *info = new (std::nothrow) PurposeInfo();
185 if (info && !info->ReadFromParcel(parcel)) {
186 APP_LOGW("read from parcel failed");
187 delete info;
188 info = nullptr;
189 }
190 return info;
191 }
192 } // namespace AbilityRuntime
193 } // namespace OHOS