1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <securec.h>
33 #include <time.h>
34 #include "ctype.h"
35 #include "stdlib.h"
36 #include "string.h"
37 #include "socket.h"
38 #include "in.h"
39 #include "los_task.h"
40 #include "ohos_types.h"
41 #include "los_config.h"
42 #include "Public.h"
43 #include "PCommon.h"
44 #include "fuzz_posix.h"
45
46 #ifndef TASK_PRIO_TEST
47 #define TASK_PRIO_TEST 2
48 #endif
49
50 #ifndef TASK_STACK_SIZE_TEST
51 #define TASK_STACK_SIZE_TEST 0x400
52 #endif
53 #define LOS_TASK_STATUS_DETACHED 0x0100
54
55 extern S_ElementInit g_element[ELEMENT_LEN];
56 extern int g_iteration;
57
58 static UINT32 g_testTaskID01;
59
60 #define BUF_SIZE 40
61 static char g_udpIp[16];
62 static UINT16 g_udpPort;
63 #define UDPMSG "ABCDEEFG"
64 #define SLEEP_SECONDS 2
65
SampleUdpServer()66 static void *SampleUdpServer()
67 {
68 int fd;
69 struct sockaddr_in srvAddr = { 0 };
70
71 struct sockaddr_in clnAddr = { 0 };
72 socklen_t clnAddrLen = sizeof(clnAddr);
73 char buf[BUF_SIZE] = { 0 };
74 struct msghdr msg = { 0 };
75 struct iovec iov[2] = { };
76
77 printf("s0\r\n");
78 fd = socket(AF_INET, SOCK_DGRAM, 0);
79
80 printf("s1\r\n");
81 srvAddr.sin_family = AF_INET;
82 srvAddr.sin_addr.s_addr = inet_addr(g_udpIp);
83 srvAddr.sin_port = htons(g_udpPort);
84 int ret = bind(fd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
85
86 printf("s1.1, ret = %d\r\n", ret);
87 (void)recvfrom(fd, buf, sizeof(buf), 0x40, (struct sockaddr *)&clnAddr, &clnAddrLen);
88
89 printf("s2, buf = %s\r\n", buf);
90 usleep(SLEEP_SECONDS);
91 msg.msg_name = &clnAddr;
92 msg.msg_namelen = sizeof(clnAddr);
93 msg.msg_iov = iov;
94 msg.msg_iovlen = 1;
95 iov[0].iov_base = buf;
96 iov[0].iov_len = strlen(buf);
97 (void)sendmsg(fd, &msg, 0);
98
99 printf("s3\r\n");
100 close(fd);
101 return NULL;
102 }
103
SampleUdpClient()104 static void *SampleUdpClient()
105 {
106 int fd = 0;
107 const int sleepSec = 5;
108 struct sockaddr_in clnAddr = { 0 };
109
110 char buf[BUF_SIZE] = { 0 };
111 int flag;
112
113 struct msghdr msg;
114 struct iovec iov[2];
115
116 printf("c1\r\n");
117 fd = socket(AF_INET, SOCK_DGRAM, 0);
118
119 printf("c2\r\n");
120 clnAddr.sin_family = AF_INET;
121 clnAddr.sin_addr.s_addr = inet_addr(g_udpIp);
122 clnAddr.sin_port = htons(g_udpPort);
123
124 printf("c3\r\n");
125 (void)strcpy_s(buf, sizeof(buf), UDPMSG);
126
127 usleep(sleepSec);
128 printf("c4, %s, %d\r\n", buf, strlen(buf));
129 (void)sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&clnAddr, (socklen_t)sizeof(clnAddr));
130
131 msg.msg_name = &clnAddr;
132 msg.msg_namelen = sizeof(clnAddr);
133 msg.msg_iov = iov;
134 msg.msg_iovlen = 1;
135 iov[0].iov_base = buf;
136 (void)recvmsg(fd, &msg, 0x40);
137 printf("c6\r\n");
138
139 close(fd);
140 return NULL;
141 }
142
UdpFun(VOID)143 static UINT32 UdpFun(VOID)
144 {
145 int i;
146
147 UINT8 num1;
148 UINT8 num2;
149 UINT8 num3;
150 UINT8 num4;
151
152 INIT_FuzzEnvironment();
153 printf("UDPFun starts\n");
154
155 for (i = 0; i < g_iteration; i++) {
156 num1 = *(UINT8 *)DT_SetGetU8(&g_element[NUM_0_INDEX], 1);
157 num2 = *(UINT8 *)DT_SetGetU8(&g_element[NUM_1_INDEX], 1);
158 num3 = *(UINT8 *)DT_SetGetU8(&g_element[NUM_2_INDEX], 1);
159 num4 = *(UINT8 *)DT_SetGetU8(&g_element[NUM_3_INDEX], 1);
160
161 (void)snprintf_s(g_udpIp, sizeof(g_udpIp), sizeof(g_udpIp) - 1, "%d.%d.%d.%d", num1, num2, num3, num4);
162 g_udpPort = *(UINT16 *)DT_SetGetU16(&g_element[NUM_5_INDEX], 0);
163
164 {
165 TSK_INIT_PARAM_S stTask1 = { 0 };
166 stTask1.pfnTaskEntry = (TSK_ENTRY_FUNC)SampleUdpServer;
167 stTask1.uwStackSize = TASK_STACK_SIZE_TEST;
168 stTask1.pcName = "Tsk001A";
169 stTask1.usTaskPrio = TASK_PRIO_TEST;
170 stTask1.uwResved = LOS_TASK_STATUS_DETACHED;
171 (void)LOS_TaskCreate(&g_testTaskID01, &stTask1);
172 }
173
174 {
175 TSK_INIT_PARAM_S stTask1 = { 0 };
176 stTask1.pfnTaskEntry = (TSK_ENTRY_FUNC)SampleUdpClient;
177 stTask1.uwStackSize = TASK_STACK_SIZE_TEST;
178 stTask1.pcName = "Tsk001A";
179 stTask1.usTaskPrio = TASK_PRIO_TEST;
180 stTask1.uwResved = LOS_TASK_STATUS_DETACHED;
181 (void)LOS_TaskCreate(&g_testTaskID01, &stTask1);
182 }
183 }
184
185 DT_Clear(g_element);
186 CLOSE_Log();
187 CLEAR_FuzzEnvironment();
188 printf("UDPFun end ....\n");
189
190 return 0;
191 }
192
193 #define LOCAL_HOST "127.0.0.1"
194 #define STACK_IP LOCAL_HOST
195 #define STACK_PORT 2277
196 #define PEER_PORT STACK_PORT
197 #define PEER_IP LOCAL_HOST
198 #define SRV_MSG "Hi, I am TCP server"
199 #define CLI_MSG "Hi, I am TCP client"
200
SampleTcpServer()201 static void *SampleTcpServer()
202 {
203 char buf[BUF_SIZE + 1] = { 0 };
204 int sfd;
205 int lsfd;
206 struct sockaddr_in srvAddr = { 0 };
207 struct sockaddr_in clnAddr = { 0 };
208 int ret;
209
210 lsfd = socket(AF_INET, SOCK_STREAM, 0);
211
212 srvAddr.sin_family = AF_INET;
213 srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
214 srvAddr.sin_port = htons(STACK_PORT);
215 (void)bind(lsfd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
216
217 int num1 = *(int *)DT_SetGetS32(&g_element[NUM_0_INDEX], 0);
218
219 (void)listen(lsfd, num1);
220
221 int num2 = *(int *)DT_SetGetS32(&g_element[NUM_1_INDEX], 0);
222 sfd = accept(lsfd, (struct sockaddr *)&clnAddr, &num2);
223
224 int num3 = *(int *)DT_SetGetS32(&g_element[NUM_2_INDEX], 0);
225 (void)recv(lsfd, buf, sizeof(buf), num3);
226
227 int num4 = *(int *)DT_SetGetS32(&g_element[NUM_3_INDEX], 0);
228 ret = shutdown(sfd, num4);
229 if (ret != 0) {
230 shutdown(sfd, SHUT_RDWR);
231 }
232
233 close(sfd);
234 close(lsfd);
235 return (void *)(intptr_t)ret;
236 }
237
SampleTcpClient()238 static void *SampleTcpClient()
239 {
240 char buf[BUF_SIZE + 1] = { 0 };
241 int sfd = -1;
242 struct sockaddr_in srvAddr = { 0 };
243 int ret;
244
245 struct sockaddr addr;
246 socklen_t addrLen = sizeof(addr);
247 /* tcp client connection */
248 sfd = socket(AF_INET, SOCK_STREAM, 0);
249 srvAddr.sin_family = AF_INET;
250 srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
251 srvAddr.sin_port = htons(PEER_PORT);
252 connect(sfd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
253
254 int num1 = *(int *)DT_SetGetS32(&g_element[0], 0);
255 (void)getpeername(num1, &addr, &addrLen);
256 (void)getsockname(num1, &addr, &addrLen);
257
258 /* send */
259 ret = memset_s(buf, sizeof(buf), 0, BUF_SIZE);
260 if (err != EOK) {
261 close(sfd);
262 return (void *)(intptr_t)ret;
263 }
264 (void)strcpy_s(buf, sizeof(buf), CLI_MSG);
265
266 int num2 = *(int *)DT_SetGetS32(&g_element[1], 0);
267 send(num1, buf, strlen(CLI_MSG), num2);
268
269 ret = shutdown(sfd, SHUT_RDWR);
270
271 close(sfd);
272 return (void *)(intptr_t)ret;
273 }
274
TcpFun(VOID)275 static UINT32 TcpFun(VOID)
276 {
277 int i;
278
279 INIT_FuzzEnvironment();
280 printf("TcpFun starts\n");
281
282 for (i = 0; i < g_iteration; i++) {
283 {
284 TSK_INIT_PARAM_S stTask1 = { 0 };
285 stTask1.pfnTaskEntry = (TSK_ENTRY_FUNC)SampleTcpServer;
286 stTask1.uwStackSize = TASK_STACK_SIZE_TEST;
287 stTask1.pcName = "Tsk001A";
288 stTask1.usTaskPrio = TASK_PRIO_TEST;
289 stTask1.uwResved = LOS_TASK_STATUS_DETACHED;
290 (void)LOS_TaskCreate(&g_testTaskID01, &stTask1);
291 }
292
293 {
294 TSK_INIT_PARAM_S stTask1 = { 0 };
295 stTask1.pfnTaskEntry = (TSK_ENTRY_FUNC)SampleTcpClient;
296 stTask1.uwStackSize = TASK_STACK_SIZE_TEST;
297 stTask1.pcName = "Tsk001A";
298 stTask1.usTaskPrio = TASK_PRIO_TEST;
299 stTask1.uwResved = LOS_TASK_STATUS_DETACHED;
300 (void)LOS_TaskCreate(&g_testTaskID01, &stTask1);
301 }
302 }
303
304 DT_Clear(g_element);
305 CLOSE_Log();
306 CLEAR_FuzzEnvironment();
307 printf("TcpFun end ....\n");
308
309 return 0;
310 }
311
NetFuzzTest(void)312 void NetFuzzTest(void)
313 {
314 DnCompFun();
315
316 UdpFun();
317 TcpFun();
318
319 InetFun();
320
321 ProtoentFun();
322 ConvertFun();
323
324 SocketFun();
325 }
326