1 /*
2  * Copyright (c) 2024 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 "backupservicestub_fuzzer.h"
17 
18 #include <cstring>
19 
20 #include "b_incremental_data.h"
21 #include "b_session_backup.h"
22 #include "b_session_restore.h"
23 #include "message_parcel.h"
24 #include "refbase.h"
25 #include "service.h"
26 #include "service_reverse.h"
27 
28 namespace OHOS {
29 using namespace FileManagement::Backup;
30 
31 constexpr int32_t SERVICE_ID = 5203;
32 
33 template<class T>
TypeCast(const uint8_t * data,int * pos=nullptr)34 T TypeCast(const uint8_t *data, int *pos = nullptr)
35 {
36     if (pos) {
37         *pos += sizeof(T);
38     }
39     return *(reinterpret_cast<const T*>(data));
40 }
41 
42 template <typename T>
WriteParcelableVector(const std::vector<T> & parcelableVector,Parcel & data)43 void WriteParcelableVector(const std::vector<T> &parcelableVector, Parcel &data)
44 {
45     if (!data.WriteUint32(parcelableVector.size())) {
46         return;
47     }
48 
49     for (const auto &parcelable : parcelableVector) {
50         if (!data.WriteParcelable(&parcelable)) {
51             return;
52         }
53     }
54 
55     return;
56 }
57 
OnRemoteRequestFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)58 bool OnRemoteRequestFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
59 {
60     if (data == nullptr || size < sizeof(uint32_t)) {
61         return true;
62     }
63 
64     MessageParcel msg;
65     MessageParcel reply;
66     MessageOption option;
67 
68     int pos = 0;
69     uint32_t code = TypeCast<uint32_t>(data, &pos);
70     msg.WriteInterfaceToken(ServiceStub::GetDescriptor());
71 
72     service->OnRemoteRequest(code, msg, reply, option);
73     return true;
74 }
75 
CmdInitRestoreSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)76 bool CmdInitRestoreSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
77 {
78     MessageParcel msg;
79     MessageParcel reply;
80 
81     try {
82         BSessionRestore::Callbacks callbacks;
83         msg.WriteRemoteObject(new ServiceReverse(callbacks));
84         service->CmdInitRestoreSession(msg, reply);
85     } catch (OHOS::FileManagement::Backup::BError &err) {
86         // Only filter BError errors, Other results are not expected.
87     }
88     return true;
89 }
90 
CmdInitBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)91 bool CmdInitBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
92 {
93     MessageParcel msg;
94     MessageParcel reply;
95 
96     try {
97         BSessionBackup::Callbacks callbacks;
98         msg.WriteRemoteObject(new ServiceReverse(callbacks));
99         service->CmdInitBackupSession(msg, reply);
100     } catch (OHOS::FileManagement::Backup::BError &err) {
101         // Only filter BError errors, Other results are not expected.
102     }
103     return true;
104 }
105 
CmdStartFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)106 bool CmdStartFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
107 {
108     MessageParcel msg;
109     MessageParcel reply;
110 
111     try {
112         service->CmdStart(msg, reply);
113     } catch (OHOS::FileManagement::Backup::BError &err) {
114         // Only filter BError errors, Other results are not expected.
115     }
116     return true;
117 }
118 
CmdGetLocalCapabilitiesFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)119 bool CmdGetLocalCapabilitiesFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
120 {
121     MessageParcel msg;
122     MessageParcel reply;
123 
124     try {
125         service->CmdGetLocalCapabilities(msg, reply);
126     } catch (OHOS::FileManagement::Backup::BError &err) {
127         // Only filter BError errors, Other results are not expected.
128     }
129     return true;
130 }
131 
CmdPublishFileFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)132 bool CmdPublishFileFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
133 {
134     if (data == nullptr || size < sizeof(TmpFileSN)) {
135         return true;
136     }
137 
138     MessageParcel msg;
139     MessageParcel reply;
140 
141     try {
142         int pos = 0;
143         BFileInfo info;
144         info.sn = TypeCast<TmpFileSN>(data, &pos);
145         int len = (size - pos) >> 1;
146         info.owner = string(reinterpret_cast<const char*>(data + pos), len);
147         info.fileName = string(reinterpret_cast<const char*>(data + pos + len), len);
148         msg.WriteParcelable(&info);
149         service->CmdPublishFile(msg, reply);
150     } catch (OHOS::FileManagement::Backup::BError &err) {
151         // Only filter BError errors, Other results are not expected.
152     }
153     return true;
154 }
155 
CmdAppFileReadyFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)156 bool CmdAppFileReadyFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
157 {
158     if (data == nullptr || size < sizeof(int32_t) + sizeof(bool) + sizeof(int)) {
159         return true;
160     }
161 
162     MessageParcel msg;
163     MessageParcel reply;
164 
165     try {
166         int pos = 0;
167         int fd = TypeCast<int>(data, &pos);
168         int32_t errCode = TypeCast<int32_t>(data + pos, &pos);
169         bool fdFlag = TypeCast<bool>(data + pos, &pos);
170         msg.WriteString(string(reinterpret_cast<const char*>(data + pos), size - pos));
171         msg.WriteBool(fdFlag);
172         if (fdFlag) {
173             msg.WriteFileDescriptor(fd);
174         }
175         msg.WriteInt32(errCode);
176         service->CmdAppFileReady(msg, reply);
177     } catch (OHOS::FileManagement::Backup::BError &err) {
178         // Only filter BError errors, Other results are not expected.
179     }
180     return true;
181 }
182 
CmdAppDoneFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)183 bool CmdAppDoneFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
184 {
185     if (data == nullptr || size < sizeof(int32_t)) {
186         return true;
187     }
188 
189     MessageParcel msg;
190     MessageParcel reply;
191 
192     try {
193         int32_t errCode = TypeCast<int32_t>(data);
194         msg.WriteInt32(errCode);
195         service->CmdAppDone(msg, reply);
196     } catch (OHOS::FileManagement::Backup::BError &err) {
197         // Only filter BError errors, Other results are not expected.
198     }
199     return true;
200 }
201 
CmdResultReportFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)202 bool CmdResultReportFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
203 {
204     if (data == nullptr || size < sizeof(int32_t) + sizeof(int32_t)) {
205         return true;
206     }
207 
208     MessageParcel msg;
209     MessageParcel reply;
210 
211     try {
212         int pos = 0;
213         int32_t scenario = TypeCast<int32_t>(data, &pos);
214         int32_t errCode = TypeCast<int32_t>(data + pos, &pos);
215         msg.WriteString(string(reinterpret_cast<const char*>(data + pos), size - pos));
216         msg.WriteInt32(scenario);
217         msg.WriteInt32(errCode);
218         service->CmdResultReport(msg, reply);
219     } catch (OHOS::FileManagement::Backup::BError &err) {
220         // Only filter BError errors, Other results are not expected.
221     }
222     return true;
223 }
224 
CmdGetFileHandleFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)225 bool CmdGetFileHandleFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
226 {
227     MessageParcel msg;
228     MessageParcel reply;
229 
230     try {
231         int len = size >> 1;
232         msg.WriteString(string(reinterpret_cast<const char*>(data), len));
233         msg.WriteString(string(reinterpret_cast<const char*>(data + len), size - len));
234         service->CmdGetFileHandle(msg, reply);
235     } catch (OHOS::FileManagement::Backup::BError &err) {
236         // Only filter BError errors, Other results are not expected.
237     }
238     return true;
239 }
240 
CmdAppendBundlesRestoreSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)241 bool CmdAppendBundlesRestoreSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
242 {
243     if (data == nullptr || size < sizeof(int) + sizeof(int32_t) + sizeof(int32_t)) {
244         return true;
245     }
246 
247     MessageParcel msg;
248     MessageParcel reply;
249 
250     try {
251         int pos = 0;
252         int fd = TypeCast<int>(data, &pos);
253         int32_t type = TypeCast<int32_t>(data + pos, &pos);
254         int32_t userId = TypeCast<int32_t>(data + pos, &pos);
255         vector<string> bundleNames;
256         bundleNames.emplace_back(string(reinterpret_cast<const char*>(data + pos), size - pos));
257         msg.WriteFileDescriptor(fd);
258         msg.WriteStringVector(bundleNames);
259         msg.WriteInt32(type);
260         msg.WriteInt32(userId);
261         service->CmdAppendBundlesRestoreSession(msg, reply);
262     } catch (OHOS::FileManagement::Backup::BError &err) {
263         // Only filter BError errors, Other results are not expected.
264     }
265     return true;
266 }
267 
CmdAppendBundlesDetailsRestoreSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)268 bool CmdAppendBundlesDetailsRestoreSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
269 {
270     if (data == nullptr || size < sizeof(int) + sizeof(int32_t) + sizeof(int32_t)) {
271         return true;
272     }
273 
274     MessageParcel msg;
275     MessageParcel reply;
276 
277     try {
278         int pos = 0;
279         int fd = TypeCast<int>(data, &pos);
280         int32_t type = TypeCast<int32_t>(data + pos, &pos);
281         int32_t userId = TypeCast<int32_t>(data + pos, &pos);
282         int len = (size - pos) >> 1;
283         vector<string> bundleNames;
284         bundleNames.emplace_back(string(reinterpret_cast<const char*>(data + pos), len));
285         vector<string> detailInfos;
286         detailInfos.emplace_back(string(reinterpret_cast<const char*>(data + pos + len), len));
287         msg.WriteFileDescriptor(fd);
288         msg.WriteStringVector(bundleNames);
289         msg.WriteStringVector(detailInfos);
290         msg.WriteInt32(type);
291         msg.WriteInt32(userId);
292         service->CmdAppendBundlesDetailsRestoreSession(msg, reply);
293     } catch (OHOS::FileManagement::Backup::BError &err) {
294         // Only filter BError errors, Other results are not expected.
295     }
296     return true;
297 }
298 
CmdAppendBundlesBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)299 bool CmdAppendBundlesBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
300 {
301     MessageParcel msg;
302     MessageParcel reply;
303 
304     try {
305         vector<string> bundleNames;
306         bundleNames.emplace_back(string(reinterpret_cast<const char*>(data), size));
307         msg.WriteStringVector(bundleNames);
308         service->CmdAppendBundlesBackupSession(msg, reply);
309     } catch (OHOS::FileManagement::Backup::BError &err) {
310         // Only filter BError errors, Other results are not expected.
311     }
312     return true;
313 }
314 
CmdAppendBundlesDetailsBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)315 bool CmdAppendBundlesDetailsBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
316 {
317     MessageParcel msg;
318     MessageParcel reply;
319 
320     try {
321         int len = size >> 1;
322         vector<string> bundleNames;
323         bundleNames.emplace_back(string(reinterpret_cast<const char*>(data), len));
324         vector<string> detailInfos;
325         detailInfos.emplace_back(string(reinterpret_cast<const char*>(data + len), len));
326         msg.WriteStringVector(bundleNames);
327         msg.WriteStringVector(detailInfos);
328         service->CmdAppendBundlesDetailsBackupSession(msg, reply);
329     } catch (OHOS::FileManagement::Backup::BError &err) {
330         // Only filter BError errors, Other results are not expected.
331     }
332     return true;
333 }
334 
CmdFinishFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)335 bool CmdFinishFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
336 {
337     MessageParcel msg;
338     MessageParcel reply;
339     try {
340         service->CmdFinish(msg, reply);
341     } catch (OHOS::FileManagement::Backup::BError &err) {
342         // Only filter BError errors, Other results are not expected.
343     }
344     return true;
345 }
346 
CmdReleaseFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)347 [[maybe_unused]] bool CmdReleaseFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
348 {
349     MessageParcel msg;
350     MessageParcel reply;
351     try {
352         service->CmdRelease(msg, reply);
353     } catch (OHOS::FileManagement::Backup::BError &err) {
354         // Only filter BError errors, Other results are not expected.
355     }
356     return true;
357 }
358 
CmdGetLocalCapabilitiesIncrementalFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)359 bool CmdGetLocalCapabilitiesIncrementalFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
360 {
361     MessageParcel msg;
362     MessageParcel reply;
363 
364     try {
365         vector<BIncrementalData> bundleNames;
366         bundleNames.emplace_back(string(reinterpret_cast<const char*>(data), size), 0);
367         WriteParcelableVector(bundleNames, msg);
368         service->CmdGetLocalCapabilitiesIncremental(msg, reply);
369     } catch (OHOS::FileManagement::Backup::BError &err) {
370         // Only filter BError errors, Other results are not expected.
371     }
372     return true;
373 }
374 
CmdGetAppLocalListAndDoIncrementalBackupFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)375 bool CmdGetAppLocalListAndDoIncrementalBackupFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
376 {
377     MessageParcel msg;
378     MessageParcel reply;
379     try {
380         service->CmdGetAppLocalListAndDoIncrementalBackup(msg, reply);
381     } catch (OHOS::FileManagement::Backup::BError &err) {
382         // Only filter BError errors, Other results are not expected.
383     }
384     return true;
385 }
386 
CmdInitIncrementalBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)387 bool CmdInitIncrementalBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
388 {
389     MessageParcel msg;
390     MessageParcel reply;
391 
392     try {
393         BIncrementalBackupSession::Callbacks callbacks;
394         msg.WriteRemoteObject(new ServiceReverse(callbacks));
395         service->CmdInitIncrementalBackupSession(msg, reply);
396     } catch (OHOS::FileManagement::Backup::BError &err) {
397         // Only filter BError errors, Other results are not expected.
398     }
399     return true;
400 }
401 
CmdAppendBundlesIncrementalBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)402 bool CmdAppendBundlesIncrementalBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
403 {
404     MessageParcel msg;
405     MessageParcel reply;
406 
407     try {
408         vector<BIncrementalData> bundlesToBackup;
409         bundlesToBackup.emplace_back(string(reinterpret_cast<const char*>(data), size), 0);
410         WriteParcelableVector(bundlesToBackup, msg);
411         service->CmdAppendBundlesIncrementalBackupSession(msg, reply);
412     } catch (OHOS::FileManagement::Backup::BError &err) {
413         // Only filter BError errors, Other results are not expected.
414     }
415     return true;
416 }
417 
CmdAppendBundlesDetailsIncrementalBackupSessionFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)418 bool CmdAppendBundlesDetailsIncrementalBackupSessionFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
419 {
420     MessageParcel msg;
421     MessageParcel reply;
422 
423     try {
424         int len = size >> 1;
425         vector<BIncrementalData> bundlesToBackup;
426         bundlesToBackup.emplace_back(string(reinterpret_cast<const char*>(data), len), 0);
427         std::vector<std::string> infos;
428         infos.emplace_back(string(reinterpret_cast<const char*>(data + len), len));
429         WriteParcelableVector(bundlesToBackup, msg);
430         msg.WriteStringVector(infos);
431         service->CmdAppendBundlesDetailsIncrementalBackupSession(msg, reply);
432     } catch (OHOS::FileManagement::Backup::BError &err) {
433         // Only filter BError errors, Other results are not expected.
434     }
435     return true;
436 }
437 
CmdPublishIncrementalFileFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)438 bool CmdPublishIncrementalFileFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
439 {
440     if (data == nullptr || size < sizeof(TmpFileSN)) {
441         return true;
442     }
443 
444     MessageParcel msg;
445     MessageParcel reply;
446 
447     try {
448         int pos = 0;
449         BFileInfo info;
450         info.sn = TypeCast<TmpFileSN>(data, &pos);
451         int len = (size - pos) >> 1;
452         info.owner = string(reinterpret_cast<const char*>(data + pos), len);
453         info.fileName = string(reinterpret_cast<const char*>(data + pos + len), len);
454         msg.WriteParcelable(&info);
455         service->CmdPublishIncrementalFile(msg, reply);
456     } catch (OHOS::FileManagement::Backup::BError &err) {
457         // Only filter BError errors, Other results are not expected.
458     }
459     return true;
460 }
461 
CmdPublishSAIncrementalFileFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)462 [[maybe_unused]] bool CmdPublishSAIncrementalFileFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
463 {
464     if (data == nullptr || size < sizeof(int) + sizeof(TmpFileSN)) {
465         return true;
466     }
467 
468     MessageParcel msg;
469     MessageParcel reply;
470 
471     try {
472         int pos = 0;
473         BFileInfo info;
474         int fd = TypeCast<int>(data, &pos);
475         info.sn = TypeCast<TmpFileSN>(data, &pos);
476         int len = (size - pos) >> 1;
477         info.owner = string(reinterpret_cast<const char*>(data + pos), len);
478         info.fileName = string(reinterpret_cast<const char*>(data + pos + len), len);
479         msg.WriteParcelable(&info);
480         msg.WriteFileDescriptor(fd);
481         service->CmdPublishSAIncrementalFile(msg, reply);
482     } catch (OHOS::FileManagement::Backup::BError &err) {
483         // Only filter BError errors, Other results are not expected.
484     }
485     return true;
486 }
487 
CmdAppIncrementalFileReadyFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)488 bool CmdAppIncrementalFileReadyFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
489 {
490     if (data == nullptr || size < sizeof(int32_t) + sizeof(bool) + sizeof(int) + sizeof(int)) {
491         return true;
492     }
493 
494     MessageParcel msg;
495     MessageParcel reply;
496 
497     try {
498         int pos = 0;
499         int fd1 = TypeCast<int>(data, &pos);
500         int fd2 = TypeCast<int>(data + pos, &pos);
501         int32_t errCode = TypeCast<int32_t>(data + pos, &pos);
502         bool fdFlag = TypeCast<bool>(data + pos, &pos);
503         msg.WriteString(string(reinterpret_cast<const char*>(data + pos), size - pos));
504         msg.WriteBool(fdFlag);
505         if (fdFlag) {
506             msg.WriteFileDescriptor(fd1);
507             msg.WriteFileDescriptor(fd2);
508         }
509         msg.WriteInt32(errCode);
510         service->CmdAppIncrementalFileReady(msg, reply);
511     } catch (OHOS::FileManagement::Backup::BError &err) {
512         // Only filter BError errors, Other results are not expected.
513     }
514     return true;
515 }
516 
CmdAppIncrementalDoneFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)517 bool CmdAppIncrementalDoneFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
518 {
519     if (data == nullptr || size < sizeof(int32_t)) {
520         return true;
521     }
522 
523     MessageParcel msg;
524     MessageParcel reply;
525 
526     try {
527         int32_t errCode = TypeCast<int32_t>(data);
528         msg.WriteInt32(errCode);
529         service->CmdAppIncrementalDone(msg, reply);
530     } catch (OHOS::FileManagement::Backup::BError &err) {
531         // Only filter BError errors, Other results are not expected.
532     }
533     return true;
534 }
535 
CmdGetIncrementalFileHandleFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)536 bool CmdGetIncrementalFileHandleFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
537 {
538     MessageParcel msg;
539     MessageParcel reply;
540 
541     try {
542         int len = size >> 1;
543         msg.WriteString(string(reinterpret_cast<const char*>(data), len));
544         msg.WriteString(string(reinterpret_cast<const char*>(data + len), size - len));
545         service->CmdGetIncrementalFileHandle(msg, reply);
546     } catch (OHOS::FileManagement::Backup::BError &err) {
547         // Only filter BError errors, Other results are not expected.
548     }
549     return true;
550 }
551 
CmdGetBackupInfoFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)552 bool CmdGetBackupInfoFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
553 {
554     MessageParcel msg;
555     MessageParcel reply;
556 
557     try {
558         msg.WriteString(string(reinterpret_cast<const char*>(data), size));
559         service->CmdGetBackupInfo(msg, reply);
560     } catch (OHOS::FileManagement::Backup::BError &err) {
561         // Only filter BError errors, Other results are not expected.
562     }
563     return true;
564 }
565 
CmdUpdateTimerFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)566 bool CmdUpdateTimerFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
567 {
568     if (data == nullptr || size < sizeof(int32_t)) {
569         return true;
570     }
571 
572     MessageParcel msg;
573     MessageParcel reply;
574 
575     try {
576         int pos = 0;
577         int32_t timeout = TypeCast<int32_t>(data, &pos);
578         msg.WriteString(string(reinterpret_cast<const char*>(data + pos), size - pos));
579         msg.WriteInt32(timeout);
580         service->CmdUpdateTimer(msg, reply);
581     } catch (OHOS::FileManagement::Backup::BError &err) {
582         // Only filter BError errors, Other results are not expected.
583     }
584     return true;
585 }
586 
CmdUpdateSendRateFuzzTest(sptr<Service> service,const uint8_t * data,size_t size)587 bool CmdUpdateSendRateFuzzTest(sptr<Service> service, const uint8_t *data, size_t size)
588 {
589     if (data == nullptr || size < sizeof(int32_t)) {
590         return true;
591     }
592 
593     MessageParcel msg;
594     MessageParcel reply;
595 
596     try {
597         int pos = 0;
598         int32_t sendRate = TypeCast<int32_t>(data, &pos);
599         msg.WriteString(string(reinterpret_cast<const char*>(data + pos), size - pos));
600         msg.WriteInt32(sendRate);
601         service->CmdUpdateSendRate(msg, reply);
602     } catch (OHOS::FileManagement::Backup::BError &err) {
603         // Only filter BError errors, Other results are not expected.
604     }
605     return true;
606 }
607 } // namespace OHOS
608 
609 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)610 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
611 {
612     OHOS::sptr service(new OHOS::FileManagement::Backup::Service(OHOS::SERVICE_ID));
613     if (service == nullptr) {
614         return 0;
615     }
616 
617     try {
618         OHOS::OnRemoteRequestFuzzTest(service, data, size);
619         CmdInitRestoreSessionFuzzTest(service, data, size);
620         CmdInitBackupSessionFuzzTest(service, data, size);
621         CmdStartFuzzTest(service, data, size);
622         CmdGetLocalCapabilitiesFuzzTest(service, data, size);
623         CmdPublishFileFuzzTest(service, data, size);
624         CmdAppFileReadyFuzzTest(service, data, size);
625         CmdAppDoneFuzzTest(service, data, size);
626         CmdResultReportFuzzTest(service, data, size);
627         CmdGetFileHandleFuzzTest(service, data, size);
628         CmdAppendBundlesRestoreSessionFuzzTest(service, data, size);
629         CmdAppendBundlesDetailsRestoreSessionFuzzTest(service, data, size);
630         CmdAppendBundlesBackupSessionFuzzTest(service, data, size);
631         CmdAppendBundlesDetailsBackupSessionFuzzTest(service, data, size);
632         CmdFinishFuzzTest(service, data, size);
633         CmdGetLocalCapabilitiesIncrementalFuzzTest(service, data, size);
634         CmdGetAppLocalListAndDoIncrementalBackupFuzzTest(service, data, size);
635         CmdInitIncrementalBackupSessionFuzzTest(service, data, size);
636         CmdAppendBundlesIncrementalBackupSessionFuzzTest(service, data, size);
637         CmdAppendBundlesDetailsIncrementalBackupSessionFuzzTest(service, data, size);
638         CmdPublishIncrementalFileFuzzTest(service, data, size);
639         CmdAppIncrementalFileReadyFuzzTest(service, data, size);
640         CmdAppIncrementalDoneFuzzTest(service, data, size);
641         CmdGetIncrementalFileHandleFuzzTest(service, data, size);
642         CmdGetBackupInfoFuzzTest(service, data, size);
643         CmdUpdateTimerFuzzTest(service, data, size);
644         CmdUpdateSendRateFuzzTest(service, data, size);
645     } catch (OHOS::FileManagement::Backup::BError &err) {
646         // Only filter BError errors, Other results are not expected.
647     }
648     return 0;
649 }