1 /*
2 * Copyright (c) 2024 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 #include "net_manager_constants.h"
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24 #include "l2tp_vpn_ctl.h"
25 #include "vpn_config.h"
26
27 namespace OHOS {
28 namespace NetManagerStandard {
29 using namespace testing::ext;
30
31 class L2tpVpnCtlTest : public testing::Test {
32 public:
33 static inline std::unique_ptr<IpsecVpnCtl> l2tpControl_ = nullptr;
34 static void SetUpTestSuite();
35 };
36
SetUpTestSuite()37 void L2tpVpnCtlTest::SetUpTestSuite()
38 {
39 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
40 if (l2tpVpnconfig == nullptr) {
41 return;
42 }
43 int32_t userId = 0;
44 std::vector<int32_t> activeUserIds;
45 l2tpControl_ = std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
46 if (l2tpControl_ == nullptr) {
47 return;
48 }
49 l2tpControl_->l2tpVpnConfig_ = l2tpVpnconfig;
50 }
51
52 HWTEST_F(L2tpVpnCtlTest, SetUp001, TestSize.Level1)
53 {
54 if (l2tpControl_ == nullptr) {
55 return;
56 }
57 EXPECT_EQ(l2tpControl_->SetUp(), NETMANAGER_EXT_SUCCESS);
58 }
59
60 HWTEST_F(L2tpVpnCtlTest, SetUp002, TestSize.Level1)
61 {
62 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
63 ASSERT_NE(l2tpVpnconfig, nullptr);
64 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
65 ASSERT_NE(netAddr, nullptr);
66 std::string ip = "1.1.1.1";
67 netAddr->address_ = ip;
68 netAddr->prefixlen_ = 1;
69 l2tpVpnconfig->addresses_.push_back(*netAddr);
70 l2tpVpnconfig->vpnId_ = "123";
71 l2tpVpnconfig->vpnName_ = "testSetUpVpn";
72 l2tpVpnconfig->vpnType_ = 1;
73 int32_t userId = 0;
74 std::vector<int32_t> activeUserIds;
75 std::unique_ptr<L2tpVpnCtl> l2tpControl =
76 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
77 ASSERT_NE(l2tpControl, nullptr);
78 l2tpControl->l2tpVpnConfig_ = l2tpVpnconfig;
79 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
80 l2tpControl->l2tpVpnConfig_->vpnType_ = 10;
81 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
82 l2tpControl->l2tpVpnConfig_->vpnType_ = 4;
83 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
84 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
85 ASSERT_NE(vpnInfo, nullptr);
86 l2tpControl->multiVpnInfo_ = vpnInfo;
87 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
88 l2tpControl->l2tpVpnConfig_->vpnType_ = 10;
89 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
90 l2tpControl->l2tpVpnConfig_->vpnType_ = 4;
91 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
92 l2tpControl->l2tpVpnConfig_->vpnType_ = 5;
93 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
94 }
95
96 HWTEST_F(L2tpVpnCtlTest, SetUpTest003, TestSize.Level1)
97 {
98 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
99 ASSERT_NE(l2tpVpnconfig, nullptr);
100 l2tpVpnconfig->vpnType_ == 10;
101 int32_t userId = 0;
102 std::vector<int32_t> activeUserIds;
103 std::unique_ptr<L2tpVpnCtl> l2tpControl =
104 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
105 ASSERT_NE(l2tpControl, nullptr);
106 l2tpControl->l2tpVpnConfig_ = l2tpVpnconfig;
107 l2tpControl->l2tpVpnConfig_->vpnType_ = 10;
108 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
109 l2tpControl->l2tpVpnConfig_->vpnType_ = 4;
110 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
111 l2tpControl->l2tpVpnConfig_->vpnType_ = 10;
112 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
113 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
114 ASSERT_NE(vpnInfo, nullptr);
115 l2tpControl->multiVpnInfo_ = vpnInfo;
116 EXPECT_EQ(l2tpControl->SetUp(), NETMANAGER_EXT_SUCCESS);
117 }
118
119 HWTEST_F(L2tpVpnCtlTest, StartSysVpnTest001, TestSize.Level1)
120 {
121 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
122 ASSERT_NE(l2tpVpnconfig, nullptr);
123 sptr<INetAddr> netAddr = new (std::nothrow) INetAddr();
124 ASSERT_NE(netAddr, nullptr);
125 std::string ip = "1.1.1.1";
126 netAddr->address_ = ip;
127 netAddr->prefixlen_ = 1;
128 l2tpVpnconfig->addresses_.push_back(*netAddr);
129 l2tpVpnconfig->vpnId_ = "123";
130 l2tpVpnconfig->vpnName_ = "testSetUpVpn";
131 l2tpVpnconfig->vpnType_ = 1;
132 int32_t userId = 0;
133 std::vector<int32_t> activeUserIds;
134 std::unique_ptr<L2tpVpnCtl> l2tpControl =
135 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
136 ASSERT_NE(l2tpControl, nullptr);
137 l2tpControl->l2tpVpnConfig_ = l2tpVpnconfig;
138 l2tpControl->l2tpVpnConfig_->vpnType_ = 4;
139 EXPECT_EQ(l2tpControl->StartSysVpn(), NETMANAGER_EXT_SUCCESS);
140 l2tpControl->l2tpVpnConfig_->vpnType_ = 5;
141 EXPECT_EQ(l2tpControl->StartSysVpn(), NETMANAGER_EXT_SUCCESS);
142 }
143
144 HWTEST_F(L2tpVpnCtlTest, Destroy001, TestSize.Level1)
145 {
146 if (l2tpControl_ == nullptr) {
147 return;
148 }
149 EXPECT_EQ(l2tpControl_->Destroy(), NETMANAGER_EXT_SUCCESS);
150 }
151
152 HWTEST_F(L2tpVpnCtlTest, Destroy002, TestSize.Level1)
153 {
154 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
155 ASSERT_NE(l2tpVpnconfig, nullptr);
156 int32_t userId = 0;
157 std::vector<int32_t> activeUserIds;
158 std::unique_ptr<L2tpVpnCtl> l2tpControl =
159 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
160 ASSERT_NE(l2tpControl, nullptr);
161 EXPECT_EQ(l2tpControl->Destroy(), NETMANAGER_EXT_SUCCESS);
162 l2tpControl->l2tpVpnConfig_->vpnType_ == VpnType::L2TP;
163 EXPECT_EQ(l2tpControl->Destroy(), NETMANAGER_EXT_SUCCESS);
164 l2tpControl->l2tpVpnConfig_->vpnType_ == VpnType::L2TP_IPSEC_PSK;
165 EXPECT_EQ(l2tpControl->Destroy(), NETMANAGER_EXT_SUCCESS);
166 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
167 ASSERT_NE(vpnInfo, nullptr);
168 l2tpControl->multiVpnInfo_ = vpnInfo;
169 EXPECT_EQ(l2tpControl->Destroy(), NETMANAGER_EXT_SUCCESS);
170 }
171
172 HWTEST_F(L2tpVpnCtlTest, IsInternalVpn001, TestSize.Level1)
173 {
174 if (l2tpControl_ == nullptr) {
175 return;
176 }
177 EXPECT_EQ(l2tpControl_->IsInternalVpn(), true);
178 }
179
180 HWTEST_F(L2tpVpnCtlTest, GetConnectedSysVpnConfigTest001, TestSize.Level1)
181 {
182 if (l2tpControl_ == nullptr) {
183 return;
184 }
185 sptr<SysVpnConfig> resConfig = nullptr;
186 int32_t ret = l2tpControl_->GetConnectedSysVpnConfig(resConfig);
187 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
188 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONNECTED;
189 ret = l2tpControl_->GetConnectedSysVpnConfig(resConfig);
190 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
191 sptr<L2tpVpnConfig> tmp = l2tpControl_->l2tpVpnConfig_;
192 l2tpControl_->l2tpVpnConfig_ = nullptr;
193 ret = l2tpControl_->GetConnectedSysVpnConfig(resConfig);
194 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
195 l2tpControl_->l2tpVpnConfig_ = tmp;
196 }
197
198 HWTEST_F(L2tpVpnCtlTest, NotifyConnectStageTest001, TestSize.Level1)
199 {
200 if (l2tpControl_ == nullptr) {
201 return;
202 }
203 std::string stage;
204 int32_t errorCode = 1;
205 int32_t ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
206 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
207 stage = IPSEC_START_TAG;
208 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
209 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
210
211 errorCode = NETMANAGER_EXT_SUCCESS;
212 l2tpControl_->state_ = IpsecVpnStateCode::STATE_INIT;
213 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
214 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
215
216 l2tpControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
217 stage = L2TP_IPSEC_CONFIGURED_TAG;
218 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
219 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
220
221 l2tpControl_->state_ = IpsecVpnStateCode::STATE_L2TP_STARTED;
222 stage = IPSEC_CONNECT_TAG;
223 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
224 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
225
226 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONTROLLED;
227 stage = L2TP_IPSEC_CONNECTED_TAG;
228 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
229 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
230
231 l2tpControl_->state_ = IpsecVpnStateCode::STATE_DISCONNECTED;
232 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
233 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
234
235 stage = "stageTest";
236 l2tpControl_->state_ = IpsecVpnStateCode::STATE_INIT;
237 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
238 l2tpControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
239 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
240 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
241 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
242 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONTROLLED;
243 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
244 }
245
246 HWTEST_F(L2tpVpnCtlTest, NotifyConnectStageTest002, TestSize.Level1)
247 {
248 if (l2tpControl_ == nullptr) {
249 return;
250 }
251 std::string stage;
252 int32_t errorCode = NETMANAGER_EXT_SUCCESS;
253 int32_t ret;
254
255 l2tpControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
256 stage = SWANCTL_START_TAG;
257 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
258 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
259
260 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
261 stage = IPSEC_CONNECT_TAG;
262 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
263 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
264
265 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
266 stage = L2TP_IPSEC_CONFIGURED_TAG;
267 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
268 ASSERT_NE(l2tpVpnconfig, nullptr);
269 l2tpControl_->l2tpVpnConfig_ = l2tpVpnconfig;
270 l2tpControl_->l2tpVpnConfig_->vpnType_ = 10;
271 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
272 ASSERT_NE(vpnInfo, nullptr);
273 l2tpControl_->multiVpnInfo_ = vpnInfo;
274 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
275 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
276
277 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONNECTED;
278 stage = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
279 "mtu":1400, "phyifname":"xfrm"}})";
280 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
281 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
282 }
283
284 HWTEST_F(L2tpVpnCtlTest, NotifyConnectStageTest003, TestSize.Level1)
285 {
286 ASSERT_NE(l2tpControl_, nullptr);
287 std::string stage;
288 int32_t errorCode = NETMANAGER_EXT_SUCCESS;
289 l2tpControl_->state_ = IpsecVpnStateCode::STATE_CONFIGED;
290 stage = L2TP_IPSEC_CONFIGURED_TAG;
291 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
292 ASSERT_NE(l2tpVpnconfig, nullptr);
293 l2tpControl_->l2tpVpnConfig_ = l2tpVpnconfig;
294 l2tpControl_->l2tpVpnConfig_->vpnType_ = 4;
295 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
296 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
297 ASSERT_NE(vpnInfo, nullptr);
298 l2tpControl_->multiVpnInfo_ = vpnInfo;
299 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
300
301 l2tpControl_->state_ = IpsecVpnStateCode::STATE_L2TP_STARTED;
302 stage = IPSEC_CONNECT_TAG;
303 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
304 }
305
306 HWTEST_F(L2tpVpnCtlTest, NotifyConnectStageTest004, TestSize.Level1)
307 {
308 ASSERT_NE(l2tpControl_, nullptr);
309 std::string stage;
310 int32_t errorCode = NETMANAGER_EXT_SUCCESS;
311 l2tpControl_->state_ = IpsecVpnStateCode::STATE_STARTED;
312 stage = SWANCTL_START_TAG;
313 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
314 ASSERT_NE(l2tpVpnconfig, nullptr);
315 l2tpControl_->l2tpVpnConfig_ = l2tpVpnconfig;
316 MultiVpnHelper::GetInstance().StartL2tp();
317 l2tpControl_->l2tpVpnConfig_->vpnType_ = 4;
318 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
319 l2tpControl_->l2tpVpnConfig_->vpnType_ = 5;
320 EXPECT_EQ(l2tpControl_->NotifyConnectStage(stage, errorCode), NETMANAGER_EXT_SUCCESS);
321 }
322
323 HWTEST_F(L2tpVpnCtlTest, NotifyConnectStageTest005, TestSize.Level1)
324 {
325 ASSERT_NE(l2tpControl_, nullptr);
326 std::string stage = SWANCTL_START_TAG;
327 int32_t errorCode = 1;
328 int32_t ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
329 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
330 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
331 ASSERT_NE(vpnInfo, nullptr);
332 l2tpControl_->multiVpnInfo_ = vpnInfo;
333 ret = l2tpControl_->NotifyConnectStage(stage, errorCode);
334 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
335 }
336
337 HWTEST_F(L2tpVpnCtlTest, GetSysVpnCertUriTest001, TestSize.Level1)
338 {
339 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
340 if (config == nullptr) {
341 return;
342 }
343 if (l2tpControl_ == nullptr) {
344 return;
345 }
346 config->ipsecCaCertConf_ = "CaCertUri";
347 l2tpControl_->l2tpVpnConfig_ = nullptr;
348 std::string certUri;
349 int32_t certType = 0;
350 int32_t ret = l2tpControl_->GetSysVpnCertUri(certType, certUri);
351 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
352 l2tpControl_->l2tpVpnConfig_ = config;
353 ret = l2tpControl_->GetSysVpnCertUri(certType, certUri);
354 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
355 EXPECT_EQ("CaCertUri", certUri);
356 }
357
358 HWTEST_F(L2tpVpnCtlTest, GetSysVpnCertUriTest002, TestSize.Level1)
359 {
360 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
361 if (config == nullptr) {
362 return;
363 }
364 if (l2tpControl_ == nullptr) {
365 return;
366 }
367 config->ipsecPublicUserCertConf_ = "UserCertUri";
368 l2tpControl_->l2tpVpnConfig_ = config;
369 std::string certUri;
370 int32_t certType = 1;
371 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
372 EXPECT_EQ("UserCertUri", certUri);
373 certType = 2;
374 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
375 certType = -1;
376 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
377 certType = 3;
378 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
379 }
380
381 HWTEST_F(L2tpVpnCtlTest, GetVpnCertData001, TestSize.Level1)
382 {
383 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
384 if (config == nullptr) {
385 return;
386 }
387 if (l2tpControl_ == nullptr) {
388 return;
389 }
390 config->pkcs12Password_ = "123456";
391 l2tpControl_->l2tpVpnConfig_ = config;
392 std::vector<int8_t> certData;
393 int32_t certType = 1;
394 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
395 EXPECT_EQ(certData.size(), 0);
396 certType = 3;
397 l2tpControl_->l2tpVpnConfig_ = nullptr;
398 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_ERR_INTERNAL);
399 std::vector<uint8_t> testCertData{0x30, 0x82, 0x0b, 0xc1, 0x02, 0x01};
400 config->pkcs12FileData_ = testCertData;
401 l2tpControl_->l2tpVpnConfig_ = config;
402 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
403 EXPECT_EQ(certData.size(), 0);
404 certType = 6;
405 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
406 EXPECT_EQ(certData.size(), testCertData.size());
407 certData.clear();
408 config->pkcs12FileData_.clear();
409 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
410 EXPECT_EQ(certData.size(), 0);
411 }
412
413 HWTEST_F(L2tpVpnCtlTest, GetVpnCertData002, TestSize.Level1)
414 {
415 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
416 if (config == nullptr) {
417 return;
418 }
419 if (l2tpControl_ == nullptr) {
420 return;
421 }
422 config->pkcs12Password_ = "123456";
423 l2tpControl_->l2tpVpnConfig_ = config;
424 std::vector<int8_t> certData;
425 int32_t certType = 7;
426 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
427 EXPECT_EQ(certData.size(), config->pkcs12Password_.length());
428 certType = 3;
429 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
430 certType = 7;
431 config->pkcs12Password_ = "";
432 EXPECT_EQ(l2tpControl_->GetVpnCertData(certType, certData), NETMANAGER_EXT_SUCCESS);
433 }
434
435 HWTEST_F(L2tpVpnCtlTest, InitConfigFile001, TestSize.Level1)
436 {
437 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
438 if (config == nullptr) {
439 return;
440 }
441 if (l2tpControl_ == nullptr) {
442 return;
443 }
444 config->ipsecPublicUserCertConf_ = "testUserUri";
445 config->xl2tpdConf_ = "testXl2tpdConf";
446 config->strongswanConf_ = "testStrongswanConf";
447 config->ipsecConf_ = "ipsecConfTest";
448 config->ipsecSecrets_ = "ipsecSecretsTest";
449 config->optionsL2tpdClient_ = "optionsL2tpdClientTest";
450 l2tpControl_->l2tpVpnConfig_ = nullptr;
451 int32_t ret = l2tpControl_->InitConfigFile();
452 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INTERNAL);
453 l2tpControl_->l2tpVpnConfig_ = config;
454 ret = l2tpControl_->InitConfigFile();
455 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
456 }
457
458 HWTEST_F(L2tpVpnCtlTest, InitConfigFile002, TestSize.Level1)
459 {
460 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
461 if (config == nullptr) {
462 return;
463 }
464 if (l2tpControl_ == nullptr) {
465 return;
466 }
467 config->ipsecPublicUserCertConf_ = "testUserUri";
468 config->xl2tpdConf_ = "INVALID_BASE64";
469 config->strongswanConf_ = "INVALID_BASE64";
470 config->ipsecConf_ = "INVALID_BASE64";
471 config->ipsecSecrets_ = "ipsecSecretsTest";
472 config->optionsL2tpdClient_ = "optionsL2tpdClientTest";
473 l2tpControl_->l2tpVpnConfig_ = config;
474 int32_t ret = l2tpControl_->InitConfigFile();
475 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
476 }
477
478 HWTEST_F(L2tpVpnCtlTest, GetSysVpnCertUriTest003, TestSize.Level1)
479 {
480 sptr<L2tpVpnConfig> config = new (std::nothrow) L2tpVpnConfig();
481 if (config == nullptr) {
482 return;
483 }
484 if (l2tpControl_ == nullptr) {
485 return;
486 }
487 config->ipsecPublicUserCertConf_ = "UserCertUri";
488 l2tpControl_->l2tpVpnConfig_ = config;
489 std::string certUri;
490 int32_t certType = 1;
491 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
492 EXPECT_EQ("UserCertUri", certUri);
493 certType = 4;
494 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
495 certType = 5;
496 EXPECT_EQ(l2tpControl_->GetSysVpnCertUri(certType, certUri), NETMANAGER_EXT_SUCCESS);
497 }
498
499 HWTEST_F(L2tpVpnCtlTest, ProcessUpdateL2tpConfig001, TestSize.Level1)
500 {
501 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
502 ASSERT_NE(l2tpVpnconfig, nullptr);
503 int32_t userId = 0;
504 std::vector<int32_t> activeUserIds;
505 std::unique_ptr<L2tpVpnCtl> l2tpControl =
506 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
507 ASSERT_NE(l2tpVpnconfig, nullptr);
508 std::string message;
509 EXPECT_EQ(l2tpControl->ProcessUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
510 message = R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
511 "mtu":1400, "phyifname":"xfrm"}})";
512 EXPECT_EQ(l2tpControl->ProcessUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
513
514 l2tpControl->l2tpVpnConfig_ = l2tpVpnconfig;
515 EXPECT_EQ(l2tpControl->ProcessUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
516 message =R"({"updateconfig":{"address":"192.168.1.1", "netmask":"255.255.255.0",
517 "mtu":1400, "phyifname":"xfrm"}})";
518 EXPECT_EQ(l2tpControl->ProcessUpdateConfig(message), NETMANAGER_EXT_ERR_INTERNAL);
519 }
520
521 HWTEST_F(L2tpVpnCtlTest, HandleConnectFailed001, TestSize.Level1)
522 {
523 sptr<L2tpVpnConfig> l2tpVpnconfig = new (std::nothrow) L2tpVpnConfig();
524 ASSERT_NE(l2tpVpnconfig, nullptr);
525 int32_t userId = 0;
526 std::vector<int32_t> activeUserIds;
527 std::unique_ptr<L2tpVpnCtl> l2tpControl =
528 std::make_unique<L2tpVpnCtl>(l2tpVpnconfig, "pkg", userId, activeUserIds);
529 ASSERT_NE(l2tpControl, nullptr);
530 l2tpControl->state_ = IpsecVpnStateCode::STATE_STARTED;
531 l2tpControl->l2tpVpnConfig_ = l2tpVpnconfig;
532 sptr<MultiVpnInfo> vpnInfo = new (std::nothrow) MultiVpnInfo();
533 ASSERT_NE(vpnInfo, nullptr);
534 l2tpControl->multiVpnInfo_ = vpnInfo;
535 int32_t code = VpnErrorCode::CONNECT_TIME_OUT;
536 l2tpControl->HandleConnectFailed(code);
537 EXPECT_TRUE(l2tpControl->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
538 code = VpnErrorCode::IKEV1_KEY_ERROR;
539 l2tpControl->state_ = IpsecVpnStateCode::STATE_STARTED;
540 l2tpControl->HandleConnectFailed(code);
541 EXPECT_TRUE(l2tpControl->state_ ==IpsecVpnStateCode::STATE_DISCONNECTED);
542 code = VpnErrorCode::PASSWORD_ERROR;
543 l2tpControl->state_ = IpsecVpnStateCode::STATE_STARTED;
544 l2tpControl->HandleConnectFailed(code);
545 EXPECT_TRUE(l2tpControl->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
546 code = 300;
547 l2tpControl->state_ = IpsecVpnStateCode::STATE_STARTED;
548 l2tpControl->HandleConnectFailed(code);
549 EXPECT_TRUE(l2tpControl->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
550 code = 400;
551 l2tpControl->state_ = IpsecVpnStateCode::STATE_DISCONNECTED;
552 l2tpControl->HandleConnectFailed(code);
553 EXPECT_TRUE(l2tpControl->state_ == IpsecVpnStateCode::STATE_DISCONNECTED);
554 }
555
556 } // namespace NetManagerStandard
557 } // namespace OHOS