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 "distributedinputstub_fuzzer.h"
17 
18 #include "add_white_list_infos_call_back_stub.h"
19 #include "del_white_list_infos_call_back_stub.h"
20 #include "get_sink_screen_infos_call_back_stub.h"
21 #include "input_node_listener_stub.h"
22 #include "prepare_d_input_call_back_stub.h"
23 #include "register_d_input_call_back_stub.h"
24 #include "register_session_state_callback_stub.h"
25 #include "sharing_dhid_listener_stub.h"
26 #include "simulation_event_listener_stub.h"
27 #include "start_d_input_call_back_stub.h"
28 #include "start_stop_d_inputs_call_back_stub.h"
29 #include "start_stop_result_call_back_stub.h"
30 #include "stop_d_input_call_back_stub.h"
31 #include "unprepare_d_input_call_back_stub.h"
32 #include "unregister_d_input_call_back_stub.h"
33 
34 namespace OHOS {
35 namespace DistributedHardware {
36 
37 class MyAddWhiteListInfosCallbackStub : public DistributedInput::AddWhiteListInfosCallbackStub {
38 public:
OnResult(const std::string & deviceId,const std::string & strJson)39     void OnResult(const std::string &deviceId, const std::string &strJson) override
40     {
41         return;
42     }
43 };
44 
AddWhiteListInfosCallbackStubFuzzTest(const uint8_t * data,size_t size)45 void AddWhiteListInfosCallbackStubFuzzTest(const uint8_t *data, size_t size)
46 {
47     if ((data == nullptr) || (size < sizeof(int32_t))) {
48         return;
49     }
50     MessageParcel pdata;
51     MessageParcel reply;
52     MessageOption option;
53     pdata.WriteInterfaceToken(DistributedInput::AddWhiteListInfosCallbackStub::GetDescriptor());
54     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
55     if (code == (uint32_t)DistributedInput::IAddWhiteListInfosCallback::Message::RESULT) {
56         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
57         std::string value(reinterpret_cast<const char*>(data), size);
58         pdata.WriteUint32(tag);
59         pdata.WriteString(value);
60     } else {
61         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
62         int32_t len = *(reinterpret_cast<const int32_t*>(data));
63         std::string name(reinterpret_cast<const char*>(data), size);
64         pdata.WriteFileDescriptor(fd);
65         pdata.WriteInt32(len);
66         pdata.WriteString(name);
67     }
68     sptr<DistributedInput::AddWhiteListInfosCallbackStub> addWhiteListInfos(new (std::nothrow)
69         MyAddWhiteListInfosCallbackStub());
70     if (addWhiteListInfos == nullptr) {
71         return;
72     }
73     addWhiteListInfos->OnRemoteRequest(code, pdata, reply, option);
74 }
75 
76 class MyDelWhiteListInfosCallbackStub : public DistributedInput::DelWhiteListInfosCallbackStub {
77 public:
OnResult(const std::string & deviceId)78     void OnResult(const std::string &deviceId) override
79     {
80         return;
81     }
82 };
83 
DelWhiteListInfosCallbackStubFuzzTest(const uint8_t * data,size_t size)84 void DelWhiteListInfosCallbackStubFuzzTest(const uint8_t *data, size_t size)
85 {
86     if ((data == nullptr) || (size < sizeof(int32_t))) {
87         return;
88     }
89     MessageParcel pdata;
90     MessageParcel reply;
91     MessageOption option;
92     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
93     pdata.WriteInterfaceToken(DistributedInput::DelWhiteListInfosCallbackStub::GetDescriptor());
94     if (code == (uint32_t)DistributedInput::IDelWhiteListInfosCallback::Message::RESULT) {
95         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
96         std::string value(reinterpret_cast<const char*>(data), size);
97         pdata.WriteUint32(tag);
98         pdata.WriteString(value);
99     } else {
100         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
101         int32_t len = *(reinterpret_cast<const int32_t*>(data));
102         std::string name(reinterpret_cast<const char*>(data), size);
103         pdata.WriteFileDescriptor(fd);
104         pdata.WriteInt32(len);
105         pdata.WriteString(name);
106     }
107 
108     sptr<DistributedInput::DelWhiteListInfosCallbackStub> delWhiteListInfos(new (std::nothrow)
109         MyDelWhiteListInfosCallbackStub());
110     if (delWhiteListInfos == nullptr) {
111         return;
112     }
113     delWhiteListInfos->OnRemoteRequest(code, pdata, reply, option);
114 }
115 
Init()116 int32_t DistributedInputSinkStubFuzz::Init()
117 {
118     return DistributedInput::DH_SUCCESS;
119 }
120 
Release()121 int32_t DistributedInputSinkStubFuzz::Release()
122 {
123     return DistributedInput::DH_SUCCESS;
124 }
125 
RegisterGetSinkScreenInfosCallback(sptr<DistributedInput::IGetSinkScreenInfosCallback> callback)126 int32_t DistributedInputSinkStubFuzz::RegisterGetSinkScreenInfosCallback(
127     sptr<DistributedInput::IGetSinkScreenInfosCallback> callback)
128 {
129     (void)callback;
130     return DistributedInput::DH_SUCCESS;
131 }
132 
NotifyStartDScreen(const DistributedInput::SrcScreenInfo & remoteCtrlInfo)133 int32_t DistributedInputSinkStubFuzz::NotifyStartDScreen(
134     const DistributedInput::SrcScreenInfo &remoteCtrlInfo)
135 {
136     (void)remoteCtrlInfo;
137     return DistributedInput::DH_SUCCESS;
138 }
139 
NotifyStopDScreen(const std::string & srcScreenInfoKey)140 int32_t DistributedInputSinkStubFuzz::NotifyStopDScreen(
141     const std::string &srcScreenInfoKey)
142 {
143     (void)srcScreenInfoKey;
144     return DistributedInput::DH_SUCCESS;
145 }
146 
RegisterSharingDhIdListener(sptr<DistributedInput::ISharingDhIdListener> sharingDhIdListener)147 int32_t DistributedInputSinkStubFuzz::RegisterSharingDhIdListener(
148     sptr<DistributedInput::ISharingDhIdListener> sharingDhIdListener)
149 {
150     (void)sharingDhIdListener;
151     return DistributedInput::DH_SUCCESS;
152 }
153 
DistributedInputSinkStubFuzzTest(const uint8_t * data,size_t size)154 void DistributedInputSinkStubFuzzTest(const uint8_t *data, size_t size)
155 {
156     if ((data == nullptr) || (size < sizeof(int32_t))) {
157         return;
158     }
159     MessageParcel pdata;
160     MessageParcel reply;
161     MessageOption option;
162     pdata.WriteInterfaceToken(DistributedInput::DistributedInputSinkStub::GetDescriptor());
163     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
164     uint32_t type = *(reinterpret_cast<const uint32_t*>(data));
165     std::string content(reinterpret_cast<const char*>(data), size);
166     std::string devId(reinterpret_cast<const char*>(data), size);
167     pdata.WriteUint32(type);
168     pdata.WriteString(content);
169     pdata.WriteString(devId);
170 
171     sptr<DistributedInput::DistributedInputSinkStub> distributedInputSinkStub(new (std::nothrow)
172         DistributedInputSinkStubFuzz());
173     if (distributedInputSinkStub == nullptr) {
174         return;
175     }
176     distributedInputSinkStub->HasEnableDHPermission();
177     distributedInputSinkStub->OnRemoteRequest(code, pdata, reply, option);
178     distributedInputSinkStub->InitInner(pdata, reply, option);
179     distributedInputSinkStub->ReleaseInner(pdata, reply, option);
180     distributedInputSinkStub->NotifyStartDScreenInner(pdata, reply, option);
181     distributedInputSinkStub->NotifyStopDScreenInner(pdata, reply, option);
182     distributedInputSinkStub->RegisterSharingDhIdListenerInner(pdata, reply, option);
183     distributedInputSinkStub->RegisterGetSinkScreenInfosInner(pdata, reply, option);
184 }
185 
Init()186 int32_t DInputSourceCallBackStubFuzz::Init()
187 {
188     return DistributedInput::DH_SUCCESS;
189 }
190 
Release()191 int32_t DInputSourceCallBackStubFuzz::Release()
192 {
193     return DistributedInput::DH_SUCCESS;
194 }
195 
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & parameters,sptr<DistributedInput::IRegisterDInputCallback> callback)196 int32_t DInputSourceCallBackStubFuzz::RegisterDistributedHardware(
197     const std::string &devId, const std::string &dhId, const std::string &parameters,
198     sptr<DistributedInput::IRegisterDInputCallback> callback)
199 {
200     (void)devId;
201     (void)dhId;
202     (void)parameters;
203     (void)callback;
204     return DistributedInput::DH_SUCCESS;
205 }
206 
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,sptr<DistributedInput::IUnregisterDInputCallback> callback)207 int32_t DInputSourceCallBackStubFuzz::UnregisterDistributedHardware(
208     const std::string &devId, const std::string &dhId,
209     sptr<DistributedInput::IUnregisterDInputCallback> callback)
210 {
211     (void)devId;
212     (void)dhId;
213     (void)callback;
214     return DistributedInput::DH_SUCCESS;
215 }
216 
PrepareRemoteInput(const std::string & deviceId,sptr<DistributedInput::IPrepareDInputCallback> callback)217 int32_t DInputSourceCallBackStubFuzz::PrepareRemoteInput(
218     const std::string &deviceId, sptr<DistributedInput::IPrepareDInputCallback> callback)
219 {
220     (void)deviceId;
221     (void)callback;
222     return DistributedInput::DH_SUCCESS;
223 }
224 
UnprepareRemoteInput(const std::string & deviceId,sptr<DistributedInput::IUnprepareDInputCallback> callback)225 int32_t DInputSourceCallBackStubFuzz::UnprepareRemoteInput(
226     const std::string &deviceId, sptr<DistributedInput::IUnprepareDInputCallback> callback)
227 {
228     (void)deviceId;
229     (void)callback;
230     return DistributedInput::DH_SUCCESS;
231 }
232 
StartRemoteInput(const std::string & deviceId,const uint32_t & inputTypes,sptr<DistributedInput::IStartDInputCallback> callback)233 int32_t DInputSourceCallBackStubFuzz::StartRemoteInput(
234     const std::string &deviceId, const uint32_t &inputTypes, sptr<DistributedInput::IStartDInputCallback> callback)
235 {
236     (void)deviceId;
237     (void)inputTypes;
238     (void)callback;
239     return DistributedInput::DH_SUCCESS;
240 }
241 
StopRemoteInput(const std::string & deviceId,const uint32_t & inputTypes,sptr<DistributedInput::IStopDInputCallback> callback)242 int32_t DInputSourceCallBackStubFuzz::StopRemoteInput(
243     const std::string &deviceId, const uint32_t &inputTypes, sptr<DistributedInput::IStopDInputCallback> callback)
244 {
245     (void)deviceId;
246     (void)inputTypes;
247     (void)callback;
248     return DistributedInput::DH_SUCCESS;
249 }
250 
StartRemoteInput(const std::string & srcId,const std::string & sinkId,const uint32_t & inputTypes,sptr<DistributedInput::IStartDInputCallback> callback)251 int32_t DInputSourceCallBackStubFuzz::StartRemoteInput(
252     const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes,
253     sptr<DistributedInput::IStartDInputCallback> callback)
254 {
255     (void)srcId;
256     (void)sinkId;
257     (void)inputTypes;
258     (void)callback;
259     return DistributedInput::DH_SUCCESS;
260 }
261 
StopRemoteInput(const std::string & srcId,const std::string & sinkId,const uint32_t & inputTypes,sptr<DistributedInput::IStopDInputCallback> callback)262 int32_t DInputSourceCallBackStubFuzz::StopRemoteInput(
263     const std::string &srcId, const std::string &sinkId, const uint32_t &inputTypes,
264     sptr<DistributedInput::IStopDInputCallback> callback)
265 {
266     (void)srcId;
267     (void)sinkId;
268     (void)inputTypes;
269     (void)callback;
270     return DistributedInput::DH_SUCCESS;
271 }
272 
PrepareRemoteInput(const std::string & srcId,const std::string & sinkId,sptr<DistributedInput::IPrepareDInputCallback> callback)273 int32_t DInputSourceCallBackStubFuzz::PrepareRemoteInput(
274     const std::string &srcId, const std::string &sinkId,
275     sptr<DistributedInput::IPrepareDInputCallback> callback)
276 {
277     (void)srcId;
278     (void)sinkId;
279     (void)callback;
280     return DistributedInput::DH_SUCCESS;
281 }
282 
UnprepareRemoteInput(const std::string & srcId,const std::string & sinkId,sptr<DistributedInput::IUnprepareDInputCallback> callback)283 int32_t DInputSourceCallBackStubFuzz::UnprepareRemoteInput(
284     const std::string &srcId, const std::string &sinkId,
285     sptr<DistributedInput::IUnprepareDInputCallback> callback)
286 {
287     (void)srcId;
288     (void)sinkId;
289     (void)callback;
290     return DistributedInput::DH_SUCCESS;
291 }
292 
StartRemoteInput(const std::string & sinkId,const std::vector<std::string> & dhIds,sptr<DistributedInput::IStartStopDInputsCallback> callback)293 int32_t DInputSourceCallBackStubFuzz::StartRemoteInput(
294     const std::string &sinkId, const std::vector<std::string> &dhIds,
295     sptr<DistributedInput::IStartStopDInputsCallback> callback)
296 {
297     (void)sinkId;
298     (void)dhIds;
299     (void)callback;
300     return DistributedInput::DH_SUCCESS;
301 }
302 
StopRemoteInput(const std::string & sinkId,const std::vector<std::string> & dhIds,sptr<DistributedInput::IStartStopDInputsCallback> callback)303 int32_t DInputSourceCallBackStubFuzz::StopRemoteInput(
304     const std::string &sinkId, const std::vector<std::string> &dhIds,
305     sptr<DistributedInput::IStartStopDInputsCallback> callback)
306 {
307     (void)sinkId;
308     (void)dhIds;
309     (void)callback;
310     return DistributedInput::DH_SUCCESS;
311 }
312 
StartRemoteInput(const std::string & srcId,const std::string & sinkId,const std::vector<std::string> & dhIds,sptr<DistributedInput::IStartStopDInputsCallback> callback)313 int32_t DInputSourceCallBackStubFuzz::StartRemoteInput(
314     const std::string &srcId, const std::string &sinkId,
315     const std::vector<std::string> &dhIds, sptr<DistributedInput::IStartStopDInputsCallback> callback)
316 {
317     (void)srcId;
318     (void)sinkId;
319     (void)dhIds;
320     (void)callback;
321     return DistributedInput::DH_SUCCESS;
322 }
323 
StopRemoteInput(const std::string & srcId,const std::string & sinkId,const std::vector<std::string> & dhIds,sptr<DistributedInput::IStartStopDInputsCallback> callback)324 int32_t DInputSourceCallBackStubFuzz::StopRemoteInput(
325     const std::string &srcId, const std::string &sinkId,
326     const std::vector<std::string> &dhIds, sptr<DistributedInput::IStartStopDInputsCallback> callback)
327 {
328     (void)srcId;
329     (void)sinkId;
330     (void)dhIds;
331     (void)callback;
332     return DistributedInput::DH_SUCCESS;
333 }
334 
RegisterAddWhiteListCallback(sptr<DistributedInput::IAddWhiteListInfosCallback> addWhiteListCallback)335 int32_t DInputSourceCallBackStubFuzz::RegisterAddWhiteListCallback(
336     sptr<DistributedInput::IAddWhiteListInfosCallback> addWhiteListCallback)
337 {
338     (void)addWhiteListCallback;
339     return DistributedInput::DH_SUCCESS;
340 }
341 
RegisterDelWhiteListCallback(sptr<DistributedInput::IDelWhiteListInfosCallback> delWhiteListCallback)342 int32_t DInputSourceCallBackStubFuzz::RegisterDelWhiteListCallback(
343     sptr<DistributedInput::IDelWhiteListInfosCallback> delWhiteListCallback)
344 {
345     (void)delWhiteListCallback;
346     return DistributedInput::DH_SUCCESS;
347 }
348 
RegisterSimulationEventListener(sptr<DistributedInput::ISimulationEventListener> listener)349 int32_t DInputSourceCallBackStubFuzz::RegisterSimulationEventListener(
350     sptr<DistributedInput::ISimulationEventListener> listener)
351 {
352     (void)listener;
353     return DistributedInput::DH_SUCCESS;
354 }
355 
UnregisterSimulationEventListener(sptr<DistributedInput::ISimulationEventListener> listener)356 int32_t DInputSourceCallBackStubFuzz::UnregisterSimulationEventListener(
357     sptr<DistributedInput::ISimulationEventListener> listener)
358 {
359     (void)listener;
360     return DistributedInput::DH_SUCCESS;
361 }
362 
RegisterSessionStateCb(sptr<DistributedInput::ISessionStateCallback> callback)363 int32_t DInputSourceCallBackStubFuzz::RegisterSessionStateCb(
364     sptr<DistributedInput::ISessionStateCallback> callback)
365 {
366     (void)callback;
367     return DistributedInput::DH_SUCCESS;
368 }
369 
UnregisterSessionStateCb()370 int32_t DInputSourceCallBackStubFuzz::UnregisterSessionStateCb()
371 {
372     return DistributedInput::DH_SUCCESS;
373 }
374 
OnResult(const std::string & deviceId,const std::string & strJson)375 void DInputSourceCallBackStubFuzz::OnResult(const std::string &deviceId,
376     const std::string &strJson)
377 {
378     deviceId_ = deviceId;
379     strJson_ = strJson;
380 }
381 
DistributedInputSourceStubFuzzTest(const uint8_t * data,size_t size)382 void DistributedInputSourceStubFuzzTest(const uint8_t *data, size_t size)
383 {
384     if ((data == nullptr) || (size < sizeof(int32_t))) {
385         return;
386     }
387     MessageParcel pdata;
388     MessageParcel reply;
389     MessageOption option;
390     pdata.WriteInterfaceToken(DistributedInput::DistributedInputSourceStub::GetDescriptor());
391     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
392     uint32_t type = *(reinterpret_cast<const uint32_t*>(data));
393     std::string content(reinterpret_cast<const char*>(data), size);
394     std::string devId(reinterpret_cast<const char*>(data), size);
395     pdata.WriteUint32(type);
396     pdata.WriteString(content);
397     pdata.WriteString(devId);
398 
399     sptr<DistributedInput::DistributedInputSourceStub> distributedInputSourceStub(new (std::nothrow)
400         DInputSourceCallBackStubFuzz());
401     if (distributedInputSourceStub == nullptr) {
402         return;
403     }
404     distributedInputSourceStub->HasEnableDHPermission();
405     distributedInputSourceStub->HasAccessDHPermission();
406     distributedInputSourceStub->HandleInitDistributedHardware(reply);
407     distributedInputSourceStub->HandleReleaseDistributedHardware(reply);
408     distributedInputSourceStub->HandleRegisterDistributedHardware(pdata, reply);
409     distributedInputSourceStub->HandleUnregisterDistributedHardware(pdata, reply);
410     distributedInputSourceStub->HandlePrepareRemoteInput(pdata, reply);
411     distributedInputSourceStub->HandleUnprepareRemoteInput(pdata, reply);
412     distributedInputSourceStub->HandleStartRemoteInput(pdata, reply);
413     distributedInputSourceStub->HandleStopRemoteInput(pdata, reply);
414     distributedInputSourceStub->HandleStartRelayTypeRemoteInput(pdata, reply);
415     distributedInputSourceStub->HandleStopRelayTypeRemoteInput(pdata, reply);
416     distributedInputSourceStub->HandlePrepareRelayRemoteInput(pdata, reply);
417     distributedInputSourceStub->HandleUnprepareRelayRemoteInput(pdata, reply);
418     distributedInputSourceStub->HandleStartDhidRemoteInput(pdata, reply);
419     distributedInputSourceStub->HandleStopDhidRemoteInput(pdata, reply);
420     distributedInputSourceStub->HandleStartRelayDhidRemoteInput(pdata, reply);
421     distributedInputSourceStub->HandleStopRelayDhidRemoteInput(pdata, reply);
422     distributedInputSourceStub->HandleRegisterAddWhiteListCallback(pdata, reply);
423     distributedInputSourceStub->HandleRegisterDelWhiteListCallback(pdata, reply);
424     distributedInputSourceStub->HandleRegisterSimulationEventListener(pdata, reply);
425     distributedInputSourceStub->HandleUnregisterSimulationEventListener(pdata, reply);
426     distributedInputSourceStub->HandleRegisterSessionStateCb(pdata, reply);
427     distributedInputSourceStub->HandleUnregisterSessionStateCb(pdata, reply);
428     distributedInputSourceStub->OnRemoteRequest(code, pdata, reply, option);
429 }
430 
431 class MyGetSinkScreenInfosCallbackStub : public DistributedInput::GetSinkScreenInfosCallbackStub {
432 public:
OnResult(const std::string & deviceId)433     void OnResult(const std::string &deviceId) override
434     {
435         return;
436     }
437 };
438 
GetSinkScreenInfosCallbackStubFuzzTest(const uint8_t * data,size_t size)439 void GetSinkScreenInfosCallbackStubFuzzTest(const uint8_t *data, size_t size)
440 {
441     if ((data == nullptr) || (size < sizeof(int32_t))) {
442         return;
443     }
444     MessageParcel pdata;
445     MessageParcel reply;
446     MessageOption option;
447     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
448     pdata.WriteInterfaceToken(DistributedInput::GetSinkScreenInfosCallbackStub::GetDescriptor());
449     if (code == (uint32_t)DistributedInput::IGetSinkScreenInfosCallback::Message::RESULT) {
450         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
451         std::string value(reinterpret_cast<const char*>(data), size);
452         pdata.WriteUint32(tag);
453         pdata.WriteString(value);
454     } else {
455         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
456         int32_t len = *(reinterpret_cast<const int32_t*>(data));
457         std::string name(reinterpret_cast<const char*>(data), size);
458         pdata.WriteFileDescriptor(fd);
459         pdata.WriteInt32(len);
460         pdata.WriteString(name);
461     }
462 
463     sptr<DistributedInput::GetSinkScreenInfosCallbackStub> getSinkScreenInfosCbStub(new (std::nothrow)
464         MyGetSinkScreenInfosCallbackStub());
465     if (getSinkScreenInfosCbStub == nullptr) {
466         return;
467     }
468     getSinkScreenInfosCbStub->OnRemoteRequest(code, pdata, reply, option);
469 }
470 
471 class MyInputNodeListenerStub : public DistributedInput::InputNodeListenerStub {
472 public:
OnNodeOnLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId,const std::string & sinkNodeDesc)473     void OnNodeOnLine(const std::string &srcDevId, const std::string &sinkDevId,
474         const std::string &sinkNodeId, const std::string &sinkNodeDesc) override
475     {
476         (void)srcDevId;
477         (void)sinkDevId;
478         (void)sinkNodeId;
479         (void)sinkNodeDesc;
480         return;
481     }
482 
OnNodeOffLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId)483     void OnNodeOffLine(const std::string &srcDevId, const std::string &sinkDevId,
484         const std::string &sinkNodeId) override
485     {
486         (void)srcDevId;
487         (void)sinkDevId;
488         (void)sinkNodeId;
489         return;
490     }
491 };
492 
InputNodeListenerStubFuzzTest(const uint8_t * data,size_t size)493 void InputNodeListenerStubFuzzTest(const uint8_t *data, size_t size)
494 {
495     if ((data == nullptr) || (size < sizeof(int32_t))) {
496         return;
497     }
498     MessageParcel pdata;
499     MessageParcel reply;
500     MessageOption option;
501     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
502     pdata.WriteInterfaceToken(DistributedInput::InputNodeListenerStub::GetDescriptor());
503     if (code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_ON) {
504         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
505         std::string value(reinterpret_cast<const char*>(data), size);
506         pdata.WriteUint32(tag);
507         pdata.WriteString(value);
508     } else if (code == (uint32_t)DistributedInput::InputNodeListener::Message::RESULT_OFF) {
509         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
510         int32_t len = *(reinterpret_cast<const int32_t*>(data));
511         std::string name(reinterpret_cast<const char*>(data), size);
512         pdata.WriteFileDescriptor(fd);
513         pdata.WriteInt32(len);
514         pdata.WriteString(name);
515     } else {
516         uint32_t type = *(reinterpret_cast<const uint32_t*>(data));
517         std::string content(reinterpret_cast<const char*>(data), size);
518         std::string devId(reinterpret_cast<const char*>(data), size);
519         pdata.WriteUint32(type);
520         pdata.WriteString(content);
521         pdata.WriteString(devId);
522     }
523 
524     sptr<DistributedInput::InputNodeListenerStub> inputNodeListenerStub(new (std::nothrow)
525         MyInputNodeListenerStub());
526     if (inputNodeListenerStub == nullptr) {
527         return;
528     }
529     inputNodeListenerStub->OnRemoteRequest(code, pdata, reply, option);
530 }
531 
532 class MyPrepareDInputCallbackStub : public DistributedInput::PrepareDInputCallbackStub {
533 public:
OnResult(const std::string & devId,const int32_t & status)534     void OnResult(const std::string &devId, const int32_t &status) override
535     {
536         return;
537     }
538 };
539 
PrepareDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)540 void PrepareDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
541 {
542     if ((data == nullptr) || (size < sizeof(int32_t))) {
543         return;
544     }
545     MessageParcel pdata;
546     MessageParcel reply;
547     MessageOption option;
548     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
549     pdata.WriteInterfaceToken(DistributedInput::PrepareDInputCallbackStub::GetDescriptor());
550     if (code == (uint32_t)DistributedInput::IPrepareDInputCallback::Message::RESULT) {
551         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
552         std::string value(reinterpret_cast<const char*>(data), size);
553         pdata.WriteUint32(tag);
554         pdata.WriteString(value);
555     } else {
556         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
557         int32_t len = *(reinterpret_cast<const int32_t*>(data));
558         std::string name(reinterpret_cast<const char*>(data), size);
559         pdata.WriteFileDescriptor(fd);
560         pdata.WriteInt32(len);
561         pdata.WriteString(name);
562     }
563     sptr<DistributedInput::PrepareDInputCallbackStub> prepareDInputCallbackStub(new (std::nothrow)
564         MyPrepareDInputCallbackStub());
565     if (prepareDInputCallbackStub == nullptr) {
566         return;
567     }
568     prepareDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
569 }
570 
571 class MyRegisterDInputCallbackStub : public DistributedInput::RegisterDInputCallbackStub {
572 public:
OnResult(const std::string & devId,const std::string & dhId,const int32_t & status)573     void OnResult(const std::string &devId, const std::string &dhId, const int32_t &status) override
574     {
575         return;
576     }
577 };
578 
RegisterDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)579 void RegisterDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
580 {
581     if ((data == nullptr) || (size < sizeof(int32_t))) {
582         return;
583     }
584     MessageParcel pdata;
585     MessageParcel reply;
586     MessageOption option;
587     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
588     pdata.WriteInterfaceToken(DistributedInput::RegisterDInputCallbackStub::GetDescriptor());
589     if (code == (uint32_t)DistributedInput::IRegisterDInputCallback::Message::RESULT) {
590         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
591         std::string value(reinterpret_cast<const char*>(data), size);
592         pdata.WriteUint32(tag);
593         pdata.WriteString(value);
594     } else {
595         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
596         int32_t len = *(reinterpret_cast<const int32_t*>(data));
597         std::string name(reinterpret_cast<const char*>(data), size);
598         pdata.WriteFileDescriptor(fd);
599         pdata.WriteInt32(len);
600         pdata.WriteString(name);
601     }
602     sptr<DistributedInput::RegisterDInputCallbackStub> registerDInputCallbackStub(new (std::nothrow)
603         MyRegisterDInputCallbackStub());
604     if (registerDInputCallbackStub == nullptr) {
605         return;
606     }
607     registerDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
608 }
609 
610 class MyRegisterSessionStateCallbackStub : public DistributedInput::RegisterSessionStateCallbackStub {
611 public:
OnResult(const std::string & devId,const uint32_t status)612     void OnResult(const std::string &devId, const uint32_t status) override
613     {
614         return;
615     }
616 };
617 
RegisterSessionStateCallbackStubFuzzTest(const uint8_t * data,size_t size)618 void RegisterSessionStateCallbackStubFuzzTest(const uint8_t *data, size_t size)
619 {
620     if ((data == nullptr) || (size < sizeof(int32_t))) {
621         return;
622     }
623     MessageParcel pdata;
624     MessageParcel reply;
625     MessageOption option;
626     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
627     pdata.WriteInterfaceToken(DistributedInput::RegisterSessionStateCallbackStub::GetDescriptor());
628     if (code == (uint32_t)DistributedInput::ISessionStateCallback::Message::RESULT) {
629         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
630         std::string value(reinterpret_cast<const char*>(data), size);
631         pdata.WriteUint32(tag);
632         pdata.WriteString(value);
633     } else {
634         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
635         int32_t len = *(reinterpret_cast<const int32_t*>(data));
636         std::string name(reinterpret_cast<const char*>(data), size);
637         pdata.WriteFileDescriptor(fd);
638         pdata.WriteInt32(len);
639         pdata.WriteString(name);
640     }
641     sptr<DistributedInput::RegisterSessionStateCallbackStub> registerSessionStateCbkStub(new (std::nothrow)
642         MyRegisterSessionStateCallbackStub());
643     if (registerSessionStateCbkStub == nullptr) {
644         return;
645     }
646     registerSessionStateCbkStub->OnRemoteRequest(code, pdata, reply, option);
647 }
648 
649 class MySharingDhIdListenerStub : public DistributedInput::SharingDhIdListenerStub {
650 public:
OnSharing(const std::string & dhId)651     int32_t OnSharing(const std::string &dhId) override
652     {
653         (void)dhId;
654         return 0;
655     }
656 
OnNoSharing(const std::string & dhId)657     int32_t OnNoSharing(const std::string &dhId) override
658     {
659         (void)dhId;
660         return 0;
661     }
662 };
663 
SharingDhIdListenerStubFuzzTest(const uint8_t * data,size_t size)664 void SharingDhIdListenerStubFuzzTest(const uint8_t *data, size_t size)
665 {
666     if ((data == nullptr) || (size < sizeof(int32_t))) {
667         return;
668     }
669     MessageParcel pdata;
670     MessageParcel reply;
671     MessageOption option;
672     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
673     pdata.WriteInterfaceToken(DistributedInput::SharingDhIdListenerStub::GetDescriptor());
674     if (code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::SHARING) {
675         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
676         std::string value(reinterpret_cast<const char*>(data), size);
677         pdata.WriteUint32(tag);
678         pdata.WriteString(value);
679     } else if (code == (uint32_t)DistributedInput::ISharingDhIdListener::Message::NO_SHARING) {
680         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
681         int32_t len = *(reinterpret_cast<const int32_t*>(data));
682         std::string name(reinterpret_cast<const char*>(data), size);
683         pdata.WriteFileDescriptor(fd);
684         pdata.WriteInt32(len);
685         pdata.WriteString(name);
686     } else {
687         uint32_t type = *(reinterpret_cast<const uint32_t*>(data));
688         std::string content(reinterpret_cast<const char*>(data), size);
689         std::string devId(reinterpret_cast<const char*>(data), size);
690         pdata.WriteUint32(type);
691         pdata.WriteString(content);
692         pdata.WriteString(devId);
693     }
694     sptr<DistributedInput::SharingDhIdListenerStub> sharingDhIdListenerStub(new (std::nothrow)
695         MySharingDhIdListenerStub());
696     if (sharingDhIdListenerStub == nullptr) {
697         return;
698     }
699     sharingDhIdListenerStub->OnRemoteRequest(code, pdata, reply, option);
700 }
701 
702 class MySimulationEventListenerStub : public DistributedInput::SimulationEventListenerStub {
703 public:
OnSimulationEvent(uint32_t type,uint32_t code,int32_t value)704     int32_t OnSimulationEvent(uint32_t type, uint32_t code, int32_t value) override
705     {
706         return 0;
707     }
708 };
709 
SimulationEventListenerStubFuzzTest(const uint8_t * data,size_t size)710 void SimulationEventListenerStubFuzzTest(const uint8_t *data, size_t size)
711 {
712     if ((data == nullptr) || (size < sizeof(int32_t))) {
713         return;
714     }
715     MessageParcel pdata;
716     MessageParcel reply;
717     MessageOption option;
718     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
719     pdata.WriteInterfaceToken(DistributedInput::SimulationEventListenerStub::GetDescriptor());
720     if (code == (uint32_t)DistributedInput::ISimulationEventListener::Message::RESULT_ON) {
721         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
722         std::string value(reinterpret_cast<const char*>(data), size);
723         pdata.WriteUint32(tag);
724         pdata.WriteString(value);
725     } else {
726         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
727         int32_t len = *(reinterpret_cast<const int32_t*>(data));
728         std::string name(reinterpret_cast<const char*>(data), size);
729         pdata.WriteFileDescriptor(fd);
730         pdata.WriteInt32(len);
731         pdata.WriteString(name);
732     }
733     sptr<DistributedInput::SimulationEventListenerStub> simulationEventListenerStub(new (std::nothrow)
734         MySimulationEventListenerStub());
735     if (simulationEventListenerStub == nullptr) {
736         return;
737     }
738     simulationEventListenerStub->OnRemoteRequest(code, pdata, reply, option);
739 }
740 
741 class MyStartDInputCallbackStub : public DistributedInput::StartDInputCallbackStub {
742 public:
OnResult(const std::string & devId,const uint32_t & inputTypes,const int32_t & status)743     void OnResult(const std::string &devId, const uint32_t &inputTypes, const int32_t &status) override
744     {
745         return;
746     }
747 };
748 
StartDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)749 void StartDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
750 {
751     if ((data == nullptr) || (size < sizeof(int32_t))) {
752         return;
753     }
754     MessageParcel pdata;
755     MessageParcel reply;
756     MessageOption option;
757     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
758     pdata.WriteInterfaceToken(DistributedInput::StartDInputCallbackStub::GetDescriptor());
759     if (code == (uint32_t)DistributedInput::IStartDInputCallback::Message::RESULT) {
760         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
761         std::string value(reinterpret_cast<const char*>(data), size);
762         pdata.WriteUint32(tag);
763         pdata.WriteString(value);
764     } else {
765         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
766         int32_t len = *(reinterpret_cast<const int32_t*>(data));
767         std::string name(reinterpret_cast<const char*>(data), size);
768         pdata.WriteFileDescriptor(fd);
769         pdata.WriteInt32(len);
770         pdata.WriteString(name);
771     }
772     sptr<DistributedInput::StartDInputCallbackStub> startDInputCallbackStub(new (std::nothrow)
773         MyStartDInputCallbackStub());
774     if (startDInputCallbackStub == nullptr) {
775         return;
776     }
777     startDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
778 }
779 
780 class MyStartStopDInputsCallbackStub : public DistributedInput::StartStopDInputsCallbackStub {
781 public:
OnResultDhids(const std::string & devId,const int32_t & status)782     void OnResultDhids(const std::string &devId, const int32_t &status) override
783     {
784         return;
785     }
786 };
787 
StartStopDInputsCallbackStubFuzzTest(const uint8_t * data,size_t size)788 void StartStopDInputsCallbackStubFuzzTest(const uint8_t *data, size_t size)
789 {
790     if ((data == nullptr) || (size < sizeof(int32_t))) {
791         return;
792     }
793     MessageParcel pdata;
794     MessageParcel reply;
795     MessageOption option;
796     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
797     pdata.WriteInterfaceToken(DistributedInput::StartStopDInputsCallbackStub::GetDescriptor());
798     if (code == (uint32_t)DistributedInput::IStartStopDInputsCallback::Message::RESULT_STRING) {
799         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
800         std::string value(reinterpret_cast<const char*>(data), size);
801         pdata.WriteUint32(tag);
802         pdata.WriteString(value);
803     } else {
804         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
805         int32_t len = *(reinterpret_cast<const int32_t*>(data));
806         std::string name(reinterpret_cast<const char*>(data), size);
807         pdata.WriteFileDescriptor(fd);
808         pdata.WriteInt32(len);
809         pdata.WriteString(name);
810     }
811     sptr<DistributedInput::StartStopDInputsCallbackStub> startStopDInputsCallbackStub(new (std::nothrow)
812         MyStartStopDInputsCallbackStub());
813     if (startStopDInputsCallbackStub == nullptr) {
814         return;
815     }
816     startStopDInputsCallbackStub->OnRemoteRequest(code, pdata, reply, option);
817 }
818 
819 class MyStartStopResultCallbackStub : public DistributedInput::StartStopResultCallbackStub {
820 public:
OnStart(const std::string & srcId,const std::string & sinkId,std::vector<std::string> & dhIds)821     void OnStart(const std::string &srcId, const std::string &sinkId,
822         std::vector<std::string> &dhIds) override
823     {
824         return;
825     }
OnStop(const std::string & srcId,const std::string & sinkId,std::vector<std::string> & dhIds)826     void OnStop(const std::string &srcId, const std::string &sinkId,
827         std::vector<std::string> &dhIds) override
828     {
829         return;
830     }
831 };
832 
StartStopResultCallbackStubFuzzTest(const uint8_t * data,size_t size)833 void StartStopResultCallbackStubFuzzTest(const uint8_t *data, size_t size)
834 {
835     if ((data == nullptr) || (size < sizeof(int32_t))) {
836         return;
837     }
838     MessageParcel pdata;
839     MessageParcel reply;
840     MessageOption option;
841     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
842     pdata.WriteInterfaceToken(DistributedInput::StartStopResultCallbackStub::GetDescriptor());
843     if (code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_START) {
844         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
845         std::string value(reinterpret_cast<const char*>(data), size);
846         pdata.WriteUint32(tag);
847         pdata.WriteString(value);
848     } else if (code == (uint32_t)DistributedInput::IStartStopResultCallback::Message::RESULT_STOP) {
849         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
850         int32_t len = *(reinterpret_cast<const int32_t*>(data));
851         std::string name(reinterpret_cast<const char*>(data), size);
852         pdata.WriteFileDescriptor(fd);
853         pdata.WriteInt32(len);
854         pdata.WriteString(name);
855     } else {
856         uint32_t type = *(reinterpret_cast<const uint32_t*>(data));
857         std::string content(reinterpret_cast<const char*>(data), size);
858         std::string devId(reinterpret_cast<const char*>(data), size);
859         pdata.WriteUint32(type);
860         pdata.WriteString(content);
861         pdata.WriteString(devId);
862     }
863     sptr<DistributedInput::StartStopResultCallbackStub> startStopResultCallbackStub(new (std::nothrow)
864         MyStartStopResultCallbackStub());
865     if (startStopResultCallbackStub == nullptr) {
866         return;
867     }
868     startStopResultCallbackStub->OnRemoteRequest(code, pdata, reply, option);
869 }
870 
871 class MyStopDInputCallbackStub : public DistributedInput::StopDInputCallbackStub {
872 public:
OnResult(const std::string & devId,const uint32_t & inputTypes,const int32_t & status)873     void OnResult(const std::string &devId, const uint32_t &inputTypes, const int32_t &status) override
874     {
875         return;
876     }
877 };
878 
StopDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)879 void StopDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
880 {
881     if ((data == nullptr) || (size < sizeof(int32_t))) {
882         return;
883     }
884     MessageParcel pdata;
885     MessageParcel reply;
886     MessageOption option;
887     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
888     pdata.WriteInterfaceToken(DistributedInput::StopDInputCallbackStub::GetDescriptor());
889     if (code == (uint32_t)DistributedInput::IStopDInputCallback::Message::RESULT) {
890         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
891         std::string value(reinterpret_cast<const char*>(data), size);
892         pdata.WriteUint32(tag);
893         pdata.WriteString(value);
894     } else {
895         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
896         int32_t len = *(reinterpret_cast<const int32_t*>(data));
897         std::string name(reinterpret_cast<const char*>(data), size);
898         pdata.WriteFileDescriptor(fd);
899         pdata.WriteInt32(len);
900         pdata.WriteString(name);
901     }
902     sptr<DistributedInput::StopDInputCallbackStub> stopDInputCallbackStub(new (std::nothrow)
903         MyStopDInputCallbackStub());
904     if (stopDInputCallbackStub == nullptr) {
905         return;
906     }
907     stopDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
908 }
909 
910 class MyUnprepareDInputCallbackStub : public DistributedInput::UnprepareDInputCallbackStub {
911 public:
OnResult(const std::string & devId,const int32_t & status)912     void OnResult(const std::string &devId, const int32_t &status) override
913     {
914         return;
915     }
916 };
917 
UnprepareDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)918 void UnprepareDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
919 {
920     if ((data == nullptr) || (size < sizeof(int32_t))) {
921         return;
922     }
923     MessageParcel pdata;
924     MessageParcel reply;
925     MessageOption option;
926     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
927     pdata.WriteInterfaceToken(DistributedInput::UnprepareDInputCallbackStub::GetDescriptor());
928     if (code == (uint32_t)DistributedInput::IUnprepareDInputCallback::Message::RESULT) {
929         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
930         std::string value(reinterpret_cast<const char*>(data), size);
931         pdata.WriteUint32(tag);
932         pdata.WriteString(value);
933     } else {
934         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
935         int32_t len = *(reinterpret_cast<const int32_t*>(data));
936         std::string name(reinterpret_cast<const char*>(data), size);
937         pdata.WriteFileDescriptor(fd);
938         pdata.WriteInt32(len);
939         pdata.WriteString(name);
940     }
941     sptr<DistributedInput::UnprepareDInputCallbackStub> unprepareDInputCallbackStub(new (std::nothrow)
942         MyUnprepareDInputCallbackStub());
943     if (unprepareDInputCallbackStub == nullptr) {
944         return;
945     }
946     unprepareDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
947 }
948 
949 class MyUnregisterDInputCallbackStub : public DistributedInput::UnregisterDInputCallbackStub {
950 public:
OnResult(const std::string & devId,const std::string & dhId,const int32_t & status)951     void OnResult(const std::string &devId, const std::string &dhId, const int32_t &status) override
952     {
953         return;
954     }
955 };
956 
UnregisterDInputCallbackStubFuzzTest(const uint8_t * data,size_t size)957 void UnregisterDInputCallbackStubFuzzTest(const uint8_t *data, size_t size)
958 {
959     if ((data == nullptr) || (size < sizeof(int32_t))) {
960         return;
961     }
962     MessageParcel pdata;
963     MessageParcel reply;
964     MessageOption option;
965     uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
966     pdata.WriteInterfaceToken(DistributedInput::UnregisterDInputCallbackStub::GetDescriptor());
967     if (code == (uint32_t)DistributedInput::IUnprepareDInputCallback::Message::RESULT) {
968         uint32_t tag = *(reinterpret_cast<const uint32_t*>(data));
969         std::string value(reinterpret_cast<const char*>(data), size);
970         pdata.WriteUint32(tag);
971         pdata.WriteString(value);
972     } else {
973         int32_t fd = *(reinterpret_cast<const int32_t*>(data));
974         int32_t len = *(reinterpret_cast<const int32_t*>(data));
975         std::string name(reinterpret_cast<const char*>(data), size);
976         pdata.WriteFileDescriptor(fd);
977         pdata.WriteInt32(len);
978         pdata.WriteString(name);
979     }
980     sptr<DistributedInput::UnregisterDInputCallbackStub> unregisterDInputCallbackStub(new (std::nothrow)
981         MyUnregisterDInputCallbackStub());
982     if (unregisterDInputCallbackStub == nullptr) {
983         return;
984     }
985     unregisterDInputCallbackStub->OnRemoteRequest(code, pdata, reply, option);
986 }
987 } // namespace DistributedHardware
988 } // namespace OHOS
989 
990 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)991 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
992 {
993     /* Run your code on data */
994     OHOS::DistributedHardware::AddWhiteListInfosCallbackStubFuzzTest(data, size);
995     OHOS::DistributedHardware::DelWhiteListInfosCallbackStubFuzzTest(data, size);
996     OHOS::DistributedHardware::DistributedInputSinkStubFuzzTest(data, size);
997     OHOS::DistributedHardware::DistributedInputSourceStubFuzzTest(data, size);
998     OHOS::DistributedHardware::GetSinkScreenInfosCallbackStubFuzzTest(data, size);
999     OHOS::DistributedHardware::InputNodeListenerStubFuzzTest(data, size);
1000     OHOS::DistributedHardware::PrepareDInputCallbackStubFuzzTest(data, size);
1001     OHOS::DistributedHardware::RegisterDInputCallbackStubFuzzTest(data, size);
1002     OHOS::DistributedHardware::RegisterSessionStateCallbackStubFuzzTest(data, size);
1003     OHOS::DistributedHardware::SharingDhIdListenerStubFuzzTest(data, size);
1004     OHOS::DistributedHardware::SimulationEventListenerStubFuzzTest(data, size);
1005     OHOS::DistributedHardware::StartDInputCallbackStubFuzzTest(data, size);
1006     OHOS::DistributedHardware::StartStopDInputsCallbackStubFuzzTest(data, size);
1007     OHOS::DistributedHardware::StartStopResultCallbackStubFuzzTest(data, size);
1008     OHOS::DistributedHardware::StopDInputCallbackStubFuzzTest(data, size);
1009     OHOS::DistributedHardware::UnprepareDInputCallbackStubFuzzTest(data, size);
1010     OHOS::DistributedHardware::UnregisterDInputCallbackStubFuzzTest(data, size);
1011     return 0;
1012 }