1 /*
2 * Copyright (c) 2022-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 "socket_exec_fuzzer.h"
17
18 #include "local_socket_exec.h"
19 #include "netstack_log.h"
20 #include "securec.h"
21 #include "socket_exec.h"
22 #include "socket_exec_common.h"
23 #include <cstdint>
24
25 namespace OHOS {
26 namespace NetStack {
27 namespace Socket {
28 namespace {
29 const uint8_t *g_netstackFuzzData = nullptr;
30 size_t g_netstackFuzzSize = 0;
31 size_t g_netstackFuzzPos = 0;
GetData()32 template <class T> T GetData()
33 {
34 T object{};
35 size_t objectSize = sizeof(object);
36 if (g_netstackFuzzData == nullptr || objectSize > g_netstackFuzzSize - g_netstackFuzzPos) {
37 return object;
38 }
39 errno_t ret = memcpy_s(&object, objectSize, g_netstackFuzzData + g_netstackFuzzPos, objectSize);
40 if (ret != EOK) {
41 return object;
42 }
43 g_netstackFuzzPos += objectSize;
44 return object;
45 }
46
SetGlobalFuzzData(const uint8_t * data,size_t size)47 inline void SetGlobalFuzzData(const uint8_t *data, size_t size)
48 {
49 g_netstackFuzzData = data;
50 g_netstackFuzzSize = size;
51 g_netstackFuzzPos = 0;
52 }
53 } // namespace
54
MakeUdpSocketFuzzTest(const uint8_t * data,size_t size)55 void MakeUdpSocketFuzzTest(const uint8_t *data, size_t size)
56 {
57 if ((data == nullptr) || (size == 0)) {
58 return;
59 }
60 SetGlobalFuzzData(data, size);
61 sa_family_t family(GetData<sa_family_t>());
62 if (family == AF_INET || family == AF_INET6) {
63 return;
64 }
65 int sockfd = ExecCommonUtils::MakeUdpSocket(family);
66 close(sockfd);
67 }
68
MakeTcpSocketFuzzTest(const uint8_t * data,size_t size)69 void MakeTcpSocketFuzzTest(const uint8_t *data, size_t size)
70 {
71 if ((data == nullptr) || (size == 0)) {
72 return;
73 }
74 SetGlobalFuzzData(data, size);
75 sa_family_t family(GetData<sa_family_t>());
76 if (family == AF_INET || family == AF_INET6) {
77 return;
78 }
79 int sockfd = ExecCommonUtils::MakeTcpSocket(family);
80 close(sockfd);
81 }
82
ExecUdpBindFuzzTest(const uint8_t * data,size_t size)83 void ExecUdpBindFuzzTest(const uint8_t *data, size_t size)
84 {
85 if ((data == nullptr) || (size == 0)) {
86 return;
87 }
88 SetGlobalFuzzData(data, size);
89 napi_env env(GetData<napi_env>());
90 EventManager eventManager;
91 BindContext context(env, &eventManager);
92
93 SocketExec::ExecUdpBind(&context);
94 }
95
ExecTcpBindFuzzTest(const uint8_t * data,size_t size)96 void ExecTcpBindFuzzTest(const uint8_t *data, size_t size)
97 {
98 if ((data == nullptr) || (size == 0)) {
99 return;
100 }
101 SetGlobalFuzzData(data, size);
102 napi_env env(GetData<napi_env>());
103 EventManager eventManager;
104 BindContext context(env, &eventManager);
105
106 SocketExec::ExecTcpBind(&context);
107 }
108
ExecUdpSendFuzzTest(const uint8_t * data,size_t size)109 void ExecUdpSendFuzzTest(const uint8_t *data, size_t size)
110 {
111 if ((data == nullptr) || (size == 0)) {
112 return;
113 }
114 SetGlobalFuzzData(data, size);
115 napi_env env(GetData<napi_env>());
116 EventManager eventManager;
117 UdpSendContext context(env, &eventManager);
118
119 SocketExec::ExecUdpSend(&context);
120 }
121
ExecTcpSendFuzzTest(const uint8_t * data,size_t size)122 void ExecTcpSendFuzzTest(const uint8_t *data, size_t size)
123 {
124 if ((data == nullptr) || (size == 0)) {
125 return;
126 }
127 SetGlobalFuzzData(data, size);
128 napi_env env(GetData<napi_env>());
129 EventManager eventManager;
130 TcpSendContext context(env, &eventManager);
131
132 SocketExec::ExecTcpSend(&context);
133 }
134
ExecConnectFuzzTest(const uint8_t * data,size_t size)135 void ExecConnectFuzzTest(const uint8_t *data, size_t size)
136 {
137 if ((data == nullptr) || (size == 0)) {
138 return;
139 }
140 SetGlobalFuzzData(data, size);
141 napi_env env(GetData<napi_env>());
142 EventManager eventManager;
143 ConnectContext context(env, &eventManager);
144
145 SocketExec::ExecConnect(&context);
146 }
147
ExecCloseFuzzTest(const uint8_t * data,size_t size)148 void ExecCloseFuzzTest(const uint8_t *data, size_t size)
149 {
150 if ((data == nullptr) || (size == 0)) {
151 return;
152 }
153 SetGlobalFuzzData(data, size);
154 napi_env env(GetData<napi_env>());
155 EventManager eventManager;
156 CloseContext context(env, &eventManager);
157
158 SocketExec::ExecClose(&context);
159 }
160
ExecGetStateFuzzTest(const uint8_t * data,size_t size)161 void ExecGetStateFuzzTest(const uint8_t *data, size_t size)
162 {
163 if ((data == nullptr) || (size == 0)) {
164 return;
165 }
166 SetGlobalFuzzData(data, size);
167 napi_env env(GetData<napi_env>());
168 EventManager eventManager;
169 GetStateContext context(env, &eventManager);
170
171 SocketExec::ExecGetState(&context);
172 }
173
ExecGetRemoteAddressFuzzTest(const uint8_t * data,size_t size)174 void ExecGetRemoteAddressFuzzTest(const uint8_t *data, size_t size)
175 {
176 if ((data == nullptr) || (size == 0)) {
177 return;
178 }
179 SetGlobalFuzzData(data, size);
180 napi_env env(GetData<napi_env>());
181 EventManager eventManager;
182 GetRemoteAddressContext context(env, &eventManager);
183
184 SocketExec::ExecGetRemoteAddress(&context);
185 }
186
ExecTcpSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)187 void ExecTcpSetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
188 {
189 if ((data == nullptr) || (size == 0)) {
190 return;
191 }
192 SetGlobalFuzzData(data, size);
193 napi_env env(GetData<napi_env>());
194 EventManager eventManager;
195 TcpSetExtraOptionsContext context(env, &eventManager);
196
197 SocketExec::ExecTcpSetExtraOptions(&context);
198 }
199
ExecUdpSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)200 void ExecUdpSetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
201 {
202 if ((data == nullptr) || (size == 0)) {
203 return;
204 }
205 SetGlobalFuzzData(data, size);
206 napi_env env(GetData<napi_env>());
207 EventManager eventManager;
208 UdpSetExtraOptionsContext context(env, &eventManager);
209
210 SocketExec::ExecUdpSetExtraOptions(&context);
211 }
212
ExecTcpServerListenFuzzTest(const uint8_t * data,size_t size)213 void ExecTcpServerListenFuzzTest(const uint8_t *data, size_t size)
214 {
215 if ((data == nullptr) || (size == 0)) {
216 return;
217 }
218 SetGlobalFuzzData(data, size);
219 napi_env env(GetData<napi_env>());
220 EventManager eventManager;
221 TcpServerListenContext context(env, &eventManager);
222
223 SocketExec::ExecTcpServerListen(&context);
224 }
225
ExecTcpServerSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)226 void ExecTcpServerSetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
227 {
228 if ((data == nullptr) || (size == 0)) {
229 return;
230 }
231 SetGlobalFuzzData(data, size);
232 napi_env env(GetData<napi_env>());
233 EventManager eventManager;
234 TcpServerSetExtraOptionsContext context(env, &eventManager);
235
236 SocketExec::ExecTcpServerSetExtraOptions(&context);
237 }
238
ExecTcpServerGetStateFuzzTest(const uint8_t * data,size_t size)239 void ExecTcpServerGetStateFuzzTest(const uint8_t *data, size_t size)
240 {
241 if ((data == nullptr) || (size == 0)) {
242 return;
243 }
244 SetGlobalFuzzData(data, size);
245 napi_env env(GetData<napi_env>());
246 EventManager eventManager;
247 TcpServerGetStateContext context(env, &eventManager);
248
249 SocketExec::ExecTcpServerGetState(&context);
250 }
251
ExecTcpConnectionSendFuzzTest(const uint8_t * data,size_t size)252 void ExecTcpConnectionSendFuzzTest(const uint8_t *data, size_t size)
253 {
254 if ((data == nullptr) || (size == 0)) {
255 return;
256 }
257 SetGlobalFuzzData(data, size);
258 napi_env env(GetData<napi_env>());
259 EventManager eventManager;
260 TcpServerSendContext context(env, &eventManager);
261
262 SocketExec::ExecTcpConnectionSend(&context);
263 }
264
ExecTcpConnectionGetRemoteAddressFuzzTest(const uint8_t * data,size_t size)265 void ExecTcpConnectionGetRemoteAddressFuzzTest(const uint8_t *data, size_t size)
266 {
267 if ((data == nullptr) || (size == 0)) {
268 return;
269 }
270 SetGlobalFuzzData(data, size);
271 napi_env env(GetData<napi_env>());
272 EventManager eventManager;
273 TcpServerGetRemoteAddressContext context(env, &eventManager);
274
275 SocketExec::ExecTcpConnectionGetRemoteAddress(&context);
276 }
277
ExecTcpConnectionCloseFuzzTest(const uint8_t * data,size_t size)278 void ExecTcpConnectionCloseFuzzTest(const uint8_t *data, size_t size)
279 {
280 if ((data == nullptr) || (size == 0)) {
281 return;
282 }
283 SetGlobalFuzzData(data, size);
284 napi_env env(GetData<napi_env>());
285 EventManager eventManager;
286 TcpServerCloseContext context(env, &eventManager);
287
288 SocketExec::ExecTcpConnectionClose(&context);
289 }
290
ExecUdpAddMembershipFuzzTest(const uint8_t * data,size_t size)291 void ExecUdpAddMembershipFuzzTest(const uint8_t *data, size_t size)
292 {
293 if ((data == nullptr) || (size == 0)) {
294 return;
295 }
296 SetGlobalFuzzData(data, size);
297 napi_env env(GetData<napi_env>());
298 EventManager eventManager;
299 MulticastMembershipContext context(env, &eventManager);
300
301 SocketExec::ExecUdpAddMembership(&context);
302 }
303
ExecUdpDropMembershipFuzzTest(const uint8_t * data,size_t size)304 void ExecUdpDropMembershipFuzzTest(const uint8_t *data, size_t size)
305 {
306 if ((data == nullptr) || (size == 0)) {
307 return;
308 }
309 SetGlobalFuzzData(data, size);
310 napi_env env(GetData<napi_env>());
311 EventManager eventManager;
312 MulticastMembershipContext context(env, &eventManager);
313
314 SocketExec::ExecUdpDropMembership(&context);
315 }
316
ExecSetMulticastTTLFuzzTest(const uint8_t * data,size_t size)317 void ExecSetMulticastTTLFuzzTest(const uint8_t *data, size_t size)
318 {
319 if ((data == nullptr) || (size == 0)) {
320 return;
321 }
322 SetGlobalFuzzData(data, size);
323 napi_env env(GetData<napi_env>());
324 EventManager eventManager;
325 MulticastSetTTLContext context(env, &eventManager);
326
327 SocketExec::ExecSetMulticastTTL(&context);
328 }
329
ExecGetMulticastTTLFuzzTest(const uint8_t * data,size_t size)330 void ExecGetMulticastTTLFuzzTest(const uint8_t *data, size_t size)
331 {
332 if ((data == nullptr) || (size == 0)) {
333 return;
334 }
335 SetGlobalFuzzData(data, size);
336 napi_env env(GetData<napi_env>());
337 EventManager eventManager;
338 MulticastGetTTLContext context(env, &eventManager);
339
340 SocketExec::ExecGetMulticastTTL(&context);
341 }
342
ExecSetLoopbackModeFuzzTest(const uint8_t * data,size_t size)343 void ExecSetLoopbackModeFuzzTest(const uint8_t *data, size_t size)
344 {
345 if ((data == nullptr) || (size == 0)) {
346 return;
347 }
348 SetGlobalFuzzData(data, size);
349 napi_env env(GetData<napi_env>());
350 EventManager eventManager;
351 MulticastSetLoopbackContext context(env, &eventManager);
352
353 SocketExec::ExecSetLoopbackMode(&context);
354 }
355
ExecGetLoopbackModeFuzzTest(const uint8_t * data,size_t size)356 void ExecGetLoopbackModeFuzzTest(const uint8_t *data, size_t size)
357 {
358 if ((data == nullptr) || (size == 0)) {
359 return;
360 }
361 SetGlobalFuzzData(data, size);
362 napi_env env(GetData<napi_env>());
363 EventManager eventManager;
364 MulticastGetLoopbackContext context(env, &eventManager);
365
366 SocketExec::ExecGetLoopbackMode(&context);
367 }
368
MakeLocalSocketFuzzTest(const uint8_t * data,size_t size)369 void MakeLocalSocketFuzzTest(const uint8_t *data, size_t size)
370 {
371 if ((data == nullptr) || (size == 0)) {
372 return;
373 }
374 SetGlobalFuzzData(data, size);
375 int sockfd = ExecCommonUtils::MakeLocalSocket(SOCK_STREAM);
376 close(sockfd);
377 }
378
ExecLocalSocketBindFuzzTest(const uint8_t * data,size_t size)379 void ExecLocalSocketBindFuzzTest(const uint8_t *data, size_t size)
380 {
381 if ((data == nullptr) || (size == 0)) {
382 return;
383 }
384 SetGlobalFuzzData(data, size);
385 napi_env env(GetData<napi_env>());
386 EventManager eventManager;
387 LocalSocketBindContext context(env, &eventManager);
388
389 LocalSocketExec::ExecLocalSocketBind(&context);
390 }
391
ExecLocalSocketConnectFuzzTest(const uint8_t * data,size_t size)392 void ExecLocalSocketConnectFuzzTest(const uint8_t *data, size_t size)
393 {
394 if ((data == nullptr) || (size == 0)) {
395 return;
396 }
397 SetGlobalFuzzData(data, size);
398 napi_env env(GetData<napi_env>());
399 EventManager eventManager;
400 LocalSocketConnectContext context(env, &eventManager);
401
402 LocalSocketExec::ExecLocalSocketConnect(&context);
403 }
404
ExecLocalSocketSendFuzzTest(const uint8_t * data,size_t size)405 void ExecLocalSocketSendFuzzTest(const uint8_t *data, size_t size)
406 {
407 if ((data == nullptr) || (size == 0)) {
408 return;
409 }
410 SetGlobalFuzzData(data, size);
411 napi_env env(GetData<napi_env>());
412 EventManager eventManager;
413 LocalSocketSendContext context(env, &eventManager);
414
415 LocalSocketExec::ExecLocalSocketSend(&context);
416 }
417
ExecLocalSocketCloseFuzzTest(const uint8_t * data,size_t size)418 void ExecLocalSocketCloseFuzzTest(const uint8_t *data, size_t size)
419 {
420 if ((data == nullptr) || (size == 0)) {
421 return;
422 }
423 SetGlobalFuzzData(data, size);
424 napi_env env(GetData<napi_env>());
425 EventManager eventManager;
426 LocalSocketCloseContext context(env, &eventManager);
427
428 LocalSocketExec::ExecLocalSocketClose(&context);
429 }
430
ExecLocalSocketGetStateFuzzTest(const uint8_t * data,size_t size)431 void ExecLocalSocketGetStateFuzzTest(const uint8_t *data, size_t size)
432 {
433 if ((data == nullptr) || (size == 0)) {
434 return;
435 }
436 SetGlobalFuzzData(data, size);
437 napi_env env(GetData<napi_env>());
438 EventManager eventManager;
439 LocalSocketGetStateContext context(env, &eventManager);
440
441 LocalSocketExec::ExecLocalSocketGetState(&context);
442 }
443
ExecLocalSocketGetSocketFdFuzzTest(const uint8_t * data,size_t size)444 void ExecLocalSocketGetSocketFdFuzzTest(const uint8_t *data, size_t size)
445 {
446 if ((data == nullptr) || (size == 0)) {
447 return;
448 }
449 SetGlobalFuzzData(data, size);
450 napi_env env(GetData<napi_env>());
451 EventManager eventManager;
452 LocalSocketGetSocketFdContext context(env, &eventManager);
453
454 LocalSocketExec::ExecLocalSocketGetSocketFd(&context);
455 }
456
ExecLocalSocketSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)457 void ExecLocalSocketSetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
458 {
459 if ((data == nullptr) || (size == 0)) {
460 return;
461 }
462 SetGlobalFuzzData(data, size);
463 napi_env env(GetData<napi_env>());
464 EventManager eventManager;
465 LocalSocketSetExtraOptionsContext context(env, &eventManager);
466
467 LocalSocketExec::ExecLocalSocketSetExtraOptions(&context);
468 }
469
ExecLocalSocketGetExtraOptionsFuzzTest(const uint8_t * data,size_t size)470 void ExecLocalSocketGetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
471 {
472 if ((data == nullptr) || (size == 0)) {
473 return;
474 }
475 SetGlobalFuzzData(data, size);
476 napi_env env(GetData<napi_env>());
477 EventManager eventManager;
478 LocalSocketGetExtraOptionsContext context(env, &eventManager);
479
480 LocalSocketExec::ExecLocalSocketGetExtraOptions(&context);
481 }
482
ExecLocalSocketServerListenFuzzTest(const uint8_t * data,size_t size)483 void ExecLocalSocketServerListenFuzzTest(const uint8_t *data, size_t size)
484 {
485 if ((data == nullptr) || (size == 0)) {
486 return;
487 }
488 SetGlobalFuzzData(data, size);
489 napi_env env(GetData<napi_env>());
490 EventManager eventManager;
491 LocalSocketServerListenContext context(env, &eventManager);
492
493 LocalSocketExec::ExecLocalSocketServerListen(&context);
494 }
495
ExecLocalSocketServerGetStateFuzzTest(const uint8_t * data,size_t size)496 void ExecLocalSocketServerGetStateFuzzTest(const uint8_t *data, size_t size)
497 {
498 if ((data == nullptr) || (size == 0)) {
499 return;
500 }
501 SetGlobalFuzzData(data, size);
502 napi_env env(GetData<napi_env>());
503 EventManager eventManager;
504 LocalSocketServerGetStateContext context(env, &eventManager);
505
506 LocalSocketExec::ExecLocalSocketServerGetState(&context);
507 }
508
ExecLocalSocketServerSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)509 void ExecLocalSocketServerSetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
510 {
511 if ((data == nullptr) || (size == 0)) {
512 return;
513 }
514 SetGlobalFuzzData(data, size);
515 napi_env env(GetData<napi_env>());
516 EventManager eventManager;
517 LocalSocketServerSetExtraOptionsContext context(env, &eventManager);
518
519 LocalSocketExec::ExecLocalSocketServerSetExtraOptions(&context);
520 }
521
ExecLocalSocketServerGetExtraOptionsFuzzTest(const uint8_t * data,size_t size)522 void ExecLocalSocketServerGetExtraOptionsFuzzTest(const uint8_t *data, size_t size)
523 {
524 if ((data == nullptr) || (size == 0)) {
525 return;
526 }
527 SetGlobalFuzzData(data, size);
528 napi_env env(GetData<napi_env>());
529 EventManager eventManager;
530 LocalSocketServerGetExtraOptionsContext context(env, &eventManager);
531
532 LocalSocketExec::ExecLocalSocketServerGetExtraOptions(&context);
533 }
534
ExecLocalSocketConnectionSendFuzzTest(const uint8_t * data,size_t size)535 void ExecLocalSocketConnectionSendFuzzTest(const uint8_t *data, size_t size)
536 {
537 if ((data == nullptr) || (size == 0)) {
538 return;
539 }
540 SetGlobalFuzzData(data, size);
541 napi_env env(GetData<napi_env>());
542 EventManager eventManager;
543 LocalSocketServerSendContext context(env, &eventManager);
544
545 LocalSocketExec::ExecLocalSocketConnectionSend(&context);
546 }
547
ExecLocalSocketConnectionCloseFuzzTest(const uint8_t * data,size_t size)548 void ExecLocalSocketConnectionCloseFuzzTest(const uint8_t *data, size_t size)
549 {
550 if ((data == nullptr) || (size == 0)) {
551 return;
552 }
553 SetGlobalFuzzData(data, size);
554 napi_env env(GetData<napi_env>());
555 EventManager eventManager;
556 LocalSocketServerCloseContext context(env, &eventManager);
557
558 LocalSocketExec::ExecLocalSocketConnectionClose(&context);
559 }
560 } // namespace Socket
561 } // namespace NetStack
562 } // namespace OHOS
563
564 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)565 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
566 {
567 /* Run your code on data */
568 OHOS::NetStack::Socket::MakeUdpSocketFuzzTest(data, size);
569 OHOS::NetStack::Socket::MakeTcpSocketFuzzTest(data, size);
570 OHOS::NetStack::Socket::ExecUdpBindFuzzTest(data, size);
571 OHOS::NetStack::Socket::ExecTcpBindFuzzTest(data, size);
572 OHOS::NetStack::Socket::ExecUdpSendFuzzTest(data, size);
573 OHOS::NetStack::Socket::ExecTcpSendFuzzTest(data, size);
574 OHOS::NetStack::Socket::ExecConnectFuzzTest(data, size);
575 OHOS::NetStack::Socket::ExecCloseFuzzTest(data, size);
576 OHOS::NetStack::Socket::ExecGetStateFuzzTest(data, size);
577 OHOS::NetStack::Socket::ExecGetRemoteAddressFuzzTest(data, size);
578 OHOS::NetStack::Socket::ExecTcpSetExtraOptionsFuzzTest(data, size);
579 OHOS::NetStack::Socket::ExecUdpSetExtraOptionsFuzzTest(data, size);
580 OHOS::NetStack::Socket::ExecTcpServerListenFuzzTest(data, size);
581 OHOS::NetStack::Socket::ExecTcpServerSetExtraOptionsFuzzTest(data, size);
582 OHOS::NetStack::Socket::ExecTcpServerGetStateFuzzTest(data, size);
583 OHOS::NetStack::Socket::ExecTcpConnectionSendFuzzTest(data, size);
584 OHOS::NetStack::Socket::ExecTcpConnectionGetRemoteAddressFuzzTest(data, size);
585 OHOS::NetStack::Socket::ExecTcpConnectionCloseFuzzTest(data, size);
586 OHOS::NetStack::Socket::ExecUdpAddMembershipFuzzTest(data, size);
587 OHOS::NetStack::Socket::ExecUdpDropMembershipFuzzTest(data, size);
588 OHOS::NetStack::Socket::ExecSetMulticastTTLFuzzTest(data, size);
589 OHOS::NetStack::Socket::ExecGetMulticastTTLFuzzTest(data, size);
590 OHOS::NetStack::Socket::ExecSetLoopbackModeFuzzTest(data, size);
591 OHOS::NetStack::Socket::ExecGetLoopbackModeFuzzTest(data, size);
592 OHOS::NetStack::Socket::MakeLocalSocketFuzzTest(data, size);
593 OHOS::NetStack::Socket::ExecLocalSocketBindFuzzTest(data, size);
594 OHOS::NetStack::Socket::ExecLocalSocketConnectFuzzTest(data, size);
595 OHOS::NetStack::Socket::ExecLocalSocketSendFuzzTest(data, size);
596 OHOS::NetStack::Socket::ExecLocalSocketCloseFuzzTest(data, size);
597 OHOS::NetStack::Socket::ExecLocalSocketGetStateFuzzTest(data, size);
598 OHOS::NetStack::Socket::ExecLocalSocketGetSocketFdFuzzTest(data, size);
599 OHOS::NetStack::Socket::ExecLocalSocketSetExtraOptionsFuzzTest(data, size);
600 OHOS::NetStack::Socket::ExecLocalSocketGetExtraOptionsFuzzTest(data, size);
601 OHOS::NetStack::Socket::ExecLocalSocketServerListenFuzzTest(data, size);
602 OHOS::NetStack::Socket::ExecLocalSocketServerGetStateFuzzTest(data, size);
603 OHOS::NetStack::Socket::ExecLocalSocketServerSetExtraOptionsFuzzTest(data, size);
604 OHOS::NetStack::Socket::ExecLocalSocketServerGetExtraOptionsFuzzTest(data, size);
605 OHOS::NetStack::Socket::ExecLocalSocketConnectionSendFuzzTest(data, size);
606 OHOS::NetStack::Socket::ExecLocalSocketConnectionCloseFuzzTest(data, size);
607 return 0;
608 }
609