1 /*
2 * Copyright (c) 2022 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 "itypes_utils.h"
17
18 #include "datashare_log.h"
19
20 namespace OHOS::DataShare {
21 constexpr size_t MAX_PARAM_COUNT = 3;
Marshalling(const DataSharePredicates & predicates,Parcel & parcel)22 bool ITypesUtils::Marshalling(const DataSharePredicates &predicates, Parcel &parcel)
23 {
24 LOG_DEBUG("Marshalling DataSharePredicates Start");
25 const std::list<OperationItem> &operations = predicates.GetOperationList();
26 if (!parcel.WriteInt32(operations.size())) {
27 LOG_ERROR("predicate write size failed");
28 return false;
29 }
30 for (auto &it : operations) {
31 if (!Marshalling(it, parcel)) {
32 LOG_ERROR("predicate write OperationItem failed");
33 return false;
34 }
35 }
36 if (!parcel.WriteString(predicates.GetWhereClause())) {
37 LOG_ERROR("predicate write whereClause failed");
38 return false;
39 }
40 if (!parcel.WriteStringVector(predicates.GetWhereArgs())) {
41 LOG_ERROR("predicate write whereArgs failed");
42 return false;
43 }
44 if (!parcel.WriteString(predicates.GetOrder())) {
45 LOG_ERROR("predicate write order failed");
46 return false;
47 }
48 if (!parcel.WriteInt64(static_cast<int64_t>(predicates.GetSettingMode()))) {
49 LOG_ERROR("predicate write settingMode failed");
50 return false;
51 }
52 return true;
53 }
54
Unmarshalling(Parcel & parcel,DataSharePredicates & predicates)55 bool ITypesUtils::Unmarshalling(Parcel &parcel, DataSharePredicates &predicates)
56 {
57 LOG_DEBUG("Unmarshalling DataSharePredicates Start");
58 std::list<OperationItem> operations {};
59 std::string whereClause = "";
60 std::vector<std::string> whereArgs;
61 std::string order = "";
62 int64_t mode = INVALID_MODE;
63 size_t size = static_cast<size_t>(parcel.ReadInt32());
64 if (static_cast<int32_t>(size) < 0) {
65 LOG_ERROR("predicate read listSize failed");
66 return false;
67 }
68 if ((size > parcel.GetReadableBytes()) || (operations.max_size() < size)) {
69 LOG_ERROR("Read operations failed, size : %{public}zu", size);
70 return false;
71 }
72 operations.clear();
73 for (size_t i = 0; i < size; i++) {
74 OperationItem listitem {};
75 if (!Unmarshalling(parcel, listitem)) {
76 LOG_ERROR("operations read OperationItem failed");
77 return false;
78 }
79 operations.push_back(listitem);
80 }
81 if (!parcel.ReadString(whereClause)) {
82 LOG_ERROR("predicate read whereClause failed");
83 return false;
84 }
85 if (!parcel.ReadStringVector(&whereArgs)) {
86 LOG_ERROR("predicate read whereArgs failed");
87 return false;
88 }
89 if (!parcel.ReadString(order)) {
90 LOG_ERROR("predicate read order failed");
91 return false;
92 }
93 if (!parcel.ReadInt64(mode)) {
94 LOG_ERROR("predicate read mode failed");
95 return false;
96 }
97 DataSharePredicates tmpPredicates(operations);
98 tmpPredicates.SetWhereClause(whereClause);
99 tmpPredicates.SetWhereArgs(whereArgs);
100 tmpPredicates.SetOrder(order);
101 tmpPredicates.SetSettingMode(static_cast<SettingMode>(mode));
102 predicates = tmpPredicates;
103 return true;
104 }
105
Marshalling(const DataShareValuesBucket & valuesBucket,Parcel & parcel)106 bool ITypesUtils::Marshalling(const DataShareValuesBucket &valuesBucket, Parcel &parcel)
107 {
108 if (!parcel.WriteInt32(valuesBucket.valuesMap.size())) {
109 LOG_ERROR("valuesBucket write size failed");
110 return false;
111 }
112 for (auto &it : valuesBucket.valuesMap) {
113 if (!parcel.WriteString(it.first)) {
114 LOG_ERROR("valuesBucket write first failed");
115 return false;
116 }
117 if (!Marshalling(it.second, parcel)) {
118 LOG_ERROR("valuesBucket write second failed");
119 return false;
120 }
121 }
122 return true;
123 }
124
Unmarshalling(Parcel & parcel,DataShareValuesBucket & valuesBucket)125 bool ITypesUtils::Unmarshalling(Parcel &parcel, DataShareValuesBucket &valuesBucket)
126 {
127 int len = parcel.ReadInt32();
128 if (len < 0) {
129 LOG_ERROR("valuesBucket read mapSize failed");
130 return false;
131 }
132 size_t size = static_cast<size_t>(len);
133 if ((size > parcel.GetReadableBytes()) || (valuesBucket.valuesMap.max_size() < size)) {
134 LOG_ERROR("Read valuesMap failed, size : %{public}zu", size);
135 return false;
136 }
137 valuesBucket.valuesMap.clear();
138 for (size_t i = 0; i < size; i++) {
139 std::string key = parcel.ReadString();
140 DataShareValueObject value {};
141 if (!Unmarshalling(parcel, value)) {
142 LOG_ERROR("valuesBucket read value failed");
143 return false;
144 }
145 valuesBucket.valuesMap.insert(std::make_pair(key, value));
146 }
147 return true;
148 }
149
Marshalling(const OperationItem & operationItem,Parcel & parcel)150 bool ITypesUtils::Marshalling(const OperationItem &operationItem, Parcel &parcel)
151 {
152 if (!parcel.WriteInt64(static_cast<int64_t>(operationItem.operation))) {
153 LOG_ERROR("predicate write operation failed");
154 return false;
155 }
156 if (operationItem.singleParams.size() > MAX_PARAM_COUNT || operationItem.multiParams.size() > MAX_PARAM_COUNT) {
157 LOG_ERROR("invalid param count");
158 return false;
159 }
160 if (!Marshalling(operationItem.singleParams, parcel)) {
161 LOG_ERROR("predicate write singleParams failed");
162 return false;
163 }
164 if (!Marshalling(operationItem.multiParams, parcel)) {
165 LOG_ERROR("predicate write multiParams failed");
166 return false;
167 }
168 return true;
169 }
170
Unmarshalling(Parcel & parcel,OperationItem & operationItem)171 bool ITypesUtils::Unmarshalling(Parcel &parcel, OperationItem &operationItem)
172 {
173 operationItem.operation = static_cast<OperationType>(parcel.ReadInt64());
174 if (operationItem.operation < OperationType::INVALID_OPERATION) {
175 LOG_ERROR("operationItem read operation failed");
176 return false;
177 }
178 if (!Unmarshalling(parcel, operationItem.singleParams)) {
179 LOG_ERROR("Unmarshalling singleParams failed");
180 return false;
181 }
182 if (!Unmarshalling(parcel, operationItem.multiParams)) {
183 LOG_ERROR("Unmarshalling multiParams failed");
184 return false;
185 }
186 return true;
187 }
188
Marshalling(const DataSharePredicatesObject & predicatesObject,Parcel & parcel)189 bool ITypesUtils::Marshalling(const DataSharePredicatesObject &predicatesObject, Parcel &parcel)
190 {
191 if (!parcel.WriteInt16((int16_t)predicatesObject.GetType())) {
192 LOG_ERROR("predicatesObject write type failed");
193 return false;
194 }
195 switch (predicatesObject.GetType()) {
196 case DataSharePredicatesObjectType::TYPE_INT: {
197 if (!parcel.WriteInt32(predicatesObject)) {
198 LOG_ERROR("predicatesObject WriteInt32 failed");
199 return false;
200 }
201 break;
202 }
203 case DataSharePredicatesObjectType::TYPE_LONG: {
204 if (!parcel.WriteInt64(predicatesObject)) {
205 LOG_ERROR("predicatesObject WriteInt64 failed");
206 return false;
207 }
208 break;
209 }
210 case DataSharePredicatesObjectType::TYPE_DOUBLE: {
211 if (!parcel.WriteDouble(predicatesObject)) {
212 LOG_ERROR("predicatesObject WriteDouble failed");
213 return false;
214 }
215 break;
216 }
217 case DataSharePredicatesObjectType::TYPE_STRING: {
218 if (!parcel.WriteString(predicatesObject)) {
219 LOG_ERROR("predicatesObject WriteString failed");
220 return false;
221 }
222 break;
223 }
224 case DataSharePredicatesObjectType::TYPE_BOOL: {
225 if (!parcel.WriteBool(predicatesObject)) {
226 LOG_ERROR("predicatesObject WriteBool failed");
227 return false;
228 }
229 break;
230 }
231 default:
232 break;
233 }
234 return true;
235 }
236
Unmarshalling(Parcel & parcel,DataSharePredicatesObject & predicatesObject)237 bool ITypesUtils::Unmarshalling(Parcel &parcel, DataSharePredicatesObject &predicatesObject)
238 {
239 int16_t type = parcel.ReadInt16();
240 if (type < (int16_t)DataSharePredicatesObjectType::TYPE_NULL) {
241 LOG_ERROR("predicatesObject read type failed");
242 return false;
243 }
244 predicatesObject.type = static_cast<DataSharePredicatesObjectType>(type);
245 switch (predicatesObject.type) {
246 case DataSharePredicatesObjectType::TYPE_INT: {
247 predicatesObject.value = parcel.ReadInt32();
248 break;
249 }
250 case DataSharePredicatesObjectType::TYPE_LONG: {
251 predicatesObject.value = parcel.ReadInt64();
252 break;
253 }
254 case DataSharePredicatesObjectType::TYPE_DOUBLE: {
255 predicatesObject.value = parcel.ReadDouble();
256 break;
257 }
258 case DataSharePredicatesObjectType::TYPE_STRING: {
259 predicatesObject.value = parcel.ReadString();
260 break;
261 }
262 case DataSharePredicatesObjectType::TYPE_BOOL: {
263 predicatesObject.value = parcel.ReadBool();
264 break;
265 }
266 default:
267 break;
268 }
269 return true;
270 }
271
Marshalling(const DataSharePredicatesObjects & predicatesObject,Parcel & parcel)272 bool ITypesUtils::Marshalling(const DataSharePredicatesObjects &predicatesObject, Parcel &parcel)
273 {
274 if (!parcel.WriteInt16((int16_t)predicatesObject.GetType())) {
275 LOG_ERROR("predicatesObject write type failed");
276 return false;
277 }
278 switch (predicatesObject.GetType()) {
279 case DataSharePredicatesObjectsType::TYPE_INT_VECTOR: {
280 if (!parcel.WriteInt32Vector(predicatesObject)) {
281 LOG_ERROR("predicatesObject WriteInt32Vector failed");
282 return false;
283 }
284 break;
285 }
286 case DataSharePredicatesObjectsType::TYPE_LONG_VECTOR: {
287 if (!parcel.WriteInt64Vector(predicatesObject)) {
288 LOG_ERROR("predicatesObject WriteInt64Vector failed");
289 return false;
290 }
291 break;
292 }
293 case DataSharePredicatesObjectsType::TYPE_DOUBLE_VECTOR: {
294 if (!parcel.WriteDoubleVector(predicatesObject)) {
295 LOG_ERROR("predicatesObject WriteDoubleVector failed");
296 return false;
297 }
298 break;
299 }
300 case DataSharePredicatesObjectsType::TYPE_STRING_VECTOR: {
301 if (!parcel.WriteStringVector(predicatesObject)) {
302 LOG_ERROR("predicatesObject WriteStringVector failed");
303 return false;
304 }
305 break;
306 }
307 default:
308 break;
309 }
310 return true;
311 }
312
Unmarshalling(Parcel & parcel,DataSharePredicatesObjects & predicatesObject)313 bool ITypesUtils::Unmarshalling(Parcel &parcel, DataSharePredicatesObjects &predicatesObject)
314 {
315 int16_t type = parcel.ReadInt16();
316 if (type < (int16_t)DataSharePredicatesObjectsType::TYPE_NULL) {
317 LOG_ERROR("predicatesObject read type failed");
318 return false;
319 }
320 predicatesObject.type = static_cast<DataSharePredicatesObjectsType>(type);
321 switch (predicatesObject.type) {
322 case DataSharePredicatesObjectsType::TYPE_INT_VECTOR: {
323 std::vector<int> intval {};
324 if (!parcel.ReadInt32Vector(&intval)) {
325 LOG_ERROR("predicatesObject ReadInt32Vector value failed");
326 return false;
327 }
328 predicatesObject.value = intval;
329 break;
330 }
331 case DataSharePredicatesObjectsType::TYPE_LONG_VECTOR: {
332 std::vector<int64_t> int64val {};
333 if (!parcel.ReadInt64Vector(&int64val)) {
334 LOG_ERROR("predicatesObject ReadInt64Vector value failed");
335 return false;
336 }
337 predicatesObject.value = int64val;
338 break;
339 }
340 case DataSharePredicatesObjectsType::TYPE_DOUBLE_VECTOR: {
341 std::vector<double> doubleval {};
342 if (!parcel.ReadDoubleVector(&doubleval)) {
343 LOG_ERROR("predicatesObject ReadDoubleVector value failed");
344 return false;
345 }
346 predicatesObject.value = doubleval;
347 break;
348 }
349 case DataSharePredicatesObjectsType::TYPE_STRING_VECTOR: {
350 std::vector<std::string> stringval {};
351 if (!parcel.ReadStringVector(&stringval)) {
352 LOG_ERROR("predicatesObject ReadDoubReadStringVectorleVector value failed");
353 return false;
354 }
355 predicatesObject.value = stringval;
356 break;
357 }
358 default:
359 break;
360 }
361 return true;
362 }
363
Marshalling(const DataShareValueObject & valueObject,Parcel & parcel)364 bool ITypesUtils::Marshalling(const DataShareValueObject &valueObject, Parcel &parcel)
365 {
366 if (!parcel.WriteInt16((int16_t)valueObject.type)) {
367 LOG_ERROR("valueObject write type failed");
368 return false;
369 }
370 switch (valueObject.type) {
371 case DataShareValueObjectType::TYPE_INT: {
372 if (!parcel.WriteInt64(std::get<int64_t>(valueObject.value))) {
373 LOG_ERROR("valueObject WriteInt64 failed");
374 return false;
375 }
376 break;
377 }
378 case DataShareValueObjectType::TYPE_DOUBLE: {
379 if (!parcel.WriteDouble(std::get<double>(valueObject.value))) {
380 LOG_ERROR("valueObject WriteDouble failed");
381 return false;
382 }
383 break;
384 }
385 case DataShareValueObjectType::TYPE_STRING: {
386 if (!parcel.WriteString(std::get<std::string>(valueObject.value))) {
387 LOG_ERROR("valueObject WriteString failed");
388 return false;
389 }
390 break;
391 }
392 case DataShareValueObjectType::TYPE_BLOB: {
393 if (!parcel.WriteUInt8Vector(std::get<std::vector<uint8_t>>(valueObject.value))) {
394 LOG_ERROR("valueObject WriteUInt8Vector failed");
395 return false;
396 }
397 break;
398 }
399 case DataShareValueObjectType::TYPE_BOOL: {
400 if (!parcel.WriteBool(std::get<bool>(valueObject.value))) {
401 LOG_ERROR("valueObject WriteBool failed");
402 return false;
403 }
404 break;
405 }
406 default:
407 break;
408 }
409 return true;
410 }
411
Unmarshalling(Parcel & parcel,DataShareValueObject & valueObject)412 bool ITypesUtils::Unmarshalling(Parcel &parcel, DataShareValueObject &valueObject)
413 {
414 int16_t type = parcel.ReadInt16();
415 if (type < (int16_t)DataShareValueObjectType::TYPE_NULL) {
416 LOG_ERROR("valueObject read type failed");
417 return false;
418 }
419 valueObject.type = static_cast<DataShareValueObjectType>(type);
420 switch (valueObject.type) {
421 case DataShareValueObjectType::TYPE_INT: {
422 valueObject.value = parcel.ReadInt64();
423 break;
424 }
425 case DataShareValueObjectType::TYPE_DOUBLE: {
426 valueObject.value = parcel.ReadDouble();
427 break;
428 }
429 case DataShareValueObjectType::TYPE_STRING: {
430 valueObject.value = parcel.ReadString();
431 break;
432 }
433 case DataShareValueObjectType::TYPE_BLOB: {
434 std::vector<uint8_t> val;
435 if (!parcel.ReadUInt8Vector(&val)) {
436 LOG_ERROR("valueObject ReadUInt8Vector value failed");
437 return false;
438 }
439 valueObject.value = val;
440 break;
441 }
442 case DataShareValueObjectType::TYPE_BOOL: {
443 valueObject.value = parcel.ReadBool();
444 break;
445 }
446 default:
447 break;
448 }
449 return true;
450 }
451
Marshalling(const std::string & input,Parcel & data)452 bool ITypesUtils::Marshalling(const std::string &input, Parcel &data)
453 {
454 return data.WriteString(input);
455 }
456
Unmarshalling(Parcel & data,std::string & output)457 bool ITypesUtils::Unmarshalling(Parcel &data, std::string &output)
458 {
459 return data.ReadString(output);
460 }
461
Marshal(Parcel & data)462 bool ITypesUtils::Marshal(Parcel &data)
463 {
464 return true;
465 }
466
Unmarshal(Parcel & data)467 bool ITypesUtils::Unmarshal(Parcel &data)
468 {
469 return true;
470 }
471 } // namespace OHOS::DistributedKv
472