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 <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #endif
21 #include "net_manager_constants.h"
22 #include "net_stats_constants.h"
23 #include "netsys_native_client.h"
24
25 namespace OHOS {
26 namespace NetManagerStandard {
27 namespace {
28 using namespace testing::ext;
29 static constexpr const char *DESTINATION = "192.168.1.3/24";
30 static constexpr const char *NEXT_HOP = "192.168.1.1";
31 static constexpr const char *LOCALIP = "127.0.0.1";
32 static constexpr const char *IF_NAME = "iface0";
33 static constexpr const char *ETH0 = "eth0";
34 static constexpr const char *IFACE = "test0";
35 static constexpr const char *IP_ADDR = "172.17.5.245";
36 static constexpr const char *INTERFACE_NAME = "interface_name";
37 static constexpr const char *REQUESTOR = "requestor";
38 const int32_t MTU = 111;
39 const int32_t NET_ID = 2;
40 const int32_t IFACEFD = 5;
41 const int64_t UID = 1010;
42 const int32_t APP_ID = 101010;
43 const int32_t SOCKET_FD = 5;
44 const int32_t PERMISSION = 5;
45 const int32_t STATRUID = 1000;
46 const int32_t ENDUID = 1100;
47 const int32_t PREFIX_LENGTH = 23;
48 uint16_t BASE_TIMEOUT_MSEC = 200;
49 const int64_t CHAIN = 1010;
50 uint8_t RETRY_COUNT = 3;
51 const uint32_t FIREWALL_RULE = 1;
52 } // namespace
53
54 class NetsysNativeClientTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57
58 static void TearDownTestCase();
59
60 void SetUp();
61
62 void TearDown();
63 static inline NetsysNativeClient nativeClient_;
64 };
65
SetUpTestCase()66 void NetsysNativeClientTest::SetUpTestCase() {}
67
TearDownTestCase()68 void NetsysNativeClientTest::TearDownTestCase() {}
69
SetUp()70 void NetsysNativeClientTest::SetUp() {}
71
TearDown()72 void NetsysNativeClientTest::TearDown() {}
73
74 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest001, TestSize.Level1)
75 {
76 int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
77 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
78
79 ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
80 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
81
82 ret = nativeClient_.NetworkDestroy(NET_ID);
83 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
84
85 ret = nativeClient_.NetworkAddInterface(NET_ID, IF_NAME);
86 EXPECT_EQ(ret, -1);
87
88 ret = nativeClient_.NetworkRemoveInterface(NET_ID, IF_NAME);
89 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
90
91 ret = nativeClient_.NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
92 EXPECT_EQ(ret, -1);
93
94 ret = nativeClient_.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
95 EXPECT_EQ(ret, -1);
96
97 OHOS::nmd::InterfaceConfigurationParcel parcel;
98 ret = nativeClient_.GetInterfaceConfig(parcel);
99 EXPECT_EQ(ret, 0);
100
101 ret = nativeClient_.SetInterfaceDown(IF_NAME);
102 EXPECT_EQ(ret, 0);
103
104 ret = nativeClient_.SetInterfaceUp(IF_NAME);
105 EXPECT_EQ(ret, 0);
106
107 nativeClient_.ClearInterfaceAddrs(IF_NAME);
108
109 ret = nativeClient_.GetInterfaceMtu(IF_NAME);
110 EXPECT_EQ(ret, -1);
111
112 ret = nativeClient_.SetInterfaceMtu(IF_NAME, MTU);
113 EXPECT_EQ(ret, -1);
114 }
115
116 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest002, TestSize.Level1)
117 {
118 int32_t ret = nativeClient_.AddInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
119 EXPECT_EQ(ret, -19);
120
121 ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
122 EXPECT_EQ(ret, -19);
123
124 ret = nativeClient_.SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {});
125 EXPECT_EQ(ret, 0);
126
127 std::vector<std::string> servers;
128 std::vector<std::string> domains;
129 ret = nativeClient_.GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT);
130 EXPECT_EQ(ret, 0);
131
132 ret = nativeClient_.CreateNetworkCache(NET_ID);
133 EXPECT_EQ(ret, 0);
134
135 ret = nativeClient_.DestroyNetworkCache(NET_ID);
136 EXPECT_EQ(ret, 0);
137
138 nmd::NetworkSharingTraffic traffic;
139 ret = nativeClient_.GetNetworkSharingTraffic(ETH0, ETH0, traffic);
140 EXPECT_NE(ret, 0);
141
142 ret = nativeClient_.GetCellularRxBytes();
143 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
144
145 ret = nativeClient_.GetCellularTxBytes();
146 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
147
148 ret = nativeClient_.GetAllRxBytes();
149 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
150
151 ret = nativeClient_.GetAllTxBytes();
152 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
153 }
154
155 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest003, TestSize.Level1)
156 {
157 int32_t ret = nativeClient_.GetUidRxBytes(NET_ID);
158 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
159
160 ret = nativeClient_.GetUidTxBytes(NET_ID);
161 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
162
163 ret = nativeClient_.GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME);
164 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
165
166 ret = nativeClient_.GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME);
167 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
168
169 ret = nativeClient_.GetIfaceRxBytes(INTERFACE_NAME);
170 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
171
172 ret = nativeClient_.GetIfaceTxBytes(INTERFACE_NAME);
173 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
174
175 std::vector<std::string> interFaceGetList = nativeClient_.InterfaceGetList();
176 EXPECT_NE(interFaceGetList.size(), 0U);
177
178 std::vector<std::string> uidGetList = nativeClient_.UidGetList();
179 EXPECT_EQ(uidGetList.size(), 0U);
180
181 ret = nativeClient_.GetIfaceRxPackets(INTERFACE_NAME);
182 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
183
184 ret = nativeClient_.GetIfaceTxPackets(INTERFACE_NAME);
185 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
186
187 std::vector<uint32_t> uids;
188 uids.push_back(UID);
189 ret = nativeClient_.FirewallSetUidsAllowedListChain(CHAIN, uids);
190 EXPECT_EQ(ret, -1);
191 ret = nativeClient_.FirewallSetUidsDeniedListChain(CHAIN, uids);
192 EXPECT_EQ(ret, -1);
193 }
194
195 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest004, TestSize.Level1)
196 {
197 int32_t ret = nativeClient_.SetDefaultNetWork(NET_ID);
198 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
199
200 ret = nativeClient_.ClearDefaultNetWorkNetId();
201 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
202
203 ret = nativeClient_.BindSocket(SOCKET_FD, NET_ID);
204 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
205
206 ret = nativeClient_.IpEnableForwarding(REQUESTOR);
207 EXPECT_EQ(ret, 0);
208
209 ret = nativeClient_.IpDisableForwarding(REQUESTOR);
210 EXPECT_EQ(ret, 0);
211
212 ret = nativeClient_.EnableNat(ETH0, ETH0);
213 EXPECT_EQ(ret, -1);
214
215 ret = nativeClient_.DisableNat(ETH0, ETH0);
216 EXPECT_EQ(ret, -1);
217
218 ret = nativeClient_.IpfwdAddInterfaceForward(ETH0, ETH0);
219 EXPECT_EQ(ret, -1);
220
221 ret = nativeClient_.IpfwdRemoveInterfaceForward(ETH0, ETH0);
222 EXPECT_EQ(ret, -1);
223
224 ret = nativeClient_.ShareDnsSet(NET_ID);
225 EXPECT_EQ(ret, 0);
226
227 ret = nativeClient_.StartDnsProxyListen();
228 EXPECT_EQ(ret, 0);
229
230 ret = nativeClient_.StopDnsProxyListen();
231 EXPECT_EQ(ret, 0);
232
233 ret = nativeClient_.FirewallEnableChain(CHAIN, true);
234 EXPECT_EQ(ret, -1);
235 ret = nativeClient_.FirewallSetUidRule(CHAIN, {NET_ID}, FIREWALL_RULE);
236 EXPECT_EQ(ret, -1);
237 }
238
239 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest005, TestSize.Level1)
240 {
241 uint64_t stats = 0;
242 int32_t ret = nativeClient_.GetTotalStats(stats, 0);
243 EXPECT_EQ(ret, 0);
244
245 ret = nativeClient_.GetUidStats(stats, 0, APP_ID);
246 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
247
248 ret = nativeClient_.GetIfaceStats(stats, 0, IFACE);
249 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED);
250
251 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
252 ret = nativeClient_.GetAllStatsInfo(statsInfo);
253 EXPECT_EQ(ret, 0);
254 }
255
256 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest006, TestSize.Level1)
257 {
258 std::vector<UidRange> uidRanges;
259 std::vector<int32_t> beginUids;
260 std::vector<int32_t> endUids;
261 beginUids.push_back(STATRUID);
262 endUids.push_back(ENDUID);
263 for (size_t i = 0; i < beginUids.size(); i++) {
264 uidRanges.emplace_back(UidRange(beginUids[i], endUids[i]));
265 }
266 nativeClient_.NetworkAddUids(NET_ID, uidRanges);
267 nativeClient_.NetworkDelUids(NET_ID, uidRanges);
268 int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
269 EXPECT_EQ(ret, 0);
270 }
271
272 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest007, TestSize.Level1)
273 {
274 NetsysNotifyCallback callback;
275 struct ifreq ifreq = {};
276 int32_t ret = nativeClient_.RegisterNetsysNotifyCallback(callback);
277 EXPECT_EQ(ret, 0);
278 ret = nativeClient_.BindNetworkServiceVpn(SOCKET_FD);
279 int32_t ifacefd1 = 0;
280 nativeClient_.EnableVirtualNetIfaceCard(SOCKET_FD, ifreq, ifacefd1);
281 int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
282 ret = nativeClient_.BindNetworkServiceVpn(sockfd);
283 int32_t ifacefd2 = 0;
284 nativeClient_.EnableVirtualNetIfaceCard(sockfd, ifreq, ifacefd2);
285 EXPECT_EQ(ret, 0);
286 }
287
288 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest008, TestSize.Level1)
289 {
290 int32_t ret = nativeClient_.SetBlocking(IFACEFD, true);
291 EXPECT_EQ(ret, NETSYS_ERR_VPN);
292 struct ifreq ifreq = {};
293 int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
294 ret = nativeClient_.SetIpAddress(sockfd, LOCALIP, PREFIX_LENGTH, ifreq);
295 EXPECT_EQ(ret, NETSYS_ERR_VPN);
296 }
297
298 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest009, TestSize.Level1)
299 {
300 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
301 std::string ifName = "wlan";
302 bool up = true;
303 int32_t ret = notifyCallback.OnInterfaceChanged(ifName, up);
304 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
305 }
306
307 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest010, TestSize.Level1)
308 {
309 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
310 sptr<OHOS::NetsysNative::DhcpResultParcel> dhcpResult = new (std::nothrow) OHOS::NetsysNative::DhcpResultParcel();
311 int32_t ret = notifyCallback.OnDhcpSuccess(dhcpResult);
312 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
313 }
314
315 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest011, TestSize.Level1)
316 {
317 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient_);
318 std::string limitName = "wlan";
319 std::string iface = "vpncard";
320 int32_t ret = notifyCallback.OnBandwidthReachedLimit(limitName, iface);
321 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
322 }
323
324 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest013, TestSize.Level1)
325 {
326 wptr<IRemoteObject> remote = nullptr;
327 nativeClient_.OnRemoteDied(remote);
328 int handle = 1;
329 sptr<IRemoteObject> result = nullptr;
330 std::u16string descriptor = std::u16string();
331 result = new (std::nothrow) IPCObjectProxy(handle, descriptor);
332 IRemoteObject *object = result.GetRefPtr();
333 remote = object;
334 nativeClient_.OnRemoteDied(remote);
335 uint32_t uid = 0;
336 uint8_t allow = 0;
337 auto ret = nativeClient_.SetInternetPermission(uid, allow);
338 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
339 }
340
341 } // namespace NetManagerStandard
342 } // namespace OHOS
343