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 #include "medialibrary_mtpmedialibrary_fuzzer.h"
16
17 #include <cstdint>
18 #include <string>
19 #include <vector>
20 #include <fstream>
21 #include <fuzzer/FuzzedDataProvider.h>
22
23 #include "system_ability_definition.h"
24 #include "iservice_registry.h"
25 #include "userfilemgr_uri.h"
26 #include "payload_data.h"
27 #include "close_session_data.h"
28 #include "medialibrary_errno.h"
29 #include "media_log.h"
30
31 #define private public
32 #include "mtp_media_library.h"
33 #undef private
34
35 namespace OHOS {
36 using namespace std;
37 using namespace Media;
38 static const int32_t NUM_BYTES = 1;
39 static const int32_t MAX_BYTE_VALUE = 256;
40 static const int32_t SEED_SIZE = 1024;
41 // storage file
42 const std::string STORAGE_FILE = "/storage/media/local/files/Docs";
43 // file path
44 const string FILE_PATH = "/storage/media/local/files/Docs/Desktop";
45 const shared_ptr<MtpMediaLibrary> mtpMediaLib_ = MtpMediaLibrary::GetInstance();
46 FuzzedDataProvider *provider = nullptr;
47
FuzzVectorUInt32()48 static inline vector<uint32_t> FuzzVectorUInt32()
49 {
50 return {provider->ConsumeIntegral<uint32_t>()};
51 }
52
FuzzMtpOperationContext()53 static MtpOperationContext FuzzMtpOperationContext()
54 {
55 MtpOperationContext context;
56 context.operationCode = provider->ConsumeIntegral<uint16_t>();
57 context.transactionID = provider->ConsumeIntegral<uint32_t>();
58 context.devicePropertyCode = provider->ConsumeIntegral<uint32_t>();
59 context.storageID = provider->ConsumeIntegral<uint32_t>();
60 context.format = provider->ConsumeIntegral<uint16_t>();
61 context.parent = provider->ConsumeIntegral<uint32_t>();
62 context.handle = provider->ConsumeIntegral<uint32_t>();
63 context.property = provider->ConsumeIntegral<uint32_t>();
64 context.groupCode = provider->ConsumeIntegral<uint32_t>();
65 context.depth = provider->ConsumeIntegral<uint32_t>();
66 context.properStrValue = provider->ConsumeBytesAsString(NUM_BYTES);
67 context.properIntValue = provider->ConsumeIntegral<int64_t>();
68 context.handles = make_shared<UInt32List>(FuzzVectorUInt32());
69 context.name = provider->ConsumeBytesAsString(NUM_BYTES);
70 context.created = provider->ConsumeBytesAsString(NUM_BYTES);
71 context.modified = provider->ConsumeBytesAsString(NUM_BYTES);
72 context.indata = provider->ConsumeBool();
73 context.storageInfoID = provider->ConsumeIntegral<uint32_t>();
74 context.sessionOpen = provider->ConsumeBool();
75 context.sessionID = provider->ConsumeIntegral<uint32_t>();
76 context.mtpDriver = make_shared<MtpDriver>();
77 context.tempSessionID = provider->ConsumeIntegral<uint32_t>();
78 context.eventHandle = provider->ConsumeIntegral<uint32_t>();
79 context.eventProperty = provider->ConsumeIntegral<uint32_t>();
80 return context;
81 }
82
FuzzObjectInfo()83 static ObjectInfo FuzzObjectInfo()
84 {
85 ObjectInfo objectInfo(0);
86 objectInfo.handle = provider->ConsumeIntegral<uint32_t>();
87 objectInfo.storageID = provider->ConsumeIntegral<uint32_t>();
88 objectInfo.format = provider->ConsumeIntegral<uint16_t>();
89 objectInfo.protectionStatus = provider->ConsumeIntegral<uint16_t>();
90 objectInfo.compressedSize = provider->ConsumeIntegral<uint32_t>();
91 objectInfo.size = provider->ConsumeIntegral<uint32_t>();
92 objectInfo.thumbFormat = provider->ConsumeIntegral<uint16_t>();
93 objectInfo.thumbCompressedSize = provider->ConsumeIntegral<uint32_t>();
94 objectInfo.thumbPixelWidth = provider->ConsumeIntegral<uint32_t>();
95 objectInfo.thumbPixelHeight = provider->ConsumeIntegral<uint32_t>();
96 objectInfo.imagePixelWidth = provider->ConsumeIntegral<uint32_t>();
97 objectInfo.imagePixelHeight = provider->ConsumeIntegral<uint32_t>();
98 objectInfo.imagePixelDepth = provider->ConsumeIntegral<uint32_t>();
99 objectInfo.parent = provider->ConsumeIntegral<uint32_t>();
100 objectInfo.associationType = provider->ConsumeIntegral<uint16_t>();
101 objectInfo.associationDesc = provider->ConsumeIntegral<uint32_t>();
102 objectInfo.sequenceNumber = provider->ConsumeIntegral<uint32_t>();
103 objectInfo.name = provider->ConsumeBytesAsString(NUM_BYTES);
104 objectInfo.keywords = provider->ConsumeBytesAsString(NUM_BYTES);
105 return objectInfo;
106 }
107
AddPathToMapTest()108 static void AddPathToMapTest()
109 {
110 if (mtpMediaLib_ == nullptr) {
111 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
112 return;
113 }
114 mtpMediaLib_->AddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
115 mtpMediaLib_->Clear();
116 }
117
ObserverAddPathToMapTest()118 static void ObserverAddPathToMapTest()
119 {
120 if (mtpMediaLib_ == nullptr) {
121 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
122 return;
123 }
124 mtpMediaLib_->Clear();
125 mtpMediaLib_->ObserverAddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
126
127 uint32_t parentId = 0;
128 mtpMediaLib_->GetIdByPath(provider->ConsumeBytesAsString(NUM_BYTES), parentId);
129 vector<int> outHandles;
130 mtpMediaLib_->GetHandles(parentId, outHandles, MEDIA_TYPE_FILE);
131 }
132
GetHandlesTest()133 static void GetHandlesTest()
134 {
135 if (mtpMediaLib_ == nullptr) {
136 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
137 return;
138 }
139 mtpMediaLib_->Clear();
140 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
141 FuzzMtpOperationContext());
142 if (context == nullptr) {
143 MEDIA_ERR_LOG("context is nullptr");
144 return;
145 }
146 mtpMediaLib_->ObserverAddPathToMap(FILE_PATH);
147 mtpMediaLib_->ObserverAddPathToMap(FILE_PATH + "/" + provider->ConsumeBytesAsString(NUM_BYTES) + ".txt");
148
149 uint32_t parentId = 0;
150 shared_ptr<UInt32List> outHandles = make_shared<UInt32List>(FuzzVectorUInt32());
151 mtpMediaLib_->GetIdByPath(FILE_PATH, parentId);
152 context->parent = parentId;
153 context->storageID = parentId;
154 mtpMediaLib_->GetHandles(context, outHandles);
155 }
156
GetObjectInfoTest()157 static void GetObjectInfoTest()
158 {
159 if (mtpMediaLib_ == nullptr) {
160 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
161 return;
162 }
163 mtpMediaLib_->Clear();
164 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
165 FuzzMtpOperationContext());
166 if (context == nullptr) {
167 MEDIA_ERR_LOG("context is nullptr");
168 return;
169 }
170 shared_ptr<ObjectInfo> objectInfo = make_shared<ObjectInfo>(FuzzObjectInfo());
171 context->handle = 1;
172 mtpMediaLib_->GetObjectInfo(context, objectInfo);
173 }
174
GetFdTest()175 static void GetFdTest()
176 {
177 if (mtpMediaLib_ == nullptr) {
178 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
179 return;
180 }
181 mtpMediaLib_->Clear();
182 shared_ptr<MtpOperationContext> context = nullptr;
183 bool condition = false;
184 int fd = 0;
185 mtpMediaLib_->CondCloseFd(condition, fd);
186
187 int32_t outFd = provider->ConsumeIntegral<int32_t>();
188 mtpMediaLib_->GetFd(context, outFd);
189 }
190
GetThumbTest()191 static void GetThumbTest()
192 {
193 if (mtpMediaLib_ == nullptr) {
194 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
195 return;
196 }
197 mtpMediaLib_->Clear();
198 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
199 FuzzMtpOperationContext());
200 if (context == nullptr) {
201 MEDIA_ERR_LOG("context is nullptr");
202 return;
203 }
204
205 shared_ptr<UInt8List> outThumb = make_shared<UInt8List>(provider->ConsumeBytes<uint8_t>(NUM_BYTES));
206 mtpMediaLib_->AddToHandlePathMap(FILE_PATH + "/" + provider->ConsumeBytesAsString(NUM_BYTES) +
207 ".txt", provider->ConsumeIntegral<uint32_t>());
208 mtpMediaLib_->GetThumb(context, outThumb);
209 }
210
SendObjectInfoTest()211 static void SendObjectInfoTest()
212 {
213 if (mtpMediaLib_ == nullptr) {
214 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
215 return;
216 }
217 mtpMediaLib_->Clear();
218 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
219 FuzzMtpOperationContext());
220 if (context == nullptr) {
221 MEDIA_ERR_LOG("context is nullptr");
222 return;
223 }
224
225 uint32_t outStorageID = provider->ConsumeIntegral<uint32_t>();
226 uint32_t outParent = provider->ConsumeIntegral<uint32_t>();
227 uint32_t outHandle = provider->ConsumeIntegral<uint32_t>();
228
229 mtpMediaLib_->SendObjectInfo(context, outStorageID, outParent, outHandle);
230
231 context->format = MTP_FORMAT_ASSOCIATION_CODE;
232 mtpMediaLib_->SendObjectInfo(context, outStorageID, outParent, outHandle);
233 }
234
MoveObjectTest()235 static void MoveObjectTest()
236 {
237 if (mtpMediaLib_ == nullptr) {
238 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
239 return;
240 }
241 mtpMediaLib_->Clear();
242 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
243 FuzzMtpOperationContext());
244 if (context == nullptr) {
245 MEDIA_ERR_LOG("context is nullptr");
246 return;
247 }
248
249 mtpMediaLib_->ObserverAddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
250 string from = provider->ConsumeBytesAsString(NUM_BYTES);
251 mtpMediaLib_->ObserverAddPathToMap(from);
252 string to = provider->ConsumeBytesAsString(NUM_BYTES);
253 uint32_t fromId = 0;
254 mtpMediaLib_->GetIdByPath(from, fromId);
255 uint32_t parentId = 0;
256 mtpMediaLib_->GetIdByPath(from, parentId);
257 context->handle = fromId;
258 context->parent = parentId;
259 mtpMediaLib_->MoveObject(context, parentId);
260 }
261
CopyObjectTest()262 static void CopyObjectTest()
263 {
264 if (mtpMediaLib_ == nullptr) {
265 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
266 return;
267 }
268 mtpMediaLib_->Clear();
269 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
270 FuzzMtpOperationContext());
271 if (context == nullptr) {
272 MEDIA_ERR_LOG("context is nullptr");
273 return;
274 }
275
276 mtpMediaLib_->AddToHandlePathMap(FILE_PATH + "/" + provider->ConsumeBytesAsString(NUM_BYTES),
277 provider->ConsumeIntegral<uint32_t>());
278 uint32_t outObjectHandle = provider->ConsumeIntegral<uint32_t>();
279 uint32_t oldHandle = provider->ConsumeIntegral<uint32_t>();
280 mtpMediaLib_->CopyObject(context, outObjectHandle, oldHandle);
281 mtpMediaLib_->DeleteObject(context);
282 }
283
SetObjectPropValueTest()284 static void SetObjectPropValueTest()
285 {
286 if (mtpMediaLib_ == nullptr) {
287 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
288 return;
289 }
290 mtpMediaLib_->Clear();
291 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
292 FuzzMtpOperationContext());
293 if (context == nullptr) {
294 MEDIA_ERR_LOG("context is nullptr");
295 return;
296 }
297 mtpMediaLib_->AddToHandlePathMap(FILE_PATH + "/" + provider->ConsumeBytesAsString(NUM_BYTES) + ".txt",
298 provider->ConsumeIntegral<uint32_t>());
299
300 mtpMediaLib_->SetObjectPropValue(context);
301 }
302
CloseFdTest()303 static void CloseFdTest()
304 {
305 if (mtpMediaLib_ == nullptr) {
306 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
307 return;
308 }
309 mtpMediaLib_->Clear();
310 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
311 FuzzMtpOperationContext());
312 if (context == nullptr) {
313 MEDIA_ERR_LOG("context is nullptr");
314 return;
315 }
316 mtpMediaLib_->ObserverAddPathToMap(FILE_PATH);
317 mtpMediaLib_->ObserverAddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
318
319 uint32_t handle = 0;
320 mtpMediaLib_->GetIdByPath(provider->ConsumeBytesAsString(NUM_BYTES), handle);
321 context->handle = handle;
322 int32_t outFd = provider->ConsumeIntegral<int32_t>();
323 mtpMediaLib_->GetFd(context, outFd);
324 mtpMediaLib_->CloseFd(context, outFd);
325 }
326
GetObjectPropListTest()327 static void GetObjectPropListTest()
328 {
329 if (mtpMediaLib_ == nullptr) {
330 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
331 return;
332 }
333 mtpMediaLib_->Clear();
334 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
335 FuzzMtpOperationContext());
336 if (context == nullptr) {
337 MEDIA_ERR_LOG("context is nullptr");
338 return;
339 }
340 shared_ptr<vector<Property>> outProps = make_shared<vector<Property>>();
341 context->groupCode = 0;
342 mtpMediaLib_->GetObjectPropList(context, outProps);
343
344 context->property = provider->ConsumeIntegral<uint32_t>();
345 context->depth = MTP_ALL_DEPTH;
346 context->handle = 0;
347 mtpMediaLib_->GetObjectPropList(context, outProps);
348 }
349
GetObjectPropValueTest()350 static void GetObjectPropValueTest()
351 {
352 if (mtpMediaLib_ == nullptr) {
353 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
354 return;
355 }
356 mtpMediaLib_->Clear();
357 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
358 FuzzMtpOperationContext());
359 if (context == nullptr) {
360 MEDIA_ERR_LOG("context is nullptr");
361 return;
362 }
363 uint64_t outIntVal = 0;
364 uint128_t outLongVal = { 0 };
365 string outStrVal = "";
366 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
367 mtpMediaLib_->GetObjectPropValue(context, outIntVal, outLongVal, outStrVal);
368 mtpMediaLib_->DeleteHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
369 }
370
GetRealPathTest()371 static void GetRealPathTest()
372 {
373 if (mtpMediaLib_ == nullptr) {
374 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
375 return;
376 }
377 mtpMediaLib_->Clear();
378 string outPath = "";
379 mtpMediaLib_->GetRealPath(provider->ConsumeBytesAsString(NUM_BYTES), outPath);
380 }
381
382
MtpMediaLibraryStorageTest()383 static void MtpMediaLibraryStorageTest()
384 {
385 if (mtpMediaLib_ == nullptr) {
386 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
387 return;
388 }
389 mtpMediaLib_->Clear();
390 string fsUuid = provider->ConsumeBytesAsString(NUM_BYTES);
391 uint32_t storageId = provider->ConsumeIntegral<uint32_t>();
392 mtpMediaLib_->TryAddExternalStorage(fsUuid, storageId);
393 mtpMediaLib_->TryRemoveExternalStorage(fsUuid, storageId);
394 mtpMediaLib_->GetStorageIds();
395 }
396
ObserverDeletePathToMapTest()397 static void ObserverDeletePathToMapTest()
398 {
399 if (mtpMediaLib_ == nullptr) {
400 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
401 return;
402 }
403 mtpMediaLib_->Clear();
404 mtpMediaLib_->ObserverAddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
405 mtpMediaLib_->ObserverDeletePathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
406 }
407
ModifyHandlePathMapTest()408 static void ModifyHandlePathMapTest()
409 {
410 if (mtpMediaLib_ == nullptr) {
411 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
412 return;
413 }
414 mtpMediaLib_->Clear();
415 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
416
417 mtpMediaLib_->ModifyHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES),
418 provider->ConsumeBytesAsString(NUM_BYTES));
419
420 uint32_t id = provider->ConsumeIntegral<uint32_t>();
421 mtpMediaLib_->ModifyPathHandleMap(provider->ConsumeBytesAsString(NUM_BYTES), id);
422 }
423
StartsWithTest()424 static void StartsWithTest()
425 {
426 if (mtpMediaLib_ == nullptr) {
427 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
428 return;
429 }
430 mtpMediaLib_->Clear();
431
432 string str = provider->ConsumeBytesAsString(NUM_BYTES);
433 string prefix = provider->ConsumeBytesAsString(NUM_BYTES);
434 mtpMediaLib_->StartsWith(str, prefix);
435 }
436
MoveHandlePathMapTest()437 static void MoveHandlePathMapTest()
438 {
439 if (mtpMediaLib_ == nullptr) {
440 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
441 return;
442 }
443 mtpMediaLib_->Clear();
444 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
445 mtpMediaLib_->MoveHandlePathMap(FILE_PATH, provider->ConsumeBytesAsString(NUM_BYTES));
446 mtpMediaLib_->AddToHandlePathMap(FILE_PATH, 1);
447 mtpMediaLib_->MoveRepeatDirHandlePathMap(FILE_PATH, provider->ConsumeBytesAsString(NUM_BYTES));
448 }
449
MoveObjectSubTest()450 static void MoveObjectSubTest()
451 {
452 if (mtpMediaLib_ == nullptr) {
453 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
454 return;
455 }
456 mtpMediaLib_->Clear();
457 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
458
459 mtpMediaLib_->AddToHandlePathMap(FILE_PATH, 1);
460 bool isDir = provider->ConsumeBool();
461 uint32_t repeatHandle = provider->ConsumeIntegral<uint32_t>();
462 mtpMediaLib_->MoveObjectSub(FILE_PATH, provider->ConsumeBytesAsString(NUM_BYTES), isDir, repeatHandle);
463 }
464
GetIdTest()465 static void GetIdTest()
466 {
467 if (mtpMediaLib_ == nullptr) {
468 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
469 return;
470 }
471 mtpMediaLib_->Clear();
472 mtpMediaLib_->GetId();
473 mtpMediaLib_->GetParentId(provider->ConsumeBytesAsString(NUM_BYTES));
474 }
475
ScanDirNoDepthTest()476 static void ScanDirNoDepthTest()
477 {
478 if (mtpMediaLib_ == nullptr) {
479 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
480 return;
481 }
482 mtpMediaLib_->Clear();
483 string root = provider->ConsumeBytesAsString(NUM_BYTES);
484 shared_ptr<UInt32List> out = make_shared<UInt32List>();
485 mtpMediaLib_->ScanDirNoDepth(root, out);
486 }
487
ScanDirWithTypeTest()488 static void ScanDirWithTypeTest()
489 {
490 if (mtpMediaLib_ == nullptr) {
491 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
492 return;
493 }
494 mtpMediaLib_->Clear();
495 shared_ptr<unordered_map<uint32_t, string>> out =
496 make_shared<unordered_map<uint32_t, string>>();
497
498 mtpMediaLib_->ScanDirWithType(STORAGE_FILE, out);
499 mtpMediaLib_->ScanDirTraverseWithType(STORAGE_FILE, out);
500
501 string root = FILE_PATH + "/" + provider->ConsumeBytesAsString(NUM_BYTES);
502 int64_t size = provider->ConsumeIntegral<int64_t>();
503 mtpMediaLib_->ScanDirWithType(root, out);
504 mtpMediaLib_->ScanDirTraverseWithType(root, out);
505 mtpMediaLib_->GetSizeFromOfft(size);
506 }
507
GetHandlesMapTest()508 static void GetHandlesMapTest()
509 {
510 if (mtpMediaLib_ == nullptr) {
511 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
512 return;
513 }
514 mtpMediaLib_->Clear();
515 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
516 FuzzMtpOperationContext());
517 if (context == nullptr) {
518 MEDIA_ERR_LOG("context is nullptr");
519 return;
520 }
521 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
522 context->handle = 0;
523 context->depth = MTP_ALL_DEPTH;
524 mtpMediaLib_->GetHandlesMap(context);
525
526 context->handle = MTP_ALL_DEPTH;
527 mtpMediaLib_->GetHandlesMap(context);
528
529 context->depth = DEFAULT_STORAGE_ID;
530 mtpMediaLib_->GetHandlesMap(context);
531
532 context->handle = MTP_ALL_HANDLE_ID;
533 mtpMediaLib_->GetHandlesMap(context);
534 }
535
GetExternalStoragesTest()536 static void GetExternalStoragesTest()
537 {
538 if (mtpMediaLib_ == nullptr) {
539 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
540 return;
541 }
542 mtpMediaLib_->Clear();
543 mtpMediaLib_->GetExternalStorages();
544 }
545
ErasePathInfoTest()546 static void ErasePathInfoTest()
547 {
548 if (mtpMediaLib_ == nullptr) {
549 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
550 return;
551 }
552 mtpMediaLib_->Clear();
553
554 mtpMediaLib_->ObserverAddPathToMap(provider->ConsumeBytesAsString(NUM_BYTES));
555 uint32_t handle = provider->ConsumeIntegral<uint32_t>();
556 mtpMediaLib_->GetIdByPath(provider->ConsumeBytesAsString(NUM_BYTES), handle);
557 mtpMediaLib_->ErasePathInfo(handle, FILE_PATH);
558 }
559
GetVideoThumbTest()560 static void GetVideoThumbTest()
561 {
562 if (mtpMediaLib_ == nullptr) {
563 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
564 return;
565 }
566 mtpMediaLib_->Clear();
567 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
568 FuzzMtpOperationContext());
569 if (context == nullptr) {
570 MEDIA_ERR_LOG("context is nullptr");
571 return;
572 }
573 shared_ptr<UInt8List> outThumb = make_shared<UInt8List>();
574 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
575
576 mtpMediaLib_->GetVideoThumb(context, outThumb);
577 }
578
GetPictureThumbTest()579 static void GetPictureThumbTest()
580 {
581 if (mtpMediaLib_ == nullptr) {
582 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
583 return;
584 }
585 mtpMediaLib_->Clear();
586 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
587 FuzzMtpOperationContext());
588 if (context == nullptr) {
589 MEDIA_ERR_LOG("context is nullptr");
590 return;
591 }
592 shared_ptr<UInt8List> outThumb = make_shared<UInt8List>();
593 mtpMediaLib_->AddToHandlePathMap(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<uint32_t>());
594
595 mtpMediaLib_->GetPictureThumb(context, outThumb);
596 }
597
CorrectStorageIdTest()598 static void CorrectStorageIdTest()
599 {
600 if (mtpMediaLib_ == nullptr) {
601 MEDIA_ERR_LOG("mtpMediaLib_ is nullptr");
602 return;
603 }
604 mtpMediaLib_->Clear();
605 const shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>(
606 FuzzMtpOperationContext());
607 if (context == nullptr) {
608 MEDIA_ERR_LOG("context is nullptr");
609 return;
610 }
611 mtpMediaLib_->CorrectStorageId(context);
612 }
613
MtpMediaLibraryTest()614 static void MtpMediaLibraryTest()
615 {
616 AddPathToMapTest();
617 ObserverAddPathToMapTest();
618 GetHandlesTest();
619 GetObjectInfoTest();
620 GetFdTest();
621 GetThumbTest();
622 SendObjectInfoTest();
623 MoveObjectTest();
624 CopyObjectTest();
625 SetObjectPropValueTest();
626 CloseFdTest();
627 GetObjectPropListTest();
628 GetObjectPropValueTest();
629 GetRealPathTest();
630 MtpMediaLibraryStorageTest();
631 ObserverDeletePathToMapTest();
632 ModifyHandlePathMapTest();
633 StartsWithTest();
634 MoveHandlePathMapTest();
635 MoveObjectSubTest();
636 GetIdTest();
637 ScanDirNoDepthTest();
638 ScanDirWithTypeTest();
639 GetHandlesMapTest();
640 GetExternalStoragesTest();
641 ErasePathInfoTest();
642 GetVideoThumbTest();
643 GetPictureThumbTest();
644 CorrectStorageIdTest();
645 }
646
AddSeed()647 static int32_t AddSeed()
648 {
649 char *seedData = new char[OHOS::SEED_SIZE];
650 for (int i = 0; i < OHOS::SEED_SIZE; i++) {
651 seedData[i] = static_cast<char>(i % MAX_BYTE_VALUE);
652 }
653
654 const char* filename = "corpus/seed.txt";
655 std::ofstream file(filename, std::ios::binary | std::ios::trunc);
656 if (!file) {
657 MEDIA_ERR_LOG("Cannot open file filename:%{public}s", filename);
658 delete[] seedData;
659 return Media::E_ERR;
660 }
661 file.write(seedData, OHOS::SEED_SIZE);
662 file.close();
663 delete[] seedData;
664 MEDIA_INFO_LOG("seedData has been successfully written to file filename:%{public}s", filename);
665 return Media::E_OK;
666 }
667 } // namespace OHOS
668
LLVMFuzzerInitialize(int * argc,char *** argv)669 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
670 {
671 OHOS::AddSeed();
672 return 0;
673 }
674
675 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)676 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
677 {
678 /* Run your code on data */
679 FuzzedDataProvider fdp(data, size);
680 OHOS::provider = &fdp;
681 if (data == nullptr) {
682 return 0;
683 }
684 OHOS::MtpMediaLibraryTest();
685 return 0;
686 }