#include <dirent.h>
#include <errno.h>
#include <linux/if.h>
+#include <math.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdlib.h>
#define DBG 0
#define VDBG 0
+#include <chrono>
+
#include <cutils/log.h>
+#include <binder/IServiceManager.h>
+#include <utils/String16.h>
#include <sysutils/SocketClient.h>
#include "Fwmark.h"
#include "NetdConstants.h"
#include "NetworkController.h"
#include "ResponseCode.h"
+#include "Stopwatch.h"
+#include "android/net/metrics/INetdEventListener.h"
+
+using android::String16;
+using android::interface_cast;
+using android::net::metrics::INetdEventListener;
DnsProxyListener::DnsProxyListener(const NetworkController* netCtrl) :
FrameworkListener("dnsproxyd"), mNetCtrl(netCtrl) {
DnsProxyListener::GetAddrInfoHandler::GetAddrInfoHandler(
SocketClient *c, char* host, char* service, struct addrinfo* hints,
- const struct android_net_context& netcontext)
+ const struct android_net_context& netcontext,
+ const android::sp<android::net::metrics::INetdEventListener>& netdEventListener)
: mClient(c),
mHost(host),
mService(service),
mHints(hints),
- mNetContext(netcontext) {
+ mNetContext(netcontext),
+ mNetdEventListener(netdEventListener) {
}
DnsProxyListener::GetAddrInfoHandler::~GetAddrInfoHandler() {
return NULL;
}
+android::sp<INetdEventListener> DnsProxyListener::getNetdEventListener() {
+ if (mNetdEventListener == nullptr) {
+ // Use checkService instead of getService because getService waits for 5 seconds for the
+ // service to become available. The DNS resolver inside netd is started much earlier in the
+ // boot sequence than the framework DNS listener, and we don't want to delay all DNS lookups
+ // for 5 seconds until the DNS listener starts up.
+ android::sp<android::IBinder> b = android::defaultServiceManager()->checkService(
+ android::String16("netd_listener"));
+ if (b != nullptr) {
+ mNetdEventListener = interface_cast<INetdEventListener>(b);
+ }
+ }
+ // If the DNS listener service is dead, the binder call will just return an error, which should
+ // be fine because the only impact is that we can't log DNS events. In any case, this should
+ // only happen if the system server is going down, which means it will shortly be taking us down
+ // with it.
+ return mNetdEventListener;
+}
+
static bool sendBE32(SocketClient* c, uint32_t data) {
uint32_t be_data = htonl(data);
return c->sendData(&be_data, sizeof(be_data)) == 0;
}
struct addrinfo* result = NULL;
+ Stopwatch s;
uint32_t rv = android_getaddrinfofornetcontext(mHost, mService, mHints, &mNetContext, &result);
+ const int latencyMs = lround(s.timeTaken());
+
if (rv) {
// getaddrinfo failed
mClient->sendBinaryMsg(ResponseCode::DnsProxyOperationFailed, &rv, sizeof(rv));
freeaddrinfo(result);
}
mClient->decRef();
+ if (mNetdEventListener != nullptr) {
+ mNetdEventListener->onDnsEvent(mNetContext.dns_netid,
+ INetdEventListener::EVENT_GETADDRINFO, (int32_t) rv,
+ latencyMs);
+ }
}
-DnsProxyListener::GetAddrInfoCmd::GetAddrInfoCmd(const DnsProxyListener* dnsProxyListener) :
+DnsProxyListener::GetAddrInfoCmd::GetAddrInfoCmd(DnsProxyListener* dnsProxyListener) :
NetdCommand("getaddrinfo"),
mDnsProxyListener(dnsProxyListener) {
}
cli->incRef();
DnsProxyListener::GetAddrInfoHandler* handler =
- new DnsProxyListener::GetAddrInfoHandler(cli, name, service, hints, netcontext);
+ new DnsProxyListener::GetAddrInfoHandler(cli, name, service, hints, netcontext,
+ mDnsProxyListener->getNetdEventListener());
handler->start();
return 0;
/*******************************************************
* GetHostByName *
*******************************************************/
-DnsProxyListener::GetHostByNameCmd::GetHostByNameCmd(const DnsProxyListener* dnsProxyListener) :
+DnsProxyListener::GetHostByNameCmd::GetHostByNameCmd(DnsProxyListener* dnsProxyListener) :
NetdCommand("gethostbyname"),
mDnsProxyListener(dnsProxyListener) {
}
cli->incRef();
DnsProxyListener::GetHostByNameHandler* handler =
- new DnsProxyListener::GetHostByNameHandler(cli, name, af, netId, mark);
+ new DnsProxyListener::GetHostByNameHandler(cli, name, af, netId, mark,
+ mDnsProxyListener->getNetdEventListener());
handler->start();
return 0;
}
-DnsProxyListener::GetHostByNameHandler::GetHostByNameHandler(SocketClient* c,
- char* name,
- int af,
- unsigned netId,
- uint32_t mark)
+DnsProxyListener::GetHostByNameHandler::GetHostByNameHandler(
+ SocketClient* c, char* name, int af, unsigned netId, uint32_t mark,
+ const android::sp<android::net::metrics::INetdEventListener>& netdEventListener)
: mClient(c),
mName(name),
mAf(af),
mNetId(netId),
- mMark(mark) {
+ mMark(mark),
+ mNetdEventListener(netdEventListener) {
}
DnsProxyListener::GetHostByNameHandler::~GetHostByNameHandler() {
ALOGD("DnsProxyListener::GetHostByNameHandler::run\n");
}
- struct hostent* hp;
-
- hp = android_gethostbynamefornet(mName, mAf, mNetId, mMark);
+ Stopwatch s;
+ struct hostent* hp = android_gethostbynamefornet(mName, mAf, mNetId, mMark);
+ const int latencyMs = lround(s.timeTaken());
if (DBG) {
ALOGD("GetHostByNameHandler::run gethostbyname errno: %s hp->h_name = %s, name_len = %zu\n",
ALOGW("GetHostByNameHandler: Error writing DNS result to client\n");
}
mClient->decRef();
+
+ if (mNetdEventListener != nullptr) {
+ mNetdEventListener->onDnsEvent(mNetId, INetdEventListener::EVENT_GETHOSTBYNAME,
+ h_errno, latencyMs);
+ }
}