1 /*
2 * Copyright (c) 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 #include "dns_result_call_back.h"
16 #include "net_manager_constants.h"
17 #include "net_mgr_log_wrapper.h"
18 #include "net_conn_service.h"
19
20 namespace OHOS {
21 namespace NetManagerStandard {
22 constexpr double FAIL_RATE = 0.6;
23 constexpr int32_t MAX_FAIL_VALUE = 3;
24
25 enum DnsFailReason {
26 DNS_FAIL_REASON_PARAM_INVALID = -1101,
27 };
28
OnDnsResultReport(uint32_t size,const std::list<NetsysNative::NetDnsResultReport> netDnsResultReport)29 int32_t NetDnsResultCallback::OnDnsResultReport(uint32_t size,
30 const std::list<NetsysNative::NetDnsResultReport> netDnsResultReport)
31 {
32 NETMGR_LOG_D("Dns Result Report interface is called");
33 netDnsResult_.Clear();
34 IterateDnsReportResults(netDnsResultReport);
35 netDnsResult_.Iterate([this](int32_t netid, NetDnsResult dnsResult) {
36 double failRate = static_cast<double>(dnsResult.failReports_) / dnsResult.totalReports_;
37 NETMGR_LOG_D("Reports: netId:%{public}d fail-total:%{public}d-%{public}d",
38 netid, dnsResult.totalReports_, dnsResult.failReports_);
39 if (failRate > FAIL_RATE) {
40 uint32_t failValue_ = 0;
41 RequestNetDetection(failValue_, netid);
42 NETMGR_LOG_D("Netdetection for dns fail, netId:%{public}d,totalReports:%{public}d, failReports:%{public}d,"
43 "failValue:%{public}d", netid, dnsResult.totalReports_, dnsResult.failReports_, failValue_);
44 } else {
45 NETMGR_LOG_D("Netdetection for dns success, netId:%{public}d, totalReports:%{public}d,"
46 "failReports:%{public}d", netid, dnsResult.totalReports_, dnsResult.failReports_);
47 failCount_.EnsureInsert(netid, 0);
48 int32_t result = NetConnService::GetInstance()->NetDetectionForDnsHealth(netid, true);
49 if (result != 0) {
50 NETMGR_LOG_E("NetDetectionForDnsHealth failed");
51 }
52 }
53 });
54 return NETMANAGER_SUCCESS;
55 }
56
RequestNetDetection(uint32_t & failValue_,uint32_t netid)57 void NetDnsResultCallback::RequestNetDetection(uint32_t &failValue_, uint32_t netid)
58 {
59 if (!failCount_.Find(netid, failValue_)) {
60 failValue_ = 1;
61 failCount_.EnsureInsert(netid, failValue_);
62 } else {
63 failValue_++;
64 if (failValue_ >= MAX_FAIL_VALUE) {
65 NETMGR_LOG_I("netId:%{public}d start net detection with DNS fail value failValue:%{public}d",
66 netid, failValue_);
67 NetConnService::GetInstance()->NetDetectionForDnsHealth(netid, false);
68 failCount_.EnsureInsert(netid, 0);
69 } else {
70 failCount_.EnsureInsert(netid, failValue_);
71 }
72 }
73 }
74
GetDumpMessageForDnsResult(std::string & message)75 void NetDnsResultCallback::GetDumpMessageForDnsResult(std::string &message)
76 {
77 message.append("Dns result Info:\n");
78 netDnsResult_.Iterate([&message](int32_t netid, NetDnsResult dnsResult) {
79 message.append("\tnetId: " + std::to_string(netid) + "\n");
80 message.append("\ttotalReports: " + std::to_string(dnsResult.totalReports_) + "\n");
81 message.append("\tfailReports: " + std::to_string(dnsResult.failReports_) + "\n");
82 });
83 }
84
IterateDnsReportResults(const std::list<NetsysNative::NetDnsResultReport> netDnsResultReport)85 void NetDnsResultCallback::IterateDnsReportResults(
86 const std::list<NetsysNative::NetDnsResultReport> netDnsResultReport)
87 {
88 int32_t defaultNetid = 0;
89 int32_t result = NetConnService::GetInstance()->GetDefaultNet(defaultNetid);
90 NETMGR_LOG_D("GetDefaultNet result: %{public}d, defaultNetid: %{public}d", result, defaultNetid);
91 for (auto &it : netDnsResultReport) {
92 NETMGR_LOG_D("netId_: %{public}d, queryResult_: %{public}d, pid_ : %{public}d",
93 it.netid_, it.queryresult_, it.pid_);
94 if (!CheckDnsSentByResult(static_cast<int32_t>(it.queryresult_))) {
95 continue;
96 }
97 NetDnsResult existResult;
98 bool ret = netDnsResult_.Find(it.netid_, existResult);
99 if (!ret && it.netid_ == 0) {
100 NetDnsResult newDefaultResult;
101 if (!netDnsResult_.Find(defaultNetid, newDefaultResult)) {
102 NetDnsResult defaultResult;
103 defaultResult.totalReports_ = 1;
104 defaultResult.failReports_ = it.queryresult_ == 0 ? 0 : 1;
105 netDnsResult_.EnsureInsert(defaultNetid, defaultResult);
106 } else {
107 newDefaultResult = netDnsResult_.ReadVal(defaultNetid);
108 newDefaultResult.totalReports_++;
109 newDefaultResult.failReports_ += it.queryresult_ == 0 ? 0 : 1;
110 netDnsResult_.EnsureInsert(defaultNetid, newDefaultResult);
111 }
112 } else if (!ret) {
113 NetDnsResult newResult;
114 newResult.totalReports_ = 1;
115 newResult.failReports_ = it.queryresult_ == 0 ? 0 : 1;
116 netDnsResult_.EnsureInsert(it.netid_, newResult);
117 } else {
118 existResult = netDnsResult_.ReadVal(it.netid_);
119 existResult.totalReports_++;
120 existResult.failReports_ += it.queryresult_ == 0 ? 0 : 1;
121 netDnsResult_.EnsureInsert(it.netid_, existResult);
122 }
123 }
124 }
125
CheckDnsSentByResult(int32_t result)126 bool NetDnsResultCallback::CheckDnsSentByResult(int32_t result)
127 {
128 if (result == DNS_FAIL_REASON_PARAM_INVALID) {
129 return false;
130 }
131 return true;
132 }
133 } // namespace NetManagerStandard
134 } // namespace OHOS
135