Replace string-to-number functions. (dc4c873b) · Commits · e / os / android_packages_modules_DnsResolver

DnsProxyListener.cpp

+62 −53

Original line number	Original line	Diff line number	Diff line
	@@ -18,7 +18,6 @@

	#include <arpa/inet.h>		#include <arpa/inet.h>
	#include <dirent.h>		#include <dirent.h>
	#include <errno.h>
	#include <linux/if.h>		#include <linux/if.h>
	#include <math.h>		#include <math.h>
	#include <net/if.h>		#include <net/if.h>
	@@ -34,6 +33,7 @@
	#include <algorithm>		#include <algorithm>
	#include <vector>		#include <vector>

			#include <android-base/parseint.h>
	#include <android/multinetwork.h> // ResNsendFlags		#include <android/multinetwork.h> // ResNsendFlags
	#include <cutils/misc.h> // FIRST_APPLICATION_UID		#include <cutils/misc.h> // FIRST_APPLICATION_UID
	#include <cutils/multiuser.h>		#include <cutils/multiuser.h>
	@@ -63,6 +63,8 @@
	using aidl::android::net::metrics::INetdEventListener;		using aidl::android::net::metrics::INetdEventListener;
	using aidl::android::net::resolv::aidl::DnsHealthEventParcel;		using aidl::android::net::resolv::aidl::DnsHealthEventParcel;
	using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;		using aidl::android::net::resolv::aidl::IDnsResolverUnsolicitedEventListener;
			using android::base::ParseInt;
			using android::base::ParseUint;
	using std::span;		using std::span;

	namespace android {		namespace android {
	@@ -235,20 +237,6 @@ int resNSendToAiError(int err, int rcode) {
	return EAI_SYSTEM;		return EAI_SYSTEM;
	}		}

	template <typename IntegralType>
	bool simpleStrtoul(const char* input, IntegralType* output, int base = 10) {
	char* endPtr;
	errno = 0;
	auto result = strtoul(input, &endPtr, base);
	// Check the length in order to ensure there is no "-" sign
	if (!input \|\| endPtr \|\| (endPtr - input) != static_cast<ptrdiff_t>(strlen(input)) \|\|
	(errno == ERANGE && (result == ULONG_MAX))) {
	return false;
	}
	*output = result;
	return true;
	}

	bool setQueryId(span<uint8_t> msg, uint16_t query_id) {		bool setQueryId(span<uint8_t> msg, uint16_t query_id) {
	if ((size_t)msg.size() < sizeof(HEADER)) {		if ((size_t)msg.size() < sizeof(HEADER)) {
	errno = EINVAL;		errno = EINVAL;
	@@ -703,6 +691,17 @@ static bool evaluate_domain_name(const android_net_context& netcontext, const ch
	return gResNetdCallbacks.evaluate_domain_name(netcontext, host);		return gResNetdCallbacks.evaluate_domain_name(netcontext, host);
	}		}

			static int HandleArgumentError(SocketClient* cli, int errorcode, std::string strerrormessage,
			int argc, char** argv) {
			for (int i = 0; i < argc; i++) {
			strerrormessage += "argv[" + std::to_string(i) + "]=" + (argv[i] ? argv[i] : "null") + " ";
			}

			LOG(WARNING) << strerrormessage;
			cli->sendMsg(errorcode, strerrormessage.c_str(), false);
			return -1;
			}

	static bool sendBE32(SocketClient* c, uint32_t data) {		static bool sendBE32(SocketClient* c, uint32_t data) {
	uint32_t be_data = htonl(data);		uint32_t be_data = htonl(data);
	return c->sendData(&be_data, sizeof(be_data)) == 0;		return c->sendData(&be_data, sizeof(be_data)) == 0;
	@@ -911,22 +910,31 @@ DnsProxyListener::GetAddrInfoCmd::GetAddrInfoCmd() : FrameworkCommand("getaddrin
	int DnsProxyListener::GetAddrInfoCmd::runCommand(SocketClient* cli, int argc, char** argv) {		int DnsProxyListener::GetAddrInfoCmd::runCommand(SocketClient* cli, int argc, char** argv) {
	logArguments(argc, argv);		logArguments(argc, argv);

			int ai_flags = 0;
			int ai_family = 0;
			int ai_socktype = 0;
			int ai_protocol = 0;
			unsigned netId = 0;
			std::string strErr = "GetAddrInfoCmd::runCommand: ";

	if (argc != 8) {		if (argc != 8) {
	char* msg = nullptr;		strErr = strErr + "invalid number of arguments: " + std::to_string(argc);
	asprintf(&msg, "Invalid number of arguments to getaddrinfo: %i", argc);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, 0, NULL);
	LOG(WARNING) << "GetAddrInfoCmd::runCommand: " << (msg ? msg : "null");
	cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
	free(msg);
	return -1;
	}		}

	const std::string name = argv[1];		const std::string name = argv[1];
	const std::string service = argv[2];		const std::string service = argv[2];
	int ai_flags = strtol(argv[3], nullptr, 10);		if (!ParseInt(argv[3], &ai_flags))
	int ai_family = strtol(argv[4], nullptr, 10);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
	int ai_socktype = strtol(argv[5], nullptr, 10);		if (!ParseInt(argv[4], &ai_family))
	int ai_protocol = strtol(argv[6], nullptr, 10);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
	unsigned netId = strtoul(argv[7], nullptr, 10);		if (!ParseInt(argv[5], &ai_socktype))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
			if (!ParseInt(argv[6], &ai_protocol))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
			if (!ParseUint(argv[7], &netId))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);

	const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);		const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);
	const uid_t uid = cli->getUid();		const uid_t uid = cli->getUid();

	@@ -967,7 +975,7 @@ int DnsProxyListener::ResNSendCommand::runCommand(SocketClient* cli, int argc, c
	}		}

	unsigned netId;		unsigned netId;
	if (!simpleStrtoul(argv[1], &netId)) {		if (!ParseUint(argv[1], &netId)) {
	LOG(WARNING) << "ResNSendCommand::runCommand: resnsend: from UID " << uid		LOG(WARNING) << "ResNSendCommand::runCommand: resnsend: from UID " << uid
	<< ", invalid netId";		<< ", invalid netId";
	sendBE32(cli, -EINVAL);		sendBE32(cli, -EINVAL);
	@@ -975,7 +983,7 @@ int DnsProxyListener::ResNSendCommand::runCommand(SocketClient* cli, int argc, c
	}		}

	uint32_t flags;		uint32_t flags;
	if (!simpleStrtoul(argv[2], &flags)) {		if (!ParseUint(argv[2], &flags)) {
	LOG(WARNING) << "ResNSendCommand::runCommand: resnsend: from UID " << uid		LOG(WARNING) << "ResNSendCommand::runCommand: resnsend: from UID " << uid
	<< ", invalid flags";		<< ", invalid flags";
	sendBE32(cli, -EINVAL);		sendBE32(cli, -EINVAL);
	@@ -1124,7 +1132,7 @@ int DnsProxyListener::GetDnsNetIdCommand::runCommand(SocketClient* cli, int argc
	}		}

	unsigned netId;		unsigned netId;
	if (!simpleStrtoul(argv[1], &netId)) {		if (!ParseUint(argv[1], &netId)) {
	LOG(WARNING) << "GetDnsNetIdCommand::runCommand: getdnsnetid: from UID " << uid		LOG(WARNING) << "GetDnsNetIdCommand::runCommand: getdnsnetid: from UID " << uid
	<< ", invalid netId";		<< ", invalid netId";
	sendCodeAndBe32(cli, ResponseCode::DnsProxyQueryResult, -EINVAL);		sendCodeAndBe32(cli, ResponseCode::DnsProxyQueryResult, -EINVAL);
	@@ -1158,20 +1166,22 @@ DnsProxyListener::GetHostByNameCmd::GetHostByNameCmd() : FrameworkCommand("getho
	int DnsProxyListener::GetHostByNameCmd::runCommand(SocketClient* cli, int argc, char** argv) {		int DnsProxyListener::GetHostByNameCmd::runCommand(SocketClient* cli, int argc, char** argv) {
	logArguments(argc, argv);		logArguments(argc, argv);

			unsigned netId = 0;
			int af = 0;
			std::string strErr = "GetHostByNameCmd::runCommand: ";

	if (argc != 4) {		if (argc != 4) {
	char* msg = nullptr;		strErr = strErr + "invalid number of arguments: " + std::to_string(argc);
	asprintf(&msg, "Invalid number of arguments to gethostbyname: %i", argc);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, 0, NULL);
	LOG(WARNING) << "GetHostByNameCmd::runCommand: " << (msg ? msg : "null");
	cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
	free(msg);
	return -1;
	}		}

			if (!ParseUint(argv[1], &netId))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
			std::string name = argv[2];
			if (!ParseInt(argv[3], &af))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
	uid_t uid = cli->getUid();		uid_t uid = cli->getUid();
	unsigned netId = strtoul(argv[1], nullptr, 10);
	const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);		const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);
	std::string name = argv[2];
	int af = strtol(argv[3], nullptr, 10);

	android_net_context netcontext;		android_net_context netcontext;
	gResNetdCallbacks.get_network_context(netId, uid, &netcontext);		gResNetdCallbacks.get_network_context(netId, uid, &netcontext);
	@@ -1292,33 +1302,32 @@ DnsProxyListener::GetHostByAddrCmd::GetHostByAddrCmd() : FrameworkCommand("getho

	int DnsProxyListener::GetHostByAddrCmd::runCommand(SocketClient* cli, int argc, char** argv) {		int DnsProxyListener::GetHostByAddrCmd::runCommand(SocketClient* cli, int argc, char** argv) {
	logArguments(argc, argv);		logArguments(argc, argv);
			int addrLen = 0;
			int addrFamily = 0;
			unsigned netId = 0;
			std::string strErr = "GetHostByAddrCmd::runCommand: ";

	if (argc != 5) {		if (argc != 5) {
	char* msg = nullptr;		strErr = strErr + "invalid number of arguments: " + std::to_string(argc);
	asprintf(&msg, "Invalid number of arguments to gethostbyaddr: %i", argc);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, 0, NULL);
	LOG(WARNING) << "GetHostByAddrCmd::runCommand: " << (msg ? msg : "null");
	cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
	free(msg);
	return -1;
	}		}

	char* addrStr = argv[1];		char* addrStr = argv[1];
	int addrLen = strtol(argv[2], nullptr, 10);		if (!ParseInt(argv[2], &addrLen))
	int addrFamily = strtol(argv[3], nullptr, 10);		return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
			if (!ParseInt(argv[3], &addrFamily))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
			if (!ParseUint(argv[4], &netId))
			return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
	uid_t uid = cli->getUid();		uid_t uid = cli->getUid();
	unsigned netId = strtoul(argv[4], nullptr, 10);
	const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);		const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);

	in6_addr addr;		in6_addr addr;
	errno = 0;		errno = 0;
	int result = inet_pton(addrFamily, addrStr, &addr);		int result = inet_pton(addrFamily, addrStr, &addr);
	if (result <= 0) {		if (result <= 0) {
	char* msg = nullptr;		strErr = strErr + "inet_pton(\"" + addrStr + "\") failed " + strerror(errno);
	asprintf(&msg, "inet_pton(\"%s\") failed %s", addrStr, strerror(errno));		return HandleArgumentError(cli, ResponseCode::OperationFailed, strErr, 0, NULL);
	LOG(WARNING) << "GetHostByAddrCmd::runCommand: " << (msg ? msg : "null");
	cli->sendMsg(ResponseCode::OperationFailed, msg, false);
	free(msg);
	return -1;
	}		}

	android_net_context netcontext;		android_net_context netcontext;

getaddrinfo.cpp

+8 −33

Original line number	Original line	Diff line number	Diff line
	@@ -38,7 +38,6 @@
	#include <arpa/nameser.h>		#include <arpa/nameser.h>
	#include <assert.h>		#include <assert.h>
	#include <ctype.h>		#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>		#include <fcntl.h>
	#include <net/if.h>		#include <net/if.h>
	#include <netdb.h>		#include <netdb.h>
	@@ -57,6 +56,7 @@
	#include <future>		#include <future>

	#include <android-base/logging.h>		#include <android-base/logging.h>
			#include <android-base/parseint.h>

	#include "Experiments.h"		#include "Experiments.h"
	#include "netd_resolv/resolv.h"		#include "netd_resolv/resolv.h"
	@@ -64,7 +64,6 @@
	#include "res_debug.h"		#include "res_debug.h"
	#include "resolv_cache.h"		#include "resolv_cache.h"
	#include "resolv_private.h"		#include "resolv_private.h"
	#include "util.h"

	#define ANY 0		#define ANY 0

	@@ -123,7 +122,6 @@ struct res_target {
	int n = 0; // result length		int n = 0; // result length
	};		};

	static int str2number(const char*);
	static int explore_fqdn(const struct addrinfo, const char, const char, struct addrinfo*,		static int explore_fqdn(const struct addrinfo, const char, const char, struct addrinfo*,
	const struct android_net_context, NetworkDnsEventReported event);		const struct android_net_context, NetworkDnsEventReported event);
	static int explore_null(const struct addrinfo, const char, struct addrinfo**);		static int explore_null(const struct addrinfo, const char, struct addrinfo**);
	@@ -213,22 +211,6 @@ void freeaddrinfo(struct addrinfo* ai) {
	}		}
	}		}

	static int str2number(const char* p) {
	char* ep;
	unsigned long v;

	assert(p != NULL);

	if (*p == '\0') return -1;
	ep = NULL;
	errno = 0;
	v = strtoul(p, &ep, 10);
	if (errno == 0 && ep && *ep == '\0' && v <= UINT_MAX)
	return v;
	else
	return -1;
	}

	/*		/*
	* The following functions determine whether IPv4 or IPv6 connectivity is		* The following functions determine whether IPv4 or IPv6 connectivity is
	* available in order to implement AI_ADDRCONFIG.		* available in order to implement AI_ADDRCONFIG.
	@@ -711,7 +693,7 @@ static int get_portmatch(const struct addrinfo* ai, const char* servname) {
	static int get_port(const struct addrinfo* ai, const char* servname, int matchonly) {		static int get_port(const struct addrinfo* ai, const char* servname, int matchonly) {
	const char* proto;		const char* proto;
	struct servent* sp;		struct servent* sp;
	int port;		uint port;
	int allownumeric;		int allownumeric;

	assert(ai != NULL);		assert(ai != NULL);
	@@ -738,10 +720,9 @@ static int get_port(const struct addrinfo* ai, const char* servname, int matchon
	return EAI_SOCKTYPE;		return EAI_SOCKTYPE;
	}		}

	port = str2number(servname);		if (android::base::ParseUint(servname, &port)) {
	if (port >= 0) {
	if (!allownumeric) return EAI_SERVICE;		if (!allownumeric) return EAI_SERVICE;
	if (port < 0 \|\| port > 65535) return EAI_SERVICE;		if (port > 65535) return EAI_SERVICE;
	port = htons(port);		port = htons(port);
	} else {		} else {
	if (ai->ai_flags & AI_NUMERICSERV) return EAI_NONAME;		if (ai->ai_flags & AI_NUMERICSERV) return EAI_NONAME;
	@@ -788,9 +769,7 @@ static const struct afd* find_afd(int af) {

	// Convert a string to a scope identifier.		// Convert a string to a scope identifier.
	static int ip6_str2scopeid(const char* scope, struct sockaddr_in6* sin6, uint32_t* scopeid) {		static int ip6_str2scopeid(const char* scope, struct sockaddr_in6* sin6, uint32_t* scopeid) {
	uint64_t lscopeid;
	struct in6_addr* a6;		struct in6_addr* a6;
	char* ep;

	assert(scope != NULL);		assert(scope != NULL);
	assert(sin6 != NULL);		assert(sin6 != NULL);
	@@ -811,14 +790,10 @@ static int ip6_str2scopeid(const char* scope, struct sockaddr_in6* sin6, uint32_
	if (*scopeid != 0) return 0;		if (*scopeid != 0) return 0;
	}		}

	// try to convert to a numeric id as a last resort		/* try to convert to a numeric id as a last resort*/
	errno = 0;		if (!android::base::ParseUint(scope, scopeid)) return -1;
	lscopeid = strtoul(scope, &ep, 10);
	*scopeid = (uint32_t)(lscopeid & 0xffffffffUL);
	if (errno == 0 && ep && ep == '\0' && scopeid == lscopeid)
	return 0;		return 0;
	else
	return -1;
	}		}

	/* code duplicate with gethnamaddr.c */		/* code duplicate with gethnamaddr.c */