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 "udmf_client_fuzzer.h"
17
18 #include <unistd.h>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23
24 #include "udmf_client.h"
25 #include "text.h"
26 #include "plain_text.h"
27 #include "html.h"
28 #include "link.h"
29 #include "file.h"
30 #include "image.h"
31 #include "video.h"
32 #include "system_defined_record.h"
33 #include "system_defined_form.h"
34 #include "system_defined_appitem.h"
35 #include "system_defined_pixelmap.h"
36 #include "udmf_async_client.h"
37 #include "unified_types.h"
38
39 using namespace OHOS;
40 using namespace OHOS::Security::AccessToken;
41 using namespace OHOS::UDMF;
42
43 namespace OHOS {
44 static constexpr int END_INTERVAL = 3;
45
AllocHapToken()46 void AllocHapToken()
47 {
48 HapInfoParams info = {
49 .userID = 100,
50 .bundleName = "ohos.test.demo",
51 .instIndex = 0,
52 .appIDDesc = "ohos.test.demo"
53 };
54
55 HapPolicyParams policy = {
56 .apl = APL_NORMAL,
57 .domain = "test.domain",
58 .permList = {
59 {
60 .permissionName = "ohos.permission.test",
61 .bundleName = "ohos.test.demo",
62 .grantMode = 1,
63 .availableLevel = APL_NORMAL,
64 .label = "label",
65 .labelId = 1,
66 .description = "test",
67 .descriptionId = 1
68 }
69 },
70 .permStateList = {
71 {
72 .permissionName = "ohos.permission.test",
73 .isGeneral = true,
74 .resDeviceID = {"local"},
75 .grantStatus = {PermissionState::PERMISSION_GRANTED},
76 .grantFlags = {1}
77 }
78 }
79 };
80 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
81 SetSelfTokenID(tokenID.tokenIDEx);
82 }
83
SetUpTestCase()84 void SetUpTestCase()
85 {
86 AllocHapToken();
87 }
88
TearDown()89 void TearDown()
90 {
91 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
92 }
93
SetNativeToken()94 void SetNativeToken()
95 {
96 NativeTokenInfoParams infoInstance = {
97 .dcapsNum = 0,
98 .permsNum = 0,
99 .aclsNum = 0,
100 .dcaps = nullptr,
101 .perms = nullptr,
102 .acls = nullptr,
103 .processName = "msdp_sa",
104 .aplStr = "system_core",
105 };
106 auto tokenId = GetAccessTokenId(&infoInstance);
107 SetSelfTokenID(tokenId);
108 AccessTokenKit::ReloadNativeTokenInfo();
109 }
110
SetHapToken()111 void SetHapToken()
112 {
113 auto tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
114 SetSelfTokenID(tokenId);
115 }
116
SetDataTextFuzz(const uint8_t * data,size_t size)117 void SetDataTextFuzz(const uint8_t *data, size_t size)
118 {
119 std::string skey(data, data + size);
120 std::string svalue(data, data + size);
121 UnifiedData unifiedData;
122 CustomOption option = {.intention = Intention::UD_INTENTION_BUTT};
123 auto text = std::make_shared<Text>();
124 UDDetails details;
125 details.insert({skey, svalue});
126 text->SetDetails(details);
127 unifiedData.AddRecord(text);
128 std::string key;
129 UdmfClient::GetInstance().SetData(option, unifiedData, key);
130
131 SetNativeToken();
132
133 QueryOption option2 = {.key = key};
134 Privilege privilege;
135 privilege.readPermission = "readPermission";
136 privilege.writePermission = "writePermission";
137 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
138
139 SetHapToken();
140
141 UnifiedData data2;
142 UdmfClient::GetInstance().GetData(option2, data2);
143 }
144
SetDataPlainTextFuzz(const uint8_t * data,size_t size)145 void SetDataPlainTextFuzz(const uint8_t *data, size_t size)
146 {
147 std::string skey(data, data + size);
148 std::string svalue(data, data + size);
149 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
150 UnifiedData data1;
151 UDDetails details1;
152 auto plainText1 = std::make_shared<PlainText>();
153 details1.insert({skey, svalue});
154 plainText1->SetDetails(details1);
155 plainText1->SetContent(svalue + "content");
156 plainText1->SetAbstract(svalue + "abstract");
157 plainText1->GetContent();
158 plainText1->GetAbstract();
159 data1.AddRecord(plainText1);
160 std::string key;
161 UdmfClient::GetInstance().SetData(option1, data1, key);
162
163 SetNativeToken();
164
165 QueryOption option2 = {.key = key};
166 Privilege privilege;
167 privilege.readPermission = "readPermission";
168 privilege.writePermission = "writePermission";
169 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
170
171 SetHapToken();
172
173 UnifiedData data2;
174 UdmfClient::GetInstance().GetData(option2, data2);
175 }
176
SetDataHtmlFuzz(const uint8_t * data,size_t size)177 void SetDataHtmlFuzz(const uint8_t *data, size_t size)
178 {
179 std::string skey(data, data + size);
180 std::string svalue(data, data + size);
181 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
182 UnifiedData data1;
183 std::string key;
184 auto html1 = std::make_shared<Html>();
185 UDDetails details1;
186 details1.insert({skey, svalue});
187 html1->SetDetails(details1);
188 html1->SetHtmlContent(svalue + "htmlcontent");
189 html1->SetPlainContent(svalue + "plainContent");
190 html1->GetHtmlContent();
191 html1->GetPlainContent();
192 data1.AddRecord(html1);
193 UdmfClient::GetInstance().SetData(option1, data1, key);
194
195 SetNativeToken();
196
197 QueryOption option2 = {.key = key};
198 Privilege privilege;
199 privilege.readPermission = "readPermission";
200 privilege.writePermission = "writePermission";
201 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
202
203 SetHapToken();
204
205 UnifiedData data2;
206 UdmfClient::GetInstance().GetData(option2, data2);
207 }
208
SetDataLinkFuzz(const uint8_t * data,size_t size)209 void SetDataLinkFuzz(const uint8_t *data, size_t size)
210 {
211 std::string skey(data, data + size);
212 std::string svalue(data, data + size);
213 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
214 UnifiedData data1;
215 std::string key;
216 auto link1 = std::make_shared<Link>();
217 UDDetails details1;
218 details1.insert({skey, svalue});
219 link1->SetDetails(details1);
220 link1->SetUrl(svalue + "url");
221 link1->SetDescription(svalue + "description");
222 link1->GetUrl();
223 link1->GetDescription();
224 data1.AddRecord(link1);
225 UdmfClient::GetInstance().SetData(option1, data1, key);
226
227 SetNativeToken();
228
229 QueryOption option2 = {.key = key};
230 Privilege privilege;
231 privilege.readPermission = "readPermission";
232 privilege.writePermission = "writePermission";
233 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
234
235 SetHapToken();
236
237 UnifiedData data2;
238 UdmfClient::GetInstance().GetData(option2, data2);
239 }
240
SetDataFileFuzz(const uint8_t * data,size_t size)241 void SetDataFileFuzz(const uint8_t *data, size_t size)
242 {
243 std::string svalue(data, data + size);
244 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
245 UnifiedData data1;
246 std::string key;
247 auto file1 = std::make_shared<File>();
248 file1->SetUri(svalue + "uri");
249 file1->SetRemoteUri(svalue + "remoteUri");
250 file1->GetUri();
251 file1->GetRemoteUri();
252 file1->GetSize();
253 data1.AddRecord(file1);
254 UdmfClient::GetInstance().SetData(option1, data1, key);
255
256 SetNativeToken();
257
258 QueryOption option2 = {.key = key};
259 Privilege privilege;
260 privilege.readPermission = "readPermission";
261 privilege.writePermission = "writePermission";
262 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
263
264 SetHapToken();
265
266 UnifiedData data2;
267 UdmfClient::GetInstance().GetData(option2, data2);
268 }
269
SetDataImageFuzz(const uint8_t * data,size_t size)270 void SetDataImageFuzz(const uint8_t *data, size_t size)
271 {
272 std::string svalue(data, data + size);
273 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
274 UnifiedData data1;
275 std::string key;
276 auto image1 = std::make_shared<Image>();
277 image1->SetUri(svalue + "uri");
278 image1->SetRemoteUri(svalue + "remoteUri");
279 data1.AddRecord(image1);
280 UdmfClient::GetInstance().SetData(option1, data1, key);
281
282 SetNativeToken();
283
284 QueryOption option2 = {.key = key};
285 Privilege privilege;
286 privilege.readPermission = "readPermission";
287 privilege.writePermission = "writePermission";
288 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
289
290 SetHapToken();
291
292 UnifiedData data2;
293 UdmfClient::GetInstance().GetData(option2, data2);
294 }
295
SetDataVideoFuzz(const uint8_t * data,size_t size)296 void SetDataVideoFuzz(const uint8_t *data, size_t size)
297 {
298 std::string svalue(data, data + size);
299 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
300 UnifiedData data1;
301 std::string key;
302 auto video1 = std::make_shared<Video>();
303 video1->SetUri(svalue + "uri");
304 video1->SetRemoteUri(svalue + "remoteUri");
305 data1.AddRecord(video1);
306 UdmfClient::GetInstance().SetData(option1, data1, key);
307
308 SetNativeToken();
309
310 QueryOption option2 = {.key = key};
311 Privilege privilege;
312 privilege.readPermission = "readPermission";
313 privilege.writePermission = "writePermission";
314 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
315
316 SetHapToken();
317
318 UnifiedData data2;
319 UdmfClient::GetInstance().GetData(option2, data2);
320 }
321
SetDataSystemDefinedRecordFuzz(const uint8_t * data,size_t size)322 void SetDataSystemDefinedRecordFuzz(const uint8_t *data, size_t size)
323 {
324 std::string skey(data, data + size);
325 std::string svalue(data, data + size);
326 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
327 UnifiedData data1;
328 std::string key;
329 auto systemDefinedRecord1 = std::make_shared<SystemDefinedRecord>();
330 UDDetails details1;
331 details1.insert({skey, svalue});
332 systemDefinedRecord1->SetDetails(details1);
333 data1.AddRecord(systemDefinedRecord1);
334 UdmfClient::GetInstance().SetData(option1, data1, key);
335
336 SetNativeToken();
337
338 QueryOption option2 = {.key = key};
339 Privilege privilege;
340 privilege.readPermission = "readPermission";
341 privilege.writePermission = "writePermission";
342 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
343
344 SetHapToken();
345
346 UnifiedData data2;
347 UdmfClient::GetInstance().GetData(option2, data2);
348 }
349
SetDataSystemDefinedFormFuzz(const uint8_t * data,size_t size)350 void SetDataSystemDefinedFormFuzz(const uint8_t *data, size_t size)
351 {
352 std::string skey(data, data + size);
353 std::string svalue(data, data + size);
354 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
355 UnifiedData data1;
356 std::string key;
357 auto systemDefinedForm1 = std::make_shared<SystemDefinedForm>();
358 UDDetails details1;
359 details1.insert({skey, svalue});
360 systemDefinedForm1->SetDetails(details1);
361 auto formId = 123;
362 systemDefinedForm1->SetFormId(formId);
363 systemDefinedForm1->SetFormName(svalue + "formName");
364 systemDefinedForm1->SetModule(svalue + "module");
365 systemDefinedForm1->SetAbilityName(svalue + "abilityName");
366 systemDefinedForm1->SetBundleName(svalue + "bundleName");
367 systemDefinedForm1->GetFormId();
368 systemDefinedForm1->GetFormName();
369 systemDefinedForm1->GetBundleName();
370 systemDefinedForm1->GetAbilityName();
371 systemDefinedForm1->GetModule();
372 data1.AddRecord(systemDefinedForm1);
373 UdmfClient::GetInstance().SetData(option1, data1, key);
374
375 SetNativeToken();
376
377 QueryOption option2 = {.key = key};
378 Privilege privilege;
379 privilege.readPermission = "readPermission";
380 privilege.writePermission = "writePermission";
381 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
382
383 SetHapToken();
384
385 UnifiedData data2;
386 UdmfClient::GetInstance().GetData(option2, data2);
387 }
388
SetDataSystemDefinedAppItemFuzz(const uint8_t * data,size_t size)389 void SetDataSystemDefinedAppItemFuzz(const uint8_t *data, size_t size)
390 {
391 std::string skey(data, data + size);
392 std::string svalue(data, data + size);
393 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
394 UnifiedData data1;
395 std::string key;
396 auto systemDefinedAppItem1 = std::make_shared<SystemDefinedAppItem>();
397 UDDetails details1;
398 details1.insert({skey, svalue});
399 systemDefinedAppItem1->SetDetails(details1);
400 systemDefinedAppItem1->SetAppId(svalue + "appId");
401 systemDefinedAppItem1->SetAppName(svalue + "appName");
402 systemDefinedAppItem1->SetAppIconId(svalue + "appIconId");
403 systemDefinedAppItem1->SetAppLabelId(svalue + "appLabelId");
404 systemDefinedAppItem1->SetBundleName(svalue + "bundleName");
405 systemDefinedAppItem1->SetAbilityName(svalue + "abilityName");
406 systemDefinedAppItem1->GetAppId();
407 systemDefinedAppItem1->GetAppName();
408 systemDefinedAppItem1->GetBundleName();
409 systemDefinedAppItem1->GetAbilityName();
410 systemDefinedAppItem1->GetAppIconId();
411 systemDefinedAppItem1->GetAppLabelId();
412 data1.AddRecord(systemDefinedAppItem1);
413 UdmfClient::GetInstance().SetData(option1, data1, key);
414
415 SetNativeToken();
416
417 QueryOption option2 = {.key = key};
418 Privilege privilege;
419 privilege.readPermission = "readPermission";
420 privilege.writePermission = "writePermission";
421 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
422
423 SetHapToken();
424
425 UnifiedData data2;
426 UdmfClient::GetInstance().GetData(option2, data2);
427 }
428
SetDataSystemDefinedPixelMapFuzz(const uint8_t * data,size_t size)429 void SetDataSystemDefinedPixelMapFuzz(const uint8_t *data, size_t size)
430 {
431 std::string skey(data, data + size);
432 std::string svalue(data, data + size);
433 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
434 UnifiedData data1;
435 std::string key;
436 auto systemDefinedPixelMap1 = std::make_shared<SystemDefinedPixelMap>();
437 UDDetails details1;
438 details1.insert({skey, svalue});
439 systemDefinedPixelMap1->SetDetails(details1);
440 std::vector<uint8_t> rawData1 = {1, 2, 3, 4, 5};
441 systemDefinedPixelMap1->SetRawData(rawData1);
442 data1.AddRecord(systemDefinedPixelMap1);
443 UdmfClient::GetInstance().SetData(option1, data1, key);
444
445 SetNativeToken();
446
447 QueryOption option2 = {.key = key};
448 Privilege privilege;
449 privilege.readPermission = "readPermission";
450 privilege.writePermission = "writePermission";
451 UdmfClient::GetInstance().AddPrivilege(option2, privilege);
452
453 SetHapToken();
454
455 UnifiedData data2;
456 UdmfClient::GetInstance().GetData(option2, data2);
457 }
458
GetSummaryFuzz(const uint8_t * data,size_t size)459 void GetSummaryFuzz(const uint8_t *data, size_t size)
460 {
461 std::string skey(data, data + size);
462 std::string svalue(data, data + size);
463 CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
464 UnifiedData UData;
465 std::string key;
466
467 UDDetails details;
468 details.insert({skey, svalue});
469
470 auto text = std::make_shared<Text>();
471 text->SetDetails(details);
472 UData.AddRecord(text);
473
474 auto plainText = std::make_shared<PlainText>();
475 plainText->SetDetails(details);
476 plainText->SetContent(svalue + "content");
477 plainText->SetAbstract(svalue + "abstract");
478 UData.AddRecord(plainText);
479
480 auto file = std::make_shared<File>();
481 file->SetUri(svalue + "uri");
482 file->SetRemoteUri(svalue + "remoteUri");
483 UData.AddRecord(file);
484
485 auto image = std::make_shared<Image>();
486 image->SetUri(svalue + "uri");
487 image->SetRemoteUri(svalue + "remoteUri");
488 UData.AddRecord(image);
489
490 auto systemDefinedRecord = std::make_shared<SystemDefinedRecord>();
491 systemDefinedRecord->SetDetails(details);
492 UData.AddRecord(systemDefinedRecord);
493
494 auto systemDefinedForm = std::make_shared<SystemDefinedForm>();
495 systemDefinedForm->SetDetails(details);
496 auto formId = 123;
497 systemDefinedForm->SetFormId(formId);
498 systemDefinedForm->SetFormName(svalue + "formName");
499 systemDefinedForm->SetModule(svalue + "module");
500 systemDefinedForm->SetAbilityName(svalue + "abilityName");
501 systemDefinedForm->SetBundleName(svalue + "bundleName");
502 UData.AddRecord(systemDefinedForm);
503
504 UdmfClient::GetInstance().SetData(option1, UData, key);
505
506 QueryOption option2 = {.key = key};
507 Summary summary;
508 UdmfClient::GetInstance().GetSummary(option2, summary);
509 UnifiedData data2;
510 UdmfClient::GetInstance().GetData(option2, data2);
511 }
512
GetBatchDataByKeyFuzz(const uint8_t * data,size_t size)513 void GetBatchDataByKeyFuzz(const uint8_t *data, size_t size)
514 {
515 std::string skey(data, data + size);
516 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
517 UnifiedData data1;
518 std::string key;
519 auto plainText = std::make_shared<PlainText>();
520 data1.AddRecord(plainText);
521 UdmfClient::GetInstance().SetData(option1, data1, key);
522
523 SetHapToken();
524 QueryOption option2 = { .key = key };
525 std::vector<UnifiedData> dataSet2;
526 UdmfClient::GetInstance().GetBatchData(option2, dataSet2);
527
528 SetHapToken();
529 QueryOption option3 = { .key = skey };
530 std::vector<UnifiedData> dataSet3;
531 UdmfClient::GetInstance().GetBatchData(option3, dataSet3);
532 }
533
GetBatchDataByIntentionFuzz(const uint8_t * data,size_t size)534 void GetBatchDataByIntentionFuzz(const uint8_t *data, size_t size)
535 {
536 std::string skey(data, data + size);
537 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
538 UnifiedData data1;
539 std::string key;
540 auto plainText = std::make_shared<PlainText>();
541 data1.AddRecord(plainText);
542 UdmfClient::GetInstance().SetData(option1, data1, key);
543
544 SetHapToken();
545 Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
546 QueryOption option2 = { .intention = intention };
547 std::vector<UnifiedData> dataSet;
548 UdmfClient::GetInstance().GetBatchData(option2, dataSet);
549 }
550
DeleteDataByKeyFuzz(const uint8_t * data,size_t size)551 void DeleteDataByKeyFuzz(const uint8_t *data, size_t size)
552 {
553 std::string skey(data, data + size);
554 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
555 UnifiedData data1;
556 std::string key;
557 auto plainText = std::make_shared<PlainText>();
558 data1.AddRecord(plainText);
559 UdmfClient::GetInstance().SetData(option1, data1, key);
560
561 SetHapToken();
562 QueryOption option2 = { .key = key };
563 std::vector<UnifiedData> dataSet2;
564 UdmfClient::GetInstance().DeleteData(option2, dataSet2);
565
566 SetHapToken();
567 QueryOption option3 = { .key = skey };
568 std::vector<UnifiedData> dataSet3;
569 UdmfClient::GetInstance().DeleteData(option3, dataSet3);
570 }
571
DeleteDataByIntentionFuzz(const uint8_t * data,size_t size)572 void DeleteDataByIntentionFuzz(const uint8_t *data, size_t size)
573 {
574 std::string skey(data, data + size);
575 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
576 UnifiedData data1;
577 std::string key;
578 auto plainText = std::make_shared<PlainText>();
579 data1.AddRecord(plainText);
580 UdmfClient::GetInstance().SetData(option1, data1, key);
581
582 SetHapToken();
583 Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
584 QueryOption option2 = { .intention = intention };
585 std::vector<UnifiedData> dataSet;
586 UdmfClient::GetInstance().DeleteData(option2, dataSet);
587 }
588
UpdateDataFuzz(const uint8_t * data,size_t size)589 void UpdateDataFuzz(const uint8_t *data, size_t size)
590 {
591 std::string skey(data, data + size);
592 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
593 UnifiedData data1;
594 std::string key;
595 auto plainText = std::make_shared<PlainText>();
596 data1.AddRecord(plainText);
597 UdmfClient::GetInstance().SetData(option1, data1, key);
598
599 SetHapToken();
600 UnifiedData data2;
601 data2.AddRecord(plainText);
602 QueryOption option2 = { .key = key };
603 UdmfClient::GetInstance().UpdateData(option2, data2);
604
605 SetHapToken();
606 UnifiedData data3;
607 data3.AddRecord(plainText);
608 QueryOption option3 = { .key = skey };
609 UdmfClient::GetInstance().UpdateData(option3, data3);
610 }
611
StartAsyncDataRetrievalFuzz(const uint8_t * data,size_t size)612 void StartAsyncDataRetrievalFuzz(const uint8_t *data, size_t size)
613 {
614 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
615 UnifiedData data1;
616 std::string key;
617 auto plainText = std::make_shared<PlainText>();
618 std::string content(data, data + size);
619 plainText->SetContent(content);
620 data1.AddRecord(plainText);
621 UdmfClient::GetInstance().SetData(option1, data1, key);
622
623 QueryOption query = {.key = key, .intention = UDMF::UD_INTENTION_DRAG};
624 GetDataParams params = {.query = query};
625 params.progressIndicator = ProgressIndicator::DEFAULT;
626 params.progressListener = [](ProgressInfo progressInfo, std::shared_ptr<UnifiedData> data) {};
627 UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
628 }
629
CancelAsyncDataRetrievalFuzz(const uint8_t * data,size_t size)630 void CancelAsyncDataRetrievalFuzz(const uint8_t *data, size_t size)
631 {
632 CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
633 UnifiedData data1;
634 std::string key;
635 auto plainText = std::make_shared<PlainText>();
636 std::string content(data, data + size);
637 plainText->SetContent(content);
638 data1.AddRecord(plainText);
639 UdmfClient::GetInstance().SetData(option1, data1, key);
640
641 QueryOption query = {.key = key, .intention = UDMF::UD_INTENTION_DRAG};
642 GetDataParams params = {.query = query};
643 params.progressIndicator = ProgressIndicator::NONE;
644 params.progressListener = [](ProgressInfo progressInfo, std::shared_ptr<UnifiedData> data) {
645 std::this_thread::sleep_for(std::chrono::milliseconds(500));
646 };
647 UdmfAsyncClient::GetInstance().StartAsyncDataRetrieval(params);
648 UdmfAsyncClient::GetInstance().Cancel(key);
649 }
650 }
651
652 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)653 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
654 {
655 /* Run your code on data */
656 OHOS::SetUpTestCase();
657 OHOS::SetDataFileFuzz(data, size);
658 OHOS::SetDataHtmlFuzz(data, size);
659 OHOS::SetDataImageFuzz(data, size);
660 OHOS::SetDataLinkFuzz(data, size);
661 OHOS::SetDataPlainTextFuzz(data, size);
662 OHOS::SetDataSystemDefinedAppItemFuzz(data, size);
663 OHOS::SetDataSystemDefinedFormFuzz(data, size);
664 OHOS::SetDataSystemDefinedPixelMapFuzz(data, size);
665 OHOS::SetDataSystemDefinedRecordFuzz(data, size);
666 OHOS::SetDataTextFuzz(data, size);
667 OHOS::SetDataVideoFuzz(data, size);
668 OHOS::GetSummaryFuzz(data, size);
669 OHOS::GetBatchDataByKeyFuzz(data, size);
670 OHOS::GetBatchDataByIntentionFuzz(data, size);
671 OHOS::DeleteDataByKeyFuzz(data, size);
672 OHOS::DeleteDataByIntentionFuzz(data, size);
673 OHOS::UpdateDataFuzz(data, size);
674 OHOS::StartAsyncDataRetrievalFuzz(data, size);
675 OHOS::CancelAsyncDataRetrievalFuzz(data, size);
676 OHOS::TearDown();
677 return 0;
678 }