1 /**
2 * Copyright (c) 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 "securec.h"
17 #include "gtest/gtest.h"
18 #include "log.h"
19 #include "utils.h"
20 #include <errno.h>
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <bits/ioctl.h>
24 #include <arpa/inet.h>
25 #include <netinet/tcp.h>
26 #include <netinet/in.h>
27 #include <netinet/ether.h>
28 #include <net/if.h>
29 #include <netdb.h>
30 #include <resolv.h>
31 #include <arpa/nameser.h>
32 #include <poll.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <stdio.h>
36
37 using namespace std;
38 using namespace testing::ext;
39
40 #define PROTOCOL_COUNT 36
41 #define TEST_FD_COUNT 10
42 #define STACK_PORT 2288
43 #define PEER_PORT 2288
44 #define BUF_SIZE (100)
45 static const char* g_udpMsg = "Hi, this is UDP";
46 static const char* g_srvMsg = "Hi, this is TCP server";
47 static const char* g_cliMsg = "Hello, this is TCP client";
48 static const char* g_localHost = "127.0.0.1";
49 static char g_protocolList[PROTOCOL_COUNT][11] = {
50 "ip", "icmp", "igmp", "ggp", "ipencap", "st", "tcp",
51 "egp", "pup", "udp", "hmp", "xns-idp", "rdp", "iso-tp4", "xtp", "ddp", "idpr-cmtp", "ipv6",
52 "ipv6-route", "ipv6-frag", "idrp", "rsvp", "gre", "esp", "ah", "skip", "ipv6-icmp", "ipv6-nonxt",
53 "ipv6-opts", "rspf", "vmtp", "ospf", "ipip", "encap", "pim", "raw"
54 };
55 static int g_protocolNumber[PROTOCOL_COUNT] = {
56 0, 1, 2, 3, 4, 5, 6, 8, 12, 17, 20, 22, 27, 29, 36, 37,
57 38, 41, 43, 44, 45, 46, 47, 50, 51, 57, 58, 59, 60, 73, 81, 89, 94, 98, 103, 255
58 };
59
60 static pthread_barrier_t g_barrier;
61 #define WAIT() pthread_barrier_wait(&g_barrier)
62
63 class ActsNetTest : public testing::Test {
64 protected:
65 // SetUpTestCase: Testsuit setup, run before 1st testcase
SetUpTestCase(void)66 static void SetUpTestCase(void) {}
67 // TearDownTestCase: Testsuit teardown, run after last testcase
TearDownTestCase(void)68 static void TearDownTestCase(void) {}
69 // Testcase setup
SetUp()70 virtual void SetUp() {}
71 // Testcase teardown
TearDown()72 virtual void TearDown() {}
73 };
74
75 /* return fd */
CommInitTcpServer(int port)76 static int CommInitTcpServer(int port)
77 {
78 int srvFd = socket(AF_INET, SOCK_STREAM, 0);
79 if (srvFd == -1) {
80 printf("[###]CommInitTcpServer]socket fail!\n");
81 return -1;
82 }
83 int flag = 1;
84 int ret = setsockopt(srvFd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
85 if (ret != 0) {
86 printf("[###][CommInitTcpServer]setsockopt fail, ret[%d]!\n", ret);
87 }
88 struct sockaddr_in srvAddr = {0};
89 srvAddr.sin_family = AF_INET;
90 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
91 srvAddr.sin_port = htons(port);
92 ret = ::bind(srvFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
93 if (ret != 0) {
94 printf("[###][CommInitTcpServer]::bind fail!\n");
95 close(srvFd);
96 return -1;
97 }
98 ret = listen(srvFd, 5);
99 if (ret != 0) {
100 printf("[###][CommInitTcpServer]listen fail!\n");
101 close(srvFd);
102 return -1;
103 }
104 printf("[###][CommInitTcpServer]success,Fd[%d]\n", srvFd);
105 return srvFd;
106 }
107
CommTcpClientTask(void * param)108 static void* CommTcpClientTask(void *param)
109 {
110 int* ret = (int *)malloc(sizeof(int));
111 if (ret == nullptr) {
112 printf("[---][comm client]malloc fail\n");
113 return nullptr;
114 }
115 *ret = 0;
116 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
117 if (clnFd == -1) {
118 printf("[@@@][comm client]socket fail\n");
119 *ret = -1;
120 return ret;
121 }
122 struct sockaddr_in srvAddr = {0};
123 srvAddr.sin_family = AF_INET;
124 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
125 srvAddr.sin_port = htons(PEER_PORT + 1);
126 int rst = connect(clnFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
127 if (rst != 0) {
128 printf("[@@@][comm client]connect fail\n");
129 close(clnFd);
130 *ret = -1;
131 return ret;
132 }
133 int sleepSecond = *((int *)param);
134 char dataBuf[50] = {0};
135 char sendMsgList[5][50] = {
136 "Hi, I'm client,FD:[%d]", "client:123456789abcdefg,FD:[%d]",
137 "client:!!@@##$$%%^^&&**(()),FD:[%d]", "client:(((112233445566778899))),FD:[%d]", "bye"
138 };
139 for (int i = 0; i < 4; i++) {
140 sleep(sleepSecond);
141 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
142 rst = sprintf_s(dataBuf, sizeof(dataBuf), sendMsgList[i], clnFd);
143 if (rst < 0) {
144 printf("[@@@][comm client]sprintf_s error!\n");
145 continue;
146 }
147 rst = send(clnFd, dataBuf, strlen(dataBuf), 0);
148 if (rst <= 0) {
149 *ret = -1;
150 printf("[@@@][comm client][%d]send fail\n", clnFd);
151 }
152 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
153 rst = recv(clnFd, dataBuf, sizeof(dataBuf), 0);
154 if (rst > 0) {
155 printf("[@@@][comm client][%d]recv msg[%s]\n", clnFd, dataBuf);
156 } else {
157 printf("[@@@][comm client][%d]recv no data\n", clnFd);
158 }
159 }
160 // send 'bye', finish
161 rst = send(clnFd, sendMsgList[4], strlen(sendMsgList[4]), 0);
162 if (rst <= 0) {
163 *ret = -1;
164 printf("[@@@][comm client][%d]send fail\n", clnFd);
165 }
166 rst = close(clnFd);
167 if (rst != 0) {
168 *ret = -1;
169 printf("[@@@][comm client][%d]close fd fail\n", clnFd);
170 }
171 return ret;
172 }
173
SampleTcpServerTask(void * p)174 static void* SampleTcpServerTask(void *p)
175 {
176 int srvFd = CommInitTcpServer(STACK_PORT);
177 EXPECT_NE(-1, srvFd);
178
179 WAIT();
180 struct sockaddr_in clnAddr = {0};
181 socklen_t clnAddrLen = sizeof(clnAddr);
182 int clnFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
183 printf("[tcp server]accept <%s:%d>\n", inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
184 EXPECT_NE(-1, clnFd);
185 printf("[tcp server]lsfd[%d], sfd[%d]\n", srvFd, clnFd);
186
187 struct sockaddr addr = {0};
188 socklen_t addrLen = sizeof(addr);
189 int ret = getsockname(clnFd, &addr, &addrLen);
190 printf("[tcp server]getsockname %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
191 ntohs(((struct sockaddr_in*)&addr)->sin_port));
192 EXPECT_EQ(0, ret);
193 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
194
195 ret = getpeername(clnFd, &addr, &addrLen);
196 printf("[tcp server]getpeername %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
197 ntohs(((struct sockaddr_in*)&addr)->sin_port));
198 EXPECT_EQ(0, ret);
199 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
200
201 static char buf[BUF_SIZE + 1] = {0};
202 unsigned int srvMsgLen = strlen(g_srvMsg);
203 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
204 ret = strcpy_s(buf, BUF_SIZE, g_srvMsg);
205 EXPECT_EQ(0, ret);
206 ret = send(clnFd, buf, srvMsgLen, 0);
207 printf("[tcp server]send, ret=%d\n", ret);
208 EXPECT_EQ(srvMsgLen, (unsigned int)ret);
209
210 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
211 ret = recv(clnFd, buf, sizeof(buf), 0);
212 printf("[tcp server]recv, ret=%d, msg[%s]\n", ret, buf);
213 EXPECT_EQ(strlen(g_cliMsg), (unsigned int)ret);
214
215 WAIT();
216 int len = 2;
217 struct msghdr msg = {nullptr};
218 struct iovec iov[2] = {nullptr};
219 clnAddr.sin_family = AF_INET;
220 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
221 clnAddr.sin_port = htons(PEER_PORT);
222 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
223 ret = strcpy_s(buf, BUF_SIZE, g_srvMsg);
224 EXPECT_EQ(0, ret);
225 msg.msg_name = &clnAddr;
226 msg.msg_namelen = sizeof(clnAddr);
227 msg.msg_iov = iov;
228 msg.msg_iovlen = len;
229 iov[0].iov_base = buf;
230 iov[0].iov_len = srvMsgLen;
231 iov[1].iov_base = buf;
232 iov[1].iov_len = srvMsgLen;
233 ret = sendmsg(clnFd, &msg, 0);
234 printf("[tcp server]sendmsg, ret=%d\n", ret);
235 EXPECT_EQ(len * srvMsgLen, (unsigned int)ret);
236
237 WAIT();
238 static char bufrec[BUF_SIZE + 1] = {0};
239 memset_s(bufrec, sizeof(bufrec), 0, BUF_SIZE);
240 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
241 msg.msg_name = &clnAddr;
242 msg.msg_namelen = sizeof(clnAddr);
243 msg.msg_iov = iov;
244 msg.msg_iovlen = 1;
245 iov[0].iov_base = bufrec;
246 iov[0].iov_len = sizeof(bufrec);
247 ret = recvmsg(clnFd, &msg, 0);
248 if (len * strlen(g_cliMsg) == (unsigned int)ret && ret >= 0) {
249 bufrec[ret] = 0;
250 printf("[tcp server]recvmsg on socket %d:%d, msg[%s]\n", clnFd, ret, buf);
251 } else {
252 EXPECT_TRUE(false);
253 printf("[tcp server] recvmsg on socket %d： %d\n", clnFd, ret);
254 }
255
256 ret = shutdown(clnFd, SHUT_RDWR);
257 printf("[tcp server]shutdown\n");
258 EXPECT_EQ(0, ret);
259 ret = close(clnFd);
260 EXPECT_NE(-1, ret);
261 ret = close(srvFd);
262 EXPECT_NE(-1, ret);
263 return nullptr;
264 }
265
SampleTcpClientTask(void * p)266 static void* SampleTcpClientTask(void *p)
267 {
268 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
269 printf("[tcp client]create socket\n");
270 EXPECT_NE(-1, clnFd);
271
272 WAIT();
273 struct sockaddr_in srvAddr = {0};
274 srvAddr.sin_family = AF_INET;
275 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
276 srvAddr.sin_port = htons(PEER_PORT);
277 int ret = connect(clnFd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
278 printf("[tcp client]connect %s:%d, fd[%d]\n", inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), clnFd);
279 EXPECT_EQ(0, ret);
280
281 struct sockaddr addr = {0};
282 socklen_t addrLen = sizeof(addr);
283 ret = getpeername(clnFd, &addr, &addrLen);
284 printf("[tcp client]getpeername %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
285 ntohs(((struct sockaddr_in*)&addr)->sin_port));
286 EXPECT_EQ(0, ret);
287 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
288
289 ret = getsockname(clnFd, &addr, &addrLen);
290 printf("[tcp client]getsockname %s:%d\n", inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
291 ntohs(((struct sockaddr_in*)&addr)->sin_port));
292 EXPECT_EQ(0, ret);
293 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
294
295 static char buf[BUF_SIZE + 1] = {0};
296 unsigned int cliMsgLen = strlen(g_cliMsg);
297 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
298 ret = strcpy_s(buf, BUF_SIZE, g_cliMsg);
299 EXPECT_EQ(0, ret);
300 ret = send(clnFd, buf, cliMsgLen, 0);
301 printf("[tcp client]send, ret=%d\n", ret);
302 EXPECT_EQ(cliMsgLen, (unsigned int)ret);
303
304 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
305 ret = recv(clnFd, buf, sizeof(buf), 0);
306 printf("[tcp client]recv, ret=%d, msg[%s]\n", ret, buf);
307 EXPECT_EQ(strlen(g_srvMsg), (unsigned int)ret);
308
309 WAIT();
310 int len = 2;
311 struct msghdr msg = {nullptr};
312 struct iovec iov[2] = {nullptr};
313 struct sockaddr_in clnAddr = {0};
314 clnAddr.sin_family = AF_INET;
315 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
316 clnAddr.sin_port = htons(PEER_PORT);
317 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
318 ret = strcpy_s(buf, BUF_SIZE, g_cliMsg);
319 EXPECT_EQ(0, ret);
320 msg.msg_name = &clnAddr;
321 msg.msg_namelen = sizeof(clnAddr);
322 msg.msg_iov = iov;
323 msg.msg_iovlen = len;
324 iov[0].iov_base = buf;
325 iov[0].iov_len = cliMsgLen;
326 iov[1].iov_base = buf;
327 iov[1].iov_len = cliMsgLen;
328 ret = sendmsg(clnFd, &msg, 0);
329 printf("[tcp client]sendmsg, ret=%d\n", ret);
330 EXPECT_EQ(len * cliMsgLen, (unsigned int)ret);
331
332 WAIT();
333 static char bufrec[BUF_SIZE + 1] = {0};
334 memset_s(bufrec, sizeof(bufrec), 0, BUF_SIZE);
335 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
336 msg.msg_name = &clnAddr;
337 msg.msg_namelen = sizeof(clnAddr);
338 msg.msg_iov = iov;
339 msg.msg_iovlen = 1;
340 iov[0].iov_base = bufrec;
341 iov[0].iov_len = sizeof(bufrec);
342 ret = recvmsg(clnFd, &msg, 0);
343 if (len * strlen(g_srvMsg) == (unsigned int)ret && ret >= 0) {
344 bufrec[ret] = 0;
345 printf("[tcp client]recvmsg, ret=%d, msg[%s]\n", ret, bufrec);
346 } else {
347 EXPECT_TRUE(false);
348 printf("[tcp clien]recvmsg, ret=%d\n", ret);
349 }
350
351 ret = shutdown(clnFd, SHUT_RDWR);
352 printf("[tcp client]shutdown\n");
353 EXPECT_EQ(0, ret);
354 ret = close(clnFd);
355 EXPECT_NE(-1, ret);
356 return nullptr;
357 }
358
TcpServerLoopTask(void * p)359 static void *TcpServerLoopTask(void *p)
360 {
361 int srvFd = CommInitTcpServer(STACK_PORT);
362 EXPECT_NE(-1, srvFd);
363 if (srvFd == -1)
364 {
365 LOG("CommInitTcpServer errno = %d\n", errno);
366 ADD_FAILURE();
367 }
368 int i = 0;
369 int clientFds[36];
370 struct sockaddr_in clnAddr = {0};
371 socklen_t clnAddrLen = sizeof(clnAddr);
372 while (i < 30)
373 {
374 clientFds[i] = accept(srvFd, (struct sockaddr *)&clnAddr, &clnAddrLen);
375 printf("[***---][tcp server loop]accept <%s:%d>, fd[%d]i[%d]\n", inet_ntoa(clnAddr.sin_addr),
376 ntohs(clnAddr.sin_port), clientFds[i], i);
377 EXPECT_NE(-1, clientFds[i]);
378 i++;
379 }
380
381 i--;
382 int ret;
383 while (i >= 0) {
384 ret = shutdown(clientFds[i], SHUT_RDWR);
385 EXPECT_EQ(0, ret);
386 ret = close(clientFds[i]);
387 EXPECT_NE(-1, ret) << "[***---][tcp server loop] close fd index[" << i << "]";
388 i--;
389 }
390 ret = close(srvFd);
391 EXPECT_NE(-1, ret);
392 return nullptr;
393 }
394
TcpClientOnlyConnectTask(void * p)395 static void* TcpClientOnlyConnectTask(void *p)
396 {
397 int tId = *((int *)p);
398 struct sockaddr addr = {0};
399 socklen_t addrLen = sizeof(addr);
400 struct sockaddr_in srvAddr = {0};
401 srvAddr.sin_family = AF_INET;
402 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
403 srvAddr.sin_port = htons(PEER_PORT);
404
405 int ret;
406 int index;
407 int clientFds[10];
408 for (index = 0; index < 10; index++) {
409 clientFds[index] = socket(AF_INET, SOCK_STREAM, 0);
410 printf("[------][tcp client[%d]]create socket fd[%d],index[%d]\n", tId, clientFds[index], index);
411 EXPECT_NE(-1, clientFds[index]);
412 ret = connect(clientFds[index], (struct sockaddr*)&srvAddr, sizeof(srvAddr));
413 EXPECT_EQ(0, ret);
414 if (ret != 0) {
415 break;
416 }
417
418 ret = getsockname(clientFds[index], &addr, &addrLen);
419 printf("[------][tcp client[%d]]getsockname %s:%d\n", tId, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr),
420 ntohs(((struct sockaddr_in*)&addr)->sin_port));
421 EXPECT_EQ(0, ret);
422 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
423 ret = getpeername(clientFds[index], &addr, &addrLen);
424 EXPECT_EQ(0, ret);
425 EXPECT_EQ(inet_addr(g_localHost), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
426 sleep(1);
427 }
428
429 index--;
430 for (int i = index; i >= 0; i--) {
431 ret = shutdown(clientFds[i], SHUT_RDWR);
432 EXPECT_EQ(0, ret);
433 ret = close(clientFds[i]);
434 EXPECT_NE(-1, ret) << "[------][tcp client] close fd index[" << i << "]";
435 }
436 return nullptr;
437 }
438
TcpServerForFork()439 static int TcpServerForFork()
440 {
441 int timeout = 10;
442 char dataBuf[50] = {0};
443 int srvFd = CommInitTcpServer(STACK_PORT + 1);
444 if (srvFd == -1) {
445 return -1;
446 }
447 printf("[---][server process]wait client...\n");
448 int ret = -1;
449 struct sockaddr_in clnAddr = {0};
450 socklen_t clnAddrLen = sizeof(clnAddr);
451 int cliFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
452 if (cliFd == -1) {
453 printf("[---][server process]accept fail!\n");
454 goto FINALLY;
455 }
456 while (timeout > 0) {
457 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
458 ret = recv(cliFd, dataBuf, sizeof(dataBuf), 0);
459 if (ret > 0) {
460 printf("[---][server process]recv msg[%s]\n", dataBuf);
461 if (strcmp(dataBuf, "bye") == 0) {
462 printf("[---][server process]break\n");
463 break;
464 }
465 } else {
466 printf("[---][server process]recv no data\n");
467 }
468 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
469 sprintf_s(dataBuf, sizeof(dataBuf), "server timeout:%d", timeout);
470 ret = send(cliFd, dataBuf, strlen(dataBuf), 0);
471 if (ret > 0) {
472 printf("[---][server process]send success, msg[%s]\n", dataBuf);
473 } else {
474 printf("[---][server process]send fail!\n");
475 }
476 timeout--;
477 }
478 close(cliFd);
479 printf("[---][server process]over\n");
480
481 FINALLY:
482 close(srvFd);
483 return ret;
484 }
485
SelectServerForFork(unsigned int timeoutSec)486 static int SelectServerForFork(unsigned int timeoutSec)
487 {
488 int srvFd = CommInitTcpServer(STACK_PORT + 1);
489 if (srvFd == -1) {
490 return -1;
491 }
492 int ret;
493 int cliCount = 0;
494 int maxFd = srvFd;
495 fd_set readSet;
496 char dataBuf[50] = {0};
497 int fds[TEST_FD_COUNT] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
498 fds[0] = srvFd;
499 struct timeval timev = {.tv_sec = timeoutSec, .tv_usec = 0};
500 struct sockaddr_in clnAddr = {0};
501 socklen_t clnAddrLen = sizeof(clnAddr);
502 while (1) {
503 FD_ZERO(&readSet);
504 for (int i = 0; i < TEST_FD_COUNT; i++) {
505 if (fds[i] != -1) {
506 FD_SET(fds[i], &readSet);
507 if (maxFd < fds[i]) {
508 maxFd = fds[i];
509 }
510 printf("[&&&][select process]fd info[%d:%d]\n", i, fds[i]);
511 }
512 }
513 ret = select(maxFd + 1, &readSet, nullptr, nullptr, &timev);
514 if (ret == 0) {
515 printf("[---][select process]select timeout!\n");
516 ret = -2;
517 break;
518 }
519 if (ret == -1) {
520 fprintf(stderr, "[---][select process]select fail[%s]\n", strerror(errno));
521 break;
522 }
523 if (FD_ISSET(srvFd, &readSet)) {
524 int cliFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
525 if (cliFd == -1) {
526 printf("[---][select process]accept fail!\n");
527 ret = -1;
528 break;
529 } else {
530 for (int i = 0; i < TEST_FD_COUNT; i++) {
531 if (fds[i] == -1) {
532 fds[i] = cliFd;
533 break;
534 }
535 }
536 cliCount++;
537 printf("[***][select process]accept success, cliCount[%d]\n", cliCount);
538 }
539 continue;
540 }
541 for (int i = 0; i < TEST_FD_COUNT; i++) {
542 if (fds[i] == -1) {
543 continue;
544 }
545 if (FD_ISSET(fds[i], &readSet)) {
546 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
547 int len = recv(fds[i], dataBuf, sizeof(dataBuf), 0);
548 if (len > 0) {
549 printf("[***][select process][%d]recv msg[%s]\n", fds[i], dataBuf);
550 if (strcmp(dataBuf, "bye") == 0) {
551 printf("[###][select process][%d]client bye,cliCount[%d]\n", fds[i], cliCount);
552 FD_CLR(fds[i], &readSet);
553 close(fds[i]);
554 fds[i] = -1;
555 cliCount--;
556 continue;
557 }
558 len = send(fds[i], dataBuf, strlen(dataBuf), 0);
559 if (len > 0) {
560 printf("[***][select process][%d]send success\n", fds[i]);
561 } else {
562 printf("[---][select process][%d]send fail\n", fds[i]);
563 }
564 }
565 }
566 }
567 if (cliCount == 0) {
568 ret = 0;
569 printf("[###][select process]cliCount=0, over!\n");
570 break;
571 }
572 }
573 close(srvFd);
574 return ret;
575 }
576
PollServerForFork(int timeoutSec)577 static int PollServerForFork(int timeoutSec)
578 {
579 int srvFd = CommInitTcpServer(STACK_PORT + 1);
580 if (srvFd == -1) {
581 return -1;
582 }
583 int ret;
584 int cliCount = 0;
585 int fdCount = 1;
586 char dataBuf[50] = {0};
587 struct pollfd fds[TEST_FD_COUNT];
588 fds[0].events = POLLIN | POLLPRI;
589 fds[0].fd = srvFd;
590 for (int i = 1; i < TEST_FD_COUNT; i++) {
591 fds[i].fd = -1;
592 }
593 struct sockaddr_in clnAddr = {0};
594 socklen_t clnAddrLen = sizeof(clnAddr);
595 while (1) {
596 ret = poll(fds, fdCount, timeoutSec);
597 if (ret == 0) {
598 printf("[---][poll process]poll timeout!\n");
599 ret = -2;
600 break;
601 }
602 if (ret == -1) {
603 fprintf(stderr, "[---][poll process]poll fail[%s]\n", strerror(errno));
604 break;
605 }
606 if (fds[0].revents & POLLIN) {
607 int cliFd = accept(srvFd, (struct sockaddr*)&clnAddr, &clnAddrLen);
608 if (cliFd == -1) {
609 printf("[---][poll process]accept fail!\n");
610 ret = -1;
611 break;
612 } else {
613 for (int i = 1; i < TEST_FD_COUNT; i++) {
614 if (fds[i].fd == -1) {
615 fds[i].fd = cliFd;
616 fds[i].events = POLLIN | POLLPRI;
617 break;
618 }
619 }
620 cliCount++;
621 fdCount++;
622 printf("[***][poll process]accept success, cliCount[%d]\n", cliCount);
623 }
624 continue;
625 }
626 for (int i = 0; i < TEST_FD_COUNT; i++) {
627 if (fds[i].fd == -1) {
628 continue;
629 }
630 if (fds[i].revents & POLLIN) {
631 memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf));
632 int len = recv(fds[i].fd, dataBuf, sizeof(dataBuf), 0);
633 if (len > 0) {
634 printf("[***][poll process][%d]recv msg[%s]\n", fds[i].fd, dataBuf);
635 if (strcmp(dataBuf, "bye") == 0) {
636 printf("[###][select process][%d]client bye,cliCount[%d]\n", fds[i].fd, cliCount);
637 cliCount--;
638 continue;
639 }
640 len = send(fds[i].fd, dataBuf, strlen(dataBuf), 0);
641 if (len > 0) {
642 printf("[***][poll process][%d]send success\n", fds[i].fd);
643 } else {
644 printf("[---][poll process][%d]send fail\n", fds[i].fd);
645 }
646 }
647 }
648 }
649 if (cliCount == 0) {
650 ret = 0;
651 printf("[###][poll process]cliCount=0, over!\n");
652 break;
653 }
654 }
655 for (int i = 0; i < TEST_FD_COUNT; i++) {
656 if (fds[i].fd != -1) {
657 close(fds[i].fd);
658 }
659 }
660 close(srvFd);
661 return ret;
662 }
663
664 /**
665 * @tc.number : SUB_KERNEL_NET_0100
666 * @tc.name : sample test tcp
667 * @tc.desc : [C- SOFTWARE -0200]
668 */
669 HWTEST_F(ActsNetTest, testTcpSample, Function | MediumTest | Level2)
670 {
671 pthread_t srv;
672 pthread_t cli;
673
674 int ret = pthread_barrier_init(&g_barrier, 0, 2);
675 EXPECT_EQ(0, ret);
676
677 ret = pthread_create(&srv, nullptr, SampleTcpServerTask, nullptr);
678 EXPECT_EQ(0, ret);
679 ret = pthread_create(&cli, nullptr, SampleTcpClientTask, nullptr);
680 EXPECT_EQ(0, ret);
681
682 ret = pthread_join(cli, nullptr);
683 EXPECT_EQ(0, ret);
684 ret = pthread_join(srv, nullptr);
685 EXPECT_EQ(0, ret);
686
687 ret = pthread_barrier_destroy(&g_barrier);
688 EXPECT_EQ(0, ret);
689 }
690
691 /**
692 * @tc.number : SUB_KERNEL_NET_0200
693 * @tc.name : test tcp concurrent connect
694 * @tc.desc : [C- SOFTWARE -0200]
695 */
696 HWTEST_F(ActsNetTest, testTcpConcurrentConnect, Function | MediumTest | Level2)
697 {
698 pthread_t srv;
699 int ret = pthread_create(&srv, nullptr, TcpServerLoopTask, nullptr);
700 EXPECT_EQ(0, ret);
701
702 sleep(2);
703 pthread_t cliOne;
704 int tIdOne = 1;
705 ret = pthread_create(&cliOne, nullptr, TcpClientOnlyConnectTask, &tIdOne);
706 EXPECT_EQ(0, ret);
707 pthread_t cliTwo;
708 int tIdTwo = 2;
709 ret = pthread_create(&cliTwo, nullptr, TcpClientOnlyConnectTask, &tIdTwo);
710 EXPECT_EQ(0, ret);
711 pthread_t cliThree;
712 int tIdThree = 3;
713 ret = pthread_create(&cliThree, nullptr, TcpClientOnlyConnectTask, &tIdThree);
714 EXPECT_EQ(0, ret);
715
716 ret = pthread_join(srv, nullptr);
717 EXPECT_EQ(0, ret);
718 ret = pthread_join(cliOne, nullptr);
719 EXPECT_EQ(0, ret);
720 printf("[******]testTcpConnect thread[1] finish!\n");
721 ret = pthread_join(cliTwo, nullptr);
722 EXPECT_EQ(0, ret);
723 printf("[******]testTcpConnect thread[2] finish!\n");
724 ret = pthread_join(cliThree, nullptr);
725 EXPECT_EQ(0, ret);
726 printf("[******]testTcpConnect thread[3] finish!\n");
727 }
728
729 /**
730 * @tc.number : SUB_KERNEL_NET_0300
731 * @tc.name : sample test upd
732 * @tc.desc : [C- SOFTWARE -0200]
733 */
734 HWTEST_F(ActsNetTest, testUdpSample, Function | MediumTest | Level2)
735 {
736 int len = 2;
737 char buf[BUF_SIZE + 1];
738 struct msghdr msg = {nullptr};
739 struct iovec iov[2] = {nullptr};
740 struct sockaddr_in srvAddr = {0};
741 struct sockaddr_in clnAddr = {0};
742 socklen_t clnAddrLen = sizeof(clnAddr);
743
744 int sfd = socket(AF_INET, SOCK_DGRAM, 0);
745 ASSERT_NE(-1, sfd);
746 srvAddr.sin_family = AF_INET;
747 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
748 srvAddr.sin_port = htons(STACK_PORT);
749 int ret = ::bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
750 ASSERT_EQ(0, ret);
751
752 clnAddr.sin_family = AF_INET;
753 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
754 clnAddr.sin_port = htons(PEER_PORT);
755 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
756 ret = strcpy_s(buf, BUF_SIZE, g_udpMsg);
757 EXPECT_EQ(0, ret);
758 ret = sendto(sfd, buf, strlen(g_udpMsg), 0, (struct sockaddr*)&clnAddr, (socklen_t)sizeof(clnAddr));
759 EXPECT_NE(-1, ret);
760
761 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
762 ret = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&clnAddr, &clnAddrLen);
763 EXPECT_EQ(strlen(g_udpMsg), (unsigned int)ret);
764
765 clnAddr.sin_family = AF_INET;
766 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
767 clnAddr.sin_port = htons(PEER_PORT);
768 memset_s(buf, BUF_SIZE, 0, BUF_SIZE);
769 ret = strcpy_s(buf, BUF_SIZE, g_udpMsg);
770 EXPECT_EQ(0, ret);
771 msg.msg_name = &clnAddr;
772 msg.msg_namelen = sizeof(clnAddr);
773 msg.msg_iov = iov;
774 msg.msg_iovlen = len;
775 iov[0].iov_base = buf;
776 iov[0].iov_len = strlen(g_udpMsg);
777 iov[1].iov_base = buf;
778 iov[1].iov_len = strlen(g_udpMsg);
779 ret = sendmsg(sfd, &msg, 0);
780 EXPECT_EQ(len*strlen(g_udpMsg), (unsigned int)ret);
781
782 ret = close(sfd);
783 EXPECT_NE(-1, ret);
784 }
785
786 /**
787 * @tc.number : SUB_KERNEL_NET_0400
788 * @tc.name : test inter-process network communication
789 * @tc.desc : [C- SOFTWARE -0200]
790 */
791 HWTEST_F(ActsNetTest, testInterProcessComm, Function | MediumTest | Level2)
792 {
793 pid_t pid = fork();
794 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
795 if (pid == 0) {
796 // child:tcp server
797 int exitCode = 0;
798 int ret = TcpServerForFork();
799 if (ret == -1) {
800 printf("[tcp server]run fail\n");
801 exitCode = 1;
802 }
803 exit(exitCode);
804 } else {
805 // parent:tcp client
806 sleep(2);
807 int second = 1;
808 void *ret = CommTcpClientTask(&second);
809 if (ret == nullptr) {
810 printf("[test select]CommClientTask ret is null\n");
811 EXPECT_TRUE(0);
812 } else {
813 printf("[test select]CommClientTask ret...\n");
814 int rst = *((int *)ret);
815 printf("[test select]CommClientTask ret [%d]\n", rst);
816 EXPECT_EQ(0, rst);
817 free(ret);
818 }
819 WaitProcExitedOK(pid);
820 }
821 }
822
823 /**
824 * @tc.number : SUB_KERNEL_NET_0500
825 * @tc.name : test select timeout
826 * @tc.desc : [C- SOFTWARE -0200]
827 */
828 HWTEST_F(ActsNetTest, testSelectTimeout, Function | MediumTest | Level2)
829 {
830 pid_t pid = fork();
831 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
832 if (pid == 0) {
833 // child: server
834 int ret = SelectServerForFork(2);
835 if (ret == -2) {
836 exit(0);
837 } else {
838 printf("[select server]fail, ret is[%d]\n", ret);
839 exit(1);
840 }
841 } else {
842 WaitProcExitedOK(pid);
843 }
844 }
845
846 /**
847 * @tc.number : SUB_KERNEL_NET_0510
848 * @tc.name : test select with one client
849 * @tc.desc : [C- SOFTWARE -0200]
850 */
851 HWTEST_F(ActsNetTest, testSelectOneClient, Function | MediumTest | Level2)
852 {
853 pid_t pid = fork();
854 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
855 if (pid == 0) {
856 // child: server
857 int exitCode = 0;
858 int ret = SelectServerForFork(5);
859 if (ret != 0) {
860 printf("[###][select server]run fail\n");
861 exitCode = 1;
862 }
863 printf("[###][select server]ret[%d]\n", ret);
864 exit(exitCode);
865 } else {
866 // parent: client
867 sleep(2);
868 int second = 1;
869 void* ret = CommTcpClientTask(&second);
870 if (ret == nullptr) {
871 printf("[###][test select]CommClientTask ret is null\n");
872 EXPECT_TRUE(0);
873 } else {
874 int rst = *((int *)ret);
875 printf("[###][test select]CommClientTask ret [%d]\n", rst);
876 EXPECT_EQ(0, rst);
877 free(ret);
878 }
879 WaitProcExitedOK(pid);
880 }
881 }
882
883 /**
884 * @tc.number : SUB_KERNEL_NET_0520
885 * @tc.name : test select with multi clients
886 * @tc.desc : [C- SOFTWARE -0200]
887 */
888 HWTEST_F(ActsNetTest, testSelectMultiClients, Function | MediumTest | Level2)
889 {
890 pid_t pid = fork();
891 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
892 if (pid == 0) {
893 // child: server
894 int exitCode = 0;
895 int ret = SelectServerForFork(5);
896 if (ret != 0) {
897 printf("[###][select server]run fail\n");
898 exitCode = 1;
899 }
900 printf("[###][select server]ret[%d]\n", ret);
901 exit(exitCode);
902 } else {
903 // parent: client
904 sleep(2);
905 int ret;
906 pthread_t pCli[4];
907 int pEroId[4] = {0};
908 int interval[4] = {2, 1, 3, 1};
909 for (int i = 0; i < 4; i++) {
910 ret = pthread_create(&pCli[i], nullptr, CommTcpClientTask, &interval[i]);
911 if (ret == -1) {
912 pEroId[i] = -1;
913 } else {
914 EXPECT_EQ(0, ret) << "Errinfo:pthread_create index is [" << i << "]";
915 }
916 }
917
918 void* rst = nullptr;
919 for (int i = 0; i < 4; i++)
920 {
921 if (pEroId[i] == 0)
922 {
923 ret = pthread_join(pCli[i], &rst);
924 EXPECT_EQ(0, ret) << "Errinfo:pthread_join index is [" << i << "]";
925 if (rst != nullptr)
926 {
927 printf("[###][test select]client thread[%d] return[%d]\n", i, *((int *)rst));
928 EXPECT_EQ(0, *((int *)rst));
929 free(rst);
930 }
931 }
932 }
933 WaitProcExitedOK(pid);
934 }
935 }
936
937 /**
938 * @tc.number : SUB_KERNEL_NET_0600
939 * @tc.name : test poll timeout
940 * @tc.desc : [C- SOFTWARE -0200]
941 */
942 HWTEST_F(ActsNetTest, testPollTimeout, Function | MediumTest | Level2)
943 {
944 pid_t pid = fork();
945 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
946 if (pid == 0) {
947 // child: server
948 int ret = PollServerForFork(2000);
949 if (ret == -2) {
950 exit(0);
951 } else {
952 printf("[###][poll server]fail, ret is[%d]\n", ret);
953 exit(1);
954 }
955 } else {
956 WaitProcExitedOK(pid);
957 }
958 }
959
960 /**
961 * @tc.number : SUB_KERNEL_NET_0610
962 * @tc.name : test poll with one client
963 * @tc.desc : [C- SOFTWARE -0200]
964 */
965 HWTEST_F(ActsNetTest, testPollOneClient, Function | MediumTest | Level2)
966 {
967 pid_t pid = fork();
968 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
969 if (pid == 0) {
970 // child: server
971 int exitCode = 0;
972 int ret = PollServerForFork(5000);
973 if (ret != 0) {
974 printf("[###][poll server]run fail\n");
975 exitCode = 1;
976 }
977 printf("[###][poll server]ret[%d]\n", ret);
978 exit(exitCode);
979 } else {
980 // parent: client
981 sleep(2);
982 int second = 1;
983 void* ret = CommTcpClientTask(&second);
984 if (ret == nullptr) {
985 printf("[###][test poll]CommClientTask ret is null\n");
986 EXPECT_TRUE(0);
987 } else {
988 int rst = *((int *)ret);
989 printf("[###][test poll]CommClientTask ret [%d]\n", rst);
990 EXPECT_EQ(0, rst);
991 free(ret);
992 }
993 WaitProcExitedOK(pid);
994 }
995 }
996
997 /**
998 * @tc.number : SUB_KERNEL_NET_0620
999 * @tc.name : test poll with multi clients
1000 * @tc.desc : [C- SOFTWARE -0200]
1001 */
1002 HWTEST_F(ActsNetTest, testPollMultiClients, Function | MediumTest | Level2)
1003 {
1004 pid_t pid = fork();
1005 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
1006 if (pid == 0) {
1007 // child: server
1008 int exitCode = 0;
1009 int ret = PollServerForFork(5000);
1010 if (ret != 0) {
1011 printf("[###][poll server]run fail\n");
1012 exitCode = 1;
1013 }
1014 printf("[###][poll server]ret[%d]\n", ret);
1015 exit(exitCode);
1016 } else {
1017 // parent: client
1018 sleep(2);
1019 int ret;
1020 pthread_t pCli[6];
1021 int pEroId[6] = {0};
1022 int interval[6] = {2, 1, 3, 1, 2, 1};
1023 for (int i = 0; i < 6; i++)
1024 {
1025 ret = pthread_create(&pCli[i], nullptr, CommTcpClientTask, &interval[i]);
1026 if (ret == -1)
1027 {
1028 pEroId[i] = -1;
1029 }
1030 else
1031 {
1032 EXPECT_EQ(0, ret) << "Errinfo:pthread_create index is [" << i << "]";
1033 }
1034 }
1035
1036 void* rst = nullptr;
1037 for (int i = 0; i < 6; i++)
1038 {
1039 if (pEroId[i] == 0)
1040 {
1041 ret = pthread_join(pCli[i], &rst);
1042 EXPECT_EQ(0, ret) << "Errinfo:pthread_join index is [" << i << "]";
1043 if (rst != nullptr)
1044 {
1045 printf("[###][test poll]client thread[%d] return[%d]\n", i, *((int *)rst));
1046 EXPECT_EQ(0, *((int *)rst));
1047 free(rst);
1048 }
1049 }
1050 }
1051 WaitProcExitedOK(pid);
1052 }
1053 }
1054
1055 /**
1056 * @tc.number : SUB_KERNEL_NET_0700
1057 * @tc.name : test ioctl SIOCGIFCONF
1058 * @tc.desc : [C- SOFTWARE -0200]
1059 */
1060 HWTEST_F(ActsNetTest, testIoctlIfconf, Function | MediumTest | Level2)
1061 {
1062 int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
1063 ASSERT_NE(-1, udpFd);
1064
1065 struct ifreq ifr[5];
1066 struct ifconf ifc = {0};
1067 memset_s(&ifc, sizeof(struct ifconf), 0, sizeof(struct ifconf));
1068 ifc.ifc_len = 5 * sizeof(struct ifreq);
1069 ifc.ifc_buf = (char *)ifr;
1070 int ret = ioctl(udpFd, SIOCGIFCONF, (char *)&ifc);
1071 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFCONF], errinfo[" << strerror(errno) << "]";
1072 int ifrCount = ifc.ifc_len / sizeof(struct ifreq);
1073 EXPECT_TRUE(ifrCount >= 2);
1074 for (int i = 0; i < ifrCount; i++) {
1075 printf("[###]interface name is %s\n", ifr[i].ifr_name);
1076 }
1077 ret = close(udpFd);
1078 EXPECT_EQ(0, ret);
1079 }
1080
1081 /**
1082 * @tc.number : SUB_KERNEL_NET_0710
1083 * @tc.name : test ioctl get set delete IFADDR,FIONREAD, localhost
1084 * @tc.desc : [C- SOFTWARE -0200]
1085 */
1086 HWTEST_F(ActsNetTest, testIoctlIfnetAddrLocal, Function | MediumTest | Level2)
1087 {
1088 int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
1089 ASSERT_NE(-1, udpFd);
1090
1091 // get ifnet address
1092 struct ifreq ifr = {0};
1093 const char *deviceLo = "lo";
1094 int ret = strcpy_s(ifr.ifr_name, sizeof(ifr.ifr_name), deviceLo);
1095 EXPECT_EQ(0, ret) << "strcpy_s fail!";
1096 ret = ioctl(udpFd, SIOCGIFADDR, &ifr);
1097 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFADDR], errinfo[" << strerror(errno) << "]";
1098 struct sockaddr_in *srvAddr = (struct sockaddr_in *)&ifr.ifr_addr;
1099 EXPECT_STREQ(g_localHost, inet_ntoa(srvAddr->sin_addr));
1100 srvAddr->sin_family = AF_INET;
1101 srvAddr->sin_port = htons(STACK_PORT);
1102
1103 // get read buffer bytes
1104 ret = ::bind(udpFd, (struct sockaddr*)srvAddr, sizeof(sockaddr_in));
1105 struct sockaddr_in clnAddr = {0};
1106 clnAddr.sin_family = AF_INET;
1107 clnAddr.sin_port = htons(PEER_PORT);
1108 clnAddr.sin_addr.s_addr = inet_addr(g_localHost);
1109 const char *msg = "Hi, test ioctl...";
1110 unsigned int msgLen = strlen(msg);
1111 ret = sendto(udpFd, msg, msgLen, 0, (struct sockaddr*)&clnAddr, (socklen_t)sizeof(clnAddr));
1112 EXPECT_NE(-1, ret);
1113 EXPECT_EQ(msgLen, (unsigned int)ret);
1114 int bytes;
1115 ret = ioctl(udpFd, FIONREAD, &bytes);
1116 EXPECT_EQ(0, ret) << "ioctl fail[FIONREAD], errinfo[" << strerror(errno) << "]";
1117 EXPECT_EQ(msgLen, (unsigned int)bytes);
1118
1119 // delete lo address, will fail
1120 ret = ioctl(udpFd, SIOCDIFADDR, &ifr);
1121 EXPECT_EQ(-1, ret);
1122 EXPECT_STREQ("Operation not permitted", strerror(errno));
1123 // set lo address, will fail
1124 srvAddr->sin_addr.s_addr = inet_addr(g_localHost);
1125 ret = ioctl(udpFd, SIOCSIFADDR, &ifr);
1126 EXPECT_STREQ("Operation not permitted", strerror(errno));
1127
1128 ret = close(udpFd);
1129 EXPECT_EQ(0, ret);
1130 }
1131
1132 /**
1133 * @tc.number : SUB_KERNEL_NET_0720
1134 * @tc.name : test ioctl get and set IFADDR others
1135 * @tc.desc : [C- SOFTWARE -0200]
1136 */
1137 HWTEST_F(ActsNetTest, testIoctlIfnetAddrOthers, Function | MediumTest | Level2)
1138 {
1139 int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
1140 ASSERT_NE(-1, udpFd);
1141
1142 struct ifreq ifr[5];
1143 struct ifconf ifc = {0};
1144 memset_s(&ifc, sizeof(struct ifconf), 0, sizeof(struct ifconf));
1145 ifc.ifc_len = 5 * sizeof(struct ifreq);
1146 ifc.ifc_buf = (char *)ifr;
1147 int ret = ioctl(udpFd, SIOCGIFCONF, (char *)&ifc);
1148 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFCONF], errinfo[" << strerror(errno) << "]";
1149
1150 struct ifreq ifrTmp = {0};
1151 struct sockaddr_in *addr1 = nullptr;
1152 struct sockaddr_in *addr2 = nullptr;
1153 int ifrCount = ifc.ifc_len / sizeof(struct ifreq);
1154 EXPECT_TRUE(ifrCount >= 2);
1155 for (int i = 0; i < ifrCount; i++) {
1156 addr1 = (struct sockaddr_in *)&ifr[i].ifr_addr;
1157 if (strcmp("lo", ifr[i].ifr_name) != 0) {
1158 // get inet addr
1159 memset_s(&ifrTmp, sizeof(struct ifreq), 0, sizeof(struct ifreq));
1160 ret = strcpy_s(ifrTmp.ifr_name, sizeof(ifrTmp.ifr_name), ifr[i].ifr_name);
1161 ret = ioctl(udpFd, SIOCGIFADDR, &ifrTmp);
1162 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFADDR], errinfo[" << strerror(errno) << "]";
1163 addr2 = (struct sockaddr_in *)&ifrTmp.ifr_addr;
1164 EXPECT_EQ(addr1->sin_addr.s_addr, addr2->sin_addr.s_addr);
1165 printf("[###]get %s\n", ifr[i].ifr_name);
1166
1167 // set inet addr
1168 addr2->sin_addr.s_addr = addr1->sin_addr.s_addr;
1169 ret = ioctl(udpFd, SIOCSIFADDR, &ifrTmp);
1170 if (strcmp("0.0.0.0", inet_ntoa(addr1->sin_addr)) == 0) {
1171 // can't set 0.0.0.0
1172 EXPECT_NE(0, ret) << "ioctl[0.0.0.0] fail[SIOCSIFADDR], errinfo[" << strerror(errno) << "]";
1173 } else {
1174 EXPECT_EQ(0, ret) << "ioctl fail[SIOCSIFADDR], errinfo[" << strerror(errno) << "]";
1175 }
1176 // get again
1177 ret = ioctl(udpFd, SIOCGIFADDR, &ifrTmp);
1178 EXPECT_EQ(0, ret) << "ioctl fail[SIOCGIFADDR], errinfo[" << strerror(errno) << "]";
1179 EXPECT_EQ(addr1->sin_addr.s_addr, addr2->sin_addr.s_addr);
1180 }
1181 }
1182 ret = close(udpFd);
1183 EXPECT_EQ(0, ret);
1184 }
1185
1186 /**
1187 * @tc.number : SUB_KERNEL_NET_0730
1188 * @tc.name : test ioctl get and set IFHWADDR
1189 * @tc.desc : [C- SOFTWARE -0200]
1190 */
1191 HWTEST_F(ActsNetTest, testIoctlIfhwAddr, Function | MediumTest | Level2)
1192 {
1193 int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
1194 ASSERT_NE(-1, udpFd);
1195
1196 struct ifreq ifr[5];
1197 struct ifconf ifc = {0};
1198 memset_s(&ifc, sizeof(struct ifconf), 0, sizeof(struct ifconf));
1199 ifc.ifc_len = 5 * sizeof(struct ifreq);
1200 ifc.ifc_buf = (char *)ifr;
1201 int ret = ioctl(udpFd, SIOCGIFCONF, (char *)&ifc);
1202 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFCONF], errinfo[" << strerror(errno) << "]";
1203
1204 char rst1[18];
1205 char rst2[18];
1206 char* macPtr = nullptr;
1207 struct ifreq ifrTmp = {0};
1208 struct sockaddr_in *addr = nullptr;
1209 int ifrCount = ifc.ifc_len / sizeof(struct ifreq);
1210 EXPECT_TRUE(ifrCount >= 2);
1211 for (int i = 0; i < ifrCount; i++) {
1212 addr = (struct sockaddr_in *)&ifr[i].ifr_addr;
1213 if (strcmp("lo", ifr[i].ifr_name) != 0) {
1214 // get ifhwaddr
1215 memset_s(&ifrTmp, sizeof(struct ifreq), 0, sizeof(struct ifreq));
1216 ret = strcpy_s(ifrTmp.ifr_name, sizeof(ifrTmp.ifr_name), ifr[i].ifr_name);
1217 EXPECT_EQ(0, ret) << "strcpy_s error";
1218 ret = ioctl(udpFd, SIOCGIFHWADDR, &ifrTmp);
1219 ASSERT_EQ(0, ret) << "ioctl fail[SIOCGIFHWADDR], errinfo[" << strerror(errno) << "]";
1220 macPtr = ifrTmp.ifr_hwaddr.sa_data;
1221 ret = sprintf_s(rst1, sizeof(rst1), "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", *macPtr, *(macPtr+1),
1222 *(macPtr+2), *(macPtr+3), *(macPtr+4), *(macPtr+5));
1223 EXPECT_EQ(strlen(rst1), (unsigned int)ret) << "sprintf_s error";
1224 printf("[###]get %s \n", ifrTmp.ifr_name);
1225 }
1226 }
1227 ret = close(udpFd);
1228 EXPECT_EQ(0, ret);
1229 }
1230
1231 /**
1232 * @tc.number : SUB_KERNEL_NET_1000
1233 * @tc.name : test socket operation
1234 * @tc.desc : [C- SOFTWARE -0200]
1235 */
1236 HWTEST_F(ActsNetTest, testSocketOpt, Function | MediumTest | Level2)
1237 {
1238 socklen_t len;
1239 struct timeval timeout = {0};
1240 int fd = socket(AF_INET, SOCK_STREAM, 0);
1241 EXPECT_NE(-1, fd);
1242
1243 int error = -1;
1244 len = sizeof(error);
1245 int ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
1246 EXPECT_EQ(0, ret);
1247 EXPECT_EQ(0, error);
1248
1249 len = sizeof(timeout);
1250 ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
1251 EXPECT_EQ(0, ret);
1252
1253 timeout.tv_sec = 1000;
1254 len = sizeof(timeout);
1255 ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, len);
1256 EXPECT_EQ(0, ret);
1257
1258 memset_s(&timeout, len, 0, len);
1259 ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
1260 EXPECT_EQ(0, ret);
1261 EXPECT_EQ(1000, timeout.tv_sec);
1262
1263 int flag = 1;
1264 ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
1265 EXPECT_EQ(0, ret);
1266
1267 flag = 0;
1268 len = sizeof(flag);
1269 ret = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, &len);
1270 EXPECT_EQ(0, ret);
1271 EXPECT_EQ(1, flag);
1272
1273 error = -1;
1274 len = sizeof(error);
1275 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
1276 EXPECT_EQ(0, ret);
1277 EXPECT_EQ(0, error);
1278
1279 ret = close(fd);
1280 EXPECT_EQ(0, ret);
1281 }
1282
1283 /**
1284 * @tc.number : SUB_KERNEL_NET_1100
1285 * @tc.name : test getsockname and getpeername invalid input
1286 * @tc.desc : [C- SOFTWARE -0200]
1287 */
1288 HWTEST_F(ActsNetTest, testGetSocketNameInvalidInput, Function | MediumTest | Level3)
1289 {
1290 struct sockaddr addr = {0};
1291 socklen_t addrLen = sizeof(addr);
1292 int ret = getsockname(-1, &addr, &addrLen);
1293 EXPECT_EQ(-1, ret);
1294 ret = getpeername(-1, &addr, &addrLen);
1295 EXPECT_EQ(-1, ret);
1296 ret = getsockname(0, &addr, &addrLen);
1297 EXPECT_EQ(-1, ret);
1298 ret = getpeername(0, &addr, &addrLen);
1299 EXPECT_EQ(-1, ret);
1300 ret = getsockname(1, &addr, &addrLen);
1301 EXPECT_EQ(-1, ret);
1302 ret = getpeername(1, &addr, &addrLen);
1303 EXPECT_EQ(-1, ret);
1304 ret = getsockname(130, &addr, &addrLen);
1305 EXPECT_EQ(-1, ret);
1306 ret = getpeername(130, &addr, &addrLen);
1307 EXPECT_EQ(-1, ret);
1308 ret = getsockname(10, nullptr, &addrLen);
1309 EXPECT_EQ(-1, ret);
1310 ret = getpeername(10, nullptr, &addrLen);
1311 EXPECT_EQ(-1, ret);
1312 ret = getsockname(10, &addr, nullptr);
1313 EXPECT_EQ(-1, ret);
1314 ret = getpeername(10, &addr, nullptr);
1315 EXPECT_EQ(-1, ret);
1316 }
1317
1318 /**
1319 * @tc.number : SUB_KERNEL_NET_1200
1320 * @tc.name : test domain name compress and expand normally
1321 * @tc.desc : [C- SOFTWARE -0200]
1322 */
1323 HWTEST_F(ActsNetTest, testDnCompExpandNormal, Function | MediumTest | Level2)
1324 {
1325 const char* domain1 = "www.testohos.com";
1326 unsigned char buf[MAXDNAME] = {0};
1327 unsigned char* bufPtr = buf;
1328 int ret = dn_comp(domain1, bufPtr, MAXDNAME, nullptr, nullptr);
1329 EXPECT_NE(-1, ret) << "dn_comp fail, buf is '" << buf << "'";
1330 int len = ret + 4;
1331
1332 char expandDn[MAXDNAME];
1333 unsigned char* eomorig = buf + MAXDNAME;
1334 ret = dn_expand(buf, eomorig, buf, expandDn, MAXDNAME);
1335 EXPECT_NE(-1, ret);
1336 EXPECT_STREQ(domain1, expandDn);
1337 printf("dn_expand ret=%d, expandDn is '%s'\n", ret, expandDn);
1338
1339 const char* domain2 = "www.baidu.com";
1340 unsigned char* dnptrs[5] = {bufPtr, nullptr};
1341 unsigned char** lastdnptr = dnptrs + 5;
1342 ret = dn_comp(domain2, bufPtr + len, MAXDNAME - len, dnptrs, lastdnptr);
1343 EXPECT_NE(-1, ret) << "dn_comp(with dnptrs) fail, buf+len is '" << bufPtr + len << "'";
1344
1345 char expandDnWithDnptrs[MAXDNAME];
1346 unsigned char* eomorigWithDnptrs = buf + MAXDNAME;
1347 ret = dn_expand(dnptrs[1], eomorigWithDnptrs, dnptrs[1], expandDnWithDnptrs, MAXDNAME);
1348 EXPECT_NE(-1, ret);
1349 EXPECT_STREQ(domain2, expandDnWithDnptrs);
1350 }
1351
1352 /**
1353 * @tc.number : SUB_KERNEL_NET_1300
1354 * @tc.name : test domain name compress and expand abnormally
1355 * @tc.desc : [C- SOFTWARE -0200]
1356 */
1357 HWTEST_F(ActsNetTest, testDnCompExpandAbnormal, Function | MediumTest | Level3)
1358 {
1359 const char* src = "!#%^.)(-+{}\r\n";
1360 unsigned char destComp[MAXDNAME];
1361 int ret = dn_comp(src, destComp, 10, nullptr, nullptr);
1362 EXPECT_EQ(-1, ret);
1363 printf("dn_comp ret=%d, compDn is '%s'\n", ret, destComp);
1364
1365 ret = dn_comp("www.baidu.com", destComp, MAXDNAME, nullptr, nullptr);
1366 EXPECT_NE(-1, ret);
1367
1368 // dest array too small
1369 char destExpand[5];
1370 unsigned char *eomorig = destComp + 10;
1371 ret = dn_expand(destComp, eomorig, destComp, destExpand, MAXDNAME);
1372 EXPECT_EQ(-1, ret);
1373 printf("dn_expand ret=%d, expandDn is '%s'\n", ret, destExpand);
1374
1375 // compress info is 0
1376 unsigned char destCompError[20] = {0};
1377 eomorig = destCompError + 20;
1378 ret = dn_expand(destCompError, eomorig, destCompError, destExpand, MAXDNAME);
1379 EXPECT_EQ(1, ret);
1380 printf("dn_expand ret=%d, expandDn is '%s'\n", ret, destExpand);
1381 }
1382
1383 /**
1384 * @tc.number : SUB_KERNEL_NET_1400
1385 * @tc.name : test convert 48 bit Ethernet host address normally
1386 * @tc.desc : [C- SOFTWARE -0200]
1387 */
1388 HWTEST_F(ActsNetTest, testEtherConvertNormal, Function | MediumTest | Level2)
1389 {
1390 char atonByteRst[24];
1391 char* ntoaRst = nullptr;
1392 struct ether_addr *atonRst = nullptr;
1393 char addrHex[3][18] = {"FF:FF:FF:FF:FF:FF", "00:00:00:00:00:00", "0A:1B:2C:3D:4E:5F"};
1394 char addrByte[3][24] = {"255.255.255.255.255.255", "0.0.0.0.0.0", "10.27.44.61.78.95"};
1395 for (int i = 0; i < 3; i++) {
1396 atonRst = nullptr;
1397 atonRst = ether_aton(addrHex[i]);
1398 ASSERT_TRUE(atonRst != nullptr);
1399 int ret = sprintf_s(atonByteRst, sizeof(atonByteRst), "%u.%u.%u.%u.%u.%u",
1400 atonRst->ether_addr_octet[0], atonRst->ether_addr_octet[1],
1401 atonRst->ether_addr_octet[2], atonRst->ether_addr_octet[3],
1402 atonRst->ether_addr_octet[4], atonRst->ether_addr_octet[5]);
1403 EXPECT_STREQ(addrByte[i], atonByteRst) << "ErrInfo:result '" << atonByteRst << "',ret=" << ret;
1404
1405 ntoaRst = nullptr;
1406 ntoaRst = ether_ntoa(atonRst);
1407 EXPECT_TRUE(ntoaRst != nullptr);
1408 EXPECT_STREQ(addrHex[i], ntoaRst) << "ErrInfo:result '" << ntoaRst << "'";
1409 }
1410 }
1411
1412 /**
1413 * @tc.number : SUB_KERNEL_NET_1500
1414 * @tc.name : test convert 48 bit Ethernet host address abnormally
1415 * @tc.desc : [C- SOFTWARE -0200]
1416 */
1417 HWTEST_F(ActsNetTest, testEtherConvertAbnormal, Function | MediumTest | Level3)
1418 {
1419 char* addrError = (char *)":::F:Z:";
1420 struct ether_addr *atonRst = nullptr;
1421 atonRst = ether_aton(addrError);
1422 EXPECT_TRUE(atonRst == nullptr);
1423 }
1424
1425 /**
1426 * @tc.number : SUB_KERNEL_NET_1600
1427 * @tc.name : test thread safe convert 48 bit Ethernet host address normally
1428 * @tc.desc : [C- SOFTWARE -0200]
1429 */
1430 HWTEST_F(ActsNetTest, testEtherConvertNormalWithThreadSafe, Function | MediumTest | Level2)
1431 {
1432 int ret;
1433 char ntoaDataRst[18];
1434 char* ntoaPointRst = nullptr;
1435 struct ether_addr *atonPointRst = nullptr;
1436 struct ether_addr *atonDataRst = (ether_addr *)malloc(sizeof(ether_addr));
1437 ASSERT_TRUE(atonDataRst != nullptr);
1438 char addrHex[3][18] = {"FF:FF:FF:FF:FF:FF", "00:00:00:00:00:00", "5F:4E:2C:3D:1B:0A"};
1439 char addrByte[3][24] = {"255.255.255.255.255.255", "0.0.0.0.0.0", "95.78.44.61.27.10"};
1440 for (int i = 0; i < 3; i++) {
1441 atonPointRst = nullptr;
1442 atonPointRst = ether_aton_r(addrHex[i], atonDataRst);
1443 ASSERT_TRUE(atonPointRst != nullptr);
1444 char byteRst[24];
1445 ret = sprintf_s(byteRst, sizeof(byteRst), "%u.%u.%u.%u.%u.%u",
1446 atonDataRst->ether_addr_octet[0], atonDataRst->ether_addr_octet[1],
1447 atonDataRst->ether_addr_octet[2], atonDataRst->ether_addr_octet[3],
1448 atonDataRst->ether_addr_octet[4], atonDataRst->ether_addr_octet[5]);
1449 EXPECT_STREQ(addrByte[i], byteRst) << "ErrInfo:ether_aton_r rst[" << byteRst << "], ret[" << ret << "]";
1450 ret = sprintf_s(byteRst, sizeof(byteRst), "%u.%u.%u.%u.%u.%u",
1451 atonPointRst->ether_addr_octet[0], atonPointRst->ether_addr_octet[1],
1452 atonPointRst->ether_addr_octet[2], atonPointRst->ether_addr_octet[3],
1453 atonPointRst->ether_addr_octet[4], atonPointRst->ether_addr_octet[5]);
1454 EXPECT_STREQ(addrByte[i], byteRst) << "ErrInfo:ether_aton_r rst[" << byteRst << "], ret[" << ret << "]";
1455
1456 ntoaPointRst = nullptr;
1457 ntoaPointRst = ether_ntoa_r(atonDataRst, ntoaDataRst);
1458 EXPECT_STREQ(addrHex[i], ntoaDataRst);
1459 EXPECT_STREQ(addrHex[i], ntoaPointRst);
1460 printf("ether_ntoa_r result '%s', '%s'\n", ntoaDataRst, ntoaPointRst);
1461 }
1462
1463 free(atonDataRst);
1464 }
1465
1466 /**
1467 * @tc.number : SUB_KERNEL_NET_1700
1468 * @tc.name : test get protocals by normal name and number
1469 * @tc.desc : [C- SOFTWARE -0200]
1470 */
1471 HWTEST_F(ActsNetTest, testGetProtoByNormal, Function | MediumTest | Level2)
1472 {
1473 int number;
1474 struct protoent *protoPtr = nullptr;
1475 for (int i = 0; i < PROTOCOL_COUNT; i++) {
1476 protoPtr = getprotobyname(g_protocolList[i]);
1477 if (protoPtr == nullptr) {
1478 printf("getprotobyname is NULL! [%s]\n", g_protocolList[i]);
1479 continue;
1480 }
1481 EXPECT_STREQ(g_protocolList[i], protoPtr->p_name);
1482 number = protoPtr->p_proto;
1483
1484 protoPtr = nullptr;
1485 protoPtr = getprotobynumber(number);
1486 if (protoPtr == nullptr) {
1487 EXPECT_TRUE(protoPtr != NULL) << "ErrInfo:getprotobynumber NULL '" << g_protocolList[i] << "'";
1488 continue;
1489 }
1490 EXPECT_STREQ(g_protocolList[i], protoPtr->p_name);
1491 protoPtr = nullptr;
1492 }
1493 }
1494
1495 /**
1496 * @tc.number : SUB_KERNEL_NET_1800
1497 * @tc.name : test get protocals by invalid name and number
1498 * @tc.desc : [C- SOFTWARE -0200]
1499 */
1500 HWTEST_F(ActsNetTest, testGetProtoByAbNormal, Function | MediumTest | Level2)
1501 {
1502 struct protoent* protoPtr = nullptr;
1503 protoPtr = getprotobyname("ipv4");
1504 EXPECT_TRUE(protoPtr == NULL);
1505 protoPtr = getprotobyname("idpr-cmtp-s");
1506 EXPECT_TRUE(protoPtr == NULL);
1507 protoPtr = getprotobyname("12&^%$\n\0?><");
1508 EXPECT_TRUE(protoPtr == NULL);
1509
1510 protoPtr = getprotobynumber(-1);
1511 EXPECT_TRUE(protoPtr == NULL);
1512 protoPtr = getprotobynumber(256);
1513 EXPECT_TRUE(protoPtr == NULL);
1514 }
1515
1516 /**
1517 * @tc.number : SUB_KERNEL_NET_1900
1518 * @tc.name : test getprotoent
1519 * @tc.desc : [C- SOFTWARE -0200]
1520 */
1521 HWTEST_F(ActsNetTest, testGetProtoent, Function | MediumTest | Level2)
1522 {
1523 int index = 0;
1524 struct protoent* protoPtr = nullptr;
1525 setprotoent(0);
1526 while (index < PROTOCOL_COUNT) {
1527 protoPtr = getprotoent();
1528 if (protoPtr == NULL) {
1529 EXPECT_TRUE(protoPtr != NULL) << "ErrInfo:getprotoent NULL, index[" << index << "]";
1530 } else {
1531 EXPECT_STREQ(g_protocolList[index], protoPtr->p_name);
1532 EXPECT_EQ(g_protocolNumber[index], protoPtr->p_proto);
1533 }
1534 protoPtr = nullptr;
1535 index ++;
1536 }
1537
1538 protoPtr = getprotoent();
1539 EXPECT_TRUE(protoPtr == NULL);
1540 }
1541
1542 /**
1543 * @tc.number : SUB_KERNEL_NET_2000
1544 * @tc.name : test setprotoent
1545 * @tc.desc : [C- SOFTWARE -0200]
1546 */
1547 HWTEST_F(ActsNetTest, testSetProtoent, Function | MediumTest | Level2)
1548 {
1549 int index = 0;
1550 struct protoent* protoPtr = nullptr;
1551 setprotoent(0);
1552 while (index < PROTOCOL_COUNT) {
1553 protoPtr = getprotoent();
1554 if (protoPtr == nullptr) {
1555 EXPECT_TRUE(protoPtr != NULL) << "ErrInfo:getprotoent NULL, index[" << index << "]";
1556 } else {
1557 EXPECT_STREQ(g_protocolList[index], protoPtr->p_name);
1558 EXPECT_EQ(g_protocolNumber[index], protoPtr->p_proto);
1559 }
1560 protoPtr = nullptr;
1561 index ++;
1562 }
1563 protoPtr = getprotoent();
1564 EXPECT_TRUE(protoPtr == NULL);
1565
1566 setprotoent(0);
1567 protoPtr = nullptr;
1568 protoPtr = getprotoent();
1569 ASSERT_TRUE(protoPtr != NULL);
1570 EXPECT_STREQ(g_protocolList[0], protoPtr->p_name);
1571 EXPECT_EQ(g_protocolNumber[0], protoPtr->p_proto);
1572
1573 index = 0;
1574 protoPtr = nullptr;
1575 setprotoent(0);
1576 while (index < PROTOCOL_COUNT) {
1577 protoPtr = getprotoent();
1578 if (protoPtr == nullptr) {
1579 EXPECT_TRUE(protoPtr != NULL) << "ErrInfo:getprotoent NULL, index[" << index << "]";
1580 } else {
1581 EXPECT_STREQ(g_protocolList[index], protoPtr->p_name);
1582 EXPECT_EQ(g_protocolNumber[index], protoPtr->p_proto);
1583 }
1584 protoPtr = nullptr;
1585 index ++;
1586 }
1587 }
1588
1589 /**
1590 * @tc.number : SUB_KERNEL_NET_2100
1591 * @tc.name : test herror,no output and return value, so no check point
1592 * @tc.desc : [C- SOFTWARE -0200]
1593 */
1594 HWTEST_F(ActsNetTest, testHerror, Function | MediumTest | Level2)
1595 {
1596 const char* fileName = "/storage/test_herror";
1597 FILE* fp = freopen(fileName, "w", stderr);
1598 ASSERT_NE(nullptr, fp);
1599
1600 const char *msg = "herror msg";
1601 herror(msg);
1602 const int errorCode[5] = {HOST_NOT_FOUND, TRY_AGAIN, NO_RECOVERY, NO_DATA, NO_ADDRESS};
1603 for (int i = 0; i < 5; i++) {
1604 h_errno = errorCode[i];
1605 herror(msg);
1606 }
1607 h_errno = -1;
1608 herror(msg);
1609 h_errno = 0;
1610 herror(msg);
1611 herror(msg);
1612 fclose(stderr);
1613
1614 char buffer[256];
1615 const char* expectStr = "herror msg: Unknown errorherror msg: Host not foundherror msg: \
1616 Try againherror msg: Non-recoverable errorherror msg: Address not availableherror msg: \
1617 Address not availableherror msg: Unknown errorherror msg: Unknown errorherror msg: Unknown error";
1618 FILE* fpRead = fopen(fileName, "rb");
1619 size_t bytes = fread(buffer, 1, sizeof(buffer), fpRead);
1620 buffer[bytes] = 0;
1621 EXPECT_STREQ(expectStr, buffer);
1622
1623 int ret = fclose(fpRead);
1624 EXPECT_EQ(0, ret);
1625 ret = remove(fileName);
1626 EXPECT_EQ(0, ret);
1627 }
1628
1629 /**
1630 * @tc.number : SUB_KERNEL_NET_2200
1631 * @tc.name : test hstrerror normal
1632 * @tc.desc : [C- SOFTWARE -0200]
1633 */
1634 HWTEST_F(ActsNetTest, testHstrerrorNormal, Function | MediumTest | Level2)
1635 {
1636 const char errorMsgs[5][22] = {"Host not found", "Try again", "Non-recoverable error", "Address not available",
1637 "Address not available"};
1638 const int errorCode[5] = {HOST_NOT_FOUND, TRY_AGAIN, NO_RECOVERY, NO_DATA, NO_ADDRESS};
1639 for (int i = 0; i < 5; i++) {
1640 EXPECT_STREQ(errorMsgs[i], hstrerror(errorCode[i]));
1641 }
1642 }
1643
1644 /**
1645 * @tc.number : SUB_KERNEL_NET_2300
1646 * @tc.name : test hstrerror abnormal
1647 * @tc.desc : [C- SOFTWARE -0200]
1648 */
1649 HWTEST_F(ActsNetTest, testHstrerrorAbnormal, Function | MediumTest | Level2)
1650 {
1651 const char* expectStr = "Unknown error";
1652 EXPECT_STREQ(expectStr, hstrerror(0));
1653 EXPECT_STREQ(expectStr, hstrerror(-1));
1654 EXPECT_STREQ(expectStr, hstrerror(16));
1655 }
1656
1657 /**
1658 * @tc.number : SUB_KERNEL_NET_2400
1659 * @tc.name : test convert value from host to network byte order
1660 * @tc.desc : [C- SOFTWARE -0200]
1661 */
1662 HWTEST_F(ActsNetTest, testHostToNetwork, Function | MediumTest | Level2)
1663 {
1664 uint32_t intInput1 = 0;
1665 uint32_t intRst1 = htonl(intInput1);
1666 uint32_t intInput2 = 65536;
1667 uint32_t intRst2 = htonl(intInput2);
1668
1669 uint16_t shortInput1 = 0;
1670 uint16_t shortRst1 = htons(shortInput1);
1671 uint16_t shortInput2 = 255;
1672 uint16_t shortRst2 = htons(shortInput2);
1673
1674 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1675 uint32_t expectZero = 0;
1676 uint32_t expectForIinput2 = 256;
1677 uint32_t expectForSinput2 = 65280;
1678 EXPECT_EQ(expectZero, intRst1);
1679 EXPECT_EQ(expectForIinput2, intRst2);
1680 EXPECT_EQ(expectZero, shortRst1);
1681 EXPECT_EQ(expectForSinput2, shortRst2);
1682 #else
1683 EXPECT_EQ(intInput1, intRst1);
1684 EXPECT_EQ(intInput2, intRst2);
1685 EXPECT_EQ(shortInput1, shortRst1);
1686 EXPECT_EQ(shortInput2, shortRst2);
1687 #endif
1688 }
1689
1690 /**
1691 * @tc.number : SUB_KERNEL_NET_2500
1692 * @tc.name : test convert value from network to host byte order
1693 * @tc.desc : [C- SOFTWARE -0200]
1694 */
1695 HWTEST_F(ActsNetTest, testNetworkToHost, Function | MediumTest | Level2)
1696 {
1697 uint32_t intInput1 = 0;
1698 uint32_t intRst1 = ntohl(intInput1);
1699 uint32_t intInput2 = 65536;
1700 uint32_t intRst2 = ntohl(intInput2);
1701 uint16_t shortInput1 = 0;
1702 uint16_t shortRst1 = ntohs(shortInput1);
1703 uint16_t shortInput2 = 255;
1704 uint16_t shortRst2 = ntohs(shortInput2);
1705
1706 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1707 uint32_t expectZero = 0;
1708 uint32_t expectForIinput2 = 256;
1709 uint32_t expectForSinput2 = 65280;
1710 EXPECT_EQ(expectZero, intRst1);
1711 EXPECT_EQ(expectForIinput2, intRst2);
1712 EXPECT_EQ(expectZero, shortRst1);
1713 EXPECT_EQ(expectForSinput2, shortRst2);
1714 #else
1715 EXPECT_EQ(intInput1, intRst1);
1716 EXPECT_EQ(intInput2, intRst2);
1717 EXPECT_EQ(shortInput1, shortRst1);
1718 EXPECT_EQ(shortInput2, shortRst2);
1719 #endif
1720 }
1721
1722 /**
1723 * @tc.number : SUB_KERNEL_NET_2600
1724 * @tc.name : test inet_pton IPv4 normal
1725 * @tc.desc : [C- SOFTWARE -0200]
1726 */
1727 HWTEST_F(ActsNetTest, testInetPtonIpv4Normal, Function | MediumTest | Level2)
1728 {
1729 int ret;
1730 struct in_addr rst = {0};
1731 char cpAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"};
1732 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1733 unsigned int expectLittle[4] = {1691630090, 0, 255, 4294967295};
1734 #else
1735 unsigned int expectBig[4] = {171627620, 0, 4278190080, 4294967295};
1736 #endif
1737
1738 for (int i = 0; i < 4; i++) {
1739 ret = inet_pton(AF_INET, cpAddrs[i], &rst);
1740 EXPECT_EQ(1, ret);
1741 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1742 EXPECT_EQ(expectLittle[i], rst.s_addr);
1743 #else
1744 EXPECT_EQ(expectBig[i], rst.s_addr);
1745 #endif
1746 printf("[###]inet_pton : un[%u],s[%d],hex[%x]\n", rst.s_addr, rst.s_addr, rst.s_addr);
1747 }
1748 }
1749
1750 /**
1751 * @tc.number : SUB_KERNEL_NET_2700
1752 * @tc.name : test inet_pton IPv4 abnormal
1753 * @tc.desc : [C- SOFTWARE -0200]
1754 */
1755 HWTEST_F(ActsNetTest, testInetPtonIpv4Abnormal, Function | MediumTest | Level2)
1756 {
1757 int ret;
1758 struct in_addr rst = {0};
1759 char cpAddrs[10][16] = {"255", "256", "255.0", "255.0.0", "256.0.0.1", "a.a.a.a", "....", "#",
1760 "127.0.0.f", "0:0:0:0:0:0:0:1"};
1761 for (int i = 0; i < 10; i++) {
1762 ret = inet_pton(AF_INET, cpAddrs[i], &rst);
1763 EXPECT_EQ(0, ret) << "ErrInfo:inet_pton abnormal [" << cpAddrs[i] << "]";
1764 }
1765 }
1766
1767 /**
1768 * @tc.number : SUB_KERNEL_NET_2800
1769 * @tc.name : test inet_pton IPv6 normal
1770 * @tc.desc : [C- SOFTWARE -0200]
1771 */
1772 HWTEST_F(ActsNetTest, testInetPtonIpv6Normal, Function | MediumTest | Level2)
1773 {
1774 int ret;
1775 struct in6_addr rst = {0};
1776 char cpAddrs[6][40] = {"0101:0101:0101:0101:1010:1010:1010:1010", "0:0:0:0:0:0:0:0",
1777 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", "::", "1::", "0011:0011:0011:0011:11:11:11:11"};
1778 for (int i = 0; i < 6; i++) {
1779 ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
1780 EXPECT_EQ(1, ret) << "ErrInfo:inet_pton [" << cpAddrs[i] << "]";
1781 }
1782 }
1783
1784 /**
1785 * @tc.number : SUB_KERNEL_NET_2900
1786 * @tc.name : test inet_pton IPv6 abnormal
1787 * @tc.desc : [C- SOFTWARE -0200]
1788 */
1789 HWTEST_F(ActsNetTest, testInetPtonIpv6Abnormal, Function | MediumTest | Level2)
1790 {
1791 int ret;
1792 struct in6_addr rst = {0};
1793 char cpAddrs[7][40] = {"127.0.0.1", "f", ":", "0:0", "1:::", ":::::::",
1794 "1111:1111:1111:1111:1111:1111:1111:111G"};
1795 for (int i = 0; i < 7; i++) {
1796 ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
1797 EXPECT_EQ(0, ret) << "ErrInfo:inet_pton abnormal [" << cpAddrs[i] << "]";
1798 }
1799 }
1800
1801 /**
1802 * @tc.number : SUB_KERNEL_NET_3000
1803 * @tc.name : test inet_pton with invalid family
1804 * @tc.desc : [C- SOFTWARE -0200]
1805 */
1806 HWTEST_F(ActsNetTest, testInetPtonInvalidFamily, Function | MediumTest | Level2)
1807 {
1808 struct in_addr rst = {0};
1809 int ret = inet_pton(AF_IPX, "127.0.0.1", &rst);
1810 EXPECT_EQ(-1, ret);
1811 ret = inet_pton(-1, "127.0.0.1", &rst);
1812 EXPECT_EQ(-1, ret);
1813 }
1814
1815 /**
1816 * @tc.number : SUB_KERNEL_NET_3100
1817 * @tc.name : test inet_ntop IPv4 normal
1818 * @tc.desc : [C- SOFTWARE -0200]
1819 */
1820 HWTEST_F(ActsNetTest, testInetNtopIpv4Normal, Function | MediumTest | Level2)
1821 {
1822 const char* ret = nullptr;
1823 struct in_addr inputAddr = {0};
1824 char rstBuff[INET_ADDRSTRLEN];
1825 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1826 unsigned int inputLittle[4] = {0x64d43a0a, 0, 255, 4294967295};
1827 #else
1828 unsigned int inputBig[4] = {171627620, 0, 4278190080, 4294967295};
1829 #endif
1830
1831 char expectAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"};
1832 for (int i = 0; i < 4; i++) {
1833 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1834 inputAddr.s_addr = inputLittle[i];
1835 #else
1836 inputAddr.s_addr = inputBig[i];
1837 #endif
1838 ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
1839 if (ret == nullptr) {
1840 EXPECT_TRUE(ret != NULL) << "ErrInfo:inet_ntop NULL [" << expectAddrs[i] << "]";
1841 } else {
1842 printf("[###]inet_ntop expect [%s]: ret[%s], buf[%s]\n", expectAddrs[i], ret, rstBuff);
1843 EXPECT_STREQ(expectAddrs[i], ret);
1844 EXPECT_STREQ(expectAddrs[i], rstBuff);
1845 }
1846 }
1847 }
1848
1849 /**
1850 * @tc.number : SUB_KERNEL_NET_3200
1851 * @tc.name : test inet_ntop IPv4 boundary input
1852 * @tc.desc : [C- SOFTWARE -0200]
1853 */
1854 HWTEST_F(ActsNetTest, testInetNtopIpv4Abnormal, Function | MediumTest | Level2)
1855 {
1856 const char* ret = nullptr;
1857 struct in_addr inputAddr = {0};
1858 char rstBuff[INET_ADDRSTRLEN];
1859 char expectStr[2][16] = {"255.255.255.255", "0.0.0.0"};
1860 for (int i = 0; i < 2; i++) {
1861 inputAddr.s_addr = (i == 0 ? -1 : 4294967296);
1862 ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
1863 ASSERT_TRUE(ret != NULL);
1864 EXPECT_STREQ(expectStr[i], ret);
1865 EXPECT_STREQ(expectStr[i], rstBuff);
1866 }
1867 }
1868
1869 /**
1870 * @tc.number : SUB_KERNEL_NET_3300
1871 * @tc.name : test inet_ntop IPv6 normal
1872 * @tc.desc : [C- SOFTWARE -0200]
1873 */
1874 HWTEST_F(ActsNetTest, testInetNtopIpv6Normal, Function | MediumTest | Level2)
1875 {
1876 int iret;
1877 const char* ret = nullptr;
1878 struct in6_addr inputAddr = {0};
1879 char rstBuff[INET6_ADDRSTRLEN];
1880 char inputAddrs[6][40] = {"0101:0101:0101:0101:1010:1010:1010:1010", "0:0:0:0:0:0:0:0",
1881 "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", "::", "1::", "0011:0011:0011:0011:11:11:11:11"};
1882 char expectAddrs[6][40] = {"101:101:101:101:1010:1010:1010:1010", "::",
1883 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", "1::", "11:11:11:11:11:11:11:11"};
1884 for (int i = 0; i < 6; i++) {
1885 iret = inet_pton(AF_INET6, inputAddrs[i], &inputAddr);
1886 ASSERT_EQ(1, iret);
1887 ret = inet_ntop(AF_INET6, &inputAddr, rstBuff, sizeof(rstBuff));
1888 if (ret == nullptr) {
1889 EXPECT_TRUE(ret != NULL) << "ErrInfo:inet_ntop NULL [" << expectAddrs[i] << "]";
1890 } else {
1891 printf("[###]inet_ntop expect [%s]: ret[%s], buf[%s]\n", expectAddrs[i], ret, rstBuff);
1892 EXPECT_STREQ(expectAddrs[i], ret);
1893 EXPECT_STREQ(expectAddrs[i], rstBuff);
1894 }
1895 }
1896 }
1897
1898 /**
1899 * @tc.number : SUB_KERNEL_NET_3400
1900 * @tc.name : test inet_ntop IPv6 boundary input
1901 * @tc.desc : [C- SOFTWARE -0200]
1902 */
1903 HWTEST_F(ActsNetTest, testInetNtopIpv6Abnormal, Function | MediumTest | Level2)
1904 {
1905 const char* ret = nullptr;
1906 struct in6_addr inputAddr = {0};
1907 char rstBuff[INET6_ADDRSTRLEN];
1908 char expectStr[2][40] = {"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::"};
1909 for (int i = 0; i < 2; i++) {
1910 for (int j = 0; j < 16; j++) {
1911 inputAddr.s6_addr[j] = (i == 0 ? -1 : 256);
1912 }
1913 ret = inet_ntop(AF_INET6, &inputAddr, rstBuff, sizeof(rstBuff));
1914 ASSERT_TRUE(ret != NULL);
1915 EXPECT_STREQ(expectStr[i], ret);
1916 EXPECT_STREQ(expectStr[i], rstBuff);
1917 }
1918 }
1919
1920 /**
1921 * @tc.number : SUB_KERNEL_NET_3500
1922 * @tc.name : test inet_ntop with invalid family
1923 * @tc.desc : [C- SOFTWARE -0200]
1924 */
1925 HWTEST_F(ActsNetTest, testInetNtopInvalidFamily, Function | MediumTest | Level2)
1926 {
1927 int iret;
1928 const char* ret = nullptr;
1929 struct in6_addr inputAddr = {0};
1930 char rstBuff[INET6_ADDRSTRLEN];
1931
1932 iret = inet_pton(AF_INET6, "1::", &inputAddr);
1933 ASSERT_EQ(1, iret);
1934 ret = inet_ntop(AF_IPX, &inputAddr, rstBuff, sizeof(rstBuff));
1935 EXPECT_TRUE(ret == NULL);
1936 ret = inet_ntop(-1, &inputAddr, rstBuff, sizeof(rstBuff));
1937 EXPECT_TRUE(ret == NULL);
1938 }
1939
1940 /**
1941 * @tc.number : SUB_KERNEL_NET_3600
1942 * @tc.name : test inet_addr normal
1943 * @tc.desc : [C- SOFTWARE -0200]
1944 */
1945 HWTEST_F(ActsNetTest, testInetAddrNormal, Function | MediumTest | Level2)
1946 {
1947 in_addr_t rst;
1948 char cpAddrs[7][16] = {"10.58.212.100", "0.0.0.0", "255", "0.255.0", "255.0.0.0",
1949 "255.255.255.255", "257"};
1950 unsigned int expectList[7] = {1691630090, 0, 4278190080, 65280, 255, 4294967295, 16842752};
1951 for (int i = 0; i < 7; i++) {
1952 rst = inet_addr(cpAddrs[i]);
1953 EXPECT_EQ(expectList[i], rst);
1954 printf("[###]inet_addr %s: uns[%u],s[%d],hex[%x]\n", cpAddrs[i], rst, rst, rst);
1955 }
1956 }
1957
1958 /**
1959 * @tc.number : SUB_KERNEL_NET_3700
1960 * @tc.name : test inet_addr abnormal
1961 * @tc.desc : [C- SOFTWARE -0200]
1962 */
1963 HWTEST_F(ActsNetTest, testInetAddrAbnormal, Function | MediumTest | Level2)
1964 {
1965 in_addr_t rst;
1966 unsigned int expect = 4294967295;
1967 char invalidAddrs[4][10] = {"-1", "a", "%^", "257.1.1.1"};
1968 for (int i = 0; i < 4; i++) {
1969 rst = inet_addr(invalidAddrs[i]);
1970 EXPECT_EQ(expect, rst) << "ErrInfo:inet_addr [" << invalidAddrs[i] << "]";
1971 }
1972 }
1973
1974 /**
1975 * @tc.number : SUB_KERNEL_NET_3800
1976 * @tc.name : test inet_aton normal
1977 * @tc.desc : [C- SOFTWARE -0200]
1978 */
1979 HWTEST_F(ActsNetTest, testInetAtonNormal, Function | MediumTest | Level2)
1980 {
1981 int ret;
1982 struct in_addr addr = {0};
1983 char cpAddrs[7][16] = {"10.58.212.100", "0.0.0.0", "255", "0.255.0", "255.0.0.0",
1984 "255.255.255.255", "257"};
1985 unsigned int expectList[7] = {1691630090, 0, 4278190080, 65280, 255, 4294967295, 16842752};
1986 for (int i = 0; i < 7; i++) {
1987 ret = inet_aton(cpAddrs[i], &addr);
1988 EXPECT_EQ(1, ret);
1989 EXPECT_EQ(expectList[i], addr.s_addr);
1990 printf("##inet_aton %s: uns[%u],s[%d],hex[%x]\n", cpAddrs[i], addr.s_addr, addr.s_addr, addr.s_addr);
1991 }
1992 }
1993
1994 /**
1995 * @tc.number : SUB_KERNEL_NET_3900
1996 * @tc.name : test inet_aton abnormal
1997 * @tc.desc : [C- SOFTWARE -0200]
1998 */
1999 HWTEST_F(ActsNetTest, testInetAtonAbnormal, Function | MediumTest | Level2)
2000 {
2001 int ret;
2002 struct in_addr addr = {0};
2003 char invalidAddrs[4][10] = {"-1", "a", "%^", "257.1.1.1"};
2004 for (int i = 0; i < 4; i++) {
2005 ret = inet_aton(invalidAddrs[i], &addr);
2006 EXPECT_EQ(0, ret) << "ErrInfo:inet_addr [" << invalidAddrs[i] << "]";
2007 }
2008 }
2009
2010 /**
2011 * @tc.number : SUB_KERNEL_NET_4000
2012 * @tc.name : test inet_ntoa normal
2013 * @tc.desc : [C- SOFTWARE -0200]
2014 */
2015 HWTEST_F(ActsNetTest, testInetNtoaNormal, Function | MediumTest | Level2)
2016 {
2017 char *rst = nullptr;
2018 struct in_addr addr = {0};
2019 char expectAddrs[6][16] = {"10.58.212.100", "0.0.0.0", "255.255.255.255", "0.0.0.255", "0.255.0.0", "0.0.1.1"};
2020 unsigned int inputList[6] = {1691630090, 0, 4294967295, 4278190080, 65280, 16842752};
2021 for (int i = 0; i < 6; i++) {
2022 addr.s_addr = inputList[i];
2023 rst = inet_ntoa(addr);
2024 if (rst == nullptr) {
2025 EXPECT_TRUE(rst != NULL);
2026 } else {
2027 EXPECT_STREQ(expectAddrs[i], rst);
2028 }
2029 printf("##inet_ntoa %u: rst is [%s]\n", inputList[i], expectAddrs[i]);
2030 }
2031 }
2032
2033 /**
2034 * @tc.number : SUB_KERNEL_NET_4100
2035 * @tc.name : test inet_ntoa boundary input
2036 * @tc.desc : [C- SOFTWARE -0200]
2037 */
2038 HWTEST_F(ActsNetTest, testInetNtoaAbnormal, Function | MediumTest | Level2)
2039 {
2040 const char* ret = nullptr;
2041 struct in_addr addrInput = {0};
2042 char expectStr[2][16] = {"255.255.255.255", "0.0.0.0"};
2043 for (int i = 0; i < 2; i++) {
2044 addrInput.s_addr = (i == 0 ? -1 : 4294967296);
2045 ret = inet_ntoa(addrInput);
2046 ASSERT_TRUE(ret != NULL);
2047 EXPECT_STREQ(expectStr[i], ret);
2048 }
2049 }
2050
2051 /**
2052 * @tc.number : SUB_KERNEL_NET_4200
2053 * @tc.name : test inet_network normal
2054 * @tc.desc : [C- SOFTWARE -0200]
2055 */
2056 HWTEST_F(ActsNetTest, testInetNetworkNormal, Function | MediumTest | Level2)
2057 {
2058 in_addr_t rst;
2059 char cpAddrs[7][16] = {"10.58.212.100", "0.0.0.0", "255", "0.255.0", "255.0.0.0",
2060 "255.255.255.255", "257"};
2061 unsigned int expectList[7] = {171627620, 0, 255, 16711680, 4278190080, 4294967295, 257};
2062 for (int i = 0; i < 7; i++) {
2063 rst = inet_network(cpAddrs[i]);
2064 EXPECT_EQ(expectList[i], rst);
2065 printf("##inet_network %s: uns[%u],s[%d],hex[%x]\n", cpAddrs, rst, rst, rst);
2066 }
2067 }
2068
2069 /**
2070 * @tc.number : SUB_KERNEL_NET_4300
2071 * @tc.name : test inet_network abnormal
2072 * @tc.desc : [C- SOFTWARE -0200]
2073 */
2074 HWTEST_F(ActsNetTest, testInetNetworkAbnormal, Function | MediumTest | Level2)
2075 {
2076 in_addr_t rst;
2077 unsigned int expect = 4294967295;
2078 char invalidAddrs[4][10] = {"-1", "a", "%^", "257.1.1.1"};
2079 for (int i = 0; i < 4; i++) {
2080 rst = inet_network(invalidAddrs[i]);
2081 EXPECT_EQ(expect, rst) << "ErrInfo:inet_network [" << invalidAddrs[i] << "]";
2082 }
2083 }
2084
2085 /**
2086 * @tc.number : SUB_KERNEL_NET_4400
2087 * @tc.name : test inet_lnaof normal
2088 * @tc.desc : [C- SOFTWARE -0200]
2089 */
2090 HWTEST_F(ActsNetTest, testInetLnaofNormal, Function | MediumTest | Level2)
2091 {
2092 in_addr_t rst;
2093 struct in_addr addr = {0};
2094 char cpAddrs[7][16] = {"10.58.212.100", "0.0.0.0", "255", "0.255.0", "255.0.0.0",
2095 "255.255.255.255", "257"};
2096 unsigned int expectList[7] = {13908490, 0, 0, 65280, 255, 255, 65536};
2097 for (int i = 0; i < 7; i++) {
2098 addr.s_addr = inet_network(cpAddrs[i]);
2099 rst = inet_lnaof(addr);
2100 EXPECT_EQ(expectList[i], rst);
2101 printf("[###]inet_lnaof %s: uns[%u],s[%d],hex[%x]\n", cpAddrs[i], rst, rst, rst);
2102 }
2103 }
2104
2105 /**
2106 * @tc.number : SUB_KERNEL_NET_4500
2107 * @tc.name : test inet_netof normal
2108 * @tc.desc : [C- SOFTWARE -0200]
2109 */
2110 HWTEST_F(ActsNetTest, testInetNetofNormal, Function | MediumTest | Level2)
2111 {
2112 in_addr_t rst;
2113 struct in_addr addr = {0};
2114 char cpAddrs[7][16] = {"10.58.212.100", "0.0.0.0", "255", "0.255.0", "255.0.0.0",
2115 "255.255.255.255", "257"};
2116 unsigned int expectList[7] = {100, 0, 16711680, 0, 0, 16777215, 1};
2117 for (int i = 0; i < 7; i++) {
2118 addr.s_addr = inet_network(cpAddrs[i]);
2119 rst = inet_netof(addr);
2120 EXPECT_EQ(expectList[i], rst);
2121 printf("[###]inet_netof %s: uns[%u],s[%d],hex[%x]\n", cpAddrs[i], rst, rst, rst);
2122 }
2123 }
2124
2125 /**
2126 * @tc.number : SUB_KERNEL_NET_4600
2127 * @tc.name : test inet_makeaddr normal
2128 * @tc.desc : [C- SOFTWARE -0200]
2129 */
2130 HWTEST_F(ActsNetTest, testInetMakeaddrNormal, Function | MediumTest | Level2)
2131 {
2132 struct in_addr addrRst = {0};
2133 int hostList[7] = {13908490, 0, 0, 65280, 255, 255, 65536};
2134 int netList[7] = {100, 0, 16711680, 0, 0, 16777215, 1};
2135 unsigned int expectList[7] = {171627620, 0, 255, 16711680, 4278190080, 4294967295, 257};
2136 for (int i = 0; i < 7; i++) {
2137 addrRst = inet_makeaddr(netList[i], hostList[i]);
2138 EXPECT_EQ(expectList[i], addrRst.s_addr);
2139 printf("[###]inet_makeaddr: uns[%u],s[%d],hex[%x]\n", addrRst.s_addr, addrRst.s_addr, addrRst.s_addr);
2140 }
2141 }
2142
2143 /**
2144 * @tc.number : SUB_KERNEL_NET_4700
2145 * @tc.name : test invalid parameter
2146 * @tc.desc : [C- SOFTWARE -0200]
2147 */
2148 HWTEST_F(ActsNetTest, testInvalidParameter, Function | MediumTest | Level3)
2149 {
2150 int ret;
2151 int fdFail = -1;
2152 int fdSuccess = -1;
2153
2154 fdFail = socket(0, 0, 0);
2155 EXPECT_EQ(fdFail, -1);
2156 fdSuccess = socket(AF_INET, SOCK_STREAM, 0);
2157 EXPECT_NE(fdSuccess, -1);
2158
2159 ret = ::bind(fdFail, nullptr, sizeof(struct sockaddr_in));
2160 EXPECT_EQ(-1, ret);
2161 ret = ::bind(fdSuccess, nullptr, sizeof(struct sockaddr_in));
2162 EXPECT_EQ(-1, ret);
2163
2164 ret = connect(fdFail, nullptr, sizeof(struct sockaddr));
2165 EXPECT_EQ(-1, ret);
2166 ret = connect(fdSuccess, nullptr, sizeof(struct sockaddr));
2167 EXPECT_EQ(-1, ret);
2168
2169 ret = accept(fdFail, nullptr, nullptr);
2170 EXPECT_EQ(-1, ret);
2171 ret = accept(fdSuccess, nullptr, nullptr);
2172 EXPECT_EQ(-1, ret);
2173
2174 ret = getsockname(fdFail, nullptr, nullptr);
2175 EXPECT_EQ(-1, ret);
2176 ret = getsockname(fdSuccess, nullptr, nullptr);
2177 EXPECT_EQ(-1, ret);
2178
2179 ret = getpeername(fdFail, nullptr, nullptr);
2180 EXPECT_EQ(-1, ret);
2181 ret = getpeername(fdSuccess, nullptr, nullptr);
2182 EXPECT_EQ(-1, ret);
2183
2184 ret = send(fdFail, nullptr, strlen(g_srvMsg), 0);
2185 EXPECT_EQ(-1, ret);
2186 ret = send(fdSuccess, nullptr, strlen(g_srvMsg), 0);
2187 EXPECT_EQ(-1, ret);
2188
2189 ret = sendto(fdFail, nullptr, strlen(g_srvMsg), 0, nullptr, (socklen_t)sizeof(struct sockaddr_in));
2190 EXPECT_EQ(-1, ret);
2191 ret = sendto(fdSuccess, nullptr, strlen(g_srvMsg), 0, nullptr, (socklen_t)sizeof(struct sockaddr_in));
2192 EXPECT_EQ(-1, ret);
2193
2194 ret = recv(fdFail, nullptr, sizeof(g_srvMsg), 0);
2195 EXPECT_EQ(-1, ret);
2196 ret = recv(fdSuccess, nullptr, sizeof(g_srvMsg), 0);
2197 EXPECT_EQ(-1, ret);
2198
2199 struct msghdr msg = {nullptr};
2200 ret = recvmsg(fdFail, &msg, 0);
2201 EXPECT_EQ(-1, ret);
2202 ret = recvmsg(fdSuccess, &msg, 0);
2203 EXPECT_EQ(-1, ret);
2204
2205 ret = recvfrom(fdFail, nullptr, sizeof(g_srvMsg), 0, nullptr, nullptr);
2206 EXPECT_EQ(-1, ret);
2207 ret = recvfrom(fdSuccess, nullptr, sizeof(g_srvMsg), 0, nullptr, nullptr);
2208 EXPECT_EQ(-1, ret);
2209
2210 ret = setsockopt(fdFail, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t)sizeof(struct timeval));
2211 EXPECT_EQ(-1, ret);
2212 ret = setsockopt(fdSuccess, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t)sizeof(struct timeval));
2213 EXPECT_EQ(-1, ret);
2214 ret = getsockopt(fdFail, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t*)sizeof(struct timeval));
2215 EXPECT_EQ(-1, ret);
2216 ret = getsockopt(fdSuccess, SOL_SOCKET, SO_RCVTIMEO, nullptr, (socklen_t*)sizeof(struct timeval));
2217 EXPECT_EQ(-1, ret);
2218
2219 ret = sendmsg(fdFail, nullptr, 0);
2220 EXPECT_EQ(-1, ret);
2221 ret = sendmsg(fdSuccess, nullptr, 0);
2222 EXPECT_EQ(-1, ret);
2223
2224 ret = listen(fdFail, 0);
2225 EXPECT_EQ(-1, ret);
2226 ret = select(fdFail, nullptr, nullptr, nullptr, nullptr);
2227 EXPECT_EQ(-1, ret);
2228
2229 ret = shutdown(fdFail, SHUT_RD);
2230 EXPECT_EQ(-1, ret);
2231 ret = shutdown(fdSuccess, -1);
2232 EXPECT_EQ(-1, ret);
2233
2234 ret = close(fdSuccess);
2235 EXPECT_EQ(0, ret);
2236 }
2237