1 /*
2 * Copyright (c) 2022-2023 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 <algorithm>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include <iostream>
20
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24
25 #ifdef GTEST_API_
26 #define private public
27 #define protected public
28 #endif
29
30 #include "net_conn_constants.h"
31 #include "net_manager_constants.h"
32 #include "net_stats_constants.h"
33 #include "netsys_controller.h"
34
35 namespace OHOS {
36 namespace NetManagerStandard {
37 namespace {
38 using namespace testing::ext;
39 static constexpr const char *IFACE = "test0";
40 static constexpr const char *WLAN = "wlan0";
41 static constexpr const char *ETH0 = "eth0";
42 static constexpr const char *DESTINATION = "192.168.1.3/24";
43 static constexpr const char *NEXT_HOP = "192.168.1.1";
44 static constexpr const char *PARCEL_IPV4_ADDR = "192.168.55.121";
45 static constexpr const char *IP_ADDR = "172.17.5.245";
46 static constexpr const char *INTERFACE_NAME = "";
47 static constexpr const char *IF_NAME = "iface0";
48 const int NET_ID = 2;
49 const int PERMISSION = 5;
50 const int PREFIX_LENGTH = 23;
51 const int TEST_MTU = 111;
52 uint16_t g_baseTimeoutMsec = 200;
53 uint8_t g_retryCount = 3;
54 const int64_t TEST_UID = 1010;
55 const int32_t SOCKET_FD = 5;
56 const int32_t TEST_STATS_UID = 11111;
57 int g_ifaceFd = 5;
58 const int64_t BYTES = 2097152;
59 const uint32_t FIREWALL_RULE = 1;
60
61 using namespace Security::AccessToken;
62 using Security::AccessToken::AccessTokenID;
63 HapInfoParams testInfoParms1 = {.userID = 1,
64 .bundleName = "netsys_native_manager_test",
65 .instIndex = 0,
66 .appIDDesc = "test"};
67 PermissionDef testPermDef1 = {.permissionName = "ohos.permission.NETSYS_INTERNAL",
68 .bundleName = "netsys_native_manager_test",
69 .grantMode = 1,
70 .availableLevel = APL_SYSTEM_BASIC,
71 .label = "label",
72 .labelId = 1,
73 .description = "Test netsys_native_manager_test",
74 .descriptionId = 1};
75
76 PermissionStateFull testState1 = {.permissionName = "ohos.permission.NETSYS_INTERNAL",
77 .isGeneral = true,
78 .resDeviceID = {"local"},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED},
80 .grantFlags = {2}};
81
82 HapPolicyParams testPolicyPrams1 = {.apl = APL_SYSTEM_BASIC,
83 .domain = "test.domain",
84 .permList = {testPermDef1},
85 .permStateList = {testState1}};
86 } // namespace
87
88 class AccessToken {
89 public:
AccessToken(HapInfoParams & testInfoParms,HapPolicyParams & testPolicyPrams)90 AccessToken(HapInfoParams &testInfoParms, HapPolicyParams &testPolicyPrams) : currentID_(GetSelfTokenID())
91 {
92 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testPolicyPrams);
93 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
94 SetSelfTokenID(tokenIdEx.tokenIDEx);
95 }
~AccessToken()96 ~AccessToken()
97 {
98 AccessTokenKit::DeleteToken(accessID_);
99 SetSelfTokenID(currentID_);
100 }
101
102 private:
103 AccessTokenID currentID_;
104 AccessTokenID accessID_ = 0;
105 };
106
107 class NetsysControllerCallbackTest : public NetsysControllerCallback {
108 public:
OnInterfaceAddressUpdated(const std::string &,const std::string &,int,int)109 virtual int32_t OnInterfaceAddressUpdated(const std::string &, const std::string &, int, int)
110 {
111 return 0;
112 }
OnInterfaceAddressRemoved(const std::string &,const std::string &,int,int)113 virtual int32_t OnInterfaceAddressRemoved(const std::string &, const std::string &, int, int)
114 {
115 return 0;
116 }
OnInterfaceAdded(const std::string &)117 virtual int32_t OnInterfaceAdded(const std::string &)
118 {
119 return 0;
120 }
OnInterfaceRemoved(const std::string &)121 virtual int32_t OnInterfaceRemoved(const std::string &)
122 {
123 return 0;
124 }
OnInterfaceChanged(const std::string &,bool)125 virtual int32_t OnInterfaceChanged(const std::string &, bool)
126 {
127 return 0;
128 }
OnInterfaceLinkStateChanged(const std::string &,bool)129 virtual int32_t OnInterfaceLinkStateChanged(const std::string &, bool)
130 {
131 return 0;
132 }
OnRouteChanged(bool,const std::string &,const std::string &,const std::string &)133 virtual int32_t OnRouteChanged(bool, const std::string &, const std::string &, const std::string &)
134 {
135 return 0;
136 }
OnDhcpSuccess(NetsysControllerCallback::DhcpResult & dhcpResult)137 virtual int32_t OnDhcpSuccess(NetsysControllerCallback::DhcpResult &dhcpResult)
138 {
139 return 0;
140 }
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)141 virtual int32_t OnBandwidthReachedLimit(const std::string &limitName, const std::string &iface)
142 {
143 return 0;
144 }
145 };
146
147 class NetsysControllerTest : public testing::Test {
148 public:
149 static void SetUpTestCase();
150
151 static void TearDownTestCase();
152
153 void SetUp();
154
155 void TearDown();
156
157 static inline std::shared_ptr<NetsysController> instance_ = nullptr;
158 };
159
SetUpTestCase()160 void NetsysControllerTest::SetUpTestCase()
161 {
162 instance_ = std::make_shared<NetsysController>();
163 }
164
TearDownTestCase()165 void NetsysControllerTest::TearDownTestCase() {}
166
SetUp()167 void NetsysControllerTest::SetUp() {}
168
TearDown()169 void NetsysControllerTest::TearDown() {}
170
171 HWTEST_F(NetsysControllerTest, NetsysControllerTest001, TestSize.Level1)
172 {
173 int32_t ret = NetsysController::GetInstance().NetworkCreatePhysical(NET_ID, PERMISSION);
174 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
175
176 ret = NetsysController::GetInstance().NetworkDestroy(NET_ID);
177 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
178 }
179
180 HWTEST_F(NetsysControllerTest, NetsysControllerTest002, TestSize.Level1)
181 {
182 int32_t ret = NetsysController::GetInstance().NetworkAddInterface(NET_ID, WLAN);
183 EXPECT_EQ(ret, -1);
184
185 ret = NetsysController::GetInstance().NetworkRemoveInterface(NET_ID, WLAN);
186 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
187 }
188
189 HWTEST_F(NetsysControllerTest, NetsysControllerTest003, TestSize.Level1)
190 {
191 int32_t ret = NetsysController::GetInstance().NetworkAddRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP);
192 EXPECT_LE(ret, 0);
193
194 ret = NetsysController::GetInstance().NetworkRemoveRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP);
195 EXPECT_LE(ret, 0);
196 }
197
198 HWTEST_F(NetsysControllerTest, NetsysControllerTest004, TestSize.Level1)
199 {
200 OHOS::nmd::InterfaceConfigurationParcel parcel;
201 parcel.ifName = ETH0;
202 parcel.ipv4Addr = PARCEL_IPV4_ADDR;
203 int32_t ret = NetsysController::GetInstance().SetInterfaceConfig(parcel);
204 EXPECT_EQ(ret, 0);
205
206 ret = NetsysController::GetInstance().GetInterfaceConfig(parcel);
207 EXPECT_EQ(ret, 0);
208 }
209
210 HWTEST_F(NetsysControllerTest, NetsysControllerTest005, TestSize.Level1)
211 {
212 int32_t ret = NetsysController::GetInstance().SetInterfaceDown(ETH0);
213 EXPECT_EQ(ret, 0);
214
215 ret = NetsysController::GetInstance().SetInterfaceUp(ETH0);
216 EXPECT_EQ(ret, 0);
217
218 NetsysController::GetInstance().ClearInterfaceAddrs(ETH0);
219 }
220
221 HWTEST_F(NetsysControllerTest, NetsysControllerTest006, TestSize.Level1)
222 {
223 int32_t ret = NetsysController::GetInstance().SetInterfaceMtu(ETH0, TEST_MTU);
224 EXPECT_EQ(ret, -1);
225
226 ret = NetsysController::GetInstance().GetInterfaceMtu(ETH0);
227 EXPECT_EQ(ret, -1);
228 }
229
230 HWTEST_F(NetsysControllerTest, NetsysControllerTest007, TestSize.Level1)
231 {
232 auto ifaceList = NetsysController::GetInstance().InterfaceGetList();
233 bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), std::string(ETH0)) == ifaceList.end();
234 if (eth0NotExist) {
235 return;
236 }
237
238 int32_t ret = NetsysController::GetInstance().AddInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH);
239 EXPECT_EQ(ret, 0);
240
241 ret = NetsysController::GetInstance().DelInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH);
242 EXPECT_EQ(ret, 0);
243 }
244
245 HWTEST_F(NetsysControllerTest, NetsysControllerTest008, TestSize.Level1)
246 {
247 int32_t ret = NetsysController::GetInstance().SetResolverConfig(NET_ID, g_baseTimeoutMsec, g_retryCount, {}, {});
248 EXPECT_EQ(ret, 0);
249
250 std::vector<std::string> servers;
251 std::vector<std::string> domains;
252 ret = NetsysController::GetInstance().GetResolverConfig(NET_ID, servers, domains, g_baseTimeoutMsec, g_retryCount);
253 EXPECT_EQ(ret, 0);
254 }
255
256 HWTEST_F(NetsysControllerTest, NetsysControllerTest009, TestSize.Level1)
257 {
258 int32_t ret = NetsysController::GetInstance().CreateNetworkCache(NET_ID);
259 EXPECT_EQ(ret, 0);
260
261 ret = NetsysController::GetInstance().DestroyNetworkCache(NET_ID);
262 EXPECT_EQ(ret, 0);
263 }
264
265 HWTEST_F(NetsysControllerTest, NetsysControllerTest010, TestSize.Level1)
266 {
267 nmd::NetworkSharingTraffic traffic;
268 int32_t ret = NetsysController::GetInstance().GetNetworkSharingTraffic(ETH0, ETH0, traffic);
269 EXPECT_EQ(ret, -1);
270 }
271
272 HWTEST_F(NetsysControllerTest, NetsysControllerTest011, TestSize.Level1)
273 {
274 int32_t ret = NetsysController::GetInstance().GetCellularRxBytes();
275 EXPECT_EQ(ret, 0);
276
277 ret = NetsysController::GetInstance().GetCellularTxBytes();
278 EXPECT_EQ(ret, 0);
279
280 ret = NetsysController::GetInstance().GetAllRxBytes();
281 EXPECT_GE(ret, 0);
282
283 ret = NetsysController::GetInstance().GetAllTxBytes();
284 EXPECT_GE(ret, 0);
285
286 ret = NetsysController::GetInstance().GetUidRxBytes(TEST_UID);
287 EXPECT_EQ(ret, -1);
288
289 ret = NetsysController::GetInstance().GetUidTxBytes(TEST_UID);
290 EXPECT_EQ(ret, -1);
291
292 ret = NetsysController::GetInstance().GetUidOnIfaceRxBytes(TEST_UID, INTERFACE_NAME);
293 EXPECT_GE(ret, 0);
294
295 ret = NetsysController::GetInstance().GetUidOnIfaceTxBytes(TEST_UID, INTERFACE_NAME);
296 EXPECT_GE(ret, 0);
297
298 ret = NetsysController::GetInstance().GetIfaceRxBytes(INTERFACE_NAME);
299 EXPECT_EQ(ret, 0);
300
301 ret = NetsysController::GetInstance().GetIfaceTxBytes(INTERFACE_NAME);
302 EXPECT_EQ(ret, 0);
303 }
304
305 HWTEST_F(NetsysControllerTest, NetsysControllerTest012, TestSize.Level1)
306 {
307 std::vector<std::string> getList = NetsysController::GetInstance().InterfaceGetList();
308
309 getList.clear();
310 getList = NetsysController::GetInstance().UidGetList();
311 EXPECT_EQ(getList.size(), 0);
312
313 int64_t ret = NetsysController::GetInstance().GetIfaceRxPackets(INTERFACE_NAME);
314 EXPECT_EQ(ret, 0);
315
316 ret = NetsysController::GetInstance().GetIfaceTxPackets(INTERFACE_NAME);
317 EXPECT_EQ(ret, 0);
318
319 ret = NetsysController::GetInstance().SetDefaultNetWork(NET_ID);
320 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
321
322 ret = NetsysController::GetInstance().ClearDefaultNetWorkNetId();
323 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
324 }
325
326 HWTEST_F(NetsysControllerTest, NetsysControllerTest013, TestSize.Level1)
327 {
328 int32_t ret = NetsysController::GetInstance().BindSocket(SOCKET_FD, NET_ID);
329 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
330
331 ret = NetsysController::GetInstance().IpEnableForwarding(INTERFACE_NAME);
332 EXPECT_EQ(ret, 0);
333
334 ret = NetsysController::GetInstance().IpDisableForwarding(INTERFACE_NAME);
335 EXPECT_EQ(ret, 0);
336
337 ret = NetsysController::GetInstance().EnableNat(ETH0, ETH0);
338 EXPECT_NE(ret, 0);
339
340 ret = NetsysController::GetInstance().DisableNat(ETH0, ETH0);
341 EXPECT_NE(ret, 0);
342
343 ret = NetsysController::GetInstance().IpfwdAddInterfaceForward(ETH0, ETH0);
344 EXPECT_NE(ret, 0);
345
346 ret = NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ETH0, ETH0);
347 EXPECT_NE(ret, 0);
348 }
349
350 HWTEST_F(NetsysControllerTest, NetsysControllerTest014, TestSize.Level1)
351 {
352 int32_t ret = NetsysController::GetInstance().ShareDnsSet(NET_ID);
353 EXPECT_EQ(ret, 0);
354
355 ret = NetsysController::GetInstance().StartDnsProxyListen();
356 EXPECT_EQ(ret, 0);
357
358 ret = NetsysController::GetInstance().StopDnsProxyListen();
359 EXPECT_EQ(ret, 0);
360
361 ret = NetsysController::GetInstance().BindNetworkServiceVpn(SOCKET_FD);
362 EXPECT_EQ(ret, 0);
363
364 ifreq ifRequest;
365 ret = NetsysController::GetInstance().EnableVirtualNetIfaceCard(SOCKET_FD, ifRequest, g_ifaceFd);
366 EXPECT_EQ(ret, 0);
367
368 ret = NetsysController::GetInstance().SetIpAddress(SOCKET_FD, IP_ADDR, PREFIX_LENGTH, ifRequest);
369 EXPECT_EQ(ret, 0);
370
371 ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, true);
372 EXPECT_EQ(ret, 0);
373
374 ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, false);
375 EXPECT_EQ(ret, 0);
376
377 ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, true);
378 EXPECT_EQ(ret, 0);
379
380 ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, false);
381 EXPECT_EQ(ret, 0);
382
383 ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, true);
384 EXPECT_EQ(ret, 0);
385
386 ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, false);
387 EXPECT_EQ(ret, 0);
388
389 ret = NetsysController::GetInstance().StartDhcpService(INTERFACE_NAME, IP_ADDR);
390 EXPECT_EQ(ret, 0);
391
392 ret = NetsysController::GetInstance().StopDhcpService(INTERFACE_NAME);
393 EXPECT_EQ(ret, 0);
394 }
395
396 HWTEST_F(NetsysControllerTest, NetsysControllerTest015, TestSize.Level1)
397 {
398 NetsysController::GetInstance().BandwidthEnableDataSaver(false);
399 int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true);
400 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
401
402 ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(IF_NAME, BYTES);
403 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
404
405 ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(WLAN, BYTES);
406 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
407
408 ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(IF_NAME);
409 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
410
411 ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(WLAN);
412 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
413
414 ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
415 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
416
417 ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID);
418 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
419
420 ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
421 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
422
423 ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID);
424 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
425
426 std::vector<uint32_t> uids;
427 uids.push_back(TEST_UID);
428 ret = NetsysController::GetInstance().FirewallSetUidsAllowedListChain(TEST_UID, uids);
429 EXPECT_NE(ret, 0);
430 ret = NetsysController::GetInstance().FirewallSetUidsDeniedListChain(TEST_UID, uids);
431 EXPECT_NE(ret, 0);
432
433 ret = NetsysController::GetInstance().FirewallEnableChain(TEST_UID, true);
434 EXPECT_NE(ret, 0);
435
436 ret = NetsysController::GetInstance().FirewallSetUidRule(TEST_UID, {TEST_UID}, FIREWALL_RULE);
437 EXPECT_NE(ret, 0);
438 }
439
440 HWTEST_F(NetsysControllerTest, NetsysControllerTest016, TestSize.Level1)
441 {
442 int32_t ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.x.x");
443 EXPECT_NE(ret, 0);
444
445 ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.2.0");
446 EXPECT_EQ(ret, -1);
447
448 ret = NetsysController::GetInstance().InterfaceSetIffUp("");
449 EXPECT_NE(ret, 0);
450
451 ret = NetsysController::GetInstance().InterfaceSetIffUp("ifaceName");
452 EXPECT_EQ(ret, -1);
453
454 std::string hostName = "";
455 std::string serverName = "";
456 AddrInfo hints;
457 uint16_t netId = 0;
458 std::vector<AddrInfo> res;
459
460 ret = NetsysController::GetInstance().GetAddrInfo(hostName, serverName, hints, netId, res);
461 EXPECT_NE(ret, 0);
462
463 auto callback = new NetsysControllerCallbackTest();
464 ret = NetsysController::GetInstance().RegisterCallback(callback);
465 EXPECT_EQ(ret, 0);
466 }
467
468 HWTEST_F(NetsysControllerTest, NetsysControllerTest017, TestSize.Level1)
469 {
470 uint64_t stats = 0;
471 int32_t ret = NetsysController::GetInstance().GetTotalStats(stats, 0);
472 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
473
474 stats = 0;
475 ret = NetsysController::GetInstance().GetUidStats(stats, 0, TEST_STATS_UID);
476 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
477
478 stats = 0;
479 ret = NetsysController::GetInstance().GetIfaceStats(stats, 0, IFACE);
480 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED);
481
482 stats = 0;
483 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
484 ret = NetsysController::GetInstance().GetAllStatsInfo(statsInfo);
485 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
486 }
487
488 HWTEST_F(NetsysControllerTest, NetsysControllerTest018, TestSize.Level1)
489 {
490 std::string respond;
491 int32_t ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond);
492 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_NET_CONN_MANAGER);
493
494 AccessToken token(testInfoParms1, testPolicyPrams1);
495 ret = NetsysController::GetInstance().SetIptablesCommandForRes("abc", respond);
496 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INVALID_PARAMETER);
497
498 ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond);
499 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
500 }
501
502 HWTEST_F(NetsysControllerTest, NetsysControllerErr001, TestSize.Level1)
503 {
504 std::vector<int32_t> beginUids;
505 std::vector<int32_t> endUids;
506 std::string iface = "test";
507 OHOS::nmd::InterfaceConfigurationParcel Parcel;
508
509 int32_t ret = instance_->SetInternetPermission(0, 0);
510 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
511
512 ret = instance_->NetworkCreateVirtual(0, false);
513 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
514
515 ret = instance_->NetworkDestroy(0);
516 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
517
518 ret = instance_->NetworkAddUids(0, beginUids, endUids);
519 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
520
521 ret = instance_->NetworkDelUids(0, beginUids, endUids);
522 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
523
524 ret = instance_->NetworkAddInterface(0, iface);
525 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
526
527 ret = instance_->NetworkRemoveInterface(0, iface);
528 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
529
530 ret = instance_->NetworkAddRoute(0, iface, iface, iface);
531 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
532
533 ret = instance_->NetworkRemoveRoute(0, iface, iface, iface);
534 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
535
536 ret = instance_->GetInterfaceConfig(Parcel);
537 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
538
539 ret = instance_->SetInterfaceConfig(Parcel);
540 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
541
542 ret = instance_->SetInterfaceDown(iface);
543 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
544
545 ret = instance_->SetInterfaceUp(iface);
546 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
547
548 instance_->ClearInterfaceAddrs(iface);
549 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
550
551 ret = instance_->GetInterfaceMtu(iface);
552 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
553
554 ret = instance_->SetInterfaceMtu(iface, 0);
555 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
556 }
557
558 HWTEST_F(NetsysControllerTest, NetsysControllerErr002, TestSize.Level1)
559 {
560 std::string iface = "test";
561 std::vector<std::string> servers;
562 uint16_t baseTimeoutMsec = 0;
563 uint8_t retryCount = 0;
564 AddrInfo hints = {0};
565 std::vector<AddrInfo> res;
566 nmd::NetworkSharingTraffic traffic;
567 addrinfo *aihead = static_cast<addrinfo *>(malloc(sizeof(addrinfo)));
568 if (aihead != nullptr) {
569 aihead->ai_next = nullptr;
570 aihead->ai_addr = static_cast<sockaddr *>(malloc(sizeof(sockaddr)));
571 }
572 if (aihead != nullptr) {
573 aihead->ai_canonname = static_cast<char *>(malloc(10));
574 }
575
576 int32_t ret = instance_->AddInterfaceAddress(iface, iface, 0);
577 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
578
579 ret = instance_->DelInterfaceAddress(iface, iface, 0);
580 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
581
582 ret = instance_->InterfaceSetIpAddress(iface, iface);
583 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
584
585 ret = instance_->InterfaceSetIffUp(iface);
586 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
587
588 ret = instance_->SetResolverConfig(0, 0, 0, servers, servers);
589 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
590
591 ret = instance_->GetResolverConfig(0, servers, servers, baseTimeoutMsec, retryCount);
592 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
593
594 ret = instance_->CreateNetworkCache(0);
595 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
596
597 ret = instance_->DestroyNetworkCache(0);
598 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
599
600 instance_->FreeAddrInfo(aihead);
601 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
602
603 ret = instance_->GetAddrInfo(iface, iface, hints, 0, res);
604 EXPECT_EQ(ret, NetManagerStandard::NetConnResultCode::NET_CONN_ERR_SERVICE_UPDATE_NET_LINK_INFO_FAIL);
605
606 ret = instance_->GetNetworkSharingTraffic(iface, iface, traffic);
607 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
608 }
609
610 HWTEST_F(NetsysControllerTest, NetsysControllerErr003, TestSize.Level1)
611 {
612 std::string iface = "test";
613
614 auto ret = instance_->GetCellularRxBytes();
615 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
616
617 ret = instance_->GetCellularTxBytes();
618 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
619
620 ret = instance_->GetAllRxBytes();
621 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
622
623 ret = instance_->GetAllTxBytes();
624 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
625
626 ret = instance_->GetUidRxBytes(0);
627 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
628
629 ret = instance_->GetUidTxBytes(0);
630 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
631
632 ret = instance_->GetUidOnIfaceRxBytes(0, iface);
633 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
634
635 ret = instance_->GetUidOnIfaceTxBytes(0, iface);
636 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
637
638 ret = instance_->GetIfaceRxBytes(iface);
639 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
640
641 ret = instance_->GetIfaceTxBytes(iface);
642 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
643
644 ret = instance_->GetIfaceRxPackets(iface);
645 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
646
647 ret = instance_->GetIfaceTxPackets(iface);
648 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
649 }
650
651 HWTEST_F(NetsysControllerTest, NetsysControllerErr004, TestSize.Level1)
652 {
653 std::string iface = "test";
654 NetsysNotifyCallback callback;
655
656 auto faceList = instance_->InterfaceGetList();
657 EXPECT_EQ(faceList.size(), 0);
658
659 auto uidList = instance_->UidGetList();
660 EXPECT_EQ(uidList.size(), 0);
661
662 auto ret = instance_->SetDefaultNetWork(0);
663 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
664
665 ret = instance_->ClearDefaultNetWorkNetId();
666 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
667
668 ret = instance_->BindSocket(0, 0);
669 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
670
671 ret = instance_->IpEnableForwarding(iface);
672 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
673
674 ret = instance_->IpDisableForwarding(iface);
675 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
676
677 ret = instance_->EnableNat(iface, iface);
678 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
679
680 ret = instance_->DisableNat(iface, iface);
681 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
682
683 ret = instance_->IpfwdAddInterfaceForward(iface, iface);
684 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
685
686 ret = instance_->IpfwdRemoveInterfaceForward(iface, iface);
687 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
688
689 ret = instance_->ShareDnsSet(0);
690 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
691
692 ret = instance_->StartDnsProxyListen();
693 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
694
695 ret = instance_->StopDnsProxyListen();
696 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
697
698 ret = instance_->RegisterNetsysNotifyCallback(callback);
699 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
700 }
701
702 HWTEST_F(NetsysControllerTest, NetsysControllerErr005, TestSize.Level1)
703 {
704 std::string iface = "test";
705 struct ifreq ifRequest;
706 int32_t ifaceFd = 0;
707 sptr<NetsysControllerCallback> callback;
708 auto ret = instance_->BindNetworkServiceVpn(0);
709 EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
710
711 ret = instance_->BindNetworkServiceVpn(1);
712 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
713
714 ret = instance_->EnableVirtualNetIfaceCard(0, ifRequest, ifaceFd);
715 EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
716
717 ret = instance_->EnableVirtualNetIfaceCard(1, ifRequest, ifaceFd);
718 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
719
720 ret = instance_->SetIpAddress(0, iface, 0, ifRequest);
721 EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
722
723 ret = instance_->SetIpAddress(1, iface, 1, ifRequest);
724 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
725
726 ret = instance_->SetBlocking(0, false);
727 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
728
729 ret = instance_->StartDhcpClient(iface, false);
730 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
731
732 ret = instance_->StopDhcpClient(iface, false);
733 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
734
735 ret = instance_->StartDhcpService(iface, iface);
736 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
737
738 ret = instance_->StopDhcpService(iface);
739 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
740
741 ret = instance_->BandwidthEnableDataSaver(false);
742 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
743
744 ret = instance_->BandwidthSetIfaceQuota(iface, 0);
745 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
746
747 ret = instance_->BandwidthRemoveIfaceQuota(iface);
748 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
749
750 ret = instance_->BandwidthAddDeniedList(0);
751 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
752
753 ret = instance_->BandwidthRemoveDeniedList(0);
754 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
755
756 ret = instance_->BandwidthAddAllowedList(0);
757 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
758
759 ret = instance_->BandwidthRemoveAllowedList(0);
760 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
761 }
762
763 HWTEST_F(NetsysControllerTest, NetsysControllerErr006, TestSize.Level1)
764 {
765 std::string iface = "test";
766 std::vector<uint32_t> uids;
767 uint64_t stats = 0;
768 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
769
770 auto ret = instance_->FirewallSetUidsAllowedListChain(0, uids);
771 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
772
773 ret = instance_->FirewallSetUidsDeniedListChain(0, uids);
774 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
775
776 ret = instance_->FirewallEnableChain(0, false);
777 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
778
779 ret = instance_->FirewallSetUidRule(0, uids, 0);
780 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
781
782 ret = instance_->GetTotalStats(stats, 0);
783 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
784
785 ret = instance_->GetUidStats(stats, 0, 0);
786 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
787
788 ret = instance_->GetIfaceStats(stats, 0, iface);
789 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
790
791 ret = instance_->GetAllStatsInfo(statsInfo);
792 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
793
794 ret = instance_->SetIptablesCommandForRes(iface, iface);
795 EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
796 }
797
798 } // namespace NetManagerStandard
799 } // namespace OHOS
800