#define LOG_TAG "ResolverController"
#define DBG 0
+#include <algorithm>
+#include <cstdlib>
+#include <string>
+#include <vector>
#include <cutils/log.h>
-
#include <net/if.h>
+#include <sys/socket.h>
+#include <netdb.h>
// NOTE: <resolv_netid.h> is a private C library header that provides
// declarations for _resolv_set_nameservers_for_net and
// _resolv_flush_cache_for_net
#include <resolv_netid.h>
+#include <resolv_params.h>
+#include <resolv_stats.h>
+
+#include <android-base/strings.h>
+#include <android/net/INetd.h>
+#include "DumpWriter.h"
#include "ResolverController.h"
+#include "ResolverStats.h"
-int ResolverController::setDnsServers(unsigned netId, const char* domains,
- const char** servers, int numservers) {
+int ResolverController::setDnsServers(unsigned netId, const char* searchDomains,
+ const char** servers, int numservers, const __res_params* params) {
if (DBG) {
ALOGD("setDnsServers netId = %u\n", netId);
}
- _resolv_set_nameservers_for_net(netId, servers, numservers, domains);
+ return -_resolv_set_nameservers_for_net(netId, servers, numservers, searchDomains, params);
+}
+int ResolverController::clearDnsServers(unsigned netId) {
+ _resolv_set_nameservers_for_net(netId, NULL, 0, "", NULL);
+ if (DBG) {
+ ALOGD("clearDnsServers netId = %u\n", netId);
+ }
return 0;
}
return 0;
}
+
+int ResolverController::getDnsInfo(unsigned netId, std::vector<std::string>* servers,
+ std::vector<std::string>* domains, __res_params* params,
+ std::vector<android::net::ResolverStats>* stats) {
+ using android::net::ResolverStats;
+ using android::net::INetd;
+ static_assert(ResolverStats::STATS_SUCCESSES == INetd::RESOLVER_STATS_SUCCESSES &&
+ ResolverStats::STATS_ERRORS == INetd::RESOLVER_STATS_ERRORS &&
+ ResolverStats::STATS_TIMEOUTS == INetd::RESOLVER_STATS_TIMEOUTS &&
+ ResolverStats::STATS_INTERNAL_ERRORS == INetd::RESOLVER_STATS_INTERNAL_ERRORS &&
+ ResolverStats::STATS_RTT_AVG == INetd::RESOLVER_STATS_RTT_AVG &&
+ ResolverStats::STATS_LAST_SAMPLE_TIME == INetd::RESOLVER_STATS_LAST_SAMPLE_TIME &&
+ ResolverStats::STATS_USABLE == INetd::RESOLVER_STATS_USABLE &&
+ ResolverStats::STATS_COUNT == INetd::RESOLVER_STATS_COUNT,
+ "AIDL and ResolverStats.h out of sync");
+ int nscount = -1;
+ sockaddr_storage res_servers[MAXNS];
+ int dcount = -1;
+ char res_domains[MAXDNSRCH][MAXDNSRCHPATH];
+ __res_stats res_stats[MAXNS];
+ servers->clear();
+ domains->clear();
+ *params = __res_params{};
+ stats->clear();
+ int revision_id = android_net_res_stats_get_info_for_net(netId, &nscount, res_servers, &dcount,
+ res_domains, params, res_stats);
+
+ // If the netId is unknown (which can happen for valid net IDs for which no DNS servers have
+ // yet been configured), there is no revision ID. In this case there is no data to return.
+ if (revision_id < 0) {
+ return 0;
+ }
+
+ // Verify that the returned data is sane.
+ if (nscount < 0 || nscount > MAXNS || dcount < 0 || dcount > MAXDNSRCH) {
+ ALOGE("%s: nscount=%d, dcount=%d", __FUNCTION__, nscount, dcount);
+ return -ENOTRECOVERABLE;
+ }
+
+ // Determine which servers are considered usable by the resolver.
+ bool valid_servers[MAXNS];
+ std::fill_n(valid_servers, MAXNS, false);
+ android_net_res_stats_get_usable_servers(params, res_stats, nscount, valid_servers);
+
+ // Convert the server sockaddr structures to std::string.
+ stats->resize(nscount);
+ for (int i = 0 ; i < nscount ; ++i) {
+ char hbuf[NI_MAXHOST];
+ int rv = getnameinfo(reinterpret_cast<const sockaddr*>(&res_servers[i]),
+ sizeof(res_servers[i]), hbuf, sizeof(hbuf), nullptr, 0, NI_NUMERICHOST);
+ std::string server_str;
+ if (rv == 0) {
+ server_str.assign(hbuf);
+ } else {
+ ALOGE("getnameinfo() failed for server #%d: %s", i, gai_strerror(rv));
+ server_str.assign("<invalid>");
+ }
+ servers->push_back(std::move(server_str));
+ android::net::ResolverStats& cur_stats = (*stats)[i];
+ android_net_res_stats_aggregate(&res_stats[i], &cur_stats.successes, &cur_stats.errors,
+ &cur_stats.timeouts, &cur_stats.internal_errors, &cur_stats.rtt_avg,
+ &cur_stats.last_sample_time);
+ cur_stats.usable = valid_servers[i];
+ }
+
+ // Convert the stack-allocated search domain strings to std::string.
+ for (int i = 0 ; i < dcount ; ++i) {
+ domains->push_back(res_domains[i]);
+ }
+ return 0;
+}
+
+int ResolverController::setResolverConfiguration(int32_t netId,
+ const std::vector<std::string>& servers, const std::vector<std::string>& domains,
+ const std::vector<int32_t>& params) {
+ using android::net::INetd;
+ if (params.size() != INetd::RESOLVER_PARAMS_COUNT) {
+ ALOGE("%s: params.size()=%zu", __FUNCTION__, params.size());
+ return -EINVAL;
+ }
+
+ auto server_count = std::min<size_t>(MAXNS, servers.size());
+ std::vector<const char*> server_ptrs;
+ for (size_t i = 0 ; i < server_count ; ++i) {
+ server_ptrs.push_back(servers[i].c_str());
+ }
+
+ std::string domains_str;
+ if (!domains.empty()) {
+ domains_str = domains[0];
+ for (size_t i = 1 ; i < domains.size() ; ++i) {
+ domains_str += " " + domains[i];
+ }
+ }
+
+ __res_params res_params;
+ res_params.sample_validity = params[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY];
+ res_params.success_threshold = params[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD];
+ res_params.min_samples = params[INetd::RESOLVER_PARAMS_MIN_SAMPLES];
+ res_params.max_samples = params[INetd::RESOLVER_PARAMS_MAX_SAMPLES];
+
+ return setDnsServers(netId, domains_str.c_str(), server_ptrs.data(), server_ptrs.size(),
+ &res_params);
+}
+
+int ResolverController::getResolverInfo(int32_t netId, std::vector<std::string>* servers,
+ std::vector<std::string>* domains, std::vector<int32_t>* params,
+ std::vector<int32_t>* stats) {
+ using android::net::ResolverStats;
+ using android::net::INetd;
+ __res_params res_params;
+ std::vector<ResolverStats> res_stats;
+ int ret = getDnsInfo(netId, servers, domains, &res_params, &res_stats);
+ if (ret != 0) {
+ return ret;
+ }
+
+ // Serialize the information for binder.
+ ResolverStats::encodeAll(res_stats, stats);
+
+ params->resize(INetd::RESOLVER_PARAMS_COUNT);
+ (*params)[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY] = res_params.sample_validity;
+ (*params)[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD] = res_params.success_threshold;
+ (*params)[INetd::RESOLVER_PARAMS_MIN_SAMPLES] = res_params.min_samples;
+ (*params)[INetd::RESOLVER_PARAMS_MAX_SAMPLES] = res_params.max_samples;
+ return 0;
+}
+
+void ResolverController::dump(DumpWriter& dw, unsigned netId) {
+ // No lock needed since Bionic's resolver locks all accessed data structures internally.
+ using android::net::ResolverStats;
+ std::vector<std::string> servers;
+ std::vector<std::string> domains;
+ __res_params params;
+ std::vector<ResolverStats> stats;
+ time_t now = time(nullptr);
+ int rv = getDnsInfo(netId, &servers, &domains, ¶ms, &stats);
+ dw.incIndent();
+ if (rv != 0) {
+ dw.println("getDnsInfo() failed for netid %u", netId);
+ } else {
+ if (servers.empty()) {
+ dw.println("No DNS servers defined");
+ } else {
+ dw.println("DNS servers: # IP (total, successes, errors, timeouts, internal errors, "
+ "RTT avg, last sample)");
+ dw.incIndent();
+ for (size_t i = 0 ; i < servers.size() ; ++i) {
+ if (i < stats.size()) {
+ const ResolverStats& s = stats[i];
+ int total = s.successes + s.errors + s.timeouts + s.internal_errors;
+ if (total > 0) {
+ int time_delta = (s.last_sample_time > 0) ? now - s.last_sample_time : -1;
+ dw.println("%s (%d, %d, %d, %d, %d, %dms, %ds)%s", servers[i].c_str(),
+ total, s.successes, s.errors, s.timeouts, s.internal_errors,
+ s.rtt_avg, time_delta, s.usable ? "" : " BROKEN");
+ } else {
+ dw.println("%s <no data>", servers[i].c_str());
+ }
+ } else {
+ dw.println("%s <no stats>", servers[i].c_str());
+ }
+ }
+ dw.decIndent();
+ }
+ if (domains.empty()) {
+ dw.println("No search domains defined");
+ } else {
+ std::string domains_str = android::base::Join(domains, ", ");
+ dw.println("search domains: %s", domains_str.c_str());
+ }
+ if (params.sample_validity != 0) {
+ dw.println("DNS parameters: sample validity = %us, success threshold = %u%%, "
+ "samples (min, max) = (%u, %u)", params.sample_validity,
+ static_cast<unsigned>(params.success_threshold),
+ static_cast<unsigned>(params.min_samples),
+ static_cast<unsigned>(params.max_samples));
+ }
+ }
+ dw.decIndent();
+}
OSDN Git Service
