1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <arpa/inet.h>
17 #include <cstdio>
18 #include <gtest/gtest.h>
19 #include <sys/socket.h>
20 #include <sys/types.h>
21
22 #define private public
23 #include "fwmark_client.h"
24 #include "fwmark_network.cpp"
25 #undef private
26 #include "net_manager_constants.h"
27 #include "netnative_log_wrapper.h"
28 #include "singleton.h"
29
30 namespace OHOS {
31 namespace NetsysNative {
32 using namespace testing::ext;
33 using namespace nmd;
34 namespace {
35 constexpr int32_t NETID_FIRST = 101;
36 constexpr int32_t NETID_SECOND = 102;
37 static constexpr const int32_t ERROR_CODE_SOCKETFD_INVALID = -1;
38 static constexpr const int32_t ERROR_CODE_CONNECT_FAILED = -2;
39 static constexpr const int32_t ERROR_CODE_SENDMSG_FAILED = -3;
40 static constexpr const int32_t ERROR_CODE_READ_FAILED = -4;
41 class ManagerNative : public std::enable_shared_from_this<ManagerNative> {
42 DECLARE_DELAYED_SINGLETON(ManagerNative);
43
44 public:
45 std::shared_ptr<FwmarkClient> GetFwmarkClient();
46
47 private:
48 std::shared_ptr<FwmarkClient> fwmarkClient_ = nullptr;
49 };
50
ManagerNative()51 ManagerNative::ManagerNative()
52 {
53 fwmarkClient_ = std::make_shared<FwmarkClient>();
54 }
55
GetFwmarkClient()56 std::shared_ptr<FwmarkClient> ManagerNative::GetFwmarkClient()
57 {
58 return fwmarkClient_;
59 }
60
~ManagerNative()61 ManagerNative::~ManagerNative() {}
62 } // namespace
63 class UnitTestFwmarkClient : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp();
68 void TearDown();
69 std::shared_ptr<FwmarkClient> fwmarkClient = DelayedSingleton<ManagerNative>::GetInstance()->GetFwmarkClient();
70 };
71
SetUpTestCase()72 void UnitTestFwmarkClient::SetUpTestCase() {}
73
TearDownTestCase()74 void UnitTestFwmarkClient::TearDownTestCase() {}
75
SetUp()76 void UnitTestFwmarkClient::SetUp() {}
77
TearDown()78 void UnitTestFwmarkClient::TearDown() {}
79
80 /**
81 * @tc.name: BindSocketTest001
82 * @tc.desc: Test FwmarkClient BindSocket.
83 * @tc.type: FUNC
84 */
85 HWTEST_F(UnitTestFwmarkClient, BindSocketTest001, TestSize.Level1)
86 {
87 int32_t udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
88 int32_t ret = fwmarkClient->BindSocket(udpSocket, NETID_FIRST);
89 NETNATIVE_LOGI("UnitTestFwmarkClient BindSocketTest001 ret=%{public}d", ret);
90 close(udpSocket);
91 udpSocket = -1;
92 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
93 }
94
95 /**
96 * @tc.name: BindSocketTest002
97 * @tc.desc: Test FwmarkClient BindSocket.
98 * @tc.type: FUNC
99 */
100 HWTEST_F(UnitTestFwmarkClient, BindSocketTest002, TestSize.Level1)
101 {
102 int32_t tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
103 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
104 NETNATIVE_LOGI("UnitTestFwmarkClient BindSocketTest002 ret=%{public}d", ret);
105 close(tcpSocket);
106 tcpSocket = -1;
107 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
108 }
109
110 /**
111 * @tc.name: BindSocketTest003
112 * @tc.desc: Test FwmarkClient BindSocket.
113 * @tc.type: FUNC
114 */
115 HWTEST_F(UnitTestFwmarkClient, BindSocketTest003, TestSize.Level1)
116 {
117 int32_t tcpSocket = -1;
118 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
119 NETNATIVE_LOGI("UnitTestFwmarkClient BindSocketTest002 ret=%{public}d", ret);
120 close(tcpSocket);
121 tcpSocket = -1;
122 EXPECT_EQ(ret, -1);
123 }
124
125 /**
126 * @tc.name: HandleErrorTest
127 * @tc.desc: Test FwmarkClient BindSocket.
128 * @tc.type: FUNC
129 */
130 HWTEST_F(UnitTestFwmarkClient, HandleErrorTest, TestSize.Level1)
131 {
132 int32_t ret = -1;
133 int32_t errorCode = ERROR_CODE_SOCKETFD_INVALID;
134 ret = fwmarkClient->HandleError(ret, errorCode);
135 EXPECT_EQ(ret, -1);
136
137 errorCode = ERROR_CODE_CONNECT_FAILED;
138 ret = fwmarkClient->HandleError(ret, errorCode);
139 EXPECT_EQ(ret, -1);
140
141 errorCode = ERROR_CODE_SENDMSG_FAILED;
142 ret = fwmarkClient->HandleError(ret, errorCode);
143 EXPECT_EQ(ret, -1);
144
145 errorCode = ERROR_CODE_READ_FAILED;
146 ret = fwmarkClient->HandleError(ret, errorCode);
147 EXPECT_EQ(ret, -1);
148
149 errorCode = 100;
150 ret = fwmarkClient->HandleError(ret, errorCode);
151 EXPECT_EQ(ret, -1);
152 }
153
154 /**
155 * @tc.name: CloseSocketTest001
156 * @tc.desc: Test FwmarkNetwork CloseSocket.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(UnitTestFwmarkClient, CloseSocketTest001, TestSize.Level1)
160 {
161 int32_t socket = 32;
162 int32_t ret = -1;
163 CloseSocket(nullptr, ret, NO_ERROR_CODE);
164 CloseSocket(&socket, ret, ERROR_CODE_RECVMSG_FAILED);
165 CloseSocket(&socket, ret, ERROR_CODE_SOCKETFD_INVALID);
166 CloseSocket(&socket, ret, ERROR_CODE_WRITE_FAILED);
167 CloseSocket(&socket, ret, ERROR_CODE_GETSOCKOPT_FAILED);
168 CloseSocket(&socket, ret, ERROR_CODE_SETSOCKOPT_FAILED);
169 CloseSocket(&socket, ret, ERROR_CODE_SETSOCKOPT_FAILED - 1);
170 EXPECT_EQ(socket, -1);
171 }
172
173 /**
174 * @tc.name: SetMarkTest001
175 * @tc.desc: Test FwmarkNetwork SetMark.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(UnitTestFwmarkClient, SetMarkTest001, TestSize.Level1)
179 {
180 FwmarkCommand cmd;
181 auto ret = SetMark(nullptr, &cmd);
182 EXPECT_EQ(ret, -1);
183 }
184
185 /**
186 * @tc.name: SetMarkTest002
187 * @tc.desc: Test FwmarkNetwork SetMark.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(UnitTestFwmarkClient, SetMarkTest002, TestSize.Level1)
191 {
192 int32_t socketFd = 0;
193 auto ret = SetMark(&socketFd, nullptr);
194 EXPECT_EQ(ret, -1);
195 }
196
197 /**
198 * @tc.name: SetMarkTest003
199 * @tc.desc: Test FwmarkNetwork SetMark.
200 * @tc.type: FUNC
201 */
202 HWTEST_F(UnitTestFwmarkClient, SetMarkTest003, TestSize.Level1)
203 {
204 int32_t socketFd = 1111;
205 FwmarkCommand cmd;
206 auto ret = SetMark(&socketFd, &cmd);
207 EXPECT_NE(ret, 0);
208 EXPECT_EQ(socketFd, -1);
209 }
210
211 /**
212 * @tc.name: SetMarkTest004
213 * @tc.desc: Test FwmarkNetwork SetMark.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(UnitTestFwmarkClient, SetMarkTest004, TestSize.Level1)
217 {
218 FwmarkCommand cmd;
219 int32_t tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
220 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
221 ASSERT_EQ(ret, 0);
222 cmd.cmdId = FwmarkCommand::SELECT_NETWORK;
223 cmd.netId = NETID_UNSET;
224 ret = SetMark(&tcpSocket, &cmd);
225 close(tcpSocket);
226 tcpSocket = -1;
227 EXPECT_EQ(ret, 0);
228 }
229
230 /**
231 * @tc.name: SetMarkTest005
232 * @tc.desc: Test FwmarkNetwork SetMark.
233 * @tc.type: FUNC
234 */
235 HWTEST_F(UnitTestFwmarkClient, SetMarkTest005, TestSize.Level1)
236 {
237 FwmarkCommand cmd;
238 int32_t tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
239 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
240 ASSERT_EQ(ret, 0);
241 cmd.cmdId = FwmarkCommand::SELECT_NETWORK;
242 cmd.netId = 100;
243 ret = SetMark(&tcpSocket, &cmd);
244 close(tcpSocket);
245 tcpSocket = -1;
246 EXPECT_EQ(ret, 0);
247 }
248
249 /**
250 * @tc.name: SetMarkTest006
251 * @tc.desc: Test FwmarkNetwork SetMark.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(UnitTestFwmarkClient, SetMarkTest006, TestSize.Level1)
255 {
256 FwmarkCommand cmd;
257 int32_t tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
258 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
259 ASSERT_EQ(ret, 0);
260 cmd.cmdId = FwmarkCommand::PROTECT_FROM_VPN;
261 cmd.netId = 100;
262 ret = SetMark(&tcpSocket, &cmd);
263 close(tcpSocket);
264 tcpSocket = -1;
265 EXPECT_EQ(ret, 0);
266 }
267
268 /**
269 * @tc.name: SetMarkTest007
270 * @tc.desc: Test FwmarkNetwork SetMark.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(UnitTestFwmarkClient, SetMarkTest007, TestSize.Level1)
274 {
275 FwmarkCommand cmd;
276 int32_t tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
277 int32_t ret = fwmarkClient->BindSocket(tcpSocket, NETID_SECOND);
278 ASSERT_EQ(ret, 0);
279 cmd.cmdId = FwmarkCommand::PROTECT_FROM_VPN;
280 cmd.netId = 9999;
281 ret = SetMark(&tcpSocket, &cmd);
282 close(tcpSocket);
283 tcpSocket = -1;
284 SendMessage(nullptr);
285 EXPECT_EQ(ret, 0);
286 }
287
288 /**
289 * @tc.name: SetMarkTest008
290 * @tc.desc: Test FwmarkNetwork ProtectFromVpn.
291 * @tc.type: FUNC
292 */
293 HWTEST_F(UnitTestFwmarkClient, SetMarkTest008, TestSize.Level1)
294 {
295 int32_t socketFd = 1111;
296 auto ret = fwmarkClient->ProtectFromVpn(socketFd);
297 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
298 }
299 } // namespace NetsysNative
300 } // namespace OHOS
301