1 /*
2 * Copyright (c) 2025 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 "medialibrarymediaassetscontrollerservice_fuzzer.h"
17
18 #include <cstdint>
19 #include <string>
20 #include <fuzzer/FuzzedDataProvider.h>
21 #define private public
22 #include "media_assets_controller_service.h"
23 #undef private
24 #include "user_define_ipc.h"
25 #include "form_info_vo.h"
26 #include "commit_edited_asset_vo.h"
27 #include "trash_photos_vo.h"
28 #include "delete_photos_vo.h"
29 #include "delete_photos_completed_vo.h"
30 #include "asset_change_vo.h"
31 #include "submit_cache_vo.h"
32 #include "asset_change_vo.h"
33 #include "add_image_vo.h"
34 #include "save_camera_photo_vo.h"
35 #include "get_assets_vo.h"
36 #include "create_asset_vo.h"
37 #include "modify_assets_vo.h"
38 #include "get_asset_analysis_data_vo.h"
39 #include "clone_asset_vo.h"
40 #include "revert_to_original_vo.h"
41 #include "convert_format_vo.h"
42 #include "cloud_enhancement_vo.h"
43 #include "start_download_cloud_media_vo.h"
44 #include "retain_cloud_media_asset_vo.h"
45 #include "get_cloudmedia_asset_status_vo.h"
46 #include "get_edit_data_vo.h"
47 #include "request_edit_data_vo.h"
48 #include "is_edited_vo.h"
49 #include "start_asset_analysis_vo.h"
50 #include "grant_photo_uri_permission_vo.h"
51 #include "grant_photo_uris_permission_vo.h"
52 #include "cancel_photo_uri_permission_vo.h"
53 #include "stop_thumbnail_creation_task_vo.h"
54 #include "start_thumbnail_creation_task_vo.h"
55 #include "request_content_vo.h"
56 #include "get_cloud_enhancement_pair_vo.h"
57 #include "query_cloud_enhancement_task_state_vo.h"
58 #include "query_photo_vo.h"
59 #include "add_visit_count_vo.h"
60 #include "adapted_vo.h"
61 #include "grant_photo_uri_permission_inner_vo.h"
62 #include "cancel_photo_uri_permission_inner_vo.h"
63 #include "get_result_set_from_db_vo.h"
64 #include "get_result_set_from_photos_extend_vo.h"
65 #include "get_moving_photo_date_modified_vo.h"
66 #include "get_uri_from_filepath_vo.h"
67 #include "get_filepath_from_uri_vo.h"
68 #include "close_asset_vo.h"
69 #include "check_photo_uri_permission_inner_vo.h"
70 #include "get_uris_by_old_uris_inner_vo.h"
71 #include "restore_vo.h"
72 #include "stop_restore_vo.h"
73
74 #include "media_old_photos_column.h"
75 #include "media_column.h"
76 #include "message_parcel.h"
77 #include "rdb_utils.h"
78
79 namespace OHOS {
80 using namespace std;
81 using namespace OHOS::Media;
82
83 static const int32_t FORM_INFO_NUM_BYTES = 10;
84 static const int32_t NUM_BYTES = 8;
85 static const string EDIT_DATA_VALUE = "{\"imageEffect\":{\"filters\":[{\"name\":\"InplaceSticker\",\"values\":"
86 "{\"RESOURCE_DIRECTORY\":\"/sys_prod/resource/camera\",\"cameraPosition\":1}}],\"name\":\"imageEdit\"}}";
87
88 FuzzedDataProvider* FDP;
89 shared_ptr<MediaAssetsControllerService> mediaAssetsControllerService = nullptr;
90
FuzzVector()91 static inline std::vector<std::string> FuzzVector()
92 {
93 return {FDP->ConsumeBytesAsString(FORM_INFO_NUM_BYTES)};
94 }
95
FormInfoFuzzer()96 static void FormInfoFuzzer()
97 {
98 FormInfoReqBody reqBody;
99 reqBody.formIds = FuzzVector();
100 string uri = "file://media/Photo/" + to_string(FDP->ConsumeIntegral<int32_t>());
101 vector<string> fileUris = { uri };
102 reqBody.fileUris = fileUris;
103 MessageParcel data;
104 MessageParcel reply;
105 reqBody.Marshalling(data);
106 mediaAssetsControllerService->SaveFormInfo(data, reply);
107 mediaAssetsControllerService->SaveGalleryFormInfo(data, reply);
108 mediaAssetsControllerService->RemoveFormInfo(data, reply);
109 mediaAssetsControllerService->RemoveGalleryFormInfo(data, reply);
110 mediaAssetsControllerService->UpdateGalleryFormInfo(data, reply);
111 }
112
CommitEditedAssetFuzzer()113 static void CommitEditedAssetFuzzer()
114 {
115 CommitEditedAssetReqBody reqBody;
116 reqBody.editData = EDIT_DATA_VALUE;
117 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
118 MessageParcel data;
119 MessageParcel reply;
120 reqBody.Marshalling(data);
121 mediaAssetsControllerService->CommitEditedAsset(data, reply);
122 }
123
SysTrashPhotosFuzzer()124 static void SysTrashPhotosFuzzer()
125 {
126 TrashPhotosReqBody reqBody;
127 auto uri = "file://media/Photo/" + to_string(FDP->ConsumeIntegral<int32_t>());
128 std::vector<std::string> testUris = {uri};
129 reqBody.uris = testUris;
130 MessageParcel data;
131 MessageParcel reply;
132 reqBody.Marshalling(data);
133 mediaAssetsControllerService->SysTrashPhotos(data, reply);
134 mediaAssetsControllerService->TrashPhotos(data, reply);
135 }
136
DeletePhotosFuzzer()137 static void DeletePhotosFuzzer()
138 {
139 DeletePhotosReqBody reqBody;
140 std::vector<std::string> testUris = {"file://media/Photo/1/IMG_1748423699_000/IMG_20250528_171318.jpg", ""};
141 reqBody.uris = testUris;
142 MessageParcel data;
143 MessageParcel reply;
144 reqBody.Marshalling(data);
145 mediaAssetsControllerService->DeletePhotos(data, reply);
146 }
147
DeletePhotosCompletedFuzzer()148 static void DeletePhotosCompletedFuzzer()
149 {
150 DeletePhotosCompletedReqBody reqBody;
151 reqBody.fileIds = {to_string(FDP->ConsumeIntegral<int32_t>())};
152 MessageParcel data;
153 MessageParcel reply;
154 reqBody.Marshalling(data);
155 mediaAssetsControllerService->DeletePhotosCompleted(data, reply);
156 }
157
AssetChangeSetFavoriteFuzzer()158 static void AssetChangeSetFavoriteFuzzer()
159 {
160 AssetChangeReqBody reqBody;
161 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
162 reqBody.favorite = FDP->ConsumeBool();
163 MessageParcel data;
164 MessageParcel reply;
165 reqBody.Marshalling(data);
166 mediaAssetsControllerService->AssetChangeSetFavorite(data, reply);
167 }
168
AssetChangeSetHiddenFuzzer()169 static void AssetChangeSetHiddenFuzzer()
170 {
171 AssetChangeReqBody reqBody;
172 reqBody.uri = "file://media/Photo/1/IMG_1748423699_000/IMG_20250528_171318.jpg";
173 reqBody.hidden = FDP->ConsumeBool();
174 MessageParcel data;
175 MessageParcel reply;
176 reqBody.Marshalling(data);
177 mediaAssetsControllerService->AssetChangeSetHidden(data, reply);
178 }
179
AssetChangeSetUserCommentFuzzer()180 static void AssetChangeSetUserCommentFuzzer()
181 {
182 AssetChangeReqBody reqBody;
183 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
184 reqBody.userComment = "user comment";
185 MessageParcel data;
186 MessageParcel reply;
187 reqBody.Marshalling(data);
188 mediaAssetsControllerService->AssetChangeSetUserComment(data, reply);
189 }
190
AssetChangeSetLocationFuzzer()191 static void AssetChangeSetLocationFuzzer()
192 {
193 AssetChangeReqBody reqBody;
194 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
195 reqBody.path = "/data/local/tmp/IMG_1501924305_001.jpg";
196 reqBody.latitude = FDP->ConsumeFloatingPoint<double>();
197 reqBody.longitude = FDP->ConsumeFloatingPoint<double>();
198 MessageParcel data;
199 MessageParcel reply;
200 reqBody.Marshalling(data);
201 mediaAssetsControllerService->AssetChangeSetLocation(data, reply);
202 }
203
AssetChangeSetTitleFuzzer()204 static void AssetChangeSetTitleFuzzer()
205 {
206 AssetChangeReqBody reqBody;
207 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
208 reqBody.title = "title_test";
209 MessageParcel data;
210 MessageParcel reply;
211 reqBody.Marshalling(data);
212 mediaAssetsControllerService->AssetChangeSetTitle(data, reply);
213 }
214
AssetChangeSetEditDataFuzzer()215 static void AssetChangeSetEditDataFuzzer()
216 {
217 AssetChangeReqBody reqBody;
218 DataShare::DataShareValuesBucket valuesBucket;
219 int fileId = FDP->ConsumeIntegral<int32_t>();
220 valuesBucket.Put("file_id", fileId);
221 std::string editData = "edit_data";
222 valuesBucket.Put("edit_data", editData);
223 reqBody.values = RdbDataShareAdapter::RdbUtils::ToValuesBucket(valuesBucket);
224
225 MessageParcel data;
226 MessageParcel reply;
227 reqBody.Marshalling(data);
228 mediaAssetsControllerService->AssetChangeSetEditData(data, reply);
229 }
230
AssetChangeSubmitCacheFuzzer()231 static void AssetChangeSubmitCacheFuzzer()
232 {
233 SubmitCacheReqBody reqBody;
234 DataShare::DataShareValuesBucket valuesBucket;
235 int fileId = FDP->ConsumeIntegral<int32_t>();
236 valuesBucket.Put("file_id", fileId);
237 std::string editData = "edit_data";
238 valuesBucket.Put("edit_data", editData);
239 reqBody.values = RdbDataShareAdapter::RdbUtils::ToValuesBucket(valuesBucket);
240 reqBody.isWriteGpsAdvanced = FDP->ConsumeBool();
241
242 MessageParcel data;
243 MessageParcel reply;
244 reqBody.Marshalling(data);
245 mediaAssetsControllerService->AssetChangeSubmitCache(data, reply);
246 }
247
AssetChangeCreateAssetFuzzer()248 static void AssetChangeCreateAssetFuzzer()
249 {
250 AssetChangeReqBody reqBody;
251 reqBody.values.Put("extention", "jpg");
252 reqBody.values.Put("media_type", MEDIA_TYPE_IMAGE);
253 reqBody.values.Put("title", "20250602162718617");
254 MessageParcel data;
255 MessageParcel reply;
256 reqBody.Marshalling(data);
257 mediaAssetsControllerService->AssetChangeCreateAsset(data, reply);
258 }
259
AssetChangeAddImageFuzzer()260 static void AssetChangeAddImageFuzzer()
261 {
262 AddImageReqBody reqBody;
263 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
264 reqBody.photoId = "20250527162718617";
265 reqBody.deferredProcType = FDP->ConsumeIntegral<int32_t>();
266 MessageParcel data;
267 MessageParcel reply;
268 reqBody.Marshalling(data);
269 mediaAssetsControllerService->AssetChangeAddImage(data, reply);
270 }
271
SetCameraShotKeyFuzzer()272 static void SetCameraShotKeyFuzzer()
273 {
274 AssetChangeReqBody reqBody;
275 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
276 reqBody.cameraShotKey = "shot_key_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_test";
277 MessageParcel data;
278 MessageParcel reply;
279 reqBody.Marshalling(data);
280 mediaAssetsControllerService->SetCameraShotKey(data, reply);
281 }
282
SaveCameraPhotoFuzzer()283 static void SaveCameraPhotoFuzzer()
284 {
285 SaveCameraPhotoReqBody reqBody;
286 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
287 reqBody.needScan = FDP->ConsumeBool();
288 reqBody.path = "file//media/Photo/";
289 reqBody.photoSubType = 1;
290 reqBody.imageFileType = 1;
291 reqBody.supportedWatermarkType = FDP->ConsumeIntegral<int32_t>();
292 reqBody.cameraShotKey = "Set";
293 MessageParcel data;
294 MessageParcel reply;
295 reqBody.Marshalling(data);
296 mediaAssetsControllerService->SaveCameraPhoto(data, reply);
297 }
298
DiscardCameraPhotoFuzzer()299 static void DiscardCameraPhotoFuzzer()
300 {
301 AssetChangeReqBody reqBody;
302 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
303 MessageParcel data;
304 MessageParcel reply;
305 reqBody.Marshalling(data);
306 mediaAssetsControllerService->DiscardCameraPhoto(data, reply);
307 }
308
SetEffectModeFuzzer()309 static void SetEffectModeFuzzer()
310 {
311 AssetChangeReqBody reqBody;
312 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
313 reqBody.effectMode = FDP->ConsumeIntegral<int32_t>();
314 MessageParcel data;
315 MessageParcel reply;
316 reqBody.Marshalling(data);
317 mediaAssetsControllerService->SetEffectMode(data, reply);
318 }
319
SetOrientationFuzzer()320 static void SetOrientationFuzzer()
321 {
322 AssetChangeReqBody reqBody;
323 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
324 reqBody.orientation = FDP->ConsumeIntegral<int32_t>();
325 MessageParcel data;
326 MessageParcel reply;
327 reqBody.Marshalling(data);
328 mediaAssetsControllerService->SetOrientation(data, reply);
329 }
330
SetVideoEnhancementAttrFuzzer()331 static void SetVideoEnhancementAttrFuzzer()
332 {
333 AssetChangeReqBody reqBody;
334 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
335 reqBody.photoId = "202410011800";
336 reqBody.path = "file//media/Photo/";
337 MessageParcel data;
338 MessageParcel reply;
339 reqBody.Marshalling(data);
340 mediaAssetsControllerService->SetVideoEnhancementAttr(data, reply);
341 }
342
SetSupportedWatermarkTypeFuzzer()343 static void SetSupportedWatermarkTypeFuzzer()
344 {
345 AssetChangeReqBody reqBody;
346 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
347 reqBody.watermarkType = FDP->ConsumeIntegral<int32_t>();
348 MessageParcel data;
349 MessageParcel reply;
350 reqBody.Marshalling(data);
351 mediaAssetsControllerService->SetSupportedWatermarkType(data, reply);
352 }
353
DuplicateAssetsFuzzer()354 static void DuplicateAssetsFuzzer()
355 {
356 GetAssetsReqBody reqBody;
357 MessageParcel data;
358 MessageParcel reply;
359 reqBody.Marshalling(data);
360 mediaAssetsControllerService->GetAllDuplicateAssets(data, reply);
361 mediaAssetsControllerService->GetDuplicateAssetsToDelete(data, reply);
362 }
363
CreateAssetFuzzer()364 static void CreateAssetFuzzer()
365 {
366 CreateAssetReqBody reqBody;
367 reqBody.mediaType = MEDIA_TYPE_IMAGE;
368 reqBody.title = FDP->ConsumeBytesAsString(NUM_BYTES);
369 reqBody.extension = FDP->ConsumeBytesAsString(NUM_BYTES);
370 MessageParcel data;
371 MessageParcel reply;
372 reqBody.Marshalling(data);
373 mediaAssetsControllerService->PublicCreateAsset(data, reply);
374 CreateAssetReqBody sysReqBody;
375 sysReqBody.mediaType = MEDIA_TYPE_IMAGE;
376 sysReqBody.photoSubtype = FDP->ConsumeIntegral<int32_t>();
377 sysReqBody.displayName = FDP->ConsumeBytesAsString(NUM_BYTES);
378 sysReqBody.cameraShotKey = FDP->ConsumeBytesAsString(NUM_BYTES);
379 MessageParcel sysData;
380 MessageParcel sysReply;
381 sysReqBody.Marshalling(sysData);
382 mediaAssetsControllerService->SystemCreateAsset(sysData, sysReply);
383 }
384
CreateAssetForAppFuzzer()385 static void CreateAssetForAppFuzzer()
386 {
387 CreateAssetForAppReqBody reqBody;
388 reqBody.tokenId = FDP->ConsumeIntegral<int32_t>();
389 reqBody.mediaType = MEDIA_TYPE_IMAGE;
390 reqBody.photoSubtype = static_cast<int32_t>(PhotoSubType::DEFAULT);
391 reqBody.title = FDP->ConsumeBytesAsString(NUM_BYTES);
392 reqBody.extension = FDP->ConsumeBytesAsString(NUM_BYTES);
393 reqBody.appId = FDP->ConsumeBytesAsString(NUM_BYTES);
394 reqBody.packageName = FDP->ConsumeBytesAsString(NUM_BYTES);
395 reqBody.bundleName = FDP->ConsumeBytesAsString(NUM_BYTES);
396 MessageParcel data;
397 MessageParcel reply;
398 reqBody.Marshalling(data);
399 mediaAssetsControllerService->PublicCreateAssetForApp(data, reply);
400 mediaAssetsControllerService->SystemCreateAssetForApp(data, reply);
401 reqBody.ownerAlbumId = to_string(FDP->ConsumeIntegral<int32_t>());
402 MessageParcel album_data;
403 MessageParcel album_reply;
404 reqBody.Marshalling(album_data);
405 mediaAssetsControllerService->CreateAssetForAppWithAlbum(album_data, album_reply);
406 }
407
SetAssetTitleFuzzer()408 static void SetAssetTitleFuzzer()
409 {
410 ModifyAssetsReqBody reqBody;
411 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
412 reqBody.title = FDP->ConsumeBytesAsString(NUM_BYTES);
413 MessageParcel data;
414 MessageParcel reply;
415 reqBody.Marshalling(data);
416 mediaAssetsControllerService->SetAssetTitle(data, reply);
417 }
418
SetAssetPendingFuzzer()419 static void SetAssetPendingFuzzer()
420 {
421 ModifyAssetsReqBody reqBody;
422 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
423 reqBody.pending = FDP->ConsumeIntegral<int32_t>();
424 MessageParcel data;
425 MessageParcel reply;
426 reqBody.Marshalling(data);
427 mediaAssetsControllerService->SetAssetPending(data, reply);
428 }
429
SetAssetsFavoriteFuzzer()430 static void SetAssetsFavoriteFuzzer()
431 {
432 ModifyAssetsReqBody reqBody;
433 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
434 reqBody.favorite = FDP->ConsumeIntegral<int32_t>();
435 MessageParcel data;
436 MessageParcel reply;
437 reqBody.Marshalling(data);
438 mediaAssetsControllerService->SetAssetsFavorite(data, reply);
439 }
440
SetAssetsHiddenStatusFuzzer()441 static void SetAssetsHiddenStatusFuzzer()
442 {
443 ModifyAssetsReqBody reqBody;
444 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
445 reqBody.hiddenStatus = FDP->ConsumeIntegral<int32_t>();
446 MessageParcel data;
447 MessageParcel reply;
448 reqBody.Marshalling(data);
449 mediaAssetsControllerService->SetAssetsHiddenStatus(data, reply);
450 }
451
SetAssetsRecentShowStatusFuzzer()452 static void SetAssetsRecentShowStatusFuzzer()
453 {
454 ModifyAssetsReqBody reqBody;
455 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
456 reqBody.recentShowStatus = FDP->ConsumeIntegral<int32_t>();
457 MessageParcel data;
458 MessageParcel reply;
459 reqBody.Marshalling(data);
460 mediaAssetsControllerService->SetAssetsRecentShowStatus(data, reply);
461 }
462
SetAssetsUserCommentFuzzer()463 static void SetAssetsUserCommentFuzzer()
464 {
465 ModifyAssetsReqBody reqBody;
466 reqBody.fileIds.push_back(FDP->ConsumeIntegral<int32_t>());
467 reqBody.userComment = FDP->ConsumeBytesAsString(NUM_BYTES);
468 MessageParcel data;
469 MessageParcel reply;
470 reqBody.Marshalling(data);
471 mediaAssetsControllerService->SetAssetsUserComment(data, reply);
472 }
473
GetAssetAnalysisDataFuzzer()474 static void GetAssetAnalysisDataFuzzer()
475 {
476 GetAssetAnalysisDataReqBody reqBody;
477 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
478 reqBody.language = "zh-Hans";
479 reqBody.analysisType = FDP->ConsumeIntegral<int32_t>();
480 reqBody.analysisTotal = FDP->ConsumeBool();
481 MessageParcel data;
482 MessageParcel reply;
483 reqBody.Marshalling(data);
484 mediaAssetsControllerService->GetAssetAnalysisData(data, reply);
485 }
486
CloneAssetFuzzer()487 static void CloneAssetFuzzer()
488 {
489 CloneAssetReqBody reqBody;
490 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
491 reqBody.displayName = FDP->ConsumeBytesAsString(NUM_BYTES);
492 reqBody.title = FDP->ConsumeBytesAsString(NUM_BYTES);
493 MessageParcel data;
494 MessageParcel reply;
495 reqBody.Marshalling(data);
496 mediaAssetsControllerService->CloneAsset(data, reply);
497 }
498
RevertToOriginalFuzzer()499 static void RevertToOriginalFuzzer()
500 {
501 RevertToOriginalReqBody reqBody;
502 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
503 reqBody.fileUri = "file://media/Photo/" + to_string(reqBody.fileId);
504 MessageParcel data;
505 MessageParcel reply;
506 reqBody.Marshalling(data);
507 mediaAssetsControllerService->RevertToOriginal(data, reply);
508 }
509
ConvertFormatFuzzer()510 static void ConvertFormatFuzzer()
511 {
512 ConvertFormatReqBody reqBody;
513 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
514 reqBody.title = FDP->ConsumeBytesAsString(NUM_BYTES);
515 reqBody.extension =FDP->ConsumeBytesAsString(NUM_BYTES);
516 MessageParcel data;
517 MessageParcel reply;
518 reqBody.Marshalling(data);
519 mediaAssetsControllerService->ConvertFormat(data, reply);
520 }
521
SubmitCloudEnhancementTasksFuzzer()522 static void SubmitCloudEnhancementTasksFuzzer()
523 {
524 CloudEnhancementReqBody reqBody;
525 reqBody.hasCloudWatermark = FDP->ConsumeBool();
526 reqBody.triggerMode = 1;
527 reqBody.fileUris = { "file://media/Photo/" + to_string(FDP->ConsumeIntegral<int32_t>()) };
528 MessageParcel data;
529 MessageParcel reply;
530 reqBody.Marshalling(data);
531 mediaAssetsControllerService->SubmitCloudEnhancementTasks(data, reply);
532 mediaAssetsControllerService->PrioritizeCloudEnhancementTask(data, reply);
533 mediaAssetsControllerService->CancelCloudEnhancementTasks(data, reply);
534 mediaAssetsControllerService->CancelAllCloudEnhancementTasks(data, reply);
535 mediaAssetsControllerService->SyncCloudEnhancementTaskStatus(data, reply);
536 }
537
StartDownloadCloudMediaFuzzer()538 static void StartDownloadCloudMediaFuzzer()
539 {
540 StartDownloadCloudMediaReqBody reqBody;
541 reqBody.cloudMediaType = FDP->ConsumeBool() ? 1 : 0;
542 MessageParcel data;
543 MessageParcel reply;
544 reqBody.Marshalling(data);
545 mediaAssetsControllerService->StartDownloadCloudMedia(data, reply);
546 }
547
RetainCloudMediaAssetFuzzer()548 static void RetainCloudMediaAssetFuzzer()
549 {
550 RetainCloudMediaAssetReqBody reqBody;
551 reqBody.cloudMediaRetainType = FDP->ConsumeBool() ? 1 : 0;
552 MessageParcel data;
553 MessageParcel reply;
554 reqBody.Marshalling(data);
555 mediaAssetsControllerService->RetainCloudMediaAsset(data, reply);
556 }
557
GetCloudMediaAssetStatusFuzzer()558 static void GetCloudMediaAssetStatusFuzzer()
559 {
560 GetCloudMediaAssetStatusReqBody reqBody;
561 MessageParcel data;
562 MessageParcel reply;
563 reqBody.Marshalling(data);
564 mediaAssetsControllerService->GetCloudMediaAssetStatus(data, reply);
565 }
566
GetEditDataFuzzer()567 static void GetEditDataFuzzer()
568 {
569 GetEditDataReqBody reqBody;
570 reqBody.predicates.EqualTo("file_id", "1111111");
571 MessageParcel data;
572 MessageParcel reply;
573 reqBody.Marshalling(data);
574 mediaAssetsControllerService->GetEditData(data, reply);
575 }
576
RequestEditDataFuzzer()577 static void RequestEditDataFuzzer()
578 {
579 RequestEditDataReqBody reqBody;
580 reqBody.predicates.EqualTo("file_id", "1111111");
581 MessageParcel data;
582 MessageParcel reply;
583 reqBody.Marshalling(data);
584 mediaAssetsControllerService->RequestEditData(data, reply);
585 }
586
IsEditedFuzzer()587 static void IsEditedFuzzer()
588 {
589 IsEditedReqBody reqBody;
590 reqBody.fileId = 1;
591 MessageParcel data;
592 MessageParcel reply;
593 reqBody.Marshalling(data);
594 mediaAssetsControllerService->IsEdited(data, reply);
595 }
596
StartAssetAnalysisFuzzer()597 static void StartAssetAnalysisFuzzer()
598 {
599 StartAssetAnalysisReqBody reqBody;
600 std::vector<std::string> fileIds{"111111", "222222", to_string(FDP->ConsumeIntegral<int32_t>())};
601 reqBody.predicates.In("Photos.file_id", fileIds);
602 MessageParcel data;
603 MessageParcel reply;
604 reqBody.Marshalling(data);
605 mediaAssetsControllerService->StartAssetAnalysis(data, reply);
606 }
607
GrantPhotoUriPermissionFuzzer()608 static void GrantPhotoUriPermissionFuzzer()
609 {
610 GrantUriPermissionReqBody reqBody;
611 reqBody.tokenId = FDP->ConsumeIntegral<int64_t>();
612 reqBody.srcTokenId = FDP->ConsumeIntegral<int64_t>();
613 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
614 reqBody.permissionType = FDP->ConsumeIntegral<int32_t>();
615 reqBody.hideSensitiveType = FDP->ConsumeIntegral<int32_t>();
616 reqBody.uriType = FDP->ConsumeIntegral<int32_t>();
617 MessageParcel data;
618 MessageParcel reply;
619 reqBody.Marshalling(data);
620 mediaAssetsControllerService->GrantPhotoUriPermission(data, reply);
621 }
622
GrantPhotoUrisPermissionFuzzer()623 static void GrantPhotoUrisPermissionFuzzer()
624 {
625 GrantUrisPermissionReqBody reqBody;
626 reqBody.tokenId = FDP->ConsumeIntegral<int64_t>();
627 reqBody.srcTokenId = FDP->ConsumeIntegral<int64_t>();
628 reqBody.fileIds = {FDP->ConsumeIntegral<int32_t>()};
629 reqBody.permissionType = FDP->ConsumeIntegral<int32_t>();
630 reqBody.hideSensitiveType = FDP->ConsumeIntegral<int32_t>();
631 reqBody.uriType = FDP->ConsumeIntegral<int32_t>();
632 MessageParcel data;
633 MessageParcel reply;
634 reqBody.Marshalling(data);
635 mediaAssetsControllerService->GrantPhotoUrisPermission(data, reply);
636 }
637
CancelPhotoUriPermissionFuzzer()638 static void CancelPhotoUriPermissionFuzzer()
639 {
640 CancelUriPermissionReqBody reqBody;
641 reqBody.tokenId = FDP->ConsumeIntegral<int64_t>();
642 reqBody.srcTokenId = FDP->ConsumeIntegral<int64_t>();
643 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
644 reqBody.permissionType = FDP->ConsumeIntegral<int32_t>();
645 reqBody.uriType = FDP->ConsumeIntegral<int32_t>();
646 MessageParcel data;
647 MessageParcel reply;
648 reqBody.Marshalling(data);
649 mediaAssetsControllerService->CancelPhotoUriPermission(data, reply);
650 }
651
StartThumbnailCreationTaskFuzzer()652 static void StartThumbnailCreationTaskFuzzer()
653 {
654 StartThumbnailCreationTaskReqBody reqBody;
655 reqBody.requestId = FDP->ConsumeIntegral<int32_t>();
656 MessageParcel data;
657 MessageParcel reply;
658 reqBody.Marshalling(data);
659 mediaAssetsControllerService->StartThumbnailCreationTask(data, reply);
660 }
661
StopThumbnailCreationTaskFuzzer()662 static void StopThumbnailCreationTaskFuzzer()
663 {
664 StopThumbnailCreationTaskReqBody reqBody;
665 reqBody.requestId = FDP->ConsumeIntegral<int32_t>();
666 MessageParcel data;
667 MessageParcel reply;
668 reqBody.Marshalling(data);
669 mediaAssetsControllerService->StopThumbnailCreationTask(data, reply);
670 }
671
RequestContentFuzzer()672 static void RequestContentFuzzer()
673 {
674 RequestContentReqBody reqBody;
675 reqBody.mediaId = to_string(FDP->ConsumeIntegral<int32_t>());
676 MessageParcel data;
677 MessageParcel reply;
678 reqBody.Marshalling(data);
679 mediaAssetsControllerService->RequestContent(data, reply);
680 }
681
GetCloudEnhancementPairFuzzer()682 static void GetCloudEnhancementPairFuzzer()
683 {
684 GetCloudEnhancementPairReqBody reqBody;
685 reqBody.photoUri = FDP->ConsumeBytesAsString(NUM_BYTES);
686
687 MessageParcel data;
688 MessageParcel reply;
689 reqBody.Marshalling(data);
690 mediaAssetsControllerService->GetCloudEnhancementPair(data, reply);
691 }
692
QueryCloudEnhancementTaskStateFuzzer()693 static void QueryCloudEnhancementTaskStateFuzzer()
694 {
695 QueryCloudEnhancementTaskStateReqBody reqBody;
696 reqBody.photoUri = FDP->ConsumeBytesAsString(NUM_BYTES);
697
698 MessageParcel data;
699 MessageParcel reply;
700 reqBody.Marshalling(data);
701 mediaAssetsControllerService->QueryCloudEnhancementTaskState(data, reply);
702 }
703
QueryPhotoStatusFuzzer()704 static void QueryPhotoStatusFuzzer()
705 {
706 QueryPhotoReqBody reqBody;
707 reqBody.fileId = std::to_string(FDP->ConsumeIntegral<int32_t>());
708
709 MessageParcel data;
710 MessageParcel reply;
711 reqBody.Marshalling(data);
712 mediaAssetsControllerService->QueryPhotoStatus(data, reply);
713 }
714
LogMovingPhotoFuzzer()715 static void LogMovingPhotoFuzzer()
716 {
717 AdaptedReqBody reqBody;
718 reqBody.adapted = FDP->ConsumeBool();
719
720 MessageParcel data;
721 MessageParcel reply;
722 reqBody.Marshalling(data);
723 mediaAssetsControllerService->LogMovingPhoto(data, reply);
724 }
725
AddAssetVisitCountFuzzer()726 static void AddAssetVisitCountFuzzer()
727 {
728 AddAssetVisitCountReqBody reqBody;
729 reqBody.fileId = FDP->ConsumeIntegral<int32_t>();
730 reqBody.visitType = FDP->ConsumeIntegral<int32_t>();
731 MessageParcel data;
732 MessageParcel reply;
733 reqBody.Marshalling(data);
734 mediaAssetsControllerService->AddAssetVisitCount(data, reply);
735 }
736
GrantPhotoUriPermissionInnerFuzzer()737 static void GrantPhotoUriPermissionInnerFuzzer()
738 {
739 GrantUrisPermissionInnerReqBody reqBody;
740 reqBody.tokenId = FDP->ConsumeIntegral<int64_t>();
741 reqBody.srcTokenId = FDP->ConsumeIntegral<int64_t>();
742 reqBody.fileIds = {FDP->ConsumeBytesAsString(NUM_BYTES)};
743 reqBody.permissionTypes = {FDP->ConsumeIntegral<int32_t>()};
744 reqBody.hideSensitiveType = FDP->ConsumeIntegral<int32_t>();
745 reqBody.uriTypes = {FDP->ConsumeIntegral<int32_t>()};
746 MessageParcel data;
747 MessageParcel reply;
748 reqBody.Marshalling(data);
749 mediaAssetsControllerService->GrantPhotoUriPermissionInner(data, reply);
750 }
751
CancelPhotoUriPermissionInnerFuzzer()752 static void CancelPhotoUriPermissionInnerFuzzer()
753 {
754 CancelUriPermissionInnerReqBody reqBody;
755 reqBody.targetTokenId = FDP->ConsumeIntegral<int64_t>();
756 reqBody.srcTokenId = FDP->ConsumeIntegral<int64_t>();
757 reqBody.fileIds = {FDP->ConsumeBytesAsString(NUM_BYTES)};
758 reqBody.uriTypes = {FDP->ConsumeIntegral<int32_t>()};
759 reqBody.permissionTypes = {{FDP->ConsumeBytesAsString(NUM_BYTES)}};
760 MessageParcel data;
761 MessageParcel reply;
762 reqBody.Marshalling(data);
763 mediaAssetsControllerService->CancelPhotoUriPermissionInner(data, reply);
764 }
765
GetResultSetFromDbFuzzer()766 static void GetResultSetFromDbFuzzer()
767 {
768 GetResultSetFromDbReqBody reqBody;
769 reqBody.columnName = FDP->ConsumeBytesAsString(NUM_BYTES);
770 reqBody.value = FDP->ConsumeBytesAsString(NUM_BYTES);
771 reqBody.columns = {FDP->ConsumeBytesAsString(NUM_BYTES)};
772 MessageParcel data;
773 MessageParcel reply;
774 reqBody.Marshalling(data);
775 mediaAssetsControllerService->GetResultSetFromDb(data, reply);
776 }
777
GetResultSetFromPhotosExtendFuzzer()778 static void GetResultSetFromPhotosExtendFuzzer()
779 {
780 GetResultSetFromPhotosExtendReqBody reqBody;
781 reqBody.value = FDP->ConsumeBytesAsString(NUM_BYTES);
782 reqBody.columns = {FDP->ConsumeBytesAsString(NUM_BYTES)};
783 MessageParcel data;
784 MessageParcel reply;
785 reqBody.Marshalling(data);
786 mediaAssetsControllerService->GetResultSetFromPhotosExtend(data, reply);
787 }
788
GetMovingPhotoDateModifiedFuzzer()789 static void GetMovingPhotoDateModifiedFuzzer()
790 {
791 GetMovingPhotoDateModifiedReqBody reqBody;
792 reqBody.fileId = to_string(FDP->ConsumeIntegral<int32_t>());
793
794 MessageParcel data;
795 MessageParcel reply;
796 reqBody.Marshalling(data);
797 mediaAssetsControllerService->GetMovingPhotoDateModified(data, reply);
798 }
799
GetFilePathFromUriFuzzer()800 static void GetFilePathFromUriFuzzer()
801 {
802 GetFilePathFromUriReqBody reqBody;
803 reqBody.virtualId = to_string(FDP->ConsumeIntegral<int32_t>());
804
805 MessageParcel data;
806 MessageParcel reply;
807 reqBody.Marshalling(data);
808 mediaAssetsControllerService->GetFilePathFromUri(data, reply);
809 }
810
GetUriFromFilePathFuzzer()811 static void GetUriFromFilePathFuzzer()
812 {
813 GetUriFromFilePathReqBody reqBody;
814 reqBody.tempPath = to_string(FDP->ConsumeIntegral<int32_t>());
815
816 MessageParcel data;
817 MessageParcel reply;
818 reqBody.Marshalling(data);
819 mediaAssetsControllerService->GetUriFromFilePath(data, reply);
820 }
821
CloseAssetFuzzer()822 static void CloseAssetFuzzer()
823 {
824 CloseAssetReqBody reqBody;
825 reqBody.uri = FDP->ConsumeBytesAsString(NUM_BYTES);
826
827 MessageParcel data;
828 MessageParcel reply;
829 reqBody.Marshalling(data);
830 mediaAssetsControllerService->CloseAsset(data, reply);
831 }
832
CheckUriPermissionInnerFuzzer()833 static void CheckUriPermissionInnerFuzzer()
834 {
835 CheckUriPermissionInnerReqBody reqBody;
836 reqBody.targetTokenId = FDP->ConsumeIntegral<int64_t>();
837 reqBody.uriType = FDP->ConsumeBytesAsString(NUM_BYTES);
838 reqBody.fileIds = {FDP->ConsumeBytesAsString(NUM_BYTES)};
839 reqBody.columns = {FDP->ConsumeBytesAsString(NUM_BYTES)};
840 MessageParcel data;
841 MessageParcel reply;
842 reqBody.Marshalling(data);
843 mediaAssetsControllerService->CheckUriPermissionInner(data, reply);
844 }
845
GetUrisByOldUrisInnerFuzzer()846 static void GetUrisByOldUrisInnerFuzzer()
847 {
848 GetUrisByOldUrisInnerReqBody reqBody;
849 reqBody.uris = {FDP->ConsumeBytesAsString(NUM_BYTES)};
850 reqBody.columns.push_back(TabOldPhotosColumn::OLD_PHOTOS_TABLE + "." + "file_id");
851 reqBody.columns.push_back(TabOldPhotosColumn::OLD_PHOTOS_TABLE + "." + "data");
852 reqBody.columns.push_back(TabOldPhotosColumn::OLD_PHOTOS_TABLE + "." + "old_file_id");
853 reqBody.columns.push_back(TabOldPhotosColumn::OLD_PHOTOS_TABLE + "." + "old_data");
854 reqBody.columns.push_back(PhotoColumn::PHOTOS_TABLE + "." + "display_name");
855
856 MessageParcel data;
857 MessageParcel reply;
858 reqBody.Marshalling(data);
859 mediaAssetsControllerService->GetUrisByOldUrisInner(data, reply);
860 }
861
RestoreFuzzer()862 static void RestoreFuzzer()
863 {
864 RestoreReqBody reqBody;
865 reqBody.albumLpath = "/" + FDP->ConsumeBytesAsString(NUM_BYTES);
866 reqBody.keyPath = FDP->ConsumeBytesAsString(NUM_BYTES);
867 reqBody.bundleName = FDP->ConsumeBytesAsString(NUM_BYTES);
868 reqBody.appName = FDP->ConsumeBytesAsString(NUM_BYTES);
869 reqBody.appId = FDP->ConsumeBytesAsString(NUM_BYTES);
870 reqBody.isDeduplication = FDP->ConsumeBool();
871
872 MessageParcel data;
873 MessageParcel reply;
874 reqBody.Marshalling(data);
875 mediaAssetsControllerService->Restore(data, reply);
876 }
877
StopRestoreFuzzer()878 static void StopRestoreFuzzer()
879 {
880 StopRestoreReqBody reqBody;
881 reqBody.keyPath = FDP->ConsumeBytesAsString(NUM_BYTES);
882
883 MessageParcel data;
884 MessageParcel reply;
885 reqBody.Marshalling(data);
886 mediaAssetsControllerService->StopRestore(data, reply);
887 }
888
GetAssetsFuzzer()889 static void GetAssetsFuzzer()
890 {
891 GetAssetsReqBody reqBody;
892 MessageParcel data;
893 MessageParcel reply;
894 reqBody.Marshalling(data);
895 OHOS::Media::IPC::IPCContext context(MessageOption(), 0);
896 mediaAssetsControllerService->GetAssets(data, reply, context);
897 }
898
GetBurstAssetsFuzzer()899 static void GetBurstAssetsFuzzer()
900 {
901 GetAssetsReqBody reqBody;
902 reqBody.burstKey = FDP->ConsumeBytesAsString(NUM_BYTES);
903 MessageParcel data;
904 MessageParcel reply;
905 reqBody.Marshalling(data);
906 OHOS::Media::IPC::IPCContext context(MessageOption(), 0);
907 mediaAssetsControllerService->GetBurstAssets(data, reply, context);
908 }
909
MediaAssetsControllerServiceFirstFuzzer()910 static void MediaAssetsControllerServiceFirstFuzzer()
911 {
912 FormInfoFuzzer();
913 CommitEditedAssetFuzzer();
914 SysTrashPhotosFuzzer();
915 DeletePhotosFuzzer();
916 DeletePhotosCompletedFuzzer();
917 AssetChangeSetFavoriteFuzzer();
918 AssetChangeSetHiddenFuzzer();
919 AssetChangeSetUserCommentFuzzer();
920 AssetChangeSetLocationFuzzer();
921 AssetChangeSetTitleFuzzer();
922 AssetChangeSetEditDataFuzzer();
923 AssetChangeSubmitCacheFuzzer();
924 AssetChangeCreateAssetFuzzer();
925 AssetChangeAddImageFuzzer();
926 SetCameraShotKeyFuzzer();
927 SaveCameraPhotoFuzzer();
928 DiscardCameraPhotoFuzzer();
929 SetEffectModeFuzzer();
930 SetOrientationFuzzer();
931 SetVideoEnhancementAttrFuzzer();
932 SetSupportedWatermarkTypeFuzzer();
933 DuplicateAssetsFuzzer();
934 CreateAssetFuzzer();
935 CreateAssetForAppFuzzer();
936 SetAssetTitleFuzzer();
937 SetAssetPendingFuzzer();
938 SetAssetsFavoriteFuzzer();
939 SetAssetsHiddenStatusFuzzer();
940 SetAssetsRecentShowStatusFuzzer();
941 SetAssetsUserCommentFuzzer();
942 GetAssetAnalysisDataFuzzer();
943 CloneAssetFuzzer();
944 RevertToOriginalFuzzer();
945 ConvertFormatFuzzer();
946 SubmitCloudEnhancementTasksFuzzer();
947 StartDownloadCloudMediaFuzzer();
948 RetainCloudMediaAssetFuzzer();
949 GetCloudMediaAssetStatusFuzzer();
950 GetEditDataFuzzer();
951 }
952
MediaAssetsControllerServiceSecondFuzzer()953 static void MediaAssetsControllerServiceSecondFuzzer()
954 {
955 RequestEditDataFuzzer();
956 IsEditedFuzzer();
957 StartAssetAnalysisFuzzer();
958 GrantPhotoUriPermissionFuzzer();
959 GrantPhotoUrisPermissionFuzzer();
960 CancelPhotoUriPermissionFuzzer();
961 StartThumbnailCreationTaskFuzzer();
962 StopThumbnailCreationTaskFuzzer();
963 RequestContentFuzzer();
964 GetCloudEnhancementPairFuzzer();
965 QueryCloudEnhancementTaskStateFuzzer();
966 QueryPhotoStatusFuzzer();
967 LogMovingPhotoFuzzer();
968 AddAssetVisitCountFuzzer();
969 GrantPhotoUriPermissionInnerFuzzer();
970 CancelPhotoUriPermissionInnerFuzzer();
971 GetResultSetFromDbFuzzer();
972 GetResultSetFromPhotosExtendFuzzer();
973 GetMovingPhotoDateModifiedFuzzer();
974 GetFilePathFromUriFuzzer();
975 GetUriFromFilePathFuzzer();
976 CloseAssetFuzzer();
977 CheckUriPermissionInnerFuzzer();
978 GetUrisByOldUrisInnerFuzzer();
979 RestoreFuzzer();
980 StopRestoreFuzzer();
981 GetAssetsFuzzer();
982 GetBurstAssetsFuzzer();
983
984 MessageParcel dataParcel;
985 MessageParcel reply;
986 mediaAssetsControllerService->GetIndexConstructProgress(dataParcel, reply);
987 mediaAssetsControllerService->PauseDownloadCloudMedia(dataParcel, reply);
988 mediaAssetsControllerService->CancelDownloadCloudMedia(dataParcel, reply);
989 }
990
Init()991 static void Init()
992 {
993 shared_ptr<MediaAssetsControllerService> mediaAssetsControllerService =
994 make_shared<MediaAssetsControllerService>();
995 }
996 } // namespace OHOS
997
LLVMFuzzerInitialize(int * argc,char *** argv)998 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
999 {
1000 OHOS::Init();
1001 return 0;
1002 }
1003
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1004 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1005 {
1006 /* Run your code on data */
1007 FuzzedDataProvider fdp(data, size);
1008 if (data == nullptr) {
1009 return 0;
1010 }
1011 OHOS::FDP = &fdp;
1012 OHOS::MediaAssetsControllerServiceFirstFuzzer();
1013 OHOS::MediaAssetsControllerServiceSecondFuzzer();
1014 return 0;
1015 }
