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 <fuzzer/FuzzedDataProvider.h>
17 #include "stubhandleallocsocketfd_fuzzer.h"
18
19 #include "mmi_service.h"
20 #include "multimodal_input_connect_stub.h"
21
22 #undef MMI_LOG_TAG
23 #define MMI_LOG_TAG "StubHandleAllocSocketFdFuzzTest"
24
25 class UDSSession;
26 using SessionPtr = std::shared_ptr<UDSSession>;
27
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 constexpr uint32_t MAX_BUNDLE_NAME_LENGTH = 127;
32 } // namespace
33 const std::u16string FORMMGR_INTERFACE_TOKEN { u"ohos.multimodalinput.IConnectManager" };
34
AddEpollFuzzTest(const uint8_t * data,size_t size)35 void AddEpollFuzzTest(const uint8_t *data, size_t size)
36 {
37 FuzzedDataProvider fdp(data, size);
38 EpollEventType type = static_cast<EpollEventType>(fdp.ConsumeIntegralInRange<uint32_t>(0, EPOLL_EVENT_END));
39 int32_t fd = fdp.ConsumeIntegral<int32_t>();
40 bool readOnly = fdp.ConsumeBool();
41 MMIService::GetInstance()->AddEpoll(type, fd, readOnly);
42 }
43
DelEpollFuzzTest(const uint8_t * data,size_t size)44 void DelEpollFuzzTest(const uint8_t *data, size_t size)
45 {
46 FuzzedDataProvider fdp(data, size);
47 EpollEventType type = static_cast<EpollEventType>(fdp.ConsumeIntegralInRange<uint32_t>(0, EPOLL_EVENT_END));
48 int32_t fd = fdp.ConsumeIntegral<int32_t>();
49
50 MMIService::GetInstance()->DelEpoll(type, fd);
51 }
52
SetMouseScrollRowsFuzzTest(const uint8_t * data,size_t size)53 void SetMouseScrollRowsFuzzTest(const uint8_t *data, size_t size)
54 {
55 FuzzedDataProvider fdp(data, size);
56 int32_t rows = fdp.ConsumeIntegral<int32_t>();
57
58 MMIService::GetInstance()->SetMouseScrollRows(rows);
59 }
60
SetMouseIconFuzzTest(const uint8_t * data,size_t size)61 void SetMouseIconFuzzTest(const uint8_t *data, size_t size)
62 {
63 FuzzedDataProvider fdp(data, size);
64 int32_t windowId = fdp.ConsumeIntegral<int32_t>();
65 CursorPixelMap cursorPixelMap;
66
67 MMIService::GetInstance()->SetMouseIcon(windowId, cursorPixelMap);
68 }
69
ReadMouseScrollRowsFuzzTest(const uint8_t * data,size_t size)70 void ReadMouseScrollRowsFuzzTest(const uint8_t *data, size_t size)
71 {
72 FuzzedDataProvider fdp(data, size);
73 int32_t rows = fdp.ConsumeIntegral<int32_t>();
74
75 MMIService::GetInstance()->ReadMouseScrollRows(rows);
76 }
77
MarkProcessedFuzzTest(const uint8_t * data,size_t size)78 void MarkProcessedFuzzTest(const uint8_t *data, size_t size)
79 {
80 FuzzedDataProvider fdp(data, size);
81 int32_t eventType = fdp.ConsumeIntegral<int32_t>();
82 int32_t eventId = fdp.ConsumeIntegral<int32_t>();
83
84 MMIService::GetInstance()->MarkProcessed(eventType, eventId);
85 }
86
OnSupportKeysFuzzTest(const uint8_t * data,size_t size)87 void OnSupportKeysFuzzTest(const uint8_t *data, size_t size)
88 {
89 FuzzedDataProvider fdp(data, size);
90 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
91 std::vector<int32_t> keys = {
92 fdp.ConsumeIntegral<int32_t>(),
93 fdp.ConsumeIntegral<int32_t>(),
94 fdp.ConsumeIntegral<int32_t>(),
95 fdp.ConsumeIntegral<int32_t>()
96 };
97 std::vector<bool> keystroke = {
98 fdp.ConsumeBool(),
99 fdp.ConsumeBool()
100 };
101
102 MMIService::GetInstance()->OnSupportKeys(deviceId, keys, keystroke);
103 }
104
OnGetDeviceIdsFuzzTest(const uint8_t * data,size_t size)105 void OnGetDeviceIdsFuzzTest(const uint8_t *data, size_t size)
106 {
107 FuzzedDataProvider fdp(data, size);
108 std::vector<int32_t> ids = {
109 fdp.ConsumeIntegral<int32_t>(),
110 fdp.ConsumeIntegral<int32_t>(),
111 fdp.ConsumeIntegral<int32_t>(),
112 fdp.ConsumeIntegral<int32_t>()
113 };
114
115 MMIService::GetInstance()->OnGetDeviceIds(ids);
116 }
117
OnGetDeviceFuzzTest(const uint8_t * data,size_t size)118 void OnGetDeviceFuzzTest(const uint8_t *data, size_t size)
119 {
120 FuzzedDataProvider fdp(data, size);
121
122 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
123 std::shared_ptr<InputDevice> inputDevice = std::make_shared<InputDevice>();
124
125 MMIService::GetInstance()->OnGetDevice(deviceId, inputDevice);
126 }
127
OnGetKeyboardTypeFuzzTest(const uint8_t * data,size_t size)128 void OnGetKeyboardTypeFuzzTest(const uint8_t *data, size_t size)
129 {
130 FuzzedDataProvider fdp(data, size);
131
132 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
133 int32_t keyboardType = fdp.ConsumeIntegral<int32_t>();
134
135 MMIService::GetInstance()->OnGetKeyboardType(deviceId, keyboardType);
136 }
137
SetKeyboardRepeatDelayFuzzTest(const uint8_t * data,size_t size)138 void SetKeyboardRepeatDelayFuzzTest(const uint8_t *data, size_t size)
139 {
140 FuzzedDataProvider fdp(data, size);
141
142 int32_t delay = fdp.ConsumeIntegral<int32_t>();
143
144 MMIService::GetInstance()->SetKeyboardRepeatDelay(delay);
145 }
146
CheckRemoveInputFuzzTest(const uint8_t * data,size_t size)147 void CheckRemoveInputFuzzTest(const uint8_t *data, size_t size)
148 {
149 FuzzedDataProvider fdp(data, size);
150
151 int32_t pid = fdp.ConsumeIntegral<int32_t>();
152 InputHandlerType handlerType =
153 static_cast<InputHandlerType>(fdp.ConsumeIntegralInRange<uint32_t>(0, MONITOR));
154 HandleEventType eventType = fdp.ConsumeIntegral<int32_t>();
155 int32_t priority = fdp.ConsumeIntegral<int32_t>();
156 uint32_t deviceTags = fdp.ConsumeIntegral<uint32_t>();
157
158 MMIService::GetInstance()->CheckRemoveInput(pid, handlerType, eventType, priority, deviceTags);
159 }
160
RemoveInputHandlerFuzzTest(const uint8_t * data,size_t size)161 void RemoveInputHandlerFuzzTest(const uint8_t *data, size_t size)
162 {
163 FuzzedDataProvider fdp(data, size);
164
165 int32_t handlerType = fdp.ConsumeIntegral<int32_t>();
166 uint32_t eventType = fdp.ConsumeIntegral<uint32_t>();
167 int32_t priority = fdp.ConsumeIntegral<int32_t>();
168 uint32_t deviceTags = fdp.ConsumeIntegral<uint32_t>();
169
170 MMIService::GetInstance()->RemoveInputHandler(handlerType, eventType, priority, deviceTags);
171 }
172
MarkEventConsumedFuzzTest(const uint8_t * data,size_t size)173 void MarkEventConsumedFuzzTest(const uint8_t *data, size_t size)
174 {
175 FuzzedDataProvider fdp(data, size);
176
177 int32_t eventId = fdp.ConsumeIntegral<int32_t>();
178
179 MMIService::GetInstance()->MarkEventConsumed(eventId);
180 }
181
MoveMouseEventFuzzTest(const uint8_t * data,size_t size)182 void MoveMouseEventFuzzTest(const uint8_t *data, size_t size)
183 {
184 FuzzedDataProvider fdp(data, size);
185
186 int32_t offsetX = fdp.ConsumeIntegral<int32_t>();
187 int32_t offsetY = fdp.ConsumeIntegral<int32_t>();
188
189 MMIService::GetInstance()->MoveMouseEvent(offsetX, offsetY);
190 }
191
InjectPointerEventFuzzTest(const uint8_t * data,size_t size)192 void InjectPointerEventFuzzTest(const uint8_t *data, size_t size)
193 {
194 FuzzedDataProvider fdp(data, size);
195
196 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
197 pointerEvent->pointerAction_ = fdp.ConsumeIntegral<int32_t>();
198 pointerEvent->originPointerAction_ = fdp.ConsumeIntegral<int32_t>();
199 pointerEvent->buttonId_ = fdp.ConsumeIntegral<int32_t>();
200 pointerEvent->fingerCount_ = fdp.ConsumeIntegral<int32_t>();
201 pointerEvent->pullId_ = fdp.ConsumeIntegral<int32_t>();
202 bool isNativeInject = fdp.ConsumeBool();
203 int32_t useCoordinate = fdp.ConsumeIntegral<int32_t>();
204
205 MMIService::GetInstance()->InjectPointerEvent(*pointerEvent.get(), isNativeInject, useCoordinate);
206 }
207
OnAddSystemAbilityFuzzTest(const uint8_t * data,size_t size)208 void OnAddSystemAbilityFuzzTest(const uint8_t *data, size_t size)
209 {
210 FuzzedDataProvider fdp(data, size);
211
212 int32_t systemAbilityId = fdp.ConsumeIntegral<int32_t>();
213 std::string deviceId = fdp.ConsumeBytesAsString(10); // test value
214
215 MMIService::GetInstance()->OnAddSystemAbility(systemAbilityId, deviceId);
216 }
217
SubscribeKeyEventFuzzTest(const uint8_t * data,size_t size)218 void SubscribeKeyEventFuzzTest(const uint8_t *data, size_t size)
219 {
220 FuzzedDataProvider fdp(data, size);
221
222 KeyOption keyOption;
223 keyOption.finalKey_ = fdp.ConsumeIntegral<int32_t>();
224 keyOption.isFinalKeyDown_ = fdp.ConsumeIntegral<int32_t>();
225 keyOption.finalKeyDownDuration_ = fdp.ConsumeBool();
226 keyOption.finalKeyUpDelay_ = fdp.ConsumeIntegral<int32_t>();
227 keyOption.isRepeat_ = fdp.ConsumeBool();
228 keyOption.priority_ = SubscribePriority::PRIORITY_0;
229
230 int32_t subscribeId = fdp.ConsumeIntegral<int32_t>();
231
232 MMIService::GetInstance()->SubscribeKeyEvent(subscribeId, keyOption);
233 }
234
UnsubscribeKeyEventFuzzTest(const uint8_t * data,size_t size)235 void UnsubscribeKeyEventFuzzTest(const uint8_t *data, size_t size)
236 {
237 FuzzedDataProvider fdp(data, size);
238
239 int32_t subscribeId = fdp.ConsumeIntegral<int32_t>();
240
241 MMIService::GetInstance()->UnsubscribeKeyEvent(subscribeId);
242 }
243
SubscribeSwitchEventFuzzTest(const uint8_t * data,size_t size)244 void SubscribeSwitchEventFuzzTest(const uint8_t *data, size_t size)
245 {
246 FuzzedDataProvider fdp(data, size);
247
248 int32_t subscribeId = fdp.ConsumeIntegral<int32_t>();
249 int32_t switchType = fdp.ConsumeIntegral<int32_t>();
250
251 MMIService::GetInstance()->SubscribeSwitchEvent(subscribeId, switchType);
252 }
253
SetDisplayBindFuzzTest(const uint8_t * data,size_t size)254 void SetDisplayBindFuzzTest(const uint8_t *data, size_t size)
255 {
256 FuzzedDataProvider fdp(data, size);
257
258 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
259 int32_t displayId = fdp.ConsumeIntegral<int32_t>();
260 std::string msg = fdp.ConsumeBytesAsString(10); // test value
261
262 MMIService::GetInstance()->SetDisplayBind(deviceId, displayId, msg);
263 }
264
SetFunctionKeyStateFuzzTest(const uint8_t * data,size_t size)265 void SetFunctionKeyStateFuzzTest(const uint8_t *data, size_t size)
266 {
267 FuzzedDataProvider fdp(data, size);
268
269 int32_t funcKey = fdp.ConsumeIntegral<int32_t>();
270 bool enable = fdp.ConsumeBool();
271
272 MMIService::GetInstance()->SetFunctionKeyState(funcKey, enable);
273 }
274
SetPointerLocationFuzzTest(const uint8_t * data,size_t size)275 void SetPointerLocationFuzzTest(const uint8_t *data, size_t size)
276 {
277 FuzzedDataProvider fdp(data, size);
278
279 int32_t x = fdp.ConsumeIntegral<int32_t>();
280 int32_t y = fdp.ConsumeIntegral<int32_t>();
281 int32_t displayId = fdp.ConsumeIntegral<int32_t>();
282
283 MMIService::GetInstance()->SetPointerLocation(x, y, displayId);
284 }
285
DumpFuzzTest(const uint8_t * data,size_t size)286 void DumpFuzzTest(const uint8_t *data, size_t size)
287 {
288 FuzzedDataProvider fdp(data, size);
289
290 std::vector<std::u16string> args = {
291 u"datatest1",
292 u"datatest2",
293 u"datatest3",
294 u"datatest4"
295 };
296 int32_t fd = fdp.ConsumeIntegral<int32_t>();
297
298 MMIService::GetInstance()->Dump(fd, args);
299 }
300
OnGetWindowPidFuzzTest(const uint8_t * data,size_t size)301 void OnGetWindowPidFuzzTest(const uint8_t *data, size_t size)
302 {
303 FuzzedDataProvider fdp(data, size);
304
305 int32_t windowId = fdp.ConsumeIntegral<int32_t>();
306 int32_t ywindowPid = fdp.ConsumeIntegral<int32_t>();
307
308 MMIService::GetInstance()->OnGetWindowPid(windowId, ywindowPid);
309 }
310
GetWindowPidFuzzTest(const uint8_t * data,size_t size)311 void GetWindowPidFuzzTest(const uint8_t *data, size_t size)
312 {
313 FuzzedDataProvider fdp(data, size);
314
315 int32_t windowId = fdp.ConsumeIntegral<int32_t>();
316 int32_t ywindowPid = fdp.ConsumeIntegral<int32_t>();
317
318 MMIService::GetInstance()->GetWindowPid(windowId, ywindowPid);
319 }
320
SetKeyDownDurationFuzzTest(const uint8_t * data,size_t size)321 void SetKeyDownDurationFuzzTest(const uint8_t *data, size_t size)
322 {
323 FuzzedDataProvider fdp(data, size);
324
325 std::string businessId = fdp.ConsumeBytesAsString(10); // test value
326 int32_t delay = fdp.ConsumeIntegral<int32_t>();
327
328 MMIService::GetInstance()->SetKeyDownDuration(businessId, delay);
329 }
330
ReadTouchpadScrollSwichFuzzTest(const uint8_t * data,size_t size)331 void ReadTouchpadScrollSwichFuzzTest(const uint8_t *data, size_t size)
332 {
333 FuzzedDataProvider fdp(data, size);
334
335 bool switchFlag = fdp.ConsumeBool();
336
337 MMIService::GetInstance()->ReadTouchpadScrollSwich(switchFlag);
338 }
339
ReadTouchpadScrollDirectionFuzzTest(const uint8_t * data,size_t size)340 void ReadTouchpadScrollDirectionFuzzTest(const uint8_t *data, size_t size)
341 {
342 FuzzedDataProvider fdp(data, size);
343
344 bool switchFlag = fdp.ConsumeBool();
345
346 MMIService::GetInstance()->ReadTouchpadScrollDirection(switchFlag);
347 }
348
ReadTouchpadTapSwitchFuzzTest(const uint8_t * data,size_t size)349 void ReadTouchpadTapSwitchFuzzTest(const uint8_t *data, size_t size)
350 {
351 FuzzedDataProvider fdp(data, size);
352
353 bool switchFlag = fdp.ConsumeBool();
354
355 MMIService::GetInstance()->ReadTouchpadTapSwitch(switchFlag);
356 }
357
ReadTouchpadPointerSpeedFuzzTest(const uint8_t * data,size_t size)358 void ReadTouchpadPointerSpeedFuzzTest(const uint8_t *data, size_t size)
359 {
360 FuzzedDataProvider fdp(data, size);
361
362 int32_t speed = fdp.ConsumeIntegral<int32_t>();
363
364 MMIService::GetInstance()->ReadTouchpadPointerSpeed(speed);
365 }
366
ReadTouchpadPinchSwitchFuzzTest(const uint8_t * data,size_t size)367 void ReadTouchpadPinchSwitchFuzzTest(const uint8_t *data, size_t size)
368 {
369 FuzzedDataProvider fdp(data, size);
370
371 bool switchFlag = fdp.ConsumeBool();
372
373 MMIService::GetInstance()->ReadTouchpadPinchSwitch(switchFlag);
374 }
375
ReadTouchpadSwipeSwitchFuzzTest(const uint8_t * data,size_t size)376 void ReadTouchpadSwipeSwitchFuzzTest(const uint8_t *data, size_t size)
377 {
378 FuzzedDataProvider fdp(data, size);
379
380 bool switchFlag = fdp.ConsumeBool();
381
382 MMIService::GetInstance()->ReadTouchpadSwipeSwitch(switchFlag);
383 }
384
ReadTouchpadRightMenuTypeFuzzTest(const uint8_t * data,size_t size)385 void ReadTouchpadRightMenuTypeFuzzTest(const uint8_t *data, size_t size)
386 {
387 FuzzedDataProvider fdp(data, size);
388
389 int32_t type = fdp.ConsumeIntegral<int32_t>();
390
391 MMIService::GetInstance()->ReadTouchpadRightMenuType(type);
392 }
393
ReadTouchpadRotateSwitchFuzzTest(const uint8_t * data,size_t size)394 void ReadTouchpadRotateSwitchFuzzTest(const uint8_t *data, size_t size)
395 {
396 FuzzedDataProvider fdp(data, size);
397
398 bool rotateSwitch = fdp.ConsumeBool();
399
400 MMIService::GetInstance()->ReadTouchpadRotateSwitch(rotateSwitch);
401 }
402
SetTouchpadScrollSwitchFuzzTest(const uint8_t * data,size_t size)403 void SetTouchpadScrollSwitchFuzzTest(const uint8_t *data, size_t size)
404 {
405 FuzzedDataProvider fdp(data, size);
406
407 bool switchFlag = fdp.ConsumeBool();
408
409 MMIService::GetInstance()->SetTouchpadScrollSwitch(switchFlag);
410 }
411
GetTouchpadScrollSwitchFuzzTest(const uint8_t * data,size_t size)412 void GetTouchpadScrollSwitchFuzzTest(const uint8_t *data, size_t size)
413 {
414 FuzzedDataProvider fdp(data, size);
415
416 bool switchFlag = fdp.ConsumeBool();
417
418 MMIService::GetInstance()->GetTouchpadScrollSwitch(switchFlag);
419 }
420
SetTouchpadScrollDirectionFuzzTest(const uint8_t * data,size_t size)421 void SetTouchpadScrollDirectionFuzzTest(const uint8_t *data, size_t size)
422 {
423 FuzzedDataProvider fdp(data, size);
424
425 bool state = fdp.ConsumeBool();
426
427 MMIService::GetInstance()->SetTouchpadScrollDirection(state);
428 }
429
GetTouchpadScrollDirectionFuzzTest(const uint8_t * data,size_t size)430 void GetTouchpadScrollDirectionFuzzTest(const uint8_t *data, size_t size)
431 {
432 FuzzedDataProvider fdp(data, size);
433
434 bool switchFlag = fdp.ConsumeBool();
435
436 MMIService::GetInstance()->GetTouchpadScrollDirection(switchFlag);
437 }
438
SetTouchpadTapSwitchFuzzTest(const uint8_t * data,size_t size)439 void SetTouchpadTapSwitchFuzzTest(const uint8_t *data, size_t size)
440 {
441 FuzzedDataProvider fdp(data, size);
442
443 bool switchFlag = fdp.ConsumeBool();
444
445 MMIService::GetInstance()->SetTouchpadTapSwitch(switchFlag);
446 }
447
GetTouchpadTapSwitchFuzzTest(const uint8_t * data,size_t size)448 void GetTouchpadTapSwitchFuzzTest(const uint8_t *data, size_t size)
449 {
450 FuzzedDataProvider fdp(data, size);
451
452 bool switchFlag = fdp.ConsumeBool();
453
454 MMIService::GetInstance()->GetTouchpadTapSwitch(switchFlag);
455 }
456
SetTouchpadPointerSpeedFuzzTest(const uint8_t * data,size_t size)457 void SetTouchpadPointerSpeedFuzzTest(const uint8_t *data, size_t size)
458 {
459 FuzzedDataProvider fdp(data, size);
460
461 int32_t speed = fdp.ConsumeIntegral<int32_t>();
462
463 MMIService::GetInstance()->SetTouchpadPointerSpeed(speed);
464 }
465
GetTouchpadPointerSpeedFuzzTest(const uint8_t * data,size_t size)466 void GetTouchpadPointerSpeedFuzzTest(const uint8_t *data, size_t size)
467 {
468 FuzzedDataProvider fdp(data, size);
469
470 int32_t speed = fdp.ConsumeIntegral<int32_t>();
471
472 MMIService::GetInstance()->GetTouchpadPointerSpeed(speed);
473 }
474
SetTouchpadPinchSwitchFuzzTest(const uint8_t * data,size_t size)475 void SetTouchpadPinchSwitchFuzzTest(const uint8_t *data, size_t size)
476 {
477 FuzzedDataProvider fdp(data, size);
478
479 bool switchFlag = fdp.ConsumeBool();
480
481 MMIService::GetInstance()->SetTouchpadPinchSwitch(switchFlag);
482 }
483
GetTouchpadPinchSwitchFuzzTest(const uint8_t * data,size_t size)484 void GetTouchpadPinchSwitchFuzzTest(const uint8_t *data, size_t size)
485 {
486 FuzzedDataProvider fdp(data, size);
487
488 bool switchFlag = fdp.ConsumeBool();
489
490 MMIService::GetInstance()->GetTouchpadPinchSwitch(switchFlag);
491 }
492
SetTouchpadSwipeSwitchFuzzTest(const uint8_t * data,size_t size)493 void SetTouchpadSwipeSwitchFuzzTest(const uint8_t *data, size_t size)
494 {
495 FuzzedDataProvider fdp(data, size);
496
497 bool switchFlag = fdp.ConsumeBool();
498
499 MMIService::GetInstance()->SetTouchpadSwipeSwitch(switchFlag);
500 }
501
GetTouchpadSwipeSwitchFuzzTest(const uint8_t * data,size_t size)502 void GetTouchpadSwipeSwitchFuzzTest(const uint8_t *data, size_t size)
503 {
504 FuzzedDataProvider fdp(data, size);
505
506 bool switchFlag = fdp.ConsumeBool();
507
508 MMIService::GetInstance()->GetTouchpadSwipeSwitch(switchFlag);
509 }
510
SetTouchpadRightClickTypeFuzzTest(const uint8_t * data,size_t size)511 void SetTouchpadRightClickTypeFuzzTest(const uint8_t *data, size_t size)
512 {
513 FuzzedDataProvider fdp(data, size);
514
515 int32_t type = fdp.ConsumeIntegral<int32_t>();
516
517 MMIService::GetInstance()->SetTouchpadRightClickType(type);
518 }
519
SetTouchpadRotateSwitchFuzzTest(const uint8_t * data,size_t size)520 void SetTouchpadRotateSwitchFuzzTest(const uint8_t *data, size_t size)
521 {
522 FuzzedDataProvider fdp(data, size);
523
524 bool rotateSwitch = fdp.ConsumeBool();
525
526 MMIService::GetInstance()->SetTouchpadRotateSwitch(rotateSwitch);
527 }
528
GetTouchpadRotateSwitchFuzzTest(const uint8_t * data,size_t size)529 void GetTouchpadRotateSwitchFuzzTest(const uint8_t *data, size_t size)
530 {
531 FuzzedDataProvider fdp(data, size);
532
533 bool rotateSwitch = fdp.ConsumeBool();
534
535 MMIService::GetInstance()->GetTouchpadRotateSwitch(rotateSwitch);
536 }
537
GetKeyStateFuzzTest(const uint8_t * data,size_t size)538 void GetKeyStateFuzzTest(const uint8_t *data, size_t size)
539 {
540 FuzzedDataProvider fdp(data, size);
541
542 std::vector<int32_t> pressedKey = {
543 fdp.ConsumeIntegral<int32_t>(),
544 fdp.ConsumeIntegral<int32_t>(),
545 fdp.ConsumeIntegral<int32_t>(),
546 fdp.ConsumeIntegral<int32_t>()
547 };
548
549 std::unordered_map<int32_t, int32_t> specialkeysState = {
550 {fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()},
551 {fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()},
552 {fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()},
553 {fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()},
554 };
555
556 MMIService::GetInstance()->GetKeyState(pressedKey, specialkeysState);
557 }
558
AuthorizeFuzzTest(const uint8_t * data,size_t size)559 void AuthorizeFuzzTest(const uint8_t *data, size_t size)
560 {
561 FuzzedDataProvider fdp(data, size);
562
563 bool isAuthorize = fdp.ConsumeBool();
564
565 MMIService::GetInstance()->Authorize(isAuthorize);
566 }
567
OnAuthorizeFuzzTest(const uint8_t * data,size_t size)568 void OnAuthorizeFuzzTest(const uint8_t *data, size_t size)
569 {
570 FuzzedDataProvider fdp(data, size);
571
572 bool isAuthorize = fdp.ConsumeBool();
573
574 MMIService::GetInstance()->OnAuthorize(isAuthorize);
575 }
576
TransmitInfraredFuzzTest(const uint8_t * data,size_t size)577 void TransmitInfraredFuzzTest(const uint8_t *data, size_t size)
578 {
579 FuzzedDataProvider fdp(data, size);
580
581 int64_t number = fdp.ConsumeIntegral<int64_t>();
582 std::vector<int64_t> pattern = {
583 fdp.ConsumeIntegral<int64_t>(),
584 fdp.ConsumeIntegral<int64_t>(),
585 fdp.ConsumeIntegral<int64_t>(),
586 fdp.ConsumeIntegral<int64_t>()
587 };
588
589 MMIService::GetInstance()->TransmitInfrared(number, pattern);
590 }
591
SetPixelMapDataFuzzTest(const uint8_t * data,size_t size)592 void SetPixelMapDataFuzzTest(const uint8_t *data, size_t size)
593 {
594 FuzzedDataProvider fdp(data, size);
595
596 int32_t infoId = fdp.ConsumeIntegral<int32_t>();
597 CursorPixelMap cursorPixelMap;
598
599 MMIService::GetInstance()->SetPixelMapData(infoId, cursorPixelMap);
600 }
601
SetCurrentUserFuzzTest(const uint8_t * data,size_t size)602 void SetCurrentUserFuzzTest(const uint8_t *data, size_t size)
603 {
604 FuzzedDataProvider fdp(data, size);
605
606 int32_t userId = fdp.ConsumeIntegral<int32_t>();
607
608 MMIService::GetInstance()->SetCurrentUser(userId);
609 }
610
AddVirtualInputDeviceFuzzTest(const uint8_t * data,size_t size)611 void AddVirtualInputDeviceFuzzTest(const uint8_t *data, size_t size)
612 {
613 FuzzedDataProvider fdp(data, size);
614
615 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
616 InputDevice device;
617 device.id_ = fdp.ConsumeIntegral<int32_t>();
618 device.type_ = fdp.ConsumeIntegral<int32_t>();
619 device.bus_ = fdp.ConsumeIntegral<int32_t>();
620 device.version_ = fdp.ConsumeIntegral<int32_t>();
621 device.product_ = fdp.ConsumeIntegral<int32_t>();
622 device.vendor_ = fdp.ConsumeIntegral<int32_t>();
623 device.phys_ = fdp.ConsumeRandomLengthString(MAX_BUNDLE_NAME_LENGTH);
624 device.uniq_ = fdp.ConsumeRandomLengthString(MAX_BUNDLE_NAME_LENGTH);
625 MMIService::GetInstance()->AddVirtualInputDevice(device, deviceId);
626 }
627
RemoveVirtualInputDeviceFuzzTest(const uint8_t * data,size_t size)628 void RemoveVirtualInputDeviceFuzzTest(const uint8_t *data, size_t size)
629 {
630 FuzzedDataProvider fdp(data, size);
631
632 int32_t deviceId = fdp.ConsumeIntegral<int32_t>();
633
634 MMIService::GetInstance()->RemoveVirtualInputDevice(deviceId);
635 }
636
EnableHardwareCursorStatsFuzzTest(const uint8_t * data,size_t size)637 void EnableHardwareCursorStatsFuzzTest(const uint8_t *data, size_t size)
638 {
639 FuzzedDataProvider fdp(data, size);
640
641 bool enable = fdp.ConsumeBool();
642
643 MMIService::GetInstance()->EnableHardwareCursorStats(enable);
644 }
645
GetHardwareCursorStatsFuzzTest(const uint8_t * data,size_t size)646 void GetHardwareCursorStatsFuzzTest(const uint8_t *data, size_t size)
647 {
648 FuzzedDataProvider fdp(data, size);
649
650 uint32_t frameCount = fdp.ConsumeIntegral<uint32_t>();
651 uint32_t vsyncCount = fdp.ConsumeIntegral<uint32_t>();
652
653 MMIService::GetInstance()->GetHardwareCursorStats(frameCount, vsyncCount);
654 }
655
MmiServiceFuzzFirstGroup(const uint8_t * data,size_t size)656 void MmiServiceFuzzFirstGroup(const uint8_t *data, size_t size)
657 {
658 AddEpollFuzzTest(data, size);
659 DelEpollFuzzTest(data, size);
660 SetMouseScrollRowsFuzzTest(data, size);
661 SetMouseIconFuzzTest(data, size);
662 ReadMouseScrollRowsFuzzTest(data, size);
663 MarkProcessedFuzzTest(data, size);
664 OnSupportKeysFuzzTest(data, size);
665 OnGetDeviceIdsFuzzTest(data, size);
666 OnGetDeviceFuzzTest(data, size);
667 OnGetKeyboardTypeFuzzTest(data, size);
668 SetKeyboardRepeatDelayFuzzTest(data, size);
669 CheckRemoveInputFuzzTest(data, size);
670 RemoveInputHandlerFuzzTest(data, size);
671 MarkEventConsumedFuzzTest(data, size);
672 MoveMouseEventFuzzTest(data, size);
673 InjectPointerEventFuzzTest(data, size);
674 OnAddSystemAbilityFuzzTest(data, size);
675 SubscribeKeyEventFuzzTest(data, size);
676 UnsubscribeKeyEventFuzzTest(data, size);
677 SubscribeSwitchEventFuzzTest(data, size);
678 SetDisplayBindFuzzTest(data, size);
679 SetFunctionKeyStateFuzzTest(data, size);
680 SetPointerLocationFuzzTest(data, size);
681 DumpFuzzTest(data, size);
682 OnGetWindowPidFuzzTest(data, size);
683 GetWindowPidFuzzTest(data, size);
684 SetKeyDownDurationFuzzTest(data, size);
685 ReadTouchpadScrollSwichFuzzTest(data, size);
686 ReadTouchpadScrollDirectionFuzzTest(data, size);
687 ReadTouchpadTapSwitchFuzzTest(data, size);
688 }
689
MmiServiceFuzzSecondGroup(const uint8_t * data,size_t size)690 void MmiServiceFuzzSecondGroup(const uint8_t *data, size_t size)
691 {
692 ReadTouchpadPointerSpeedFuzzTest(data, size);
693 ReadTouchpadPinchSwitchFuzzTest(data, size);
694 ReadTouchpadSwipeSwitchFuzzTest(data, size);
695 ReadTouchpadRightMenuTypeFuzzTest(data, size);
696 ReadTouchpadRotateSwitchFuzzTest(data, size);
697 SetTouchpadScrollSwitchFuzzTest(data, size);
698 GetTouchpadScrollSwitchFuzzTest(data, size);
699 SetTouchpadScrollDirectionFuzzTest(data, size);
700 GetTouchpadScrollDirectionFuzzTest(data, size);
701 SetTouchpadTapSwitchFuzzTest(data, size);
702 GetTouchpadTapSwitchFuzzTest(data, size);
703 SetTouchpadPointerSpeedFuzzTest(data, size);
704 GetTouchpadPointerSpeedFuzzTest(data, size);
705 SetTouchpadPinchSwitchFuzzTest(data, size);
706 GetTouchpadPinchSwitchFuzzTest(data, size);
707 SetTouchpadSwipeSwitchFuzzTest(data, size);
708 GetTouchpadSwipeSwitchFuzzTest(data, size);
709 SetTouchpadRightClickTypeFuzzTest(data, size);
710 SetTouchpadRotateSwitchFuzzTest(data, size);
711 GetTouchpadRotateSwitchFuzzTest(data, size);
712 GetKeyStateFuzzTest(data, size);
713 AuthorizeFuzzTest(data, size);
714 OnAuthorizeFuzzTest(data, size);
715 TransmitInfraredFuzzTest(data, size);
716 SetPixelMapDataFuzzTest(data, size);
717 SetCurrentUserFuzzTest(data, size);
718 AddVirtualInputDeviceFuzzTest(data, size);
719 RemoveVirtualInputDeviceFuzzTest(data, size);
720 EnableHardwareCursorStatsFuzzTest(data, size);
721 GetHardwareCursorStatsFuzzTest(data, size);
722 }
723
StubHandleAllocSocketFdFuzzTest(const uint8_t * data,size_t size)724 bool StubHandleAllocSocketFdFuzzTest(const uint8_t *data, size_t size)
725 {
726 MessageParcel datas;
727 if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN) ||
728 !datas.WriteBuffer(data, size) || !datas.RewindRead(0)) {
729 return false;
730 }
731 MessageParcel reply;
732 MessageOption option;
733
734 MMIService::GetInstance()->InitLibinputService();
735 MMIService::GetInstance()->InitDelegateTasks();
736 MMIService::GetInstance()->AddAppDebugListener();
737 MMIService::GetInstance()->AddReloadDeviceTimer();
738 MMIService::GetInstance()->CancelInjection();
739 MMIService::GetInstance()->OnCancelInjection();
740 MmiServiceFuzzFirstGroup(data, size);
741 MmiServiceFuzzSecondGroup(data, size);
742
743 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
744 MMIService::GetInstance()->GetPointerSnapshot(*pixelMapPtr);
745 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
746 MMIService::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
747 MMIService::GetInstance()->OnRemoteRequest(
748 static_cast<uint32_t>(IMultimodalInputConnectIpcCode::COMMAND_ALLOC_SOCKET_FD), datas, reply, option);
749 return true;
750 }
751 } // MMI
752 } // OHOS
753
754 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)755 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
756 {
757 /* Run your code on data */
758 if (data == nullptr) {
759 return 0;
760 }
761
762 OHOS::MMI::StubHandleAllocSocketFdFuzzTest(data, size);
763 return 0;
764 }
765