1 /*
2 * Copyright (c) 2022 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 <arpa/inet.h>
17 #include <ctype.h>
18 #include <dlfcn.h>
19 #include <fcntl.h>
20 #include <netdb.h>
21 #include <pthread.h>
22 #include <stdint.h>
23 #include <stdlib.h>
24 #include <sys/socket.h>
25 #include <sys/stat.h>
26 #include <unistd.h>
27 #include "functionalext.h"
28
29 const int SUCCESS = 0;
30 #define BUF_SIZE (100)
31 #define PORT 2288
32 #define WAIT() pthread_barrier_wait(&g_barrier)
33 static const char *g_localHost = "127.0.0.1";
34 static pthread_barrier_t g_barrier;
35
ServerTaskOne()36 void *ServerTaskOne()
37 {
38 int *ret = (int *)malloc(sizeof(int));
39 int rets = -1;
40 int sListen = socket(AF_INET, SOCK_STREAM, 0);
41 if (sListen == -1) {
42 *ret = -1;
43 return ret;
44 }
45 int flag = 1;
46 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
47 if (rets != 0) {
48 printf("[server] setsockopt fail, rets: %d!\n", rets);
49 }
50 struct sockaddr_in srvAddr = {0};
51 srvAddr.sin_family = AF_INET;
52 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
53 srvAddr.sin_port = htons(PORT);
54 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
55 if (rets != 0) {
56 close(sListen);
57 *ret = -1;
58 return ret;
59 }
60 rets = listen(sListen, 2);
61 if (rets != 0) {
62 close(sListen);
63 *ret = -1;
64 return ret;
65 }
66 WAIT();
67 struct sockaddr_in clnAddr = {0};
68 socklen_t clnAddrLen = sizeof(clnAddr);
69 int sClient = -1;
70 sClient = accept4(sListen, (struct sockaddr *)&clnAddr, &clnAddrLen, 0);
71 EXPECT_NE("accept4_0100", sClient, -1);
72 close(sClient);
73 close(sListen);
74 return ret;
75 }
76
ServerTaskTwo()77 void *ServerTaskTwo()
78 {
79 int *ret = (int *)malloc(sizeof(int));
80 int rets = -1;
81 int sListen = socket(AF_INET, SOCK_STREAM, 0);
82 if (sListen == -1) {
83 *ret = -1;
84 return ret;
85 }
86 int flag = 1;
87 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
88 if (rets != 0) {
89 printf("[server] setsockopt fail, rets: %d!\n", rets);
90 }
91 struct sockaddr_in srvAddr = {0};
92 srvAddr.sin_family = AF_INET;
93 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
94 srvAddr.sin_port = htons(PORT);
95 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
96 if (rets != 0) {
97 close(sListen);
98 *ret = -1;
99 return ret;
100 }
101 rets = listen(sListen, 2);
102 if (rets != 0) {
103 close(sListen);
104 *ret = -1;
105 return ret;
106 }
107 WAIT();
108 struct sockaddr_in clnAddr = {0};
109 socklen_t clnAddrLen = sizeof(clnAddr);
110 int sClient = -1;
111 sClient = accept4(sListen, (struct sockaddr *)&clnAddr, &clnAddrLen, SOCK_NONBLOCK);
112 EXPECT_NE("accept4_0200", sClient, -1);
113 close(sClient);
114 close(sListen);
115 return ret;
116 }
117
ServerTaskThree()118 void *ServerTaskThree()
119 {
120 int *ret = (int *)malloc(sizeof(int));
121 int rets = -1;
122 int sListen = socket(AF_INET, SOCK_STREAM, 0);
123 if (sListen == -1) {
124 *ret = -1;
125 return ret;
126 }
127 int flag = 1;
128 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
129 if (rets != 0) {
130 printf("[server] setsockopt fail, rets: %d!\n", rets);
131 }
132 struct sockaddr_in srvAddr = {0};
133 srvAddr.sin_family = AF_INET;
134 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
135 srvAddr.sin_port = htons(PORT);
136 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
137 if (rets != 0) {
138 close(sListen);
139 *ret = -1;
140 return ret;
141 }
142 rets = listen(sListen, 2);
143 if (rets != 0) {
144 close(sListen);
145 *ret = -1;
146 return ret;
147 }
148 WAIT();
149 struct sockaddr_in clnAddr = {0};
150 socklen_t clnAddrLen = sizeof(clnAddr);
151 int sClient = -1;
152 sClient = accept4(sListen, (struct sockaddr *)&clnAddr, &clnAddrLen, SOCK_CLOEXEC);
153 EXPECT_NE("accept4_0300", sClient, -1);
154 close(sClient);
155 close(sListen);
156 return ret;
157 }
158
ServerTaskFive()159 void *ServerTaskFive()
160 {
161 int *ret = (int *)malloc(sizeof(int));
162 int rets = -1;
163 int sListen = socket(AF_INET, SOCK_STREAM, 0);
164 if (sListen == -1) {
165 *ret = -1;
166 return ret;
167 }
168 int flag = 1;
169 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
170 if (rets != 0) {
171 printf("[server] setsockopt fail, rets: %d!\n", rets);
172 }
173 struct sockaddr_in srvAddr = {0};
174 srvAddr.sin_family = AF_INET;
175 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
176 srvAddr.sin_port = htons(PORT);
177 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
178 if (rets != 0) {
179 close(sListen);
180 *ret = -1;
181 return ret;
182 }
183 rets = listen(sListen, 2);
184 if (rets != 0) {
185 close(sListen);
186 *ret = -1;
187 return ret;
188 }
189 WAIT();
190 struct sockaddr_in clnAddr = {0};
191 socklen_t clnAddrLen = sizeof(clnAddr);
192 int sClient = -1;
193 sClient = accept4(sListen, 0, &clnAddrLen, SOCK_CLOEXEC);
194 EXPECT_NE("accept4_0500", sClient, -1);
195 close(sClient);
196 close(sListen);
197 return ret;
198 }
199
ServerTaskSix()200 void *ServerTaskSix()
201 {
202 int *ret = (int *)malloc(sizeof(int));
203 int rets = -1;
204 int sListen = socket(AF_INET, SOCK_STREAM, 0);
205 if (sListen == -1) {
206 *ret = -1;
207 }
208 int flag = 1;
209 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
210 if (rets != 0) {
211 printf("[server] setsockopt fail, rets: %d!\n", rets);
212 }
213 struct sockaddr_in srvAddr = {0};
214 srvAddr.sin_family = AF_INET;
215 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
216 srvAddr.sin_port = htons(PORT);
217 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
218 if (rets != 0) {
219 close(sListen);
220 *ret = -1;
221 }
222 rets = listen(sListen, 2);
223 if (rets != 0) {
224 close(sListen);
225 *ret = -1;
226 }
227 WAIT();
228 struct sockaddr_in clnAddr = {0};
229 socklen_t clnAddrLen = sizeof(clnAddr);
230 int sClient = 0;
231 sClient = accept4(sListen, (struct sockaddr *)&clnAddr, 0, 0);
232 EXPECT_EQ("accept4_0600", sClient, -1);
233 close(sClient);
234 close(sListen);
235 return ret;
236 }
237
ClientTask()238 void *ClientTask()
239 {
240 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
241 WAIT();
242 struct sockaddr_in srvAddr = {0};
243 srvAddr.sin_family = AF_INET;
244 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
245 srvAddr.sin_port = htons(PORT);
246 int ret = connect(clnFd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
247 if (ret != 0) {
248 printf("connect failed\n");
249 }
250 close(clnFd);
251 return NULL;
252 }
253
254 /**
255 * @tc.name : accept4_0100
256 * @tc.desc : Each parameter is valid, the flag parameter is 0, and the socket connection can be accepted.
257 * @tc.level : Level 0
258 */
accept4_0100(void)259 void accept4_0100(void)
260 {
261 pthread_t srv;
262 pthread_t cli;
263 int ret = pthread_barrier_init(&g_barrier, 0, 2);
264 EXPECT_EQ("accept4_0100", SUCCESS, ret);
265 ret = pthread_create(&srv, NULL, ServerTaskOne, NULL);
266 EXPECT_EQ("accept4_0100", SUCCESS, ret);
267 ret = pthread_create(&cli, NULL, ClientTask, NULL);
268 EXPECT_EQ("accept4_0100", SUCCESS, ret);
269 ret = pthread_join(cli, NULL);
270 EXPECT_EQ("accept4_0100", SUCCESS, ret);
271 ret = pthread_join(srv, NULL);
272 EXPECT_EQ("accept4_0100", SUCCESS, ret);
273 ret = pthread_barrier_destroy(&g_barrier);
274 EXPECT_EQ("accept4_0100", SUCCESS, ret);
275 }
276
277 /**
278 * @tc.name : accept4_0200
279 * @tc.desc : Each parameter is valid, the flag parameter is SOCK_NONBLOCK, which can accept socket connection.
280 * @tc.level : Level 1
281 */
accept4_0200(void)282 void accept4_0200(void)
283 {
284 pthread_t srv;
285 pthread_t cli;
286 int ret = pthread_barrier_init(&g_barrier, 0, 2);
287 EXPECT_EQ("accept4_0200", SUCCESS, ret);
288 ret = pthread_create(&srv, NULL, ServerTaskTwo, NULL);
289 EXPECT_EQ("accept4_0200", SUCCESS, ret);
290 ret = pthread_create(&cli, NULL, ClientTask, NULL);
291 EXPECT_EQ("accept4_0200", SUCCESS, ret);
292 ret = pthread_join(cli, NULL);
293 EXPECT_EQ("accept4_0200", SUCCESS, ret);
294 ret = pthread_join(srv, NULL);
295 EXPECT_EQ("accept4_0200", SUCCESS, ret);
296 ret = pthread_barrier_destroy(&g_barrier);
297 EXPECT_EQ("accept4_0200", SUCCESS, ret);
298 }
299
300 /**
301 * @tc.name : accept4_0300
302 * @tc.desc : Each parameter is valid, the flag parameter is SOCK_CLOEXEC, which can accept socket connection.
303 * @tc.level : Level 1
304 */
accept4_0300(void)305 void accept4_0300(void)
306 {
307 pthread_t srv;
308 pthread_t cli;
309 int ret = pthread_barrier_init(&g_barrier, 0, 2);
310 EXPECT_EQ("accept4_0300", SUCCESS, ret);
311 ret = pthread_create(&srv, NULL, ServerTaskThree, NULL);
312 EXPECT_EQ("accept4_0300", SUCCESS, ret);
313 ret = pthread_create(&cli, NULL, ClientTask, NULL);
314 EXPECT_EQ("accept4_0300", SUCCESS, ret);
315 ret = pthread_join(cli, NULL);
316 EXPECT_EQ("accept4_0300", SUCCESS, ret);
317 ret = pthread_join(srv, NULL);
318 EXPECT_EQ("accept4_0300", SUCCESS, ret);
319 ret = pthread_barrier_destroy(&g_barrier);
320 EXPECT_EQ("accept4_0300", SUCCESS, ret);
321 }
322
323 /**
324 * @tc.name : accept4_0400
325 * @tc.desc : The fd parameter is invalid, socket connection cannot be accepted.
326 * @tc.level : Level 2
327 */
accept4_0400(void)328 void accept4_0400(void)
329 {
330 struct sockaddr_in clnAddr = {0};
331 socklen_t clnAddrLen = sizeof(clnAddr);
332 int sClient = 0;
333 sClient = accept4(0, (struct sockaddr *)&clnAddr, &clnAddrLen, 0);
334 EXPECT_EQ("accept4_0400", sClient, -1);
335 }
336
337 /**
338 * @tc.name : accept4_0500
339 * @tc.desc : The addr parameter is invalid, socket connection can be accepted.
340 * @tc.level : Level 1
341 */
accept4_0500(void)342 void accept4_0500(void)
343 {
344 pthread_t srv;
345 pthread_t cli;
346 int ret = pthread_barrier_init(&g_barrier, 0, 2);
347 EXPECT_EQ("accept4_0500", SUCCESS, ret);
348 ret = pthread_create(&srv, NULL, ServerTaskFive, NULL);
349 EXPECT_EQ("accept4_0500", SUCCESS, ret);
350 ret = pthread_create(&cli, NULL, ClientTask, NULL);
351 EXPECT_EQ("accept4_0500", SUCCESS, ret);
352 ret = pthread_join(cli, NULL);
353 EXPECT_EQ("accept4_0500", SUCCESS, ret);
354 ret = pthread_join(srv, NULL);
355 EXPECT_EQ("accept4_0500", SUCCESS, ret);
356 ret = pthread_barrier_destroy(&g_barrier);
357 EXPECT_EQ("accept4_0500", SUCCESS, ret);
358 }
359
360 /**
361 * @tc.name : accept4_0600
362 * @tc.desc : The len parameter is invalid, socket connection cannot be accepted.
363 * @tc.level : Level 2
364 */
accept4_0600(void)365 void accept4_0600(void)
366 {
367 pthread_t srv;
368 pthread_t cli;
369 int ret = pthread_barrier_init(&g_barrier, 0, 2);
370 EXPECT_EQ("accept4_0600", SUCCESS, ret);
371 ret = pthread_create(&srv, NULL, ServerTaskSix, NULL);
372 EXPECT_EQ("accept4_0600", SUCCESS, ret);
373 ret = pthread_create(&cli, NULL, ClientTask, NULL);
374 EXPECT_EQ("accept4_0600", SUCCESS, ret);
375 ret = pthread_join(cli, NULL);
376 EXPECT_EQ("accept4_0600", SUCCESS, ret);
377 ret = pthread_join(srv, NULL);
378 EXPECT_EQ("accept4_0600", SUCCESS, ret);
379 ret = pthread_barrier_destroy(&g_barrier);
380 EXPECT_EQ("accept4_0600", SUCCESS, ret);
381 }
main(int argc,char * argv[])382 int main(int argc, char *argv[])
383 {
384 accept4_0100();
385 accept4_0200();
386 accept4_0300();
387 accept4_0400();
388 accept4_0500();
389 accept4_0600();
390 return t_status;
391 }