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 #define private public
16 #define protected public
17 
18 #include "downloaduploadmanager_fuzzer.h"
19 
20 #include <securec.h>
21 
22 #include <cstddef>
23 #include <cstdint>
24 
25 #include "accesstoken_kit.h"
26 #include "js_common.h"
27 #include "message_parcel.h"
28 #include "nativetoken_kit.h"
29 #include "request.h"
30 #include "request_manager.h"
31 #include "request_manager_impl.h"
32 #include "request_running_task_count.h"
33 #include "request_service_interface.h"
34 #include "request_sync_load_callback.h"
35 #include "runcount_notify_stub.h"
36 #include "running_task_count.h"
37 #include "system_ability_definition.h"
38 #include "token_setproc.h"
39 
40 using namespace OHOS::Request;
41 using namespace OHOS::Security::AccessToken;
42 
43 #undef private
44 #undef protected
45 
46 namespace OHOS {
47 
ConvertToUint32(const uint8_t * ptr,size_t size)48 uint32_t ConvertToUint32(const uint8_t *ptr, size_t size)
49 {
50     if (ptr == nullptr || (size < sizeof(uint32_t))) {
51         return 0;
52     }
53     return *(reinterpret_cast<const uint32_t *>(ptr));
54 }
55 
GrantNativePermission()56 void GrantNativePermission()
57 {
58     const char **perms = new const char *[1];
59     perms[0] = "ohos.permission.INTERNET";
60     TokenInfoParams infoInstance = {
61         .dcapsNum = 0,
62         .permsNum = 1,
63         .aclsNum = 0,
64         .dcaps = nullptr,
65         .perms = perms,
66         .acls = nullptr,
67         .processName = "request_service",
68         .aplStr = "system_core",
69     };
70     uint64_t tokenId = GetAccessTokenId(&infoInstance);
71     SetSelfTokenID(tokenId);
72     AccessTokenKit::ReloadNativeTokenInfo();
73     delete[] perms;
74 }
75 
CreateRequestFuzzTest(const uint8_t * data,size_t size)76 void CreateRequestFuzzTest(const uint8_t *data, size_t size)
77 {
78     Config config;
79     auto tid = std::to_string(size);
80 
81     GrantNativePermission();
82     int32_t seq = RequestManager::GetInstance()->GetNextSeq();
83     RequestManager::GetInstance()->Create(config, seq, tid);
84 }
85 
StartRequestFuzzTest(const uint8_t * data,size_t size)86 void StartRequestFuzzTest(const uint8_t *data, size_t size)
87 {
88     std::string tid(reinterpret_cast<const char *>(data), size);
89     GrantNativePermission();
90     RequestManager::GetInstance()->Start(tid);
91 }
92 
StopRequestFuzzTest(const uint8_t * data,size_t size)93 void StopRequestFuzzTest(const uint8_t *data, size_t size)
94 {
95     std::string tid(reinterpret_cast<const char *>(data), size);
96     GrantNativePermission();
97     RequestManager::GetInstance()->Stop(tid);
98 }
99 
ShowRequestFuzzTest(const uint8_t * data,size_t size)100 void ShowRequestFuzzTest(const uint8_t *data, size_t size)
101 {
102     TaskInfo info;
103     std::string tid(reinterpret_cast<const char *>(data), size);
104     GrantNativePermission();
105     RequestManager::GetInstance()->Show(tid, info);
106 }
107 
TouchRequestFuzzTest(const uint8_t * data,size_t size)108 void TouchRequestFuzzTest(const uint8_t *data, size_t size)
109 {
110     TaskInfo info;
111     std::string tid(reinterpret_cast<const char *>(data), size);
112     std::string token(data, data + size);
113     GrantNativePermission();
114     RequestManager::GetInstance()->Touch(tid, token, info);
115 }
116 
SearchRequestFuzzTest(const uint8_t * data,size_t size)117 void SearchRequestFuzzTest(const uint8_t *data, size_t size)
118 {
119     Filter filter;
120     std::vector<std::string> tids;
121     std::string str(reinterpret_cast<const char *>(data), size);
122     tids.push_back(str);
123     GrantNativePermission();
124     RequestManager::GetInstance()->Search(filter, tids);
125 }
126 
PauseRequestFuzzTest(const uint8_t * data,size_t size)127 void PauseRequestFuzzTest(const uint8_t *data, size_t size)
128 {
129     Version version = static_cast<Version>(ConvertToUint32(data, size));
130     std::string tid(reinterpret_cast<const char *>(data), size);
131     GrantNativePermission();
132     RequestManager::GetInstance()->Pause(tid, version);
133 }
134 
QueryMimeTypeRequestFuzzTest(const uint8_t * data,size_t size)135 void QueryMimeTypeRequestFuzzTest(const uint8_t *data, size_t size)
136 {
137     std::string tid(reinterpret_cast<const char *>(data), size);
138     std::string mimeType(data, data + size);
139     GrantNativePermission();
140     RequestManager::GetInstance()->QueryMimeType(tid, mimeType);
141 }
142 
RemoveRequestFuzzTest(const uint8_t * data,size_t size)143 void RemoveRequestFuzzTest(const uint8_t *data, size_t size)
144 {
145     Version version = static_cast<Version>(ConvertToUint32(data, size));
146     std::string tid(reinterpret_cast<const char *>(data), size);
147     GrantNativePermission();
148     RequestManager::GetInstance()->Remove(tid, version);
149 }
150 
ResumeRequestFuzzTest(const uint8_t * data,size_t size)151 void ResumeRequestFuzzTest(const uint8_t *data, size_t size)
152 {
153     std::string tid(reinterpret_cast<const char *>(data), size);
154     GrantNativePermission();
155     RequestManager::GetInstance()->Resume(tid);
156 }
157 
GetTaskRequestFuzzTest(const uint8_t * data,size_t size)158 void GetTaskRequestFuzzTest(const uint8_t *data, size_t size)
159 {
160     Config config;
161     std::string tid(reinterpret_cast<const char *>(data), size);
162     std::string token(reinterpret_cast<const char *>(data), size);
163     GrantNativePermission();
164     RequestManager::GetInstance()->GetTask(tid, token, config);
165 }
166 
SubscribeRequestFuzzTest(const uint8_t * data,size_t size)167 void SubscribeRequestFuzzTest(const uint8_t *data, size_t size)
168 {
169     std::string tid(reinterpret_cast<const char *>(data), size);
170     GrantNativePermission();
171     RequestManager::GetInstance()->Subscribe(tid);
172 }
173 
UnsubscribeRequestFuzzTest(const uint8_t * data,size_t size)174 void UnsubscribeRequestFuzzTest(const uint8_t *data, size_t size)
175 {
176     std::string tid(reinterpret_cast<const char *>(data), size);
177     GrantNativePermission();
178     RequestManager::GetInstance()->Unsubscribe(tid);
179 }
180 
IsSaReadyRequestFuzzTest(const uint8_t * data,size_t size)181 void IsSaReadyRequestFuzzTest(const uint8_t *data, size_t size)
182 {
183     GrantNativePermission();
184     RequestManager::GetInstance()->IsSaReady();
185 }
186 
ReopenChannelRequestFuzzTest(const uint8_t * data,size_t size)187 void ReopenChannelRequestFuzzTest(const uint8_t *data, size_t size)
188 {
189     GrantNativePermission();
190     RequestManager::GetInstance()->ReopenChannel();
191 }
192 
SubscribeSARequestFuzzTest(const uint8_t * data,size_t size)193 void SubscribeSARequestFuzzTest(const uint8_t *data, size_t size)
194 {
195     GrantNativePermission();
196     RequestManager::GetInstance()->SubscribeSA();
197     RequestManager::GetInstance()->UnsubscribeSA();
198 }
199 
200 class FuzzResponseListenerImpl : public IResponseListener {
201 public:
~FuzzResponseListenerImpl()202     ~FuzzResponseListenerImpl(){};
OnResponseReceive(const std::shared_ptr<Response> & response)203     void OnResponseReceive(const std::shared_ptr<Response> &response) override
204     {
205         (void)response;
206         return;
207     }
208 };
209 
210 class FuzzNotifyDataListenerImpl : public INotifyDataListener {
211 public:
~FuzzNotifyDataListenerImpl()212     ~FuzzNotifyDataListenerImpl(){};
OnNotifyDataReceive(const std::shared_ptr<NotifyData> & notifyData)213     void OnNotifyDataReceive(const std::shared_ptr<NotifyData> &notifyData) override
214     {
215         (void)notifyData;
216         return;
217     }
218 };
219 
AddAndRemoveListenerRequestFuzzTest(const uint8_t * data,size_t size)220 void AddAndRemoveListenerRequestFuzzTest(const uint8_t *data, size_t size)
221 {
222     std::string taskId(reinterpret_cast<const char *>(data), size);
223     GrantNativePermission();
224     SubscribeType type = SubscribeType::RESPONSE;
225     std::shared_ptr<FuzzResponseListenerImpl> listener = std::make_shared<FuzzResponseListenerImpl>();
226     RequestManager::GetInstance()->AddListener(taskId, type, listener);
227     RequestManager::GetInstance()->RemoveListener(taskId, type, listener);
228     type = SubscribeType::COMPLETED;
229     std::shared_ptr<FuzzNotifyDataListenerImpl> listener2 = std::make_shared<FuzzNotifyDataListenerImpl>();
230     RequestManager::GetInstance()->AddListener(taskId, type, listener2);
231     RequestManager::GetInstance()->RemoveListener(taskId, type, listener2);
232 }
233 
RemoveAllListenersRequestFuzzTest(const uint8_t * data,size_t size)234 void RemoveAllListenersRequestFuzzTest(const uint8_t *data, size_t size)
235 {
236     std::string taskId(reinterpret_cast<const char *>(data), size);
237     GrantNativePermission();
238     SubscribeType type = SubscribeType::RESPONSE;
239     std::shared_ptr<FuzzResponseListenerImpl> listener = std::make_shared<FuzzResponseListenerImpl>();
240     RequestManager::GetInstance()->AddListener(taskId, type, listener);
241     type = SubscribeType::COMPLETED;
242     std::shared_ptr<FuzzNotifyDataListenerImpl> listener2 = std::make_shared<FuzzNotifyDataListenerImpl>();
243     RequestManager::GetInstance()->AddListener(taskId, type, listener2);
244     RequestManager::GetInstance()->RemoveAllListeners(taskId);
245     RequestManager::GetInstance()->RestoreListener(nullptr);
246 }
247 
TestFunc(void)248 void TestFunc(void)
249 {
250     return;
251 }
252 
RestoreListenerRequestFuzzTest(const uint8_t * data,size_t size)253 void RestoreListenerRequestFuzzTest(const uint8_t *data, size_t size)
254 {
255     GrantNativePermission();
256     RequestManager::GetInstance()->RestoreListener(TestFunc);
257 }
258 
QueryRequestFuzzTest(const uint8_t * data,size_t size)259 void QueryRequestFuzzTest(const uint8_t *data, size_t size)
260 {
261     std::string tid(reinterpret_cast<const char *>(data), size);
262     TaskInfo taskinfo;
263     GrantNativePermission();
264     RequestManager::GetInstance()->Query(tid, taskinfo);
265 }
266 
RequestFuzzTestGetId(const uint8_t * data,size_t size)267 void RequestFuzzTestGetId(const uint8_t *data, size_t size)
268 {
269     std::string tid(reinterpret_cast<const char *>(data), size);
270     GrantNativePermission();
271     auto request = OHOS::Request::Request(tid);
272     request.getId();
273 }
274 
RequestFuzzTestHasListener(const uint8_t * data,size_t size)275 void RequestFuzzTestHasListener(const uint8_t *data, size_t size)
276 {
277     std::string tid(reinterpret_cast<const char *>(data), size);
278     SubscribeType type = SubscribeType::RESPONSE;
279     auto request = OHOS::Request::Request(tid);
280     std::shared_ptr<FuzzResponseListenerImpl> listenerPtr = std::make_shared<FuzzResponseListenerImpl>();
281     GrantNativePermission();
282     request.AddListener(type, listenerPtr);
283     request.HasListener();
284     request.RemoveListener(type, listenerPtr);
285 }
286 
RequestFuzzTestOnNotifyDataReceive(const uint8_t * data,size_t size)287 void RequestFuzzTestOnNotifyDataReceive(const uint8_t *data, size_t size)
288 {
289     std::string tid(reinterpret_cast<const char *>(data), size);
290     SubscribeType type = SubscribeType::COMPLETED;
291     auto request = OHOS::Request::Request(tid);
292     std::shared_ptr<NotifyData> notifyData = std::make_shared<NotifyData>();
293     notifyData->type = type;
294     notifyData->version = Version::API9;
295     GrantNativePermission();
296     request.OnNotifyDataReceive(notifyData);
297     std::shared_ptr<FuzzNotifyDataListenerImpl> listenerPtr = std::make_shared<FuzzNotifyDataListenerImpl>();
298     request.AddListener(type, listenerPtr);
299     request.OnNotifyDataReceive(notifyData);
300 }
301 
RequestFuzzTestAddAndRemoveListener(const uint8_t * data,size_t size)302 void RequestFuzzTestAddAndRemoveListener(const uint8_t *data, size_t size)
303 {
304     std::string tid(reinterpret_cast<const char *>(data), size);
305     SubscribeType type = SubscribeType::COMPLETED;
306     GrantNativePermission();
307     auto request = OHOS::Request::Request(tid);
308     std::shared_ptr<NotifyData> notifyData = std::make_shared<NotifyData>();
309     notifyData->type = type;
310     notifyData->version = Version::API9;
311 
312     request.OnNotifyDataReceive(notifyData);
313     std::shared_ptr<FuzzNotifyDataListenerImpl> listenerPtr = std::make_shared<FuzzNotifyDataListenerImpl>();
314     request.AddListener(type, listenerPtr);
315     request.RemoveListener(type, listenerPtr);
316 }
317 
RequestFuzzTestOnResponseReceive(const uint8_t * data,size_t size)318 void RequestFuzzTestOnResponseReceive(const uint8_t *data, size_t size)
319 {
320     std::string tid(reinterpret_cast<const char *>(data), size);
321     SubscribeType type = SubscribeType::RESPONSE;
322     std::shared_ptr<Response> response = std::make_shared<Response>();
323     GrantNativePermission();
324     auto request = OHOS::Request::Request(tid);
325     request.OnResponseReceive(response);
326     std::shared_ptr<FuzzResponseListenerImpl> listenerPtr = std::make_shared<FuzzResponseListenerImpl>();
327     request.AddListener(type, listenerPtr);
328     request.OnResponseReceive(response);
329 }
330 
331 class FuzzFwkTestOberver : public IRunningTaskObserver {
332 public:
333     void OnRunningTaskCountUpdate(int count) override;
334     ~FuzzFwkTestOberver() = default;
335     FuzzFwkTestOberver() = default;
336 };
337 
OnRunningTaskCountUpdate(int count)338 void FuzzFwkTestOberver::OnRunningTaskCountUpdate(int count)
339 {
340 }
341 
RunningTaskCountFuzzTestSubscribeRunningTaskCount(const uint8_t * data,size_t size)342 void RunningTaskCountFuzzTestSubscribeRunningTaskCount(const uint8_t *data, size_t size)
343 {
344     GrantNativePermission();
345     auto proxy = RequestManagerImpl::GetInstance()->GetRequestServiceProxy();
346     if (proxy == nullptr) {
347         std::shared_ptr<IRunningTaskObserver> ob = std::make_shared<FuzzFwkTestOberver>();
348         SubscribeRunningTaskCount(ob);
349         UnsubscribeRunningTaskCount(ob);
350     }
351     std::shared_ptr<IRunningTaskObserver> ob1 = std::make_shared<FuzzFwkTestOberver>();
352     SubscribeRunningTaskCount(ob1);
353     std::shared_ptr<IRunningTaskObserver> ob2 = std::make_shared<FuzzFwkTestOberver>();
354     FwkRunningTaskCountManager::GetInstance()->AttachObserver(ob2);
355     SubscribeRunningTaskCount(ob2);
356     FwkRunningTaskCountManager::GetInstance()->DetachObserver(ob1);
357     FwkRunningTaskCountManager::GetInstance()->DetachObserver(ob2);
358 }
359 
RunningTaskCountFuzzTestUnubscribeRunning(const uint8_t * data,size_t size)360 void RunningTaskCountFuzzTestUnubscribeRunning(const uint8_t *data, size_t size)
361 {
362     GrantNativePermission();
363     std::shared_ptr<IRunningTaskObserver> ob1 = std::make_shared<FuzzFwkTestOberver>();
364     FwkRunningTaskCountManager::GetInstance()->AttachObserver(ob1);
365 
366     std::shared_ptr<IRunningTaskObserver> ob2 = std::make_shared<FuzzFwkTestOberver>();
367     UnsubscribeRunningTaskCount(ob2);
368     UnsubscribeRunningTaskCount(ob1);
369 }
370 
RunningTaskCountFuzzTestGetAndSetCount(const uint8_t * data,size_t size)371 void RunningTaskCountFuzzTestGetAndSetCount(const uint8_t *data, size_t size)
372 {
373     GrantNativePermission();
374     int old = FwkRunningTaskCountManager::GetInstance()->GetCount();
375     int except = 1; // 10 is except count num
376     FwkRunningTaskCountManager::GetInstance()->SetCount(except);
377     FwkRunningTaskCountManager::GetInstance()->GetCount();
378     FwkRunningTaskCountManager::GetInstance()->SetCount(old);
379     FwkRunningTaskCountManager::GetInstance()->GetCount();
380 }
381 
RunningTaskCountFuzzTestUpdateRunningTaskCount(const uint8_t * data,size_t size)382 void RunningTaskCountFuzzTestUpdateRunningTaskCount(const uint8_t *data, size_t size)
383 {
384     GrantNativePermission();
385     std::shared_ptr<IRunningTaskObserver> ob = std::make_shared<FuzzFwkTestOberver>();
386     FwkIRunningTaskObserver runningOb = FwkIRunningTaskObserver(ob);
387     runningOb.UpdateRunningTaskCount();
388 }
389 
RunningTaskCountFuzzTestNotifyAllObservers(const uint8_t * data,size_t size)390 void RunningTaskCountFuzzTestNotifyAllObservers(const uint8_t *data, size_t size)
391 {
392     GrantNativePermission();
393     std::shared_ptr<IRunningTaskObserver> ob1 = std::make_shared<FuzzFwkTestOberver>();
394     FwkRunningTaskCountManager::GetInstance()->AttachObserver(ob1);
395     FwkRunningTaskCountManager::GetInstance()->NotifyAllObservers();
396     FwkRunningTaskCountManager::GetInstance()->DetachObserver(ob1);
397 }
398 
RunCountNotifyStubFuzzTestGetInstance(const uint8_t * data,size_t size)399 void RunCountNotifyStubFuzzTestGetInstance(const uint8_t *data, size_t size)
400 {
401     GrantNativePermission();
402     RunCountNotifyStub::GetInstance();
403 }
404 
RunCountNotifyStubFuzzTestCallBack(const uint8_t * data,size_t size)405 void RunCountNotifyStubFuzzTestCallBack(const uint8_t *data, size_t size)
406 {
407     Notify notify;
408     GrantNativePermission();
409     RunCountNotifyStub::GetInstance()->CallBack(notify);
410 }
411 
RunCountNotifyStubFuzzTestDone(const uint8_t * data,size_t size)412 void RunCountNotifyStubFuzzTestDone(const uint8_t *data, size_t size)
413 {
414     TaskInfo taskInfo;
415     GrantNativePermission();
416     RunCountNotifyStub::GetInstance()->Done(taskInfo);
417 }
418 
RunCountNotifyStubFuzzTestOnCallBack(const uint8_t * data,size_t size)419 void RunCountNotifyStubFuzzTestOnCallBack(const uint8_t *data, size_t size)
420 {
421     int64_t except = 10; // 10 is except value
422     int old = FwkRunningTaskCountManager::GetInstance()->GetCount();
423     OHOS::MessageParcel parcel;
424     parcel.WriteInt64(except);
425     GrantNativePermission();
426     RunCountNotifyStub::GetInstance()->OnCallBack(parcel);
427     FwkRunningTaskCountManager::GetInstance()->GetCount();
428     FwkRunningTaskCountManager::GetInstance()->SetCount(old);
429     FwkRunningTaskCountManager::GetInstance()->GetCount();
430 }
431 
432 static constexpr int32_t ARRAY_LEN = 256; // 128 is array length
433 static constexpr int32_t INT64_SIZE = 8;  // 8 is int64 and uint64 num length
434 static constexpr int32_t INT32_SIZE = 4;  // 4 is int32 and uint32 num length
435 static constexpr int32_t INT16_SIZE = 2;  // 2 is int16 and uint16 num length
436 
ResponseMessageFuzzTestInt64FromParcel(const uint8_t * data,size_t size)437 void ResponseMessageFuzzTestInt64FromParcel(const uint8_t *data, size_t size)
438 {
439     int64_t except = 123456; // 123456 is except num
440     char *parcel = reinterpret_cast<char *>(&except);
441     int64_t num;
442     int testSize = INT32_SIZE;
443     ResponseMessageReceiver::Int64FromParcel(num, parcel, testSize);
444     testSize = INT64_SIZE;
445     ResponseMessageReceiver::Int64FromParcel(num, parcel, testSize);
446 }
447 
ResponseMessageFuzzTestUint64FromParcel(const uint8_t * data,size_t size)448 void ResponseMessageFuzzTestUint64FromParcel(const uint8_t *data, size_t size)
449 {
450     uint64_t except = 123456; // 123456 is except num
451     char *parcel = reinterpret_cast<char *>(&except);
452     uint64_t num;
453     int testSize = INT32_SIZE;
454     ResponseMessageReceiver::Uint64FromParcel(num, parcel, testSize);
455     testSize = INT64_SIZE;
456     ResponseMessageReceiver::Uint64FromParcel(num, parcel, testSize);
457 }
458 
ResponseMessageFuzzTestInt32FromParcel(const uint8_t * data,size_t size)459 void ResponseMessageFuzzTestInt32FromParcel(const uint8_t *data, size_t size)
460 {
461     int32_t except = 123456; // 123456 is except num
462     char *parcel = reinterpret_cast<char *>(&except);
463     int32_t num;
464     int testSize = INT16_SIZE;
465     ResponseMessageReceiver::Int32FromParcel(num, parcel, testSize);
466     testSize = INT32_SIZE;
467     ResponseMessageReceiver::Int32FromParcel(num, parcel, testSize);
468 }
469 
ResponseMessageFuzzTestUint32FromParcel(const uint8_t * data,size_t size)470 void ResponseMessageFuzzTestUint32FromParcel(const uint8_t *data, size_t size)
471 {
472     uint32_t except = 123456; // 123456 is except num
473     char *parcel = reinterpret_cast<char *>(&except);
474     uint32_t num;
475     int testSize = INT16_SIZE;
476     ResponseMessageReceiver::Uint32FromParcel(num, parcel, testSize);
477     testSize = INT32_SIZE;
478     ResponseMessageReceiver::Uint32FromParcel(num, parcel, testSize);
479 }
480 
ResponseMessageFuzzTestInt16FromParcel(const uint8_t * data,size_t size)481 void ResponseMessageFuzzTestInt16FromParcel(const uint8_t *data, size_t size)
482 {
483     int16_t except = 123; // 123 is except num
484     char *parcel = reinterpret_cast<char *>(&except);
485     int16_t num;
486     int testSize = 0;
487     ResponseMessageReceiver::Int16FromParcel(num, parcel, testSize);
488     testSize = INT16_SIZE;
489     ResponseMessageReceiver::Int16FromParcel(num, parcel, testSize);
490 }
491 
ResponseMessageFuzzTestStateFromParcel(const uint8_t * data,size_t size)492 void ResponseMessageFuzzTestStateFromParcel(const uint8_t *data, size_t size)
493 {
494     State state;
495     uint32_t except = static_cast<uint32_t>(State::ANY) + 1;
496     char *parcel = reinterpret_cast<char *>(&except);
497     int testSize = INT32_SIZE;
498     ResponseMessageReceiver::StateFromParcel(state, parcel, testSize);
499     except = static_cast<uint32_t>(State::ANY);
500     parcel = reinterpret_cast<char *>(&except);
501     testSize = INT32_SIZE;
502     ResponseMessageReceiver::StateFromParcel(state, parcel, testSize);
503 }
504 
ResponseMessageFuzzTestActionFromParcel(const uint8_t * data,size_t size)505 void ResponseMessageFuzzTestActionFromParcel(const uint8_t *data, size_t size)
506 {
507     Action action;
508     uint32_t except = static_cast<uint32_t>(Action::ANY) + 1;
509     char *parcel = reinterpret_cast<char *>(&except);
510     int testSize = INT32_SIZE;
511     ResponseMessageReceiver::ActionFromParcel(action, parcel, testSize);
512     except = static_cast<uint32_t>(Action::ANY);
513     parcel = reinterpret_cast<char *>(&except);
514     testSize = INT32_SIZE;
515     ResponseMessageReceiver::ActionFromParcel(action, parcel, testSize);
516 }
517 
ResponseMessageFuzzTestVersionFromParcel(const uint8_t * data,size_t size)518 void ResponseMessageFuzzTestVersionFromParcel(const uint8_t *data, size_t size)
519 {
520     Version version;
521     uint32_t except = static_cast<uint32_t>(Version::API10) + 1;
522     char *parcel = reinterpret_cast<char *>(&except);
523     int testSize = INT32_SIZE;
524     ResponseMessageReceiver::VersionFromParcel(version, parcel, testSize);
525     except = static_cast<uint32_t>(Version::API10);
526     parcel = reinterpret_cast<char *>(&except);
527     testSize = INT32_SIZE;
528     ResponseMessageReceiver::VersionFromParcel(version, parcel, testSize);
529 }
530 
ResponseMessageFuzzTestSubscribeTypeFromParcel(const uint8_t * data,size_t size)531 void ResponseMessageFuzzTestSubscribeTypeFromParcel(const uint8_t *data, size_t size)
532 {
533     SubscribeType type;
534     uint32_t except = static_cast<uint32_t>(SubscribeType::BUTT) + 1;
535     char *parcel = reinterpret_cast<char *>(&except);
536     int testSize = INT32_SIZE;
537     ResponseMessageReceiver::SubscribeTypeFromParcel(type, parcel, testSize);
538     except = static_cast<uint32_t>(SubscribeType::BUTT);
539     parcel = reinterpret_cast<char *>(&except);
540     testSize = INT32_SIZE;
541     ResponseMessageReceiver::SubscribeTypeFromParcel(type, parcel, testSize);
542 }
543 
ResponseMessageFuzzTestStringFromParcel(const uint8_t * data,size_t size)544 void ResponseMessageFuzzTestStringFromParcel(const uint8_t *data, size_t size)
545 {
546     std::string str;
547     std::string except = "except string";
548     char *parcel = const_cast<char *>(except.c_str());
549     int testSize = except.size() - 1;
550     ResponseMessageReceiver::StringFromParcel(str, parcel, testSize);
551     testSize = except.size() + 1;
552     ResponseMessageReceiver::StringFromParcel(str, parcel, testSize);
553 }
554 
ResponseMessageFuzzTestResponseHeaderFromParcel(const uint8_t * data,size_t size)555 void ResponseMessageFuzzTestResponseHeaderFromParcel(const uint8_t *data, size_t size)
556 {
557     std::map<std::string, std::vector<std::string>> headers;
558     std::string except = "header:aaa,bbb,ccc\n";
559     char *parcel = const_cast<char *>(except.c_str());
560     int testSize = except.size();
561     ResponseMessageReceiver::ResponseHeaderFromParcel(headers, parcel, testSize);
562 }
563 
ResponseMessageFuzzTestProgressExtrasFromParcel(const uint8_t * data,size_t size)564 void ResponseMessageFuzzTestProgressExtrasFromParcel(const uint8_t *data, size_t size)
565 {
566     int arraySize = 64; // 64 is char array length
567     char except[arraySize];
568     uint32_t length = 1;
569     int ret = memcpy_s(except, static_cast<size_t>(arraySize), reinterpret_cast<void *>(&length), sizeof(length));
570     if (ret != 0) {
571         return;
572     }
573     char keyValue[] = "key\0value\0";
574     ret = memcpy_s(except + sizeof(length), static_cast<size_t>(arraySize - sizeof(length)), keyValue,
575         9); // 9 is keyValue length
576     if (ret != 0) {
577         return;
578     }
579     std::map<std::string, std::string> extras;
580     char *parcel = except;
581     int testSize = INT16_SIZE;
582     ResponseMessageReceiver::ProgressExtrasFromParcel(extras, parcel, testSize);
583     parcel = except;
584     testSize = sizeof(length) + 1;
585     ResponseMessageReceiver::ProgressExtrasFromParcel(extras, parcel, testSize);
586     parcel = except;
587     testSize = sizeof(length) + 6; // 6 make except testSize between the keyValue
588     ResponseMessageReceiver::ProgressExtrasFromParcel(extras, parcel, testSize);
589     parcel = except;
590     testSize = arraySize;
591     ResponseMessageReceiver::ProgressExtrasFromParcel(extras, parcel, testSize);
592 }
593 
ResponseMessageFuzzTestVecInt64FromParcel(const uint8_t * data,size_t size)594 void ResponseMessageFuzzTestVecInt64FromParcel(const uint8_t *data, size_t size)
595 {
596     int arraySize = INT32_SIZE + INT64_SIZE;
597     char except[arraySize];
598     uint32_t length = 1;
599     int ret = memcpy_s(except, static_cast<size_t>(arraySize), reinterpret_cast<void *>(&length), sizeof(length));
600     if (ret != 0) {
601         return;
602     }
603     int64_t value = 123456; // 123456 is except num
604     ret = memcpy_s(except + sizeof(length), static_cast<size_t>(arraySize - sizeof(length)),
605         reinterpret_cast<void *>(&value), sizeof(value));
606     if (ret != 0) {
607         return;
608     }
609     std::vector<int64_t> vec;
610     char *parcel = except;
611     int testSize = INT16_SIZE;
612     ResponseMessageReceiver::VecInt64FromParcel(vec, parcel, testSize);
613     parcel = except;
614     testSize = INT64_SIZE;
615     ResponseMessageReceiver::VecInt64FromParcel(vec, parcel, testSize);
616     parcel = except;
617     testSize = arraySize; // 6 make except testSize between the keyValue
618     ResponseMessageReceiver::VecInt64FromParcel(vec, parcel, testSize);
619 }
620 
ResponseMessageFuzzTestResponseMessageReceiver(const uint8_t * data,size_t size)621 void ResponseMessageFuzzTestResponseMessageReceiver(const uint8_t *data, size_t size)
622 {
623     IResponseMessageHandler *handler = nullptr;
624     int32_t sockFd = -1;
625     ResponseMessageReceiver receiver = ResponseMessageReceiver(handler, sockFd);
626 }
627 
ResponseMessageFuzzTestMsgHeaderParcel(const uint8_t * data,size_t size)628 void ResponseMessageFuzzTestMsgHeaderParcel(const uint8_t *data, size_t size)
629 {
630     uint32_t magicNum = ResponseMessageReceiver::RESPONSE_MAGIC_NUM - 1;
631     int pos = 0;
632     int arraySize = INT32_SIZE + INT64_SIZE;
633     char except[arraySize];
634     int ret = memcpy_s(except, static_cast<size_t>(arraySize), reinterpret_cast<void *>(&magicNum), sizeof(magicNum));
635     if (ret != 0) {
636         return;
637     }
638     pos += sizeof(magicNum);
639     int32_t msgId = 123456; // 123456 is except num
640     ret = memcpy_s(except + pos, static_cast<size_t>(arraySize - pos), reinterpret_cast<void *>(&msgId), sizeof(msgId));
641     if (ret != 0) {
642         return;
643     }
644     pos += sizeof(msgId);
645     int16_t msgType = 123; // 123 is except num
646     ret = memcpy_s(
647         except + pos, static_cast<size_t>(arraySize - pos), reinterpret_cast<void *>(&msgType), sizeof(msgType));
648     if (ret != 0) {
649         return;
650     }
651     pos += sizeof(msgType);
652     int16_t bodySize = 456; // 456 is except num
653     ret = memcpy_s(
654         except + pos, static_cast<size_t>(arraySize - pos), reinterpret_cast<void *>(&bodySize), sizeof(bodySize));
655     if (ret != 0) {
656         return;
657     }
658     pos += sizeof(bodySize);
659     msgId = 0;
660     msgType = 0;
661     bodySize = 0;
662     char *parcel = except;
663     int testSize = INT16_SIZE;
664     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
665     parcel = except;
666     testSize = INT32_SIZE;
667     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
668     parcel = except;
669     testSize = INT32_SIZE;
670     magicNum = ResponseMessageReceiver::RESPONSE_MAGIC_NUM;
671     ret = memcpy_s(except, static_cast<size_t>(arraySize), reinterpret_cast<void *>(&magicNum), sizeof(magicNum));
672     if (ret != 0) {
673         return;
674     }
675     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
676     parcel = except;
677     testSize = INT32_SIZE + INT16_SIZE;
678     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
679     parcel = except;
680     testSize = INT64_SIZE;
681     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize); // 123456 is except num
682     parcel = except;
683     testSize = INT64_SIZE + INT16_SIZE;
684     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
685     parcel = except;
686     testSize = arraySize;
687     ResponseMessageReceiver::MsgHeaderParcel(msgId, msgType, bodySize, parcel, testSize);
688 }
689 
ResponseMessageFuzzTestResponseFromParcel(const uint8_t * data,size_t size)690 void ResponseMessageFuzzTestResponseFromParcel(const uint8_t *data, size_t size)
691 {
692     std::shared_ptr<Response> response = std::make_shared<Response>();
693     int pos = 0;
694     int32_t tid = 123; // 123 is except tid
695     std::string version = "version";
696     int32_t statusCode = 456; // 456 is except statusCode
697     std::string reason = "reason";
698     std::string headers = "header:aaa,bbb,ccc\n";
699     char except[ARRAY_LEN];
700     int ret = memcpy_s(except, static_cast<size_t>(ARRAY_LEN), reinterpret_cast<void *>(&tid), sizeof(tid));
701     if (ret != 0) {
702         return;
703     }
704     pos += sizeof(tid);
705     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), version.c_str(), version.size() + 1);
706     if (ret != 0) {
707         return;
708     }
709     pos += (version.size() + 1);
710     ret = memcpy_s(
711         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&statusCode), sizeof(statusCode));
712     if (ret != 0) {
713         return;
714     }
715     pos += sizeof(statusCode);
716     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reason.c_str(), reason.size() + 1);
717     if (ret != 0) {
718         return;
719     }
720     pos += (reason.size() + 1);
721     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), headers.c_str(), headers.size() + 1);
722     if (ret != 0) {
723         return;
724     }
725     pos += (headers.size() + 1);
726     char *parcel = except;
727     int testSize = INT16_SIZE;
728     ResponseMessageReceiver::ResponseFromParcel(response, parcel, testSize);
729     parcel = except;
730     testSize = INT32_SIZE;
731     ResponseMessageReceiver::ResponseFromParcel(response, parcel, testSize);
732     parcel = except;
733     testSize = INT32_SIZE + version.size() + 1;
734     ResponseMessageReceiver::ResponseFromParcel(response, parcel, testSize);
735     parcel = except;
736     testSize = INT64_SIZE + version.size() + 1;
737     ResponseMessageReceiver::ResponseFromParcel(response, parcel, testSize);
738     parcel = except;
739     testSize = ARRAY_LEN;
740     ResponseMessageReceiver::ResponseFromParcel(response, parcel, testSize);
741 }
742 
ResponseMessageFuzzTestTaskStatesFromParcel(const uint8_t * data,size_t size)743 void ResponseMessageFuzzTestTaskStatesFromParcel(const uint8_t *data, size_t size)
744 {
745     std::vector<TaskState> taskStates;
746     int pos = 0;
747     int32_t length = 1;
748     std::string path = "path";
749     int32_t responseCode = NETWORK_OFFLINE;
750     std::string message = "message";
751     char except[ARRAY_LEN];
752     int ret = memcpy_s(except, static_cast<size_t>(ARRAY_LEN), reinterpret_cast<void *>(&length), sizeof(length));
753     if (ret != 0) {
754         return;
755     }
756     pos += sizeof(length);
757     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), path.c_str(), path.size() + 1);
758     if (ret != 0) {
759         return;
760     }
761     pos += (path.size() + 1);
762     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&responseCode),
763         sizeof(responseCode));
764     if (ret != 0) {
765         return;
766     }
767     pos += sizeof(responseCode);
768     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), message.c_str(), message.size() + 1);
769     if (ret != 0) {
770         return;
771     }
772     pos += (message.size() + 1);
773     char *parcel = except;
774     int testSize = INT16_SIZE;
775     ResponseMessageReceiver::TaskStatesFromParcel(taskStates, parcel, testSize);
776     parcel = except;
777     testSize = INT32_SIZE;
778     ResponseMessageReceiver::TaskStatesFromParcel(taskStates, parcel, testSize);
779     parcel = except;
780     testSize = INT32_SIZE + path.size() + 1;
781     ResponseMessageReceiver::TaskStatesFromParcel(taskStates, parcel, testSize);
782     parcel = except;
783     testSize = INT64_SIZE + path.size() + 1;
784     ResponseMessageReceiver::TaskStatesFromParcel(taskStates, parcel, testSize);
785     parcel = except;
786     testSize = ARRAY_LEN;
787     ResponseMessageReceiver::TaskStatesFromParcel(taskStates, parcel, testSize);
788 }
789 
ResponseMessageFuzzTestNotifyDataFromParcel(const uint8_t * data,size_t size)790 void ResponseMessageFuzzTestNotifyDataFromParcel(const uint8_t *data, size_t size)
791 {
792     std::shared_ptr<NotifyData> notifyData = std::make_shared<NotifyData>();
793     int pos = 0;
794     int32_t length = 1;
795     SubscribeType type = SubscribeType::BUTT;
796     uint32_t taskId = 123; // 123 is except tid
797     State state = State::ANY;
798     uint32_t index = 456;             // 456 is except index
799     uint64_t processed = 123456;      // 123456 is except processed
800     uint64_t totalProcessed = 111222; // 111222 is except totalProcessed
801     int64_t value = 333444;           // 333444 is except num
802     int ketValueLen = 10;             //9 is keyValue length
803     char keyValue[] = "key\0value\0";
804     Action action = Action::UPLOAD;
805     Version version = Version::API10;
806     std::string path = "path";
807     int32_t responseCode = NETWORK_OFFLINE;
808     std::string message = "message";
809     char except[ARRAY_LEN];
810     int ret = memcpy_s(except, static_cast<size_t>(ARRAY_LEN), reinterpret_cast<void *>(&type), sizeof(type));
811     if (ret != 0) {
812         return;
813     }
814     pos += sizeof(type);
815     ret = memcpy_s(
816         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&taskId), sizeof(taskId));
817     if (ret != 0) {
818         return;
819     }
820     pos += sizeof(taskId);
821     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&state), sizeof(state));
822     if (ret != 0) {
823         return;
824     }
825     pos += sizeof(state);
826     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&index), sizeof(index));
827     if (ret != 0) {
828         return;
829     }
830     pos += sizeof(index);
831     ret = memcpy_s(
832         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&processed), sizeof(processed));
833     if (ret != 0) {
834         return;
835     }
836     pos += sizeof(processed);
837     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&totalProcessed),
838         sizeof(totalProcessed));
839     if (ret != 0) {
840         return;
841     }
842     pos += sizeof(totalProcessed);
843     ret = memcpy_s(
844         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&length), sizeof(length));
845     if (ret != 0) {
846         return;
847     }
848     pos += sizeof(length);
849     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&value), sizeof(value));
850     if (ret != 0) {
851         return;
852     }
853     pos += sizeof(value);
854     ret = memcpy_s(
855         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&length), sizeof(length));
856     if (ret != 0) {
857         return;
858     }
859     pos += sizeof(length);
860     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), keyValue, ketValueLen);
861     if (ret != 0) {
862         return;
863     }
864     pos += ketValueLen;
865     ret = memcpy_s(
866         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&action), sizeof(action));
867     if (ret != 0) {
868         return;
869     }
870     pos += sizeof(action);
871     ret = memcpy_s(
872         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&version), sizeof(version));
873     if (ret != 0) {
874         return;
875     }
876     pos += sizeof(version);
877     ret = memcpy_s(
878         except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&length), sizeof(length));
879     if (ret != 0) {
880         return;
881     }
882     pos += sizeof(length);
883     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), path.c_str(), path.size() + 1);
884     if (ret != 0) {
885         return;
886     }
887     pos += (path.size() + 1);
888     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), reinterpret_cast<void *>(&responseCode),
889         sizeof(responseCode));
890     if (ret != 0) {
891         return;
892     }
893     pos += sizeof(responseCode);
894     ret = memcpy_s(except + pos, static_cast<size_t>(ARRAY_LEN - pos), message.c_str(), message.size() + 1);
895     if (ret != 0) {
896         return;
897     }
898     pos += (message.size() + 1);
899     char *parcel = except;
900     int testSize = INT16_SIZE;
901     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
902     parcel = except;
903     testSize = INT32_SIZE;
904     int maxLen = testSize;
905     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
906     parcel = except;
907     maxLen += INT32_SIZE;
908     testSize = maxLen;
909     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
910     parcel = except;
911     maxLen += INT32_SIZE;
912     testSize = maxLen;
913     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
914     parcel = except;
915     maxLen += INT32_SIZE;
916     testSize = maxLen;
917     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
918     parcel = except;
919     maxLen += INT64_SIZE;
920     testSize = maxLen;
921     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
922     parcel = except;
923     maxLen += INT64_SIZE;
924     testSize = maxLen;
925     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
926     parcel = except;
927     maxLen += (sizeof(length) + sizeof(value));
928     testSize = maxLen;
929     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
930     parcel = except;
931     maxLen += (sizeof(length) + ketValueLen);
932     testSize = maxLen;
933     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
934     parcel = except;
935     maxLen += INT32_SIZE;
936     testSize = maxLen;
937     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
938     parcel = except;
939     maxLen += INT32_SIZE;
940     testSize = maxLen;
941     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
942     parcel = except;
943     testSize = ARRAY_LEN;
944     ResponseMessageReceiver::NotifyDataFromParcel(notifyData, parcel, testSize);
945 }
946 
947 class FuzzRemoteObjectImpl : public OHOS::IRemoteObject {};
948 
RequestSyncLoadFuzzTestOnLoadSystemAbility(const uint8_t * data,size_t size)949 void RequestSyncLoadFuzzTestOnLoadSystemAbility(const uint8_t *data, size_t size)
950 {
951     OHOS::sptr<FuzzRemoteObjectImpl> remote;
952     RequestSyncLoadCallback requestSyncLoadCallback = RequestSyncLoadCallback();
953     requestSyncLoadCallback.OnLoadSystemAbilityFail(OHOS::PRINT_SERVICE_ID);
954     requestSyncLoadCallback.OnLoadSystemAbilityFail(OHOS::DOWNLOAD_SERVICE_ID);
955     requestSyncLoadCallback.OnLoadSystemAbilitySuccess(OHOS::PRINT_SERVICE_ID, remote);
956     requestSyncLoadCallback.OnLoadSystemAbilitySuccess(OHOS::DOWNLOAD_SERVICE_ID, remote);
957 }
958 
959 } // namespace OHOS
960 
961 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)962 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
963 {
964     /* Run your code on data */
965     OHOS::CreateRequestFuzzTest(data, size);
966     OHOS::StartRequestFuzzTest(data, size);
967     OHOS::StopRequestFuzzTest(data, size);
968     OHOS::ShowRequestFuzzTest(data, size);
969     OHOS::TouchRequestFuzzTest(data, size);
970     OHOS::SearchRequestFuzzTest(data, size);
971     OHOS::PauseRequestFuzzTest(data, size);
972     OHOS::QueryMimeTypeRequestFuzzTest(data, size);
973     OHOS::RemoveRequestFuzzTest(data, size);
974     OHOS::ResumeRequestFuzzTest(data, size);
975     OHOS::GetTaskRequestFuzzTest(data, size);
976     OHOS::SubscribeRequestFuzzTest(data, size);
977     OHOS::UnsubscribeRequestFuzzTest(data, size);
978     OHOS::RestoreListenerRequestFuzzTest(data, size);
979     OHOS::IsSaReadyRequestFuzzTest(data, size);
980     OHOS::ReopenChannelRequestFuzzTest(data, size);
981     OHOS::SubscribeSARequestFuzzTest(data, size);
982     OHOS::AddAndRemoveListenerRequestFuzzTest(data, size);
983     OHOS::RemoveAllListenersRequestFuzzTest(data, size);
984     OHOS::QueryRequestFuzzTest(data, size);
985     OHOS::RequestFuzzTestGetId(data, size);
986     OHOS::RequestFuzzTestHasListener(data, size);
987     OHOS::RequestFuzzTestOnNotifyDataReceive(data, size);
988     OHOS::RequestFuzzTestAddAndRemoveListener(data, size);
989     OHOS::RequestFuzzTestOnResponseReceive(data, size);
990     OHOS::RunningTaskCountFuzzTestSubscribeRunningTaskCount(data, size);
991     OHOS::RunningTaskCountFuzzTestUnubscribeRunning(data, size);
992     OHOS::RunningTaskCountFuzzTestGetAndSetCount(data, size);
993     OHOS::RunningTaskCountFuzzTestUpdateRunningTaskCount(data, size);
994     OHOS::RunningTaskCountFuzzTestNotifyAllObservers(data, size);
995     OHOS::RunCountNotifyStubFuzzTestGetInstance(data, size);
996     OHOS::RunCountNotifyStubFuzzTestCallBack(data, size);
997     OHOS::RunCountNotifyStubFuzzTestDone(data, size);
998     OHOS::RunCountNotifyStubFuzzTestOnCallBack(data, size);
999     OHOS::ResponseMessageFuzzTestInt64FromParcel(data, size);
1000     OHOS::ResponseMessageFuzzTestUint64FromParcel(data, size);
1001     OHOS::ResponseMessageFuzzTestInt32FromParcel(data, size);
1002     OHOS::ResponseMessageFuzzTestUint32FromParcel(data, size);
1003     OHOS::ResponseMessageFuzzTestInt16FromParcel(data, size);
1004     OHOS::ResponseMessageFuzzTestStateFromParcel(data, size);
1005     OHOS::ResponseMessageFuzzTestActionFromParcel(data, size);
1006     OHOS::ResponseMessageFuzzTestVersionFromParcel(data, size);
1007     OHOS::ResponseMessageFuzzTestSubscribeTypeFromParcel(data, size);
1008     OHOS::ResponseMessageFuzzTestStringFromParcel(data, size);
1009     OHOS::ResponseMessageFuzzTestResponseHeaderFromParcel(data, size);
1010     OHOS::ResponseMessageFuzzTestProgressExtrasFromParcel(data, size);
1011     OHOS::ResponseMessageFuzzTestVecInt64FromParcel(data, size);
1012     OHOS::ResponseMessageFuzzTestResponseMessageReceiver(data, size);
1013     OHOS::ResponseMessageFuzzTestMsgHeaderParcel(data, size);
1014     OHOS::ResponseMessageFuzzTestResponseFromParcel(data, size);
1015     OHOS::ResponseMessageFuzzTestTaskStatesFromParcel(data, size);
1016     OHOS::ResponseMessageFuzzTestNotifyDataFromParcel(data, size);
1017     OHOS::RequestSyncLoadFuzzTestOnLoadSystemAbility(data, size);
1018     return 0;
1019 }
1020