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