ResolverController.cpp revision 3a272070fc318ef1a7a5a04e500483f1a7c629a8 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "ResolverController"
18#define DBG 0
19
20#include <algorithm>
21#include <cstdlib>
22#include <string>
23#include <vector>
24#include <cutils/log.h>
25#include <net/if.h>
26#include <sys/socket.h>
27#include <netdb.h>
28
29// NOTE: <resolv_netid.h> is a private C library header that provides
30//       declarations for _resolv_set_nameservers_for_net and
31//       _resolv_flush_cache_for_net
32#include <resolv_netid.h>
33#include <resolv_params.h>
34#include <resolv_stats.h>
35
36#include <android-base/strings.h>
37#include <android/net/INetd.h>
38
39#include "DumpWriter.h"
40#include "ResolverController.h"
41#include "ResolverStats.h"
42
43int ResolverController::setDnsServers(unsigned netId, const char* searchDomains,
44        const char** servers, int numservers, const __res_params* params) {
45    if (DBG) {
46        ALOGD("setDnsServers netId = %u\n", netId);
47    }
48    return -_resolv_set_nameservers_for_net(netId, servers, numservers, searchDomains, params);
49}
50
51int ResolverController::clearDnsServers(unsigned netId) {
52    _resolv_set_nameservers_for_net(netId, NULL, 0, "", NULL);
53    if (DBG) {
54        ALOGD("clearDnsServers netId = %u\n", netId);
55    }
56    return 0;
57}
58
59int ResolverController::flushDnsCache(unsigned netId) {
60    if (DBG) {
61        ALOGD("flushDnsCache netId = %u\n", netId);
62    }
63
64    _resolv_flush_cache_for_net(netId);
65
66    return 0;
67}
68
69int ResolverController::getDnsInfo(unsigned netId, std::vector<std::string>* servers,
70        std::vector<std::string>* domains, __res_params* params,
71        std::vector<android::net::ResolverStats>* stats) {
72    using android::net::ResolverStats;
73    using android::net::INetd;
74    static_assert(ResolverStats::STATS_SUCCESSES == INetd::RESOLVER_STATS_SUCCESSES &&
75            ResolverStats::STATS_ERRORS == INetd::RESOLVER_STATS_ERRORS &&
76            ResolverStats::STATS_TIMEOUTS == INetd::RESOLVER_STATS_TIMEOUTS &&
77            ResolverStats::STATS_INTERNAL_ERRORS == INetd::RESOLVER_STATS_INTERNAL_ERRORS &&
78            ResolverStats::STATS_RTT_AVG == INetd::RESOLVER_STATS_RTT_AVG &&
79            ResolverStats::STATS_LAST_SAMPLE_TIME == INetd::RESOLVER_STATS_LAST_SAMPLE_TIME &&
80            ResolverStats::STATS_USABLE == INetd::RESOLVER_STATS_USABLE &&
81            ResolverStats::STATS_COUNT == INetd::RESOLVER_STATS_COUNT,
82            "AIDL and ResolverStats.h out of sync");
83    int nscount = -1;
84    sockaddr_storage res_servers[MAXNS];
85    int dcount = -1;
86    char res_domains[MAXDNSRCH][MAXDNSRCHPATH];
87    __res_stats res_stats[MAXNS];
88    servers->clear();
89    domains->clear();
90    *params = __res_params{};
91    stats->clear();
92    int revision_id = android_net_res_stats_get_info_for_net(netId, &nscount, res_servers, &dcount,
93            res_domains, params, res_stats);
94
95    // If the netId is unknown (which can happen for valid net IDs for which no DNS servers have
96    // yet been configured), there is no revision ID. In this case there is no data to return.
97    if (revision_id < 0) {
98        return 0;
99    }
100
101    // Verify that the returned data is sane.
102    if (nscount < 0 || nscount > MAXNS || dcount < 0 || dcount > MAXDNSRCH) {
103        ALOGE("%s: nscount=%d, dcount=%d", __FUNCTION__, nscount, dcount);
104        return -ENOTRECOVERABLE;
105    }
106
107    // Determine which servers are considered usable by the resolver.
108    bool valid_servers[MAXNS];
109    std::fill_n(valid_servers, MAXNS, false);
110    android_net_res_stats_get_usable_servers(params, res_stats, nscount, valid_servers);
111
112    // Convert the server sockaddr structures to std::string.
113    stats->resize(nscount);
114    for (int i = 0 ; i < nscount ; ++i) {
115        char hbuf[NI_MAXHOST];
116        int rv = getnameinfo(reinterpret_cast<const sockaddr*>(&res_servers[i]),
117                sizeof(res_servers[i]), hbuf, sizeof(hbuf), nullptr, 0, NI_NUMERICHOST);
118        std::string server_str;
119        if (rv == 0) {
120            server_str.assign(hbuf);
121        } else {
122            ALOGE("getnameinfo() failed for server #%d: %s", i, gai_strerror(rv));
123            server_str.assign("<invalid>");
124        }
125        servers->push_back(std::move(server_str));
126        android::net::ResolverStats& cur_stats = (*stats)[i];
127        android_net_res_stats_aggregate(&res_stats[i], &cur_stats.successes, &cur_stats.errors,
128                &cur_stats.timeouts, &cur_stats.internal_errors, &cur_stats.rtt_avg,
129                &cur_stats.last_sample_time);
130        cur_stats.usable = valid_servers[i];
131    }
132
133    // Convert the stack-allocated search domain strings to std::string.
134    for (int i = 0 ; i < dcount ; ++i) {
135        domains->push_back(res_domains[i]);
136    }
137    return 0;
138}
139
140int ResolverController::setResolverConfiguration(int32_t netId,
141        const std::vector<std::string>& servers, const std::vector<std::string>& domains,
142        const std::vector<int32_t>& params) {
143    using android::net::INetd;
144    if (params.size() != INetd::RESOLVER_PARAMS_COUNT) {
145        ALOGE("%s: params.size()=%zu", __FUNCTION__, params.size());
146        return -EINVAL;
147    }
148
149    std::vector<const char*> server_ptrs;
150    for (const std::string& str : servers) {
151        server_ptrs.push_back(str.c_str());
152    }
153
154    std::string domains_str;
155    if (!domains.empty()) {
156        domains_str = domains[0];
157        for (size_t i = 1 ; i < domains.size() ; ++i) {
158            domains_str += " " + domains[i];
159        }
160    }
161
162    __res_params res_params;
163    res_params.sample_validity = params[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY];
164    res_params.success_threshold = params[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD];
165    res_params.min_samples = params[INetd::RESOLVER_PARAMS_MIN_SAMPLES];
166    res_params.max_samples = params[INetd::RESOLVER_PARAMS_MAX_SAMPLES];
167
168    return setDnsServers(netId, domains_str.c_str(), server_ptrs.data(), server_ptrs.size(),
169            &res_params);
170}
171
172int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* servers,
173        std::vector<std::string>* domains, std::vector<int32_t>* params,
174        std::vector<int32_t>* stats) {
175    using android::net::ResolverStats;
176    using android::net::INetd;
177    __res_params res_params;
178    std::vector<ResolverStats> res_stats;
179    int ret = getDnsInfo(netId, servers, domains, &res_params, &res_stats);
180    if (ret != 0) {
181        return ret;
182    }
183
184    // Serialize the information for binder.
185    ResolverStats::encodeAll(res_stats, stats);
186
187    params->resize(INetd::RESOLVER_PARAMS_COUNT);
188    (*params)[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY] = res_params.sample_validity;
189    (*params)[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD] = res_params.success_threshold;
190    (*params)[INetd::RESOLVER_PARAMS_MIN_SAMPLES] = res_params.min_samples;
191    (*params)[INetd::RESOLVER_PARAMS_MAX_SAMPLES] = res_params.max_samples;
192    return 0;
193}
194
195void ResolverController::dump(DumpWriter& dw, unsigned netId) {
196    // No lock needed since Bionic's resolver locks all accessed data structures internally.
197    using android::net::ResolverStats;
198    std::vector<std::string> servers;
199    std::vector<std::string> domains;
200    __res_params params;
201    std::vector<ResolverStats> stats;
202    time_t now = time(nullptr);
203    int rv = getDnsInfo(netId, &servers, &domains, &params, &stats);
204    dw.incIndent();
205    if (rv != 0) {
206        dw.println("getDnsInfo() failed for netid %u", netId);
207    } else {
208        if (servers.empty()) {
209            dw.println("No DNS servers defined");
210        } else {
211            dw.println("DNS servers: # IP (total, successes, errors, timeouts, internal errors, "
212                    "RTT avg, last sample)");
213            dw.incIndent();
214            for (size_t i = 0 ; i < servers.size() ; ++i) {
215                if (i < stats.size()) {
216                    const ResolverStats& s = stats[i];
217                    int total = s.successes + s.errors + s.timeouts + s.internal_errors;
218                    if (total > 0) {
219                        int time_delta = (s.last_sample_time > 0) ? now - s.last_sample_time : -1;
220                        dw.println("%s (%d, %d, %d, %d, %d, %dms, %ds)%s", servers[i].c_str(),
221                                total, s.successes, s.errors, s.timeouts, s.internal_errors,
222                                s.rtt_avg, time_delta, s.usable ? "" : " BROKEN");
223                    } else {
224                        dw.println("%s <no data>", servers[i].c_str());
225                    }
226                } else {
227                    dw.println("%s <no stats>", servers[i].c_str());
228                }
229            }
230            dw.decIndent();
231        }
232        if (domains.empty()) {
233            dw.println("No search domains defined");
234        } else {
235            std::string domains_str = android::base::Join(domains, ", ");
236            dw.println("search domains: %s", domains_str.c_str());
237        }
238        if (params.sample_validity != 0) {
239            dw.println("DNS parameters: sample validity = %us, success threshold = %u%%, "
240                    "samples (min, max) = (%u, %u)", params.sample_validity,
241                    static_cast<unsigned>(params.success_threshold),
242                    static_cast<unsigned>(params.min_samples),
243                    static_cast<unsigned>(params.max_samples));
244        }
245    }
246    dw.decIndent();
247}
248