1 /*
2 * Copyright (c) 2022 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 #include "netsys_native_client.h"
20
21 namespace OHOS {
22 namespace NetManagerStandard {
23 namespace {
24 using namespace testing::ext;
25 static constexpr const char *DESTINATION = "192.168.1.3/24";
26 static constexpr const char *NEXT_HOP = "192.168.1.1";
27 static constexpr const char *IF_NAME = "iface0";
28 static constexpr const char *ETH0 = "eth0";
29 static constexpr const char *IP_ADDR = "172.17.5.245";
30 static constexpr const char *INTERFACE_NAME = "interface_name";
31 static constexpr const char *REQUESTOR = "requestor";
32 const int32_t MTU = 111;
33 const int32_t NET_ID = 2;
34 const int64_t UID = 1010;
35 const int32_t SOCKET_FD = 5;
36 const int32_t PERMISSION = 5;
37 const int32_t PREFIX_LENGTH = 23;
38 uint16_t BASE_TIMEOUT_MSEC = 200;
39 const int64_t CHAIN = 1010;
40 uint8_t RETRY_COUNT = 3;
41 const uint32_t FIREWALL_RULE = 1;
42 } // namespace
43
44 class NetsysNativeClientTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47
48 static void TearDownTestCase();
49
50 void SetUp();
51
52 void TearDown();
53 };
54
SetUpTestCase()55 void NetsysNativeClientTest::SetUpTestCase() {}
56
TearDownTestCase()57 void NetsysNativeClientTest::TearDownTestCase() {}
58
SetUp()59 void NetsysNativeClientTest::SetUp() {}
60
TearDown()61 void NetsysNativeClientTest::TearDown() {}
62
63 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest001, TestSize.Level1)
64 {
65 NetsysNativeClient nativeClient;
66 int32_t ret = nativeClient.NetworkCreatePhysical(NET_ID, PERMISSION);
67 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
68
69 ret = nativeClient.NetworkCreatePhysical(NET_ID, PERMISSION);
70 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
71
72 ret = nativeClient.NetworkDestroy(NET_ID);
73 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
74
75 ret = nativeClient.NetworkAddInterface(NET_ID, IF_NAME);
76 EXPECT_EQ(ret, -1);
77
78 ret = nativeClient.NetworkRemoveInterface(NET_ID, IF_NAME);
79 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
80
81 ret = nativeClient.NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
82 EXPECT_EQ(ret, -1);
83
84 ret = nativeClient.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
85 EXPECT_EQ(ret, -1);
86
87 OHOS::nmd::InterfaceConfigurationParcel parcel;
88 ret = nativeClient.InterfaceGetConfig(parcel);
89 EXPECT_EQ(ret, 0);
90
91 ret = nativeClient.SetInterfaceDown(IF_NAME);
92 EXPECT_EQ(ret, 0);
93
94 ret = nativeClient.SetInterfaceUp(IF_NAME);
95 EXPECT_EQ(ret, 0);
96
97 nativeClient.InterfaceClearAddrs(IF_NAME);
98
99 ret = nativeClient.InterfaceGetMtu(IF_NAME);
100 EXPECT_EQ(ret, -1);
101
102 ret = nativeClient.InterfaceSetMtu(IF_NAME, MTU);
103 EXPECT_EQ(ret, -1);
104 }
105
106 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest002, TestSize.Level1)
107 {
108 NetsysNativeClient nativeClient;
109 int32_t ret = nativeClient.InterfaceAddAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
110 EXPECT_EQ(ret, -19);
111
112 ret = nativeClient.InterfaceDelAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
113 EXPECT_EQ(ret, -19);
114
115 ret = nativeClient.SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {});
116 EXPECT_EQ(ret, 0);
117
118 std::vector<std::string> servers;
119 std::vector<std::string> domains;
120 ret = nativeClient.GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT);
121 EXPECT_EQ(ret, 0);
122
123 ret = nativeClient.CreateNetworkCache(NET_ID);
124 EXPECT_EQ(ret, 0);
125
126 ret = nativeClient.DestroyNetworkCache(NET_ID);
127 EXPECT_EQ(ret, 0);
128
129 nmd::NetworkSharingTraffic traffic;
130 ret = nativeClient.GetNetworkSharingTraffic(ETH0, ETH0, traffic);
131 EXPECT_NE(ret, 0);
132
133 ret = nativeClient.GetCellularRxBytes();
134 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
135
136 ret = nativeClient.GetCellularTxBytes();
137 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
138
139 ret = nativeClient.GetAllRxBytes();
140 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
141
142 ret = nativeClient.GetAllTxBytes();
143 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
144 }
145
146 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest003, TestSize.Level1)
147 {
148 NetsysNativeClient nativeClient;
149 int32_t ret = nativeClient.GetUidRxBytes(NET_ID);
150 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
151
152 ret = nativeClient.GetUidTxBytes(NET_ID);
153 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
154
155 ret = nativeClient.GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME);
156 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
157
158 ret = nativeClient.GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME);
159 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
160
161 ret = nativeClient.GetIfaceRxBytes(INTERFACE_NAME);
162 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
163
164 ret = nativeClient.GetIfaceTxBytes(INTERFACE_NAME);
165 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
166
167 std::vector<std::string> interFaceGetList = nativeClient.InterfaceGetList();
168 EXPECT_NE(interFaceGetList.size(), 0);
169
170 std::vector<std::string> uidGetList = nativeClient.UidGetList();
171 EXPECT_EQ(uidGetList.size(), 0);
172
173 ret = nativeClient.GetIfaceRxPackets(INTERFACE_NAME);
174 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
175
176 ret = nativeClient.GetIfaceTxPackets(INTERFACE_NAME);
177 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
178
179 std::vector<uint32_t> uids;
180 uids.push_back(UID);
181 ret = nativeClient.FirewallSetUidsAllowedListChain(CHAIN, uids);
182 EXPECT_EQ(ret, -1);
183 ret = nativeClient.FirewallSetUidsDeniedListChain(CHAIN, uids);
184 EXPECT_EQ(ret, -1);
185 }
186
187 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest004, TestSize.Level1)
188 {
189 NetsysNativeClient nativeClient;
190 int32_t ret = nativeClient.SetDefaultNetWork(NET_ID);
191 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
192
193 ret = nativeClient.ClearDefaultNetWorkNetId();
194 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
195
196 ret = nativeClient.BindSocket(SOCKET_FD, NET_ID);
197 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
198
199 ret = nativeClient.IpEnableForwarding(REQUESTOR);
200 EXPECT_EQ(ret, 0);
201
202 ret = nativeClient.IpDisableForwarding(REQUESTOR);
203 EXPECT_EQ(ret, 0);
204
205 ret = nativeClient.EnableNat(ETH0, ETH0);
206 EXPECT_EQ(ret, -1);
207
208 ret = nativeClient.DisableNat(ETH0, ETH0);
209 EXPECT_EQ(ret, -1);
210
211 ret = nativeClient.IpfwdAddInterfaceForward(ETH0, ETH0);
212 EXPECT_EQ(ret, -1);
213
214 ret = nativeClient.IpfwdRemoveInterfaceForward(ETH0, ETH0);
215 EXPECT_EQ(ret, -1);
216
217 ret = nativeClient.ShareDnsSet(NET_ID);
218 EXPECT_EQ(ret, 0);
219
220 ret = nativeClient.StartDnsProxyListen();
221 EXPECT_EQ(ret, 0);
222
223 ret = nativeClient.StopDnsProxyListen();
224 EXPECT_EQ(ret, 0);
225
226 ret = nativeClient.FirewallEnableChain(CHAIN, true);
227 EXPECT_EQ(ret, -1);
228 ret = nativeClient.FirewallSetUidRule(CHAIN, NET_ID, FIREWALL_RULE);
229 EXPECT_EQ(ret, -1);
230 }
231 } // namespace NetManagerStandard
232 } // namespace OHOS