>From 5ce8809b522afa1226718ce5b354b24783e90793 Mon Sep 17 00:00:00 2001
From: Matthieu Patou <mat@matws.net>
Date: Tue, 7 Feb 2017 11:29:55 -0800
Subject: [PATCH 31/33] Move to async name resolution for names returned by SRV
 lookups

For small setups and correctly configured one, DNS servers will add
additional records in the SRV response with the A/AAAA entries
associated with the name that are returned.

But if it's too large or if the server is not correctly configured then
the additional names are not returned and we have to resort on calling
getaddrinfo. Traditionally we have been doing it in sequence but for
large/slow network it can be an issue.

With this change resolution is now asynchronous (using
pthreadpool_tevent framework), all the DNS requests are fired at once
and then we wait for all the threads to provide the results before
assembling the ip_list response
Signed-off-by: Matthieu Patou <mat@matws.net>

Change-Id: Ib755bbe98a5bd649d4959bd2474fc883f0ae65df
---
 source3/libsmb/namequery.c | 220 +++++++++++++++++++++++++++++++--------------
 1 file changed, 151 insertions(+), 69 deletions(-)

diff --git a/source3/libsmb/namequery.c b/source3/libsmb/namequery.c
index 945fc64..0bbcc5a 100644
--- a/source3/libsmb/namequery.c
+++ b/source3/libsmb/namequery.c
@@ -28,6 +28,7 @@
 #include "libsmb/nmblib.h"
 #include "../libcli/nbt/libnbt.h"
 #include "libads/kerberos_proto.h"
+#include "lib/pthreadpool/pthreadpool_tevent.h"
 
 /* nmbd.c sets this to True. */
 bool global_in_nmbd = False;
@@ -2361,6 +2362,35 @@ static NTSTATUS resolve_hosts(const char *name, int name_type,
 	return NT_STATUS_UNSUCCESSFUL;
 }
 
+static void resolve_one_name(void *private_data)
+{
+	struct dns_rr_srv *rr = private_data;
+	struct addrinfo *res = NULL;
+	struct addrinfo *p;
+	int num_ips = 0;
+	if (!interpret_string_addr_internal(&res, rr->hostname, 0)) {
+		return;
+	}
+	/* Add in every IP from the lookup. How many is that ? */
+	for (p = res; p; p = p->ai_next) {
+		if (num_ips != 0) {
+			if (NULL == (rr->ss_s = talloc_realloc(rr->ss_s, rr->ss_s,
+					struct sockaddr_storage, num_ips + 1)))
+			{
+				return;
+			}
+		}
+		memcpy(&rr->ss_s[num_ips], p->ai_addr, p->ai_addrlen);
+		if (is_zero_addr(&rr->ss_s[num_ips])) {
+			continue;
+		}
+		num_ips++;
+	}
+	rr->num_ips = num_ips;
+	if (res) {
+		freeaddrinfo(res);
+	}
+}
 /********************************************************
  Resolve via "ADS" method.
 *********************************************************/
