1 /*
2 * Copyright (c) 2023-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 <arpa/inet.h>
17 #include <gtest/gtest.h>
18 #include <linux/if_tun.h>
19 #include <net/if.h>
20 #include <netinet/in.h>
21 #include <poll.h>
22 #include <sys/ioctl.h>
23 #include <sys/socket.h>
24 #include <thread>
25 #include <unistd.h>
26
27 #include "fwmark_client.h"
28 #include "iservice_registry.h"
29 #include "netmanager_ext_test_security.h"
30 #include "netmgr_ext_log_wrapper.h"
31 #include "system_ability_definition.h"
32
33 #ifdef GTEST_API_
34 #define private public
35 #endif
36 #include "net_manager_constants.h"
37 #include "netmanager_base_common_utils.h"
38 #include "networkvpn_client.h"
39 #include "vpn_event_callback_stub.h"
40 #ifdef SUPPORT_SYSVPN
41 #include "ipsecvpn_config.h"
42 #endif // SUPPORT_SYSVPN
43
44 namespace OHOS {
45 namespace NetManagerStandard {
46 namespace {
47 using namespace testing::ext;
48 } // namespace
49
50 class IVpnEventCallbackTest : public IRemoteStub<IVpnEventCallback> {
51 public:
OnVpnStateChanged(const bool & isConnected)52 void OnVpnStateChanged(const bool &isConnected) override{};
OnVpnMultiUserSetUp()53 void OnVpnMultiUserSetUp() override{};
54 };
55
56 class NetworkVpnClientTest : public testing::Test {
57 public:
58 static void SetUpTestCase();
59 static void TearDownTestCase();
60 void SetUp();
61 void TearDown();
62 #ifdef SUPPORT_SYSVPN
63 void AddSysVpnConfig();
64 void DeleteSysVpnConfig();
65 void GetSysVpnConfigList();
66 void GetSysVpnConfig();
67 void GetConnectedSysVpnConfig();
68 #endif // SUPPORT_SYSVPN
69
70 sptr<IVpnEventCallback> callback_ = nullptr;
71 NetworkVpnClient &networkVpnClient_ = NetworkVpnClient::GetInstance();
72 };
73
SetUpTestCase()74 void NetworkVpnClientTest::SetUpTestCase() {}
75
TearDownTestCase()76 void NetworkVpnClientTest::TearDownTestCase() {}
77
SetUp()78 void NetworkVpnClientTest::SetUp() {}
79
TearDown()80 void NetworkVpnClientTest::TearDown() {}
81
82 #ifdef SUPPORT_SYSVPN
AddSysVpnConfig()83 void NetworkVpnClientTest::AddSysVpnConfig() {}
84
DeleteSysVpnConfig()85 void NetworkVpnClientTest::DeleteSysVpnConfig() {}
86
GetSysVpnConfigList()87 void NetworkVpnClientTest::GetSysVpnConfigList() {}
88
GetSysVpnConfig()89 void NetworkVpnClientTest::GetSysVpnConfig() {}
90
GetConnectedSysVpnConfig()91 void NetworkVpnClientTest::GetConnectedSysVpnConfig() {}
92 #endif // SUPPORT_SYSVPN
93
94 HWTEST_F(NetworkVpnClientTest, Prepare001, TestSize.Level1)
95 {
96 bool isExistVpn = false;
97 bool isRun = false;
98 std::string pkg;
99 EXPECT_EQ(networkVpnClient_.Prepare(isExistVpn, isRun, pkg), NETMANAGER_ERR_PERMISSION_DENIED);
100 }
101
102 HWTEST_F(NetworkVpnClientTest, Prepare002, TestSize.Level1)
103 {
104 NetManagerExtAccessToken access;
105 bool isExistVpn = false;
106 bool isRun = false;
107 std::string pkg;
108 EXPECT_EQ(networkVpnClient_.Prepare(isExistVpn, isRun, pkg), NETMANAGER_EXT_SUCCESS);
109 }
110
111 HWTEST_F(NetworkVpnClientTest, Protect001, TestSize.Level1)
112 {
113 EXPECT_EQ(networkVpnClient_.Protect(0), NETWORKVPN_ERROR_INVALID_FD);
114 EXPECT_EQ(networkVpnClient_.Protect(1), NETMANAGER_ERR_PERMISSION_DENIED);
115 }
116
117 HWTEST_F(NetworkVpnClientTest, Protect002, TestSize.Level1)
118 {
119 NetManagerExtAccessToken access;
120 EXPECT_EQ(networkVpnClient_.Protect(1), NETMANAGER_EXT_SUCCESS);
121 }
122
123 HWTEST_F(NetworkVpnClientTest, SetUpVpn001, TestSize.Level1)
124 {
125 sptr<VpnConfig> config = nullptr;
126 int32_t tunFd = 0;
127 EXPECT_EQ(networkVpnClient_.SetUpVpn(config, tunFd), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
128 config = new (std::nothrow) VpnConfig();
129 EXPECT_EQ(networkVpnClient_.SetUpVpn(config, tunFd), NETMANAGER_ERR_PERMISSION_DENIED);
130 }
131
132 HWTEST_F(NetworkVpnClientTest, SetUpVpn002, TestSize.Level1)
133 {
134 NetManagerExtAccessToken access;
135 int32_t tunFd = 0;
136 sptr<VpnConfig> config = new (std::nothrow) VpnConfig();
137 EXPECT_EQ(networkVpnClient_.SetUpVpn(config, tunFd), NETMANAGER_EXT_SUCCESS);
138 EXPECT_EQ(networkVpnClient_.DestroyVpn(), NETMANAGER_EXT_SUCCESS);
139 }
140
141 HWTEST_F(NetworkVpnClientTest, RegisterVpnEvent001, TestSize.Level1)
142 {
143 EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
144 callback_ = new (std::nothrow) IVpnEventCallbackTest();
145 EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_ERR_PERMISSION_DENIED);
146 }
147
148 HWTEST_F(NetworkVpnClientTest, RegisterVpnEvent002, TestSize.Level1)
149 {
150 NetManagerExtAccessToken access;
151 EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
152 callback_ = new (std::nothrow) IVpnEventCallbackTest();
153 EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
154 }
155
156 HWTEST_F(NetworkVpnClientTest, UnregisterVpnEvent001, TestSize.Level1)
157 {
158 EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
159 callback_ = new (std::nothrow) IVpnEventCallbackTest();
160 EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_ERR_PERMISSION_DENIED);
161 }
162
163 HWTEST_F(NetworkVpnClientTest, UnregisterVpnEvent002, TestSize.Level1)
164 {
165 NetManagerExtAccessToken access;
166 EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
167 callback_ = new (std::nothrow) IVpnEventCallbackTest();
168 EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_EXT_ERR_OPERATION_FAILED);
169 }
170
171 HWTEST_F(NetworkVpnClientTest, GetProxy, TestSize.Level1)
172 {
173 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
174 sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
175 networkVpnClient_.networkVpnService_ = iface_cast<INetworkVpnService>(remote);
176 EXPECT_EQ(networkVpnClient_.GetProxy(), networkVpnClient_.networkVpnService_);
177 networkVpnClient_.networkVpnService_ = nullptr;
178 EXPECT_NE(networkVpnClient_.GetProxy(), nullptr);
179 }
180
181 HWTEST_F(NetworkVpnClientTest, OnRemoteDied, TestSize.Level1)
182 {
183 sptr<IRemoteObject> remote = nullptr;
184 networkVpnClient_.OnRemoteDied(remote);
185 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
186 remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
187 networkVpnClient_.networkVpnService_ = nullptr;
188 networkVpnClient_.OnRemoteDied(remote);
189 networkVpnClient_.networkVpnService_ = iface_cast<INetworkVpnService>(remote);
190 networkVpnClient_.OnRemoteDied(remote);
191 EXPECT_EQ(networkVpnClient_.networkVpnService_, nullptr);
192 }
193
194 HWTEST_F(NetworkVpnClientTest, NetworkVpnClientBranch001, TestSize.Level1)
195 {
196 callback_ = new (std::nothrow) IVpnEventCallbackTest();
197 callback_->OnVpnMultiUserSetUp();
198 networkVpnClient_.multiUserSetUpEvent();
199
200 auto ret = networkVpnClient_.CreateVpnConnection();
201 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
202 }
203
204 HWTEST_F(NetworkVpnClientTest, RegisterBundleName001, TestSize.Level1)
205 {
206 std::string bundleName = "com.test.test";
207 auto ret = networkVpnClient_.RegisterBundleName(bundleName);
208 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
209 }
210
211 HWTEST_F(NetworkVpnClientTest, ConnectControl, TestSize.Level1)
212 {
213 VpnInterface vpnInterface;
214 int32_t fd = -1;
215 int32_t nsec = 1;
216 int32_t ret = vpnInterface.ConnectControl(fd, nsec);
217 EXPECT_EQ(NETMANAGER_EXT_ERR_INTERNAL, ret);
218
219 fd = socket(AF_UNIX, SOCK_STREAM, 0);
220 ASSERT_GE(fd, 0);
221 ret = vpnInterface.ConnectControl(fd, nsec);
222 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
223 }
224
225 HWTEST_F(NetworkVpnClientTest, RecvMsgFromUnixServer, TestSize.Level1)
226 {
227 VpnInterface vpnInterface;
228 int32_t fd = -1;
229 int32_t ret = vpnInterface.RecvMsgFromUnixServer(fd);
230 EXPECT_EQ(NETMANAGER_EXT_ERR_INTERNAL, ret);
231 }
232
233 HWTEST_F(NetworkVpnClientTest, GetVpnInterfaceFd, TestSize.Level1)
234 {
235 VpnInterface vpnInterface;
236 int32_t fd = vpnInterface.GetVpnInterfaceFd();
237 EXPECT_GT(fd, 0);
238 }
239
240 #ifdef SUPPORT_SYSVPN
241 HWTEST_F(NetworkVpnClientTest, AddSysVpnConfig001, TestSize.Level1)
242 {
243 NetManagerExtAccessToken access;
244 std::string id = "1234";
245 sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
246 config->vpnId_ = id;
247 config->vpnName_ = "test";
248 config->vpnType_ = 1;
249 EXPECT_EQ(networkVpnClient_.AddSysVpnConfig(config), NETMANAGER_EXT_SUCCESS);
250 // delete test config
251 EXPECT_EQ(networkVpnClient_.DeleteSysVpnConfig(id), NETMANAGER_EXT_SUCCESS);
252 }
253
254 HWTEST_F(NetworkVpnClientTest, AddSysVpnConfig002, TestSize.Level1)
255 {
256 NetManagerExtAccessToken access;
257 std::string id = "1234";
258 sptr<SysVpnConfig> config = new (std::nothrow) SysVpnConfig();
259 config->vpnId_ = id;
260 config->vpnName_ = "test";
261 config->vpnType_ = 1;
262 EXPECT_EQ(networkVpnClient_.AddSysVpnConfig(config), NETMANAGER_EXT_ERR_READ_DATA_FAIL);
263 }
264
265 HWTEST_F(NetworkVpnClientTest, AddSysVpnConfig003, TestSize.Level1)
266 {
267 NetManagerExtAccessToken access;
268 sptr<SysVpnConfig> config = nullptr;
269 EXPECT_EQ(networkVpnClient_.AddSysVpnConfig(config), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
270 }
271
272 HWTEST_F(NetworkVpnClientTest, DeleteSysVpnConfig001, TestSize.Level1)
273 {
274 NetManagerExtAccessToken access;
275 std::string id = "1234";
276 sptr<SysVpnConfig> config = new (std::nothrow) IpsecVpnConfig();
277 config->vpnId_ = id;
278 config->vpnName_ = "test";
279 config->vpnType_ = 1;
280 EXPECT_EQ(networkVpnClient_.AddSysVpnConfig(config), NETMANAGER_EXT_SUCCESS);
281 // delete test config
282 EXPECT_EQ(networkVpnClient_.DeleteSysVpnConfig(id), NETMANAGER_EXT_SUCCESS);
283 }
284
285 HWTEST_F(NetworkVpnClientTest, DeleteSysVpnConfig002, TestSize.Level1)
286 {
287 NetManagerExtAccessToken access;
288 std::string id;
289 EXPECT_EQ(networkVpnClient_.DeleteSysVpnConfig(id), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
290 }
291
292 HWTEST_F(NetworkVpnClientTest, GetSysVpnConfigList001, TestSize.Level1)
293 {
294 NetManagerExtAccessToken access;
295 std::vector<SysVpnConfig> list;
296 EXPECT_EQ(networkVpnClient_.GetSysVpnConfigList(list), NETMANAGER_EXT_SUCCESS);
297 }
298
299 HWTEST_F(NetworkVpnClientTest, GetSysVpnConfig001, TestSize.Level1)
300 {
301 NetManagerExtAccessToken access;
302 std::string id = "1234";
303 sptr<SysVpnConfig> resConfig = nullptr;
304 EXPECT_EQ(networkVpnClient_.GetSysVpnConfig(resConfig, id), NETMANAGER_EXT_SUCCESS);
305 }
306
307 HWTEST_F(NetworkVpnClientTest, GetSysVpnConfig002, TestSize.Level1)
308 {
309 NetManagerExtAccessToken access;
310 std::string id;
311 sptr<SysVpnConfig> resConfig = nullptr;
312 EXPECT_EQ(networkVpnClient_.GetSysVpnConfig(resConfig, id), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
313 }
314
315 HWTEST_F(NetworkVpnClientTest, GetConnectedSysVpnConfig001, TestSize.Level1)
316 {
317 NetManagerExtAccessToken access;
318 sptr<SysVpnConfig> resConfig = nullptr;
319 EXPECT_EQ(networkVpnClient_.GetConnectedSysVpnConfig(resConfig), NETMANAGER_EXT_SUCCESS);
320 }
321 #endif // SUPPORT_SYSVPN
322 } // namespace NetManagerStandard
323 } // namespace OHOS
324