1 /*
2  * Copyright (c) 2022-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 #ifdef GTEST_API_
19 #define private public
20 #endif
21 #include "bpf_def.h"
22 #include "bpf_mapper.h"
23 #include "bpf_path.h"
24 #include "net_manager_constants.h"
25 #include "net_stats_constants.h"
26 #include "netsys_native_client.h"
27 
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 static constexpr const char *DESTINATION = "192.168.1.3/24";
33 static constexpr const char *NEXT_HOP = "192.168.1.1";
34 static constexpr const char *LOCALIP = "127.0.0.1";
35 static constexpr const char *IF_NAME = "iface0";
36 static constexpr const char *ETH0 = "eth0";
37 static constexpr const char *IFACE = "test0";
38 static constexpr const char *IP_ADDR = "172.17.5.245";
39 static constexpr const char *INTERFACE_NAME = "interface_name";
40 static constexpr const char *REQUESTOR = "requestor";
41 static constexpr const char *TCP_BUFFER_SIZES = "524288,1048576,2097152,262144,524288,1048576";
42 static constexpr uint64_t TEST_COOKIE = 1;
43 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
44 static constexpr uint32_t TEST_STATS_TYPE2 = 2;
45 const int32_t MTU = 111;
46 const int32_t NET_ID = 2;
47 const int32_t IFACEFD = 5;
48 const int64_t UID = 1010;
49 const int32_t APP_ID = 101010;
50 const int32_t SOCKET_FD = 5;
51 const int32_t PERMISSION = 5;
52 const int32_t STATRUID = 1000;
53 const int32_t ENDUID = 1100;
54 const int32_t PREFIX_LENGTH = 23;
55 const int32_t INVALID_ARGUMENTS = -22;
56 uint16_t BASE_TIMEOUT_MSEC = 200;
57 const int64_t CHAIN = 1010;
58 uint8_t RETRY_COUNT = 3;
59 const uint32_t FIREWALL_RULE = 1;
60 } // namespace
61 
62 class NetsysNativeClientTest : public testing::Test {
63 public:
64     static void SetUpTestCase();
65 
66     static void TearDownTestCase();
67 
68     void SetUp();
69 
70     void TearDown();
71     static inline NetsysNativeClient nativeClient_;
72 };
73 
SetUpTestCase()74 void NetsysNativeClientTest::SetUpTestCase() {}
75 
TearDownTestCase()76 void NetsysNativeClientTest::TearDownTestCase() {}
77 
SetUp()78 void NetsysNativeClientTest::SetUp() {}
79 
TearDown()80 void NetsysNativeClientTest::TearDown() {}
81 
82 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest001, TestSize.Level1)
83 {
84     int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
85     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
86 
87     ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
88     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
89 
90     ret = nativeClient_.NetworkDestroy(NET_ID);
91     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
92 
93     ret = nativeClient_.NetworkAddInterface(NET_ID, IF_NAME, BEARER_DEFAULT);
94     EXPECT_EQ(ret, -1);
95 
96     ret = nativeClient_.NetworkRemoveInterface(NET_ID, IF_NAME);
97     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
98 
99     ret = nativeClient_.NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
100     EXPECT_EQ(ret, INVALID_ARGUMENTS);
101 
102     ret = nativeClient_.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
103     EXPECT_EQ(ret, INVALID_ARGUMENTS);
104 
105     OHOS::nmd::InterfaceConfigurationParcel parcel;
106     ret = nativeClient_.GetInterfaceConfig(parcel);
107     EXPECT_EQ(ret, 0);
108 
109     ret = nativeClient_.SetInterfaceDown(IF_NAME);
110     EXPECT_EQ(ret, 0);
111 
112     ret = nativeClient_.SetInterfaceUp(IF_NAME);
113     EXPECT_EQ(ret, 0);
114 
115     nativeClient_.ClearInterfaceAddrs(IF_NAME);
116 
117     ret = nativeClient_.GetInterfaceMtu(IF_NAME);
118     EXPECT_EQ(ret, -1);
119 
120     ret = nativeClient_.SetInterfaceMtu(IF_NAME, MTU);
121     EXPECT_EQ(ret, -1);
122 
123     ret = nativeClient_.SetTcpBufferSizes(TCP_BUFFER_SIZES);
124     EXPECT_EQ(ret, 0);
125 }
126 
127 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest002, TestSize.Level1)
128 {
129     int32_t ret = nativeClient_.AddInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
130     EXPECT_EQ(ret, -19);
131 
132     ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
133     EXPECT_EQ(ret, -19);
134 
135     ret = nativeClient_.SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {});
136     EXPECT_EQ(ret, 0);
137 
138     std::vector<std::string> servers;
139     std::vector<std::string> domains;
140     ret = nativeClient_.GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT);
141     EXPECT_EQ(ret, 0);
142 
143     ret = nativeClient_.CreateNetworkCache(NET_ID);
144     EXPECT_EQ(ret, 0);
145 
146     ret = nativeClient_.DestroyNetworkCache(NET_ID);
147     EXPECT_EQ(ret, 0);
148 
149     nmd::NetworkSharingTraffic traffic;
150     ret = nativeClient_.GetNetworkSharingTraffic(ETH0, ETH0, traffic);
151     EXPECT_NE(ret, 0);
152 
153     ret = nativeClient_.GetCellularRxBytes();
154     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
155 
156     ret = nativeClient_.GetCellularTxBytes();
157     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
158 
159     ret = nativeClient_.GetAllRxBytes();
160     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
161 
162     ret = nativeClient_.GetAllTxBytes();
163     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
164 }
165 
166 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest003, TestSize.Level1)
167 {
168     int32_t ret = nativeClient_.GetUidRxBytes(NET_ID);
169     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
170 
171     ret = nativeClient_.GetUidTxBytes(NET_ID);
172     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
173 
174     ret = nativeClient_.GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME);
175     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
176 
177     ret = nativeClient_.GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME);
178     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
179 
180     ret = nativeClient_.GetIfaceRxBytes(INTERFACE_NAME);
181     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
182 
183     ret = nativeClient_.GetIfaceTxBytes(INTERFACE_NAME);
184     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
185 
186     std::vector<std::string> interFaceGetList = nativeClient_.InterfaceGetList();
187     EXPECT_NE(interFaceGetList.size(), 0U);
188 
189     std::vector<std::string> uidGetList = nativeClient_.UidGetList();
190     EXPECT_EQ(uidGetList.size(), 0U);
191 
192     ret = nativeClient_.GetIfaceRxPackets(INTERFACE_NAME);
193     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
194 
195     ret = nativeClient_.GetIfaceTxPackets(INTERFACE_NAME);
196     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
197 
198     std::vector<uint32_t> uids;
199     uids.push_back(UID);
200     ret = nativeClient_.FirewallSetUidsAllowedListChain(CHAIN, uids);
201     EXPECT_EQ(ret, -1);
202     ret = nativeClient_.FirewallSetUidsDeniedListChain(CHAIN, uids);
203     EXPECT_EQ(ret, -1);
204 }
205 
206 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest004, TestSize.Level1)
207 {
208     int32_t ret = nativeClient_.SetDefaultNetWork(NET_ID);
209     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
210 
211     ret = nativeClient_.ClearDefaultNetWorkNetId();
212     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
213 
214     ret = nativeClient_.BindSocket(SOCKET_FD, NET_ID);
215     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
216 
217     ret = nativeClient_.IpEnableForwarding(REQUESTOR);
218     EXPECT_EQ(ret, 0);
219 
220     ret = nativeClient_.IpDisableForwarding(REQUESTOR);
221     EXPECT_EQ(ret, 0);
222 
223     ret = nativeClient_.EnableNat(ETH0, ETH0);
224     EXPECT_EQ(ret, -1);
225 
226     ret = nativeClient_.DisableNat(ETH0, ETH0);
227     EXPECT_EQ(ret, -1);
228 
229     ret = nativeClient_.IpfwdAddInterfaceForward(ETH0, ETH0);
230     EXPECT_EQ(ret, -1);
231 
232     ret = nativeClient_.IpfwdRemoveInterfaceForward(ETH0, ETH0);
233     EXPECT_EQ(ret, -1);
234 
235     ret = nativeClient_.ShareDnsSet(NET_ID);
236     EXPECT_EQ(ret, 0);
237 
238     ret = nativeClient_.StartDnsProxyListen();
239     EXPECT_EQ(ret, 0);
240 
241     ret = nativeClient_.StopDnsProxyListen();
242     EXPECT_EQ(ret, 0);
243 
244     ret = nativeClient_.FirewallEnableChain(CHAIN, true);
245     EXPECT_EQ(ret, -1);
246     ret = nativeClient_.FirewallSetUidRule(CHAIN, {NET_ID}, FIREWALL_RULE);
247     EXPECT_EQ(ret, -1);
248 }
249 
250 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest005, TestSize.Level1)
251 {
252     uint64_t stats = 0;
253     int32_t ret = nativeClient_.GetTotalStats(stats, 0);
254     EXPECT_EQ(ret, 0);
255 
256     ret = nativeClient_.GetUidStats(stats, 0, APP_ID);
257     EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
258 
259     ret = nativeClient_.GetIfaceStats(stats, 0, IFACE);
260     EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED);
261 
262     std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
263     ret = nativeClient_.GetAllStatsInfo(statsInfo);
264     EXPECT_EQ(ret, 0);
265 
266     ret = nativeClient_.GetAllSimStatsInfo(statsInfo);
267     EXPECT_EQ(ret, 0);
268 }
269 
270 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest006, TestSize.Level1)
271 {
272     std::vector<UidRange> uidRanges;
273     std::vector<int32_t> beginUids;
274     std::vector<int32_t> endUids;
275     beginUids.push_back(STATRUID);
276     endUids.push_back(ENDUID);
277     for (size_t i = 0; i < beginUids.size(); i++) {
278         uidRanges.emplace_back(UidRange(beginUids[i], endUids[i]));
279     }
280     nativeClient_.NetworkAddUids(NET_ID, uidRanges);
281     nativeClient_.NetworkDelUids(NET_ID, uidRanges);
282     int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
283     EXPECT_EQ(ret, 0);
284 }
285 
286 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest007, TestSize.Level1)
287 {
288     NetsysNotifyCallback callback;
289     struct ifreq ifreq = {};
290     int32_t ret = nativeClient_.RegisterNetsysNotifyCallback(callback);
291     EXPECT_EQ(ret, 0);
292     ret = nativeClient_.BindNetworkServiceVpn(SOCKET_FD);
293     int32_t ifacefd1 = 0;
294     nativeClient_.EnableVirtualNetIfaceCard(SOCKET_FD, ifreq, ifacefd1);
295     int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
296     ret = nativeClient_.BindNetworkServiceVpn(sockfd);
297     int32_t ifacefd2 = 0;
298     nativeClient_.EnableVirtualNetIfaceCard(sockfd, ifreq, ifacefd2);
299     EXPECT_EQ(ret, 0);
300 }
301 
302 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest008, TestSize.Level1)
303 {
304     int32_t ret = nativeClient_.SetBlocking(IFACEFD, true);
305     EXPECT_EQ(ret, NETSYS_ERR_VPN);
306     struct ifreq ifreq = {};
307     int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
308     ret = nativeClient_.SetIpAddress(sockfd, LOCALIP, PREFIX_LENGTH, ifreq);
309     EXPECT_EQ(ret, NETSYS_ERR_VPN);
310 }
311 
312 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest009, TestSize.Level1)
313 {
314     NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
315     std::string ifName = "wlan";
316     bool up = true;
317     int32_t ret = notifyCallback.OnInterfaceChanged(ifName, up);
318     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
319 }
320 
321 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest010, TestSize.Level1)
322 {
323     NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
324     sptr<OHOS::NetsysNative::DhcpResultParcel> dhcpResult = new (std::nothrow) OHOS::NetsysNative::DhcpResultParcel();
325     int32_t ret = notifyCallback.OnDhcpSuccess(dhcpResult);
326     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
327 }
328 
329 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest011, TestSize.Level1)
330 {
331     NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
332     std::string limitName = "wlan";
333     std::string iface = "vpncard";
334     int32_t ret = notifyCallback.OnBandwidthReachedLimit(limitName, iface);
335     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
336 }
337 
338 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest013, TestSize.Level1)
339 {
340     wptr<IRemoteObject> remote = nullptr;
341     nativeClient_.OnRemoteDied(remote);
342     int handle = 1;
343     sptr<IRemoteObject> result = nullptr;
344     std::u16string descriptor = std::u16string();
345     result = new (std::nothrow) IPCObjectProxy(handle, descriptor);
346     IRemoteObject *object = result.GetRefPtr();
347     remote = object;
348     nativeClient_.OnRemoteDied(remote);
349     uint32_t uid = 0;
350     uint8_t allow = 0;
351     auto ret = nativeClient_.SetInternetPermission(uid, allow);
352     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
353 }
354 
355 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest014, TestSize.Level1)
356 {
357     std::string ipAddr = "192.168.1.100";
358     std::string macAddr = "aa:bb:cc:dd:ee:ff";
359     std::string ifName = "wlan0";
360     auto ret = nativeClient_.AddStaticArp(ipAddr, macAddr, ifName);
361     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
362 
363     ret = nativeClient_.DelStaticArp(ipAddr, macAddr, ifName);
364     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
365 }
366 
367 HWTEST_F(NetsysNativeClientTest, GetCookieStatsTest001, TestSize.Level1)
368 {
369     uint64_t stats = 0;
370     BpfMapper<socket_cookie_stats_key, app_cookie_stats_value> appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY);
371     int32_t ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
372     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
373     ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
374     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
375 }
376 
377 HWTEST_F(NetsysNativeClientTest, GetNetworkSharingTypeTest001, TestSize.Level1)
378 {
379     std::set<uint32_t> sharingTypeIsOn;
380     int32_t ret = nativeClient_.GetNetworkSharingType(sharingTypeIsOn);
381     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
382 }
383 
384 HWTEST_F(NetsysNativeClientTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
385 {
386     uint64_t type = 0;
387     bool isOpen = true;
388     int32_t ret = nativeClient_.UpdateNetworkSharingType(type, isOpen);
389     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
390 }
391 
392 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientBranchTest001, TestSize.Level1)
393 {
394     uint32_t timeStep = 0;
395     sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> callback = nullptr;
396     int32_t ret = nativeClient_.RegisterDnsResultCallback(callback, timeStep);
397     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
398     ret = nativeClient_.UnregisterDnsResultCallback(callback);
399     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
400 
401     sptr<OHOS::NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
402     ret = nativeClient_.RegisterDnsHealthCallback(healthCallback);
403     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
404     ret = nativeClient_.UnregisterDnsHealthCallback(healthCallback);
405     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
406 }
407 
408 HWTEST_F(NetsysNativeClientTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
409 {
410     uint32_t on = 0;
411     std::string interface = "wlan0";
412     int32_t ret = nativeClient_.SetIpv6PrivacyExtensions(interface, on);
413     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
414     ret = nativeClient_.SetEnableIpv6(interface, on);
415     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
416 }
417 
418 HWTEST_F(NetsysNativeClientTest, SetNetworkAccessPolicy001, TestSize.Level1)
419 {
420     uint32_t uid = 0;
421     NetworkAccessPolicy netAccessPolicy;
422     netAccessPolicy.wifiAllow = false;
423     netAccessPolicy.cellularAllow = false;
424     bool reconfirmFlag = true;
425     bool isBroker = false;
426     int32_t ret = nativeClient_.SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag, isBroker);
427     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
428 }
429 
430 HWTEST_F(NetsysNativeClientTest, NotifyNetBearerTypeChange001, TestSize.Level1)
431 {
432     std::set<NetManagerStandard::NetBearType> bearerTypes;
433     bearerTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
434     int32_t ret = nativeClient_.NotifyNetBearerTypeChange(bearerTypes);
435     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
436 }
437 
438 HWTEST_F(NetsysNativeClientTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
439 {
440     uint32_t uid = 0;
441     int32_t ret = nativeClient_.DeleteNetworkAccessPolicy(uid);
442     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
443 }
444 } // namespace NetManagerStandard
445 } // namespace OHOS
446