1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "net_manager_constants.h"
24 #include "netnative_log_wrapper.h"
25 #include "multi_vpn_manager.h"
26
27 namespace OHOS {
28 namespace NetManagerStandard {
29 namespace {
30 using namespace testing::ext;
31 constexpr const char *TEST_XFRM_CARD_NAME = "xfrm-vpn1";
32 constexpr const char *TEST_PPP_CARD_NAME = "ppp-vpn2";
33 constexpr const char *TEST_MULTI_TUN_CARD_NAME = "multitun-vpn3";
34 } // namespace
35
36 class MultiVpnManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase()44 void MultiVpnManagerTest::SetUpTestCase() {}
45
TearDownTestCase()46 void MultiVpnManagerTest::TearDownTestCase() {}
47
SetUp()48 void MultiVpnManagerTest::SetUp() {}
49
TearDown()50 void MultiVpnManagerTest::TearDown() {}
51
52 HWTEST_F(MultiVpnManagerTest, VpnManagerBranchTest001, TestSize.Level1)
53 {
54 MultiVpnManager::GetInstance().CreatePppFd(TEST_XFRM_CARD_NAME);
55 MultiVpnManager::GetInstance().multiVpnListeningFlag_ = false;
56 MultiVpnManager::GetInstance().CreatePppFd(TEST_PPP_CARD_NAME);
57 MultiVpnManager::GetInstance().CreatePppFd(TEST_PPP_CARD_NAME);
58 MultiVpnManager::GetInstance().StartMultiVpnSocketListen();
59 MultiVpnManager::GetInstance().SetXfrmPhyIfName("eth0");
60 MultiVpnManager::GetInstance().DestroyVpnInterface(TEST_XFRM_CARD_NAME);
61
62 auto result = MultiVpnManager::GetInstance().CreateVpnInterface(TEST_XFRM_CARD_NAME);
63 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
64 result = MultiVpnManager::GetInstance().CreateVpnInterface(TEST_PPP_CARD_NAME);
65 EXPECT_EQ(result, NETMANAGER_ERROR);
66
67 result = MultiVpnManager::GetInstance().CreateVpnInterface(TEST_MULTI_TUN_CARD_NAME);
68 EXPECT_EQ(result, NETMANAGER_SUCCESS);
69
70 result = MultiVpnManager::GetInstance().CreateVpnInterface("eth0");
71 EXPECT_EQ(result, NETMANAGER_ERROR);
72
73 MultiVpnManager::GetInstance().SetVpnRemoteAddress("192.168.1.1");
74
75 std::string ifName = "";
76 int32_t testNumber = 0;
77 result = MultiVpnManager::GetInstance().SetVpnMtu(ifName, testNumber);
78 EXPECT_EQ(result, NETMANAGER_ERROR);
79
80 testNumber = 1500;
81 result = MultiVpnManager::GetInstance().SetVpnMtu(TEST_XFRM_CARD_NAME, testNumber);
82 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
83
84 std::string ipAddr = "";
85 result = MultiVpnManager::GetInstance().SetVpnAddress(ifName, ipAddr, testNumber);
86 EXPECT_EQ(result, NETMANAGER_ERROR);
87
88 result = MultiVpnManager::GetInstance().SetVpnUp(TEST_XFRM_CARD_NAME);
89 EXPECT_EQ(result, NETMANAGER_SUCCESS);
90
91 result = MultiVpnManager::GetInstance().SetVpnDown(TEST_XFRM_CARD_NAME);
92 EXPECT_EQ(result, NETMANAGER_SUCCESS);
93
94 ifreq ifr;
95 std::string cardName = "xfrm-vpn2";
96 result = MultiVpnManager::GetInstance().InitIfreq(ifr, cardName);
97 EXPECT_EQ(result, NETMANAGER_SUCCESS);
98
99 uint32_t cmd = 0;
100 std::atomic_int fd = 1;
101 result = MultiVpnManager::GetInstance().SetVpnResult(fd, cmd, ifr);
102 EXPECT_EQ(result, NETMANAGER_ERROR);
103
104 result = MultiVpnManager::GetInstance().DestroyVpnInterface(TEST_XFRM_CARD_NAME);
105 EXPECT_EQ(result, NETMANAGER_SUCCESS);
106
107 result = MultiVpnManager::GetInstance().SendVpnInterfaceFdToClient(testNumber, testNumber);
108 EXPECT_EQ(result, NETMANAGER_ERROR);
109 }
110
111 HWTEST_F(MultiVpnManagerTest, VpnManagerBranchTest002, TestSize.Level1)
112 {
113 auto ret = MultiVpnManager::GetInstance().CreateVpnInterface(TEST_XFRM_CARD_NAME);
114 EXPECT_TRUE(ret == NETMANAGER_SUCCESS || ret == NETMANAGER_ERROR);
115 }
116
117 HWTEST_F(MultiVpnManagerTest, VpnManagerBranchTest003, TestSize.Level1)
118 {
119 auto ret = MultiVpnManager::GetInstance().SetVpnMtu(TEST_XFRM_CARD_NAME, 1500);
120 EXPECT_TRUE(ret == NETMANAGER_SUCCESS || ret == NETMANAGER_ERROR);
121 }
122
123 HWTEST_F(MultiVpnManagerTest, VpnManagerBranchTest004, TestSize.Level1)
124 {
125 std::string ipAddr = "127.0.0.1";
126 auto ret = MultiVpnManager::GetInstance().SetVpnAddress(TEST_XFRM_CARD_NAME, ipAddr, 0);
127 EXPECT_EQ(ret, NETMANAGER_ERROR);
128 }
129
130 HWTEST_F(MultiVpnManagerTest, VpnManagerBranchTest005, TestSize.Level1)
131 {
132 ifreq ifr;
133 uint32_t cmd = 0;
134 std::atomic_int fd = 1;
135 auto result = MultiVpnManager::GetInstance().SetVpnResult(fd, cmd, ifr);
136 EXPECT_EQ(result, NETMANAGER_ERROR);
137 }
138
139 HWTEST_F(MultiVpnManagerTest, SetVpnMtuTest001, TestSize.Level1)
140 {
141 MultiVpnManager multiVpnManager;
142 std::string ifName = "12345678901234567890";
143 int32_t mtu = 1;
144 auto result = multiVpnManager.SetVpnMtu(ifName, mtu);
145 EXPECT_EQ(result, NETMANAGER_ERROR);
146 }
147
148 HWTEST_F(MultiVpnManagerTest, SetVpnMtuTest002, TestSize.Level1)
149 {
150 MultiVpnManager multiVpnManager;
151 std::string ifName = TEST_XFRM_CARD_NAME;
152 int32_t mtu = 1500;
153 auto result = multiVpnManager.SetVpnMtu(ifName, mtu);
154 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
155 }
156
157 HWTEST_F(MultiVpnManagerTest, SetVpnAddressTest001, TestSize.Level1)
158 {
159 MultiVpnManager multiVpnManager;
160 std::string ifName = "12345678901234567890";
161 std::string ipAddr = "192.168.1.1";
162 int32_t prefix = 1;
163 auto result = multiVpnManager.SetVpnAddress(ifName, ipAddr, prefix);
164 EXPECT_EQ(result, NETMANAGER_ERROR);
165 }
166
167 HWTEST_F(MultiVpnManagerTest, SetVpnAddressTest002, TestSize.Level1)
168 {
169 MultiVpnManager multiVpnManager;
170 std::string ifName = "12345678901234567890";
171 std::string ipAddr = "";
172 int32_t prefix = 1;
173 auto result = multiVpnManager.SetVpnAddress(ifName, ipAddr, prefix);
174 EXPECT_EQ(result, NETMANAGER_ERROR);
175 }
176
177 HWTEST_F(MultiVpnManagerTest, SetVpnAddressTest003, TestSize.Level1)
178 {
179 MultiVpnManager multiVpnManager;
180 std::string ifName = TEST_XFRM_CARD_NAME;
181 std::string ipAddr = "127.0.0.1";
182 int32_t prefix = 32;
183 auto result = multiVpnManager.SetVpnAddress(ifName, ipAddr, prefix);
184 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
185 ifName = TEST_PPP_CARD_NAME;
186 multiVpnManager.remoteIpv4Addr_ = "";
187 result = multiVpnManager.SetVpnAddress(ifName, ipAddr, prefix);
188 EXPECT_EQ(result, NETMANAGER_ERROR);
189 }
190
191 HWTEST_F(MultiVpnManagerTest, InitIfreqTest001, TestSize.Level1)
192 {
193 MultiVpnManager multiVpnManager;
194 ifreq ifr;
195 std::string cardName = "12345678901234567890";
196 auto result = multiVpnManager.InitIfreq(ifr, cardName);
197 EXPECT_EQ(result, NETMANAGER_ERROR);
198 }
199
200 HWTEST_F(MultiVpnManagerTest, SetMultiVpnDown001, TestSize.Level1)
201 {
202 MultiVpnManager multiVpnManager;
203 std::string cardName = TEST_XFRM_CARD_NAME;
204 auto result = multiVpnManager.SetVpnDown(cardName);
205 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
206 }
207
208 HWTEST_F(MultiVpnManagerTest, SetMultiVpnDown002, TestSize.Level1)
209 {
210 MultiVpnManager multiVpnManager;
211 std::string cardName = "12345678901234567890";
212 auto result = multiVpnManager.SetVpnDown(cardName);
213 EXPECT_EQ(result, NETMANAGER_ERROR);
214 }
215
216 HWTEST_F(MultiVpnManagerTest, SetMultiVpnUp001, TestSize.Level1)
217 {
218 MultiVpnManager multiVpnManager;
219 std::string cardName = "12345678901234567890";
220 auto result = multiVpnManager.SetVpnUp(cardName);
221 EXPECT_EQ(result, NETMANAGER_ERROR);
222 }
223
224 HWTEST_F(MultiVpnManagerTest, SetMultiVpnUp002, TestSize.Level1)
225 {
226 MultiVpnManager multiVpnManager;
227 std::string cardName = TEST_XFRM_CARD_NAME;
228 auto result = multiVpnManager.SetVpnUp(TEST_XFRM_CARD_NAME);
229 EXPECT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERROR);
230 }
231
232 HWTEST_F(MultiVpnManagerTest, CreatePppInterface001, TestSize.Level1)
233 {
234 MultiVpnManager multiVpnManager;
235 std::string cardName = "12345678901234567890";
236 auto result = multiVpnManager.CreatePppInterface(cardName);
237 EXPECT_EQ(result, NETMANAGER_ERROR);
238 }
239
240 HWTEST_F(MultiVpnManagerTest, CreatePppInterface002, TestSize.Level1)
241 {
242 MultiVpnManager multiVpnManager;
243 multiVpnManager.multiVpnFdMap_[TEST_PPP_CARD_NAME] = 1;
244 std::string cardName = TEST_PPP_CARD_NAME;
245 auto result = multiVpnManager.CreatePppInterface(cardName);
246 EXPECT_EQ(result, NETMANAGER_ERROR);
247 }
248
249 HWTEST_F(MultiVpnManagerTest, GetMultiVpnFd001, TestSize.Level1)
250 {
251 MultiVpnManager multiVpnManager;
252 std::string cardName = "12345678901234567890";
253 int32_t multiVpnFd = -1;
254 auto result = multiVpnManager.GetMultiVpnFd(cardName, multiVpnFd);
255 EXPECT_EQ(result, NETMANAGER_ERROR);
256 result = multiVpnManager.GetMultiVpnFd(TEST_MULTI_TUN_CARD_NAME, multiVpnFd);
257 EXPECT_EQ(result, NETMANAGER_SUCCESS);
258 result = MultiVpnManager::GetInstance().GetMultiVpnFd(TEST_PPP_CARD_NAME, multiVpnFd);
259 EXPECT_EQ(result, NETMANAGER_SUCCESS);
260 }
261
262 HWTEST_F(MultiVpnManagerTest, GetMultiVpnFd002, TestSize.Level1)
263 {
264 MultiVpnManager multiVpnManager;
265 int32_t multiVpnFd = -1;
266 auto result = MultiVpnManager::GetInstance().GetMultiVpnFd(TEST_MULTI_TUN_CARD_NAME, multiVpnFd);
267 EXPECT_EQ(result, NETMANAGER_SUCCESS);
268 }
269
270 HWTEST_F(MultiVpnManagerTest, DestroyPppFd001, TestSize.Level1)
271 {
272 MultiVpnManager multiVpnManager;
273 std::string cardName = "12345678901234567890";
274 auto result = multiVpnManager.DestroyMultiVpnFd(cardName);
275 EXPECT_EQ(result, NETMANAGER_ERROR);
276 }
277
278 HWTEST_F(MultiVpnManagerTest, DestroyPppFd002, TestSize.Level1)
279 {
280 MultiVpnManager multiVpnManager;
281 std::string cardName = TEST_PPP_CARD_NAME;
282 auto result = multiVpnManager.DestroyMultiVpnFd(cardName);
283 EXPECT_EQ(result, NETMANAGER_ERROR);
284 }
285
286 HWTEST_F(MultiVpnManagerTest, DestroyPppFd003, TestSize.Level1)
287 {
288 MultiVpnManager multiVpnManager;
289 std::string cardName = TEST_PPP_CARD_NAME;
290 multiVpnManager.multiVpnFdMap_[TEST_PPP_CARD_NAME] = 2;
291 auto result = multiVpnManager.DestroyMultiVpnFd(cardName);
292 EXPECT_EQ(result, NETMANAGER_SUCCESS);
293 }
294
295 HWTEST_F(MultiVpnManagerTest, AddVpnRemoteAddress001, TestSize.Level1)
296 {
297 MultiVpnManager multiVpnManager;
298 ifreq ifr = {};
299 std::atomic_int net4Sock = 1;
300 std::string cardName = TEST_PPP_CARD_NAME;
301 auto result = multiVpnManager.AddVpnRemoteAddress(cardName, net4Sock, ifr);
302 EXPECT_EQ(result, NETMANAGER_ERROR);
303 multiVpnManager.remoteIpv4Addr_= "192.168.1.20";
304 result = multiVpnManager.AddVpnRemoteAddress(cardName, net4Sock, ifr);
305 EXPECT_EQ(result, NETMANAGER_ERROR);
306 }
307
308 HWTEST_F(MultiVpnManagerTest, SendVpnInterfaceFdToClient001, TestSize.Level1)
309 {
310 MultiVpnManager multiVpnManager;
311 int32_t clientFd = 0;
312 std::atomic_int net4Sock = 1;
313 auto result = multiVpnManager.SendVpnInterfaceFdToClient(clientFd, net4Sock);
314 EXPECT_EQ(result, NETMANAGER_ERROR);
315 }
316
317 HWTEST_F(MultiVpnManagerTest, DestroyVpnInterface001, TestSize.Level1)
318 {
319 MultiVpnManager multiVpnManager;
320 auto result = multiVpnManager.DestroyVpnInterface(TEST_XFRM_CARD_NAME);
321 EXPECT_EQ(result, NETMANAGER_SUCCESS);
322 result = multiVpnManager.DestroyVpnInterface(TEST_PPP_CARD_NAME);
323 EXPECT_EQ(result, NETMANAGER_SUCCESS);
324 }
325
326 HWTEST_F(MultiVpnManagerTest, DestroyVpnInterface002, TestSize.Level1)
327 {
328 MultiVpnManager multiVpnManager;
329 std::string cardName = "12345678901234567890";
330 auto result = multiVpnManager.DestroyVpnInterface(cardName);
331 EXPECT_EQ(result, NETMANAGER_ERROR);
332 }
333
334 HWTEST_F(MultiVpnManagerTest, SetVpnCallMode001, TestSize.Level1)
335 {
336 MultiVpnManager multiVpnManager;
337 std::string message = "";
338 auto result = multiVpnManager.SetVpnCallMode(message);
339 EXPECT_EQ(result, NETMANAGER_ERROR);
340 message = "1";
341 result = multiVpnManager.SetVpnCallMode(message);
342 EXPECT_EQ(result, NETMANAGER_SUCCESS);
343 message = "0";
344 result = multiVpnManager.SetVpnCallMode(message);
345 EXPECT_EQ(result, NETMANAGER_SUCCESS);
346 message = "2";
347 result = multiVpnManager.SetVpnCallMode(message);
348 EXPECT_EQ(result, NETMANAGER_SUCCESS);
349 }
350
351 HWTEST_F(MultiVpnManagerTest, CreateMultiTunInterface001, TestSize.Level1)
352 {
353 std::string cardName = "12345678901234567890";
354 auto result = MultiVpnManager::GetInstance().CreateMultiTunInterface(cardName);
355 EXPECT_EQ(result, NETMANAGER_ERROR);
356 cardName = "multitun-vpn1";
357 result = MultiVpnManager::GetInstance().CreateMultiTunInterface(cardName);
358 EXPECT_EQ(result, NETMANAGER_SUCCESS);
359 }
360
361 } // namespace NetManagerStandard
362 } // namespace OHOS
363