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 #define protected public
21 #endif
22
23 #include <netinet/in.h>
24 #include "netsys_client.h"
25 #include "dns_config_client.h"
26 #include "app_net_client.h"
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 void MakeDefaultDnsServer(char *server, size_t length);
33 int32_t NetSysGetResolvConf(uint16_t netId, struct ResolvConfig *config);
34 int32_t NetSysGetResolvCache(uint16_t netId, const struct ParamWrapper param,
35 struct AddrInfo addrInfo[], uint32_t *num);
36 int32_t NetSysSetResolvCache(uint16_t netId, const struct ParamWrapper param, struct addrinfo *res);
37 int32_t NetSysGetDefaultNetwork(uint16_t netId, int32_t* currentNetId);
38 int32_t NetSysBindSocket(int32_t fd, uint32_t netId);
39 char *addr_to_string(const AlignedSockAddr *addr, char *buf, size_t len);
40 bool IsSystemUid(void);
41 bool IsLoopbackAddr(struct AddrInfo addrInfo[], int32_t addrSize);
42 bool IsAllCname(struct DnsProcessInfoExt *dnsProcessInfo);
43 bool IsAllNoAnswer(struct DnsProcessInfoExt *dnsProcessInfo);
44 bool IsFailCauseAllowedReport(int failcause);
45 int32_t GetQueryFailCause(struct DnsProcessInfoExt *dnsProcessInfo,
46 struct AddrInfo addrInfo[], int32_t addrSize);
47 int32_t NetsysPostDnsAbnormal(int32_t failcause, struct DnsCacheInfo dnsInfo);
48 void HandleQueryAbnormalReport(struct DnsProcessInfoExt dnsProcessInfo,
49 struct AddrInfo addrInfo[], int32_t addrSize);
50 int32_t NetSysPostDnsQueryResult(int netid, struct addrinfo *addr, char *srcAddr,
51 struct DnsProcessInfo *processInfo);
52
53 #ifdef __cplusplus
54 }
55 #endif
56
57 namespace OHOS {
58 namespace nmd {
59 namespace {
60 using namespace testing::ext;
61 }
62
63 class NetsysClientTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp();
68 void TearDown();
69 };
70
SetUpTestCase()71 void NetsysClientTest::SetUpTestCase() {}
72
TearDownTestCase()73 void NetsysClientTest::TearDownTestCase() {}
74
SetUp()75 void NetsysClientTest::SetUp() {}
76
TearDown()77 void NetsysClientTest::TearDown() {}
78
79 HWTEST_F(NetsysClientTest, MakeDefaultDnsServerTest001, TestSize.Level1)
80 {
81 char server[DEFAULT_SERVER_LENTH] = {0};
82 size_t length = 1;
83 int ret = memset_s(nullptr, length, 0, DEFAULT_SERVER_LENTH);
84 EXPECT_NE(ret, 0);
85 MakeDefaultDnsServer(nullptr, length);
86 MakeDefaultDnsServer(server, length);
87 }
88
89 HWTEST_F(NetsysClientTest, NetSysGetResolvConfTest001, TestSize.Level1)
90 {
91 uint16_t netId = 0;
92 struct ResolvConfig config;
93 auto ret = NetSysGetResolvConf(netId, nullptr);
94 EXPECT_EQ(ret, -EINVAL);
95
96 SetNetForApp(1);
97 ret = NetSysGetResolvConf(netId, &config);
98 EXPECT_NE(ret, 0);
99
100 config.nameservers[0][0] = '\0';
101 ret = NetSysGetResolvConf(netId, &config);
102 EXPECT_NE(ret, 0);
103 }
104
105 HWTEST_F(NetsysClientTest, NetSysGetResolvCacheTest001, TestSize.Level1)
106 {
107 uint16_t netId = 0;
108 SetNetForApp(1);
109 struct ParamWrapper param;
110 param.host = nullptr;
111 struct AddrInfo addrInfo[MAX_RESULTS];
112 uint32_t num = 0;
113 auto ret = NetSysGetResolvCache(netId, param, addrInfo, nullptr);
114 EXPECT_EQ(ret, -EINVAL);
115
116 char host[MAX_RESULTS] = {0};
117 param.host = host;
118 ret = NetSysGetResolvCache(netId, param, addrInfo, nullptr);
119 EXPECT_EQ(ret, -EINVAL);
120
121 strcpy_s(host, MAX_RESULTS, "test");
122 ret = NetSysGetResolvCache(netId, param, addrInfo, nullptr);
123 EXPECT_EQ(ret, -EINVAL);
124
125 ret = NetSysGetResolvCache(netId, param, addrInfo, &num);
126 EXPECT_EQ(ret, 0);
127 }
128
129 HWTEST_F(NetsysClientTest, NetSysSetResolvCacheTest001, TestSize.Level1)
130 {
131 uint16_t netId = 0;
132 SetNetForApp(1);
133 struct ParamWrapper param;
134 param.host = nullptr;
135 auto ret = NetSysSetResolvCache(netId, param, nullptr);
136 EXPECT_EQ(ret, -EINVAL);
137
138 char host[MAX_RESULTS] = {0};
139 param.host = host;
140 ret = NetSysSetResolvCache(netId, param, nullptr);
141 EXPECT_EQ(ret, -EINVAL);
142
143 strcpy_s(host, MAX_RESULTS, "test");
144 ret = NetSysSetResolvCache(netId, param, nullptr);
145 EXPECT_EQ(ret, -EINVAL);
146
147 struct addrinfo addrInfo;
148 ret = NetSysSetResolvCache(netId, param, &addrInfo);
149 EXPECT_NE(ret, 0);
150 }
151
152 HWTEST_F(NetsysClientTest, NetSysGetDefaultNetworkTest001, TestSize.Level1)
153 {
154 uint16_t netId = 0;
155 int32_t currentNetId = 1;
156 auto ret = NetSysGetDefaultNetwork(netId, ¤tNetId);
157 EXPECT_EQ(ret, 0);
158 }
159
160 HWTEST_F(NetsysClientTest, NetSysBindSocketTest001, TestSize.Level1)
161 {
162 uint16_t netId = 0;
163 int32_t fd = 0;
164 auto ret = NetSysBindSocket(fd, netId);
165 EXPECT_EQ(ret, 0);
166 }
167
168 HWTEST_F(NetsysClientTest, addr_to_stringTest001, TestSize.Level1)
169 {
170 AlignedSockAddr addr;
171 char buf[INET6_ADDRSTRLEN] = {0};
172 size_t len = 0;
173 addr.sa.sa_family = AF_INET;
174 auto ret = addr_to_string(&addr, nullptr, len);
175 EXPECT_EQ(ret, nullptr);
176
177 len = INET_ADDRSTRLEN;
178 ret = addr_to_string(&addr, buf, len);
179 EXPECT_EQ(ret, buf);
180
181 len = 0;
182 addr.sa.sa_family = AF_INET6;
183 ret = addr_to_string(&addr, nullptr, len);
184 EXPECT_EQ(ret, nullptr);
185
186 len = INET6_ADDRSTRLEN;
187 ret = addr_to_string(&addr, buf, len);
188 EXPECT_EQ(ret, buf);
189
190 addr.sa.sa_family = 0;
191 ret = addr_to_string(&addr, nullptr, len);
192 EXPECT_EQ(ret, nullptr);
193 }
194
195 HWTEST_F(NetsysClientTest, IsSystemUidTest001, TestSize.Level1)
196 {
197 auto ret = IsSystemUid();
198 EXPECT_TRUE(ret);
199 }
200
201 HWTEST_F(NetsysClientTest, IsLoopbackAddrTest001, TestSize.Level1)
202 {
203 struct AddrInfo addrInfo[MAX_RESULTS];
204 int32_t addrSize = 0;
205 auto ret = IsLoopbackAddr(addrInfo, addrSize);
206 EXPECT_FALSE(ret);
207
208 addrSize = 1;
209 addrInfo[0].aiAddr.sa.sa_family = 0;
210 ret = IsLoopbackAddr(addrInfo, addrSize);
211 EXPECT_FALSE(ret);
212
213 addrInfo[0].aiAddr.sa.sa_family = AF_INET;
214 inet_pton(AF_INET, LOOP_BACK_ADDR1, &addrInfo[0].aiAddr.sin.sin_addr);
215 ret = IsLoopbackAddr(addrInfo, addrSize);
216 EXPECT_TRUE(ret);
217
218 inet_pton(AF_INET, LOOP_BACK_ADDR2, &addrInfo[0].aiAddr.sin.sin_addr);
219 ret = IsLoopbackAddr(addrInfo, addrSize);
220 EXPECT_TRUE(ret);
221
222 inet_pton(AF_INET, "192.168.1.1", &addrInfo[0].aiAddr.sin.sin_addr);
223 ret = IsLoopbackAddr(addrInfo, addrSize);
224 EXPECT_FALSE(ret);
225 }
226
227 HWTEST_F(NetsysClientTest, IsAllCnameTest001, TestSize.Level1)
228 {
229 struct DnsProcessInfoExt dnsProcessInfo = {};
230 dnsProcessInfo.isFromCache = true;
231 auto ret = IsAllCname(&dnsProcessInfo);
232 EXPECT_FALSE(ret);
233
234 dnsProcessInfo.isFromCache = false;
235 ret = IsAllCname(&dnsProcessInfo);
236 EXPECT_FALSE(ret);
237 }
238
239 HWTEST_F(NetsysClientTest, IsAllNoAnswerTest001, TestSize.Level1)
240 {
241 struct DnsProcessInfoExt dnsProcessInfo = {};
242 dnsProcessInfo.isFromCache = true;
243 auto ret = IsAllNoAnswer(&dnsProcessInfo);
244 EXPECT_FALSE(ret);
245
246 dnsProcessInfo.isFromCache = false;
247 dnsProcessInfo.retCode = 1;
248 ret = IsAllNoAnswer(&dnsProcessInfo);
249 EXPECT_FALSE(ret);
250
251 dnsProcessInfo.retCode = 0;
252 dnsProcessInfo.ipv4QueryInfo.isNoAnswer = 1;
253 dnsProcessInfo.ipv6QueryInfo.isNoAnswer = 1;
254 ret = IsAllNoAnswer(&dnsProcessInfo);
255 EXPECT_TRUE(ret);
256 }
257
258 HWTEST_F(NetsysClientTest, IsFailCauseAllowedReportTest001, TestSize.Level1)
259 {
260 int failcause = FAIL_CAUSE_NONE;
261 auto ret = IsFailCauseAllowedReport(failcause);
262 EXPECT_FALSE(ret);
263
264 failcause = FAIL_CAUSE_QUERY_FAIL;
265 IsFailCauseAllowedReport(failcause);
266 }
267
268 HWTEST_F(NetsysClientTest, GetQueryFailCauseTest001, TestSize.Level1)
269 {
270 struct DnsProcessInfoExt dnsProcessInfo;
271 struct AddrInfo addrInfo[MAX_RESULTS];
272 int32_t addrSize = 0;
273 auto ret = GetQueryFailCause(nullptr, addrInfo, addrSize);
274 EXPECT_EQ(ret, FAIL_CAUSE_NONE);
275
276 dnsProcessInfo.retCode = 1;
277 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
278 EXPECT_EQ(ret, FAIL_CAUSE_QUERY_FAIL);
279
280 dnsProcessInfo.retCode = 0;
281 dnsProcessInfo.firstQueryEndDuration = QUERY_CALLBACK_RETURN_SLOW_THRESHOLD + 1;
282 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
283 EXPECT_EQ(ret, FAIL_CAUSE_FIRST_RETURN_SLOW);
284
285 dnsProcessInfo.firstQueryEndDuration = QUERY_CALLBACK_RETURN_SLOW_THRESHOLD;
286 dnsProcessInfo.firstQueryEnd2AppDuration = FIRST_RETURN_SLOW_THRESHOLD + 1;
287 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
288 EXPECT_TRUE(ret == FAIL_CAUSE_CALLBACK_RETURN_SLOW || ret == FAIL_CAUSE_FIRST_RETURN_SLOW);
289 }
290
291 HWTEST_F(NetsysClientTest, GetQueryFailCauseTest002, TestSize.Level1)
292 {
293 struct DnsProcessInfoExt dnsProcessInfo;
294 struct AddrInfo addrInfo[MAX_RESULTS];
295 int32_t addrSize = 1;
296 dnsProcessInfo.retCode = 0;
297 dnsProcessInfo.firstQueryEndDuration = QUERY_CALLBACK_RETURN_SLOW_THRESHOLD;
298 dnsProcessInfo.firstQueryEnd2AppDuration = FIRST_RETURN_SLOW_THRESHOLD;
299 addrInfo[0].aiAddr.sa.sa_family = AF_INET;
300 inet_pton(AF_INET, LOOP_BACK_ADDR1, &addrInfo[0].aiAddr.sin.sin_addr);
301 auto ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
302 EXPECT_TRUE(ret == FAIL_CAUSE_RETURN_LOOPBACK_ADDR || ret == FAIL_CAUSE_FIRST_RETURN_SLOW);
303
304 addrSize = 0;
305 dnsProcessInfo.isFromCache = false;
306 dnsProcessInfo.ipv4QueryInfo.cname = 1;
307 dnsProcessInfo.ipv6QueryInfo.cname = 1;
308 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
309 EXPECT_TRUE(ret == FAIL_CAUSE_RETURN_CNAME || ret == FAIL_CAUSE_FIRST_RETURN_SLOW);
310
311 dnsProcessInfo.ipv4QueryInfo.cname = 0;
312 dnsProcessInfo.ipv6QueryInfo.cname = 0;
313 dnsProcessInfo.retCode = 0;
314 dnsProcessInfo.ipv4QueryInfo.isNoAnswer = 1;
315 dnsProcessInfo.ipv6QueryInfo.isNoAnswer = 1;
316 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
317
318 dnsProcessInfo.ipv4QueryInfo.isNoAnswer = 0;
319 ret = GetQueryFailCause(&dnsProcessInfo, addrInfo, addrSize);
320 }
321
322 HWTEST_F(NetsysClientTest, NetsysPostDnsAbnormalTest001, TestSize.Level1)
323 {
324 int32_t failcause = 0;
325 struct DnsCacheInfo dnsInfo;
326 auto ret = NetsysPostDnsAbnormal(failcause, dnsInfo);
327 ret = IsFailCauseAllowedReport(failcause);
328 EXPECT_FALSE(ret);
329 }
330
331 HWTEST_F(NetsysClientTest, HandleQueryAbnormalReportTest001, TestSize.Level1)
332 {
333 struct DnsProcessInfoExt dnsProcessInfo;
334 struct AddrInfo addrInfo[MAX_RESULTS];
335 int32_t addrSize = 0;
336 EXPECT_TRUE(IsSystemUid());
337 HandleQueryAbnormalReport(dnsProcessInfo, addrInfo, addrSize);
338 }
339
340 HWTEST_F(NetsysClientTest, NetSysPostDnsQueryResultTest001, TestSize.Level1)
341 {
342 int netId = 0;
343 struct addrinfo addr;
344 char srcAddr[MAX_RESULTS] = {0};
345 struct DnsProcessInfo processInfo;
346 auto ret = NetSysPostDnsQueryResult(netId, &addr, srcAddr, nullptr);
347 EXPECT_EQ(ret, -1);
348
349 processInfo.hostname = nullptr;
350 ret = NetSysPostDnsQueryResult(netId, &addr, srcAddr, &processInfo);
351 EXPECT_EQ(ret, -1);
352
353 char hostname[MAX_RESULTS] = {0};
354 processInfo.hostname = hostname;
355 processInfo.retCode = 0;
356 ret = NetSysPostDnsQueryResult(netId, nullptr, srcAddr, &processInfo);
357 EXPECT_EQ(ret, 0);
358
359 processInfo.retCode = 1;
360 ret = NetSysPostDnsQueryResult(netId, &addr, nullptr, &processInfo);
361 EXPECT_TRUE(ret == -1 || ret == 0);
362 }
363
364 } // namespace nmd
365 } // namespace OHOS