@@ -2380,6 +2410,12 @@ static NTSTATUS resolve_ads(const char *name,
 	struct dns_rr_srv	*dcs = NULL;
 	int			numdcs = 0;
 	int			numaddrs = 0;
+	int			allocated_addrs = 0;
+	int			ret;
+	struct			pthreadpool_tevent *pth_tevent;
+	struct			tevent_context *ev;
+	struct			tevent_req *req1, **allreqs;
+	bool			exec_continue = true;
 
 	if ((name_type != 0x1c) && (name_type != KDC_NAME_TYPE) &&
 	    (name_type != 0x1b)) {
@@ -2437,98 +2473,144 @@ static NTSTATUS resolve_ads(const char *name,
 		return NT_STATUS_OK;
 	}
 
-	for (i=0;i<numdcs;i++) {
+	/* prepare for async resolution of missing IPs */
+	ev = tevent_context_init(ctx);
+	ret = pthreadpool_tevent_init(ctx, 0, &pth_tevent);
+	if (ret != 0) {
+		DEBUG(0,("resolve_ads: Can't create the threadpool context: %s",
+			strerror(ret)));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	allreqs = talloc_zero_array(ctx, struct tevent_req*, numdcs);
+	if (allreqs == NULL) {
+		DEBUG(0,("resolve_ads: malloc failed for %d entries\n", numdcs));
+		talloc_destroy(ctx);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	for (i=0; i < numdcs; i++) {
 		if (!dcs[i].ss_s) {
 			numaddrs += 1;
+			/* resolve_one_name needs to (re)allocate memory sometime
+			 * but we only pass dcs[i] which is just an element of a talloced
+			 * array and so it can't be used by talloc so instead we need
+			 * to preallocate the first entry for ss_s and then we can just reallocate it
+			 * there is a small chance that we will allocate memory that will not
+			 * be used (if getaddrinfo fails) but it's unlikely
+			 * and if it happens it will be free soon enough.
+			 */
+			dcs[i].ss_s = talloc_array(dcs, struct sockaddr_storage, 1);
+			if (dcs[i].ss_s == NULL)
+			{
+				DEBUG(0,("resolve_ads: failed to  allocate memory\n"));
+				talloc_destroy(ctx);
+				return NT_STATUS_NO_MEMORY;
+			}
+			req1 = pthreadpool_tevent_job_send(ev, ev, pth_tevent,
+							resolve_one_name, &dcs[i]);
+			if (req1 == NULL) {
+				DEBUG(0,("resolve_ads: pthreadpool_tevent_job_send failed\n"));
+				talloc_destroy(ctx);
+				return NT_STATUS_NO_MEMORY;
+			}
+			allreqs[i] = req1;
 		} else {
 			numaddrs += dcs[i].num_ips;
 		}
-        }
+	}
 
 	if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
-			NULL ) {
+			NULL) {
 		DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
 					numaddrs ));
 		talloc_destroy(ctx);
 		return NT_STATUS_NO_MEMORY;
 	}
+	allocated_addrs = numaddrs;
+	numaddrs = 0;
 
-	/* now unroll the list of IP addresses */
+	/* let's wait for all the events to be done */
+	for (i=0; i < numdcs; i++) {
+		bool ok;
+		if (allreqs[i] == NULL) {
+			continue;
+		}
+		req1 = allreqs[i];
+		ok = tevent_req_poll(req1, ev);
+		TALLOC_FREE(req1);
+		if (!ok) {
+			DEBUG(0,("resolve_ads: tevent_req_poll failed for index %d: %s\n",
+				i, strerror(ret)));
+			exec_continue = false;
+		}
+	}
+	if (!exec_continue) {
+		talloc_destroy(ctx);
+		return NT_STATUS_UNSUCCESSFUL;
+	}
 
-	*return_count = 0;
+	TALLOC_FREE(allreqs);
 
-	for (i = 0; i < numdcs && (*return_count<numaddrs); i++ ) {
-		/* If we don't have an IP list for a name, lookup it up */
+	for (i = 0; i < numdcs && (*return_count < allocated_addrs); i++ ) {
+		int j;
+		int delta = 0;
 		if (!dcs[i].ss_s) {
-			/* We need to get all IP addresses here. */
-			struct addrinfo *res = NULL;
-			struct addrinfo *p;
-			int extra_addrs = 0;
-
-			if (!interpret_string_addr_internal(&res,
-						dcs[i].hostname,
-						0)) {
+			/* We already have tried to get the IP for this name
+			 * seems to have failed, it's not clear if try one
+			 * or two, three, ...  more time(s) will actually help
+			 * So just skip it.
+			 */
+			DEBUG(0,("resolve_ads: sockaddr_storage still NULL even after"\
+				 " trying to resolve it for the name %s\n",
+				 dcs[i].hostname));
+			continue;
+		}
+		/* There is a least one name left so make room for it too*/
+		if (i < (numdcs - 1)) {
+			delta = 1;
+		}
+		/*
+		 * This is a bit of change with how it used to be done before
+		 * We now use all the initial space that has been allocated
+		 * (on the basis that each name will return 1 IP)
+		 * and then only when we extend the array to meet the size requirements
+		 */
+		if ((numaddrs + dcs[i].num_ips + delta) > allocated_addrs) {
+			allocated_addrs = numaddrs + dcs[i].num_ips + delta;
+			*return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
+							struct ip_service,
+							allocated_addrs);
+		}
+		for (j = 0; j < dcs[i].num_ips; j++) {
+			(*return_iplist)[*return_count].port = dcs[i].port;
+			(*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
+			if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
 				continue;
 			}
-			/* Add in every IP from the lookup. How
-			   many is that ? */
-			for (p = res; p; p = p->ai_next) {
-				struct sockaddr_storage ss;
-				memcpy(&ss, p->ai_addr, p->ai_addrlen);
-				if (is_zero_addr(&ss)) {
-					continue;
-				}
-				extra_addrs++;
-			}
-			if (extra_addrs > 1) {
-				/* We need to expand the return_iplist array
-				   as we only budgeted for one address. */
-				numaddrs += (extra_addrs-1);
-				*return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
-						struct ip_service,
-						numaddrs);
-				if (*return_iplist == NULL) {
-					if (res) {
-						freeaddrinfo(res);
-					}
-					talloc_destroy(ctx);
-					return NT_STATUS_NO_MEMORY;
-				}
-			}
-			for (p = res; p; p = p->ai_next) {
-				(*return_iplist)[*return_count].port = dcs[i].port;
-				memcpy(&(*return_iplist)[*return_count].ss,
-						p->ai_addr,
-						p->ai_addrlen);
-				if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
-					continue;
-				}
-				(*return_count)++;
-				/* Should never happen, but still... */
-				if (*return_count>=numaddrs) {
-					break;
-				}
-			}
-			if (res) {
-				freeaddrinfo(res);
-			}
-		} else {
-			/* use all the IP addresses from the SRV sresponse */
-			int j;
-			for (j = 0; j < dcs[i].num_ips; j++) {
-				(*return_iplist)[*return_count].port = dcs[i].port;
-				(*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
-				if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
-					continue;
-				}
-                                (*return_count)++;
-				/* Should never happen, but still... */
-				if (*return_count>=numaddrs) {
+			(*return_count)++;
+			numaddrs++;
+			if (*return_count >= allocated_addrs) {
+				/*
+				 * This should never happen but if it's the last
+				 * DC and the last entry actually the condition
+				 * is not really unexpected.
+				 */
+				if (!((*return_count == allocated_addrs) &&
+				     (j == (dcs[i].num_ips - 1)) &&
+				     (i == (numdcs - 1)))) {
+					DEBUG(0,("resolve_ads: unexpected condition met "\
+						 "return_count > allocated_addrs (%d vs %d) "\
+						 "while processing %s\n" ,
+						*return_count,
+						allocated_addrs,
+						dcs[i].hostname));
 					break;
 				}
 			}
 		}
 	}
+	DEBUG(10,("resolve_ads: returning %d entries\n", *return_count));
 
 	talloc_destroy(ctx);
 	return NT_STATUS_OK;
-- 
2.7.4