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 "stubunsubscribeswitchevent_fuzzer.h"
17 
18 #include "mmi_log.h"
19 #include "mmi_service.h"
20 #include "multimodal_input_connect_stub.h"
21 
22 #undef MMI_LOG_TAG
23 #define MMI_LOG_TAG "StubUnsubscribeSwitchEventFuzzTest"
24 
25 namespace OHOS {
26 namespace MMI {
27 namespace OHOS {
StubUnsubscribeSwitchEventFuzzTest(const uint8_t * data,size_t size)28 bool StubUnsubscribeSwitchEventFuzzTest(const uint8_t* data, size_t size)
29 {
30     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
31     MessageParcel datas;
32     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
33         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
34         return false;
35     }
36     MessageParcel reply;
37     MessageOption option;
38     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
39     MMIService::GetInstance()->OnRemoteRequest(
40         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_SWITCH_EVENT), datas, reply, option);
41     return true;
42 }
43 
StubSetTouchpadRotateSwitchFuzzTest(const uint8_t * data,size_t size)44 bool StubSetTouchpadRotateSwitchFuzzTest(const uint8_t* data, size_t size)
45 {
46     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
47     MessageParcel datas;
48     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
49         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
50         return false;
51     }
52     MessageParcel reply;
53     MessageOption option;
54     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
55     MMIService::GetInstance()->OnRemoteRequest(
56         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_ROTATE_SWITCH), datas, reply, option);
57     return true;
58 }
59 
StubGetTouchpadRotateSwitchFuzzTest(const uint8_t * data,size_t size)60 bool StubGetTouchpadRotateSwitchFuzzTest(const uint8_t* data, size_t size)
61 {
62     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
63     MessageParcel datas;
64     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
65         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
66         return false;
67     }
68     MessageParcel reply;
69     MessageOption option;
70     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
71     MMIService::GetInstance()->OnRemoteRequest(
72         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_ROTATE_SWITCH), datas, reply, option);
73     return true;
74 }
75 
StubGetKeyStateFuzzTest(const uint8_t * data,size_t size)76 bool StubGetKeyStateFuzzTest(const uint8_t* data, size_t size)
77 {
78     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
79     MessageParcel datas;
80     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
81         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
82         return false;
83     }
84     MessageParcel reply;
85     MessageOption option;
86     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
87     MMIService::GetInstance()->OnRemoteRequest(
88         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_KEY_STATE), datas, reply, option);
89     return true;
90 }
91 
StubAuthorizeFuzzTest(const uint8_t * data,size_t size)92 bool StubAuthorizeFuzzTest(const uint8_t* data, size_t size)
93 {
94     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
95     MessageParcel datas;
96     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
97         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
98         return false;
99     }
100     MessageParcel reply;
101     MessageOption option;
102     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
103     MMIService::GetInstance()->OnRemoteRequest(
104         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_AUTHORIZE), datas, reply, option);
105     return true;
106 }
107 
StubCancelInjectionFuzzTest(const uint8_t * data,size_t size)108 bool StubCancelInjectionFuzzTest(const uint8_t* data, size_t size)
109 {
110     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
111     MessageParcel datas;
112     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
113         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
114         return false;
115     }
116     MessageParcel reply;
117     MessageOption option;
118     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
119     MMIService::GetInstance()->OnRemoteRequest(
120         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_INJECTION), datas, reply, option);
121     return true;
122 }
123 
StubHasIrEmitterFuzzTest(const uint8_t * data,size_t size)124 bool StubHasIrEmitterFuzzTest(const uint8_t* data, size_t size)
125 {
126     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
127     MessageParcel datas;
128     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
129         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
130         return false;
131     }
132     MessageParcel reply;
133     MessageOption option;
134     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
135     MMIService::GetInstance()->OnRemoteRequest(
136         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_OWN), datas, reply, option);
137     return true;
138 }
139 
StubGetInfraredFrequenciesFuzzTest(const uint8_t * data,size_t size)140 bool StubGetInfraredFrequenciesFuzzTest(const uint8_t* data, size_t size)
141 {
142     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
143     MessageParcel datas;
144     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
145         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
146         return false;
147     }
148     MessageParcel reply;
149     MessageOption option;
150     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
151     MMIService::GetInstance()->OnRemoteRequest(
152         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_FREQUENCY), datas, reply, option);
153     return true;
154 }
155 
StubTransmitInfraredFuzzTest(const uint8_t * data,size_t size)156 bool StubTransmitInfraredFuzzTest(const uint8_t* data, size_t size)
157 {
158     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
159     MessageParcel datas;
160     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
161         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
162         return false;
163     }
164     MessageParcel reply;
165     MessageOption option;
166     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
167     MMIService::GetInstance()->OnRemoteRequest(
168         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_TRANSMIT), datas, reply, option);
169     return true;
170 }
171 
StubSetPixelMapDataFuzzTest(const uint8_t * data,size_t size)172 bool StubSetPixelMapDataFuzzTest(const uint8_t* data, size_t size)
173 {
174     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
175     MessageParcel datas;
176     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
177         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
178         return false;
179     }
180     MessageParcel reply;
181     MessageOption option;
182     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
183     MMIService::GetInstance()->OnRemoteRequest(
184         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_PIXEL_MAP_DATA), datas, reply, option);
185     return true;
186 }
187 
StubSetCurrentUserFuzzTest(const uint8_t * data,size_t size)188 bool StubSetCurrentUserFuzzTest(const uint8_t* data, size_t size)
189 {
190     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
191     MessageParcel datas;
192     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
193         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
194         return false;
195     }
196     MessageParcel reply;
197     MessageOption option;
198     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
199     MMIService::GetInstance()->OnRemoteRequest(
200         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CURRENT_USERID), datas, reply, option);
201     return true;
202 }
203 
StubEnableHardwareCursorStatsFuzzTest(const uint8_t * data,size_t size)204 bool StubEnableHardwareCursorStatsFuzzTest(const uint8_t* data, size_t size)
205 {
206     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
207     MessageParcel datas;
208     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
209         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
210         return false;
211     }
212     MessageParcel reply;
213     MessageOption option;
214     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
215     MMIService::GetInstance()->OnRemoteRequest(
216         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ENABLE_HARDWARE_CURSOR_STATS),
217         datas, reply, option);
218     return true;
219 }
220 
StubGetHardwareCursorStatsFuzzTest(const uint8_t * data,size_t size)221 bool StubGetHardwareCursorStatsFuzzTest(const uint8_t* data, size_t size)
222 {
223     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
224     MessageParcel datas;
225     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
226         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
227         return false;
228     }
229     MessageParcel reply;
230     MessageOption option;
231     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
232     MMIService::GetInstance()->OnRemoteRequest(
233         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_HARDWARE_CURSOR_STATS), datas, reply, option);
234     return true;
235 }
236 
StubAddVirtualInputDeviceFuzzTest(const uint8_t * data,size_t size)237 bool StubAddVirtualInputDeviceFuzzTest(const uint8_t* data, size_t size)
238 {
239     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
240     MessageParcel datas;
241     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
242         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
243         return false;
244     }
245     MessageParcel reply;
246     MessageOption option;
247     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
248     MMIService::GetInstance()->OnRemoteRequest(
249         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_VIRTUAL_INPUT_DEVICE), datas, reply, option);
250     return true;
251 }
252 
StubRemoveVirtualInputDeviceFuzzTest(const uint8_t * data,size_t size)253 bool StubRemoveVirtualInputDeviceFuzzTest(const uint8_t* data, size_t size)
254 {
255     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
256     MessageParcel datas;
257     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
258         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
259         return false;
260     }
261     MessageParcel reply;
262     MessageOption option;
263     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
264     MMIService::GetInstance()->OnRemoteRequest(
265         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_VIRTUAL_INPUT_DEVICE), datas, reply, option);
266     return true;
267 }
268 
StubTransferBinderClientServiceFuzzTest(const uint8_t * data,size_t size)269 bool StubTransferBinderClientServiceFuzzTest(const uint8_t* data, size_t size)
270 {
271     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
272     MessageParcel datas;
273     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
274         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
275         return false;
276     }
277     MessageParcel reply;
278     MessageOption option;
279     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
280     MMIService::GetInstance()->OnRemoteRequest(
281         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::TRANSFER_BINDER_CLIENT_SERVICE),
282         datas, reply, option);
283     return true;
284 }
285 
286 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
StubGetPointerSnapshotFuzzTest(const uint8_t * data,size_t size)287 bool StubGetPointerSnapshotFuzzTest(const uint8_t* data, size_t size)
288 {
289     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
290     MessageParcel datas;
291     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
292         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
293         return false;
294     }
295     MessageParcel reply;
296     MessageOption option;
297     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
298     MMIService::GetInstance()->OnRemoteRequest(
299         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_SNAPSHOT), datas, reply, option);
300     return true;
301 }
302 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
303 
StubSkipPointerLayerFuzzTest(const uint8_t * data,size_t size)304 bool StubSkipPointerLayerFuzzTest(const uint8_t* data, size_t size)
305 {
306     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
307     MessageParcel datas;
308     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
309         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
310         return false;
311     }
312     MessageParcel reply;
313     MessageOption option;
314     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
315     MMIService::GetInstance()->OnRemoteRequest(
316         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SKIP_POINTER_LAYER), datas, reply, option);
317     return true;
318 }
319 
StubMarkEventConsumedFuzzTest(const uint8_t * data,size_t size)320 bool StubMarkEventConsumedFuzzTest(const uint8_t* data, size_t size)
321 {
322     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
323     MessageParcel datas;
324     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
325         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
326         return false;
327     }
328     MessageParcel reply;
329     MessageOption option;
330     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
331     MMIService::GetInstance()->OnRemoteRequest(
332         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::MARK_EVENT_CONSUMED), datas, reply, option);
333     return true;
334 }
335 
StubGetDeviceFuzzTest(const uint8_t * data,size_t size)336 bool StubGetDeviceFuzzTest(const uint8_t* data, size_t size)
337 {
338     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
339     MessageParcel datas;
340     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
341         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
342         return false;
343     }
344     MessageParcel reply;
345     MessageOption option;
346     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
347     MMIService::GetInstance()->OnRemoteRequest(
348         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_DEVICE), datas, reply, option);
349     return true;
350 }
351 
352 #ifdef OHOS_BUILD_ENABLE_ANCO
StubAncoAddChannelFuzzTest(const uint8_t * data,size_t size)353 bool StubAncoAddChannelFuzzTest(const uint8_t* data, size_t size)
354 {
355     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
356     MessageParcel datas;
357     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
358         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
359         return false;
360     }
361     MessageParcel reply;
362     MessageOption option;
363     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
364     MMIService::GetInstance()->OnRemoteRequest(
365         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_ANCO_CHANNEL), datas, reply, option);
366     return true;
367 }
368 
StubAncoRemoveChannelFuzzTest(const uint8_t * data,size_t size)369 bool StubAncoRemoveChannelFuzzTest(const uint8_t* data, size_t size)
370 {
371     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
372     MessageParcel datas;
373     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
374         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
375         return false;
376     }
377     MessageParcel reply;
378     MessageOption option;
379     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
380     MMIService::GetInstance()->OnRemoteRequest(
381         static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_ANCO_CHANNEL), datas, reply, option);
382     return true;
383 }
384 #endif // OHOS_BUILD_ENABLE_ANCO
385 
switchDefaultFuzzTest(const uint8_t * data,size_t size)386 bool switchDefaultFuzzTest(const uint8_t* data, size_t size)
387 {
388     const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
389     MessageParcel datas;
390     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
391         !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
392         return false;
393     }
394     MessageParcel reply;
395     MessageOption option;
396     MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
397     uint32_t code = 1000;
398     MMIService::GetInstance()->OnRemoteRequest(code, datas, reply, option);
399     return true;
400 }
401 } // namespace OHOS
402 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)403 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
404 {
405     /* Run your code on data */
406     if (data == nullptr) {
407         return 0;
408     }
409 
410     OHOS::StubUnsubscribeSwitchEventFuzzTest(data, size);
411     OHOS::StubSetTouchpadRotateSwitchFuzzTest(data, size);
412     OHOS::StubGetTouchpadRotateSwitchFuzzTest(data, size);
413     OHOS::StubGetKeyStateFuzzTest(data, size);
414     OHOS::StubAuthorizeFuzzTest(data, size);
415     OHOS::StubCancelInjectionFuzzTest(data, size);
416     OHOS::StubHasIrEmitterFuzzTest(data, size);
417     OHOS::StubGetInfraredFrequenciesFuzzTest(data, size);
418     OHOS::StubTransmitInfraredFuzzTest(data, size);
419     OHOS::StubSetPixelMapDataFuzzTest(data, size);
420     OHOS::StubSetCurrentUserFuzzTest(data, size);
421     OHOS::StubEnableHardwareCursorStatsFuzzTest(data, size);
422     OHOS::StubGetHardwareCursorStatsFuzzTest(data, size);
423     OHOS::StubAddVirtualInputDeviceFuzzTest(data, size);
424     OHOS::StubRemoveVirtualInputDeviceFuzzTest(data, size);
425     OHOS::StubTransferBinderClientServiceFuzzTest(data, size);
426 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
427     OHOS::StubGetPointerSnapshotFuzzTest(data, size);
428 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
429     OHOS::StubSkipPointerLayerFuzzTest(data, size);
430     OHOS::StubMarkEventConsumedFuzzTest(data, size);
431     OHOS::StubGetDeviceFuzzTest(data, size);
432 #ifdef OHOS_BUILD_ENABLE_ANCO
433     OHOS::StubAncoAddChannelFuzzTest(data, size);
434     OHOS::StubAncoRemoveChannelFuzzTest(data, size);
435 #endif // OHOS_BUILD_ENABLE_ANCO
436     OHOS::switchDefaultFuzzTest(data, size);
437     return 0;
438 }
439 } // namespace MMI
440 } // namespace OHOS