1 /*
2 * Copyright (C) 2024 HiHope Open Source Organization.
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 <cerrno>
17 #include <cstdio>
18 #include <cstdlib>
19 #include <string>
20 #include <vector>
21 #include <fcntl.h>
22 #include <pthread.h>
23 #include <unistd.h>
24 #include <arpa/inet.h>
25 #include <gtest/gtest.h>
26 #include <netinet/in.h>
27 #include <sys/stat.h>
28 #include <sys/socket.h>
29 #include <sys/types.h>
30 #include "securec.h"
31
32 using namespace testing::ext;
33
34 static const int BAD_SOCKET_FD = -1;
35 static const int TEST_PORT = 22357;
36 static const char *TEST_LOCAL_IP = "127.0.0.1";
37 static int g_serviceFd = -1;
38 static const int TEST_DELAY_TIME = 100000;
39
40 class HatsShutdownTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 private:
47 };
SetUp()48 void HatsShutdownTest::SetUp()
49 {
50 int ret;
51 int socketFd = -1;
52 int32_t optVal = 1;
53 struct sockaddr_in serAddr = {
54 .sin_family = AF_INET,
55 .sin_port = htons(TEST_PORT),
56 .sin_addr = {
57 .s_addr = inet_addr(TEST_LOCAL_IP),
58 }
59 };
60
61 socketFd = socket(AF_INET, SOCK_STREAM, 0);
62 EXPECT_TRUE(socketFd > 0);
63
64 ret = setsockopt(socketFd, SOL_SOCKET, SO_REUSEADDR, &optVal, sizeof(optVal));
65 EXPECT_EQ(ret, 0);
66
67 ret = bind(socketFd, reinterpret_cast<struct sockaddr *>(&serAddr), sizeof(serAddr));
68 EXPECT_EQ(ret, 0);
69
70 g_serviceFd = socketFd;
71 }
TearDown()72 void HatsShutdownTest::TearDown()
73 {
74 close(g_serviceFd);
75 g_serviceFd = -1;
76 }
SetUpTestCase()77 void HatsShutdownTest::SetUpTestCase()
78 {
79 }
TearDownTestCase()80 void HatsShutdownTest::TearDownTestCase()
81 {
82 }
83
ClientConnect(void *args)84 static void *ClientConnect(void *args)
85 {
86 int ret;
87 int clientFd = -1;
88 struct sockaddr_in serAddr = {
89 .sin_family = AF_INET,
90 .sin_port = htons(TEST_PORT),
91 .sin_addr = {
92 .s_addr = inet_addr(TEST_LOCAL_IP),
93 }
94 };
95
96 clientFd = socket(AF_INET, SOCK_STREAM, 0);
97 EXPECT_TRUE(clientFd > 0);
98
99 ret = connect(clientFd, reinterpret_cast<struct sockaddr *>(&serAddr), sizeof(struct sockaddr_in));
100
101 usleep(TEST_DELAY_TIME);
102
103 close(clientFd);
104 return nullptr;
105 }
106
107 /*
108 * @tc.number : SUB_KERNEL_SYSCALL_SHUTDOWN_0100
109 * @tc.name : ShutdownSHUT_WRTestSuccess_0001
110 * @tc.desc : shutdown socket fd by SHUT_WR success.
111 * @tc.size : MediumTest
112 * @tc.type : Function
113 * @tc.level : Level 1
114 */
HWTEST_F(HatsShutdownTest, ShutdownSHUT_WRTestSuccess_0001, Function | MediumTest | Level1)115 HWTEST_F(HatsShutdownTest, ShutdownSHUT_WRTestSuccess_0001, Function | MediumTest | Level1)
116 {
117 int ret;
118 pthread_t thread;
119 int acceptFd = -1;
120 int32_t backLog = 5;
121 struct sockaddr_in dstAddr = { 0 };
122 socklen_t addrLen = sizeof(struct sockaddr_in);
123
124 ret = listen(g_serviceFd, backLog);
125 EXPECT_EQ(ret, 0);
126
127 pthread_create(&thread, nullptr, ClientConnect, nullptr);
128
129 acceptFd = accept(g_serviceFd, reinterpret_cast<struct sockaddr *>(&dstAddr), &addrLen);
130 EXPECT_TRUE(acceptFd > 0);
131 ret = shutdown(g_serviceFd, SHUT_WR);
132 EXPECT_EQ(ret, 0);
133
134 close(acceptFd);
135 pthread_join(thread, nullptr);
136 }
137
138 /*
139 * @tc.number : SUB_KERNEL_SYSCALL_SHUTDOWN_0200
140 * @tc.name : ShutdownSHUT_RDTestSuccess_0002
141 * @tc.desc : shutdown socket fd by SHUT_RD success.
142 * @tc.size : MediumTest
143 * @tc.type : Function
144 * @tc.level : Level 1
145 */
HWTEST_F(HatsShutdownTest, ShutdownSHUT_RDTestSuccess_0002, Function | MediumTest | Level1)146 HWTEST_F(HatsShutdownTest, ShutdownSHUT_RDTestSuccess_0002, Function | MediumTest | Level1)
147 {
148 int ret;
149 pthread_t thread;
150 int acceptFd = -1;
151 int32_t backLog = 5;
152 struct sockaddr_in dstAddr = { 0 };
153 socklen_t addrLen = sizeof(struct sockaddr_in);
154
155 ret = listen(g_serviceFd, backLog);
156 EXPECT_EQ(ret, 0);
157
158 pthread_create(&thread, nullptr, ClientConnect, nullptr);
159
160 acceptFd = accept(g_serviceFd, reinterpret_cast<struct sockaddr *>(&dstAddr), &addrLen);
161 EXPECT_TRUE(acceptFd > 0);
162 ret = shutdown(g_serviceFd, SHUT_RD);
163 EXPECT_EQ(ret, 0);
164
165 close(acceptFd);
166 pthread_join(thread, nullptr);
167 }
168
169 /*
170 * @tc.number : SUB_KERNEL_SYSCALL_SHUTDOWN_0300
171 * @tc.name : ShutdownSHUT_RDWRTestSuccess_0003
172 * @tc.desc : shutdown socket fd by SHUT_RDWR success.
173 * @tc.size : MediumTest
174 * @tc.type : Function
175 * @tc.level : Level 1
176 */
HWTEST_F(HatsShutdownTest, ShutdownSHUT_RDWRTestSuccess_0003, Function | MediumTest | Level1)177 HWTEST_F(HatsShutdownTest, ShutdownSHUT_RDWRTestSuccess_0003, Function | MediumTest | Level1)
178 {
179 int ret;
180 pthread_t thread;
181 int acceptFd = -1;
182 int32_t backLog = 5;
183 struct sockaddr_in dstAddr = { 0 };
184 socklen_t addrLen = sizeof(struct sockaddr_in);
185
186 ret = listen(g_serviceFd, backLog);
187 EXPECT_EQ(ret, 0);
188
189 pthread_create(&thread, nullptr, ClientConnect, nullptr);
190
191 acceptFd = accept(g_serviceFd, reinterpret_cast<struct sockaddr *>(&dstAddr), &addrLen);
192 EXPECT_TRUE(acceptFd > 0);
193
194 ret = shutdown(g_serviceFd, SHUT_RDWR);
195 EXPECT_EQ(ret, 0);
196
197 close(acceptFd);
198 pthread_join(thread, nullptr);
199 }
200
201 /*
202 * @tc.number : SUB_KERNEL_SYSCALL_SHUTDOWN_0400
203 * @tc.name : ShutdownUseInvalidFdFailed_0004
204 * @tc.desc : shutdown socket fd by invalid fd failed.
205 * @tc.size : MediumTest
206 * @tc.type : Function
207 * @tc.level : Level 2
208 */
HWTEST_F(HatsShutdownTest, ShutdownUseInvalidFdFailed_0004, Function | MediumTest | Level2)209 HWTEST_F(HatsShutdownTest, ShutdownUseInvalidFdFailed_0004, Function | MediumTest | Level2)
210 {
211 errno = 0;
212 int ret = shutdown(g_serviceFd, SHUT_RDWR);
213 EXPECT_EQ(ret, -1);
214 EXPECT_EQ(errno, ENOTCONN);
215
216 errno = 0;
217 ret = shutdown(BAD_SOCKET_FD, SHUT_RDWR);
218 EXPECT_EQ(ret, -1);
219 EXPECT_EQ(errno, EBADF);
220 }
221