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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<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 auto eventManager = std::make_shared<EventManager>();
221 TcpServerListenContext context(env, eventManager);
222
223 SocketExec::ExecTcpServerListen(&context);
224 }
225
ExecTcpServerCloseFuzzTest(const uint8_t * data,size_t size)226 void ExecTcpServerCloseFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
234 TcpServerCloseContext context(env, eventManager);
235
236 SocketExec::ExecTcpServerClose(&context);
237 }
238
ExecTcpServerSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)239 void ExecTcpServerSetExtraOptionsFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
247 TcpServerSetExtraOptionsContext context(env, eventManager);
248
249 SocketExec::ExecTcpServerSetExtraOptions(&context);
250 }
251
ExecTcpServerGetStateFuzzTest(const uint8_t * data,size_t size)252 void ExecTcpServerGetStateFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
260 TcpServerGetStateContext context(env, eventManager);
261
262 SocketExec::ExecTcpServerGetState(&context);
263 }
264
ExecTcpConnectionSendFuzzTest(const uint8_t * data,size_t size)265 void ExecTcpConnectionSendFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
273 TcpServerSendContext context(env, eventManager);
274
275 SocketExec::ExecTcpConnectionSend(&context);
276 }
277
ExecTcpConnectionGetRemoteAddressFuzzTest(const uint8_t * data,size_t size)278 void ExecTcpConnectionGetRemoteAddressFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
286 TcpServerGetRemoteAddressContext context(env, eventManager);
287
288 SocketExec::ExecTcpConnectionGetRemoteAddress(&context);
289 }
290
ExecTcpConnectionCloseFuzzTest(const uint8_t * data,size_t size)291 void ExecTcpConnectionCloseFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
299 TcpServerCloseContext context(env, eventManager);
300
301 SocketExec::ExecTcpConnectionClose(&context);
302 }
303
ExecUdpAddMembershipFuzzTest(const uint8_t * data,size_t size)304 void ExecUdpAddMembershipFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
312 MulticastMembershipContext context(env, eventManager);
313
314 SocketExec::ExecUdpAddMembership(&context);
315 }
316
ExecUdpDropMembershipFuzzTest(const uint8_t * data,size_t size)317 void ExecUdpDropMembershipFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
325 MulticastMembershipContext context(env, eventManager);
326
327 SocketExec::ExecUdpDropMembership(&context);
328 }
329
ExecSetMulticastTTLFuzzTest(const uint8_t * data,size_t size)330 void ExecSetMulticastTTLFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
338 MulticastSetTTLContext context(env, eventManager);
339
340 SocketExec::ExecSetMulticastTTL(&context);
341 }
342
ExecGetMulticastTTLFuzzTest(const uint8_t * data,size_t size)343 void ExecGetMulticastTTLFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
351 MulticastGetTTLContext context(env, eventManager);
352
353 SocketExec::ExecGetMulticastTTL(&context);
354 }
355
ExecSetLoopbackModeFuzzTest(const uint8_t * data,size_t size)356 void ExecSetLoopbackModeFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
364 MulticastSetLoopbackContext context(env, eventManager);
365
366 SocketExec::ExecSetLoopbackMode(&context);
367 }
368
ExecGetLoopbackModeFuzzTest(const uint8_t * data,size_t size)369 void ExecGetLoopbackModeFuzzTest(const uint8_t *data, size_t size)
370 {
371 if ((data == nullptr) || (size == 0)) {
372 return;
373 }
374 SetGlobalFuzzData(data, size);
375 napi_env env(GetData<napi_env>());
376 auto eventManager = std::make_shared<EventManager>();
377 MulticastGetLoopbackContext context(env, eventManager);
378
379 SocketExec::ExecGetLoopbackMode(&context);
380 }
381
MakeLocalSocketFuzzTest(const uint8_t * data,size_t size)382 void MakeLocalSocketFuzzTest(const uint8_t *data, size_t size)
383 {
384 if ((data == nullptr) || (size == 0)) {
385 return;
386 }
387 SetGlobalFuzzData(data, size);
388 int sockfd = ExecCommonUtils::MakeLocalSocket(SOCK_STREAM);
389 close(sockfd);
390 }
391
ExecLocalSocketBindFuzzTest(const uint8_t * data,size_t size)392 void ExecLocalSocketBindFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
400 LocalSocketBindContext context(env, eventManager);
401
402 LocalSocketExec::ExecLocalSocketBind(&context);
403 }
404
ExecLocalSocketConnectFuzzTest(const uint8_t * data,size_t size)405 void ExecLocalSocketConnectFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
413 LocalSocketConnectContext context(env, eventManager);
414
415 LocalSocketExec::ExecLocalSocketConnect(&context);
416 }
417
ExecLocalSocketSendFuzzTest(const uint8_t * data,size_t size)418 void ExecLocalSocketSendFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
426 LocalSocketSendContext context(env, eventManager);
427
428 LocalSocketExec::ExecLocalSocketSend(&context);
429 }
430
ExecLocalSocketCloseFuzzTest(const uint8_t * data,size_t size)431 void ExecLocalSocketCloseFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
439 LocalSocketCloseContext context(env, eventManager);
440
441 LocalSocketExec::ExecLocalSocketClose(&context);
442 }
443
ExecLocalSocketGetStateFuzzTest(const uint8_t * data,size_t size)444 void ExecLocalSocketGetStateFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
452 LocalSocketGetStateContext context(env, eventManager);
453
454 LocalSocketExec::ExecLocalSocketGetState(&context);
455 }
456
ExecLocalSocketGetSocketFdFuzzTest(const uint8_t * data,size_t size)457 void ExecLocalSocketGetSocketFdFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
465 LocalSocketGetSocketFdContext context(env, eventManager);
466
467 LocalSocketExec::ExecLocalSocketGetSocketFd(&context);
468 }
469
ExecLocalSocketSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)470 void ExecLocalSocketSetExtraOptionsFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
478 LocalSocketSetExtraOptionsContext context(env, eventManager);
479
480 LocalSocketExec::ExecLocalSocketSetExtraOptions(&context);
481 }
482
ExecLocalSocketGetExtraOptionsFuzzTest(const uint8_t * data,size_t size)483 void ExecLocalSocketGetExtraOptionsFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
491 LocalSocketGetExtraOptionsContext context(env, eventManager);
492
493 LocalSocketExec::ExecLocalSocketGetExtraOptions(&context);
494 }
495
ExecLocalSocketServerListenFuzzTest(const uint8_t * data,size_t size)496 void ExecLocalSocketServerListenFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
504 LocalSocketServerListenContext context(env, eventManager);
505
506 LocalSocketExec::ExecLocalSocketServerListen(&context);
507 }
508
ExecLocalSocketServerGetStateFuzzTest(const uint8_t * data,size_t size)509 void ExecLocalSocketServerGetStateFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
517 LocalSocketServerGetStateContext context(env, eventManager);
518
519 LocalSocketExec::ExecLocalSocketServerGetState(&context);
520 }
521
ExecLocalSocketServerSetExtraOptionsFuzzTest(const uint8_t * data,size_t size)522 void ExecLocalSocketServerSetExtraOptionsFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
530 LocalSocketServerSetExtraOptionsContext context(env, eventManager);
531
532 LocalSocketExec::ExecLocalSocketServerSetExtraOptions(&context);
533 }
534
ExecLocalSocketServerGetExtraOptionsFuzzTest(const uint8_t * data,size_t size)535 void ExecLocalSocketServerGetExtraOptionsFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
543 LocalSocketServerGetExtraOptionsContext context(env, eventManager);
544
545 LocalSocketExec::ExecLocalSocketServerGetExtraOptions(&context);
546 }
547
ExecLocalSocketConnectionSendFuzzTest(const uint8_t * data,size_t size)548 void ExecLocalSocketConnectionSendFuzzTest(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 auto eventManager = std::make_shared<EventManager>();
556 LocalSocketServerSendContext context(env, eventManager);
557
558 LocalSocketExec::ExecLocalSocketConnectionSend(&context);
559 }
560
ExecLocalSocketConnectionCloseFuzzTest(const uint8_t * data,size_t size)561 void ExecLocalSocketConnectionCloseFuzzTest(const uint8_t *data, size_t size)
562 {
563 if ((data == nullptr) || (size == 0)) {
564 return;
565 }
566 SetGlobalFuzzData(data, size);
567 napi_env env(GetData<napi_env>());
568 auto eventManager = std::make_shared<EventManager>();
569 LocalSocketServerCloseContext context(env, eventManager);
570
571 LocalSocketExec::ExecLocalSocketConnectionClose(&context);
572 }
573 } // namespace Socket
574 } // namespace NetStack
575 } // namespace OHOS
576
577 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)578 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
579 {
580 /* Run your code on data */
581 OHOS::NetStack::Socket::MakeUdpSocketFuzzTest(data, size);
582 OHOS::NetStack::Socket::MakeTcpSocketFuzzTest(data, size);
583 OHOS::NetStack::Socket::ExecUdpBindFuzzTest(data, size);
584 OHOS::NetStack::Socket::ExecTcpBindFuzzTest(data, size);
585 OHOS::NetStack::Socket::ExecUdpSendFuzzTest(data, size);
586 OHOS::NetStack::Socket::ExecTcpSendFuzzTest(data, size);
587 OHOS::NetStack::Socket::ExecConnectFuzzTest(data, size);
588 OHOS::NetStack::Socket::ExecCloseFuzzTest(data, size);
589 OHOS::NetStack::Socket::ExecGetStateFuzzTest(data, size);
590 OHOS::NetStack::Socket::ExecGetRemoteAddressFuzzTest(data, size);
591 OHOS::NetStack::Socket::ExecTcpSetExtraOptionsFuzzTest(data, size);
592 OHOS::NetStack::Socket::ExecUdpSetExtraOptionsFuzzTest(data, size);
593 OHOS::NetStack::Socket::ExecTcpServerListenFuzzTest(data, size);
594 OHOS::NetStack::Socket::ExecTcpServerCloseFuzzTest(data, size);
595 OHOS::NetStack::Socket::ExecTcpServerSetExtraOptionsFuzzTest(data, size);
596 OHOS::NetStack::Socket::ExecTcpServerGetStateFuzzTest(data, size);
597 OHOS::NetStack::Socket::ExecTcpConnectionSendFuzzTest(data, size);
598 OHOS::NetStack::Socket::ExecTcpConnectionGetRemoteAddressFuzzTest(data, size);
599 OHOS::NetStack::Socket::ExecTcpConnectionCloseFuzzTest(data, size);
600 OHOS::NetStack::Socket::ExecUdpAddMembershipFuzzTest(data, size);
601 OHOS::NetStack::Socket::ExecUdpDropMembershipFuzzTest(data, size);
602 OHOS::NetStack::Socket::ExecSetMulticastTTLFuzzTest(data, size);
603 OHOS::NetStack::Socket::ExecGetMulticastTTLFuzzTest(data, size);
604 OHOS::NetStack::Socket::ExecSetLoopbackModeFuzzTest(data, size);
605 OHOS::NetStack::Socket::ExecGetLoopbackModeFuzzTest(data, size);
606 OHOS::NetStack::Socket::MakeLocalSocketFuzzTest(data, size);
607 OHOS::NetStack::Socket::ExecLocalSocketBindFuzzTest(data, size);
608 OHOS::NetStack::Socket::ExecLocalSocketConnectFuzzTest(data, size);
609 OHOS::NetStack::Socket::ExecLocalSocketSendFuzzTest(data, size);
610 OHOS::NetStack::Socket::ExecLocalSocketCloseFuzzTest(data, size);
611 OHOS::NetStack::Socket::ExecLocalSocketGetStateFuzzTest(data, size);
612 OHOS::NetStack::Socket::ExecLocalSocketGetSocketFdFuzzTest(data, size);
613 OHOS::NetStack::Socket::ExecLocalSocketSetExtraOptionsFuzzTest(data, size);
614 OHOS::NetStack::Socket::ExecLocalSocketGetExtraOptionsFuzzTest(data, size);
615 OHOS::NetStack::Socket::ExecLocalSocketServerListenFuzzTest(data, size);
616 OHOS::NetStack::Socket::ExecLocalSocketServerGetStateFuzzTest(data, size);
617 OHOS::NetStack::Socket::ExecLocalSocketServerSetExtraOptionsFuzzTest(data, size);
618 OHOS::NetStack::Socket::ExecLocalSocketServerGetExtraOptionsFuzzTest(data, size);
619 OHOS::NetStack::Socket::ExecLocalSocketConnectionSendFuzzTest(data, size);
620 OHOS::NetStack::Socket::ExecLocalSocketConnectionCloseFuzzTest(data, size);
621 return 0;
622 }
623