1 /**
2 * Copyright (c) 2020-2021 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 "gtest/gtest.h"
17 #include <sys/socket.h>
18 #include <arpa/inet.h>
19 #include <netinet/tcp.h>
20 #include <sys/wait.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <signal.h>
25 #include "securec.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 static const int TEST_FD_COUNT = 10;
31 static const int STACK_PORT = 2277;
32 static const int PEER_PORT = 2277;
33 static const int BUF_SIZE = (1024 * 8);
34 static const char* g_udpMsg = "Hi, I am UDP";
35 static const char* g_srvMsg = "Hi, I am TCP server";
36 static const char* g_cliMsg = "Hi, I am TCP client";
37 static const char* g_localHost = "127.0.0.1";
38
39 static pthread_barrier_t g_barrier;
40 #define WAIT() pthread_barrier_wait(&g_barrier)
41
42 class ActsLwipTest : public testing::Test {
43 protected:
44 // SetUpTestCase: Testsuit setup, run before 1st testcase
SetUpTestCase(void)45 static void SetUpTestCase(void)
46 {
47 // Ignore SIGPIPE Signals
48 signal(SIGPIPE, SIG_IGN);
49 }
50 // TearDownTestCase: Testsuit teardown, run after last testcase
TearDownTestCase(void)51 static void TearDownTestCase(void) {}
52 // Testcase setup
SetUp()53 virtual void SetUp() {}
54 // Testcase teardown
TearDown()55 virtual void TearDown() {}
56 };
57
CommInitTcpServer(int port)58 static int CommInitTcpServer(int port)
59 {
60 int srvFd = socket(AF_INET, SOCK_STREAM, 0);
61 if (srvFd == -1) {
62 printf("CommInitTcpServer]socket fail!\n");
63 return -1;
64 }
65 int flag = 1;
66 int ret = setsockopt(srvFd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
67 if (ret != 0) {
68 printf("[CommInitTcpServer]setsockopt fail, ret[%d]!\n", ret);
69 }
70 struct sockaddr_in srvAddr = {0};
71 srvAddr.sin_family = AF_INET;
72 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
73 srvAddr.sin_port = htons(port);
74 ret = ::bind(srvFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
75 if (ret != 0) {
76 printf("[CommInitTcpServer]::bind fail!\n");
77 close(srvFd);
78 return -1;
79 }
80 int backlog = 5;
81 ret = listen(srvFd, backlog);
82 if (ret != 0) {
83 printf("[CommInitTcpServer]listen fail!\n");
84 close(srvFd);
85 return -1;
86 }
87 printf("[CommInitTcpServer]success,Fd[%d]\n", srvFd);
88 return srvFd;
89 }
90
CommTcpClientTask(void * param)91 static void* CommTcpClientTask(void* param)
92 {
93 int* ret = (int *)malloc(sizeof(int));
94 if (ret == nullptr) {
95 printf("[comm client]malloc fail\n");
96 return nullptr;
97 }
98 *ret = 0;
99 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
100 if (clnFd == -1) {
101 printf("[comm client]socket fail\n");
102 *ret = -1;
103 return ret;
104 }
105 struct sockaddr_in srvAddr = {0};
106 srvAddr.sin_family = AF_INET;
107 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
108 srvAddr.sin_port = htons(PEER_PORT + 1);
109 int rst = connect(clnFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
110 if (rst != 0) {
111 printf("[comm client]connect fail\n");
112 close(clnFd);
113 *ret = -1;
114 return ret;
115 }
116 int sleepSecond = *((int *)param);
117 int count = 4;
118 char dataBuf[50] = {0};
119 char sendMsgList[5][50] = {"Hi, I'm client,FD:[%d]", "client:123456789abcdefg,FD:[%d]",
120 "client:!!@@##$$%%^^&&**(()),FD:[%d]", "client:(((112233445566778899))),FD:[%d]", "bye"};
121 for (int i = 0; i < count; i++) {
122 sleep(sleepSecond);
123 (void) memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
124 rst = sprintf_s(dataBuf, sizeof(dataBuf), sendMsgList[i], clnFd);
125 if (rst < 0) {
126 printf("[comm client]sprintf_s error!\n");
127 continue;
128 }
129 rst = send(clnFd, dataBuf, strlen(dataBuf), 0);
130 if (rst <= 0) {
131 *ret = -1;
132 printf("[comm client][%d]send fail\n", clnFd);
133 }
134 (void) memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
135 rst = recv(clnFd, dataBuf, sizeof(dataBuf), 0);
136 if (rst > 0) {
137 printf("[comm client][%d]recv msg[%s]\n", clnFd, dataBuf);
138 } else {
139 printf("[comm client][%d]recv no data\n", clnFd);
140 }
141 }
142 // send 'bye', finish
143 rst = send(clnFd, sendMsgList[count], strlen(sendMsgList[count]), 0);
144 if (rst <= 0) {
145 *ret = -1;
146 printf("[comm client][%d]send fail\n", clnFd);
147 }
148 rst = close(clnFd);
149 if (rst != 0) {
150 *ret = -1;
151 printf("[comm client][%d]close fd fail\n", clnFd);
152 }
153 return ret;
154 }
155
SampleTcpServerTask(void * p)156 static void* SampleTcpServerTask(void* p)
157 {
158 int srvFd = CommInitTcpServer(STACK_PORT);
159 EXPECT_NE(-1, srvFd);
160
161 WAIT();
162 struct sockaddr_in clnAddr = {0};
163 socklen_t clnAddrLen = sizeof(clnAddr);
164 int clnFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
165 printf("[tcp server]accept <%s:%d>\n", inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
166 EXPECT_NE(-1, clnFd);
167 printf("[tcp server]lsfd[%d], sfd[%d]\n", srvFd, clnFd);
168
169 struct sockaddr addr = {0};
170 socklen_t addrLen = sizeof(addr);
171 int ret = getsockname(clnFd, &addr, &addrLen);
172 printf("[tcp server]getsockname %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
173 ntohs(((struct sockaddr_in*)&addr)->sin_port));
174 EXPECT_EQ(0, ret);
175 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
176
177 ret = getpeername(clnFd, &addr, &addrLen);
178 printf("[tcp server]getpeername %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
179 ntohs(((struct sockaddr_in*)&addr)->sin_port));
180 EXPECT_EQ(0, ret);
181 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
182
183 static char buf[BUF_SIZE + 1] = {0};
184 unsigned int srvMsgLen = strlen(g_srvMsg);
185 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
186 ret = strcpy_s(buf, BUF_SIZE, g_srvMsg);
187 EXPECT_EQ(0, ret);
188 ret = send(clnFd, buf, srvMsgLen, 0);
189 printf("[tcp server]send, ret=%d\n", ret);
190 EXPECT_EQ(srvMsgLen, (unsigned int)ret);
191
192 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
193 ret = recv(clnFd, buf, sizeof(buf), 0);
194 printf("[tcp server]recv, ret=%d, msg[%s]\n", ret, buf);
195 EXPECT_EQ(strlen(g_cliMsg), (unsigned int)ret);
196
197 WAIT();
198 int len = 2;
199 struct msghdr msg = {0};
200 struct iovec iov[2] = {0};
201 clnAddr.sin_family = AF_INET;
202 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
203 clnAddr.sin_port = htons(PEER_PORT);
204 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
205 ret = strcpy_s(buf, BUF_SIZE, g_srvMsg);
206 EXPECT_EQ(0, ret);
207 msg.msg_name = &clnAddr;
208 msg.msg_namelen = sizeof(clnAddr);
209 msg.msg_iov = iov;
210 msg.msg_iovlen = len;
211 iov[0].iov_base = buf;
212 iov[0].iov_len = srvMsgLen;
213 iov[1].iov_base = buf;
214 iov[1].iov_len = srvMsgLen;
215 ret = sendmsg(clnFd, &msg, 0);
216 printf("[tcp server]sendmsg, ret=%d\n", ret);
217 EXPECT_EQ(len * srvMsgLen, (unsigned int)ret);
218
219 WAIT();
220 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
221 (void) memset_s(&msg, sizeof(msg), 0, sizeof(msg));
222 msg.msg_name = &clnAddr;
223 msg.msg_namelen = sizeof(clnAddr);
224 msg.msg_iov = iov;
225 msg.msg_iovlen = 1;
226 iov[0].iov_base = buf;
227 iov[0].iov_len = sizeof(buf);
228 ret = recvmsg(clnFd, &msg, 0);
229 printf("[tcp server]recvmsg on socket %d:%d, msg[%s]\n", clnFd, ret, buf);
230 EXPECT_EQ(len * strlen(g_cliMsg), (unsigned int)ret);
231
232 ret = shutdown(clnFd, SHUT_RDWR);
233 printf("[tcp server]shutdown\n");
234 EXPECT_EQ(0, ret);
235 ret = close(clnFd);
236 EXPECT_NE(-1, ret);
237 ret = close(srvFd);
238 EXPECT_NE(-1, ret);
239 return nullptr;
240 }
241
SampleTcpClientTask(void * p)242 static void* SampleTcpClientTask(void* p)
243 {
244 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
245 printf("[tcp client]create socket\n");
246 EXPECT_NE(-1, clnFd);
247
248 WAIT();
249 struct sockaddr_in srvAddr = {0};
250 srvAddr.sin_family = AF_INET;
251 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
252 srvAddr.sin_port = htons(PEER_PORT);
253 int ret = connect(clnFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
254 printf("[tcp client]connect %s:%d, fd[%d]\n", inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), clnFd);
255 EXPECT_EQ(0, ret);
256
257 struct sockaddr addr = {0};
258 socklen_t addrLen = sizeof(addr);
259 ret = getpeername(clnFd, &addr, &addrLen);
260 printf("[tcp client]getpeername %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
261 ntohs(((struct sockaddr_in*)&addr)->sin_port));
262 EXPECT_EQ(0, ret);
263 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
264
265 ret = getsockname(clnFd, &addr, &addrLen);
266 printf("[tcp client]getsockname %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
267 ntohs(((struct sockaddr_in*)&addr)->sin_port));
268 EXPECT_EQ(0, ret);
269 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
270
271 static char buf[BUF_SIZE + 1] = {0};
272 unsigned int cliMsgLen = strlen(g_cliMsg);
273 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
274 ret = strcpy_s(buf, BUF_SIZE, g_cliMsg);
275 EXPECT_EQ(0, ret);
276 ret = send(clnFd, buf, cliMsgLen, 0);
277 printf("[tcp client]send, ret=%d\n", ret);
278 EXPECT_EQ(cliMsgLen, (unsigned int)ret);
279
280 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
281 ret = recv(clnFd, buf, sizeof(buf), 0);
282 printf("[tcp client]recv, ret=%d, msg[%s]\n", ret, buf);
283 EXPECT_EQ(strlen(g_srvMsg), (unsigned int)ret);
284
285 WAIT();
286 int len = 2;
287 struct msghdr msg = {0};
288 struct iovec iov[2] = {0};
289 struct sockaddr_in clnAddr = {0};
290 clnAddr.sin_family = AF_INET;
291 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
292 clnAddr.sin_port = htons(PEER_PORT);
293 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
294 ret = strcpy_s(buf, BUF_SIZE, g_cliMsg);
295 EXPECT_EQ(0, ret);
296 msg.msg_name = &clnAddr;
297 msg.msg_namelen = sizeof(clnAddr);
298 msg.msg_iov = iov;
299 msg.msg_iovlen = len;
300 iov[0].iov_base = buf;
301 iov[0].iov_len = cliMsgLen;
302 iov[1].iov_base = buf;
303 iov[1].iov_len = cliMsgLen;
304 ret = sendmsg(clnFd, &msg, 0);
305 printf("[tcp client]sendmsg, ret=%d\n", ret);
306 EXPECT_EQ(len * cliMsgLen, (unsigned int)ret);
307
308 WAIT();
309 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
310 (void) memset_s(&msg, sizeof(msg), 0, sizeof(msg));
311 msg.msg_name = &clnAddr;
312 msg.msg_namelen = sizeof(clnAddr);
313 msg.msg_iov = iov;
314 msg.msg_iovlen = 1;
315 iov[0].iov_base = buf;
316 iov[0].iov_len = sizeof(buf);
317 ret = recvmsg(clnFd, &msg, 0);
318 printf("[tcp client]recvmsg, ret=%d, msg[%s]\n", ret, buf);
319 EXPECT_EQ(len * strlen(g_srvMsg), (unsigned int)ret);
320
321 ret = shutdown(clnFd, SHUT_RDWR);
322 printf("[tcp client]shutdown\n");
323 EXPECT_EQ(0, ret);
324 ret = close(clnFd);
325 EXPECT_NE(-1, ret);
326 return nullptr;
327 }
328
TcpServerForFork()329 static int TcpServerForFork()
330 {
331 int timeout = 10;
332 char dataBuf[50] = {0};
333 int srvFd = CommInitTcpServer(STACK_PORT + 1);
334 if (srvFd == -1) {
335 return -1;
336 }
337 printf("[server process]wait client...\n");
338 int ret = -1;
339 struct sockaddr_in clnAddr = {0};
340 socklen_t clnAddrLen = sizeof(clnAddr);
341 int cliFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
342 if (cliFd == -1) {
343 printf("[server process]accept fail!\n");
344 goto FINALLY;
345 }
346 while (timeout > 0) {
347 (void) memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
348 ret = recv(cliFd, dataBuf, sizeof(dataBuf), 0);
349 if (ret > 0) {
350 printf("[server process]recv msg[%s]\n", dataBuf);
351 if (strcmp(dataBuf, "bye") == 0) {
352 printf("[server process]break\n");
353 break;
354 }
355 } else {
356 printf("[server process]recv no data\n");
357 }
358 (void) memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
359 sprintf_s(dataBuf, sizeof(dataBuf), "server timeout:%d", timeout);
360 ret = send(cliFd, dataBuf, strlen(dataBuf), 0);
361 if (ret > 0) {
362 printf("[server process]send success, msg[%s]\n", dataBuf);
363 } else {
364 printf("[server process]send fail!\n");
365 }
366 timeout--;
367 }
368 close(cliFd);
369 printf("[server process]over\n");
370
371 FINALLY:
372 close(srvFd);
373 return ret;
374 }
375
WaitProcessExit(int pid,int * code)376 static int WaitProcessExit(int pid, int* code)
377 {
378 int status;
379 int rt = waitpid(pid, &status, 0);
380 errno = 0;
381 int retError = -2;
382 if (rt == -1) {
383 printf("[WaitProcessExit]waitpid return -1, errno=%d:%s\n", errno, strerror(errno));
384 return -1;
385 } else if (rt == 0) {
386 return 0;
387 } else if (rt != pid) { // waitpid return error
388 printf("[WaitProcessExit]waitpid error\n");
389 return retError;
390 }
391
392 int retWterm = 2;
393 int retWstop = 3;
394 int other = 4;
395 if (WIFEXITED(status)) {
396 *code = WEXITSTATUS(status);
397 return 1;
398 } else if (WIFSIGNALED(status)) {
399 *code = WTERMSIG(status);
400 return retWterm;
401 } else if (WIFSTOPPED(status)) {
402 *code = WSTOPSIG(status);
403 return retWstop;
404 }
405 return other;
406 }
407
SelectServerForFork(unsigned int timeoutSec)408 static int SelectServerForFork(unsigned int timeoutSec)
409 {
410 int srvFd = CommInitTcpServer(STACK_PORT + 1);
411 if (srvFd == -1) {
412 return -1;
413 }
414 int ret;
415 int cliCount = 0;
416 int maxFd = srvFd;
417 fd_set readSet;
418 char dataBuf[50] = {0};
419 int fds[TEST_FD_COUNT] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
420 fds[0] = srvFd;
421 long timeout = static_cast<long>(timeoutSec);
422 struct timeval timev = {.tv_sec = timeout, .tv_usec = 0};
423 struct sockaddr_in clnAddr = {0};
424 socklen_t clnAddrLen = sizeof(clnAddr);
425 while (1) {
426 FD_ZERO(&readSet);
427 for (int i = 0; i < TEST_FD_COUNT; i++) {
428 if (fds[i] != -1) {
429 FD_SET(fds[i], &readSet);
430 if (maxFd < fds[i]) {
431 maxFd = fds[i];
432 }
433 printf("[select process]fd info[%d:%d]\n", i, fds[i]);
434 }
435 }
436 ret = select(maxFd + 1, &readSet, NULL, NULL, &timev);
437 if (ret == 0) {
438 printf("[select process]select timeout!\n");
439 ret = -2;
440 break;
441 }
442 if (ret == -1) {
443 fprintf(stderr, "[select process]select fail[%s]\n", strerror(errno));
444 break;
445 }
446 if (FD_ISSET(srvFd, &readSet)) {
447 int cliFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
448 if (cliFd == -1) {
449 printf("[select process]accept fail!\n");
450 ret = -1;
451 break;
452 } else {
453 for (int i = 0; i < TEST_FD_COUNT; i++) {
454 if (fds[i] == -1) {
455 fds[i] = cliFd;
456 break;
457 }
458 }
459 cliCount++;
460 printf("[select process]accept success, cliCount[%d]\n", cliCount);
461 }
462 continue;
463 }
464 for (int i = 0; i < TEST_FD_COUNT; i++) {
465 if (fds[i] == -1) {
466 continue;
467 }
468 if (FD_ISSET(fds[i], &readSet)) {
469 (void) memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
470 int len = recv(fds[i], dataBuf, sizeof(dataBuf), 0);
471 if (len > 0) {
472 printf("[select process][%d]recv msg[%s]\n", fds[i], dataBuf);
473 if (strcmp(dataBuf, "bye") == 0) {
474 printf("[select process][%d]client bye,cliCount[%d]\n", fds[i], cliCount);
475 FD_CLR(fds[i], &readSet);
476 close(fds[i]);
477 fds[i] = -1;
478 cliCount--;
479 continue;
480 }
481 len = send(fds[i], dataBuf, strlen(dataBuf), 0);
482 if (len > 0) {
483 printf("[select process][%d]send success\n", fds[i]);
484 } else {
485 printf("[select process][%d]send fail\n", fds[i]);
486 }
487 }
488 }
489 }
490 if (cliCount == 0) {
491 ret = 0;
492 printf("[select process]cliCount=0, over!\n");
493 break;
494 }
495 }
496 close(srvFd);
497 return ret;
498 }
499
500 /**
501 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0100
502 * @tc.name : sample test tcp
503 * @tc.desc : [C- SOFTWARE -0200]
504 */
505 HWTEST_F(ActsLwipTest, testTcpSample, Function | MediumTest | Level1)
506 {
507 pthread_t srv;
508 pthread_t cli;
509
510 int ret = pthread_barrier_init(&g_barrier, 0, 2);
511 EXPECT_EQ(0, ret);
512
513 ret = pthread_create(&srv, nullptr, SampleTcpServerTask, nullptr);
514 EXPECT_EQ(0, ret);
515 ret = pthread_create(&cli, nullptr, SampleTcpClientTask, nullptr);
516 EXPECT_EQ(0, ret);
517
518 ret = pthread_join(cli, nullptr);
519 EXPECT_EQ(0, ret);
520 ret = pthread_join(srv, nullptr);
521 EXPECT_EQ(0, ret);
522
523 ret = pthread_barrier_destroy(&g_barrier);
524 EXPECT_EQ(0, ret);
525 }
526
527 /**
528 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0200
529 * @tc.name : sample test udp
530 * @tc.desc : [C- SOFTWARE -0200]
531 */
532 HWTEST_F(ActsLwipTest, testUdpSample, Function | MediumTest | Level2)
533 {
534 int len = 2;
535 char buf[BUF_SIZE + 1];
536 struct msghdr msg = {0};
537 struct iovec iov[2] = {0};
538 struct sockaddr_in srvAddr = {0};
539 struct sockaddr_in clnAddr = {0};
540 socklen_t clnAddrLen = sizeof(clnAddr);
541
542 int sfd = socket(AF_INET, SOCK_DGRAM, 0);
543 ASSERT_NE(-1, sfd);
544 srvAddr.sin_family = AF_INET;
545 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
546 srvAddr.sin_port = htons(STACK_PORT);
547 int ret = ::bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
548 ASSERT_EQ(0, ret);
549
550 clnAddr.sin_family = AF_INET;
551 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
552 clnAddr.sin_port = htons(PEER_PORT);
553 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
554 ret = strcpy_s(buf, BUF_SIZE, g_udpMsg);
555 EXPECT_EQ(0, ret);
556 ret = sendto(sfd, buf, strlen(g_udpMsg), 0, (struct sockaddr*)&clnAddr, (socklen_t)sizeof(clnAddr));
557 EXPECT_NE(-1, ret);
558
559 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
560 ret = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&clnAddr, &clnAddrLen);
561 EXPECT_EQ(strlen(g_udpMsg), (unsigned int)ret);
562
563 clnAddr.sin_family = AF_INET;
564 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
565 clnAddr.sin_port = htons(PEER_PORT);
566 (void) memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
567 ret = strcpy_s(buf, BUF_SIZE, g_udpMsg);
568 EXPECT_EQ(0, ret);
569 msg.msg_name = &clnAddr;
570 msg.msg_namelen = sizeof(clnAddr);
571 msg.msg_iov = iov;
572 msg.msg_iovlen = len;
573 iov[0].iov_base = buf;
574 iov[0].iov_len = strlen(g_udpMsg);
575 iov[1].iov_base = buf;
576 iov[1].iov_len = strlen(g_udpMsg);
577 ret = sendmsg(sfd, &msg, 0);
578 EXPECT_EQ(len*strlen(g_udpMsg), (unsigned int)ret);
579
580 ret = close(sfd);
581 EXPECT_NE(-1, ret);
582 }
583
584 /**
585 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0300
586 * @tc.name : test inter-process network communication
587 * @tc.desc : [C- SOFTWARE -0200]
588 */
589 HWTEST_F(ActsLwipTest, testInterProcessComm, Function | MediumTest | Level2)
590 {
591 pid_t pid = fork();
592 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
593 if (pid == 0) {
594 // child:tcp server
595 int exitCode = 0;
596 int ret = TcpServerForFork();
597 if (ret == -1) {
598 printf("[tcp server]run fail\n");
599 exitCode = 1;
600 }
601 exit(exitCode);
602 } else {
603 // parent:tcp client
604 sleep(2);
605 int second = 1;
606 void *ret = CommTcpClientTask(&second);
607 if (ret == nullptr) {
608 printf("[test select]CommClientTask ret is null\n");
609 EXPECT_TRUE(0);
610 } else {
611 printf("[test select]CommClientTask ret...\n");
612 int rst = *((int *)ret);
613 printf("[test select]CommClientTask ret [%d]\n", rst);
614 EXPECT_EQ(0, rst);
615 free(ret);
616 }
617 int exitCode;
618 int procStat = WaitProcessExit(pid, &exitCode);
619 ASSERT_EQ(1, procStat);
620 ASSERT_EQ(0, exitCode);
621 }
622 }
623
624 /**
625 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0400
626 * @tc.name : test select timeout
627 * @tc.desc : [C- SOFTWARE -0200]
628 */
629 HWTEST_F(ActsLwipTest, testSelectTimeout, Function | MediumTest | Level2)
630 {
631 pid_t pid = fork();
632 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
633 if (pid == 0) {
634 // child: server
635 int ret = SelectServerForFork(2);
636 if (ret == -2) {
637 exit(0);
638 } else {
639 printf("[select server]fail, ret is[%d]\n", ret);
640 exit(1);
641 }
642 } else {
643 int exitCode;
644 int procStat = WaitProcessExit(pid, &exitCode);
645 ASSERT_EQ(procStat, 1);
646 ASSERT_EQ(exitCode, 0);
647 }
648 }
649
650 /**
651 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0500
652 * @tc.name : test select with one client
653 * @tc.desc : [C- SOFTWARE -0200]
654 */
655 HWTEST_F(ActsLwipTest, testSelectOneClient, Function | MediumTest | Level2)
656 {
657 pid_t pid = fork();
658 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
659 if (pid == 0) {
660 // child: server
661 int exitCode = 0;
662 int ret = SelectServerForFork(15);
663 if (ret != 0) {
664 printf("[select server]run fail\n");
665 exitCode = 1;
666 }
667 printf("[select server]ret[%d]\n", ret);
668 exit(exitCode);
669 } else {
670 // parent: client
671 sleep(2);
672 int second = 1;
673 void *ret = CommTcpClientTask(&second);
674 if (ret == nullptr) {
675 printf("[test select]CommClientTask ret is null\n");
676 EXPECT_TRUE(0);
677 } else {
678 int rst = *((int *)ret);
679 printf("[test select]CommClientTask ret [%d]\n", rst);
680 EXPECT_EQ(0, rst);
681 free(ret);
682 }
683 int exitCode;
684 int procStat = WaitProcessExit(pid, &exitCode);
685 ASSERT_EQ(1, procStat);
686 ASSERT_EQ(0, exitCode);
687 }
688 }
689
690 /**
691 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0600
692 * @tc.name : test select with multi clients
693 * @tc.desc : [C- SOFTWARE -0200]
694 */
695 HWTEST_F(ActsLwipTest, testSelectMultiClients, Function | MediumTest | Level2)
696 {
697 pid_t pid = fork();
698 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
699 if (pid == 0) {
700 // child: server
701 int exitCode = 0;
702 int ret = SelectServerForFork(15);
703 if (ret != 0) {
704 printf("[select server]run fail\n");
705 exitCode = 1;
706 }
707 printf("[select server]ret[%d]\n", ret);
708 exit(exitCode);
709 } else {
710 // parent: client
711 sleep(2);
712 int ret;
713 pthread_t pCli[4];
714 int interval[4] = {2, 1, 3, 1};
715 for (int i = 0; i < 4; i++) {
716 ret = pthread_create(&pCli[i], nullptr, CommTcpClientTask, &interval[i]);
717 EXPECT_EQ(0, ret) << "Errinfo:pthread_create index is [" << i << "]";
718 }
719
720 void *rst = nullptr;
721 for (int i = 0; i < 4; i++) {
722 ret = pthread_join(pCli[i], &rst);
723 EXPECT_EQ(0, ret) << "Errinfo:pthread_join index is [" << i << "]";
724 if (rst != nullptr) {
725 printf("[test select]client thread[%d] return[%d]\n", i, *((int *)rst));
726 EXPECT_EQ(0, *((int *)rst));
727 free(rst);
728 }
729 }
730 int exitCode;
731 int procStat = WaitProcessExit(pid, &exitCode);
732 ASSERT_EQ(1, procStat);
733 ASSERT_EQ(0, exitCode);
734 }
735 }
736
737 /**
738 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0700
739 * @tc.name : test socket operation
740 * @tc.desc : [C- SOFTWARE -0200]
741 */
742 HWTEST_F(ActsLwipTest, testSocketOpt, Function | MediumTest | Level2)
743 {
744 socklen_t len;
745 struct timeval timeout = {0};
746 int fd = socket(AF_INET, SOCK_STREAM, 0);
747 EXPECT_NE(-1, fd);
748
749 int error = -1;
750 len = sizeof(error);
751 int ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
752 EXPECT_EQ(0, ret);
753 EXPECT_EQ(0, error);
754
755 len = sizeof(timeout);
756 ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
757 EXPECT_EQ(0, ret);
758
759 timeout.tv_sec = 1000;
760 len = sizeof(timeout);
761 ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, len);
762 EXPECT_EQ(0, ret);
763
764 (void) memset_s(&timeout, len, 0, len);
765 ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
766 EXPECT_EQ(0, ret);
767 EXPECT_EQ(1000, timeout.tv_sec);
768
769 int flag = 1;
770 ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
771 EXPECT_EQ(0, ret);
772
773 flag = 0;
774 len = sizeof(flag);
775 ret = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, &len);
776 EXPECT_EQ(0, ret);
777 EXPECT_EQ(1, flag);
778
779 error = -1;
780 len = sizeof(error);
781 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
782 EXPECT_EQ(0, ret);
783 EXPECT_EQ(0, error);
784
785 ret = close(fd);
786 EXPECT_EQ(0, ret);
787 }
788
789 /**
790 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0800
791 * @tc.name : test getsockname and getpeername invalid input
792 * @tc.desc : [C- SOFTWARE -0200]
793 */
794 HWTEST_F(ActsLwipTest, testGetSocketNameInvalidInput, Function | MediumTest | Level3)
795 {
796 struct sockaddr addr = {0};
797 socklen_t addrLen = sizeof(addr);
798 int ret = getsockname(-1, &addr, &addrLen);
799 EXPECT_EQ(-1, ret);
800 ret = getpeername(-1, &addr, &addrLen);
801 EXPECT_EQ(-1, ret);
802 ret = getsockname(0, &addr, &addrLen);
803 EXPECT_EQ(-1, ret);
804 ret = getpeername(0, &addr, &addrLen);
805 EXPECT_EQ(-1, ret);
806 ret = getsockname(1, &addr, &addrLen);
807 EXPECT_EQ(-1, ret);
808 ret = getpeername(1, &addr, &addrLen);
809 EXPECT_EQ(-1, ret);
810 ret = getsockname(130, &addr, &addrLen);
811 EXPECT_EQ(-1, ret);
812 ret = getpeername(130, &addr, &addrLen);
813 EXPECT_EQ(-1, ret);
814 ret = getsockname(10, nullptr, &addrLen);
815 EXPECT_EQ(-1, ret);
816 ret = getpeername(10, nullptr, &addrLen);
817 EXPECT_EQ(-1, ret);
818 ret = getsockname(10, &addr, nullptr);
819 EXPECT_EQ(-1, ret);
820 ret = getpeername(10, &addr, nullptr);
821 EXPECT_EQ(-1, ret);
822 }
823
824 /**
825 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_0900
826 * @tc.name : test inet_pton IPv4 normal
827 * @tc.desc : [C- SOFTWARE -0200]
828 */
829 HWTEST_F(ActsLwipTest, testInetPtonIpv4Normal, Function | MediumTest | Level2)
830 {
831 int ret;
832 struct in_addr rst = {0};
833 char cpAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"};
834 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
835 unsigned int expectLittle[4] = {1691630090, 0, 255, 4294967295};
836 #else
837 unsigned int expectBig[4] = {171627620, 0, 4278190080, 4294967295};
838 #endif
839
840 for (int i = 0; i < 4; i++) {
841 ret = inet_pton(AF_INET, cpAddrs[i], &rst);
842 EXPECT_EQ(1, ret);
843 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
844 EXPECT_EQ(expectLittle[i], rst.s_addr);
845 #else
846 EXPECT_EQ(expectBig[i], rst.s_addr);
847 #endif
848 printf("inet_pton %s: un[%u],s[%d],hex[%x]\n", cpAddrs[i], rst.s_addr, rst.s_addr, rst.s_addr);
849 }
850 }
851
852 /**
853 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1000
854 * @tc.name : test inet_pton IPv4 abnormal
855 * @tc.desc : [C- SOFTWARE -0200]
856 */
857 HWTEST_F(ActsLwipTest, testInetPtonIpv4Abnormal, Function | MediumTest | Level2)
858 {
859 int ret;
860 struct in_addr rst = {0};
861 char cpAddrs[6][16] = {"256.0.0.1", "a.a.a.a", "....", "#", "127.0.0.f", "0:0:0:0:0:0:0:1"};
862 for (int i = 0; i < 6; i++) {
863 ret = inet_pton(AF_INET, cpAddrs[i], &rst);
864 EXPECT_EQ(0, ret) << "ErrInfo:inet_pton abnormal [" << cpAddrs[i] << "]";
865 }
866 }
867
868 /**
869 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1100
870 * @tc.name : test inet_pton IPv6 normal
871 * @tc.desc : [C- SOFTWARE -0200]
872 */
873 HWTEST_F(ActsLwipTest, testInetPtonIpv6Normal, Function | MediumTest | Level2)
874 {
875 int ret;
876 struct in6_addr rst = {0};
877 char cpAddrs[6][40] = {"fc00:0101:0011:0011:0011:0011:0011:0011", "0:0:0:0:0:0:0:0",
878 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", "::", "1::", "fc00:0011:0011:0011:0011:11:11:11"};
879 for (int i = 0; i < 6; i++) {
880 ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
881 EXPECT_EQ(1, ret) << "ErrInfo:inet_pton [" << cpAddrs[i] << "]";
882 }
883 }
884
885 /**
886 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1200
887 * @tc.name : test inet_pton IPv6 abnormal
888 * @tc.desc : [C- SOFTWARE -0200]
889 */
890 HWTEST_F(ActsLwipTest, testInetPtonIpv6Abnormal, Function | MediumTest | Level2)
891 {
892 int ret;
893 struct in6_addr rst = {0};
894 char cpAddrs[7][40] = {"127.0.0.1", "f", ":", "0:0", "1:::", ":::::::",
895 "1111:1111:1111:1111:1111:1111:1111:111G"};
896 for (int i = 0; i < 7; i++) {
897 ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
898 EXPECT_EQ(0, ret) << "ErrInfo:inet_pton abnormal [" << cpAddrs[i] << "]";
899 }
900 }
901
902 /**
903 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1300
904 * @tc.name : test inet_pton with invalid family
905 * @tc.desc : [C- SOFTWARE -0200]
906 */
907 HWTEST_F(ActsLwipTest, testInetPtonInvalidFamily, Function | MediumTest | Level2)
908 {
909 struct in_addr rst = {0};
910 int ret = inet_pton(AF_IPX, "127.0.0.1", &rst);
911 EXPECT_EQ(-1, ret);
912 ret = inet_pton(-1, "127.0.0.1", &rst);
913 EXPECT_EQ(-1, ret);
914 }
915
916 /**
917 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1400
918 * @tc.name : test inet_ntop IPv4 normal
919 * @tc.desc : [C- SOFTWARE -0200]
920 */
921 HWTEST_F(ActsLwipTest, testInetNtopIpv4Normal, Function | MediumTest | Level2)
922 {
923 const char* ret = nullptr;
924 struct in_addr inputAddr = {0};
925 char rstBuff[INET_ADDRSTRLEN];
926 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
927 unsigned int inputLittle[4] = {0x64d43a0a, 0, 255, 4294967295};
928 #else
929 unsigned int inputBig[4] = {171627620, 0, 4278190080, 4294967295};
930 #endif
931
932 char expectAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"};
933 for (int i = 0; i < 4; i++) {
934 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
935 inputAddr.s_addr = inputLittle[i];
936 #else
937 inputAddr.s_addr = inputBig[i];
938 #endif
939 ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
940 ASSERT_NE(ret, nullptr);
941 printf("inet_ntop expect [%s]: ret[%s], buf[%s]\n", expectAddrs[i], ret, rstBuff);
942 EXPECT_STREQ(expectAddrs[i], ret);
943 EXPECT_STREQ(expectAddrs[i], rstBuff);
944 }
945 }
946
947 /**
948 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1500
949 * @tc.name : test inet_ntop IPv4 boundary input
950 * @tc.desc : [C- SOFTWARE -0200]
951 */
952 HWTEST_F(ActsLwipTest, testInetNtopIpv4Abnormal, Function | MediumTest | Level2)
953 {
954 const char* ret = nullptr;
955 struct in_addr inputAddr = {0};
956 char rstBuff[INET_ADDRSTRLEN];
957 char expectStr[2][16] = {"255.255.255.255", "0.0.0.0"};
958 for (int i = 0; i < 2; i++) {
959 inputAddr.s_addr = (i == 0 ? -1 : 4294967296);
960 ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
961 ASSERT_TRUE(ret != NULL);
962 EXPECT_STREQ(expectStr[i], ret);
963 EXPECT_STREQ(expectStr[i], rstBuff);
964 }
965 }
966
967 /**
968 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1600
969 * @tc.name : test inet_ntop IPv6 normal
970 * @tc.desc : [C- SOFTWARE -0200]
971 */
972 HWTEST_F(ActsLwipTest, testInetNtopIpv6Normal, Function | MediumTest | Level2)
973 {
974 int iret;
975 const char* ret = nullptr;
976 struct in6_addr inputAddr = {0};
977 char rstBuff[INET6_ADDRSTRLEN];
978 char inputAddrs[6][40] = {"fc00:0101:0011:0011:0011:0011:0011:0011", "0:0:0:0:0:0:0:0",
979 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", "::", "1::", "fc00:0011:0011:0011:1100:11:11:11"};
980 char expectAddrs[6][40] = {"fc00:101:11:11:11:11:11:11", "::",
981 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", "1::", "fc00:11:11:11:1100:11:11:11"};
982 for (int i = 0; i < 6; i++) {
983 iret = inet_pton(AF_INET6, inputAddrs[i], &inputAddr);
984 ASSERT_EQ(1, iret);
985 ret = inet_ntop(AF_INET6, &inputAddr, rstBuff, sizeof(rstBuff));
986 if (ret == nullptr) {
987 EXPECT_TRUE(ret != NULL) << "ErrInfo:inet_ntop NULL [" << expectAddrs[i] << "]";
988 } else {
989 printf("inet_ntop expect [%s]: ret[%s], buf[%s]\n", expectAddrs[i], ret, rstBuff);
990 EXPECT_STREQ(expectAddrs[i], ret);
991 EXPECT_STREQ(expectAddrs[i], rstBuff);
992 }
993 }
994 }
995
996 /**
997 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1700
998 * @tc.name : test inet_ntop IPv6 boundary input
999 * @tc.desc : [C- SOFTWARE -0200]
1000 */
1001 HWTEST_F(ActsLwipTest, testInetNtopIpv6Abnormal, Function | MediumTest | Level2)
1002 {
1003 const char* ret = nullptr;
1004 struct in6_addr inputAddr = {0};
1005 char rstBuff[INET6_ADDRSTRLEN];
1006 char expectStr[2][40] = {"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::"};
1007 for (int i = 0; i < 2; i++) {
1008 for (int j = 0; j < 16; j++) {
1009 inputAddr.s6_addr[j] = (i == 0 ? -1 : 256);
1010 }
1011 ret = inet_ntop(AF_INET6, &inputAddr, rstBuff, sizeof(rstBuff));
1012 ASSERT_TRUE(ret != NULL);
1013 EXPECT_STREQ(expectStr[i], ret);
1014 EXPECT_STREQ(expectStr[i], rstBuff);
1015 }
1016 }
1017
1018 /**
1019 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1800
1020 * @tc.name : test inet_ntop with invalid family
1021 * @tc.desc : [C- SOFTWARE -0200]
1022 */
1023 HWTEST_F(ActsLwipTest, testInetNtopInvalidFamily, Function | MediumTest | Level2)
1024 {
1025 int iret;
1026 const char* ret = nullptr;
1027 struct in6_addr inputAddr = {0};
1028 char rstBuff[INET6_ADDRSTRLEN];
1029
1030 iret = inet_pton(AF_INET6, "1::", &inputAddr);
1031 ASSERT_EQ(1, iret);
1032 ret = inet_ntop(AF_IPX, &inputAddr, rstBuff, sizeof(rstBuff));
1033 EXPECT_TRUE(ret == NULL);
1034 ret = inet_ntop(-1, &inputAddr, rstBuff, sizeof(rstBuff));
1035 EXPECT_TRUE(ret == NULL);
1036 }
1037
1038 /**
1039 * @tc.number : SUB_COMMUNICATION_LWIP_SDK_1900
1040 * @tc.name : test invalid parameter
1041 * @tc.desc : [C- SOFTWARE -0200]
1042 */
1043 HWTEST_F(ActsLwipTest, testInvalidParameter, Function | MediumTest | Level3)
1044 {
1045 int ret;
1046 int fdFail = -1;
1047 int fdSuccess = -1;
1048
1049 fdFail = socket(0, 0, 0);
1050 EXPECT_EQ(-1, fdFail);
1051 fdSuccess = socket(AF_INET, SOCK_STREAM, 0);
1052 EXPECT_NE(-1, fdSuccess);
1053
1054 ret = ::bind(fdFail, nullptr, sizeof(struct sockaddr_in));
1055 EXPECT_EQ(-1, ret);
1056 ret = ::bind(fdSuccess, nullptr, sizeof(struct sockaddr_in));
1057 EXPECT_EQ(-1, ret);
1058
1059 ret = connect(fdFail, nullptr, sizeof(struct sockaddr));
1060 EXPECT_EQ(-1, ret);
1061 ret = connect(fdSuccess, nullptr, sizeof(struct sockaddr));
1062 EXPECT_EQ(-1, ret);
1063
1064 ret = accept(fdFail, nullptr, nullptr);
1065 EXPECT_EQ(-1, ret);
1066 ret = accept(fdSuccess, nullptr, nullptr);
1067 EXPECT_EQ(-1, ret);
1068
1069 ret = getsockname(fdFail, nullptr, nullptr);
1070 EXPECT_EQ(-1, ret);
1071 ret = getsockname(fdSuccess, nullptr, nullptr);
1072 EXPECT_EQ(-1, ret);
1073
1074 ret = getpeername(fdFail, nullptr, nullptr);
1075 EXPECT_EQ(-1, ret);
1076 ret = getpeername(fdSuccess, nullptr, nullptr);
1077 EXPECT_EQ(-1, ret);
1078
1079 ret = send(fdFail, nullptr, strlen(g_srvMsg), 0);
1080 EXPECT_EQ(-1, ret);
1081 ret = send(fdSuccess, nullptr, strlen(g_srvMsg), 0);
1082 EXPECT_EQ(-1, ret);
1083
1084 ret = sendto(fdFail, nullptr, strlen(g_srvMsg), 0, nullptr, (socklen_t)sizeof(struct sockaddr_in));
1085 EXPECT_EQ(-1, ret);
1086 ret = sendto(fdSuccess, nullptr, strlen(g_srvMsg), 0, nullptr, (socklen_t)sizeof(struct sockaddr_in));
1087 EXPECT_EQ(-1, ret);
1088
1089 ret = recv(fdFail, nullptr, strlen(g_srvMsg), 0);
1090 EXPECT_EQ(-1, ret);
1091 ret = recv(fdSuccess, nullptr, strlen(g_srvMsg), 0);
1092 EXPECT_EQ(-1, ret);
1093
1094 struct msghdr msg = {0};
1095 ret = recvmsg(fdFail, &msg, 0);
1096 EXPECT_EQ(-1, ret);
1097 ret = recvmsg(fdSuccess, &msg, 0);
1098 EXPECT_EQ(-1, ret);
1099
1100 ret = recvfrom(fdFail, nullptr, strlen(g_srvMsg), 0, nullptr, nullptr);
1101 EXPECT_EQ(-1, ret);
1102 ret = recvfrom(fdSuccess, nullptr, strlen(g_srvMsg), 0, nullptr, nullptr);
1103 EXPECT_EQ(-1, ret);
1104
1105 ret = setsockopt(fdFail, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t)sizeof(struct timeval));
1106 EXPECT_EQ(-1, ret);
1107 ret = setsockopt(fdSuccess, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t)sizeof(struct timeval));
1108 EXPECT_EQ(-1, ret);
1109 ret = getsockopt(fdFail, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t*)sizeof(struct timeval));
1110 EXPECT_EQ(-1, ret);
1111 ret = getsockopt(fdSuccess, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t*)sizeof(struct timeval));
1112 EXPECT_EQ(-1, ret);
1113
1114 ret = sendmsg(fdFail, nullptr, 0);
1115 EXPECT_EQ(-1, ret);
1116 ret = sendmsg(fdSuccess, nullptr, 0);
1117 EXPECT_EQ(-1, ret);
1118
1119 ret = listen(fdFail, 0);
1120 EXPECT_EQ(-1, ret);
1121 ret = select(fdFail, nullptr, nullptr, nullptr, nullptr);
1122 EXPECT_EQ(-1, ret);
1123
1124 ret = shutdown(fdFail, SHUT_RD);
1125 EXPECT_EQ(-1, ret);
1126 ret = shutdown(fdSuccess, -1);
1127 EXPECT_EQ(-1, ret);
1128
1129 ret = close(fdSuccess);
1130 EXPECT_EQ(0, ret);
1131 }
1132