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