busybox: add musl compatible nslookup replacement

Add an alternative nslookup applet implementation which is compatible with
musl libc wrt. name server selection and which supports a number of additional
features such as query type selection.

Fixes #155, #217

Signed-off-by: Jo-Philipp Wich <jo@mein.io>

3 files changed, 931 insertions, 0 deletions

diff --git a/package/utils/busybox/Config-defaults.in b/package/utils/busybox/Config-defaults.in
index 11cce03db9..1977e7ff46 100644
--- a/package/utils/busybox/Config-defaults.in
+++ b/package/utils/busybox/Config-defaults.in
@@ -2262,6 +2262,9 @@ config BUSYBOX_DEFAULT_FEATURE_NETSTAT_PRG
 	default y
 config BUSYBOX_DEFAULT_NSLOOKUP
 	bool
+	default n
+config BUSYBOX_DEFAULT_NSLOOKUP_LEDE
+	bool
 	default y
 config BUSYBOX_DEFAULT_NTPD
 	bool
diff --git a/package/utils/busybox/config/networking/Config.in b/package/utils/busybox/config/networking/Config.in
index 407ddd30dd..e58746bdd7 100644
--- a/package/utils/busybox/config/networking/Config.in
+++ b/package/utils/busybox/config/networking/Config.in
@@ -850,6 +850,20 @@ config BUSYBOX_CONFIG_NSLOOKUP
 	help
 	  nslookup is a tool to query Internet name servers.
 
+config BUSYBOX_CONFIG_NSLOOKUP_LEDE
+	bool "nslookup_lede"
+	depends on !BUSYBOX_CONFIG_NSLOOKUP
+	default BUSYBOX_DEFAULT_NSLOOKUP_LEDE
+	help
+	  nslookup is a tool to query Internet name servers (LEDE flavor).
+
+config BUSYBOX_CONFIG_FEATURE_NSLOOKUP_LEDE_LONG_OPTIONS
+       bool "Enable long options"
+       default BUSYBOX_DEFAULT_FEATURE_NSLOOKUP_LEDE_LONG_OPTIONS
+       depends on BUSYBOX_CONFIG_NSLOOKUP_LEDE && BUSYBOX_CONFIG_LONG_OPTS
+       help
+         Support long options for the nslookup applet.
+
 config BUSYBOX_CONFIG_NTPD
 	bool "ntpd"
 	default BUSYBOX_DEFAULT_NTPD
diff --git a/package/utils/busybox/patches/230-add_nslookup_lede.patch b/package/utils/busybox/patches/230-add_nslookup_lede.patch
new file mode 100644
index 0000000000..bff88a69cc
--- /dev/null
+++ b/package/utils/busybox/patches/230-add_nslookup_lede.patch
@@ -0,0 +1,914 @@
+From 8c1440a0934dd8b3ad6aae48d6653b5ba6fce8a1 Mon Sep 17 00:00:00 2001
+From: Jo-Philipp Wich <jo@mein.io>
+Date: Tue, 14 Mar 2017 22:21:34 +0100
+Subject: [PATCH] networking: add LEDE nslookup applet
+
+Add a new LEDE nslookup applet which is compatible with musl libc
+and providing more features like ability to specify query type.
+
+In contrast to busybox' builtin nslookup applet, this variant does
+not rely on libc resolver internals but uses explicit send logic
+and the libresolv primitives to parse received DNS responses.
+
+Signed-off-by: Jo-Philipp Wich <jo@mein.io>
+---
+ Makefile.flags             |   6 +
+ networking/nslookup_lede.c | 869 +++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 875 insertions(+)
+ create mode 100644 networking/nslookup_lede.c
+
+diff --git a/Makefile.flags b/Makefile.flags
+index 65021de..096ab77 100644
+--- a/Makefile.flags
++++ b/Makefile.flags
+@@ -134,6 +134,12 @@ else
+ LDLIBS += m
+ endif
+ 
++# nslookup_lede might need the resolv library
++RESOLV_AVAILABLE := $(shell echo 'int main(void){res_init();return 0;}' >resolvtest.c; $(CC) $(CFLAGS) -include resolv.h -lresolv -o /dev/null resolvtest.c >/dev/null 2>&1 && echo "y"; rm resolvtest.c)
++ifeq ($(RESOLV_AVAILABLE),y)
++LDLIBS += resolv
++endif
++
+ # libpam may use libpthread, libdl and/or libaudit.
+ # On some platforms that requires an explicit -lpthread, -ldl, -laudit.
+ # However, on *other platforms* it fails when some of those flags
+diff --git a/networking/nslookup_lede.c b/networking/nslookup_lede.c
+new file mode 100644
+index 0000000..fe927ad
+--- /dev/null
++++ b/networking/nslookup_lede.c
+@@ -0,0 +1,869 @@
++/*
++ * nslookup_lede - musl compatible replacement for busybox nslookup
++ *
++ * Copyright (C) 2017 Jo-Philipp Wich <jo@mein.io>
++ *
++ * Permission to use, copy, modify, and/or distribute this software for any
++ * purpose with or without fee is hereby granted, provided that the above
++ * copyright notice and this permission notice appear in all copies.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
++ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
++ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
++ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
++ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
++ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
++ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ */
++
++//config:config NSLOOKUP_LEDE
++//config:	bool "nslookup_lede"
++//config:	depends on !NSLOOKUP
++//config:	default y
++//config:	help
++//config:	  nslookup is a tool to query Internet name servers (LEDE flavor).
++//config:
++//config:config FEATURE_NSLOOKUP_LEDE_LONG_OPTIONS
++//config:       bool "Enable long options"
++//config:       default y
++//config:       depends on NSLOOKUP_LEDE && LONG_OPTS
++//config:       help
++//config:         Support long options for the nslookup applet.
++
++//applet:IF_NSLOOKUP_LEDE(APPLET(nslookup, BB_DIR_USR_BIN, BB_SUID_DROP))
++
++//kbuild:lib-$(CONFIG_NSLOOKUP_LEDE) += nslookup_lede.o
++
++//usage:#define nslookup_lede_trivial_usage
++//usage:       "[HOST] [SERVER]"
++//usage:#define nslookup_lede_full_usage "\n\n"
++//usage:       "Query the nameserver for the IP address of the given HOST\n"
++//usage:       "optionally using a specified DNS server"
++//usage:
++//usage:#define nslookup_lede_example_usage
++//usage:       "$ nslookup localhost\n"
++//usage:       "Server:     default\n"
++//usage:       "Address:    default\n"
++//usage:       "\n"
++//usage:       "Name:       debian\n"
++//usage:       "Address:    127.0.0.1\n"
++
++#include <stdio.h>
++#include <resolv.h>
++#include <string.h>
++#include <errno.h>
++#include <time.h>
++#include <poll.h>
++#include <unistd.h>
++#include <stdlib.h>
++#include <sys/socket.h>
++#include <arpa/inet.h>
++#include <net/if.h>
++#include <netdb.h>
++
++#include "libbb.h"
++
++struct ns {
++	const char *name;
++	len_and_sockaddr addr;
++	int failures;
++	int replies;
++};
++
++struct query {
++	const char *name;
++	size_t qlen, rlen;
++	unsigned char query[512], reply[512];
++	unsigned long latency;
++	int rcode, n_ns;
++};
++
++static struct {
++	int type;
++	const char *name;
++} qtypes[] = {
++	{ ns_t_soa,   "SOA"   },
++	{ ns_t_ns,    "NS"    },
++	{ ns_t_a,     "A"     },
++	{ ns_t_aaaa,  "AAAA"  },
++	{ ns_t_cname, "CNAME" },
++	{ ns_t_mx,    "MX"    },
++	{ ns_t_txt,   "TXT"   },
++	{ ns_t_ptr,   "PTR"   },
++	{ ns_t_any,   "ANY"   },
++	{ }
++};
++
++static const char *rcodes[] = {
++	"NOERROR",
++	"FORMERR",
++	"SERVFAIL",
++	"NXDOMAIN",
++	"NOTIMP",
++	"REFUSED",
++	"YXDOMAIN",
++	"YXRRSET",
++	"NXRRSET",
++	"NOTAUTH",
++	"NOTZONE",
++	"RESERVED11",
++	"RESERVED12",
++	"RESERVED13",
++	"RESERVED14",
++	"RESERVED15",
++	"BADVERS"
++};
++
++static unsigned int default_port = 53;
++static unsigned int default_retry = 2;
++static unsigned int default_timeout = 5;
++
++
++static int parse_reply(const unsigned char *msg, size_t len)
++{
++	ns_msg handle;
++	ns_rr rr;
++	int i, n, rdlen;
++	const char *format = NULL;
++	char astr[INET6_ADDRSTRLEN], dname[MAXDNAME];
++	const unsigned char *cp;
++
++	if (ns_initparse(msg, len, &handle) != 0) {
++		//fprintf(stderr, "Unable to parse reply: %s\n", strerror(errno));
++		return -1;
++	}
++
++	for (i = 0; i < ns_msg_count(handle, ns_s_an); i++) {
++		if (ns_parserr(&handle, ns_s_an, i, &rr) != 0) {
++			//fprintf(stderr, "Unable to parse resource record: %s\n", strerror(errno));
++			return -1;
++		}
++
++		rdlen = ns_rr_rdlen(rr);
++
++		switch (ns_rr_type(rr))
++		{
++		case ns_t_a:
++			if (rdlen != 4) {
++				//fprintf(stderr, "Unexpected A record length\n");
++				return -1;
++			}
++			inet_ntop(AF_INET, ns_rr_rdata(rr), astr, sizeof(astr));
++			printf("Name:\t%s\nAddress: %s\n", ns_rr_name(rr), astr);
++			break;
++
++		case ns_t_aaaa:
++			if (rdlen != 16) {
++				//fprintf(stderr, "Unexpected AAAA record length\n");
++				return -1;
++			}
++			inet_ntop(AF_INET6, ns_rr_rdata(rr), astr, sizeof(astr));
++			printf("%s\thas AAAA address %s\n", ns_rr_name(rr), astr);
++			break;
++
++		case ns_t_ns:
++			if (!format)
++				format = "%s\tnameserver = %s\n";
++			/* fall through */
++
++		case ns_t_cname:
++			if (!format)
++				format = "%s\tcanonical name = %s\n";
++			/* fall through */
++
++		case ns_t_ptr:
++			if (!format)
++				format = "%s\tname = %s\n";
++			if (ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle),
++				ns_rr_rdata(rr), dname, sizeof(dname)) < 0) {
++				//fprintf(stderr, "Unable to uncompress domain: %s\n", strerror(errno));
++				return -1;
++			}
++			printf(format, ns_rr_name(rr), dname);
++			break;
++
++		case ns_t_mx:
++			if (rdlen < 2) {
++				fprintf(stderr, "MX record too short\n");
++				return -1;
++			}
++			n = ns_get16(ns_rr_rdata(rr));
++			if (ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle),
++				ns_rr_rdata(rr) + 2, dname, sizeof(dname)) < 0) {
++				//fprintf(stderr, "Cannot uncompress MX domain: %s\n", strerror(errno));
++				return -1;
++			}
++			printf("%s\tmail exchanger = %d %s\n", ns_rr_name(rr), n, dname);
++			break;
++
++		case ns_t_txt:
++			if (rdlen < 1) {
++				//fprintf(stderr, "TXT record too short\n");
++				return -1;
++			}
++			n = *(unsigned char *)ns_rr_rdata(rr);
++			if (n > 0) {
++				memset(dname, 0, sizeof(dname));
++				memcpy(dname, ns_rr_rdata(rr) + 1, n);
++				printf("%s\ttext = \"%s\"\n", ns_rr_name(rr), dname);
++			}
++			break;
++
++		case ns_t_soa:
++			if (rdlen < 20) {
++				//fprintf(stderr, "SOA record too short\n");
++				return -1;
++			}
++
++			printf("%s\n", ns_rr_name(rr));
++
++			cp = ns_rr_rdata(rr);
++			n = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle),
++			                       cp, dname, sizeof(dname));
++
++			if (n < 0) {
++				//fprintf(stderr, "Unable to uncompress domain: %s\n", strerror(errno));
++				return -1;
++			}
++
++			printf("\torigin = %s\n", dname);
++			cp += n;
++
++			n = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle),
++			                       cp, dname, sizeof(dname));
++
++			if (n < 0) {
++				//fprintf(stderr, "Unable to uncompress domain: %s\n", strerror(errno));
++				return -1;
++			}
++
++			printf("\tmail addr = %s\n", dname);
++			cp += n;
++
++			printf("\tserial = %lu\n", ns_get32(cp));
++			cp += 4;
++
++			printf("\trefresh = %lu\n", ns_get32(cp));
++			cp += 4;
++
++			printf("\tretry = %lu\n", ns_get32(cp));
++			cp += 4;
++
++			printf("\texpire = %lu\n", ns_get32(cp));
++			cp += 4;
++
++			printf("\tminimum = %lu\n", ns_get32(cp));
++			break;
++
++		default:
++			break;
++		}
++	}
++
++	return i;
++}
++
++static int parse_nsaddr(const char *addrstr, len_and_sockaddr *lsa)
++{
++	char *eptr, *hash, ifname[IFNAMSIZ];
++	unsigned int port = default_port;
++	unsigned int scope = 0;
++
++	hash = strchr(addrstr, '#');
++
++	if (hash) {
++		*hash++ = '\0';
++		port = strtoul(hash, &eptr, 10);
++
++		if (eptr == hash || *eptr != '\0' || port > 65535) {
++			errno = EINVAL;
++			return -1;
++		}
++	}
++
++	hash = strchr(addrstr, '%');
++
++	if (hash) {
++		for (eptr = ++hash; *eptr != '\0' && *eptr != '#'; eptr++) {
++			if ((eptr - hash) >= IFNAMSIZ) {
++				errno = ENODEV;
++				return -1;
++			}
++
++			ifname[eptr - hash] = *eptr;
++		}
++
++		ifname[eptr - hash] = '\0';
++		scope = if_nametoindex(ifname);
++
++		if (scope == 0) {
++			errno = ENODEV;
++			return -1;
++		}
++	}
++
++	if (inet_pton(AF_INET6, addrstr, &lsa->u.sin6.sin6_addr)) {
++		lsa->u.sin6.sin6_family = AF_INET6;
++		lsa->u.sin6.sin6_port = htons(port);
++		lsa->u.sin6.sin6_scope_id = scope;
++		lsa->len = sizeof(lsa->u.sin6);
++		return 0;
++	}
++
++	if (!scope && inet_pton(AF_INET, addrstr, &lsa->u.sin.sin_addr)) {
++		lsa->u.sin.sin_family = AF_INET;
++		lsa->u.sin.sin_port = htons(port);
++		lsa->len = sizeof(lsa->u.sin);
++		return 0;
++	}
++
++	errno = EINVAL;
++	return -1;
++}
++
++static char *make_ptr(const char *addrstr)
++{
++	const char *hexdigit = "0123456789abcdef";
++	static char ptrstr[73];
++	unsigned char addr[16];
++	char *ptr = ptrstr;
++	int i;
++
++	if (inet_pton(AF_INET6, addrstr, addr)) {
++		if (memcmp(addr, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12) != 0) {
++			for (i = 0; i < 16; i++) {
++				*ptr++ = hexdigit[(unsigned char)addr[15 - i] & 0xf];
++				*ptr++ = '.';
++				*ptr++ = hexdigit[(unsigned char)addr[15 - i] >> 4];
++				*ptr++ = '.';
++			}
++			strcpy(ptr, "ip6.arpa");
++		}
++		else {
++			sprintf(ptr, "%u.%u.%u.%u.in-addr.arpa",
++			        addr[15], addr[14], addr[13], addr[12]);
++		}
++
++		return ptrstr;
++	}
++
++	if (inet_pton(AF_INET, addrstr, addr)) {
++		sprintf(ptr, "%u.%u.%u.%u.in-addr.arpa",
++		        addr[3], addr[2], addr[1], addr[0]);
++		return ptrstr;
++	}
++
++	return NULL;
++}
++
++static unsigned long mtime(void)
++{
++	struct timespec ts;
++	clock_gettime(CLOCK_REALTIME, &ts);
++	return (unsigned long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
++}
++
++static void to_v4_mapped(len_and_sockaddr *a)
++{
++	if (a->u.sa.sa_family != AF_INET)
++		return;
++
++	memcpy(a->u.sin6.sin6_addr.s6_addr + 12,
++	       &a->u.sin.sin_addr, 4);
++
++	memcpy(a->u.sin6.sin6_addr.s6_addr,
++	       "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
++
++	a->u.sin6.sin6_family = AF_INET6;
++	a->u.sin6.sin6_flowinfo = 0;
++	a->u.sin6.sin6_scope_id = 0;
++	a->len = sizeof(a->u.sin6);
++}
++
++
++/*
++ * Function logic borrowed & modified from musl libc, res_msend.c
++ */
++
++static int send_queries(struct ns *ns, int n_ns, struct query *queries, int n_queries)
++{
++	int fd;
++	int timeout = default_timeout * 1000, retry_interval, servfail_retry = 0;
++	len_and_sockaddr from = { };
++	int one = 1;
++	int recvlen = 0;
++	int n_replies = 0;
++	struct pollfd pfd;
++	unsigned long t0, t1, t2;
++	int nn, qn, next_query = 0;
++
++	from.u.sa.sa_family = AF_INET;
++	from.len = sizeof(from.u.sin);
++
++	for (nn = 0; nn < n_ns; nn++) {
++		if (ns[nn].addr.u.sa.sa_family == AF_INET6) {
++			from.u.sa.sa_family = AF_INET6;
++			from.len = sizeof(from.u.sin6);
++			break;
++		}
++	}
++
++	/* Get local address and open/bind a socket */
++	fd = socket(from.u.sa.sa_family, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
++
++	/* Handle case where system lacks IPv6 support */
++	if (fd < 0 && from.u.sa.sa_family == AF_INET6 && errno == EAFNOSUPPORT) {
++		fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
++		from.u.sa.sa_family = AF_INET;
++	}
++
++	if (fd < 0)
++		return -1;
++
++	if (bind(fd, &from.u.sa, from.len) < 0) {
++		close(fd);
++		return -1;
++	}
++
++	/* Convert any IPv4 addresses in a mixed environment to v4-mapped */
++	if (from.u.sa.sa_family == AF_INET6) {
++		setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
++
++		for (nn = 0; nn < n_ns; nn++)
++			to_v4_mapped(&ns[nn].addr);
++	}
++
++	pfd.fd = fd;
++	pfd.events = POLLIN;
++	retry_interval = timeout / default_retry;
++	t0 = t2 = mtime();
++	t1 = t2 - retry_interval;
++
++	for (; t2 - t0 < timeout; t2 = mtime()) {
++		if (t2 - t1 >= retry_interval) {
++			for (qn = 0; qn < n_queries; qn++) {
++				if (queries[qn].rlen)
++					continue;
++
++				for (nn = 0; nn < n_ns; nn++) {
++					sendto(fd, queries[qn].query, queries[qn].qlen,
++					       MSG_NOSIGNAL, &ns[nn].addr.u.sa, ns[nn].addr.len);
++				}
++			}
++
++			t1 = t2;
++			servfail_retry = 2 * n_queries;
++		}
++
++		/* Wait for a response, or until time to retry */
++		if (poll(&pfd, 1, t1+retry_interval-t2) <= 0)
++			continue;
++
++		while (1) {
++			recvlen = recvfrom(fd, queries[next_query].reply,
++			                   sizeof(queries[next_query].reply), 0,
++			                   &from.u.sa, &from.len);
++
++			/* read error */
++			if (recvlen < 0)
++				break;
++
++			/* Ignore non-identifiable packets */
++			if (recvlen < 4)
++				continue;
++
++			/* Ignore replies from addresses we didn't send to */
++			for (nn = 0; nn < n_ns; nn++)
++				if (memcmp(&from.u.sa, &ns[nn].addr.u.sa, from.len) == 0)
++					break;
++
++			if (nn >= n_ns)
++				continue;
++
++			/* Find which query this answer goes with, if any */
++			for (qn = next_query; qn < n_queries; qn++)
++				if (!memcmp(queries[next_query].reply, queries[qn].query, 2))
++					break;
++
++			if (qn >= n_queries || queries[qn].rlen)
++				continue;
++
++			queries[qn].rcode = queries[next_query].reply[3] & 15;
++			queries[qn].latency = mtime() - t0;
++			queries[qn].n_ns = nn;
++
++			ns[nn].replies++;
++
++			/* Only accept positive or negative responses;
++			 * retry immediately on server failure, and ignore
++			 * all other codes such as refusal. */
++			switch (queries[qn].rcode) {
++			case 0:
++			case 3:
++				break;
++
++			case 2:
++				if (servfail_retry && servfail_retry--) {
++					ns[nn].failures++;
++					sendto(fd, queries[qn].query, queries[qn].qlen,
++					       MSG_NOSIGNAL, &ns[nn].addr.u.sa, ns[nn].addr.len);
++				}
++				/* fall through */
++
++			default:
++				continue;
++			}
++
++			/* Store answer */
++			n_replies++;
++
++			queries[qn].rlen = recvlen;
++
++			if (qn == next_query) {
++				while (next_query < n_queries) {
++					if (!queries[next_query].rlen)
++						break;
++
++					next_query++;
++				}
++			}
++			else {
++				memcpy(queries[qn].reply, queries[next_query].reply, recvlen);
++			}
++
++			if (next_query >= n_queries)
++				return n_replies;
++		}
++	}
++
++	return n_replies;
++}
++
++static struct ns *add_ns(struct ns **ns, int *n_ns, const char *addr)
++{
++	char portstr[sizeof("65535")], *p;
++	len_and_sockaddr a = { };
++	struct ns *tmp;
++	struct addrinfo *ai, *aip, hints = {
++		.ai_flags = AI_NUMERICSERV,
++		.ai_socktype = SOCK_DGRAM
++	};
++
++	if (parse_nsaddr(addr, &a)) {
++		/* Maybe we got a domain name, attempt to resolve it using the standard
++		 * resolver routines */
++
++		p = strchr(addr, '#');
++		snprintf(portstr, sizeof(portstr), "%hu",
++		         (unsigned short)(p ? strtoul(p, NULL, 10) : default_port));
++
++		if (!getaddrinfo(addr, portstr, &hints, &ai)) {
++			for (aip = ai; aip; aip = aip->ai_next) {
++				if (aip->ai_addr->sa_family != AF_INET &&
++				    aip->ai_addr->sa_family != AF_INET6)
++				    continue;
++
++				tmp = realloc(*ns, sizeof(**ns) * (*n_ns + 1));
++
++				if (!tmp)
++					return NULL;
++
++				*ns = tmp;
++
++				(*ns)[*n_ns].name = addr;
++				(*ns)[*n_ns].replies = 0;
++				(*ns)[*n_ns].failures = 0;
++				(*ns)[*n_ns].addr.len = aip->ai_addrlen;
++
++				memcpy(&(*ns)[*n_ns].addr.u.sa, aip->ai_addr, aip->ai_addrlen);
++
++				(*n_ns)++;
++			}
++
++			freeaddrinfo(ai);
++
++			return &(*ns)[*n_ns];
++		}
++
++		return NULL;
++	}
++
++	tmp = realloc(*ns, sizeof(**ns) * (*n_ns + 1));
++
++	if (!tmp)
++		return NULL;
++
++	*ns = tmp;
++
++	(*ns)[*n_ns].addr = a;
++	(*ns)[*n_ns].name = addr;
++	(*ns)[*n_ns].replies = 0;
++	(*ns)[*n_ns].failures = 0;
++
++	return &(*ns)[(*n_ns)++];
++}
++
++static int parse_resolvconf(struct ns **ns, int *n_ns)
++{
++	int prev_n_ns = *n_ns;
++	char line[128], *p;
++	FILE *resolv;
++
++	if ((resolv = fopen("/etc/resolv.conf", "r")) != NULL) {
++		while (fgets(line, sizeof(line), resolv)) {
++			p = strtok(line, " \t\n");
++
++			if (!p || strcmp(p, "nameserver"))
++				continue;
++
++			p = strtok(NULL, " \t\n");
++
++			if (!p)
++				continue;
++
++			if (!add_ns(ns, n_ns, strdup(p))) {
++				free(p);
++				break;
++			}
++		}
++
++		fclose(resolv);
++	}
++
++	return *n_ns - prev_n_ns;
++}
++
++static struct query *add_query(struct query **queries, int *n_queries,
++                               int type, const char *dname)
++{
++	struct query *tmp;
++	ssize_t qlen;
++
++	tmp = realloc(*queries, sizeof(**queries) * (*n_queries + 1));
++
++	if (!tmp)
++		return NULL;
++
++	memset(&tmp[*n_queries], 0, sizeof(*tmp));
++
++	qlen = res_mkquery(QUERY, dname, C_IN, type, NULL, 0, NULL,
++	                   tmp[*n_queries].query, sizeof(tmp[*n_queries].query));
++
++	tmp[*n_queries].qlen = qlen;
++	tmp[*n_queries].name = dname;
++	*queries = tmp;
++
++	return &tmp[(*n_queries)++];
++}
++
++static char *sal2str(len_and_sockaddr *a)
++{
++	static char buf[INET6_ADDRSTRLEN + 1 + IFNAMSIZ + 1 + 5 + 1];
++	char *p = buf;
++
++	if (a->u.sa.sa_family == AF_INET6) {
++		inet_ntop(AF_INET6, &a->u.sin6.sin6_addr, buf, sizeof(buf));
++		p += strlen(p);
++
++		if (a->u.sin6.sin6_scope_id) {
++			if (if_indextoname(a->u.sin6.sin6_scope_id, p + 1)) {
++				*p++ = '%';
++				p += strlen(p);
++			}
++		}
++	}
++	else {
++		inet_ntop(AF_INET, &a->u.sin.sin_addr, buf, sizeof(buf));
++		p += strlen(p);
++	}
++
++	sprintf(p, "#%hu", ntohs(a->u.sin6.sin6_port));
++
++	return buf;
++}
++
++
++#if ENABLE_FEATURE_NSLOOKUP_LEDE_LONG_OPTIONS
++static const char nslookup_longopts[] ALIGN1 =
++		"type\0"		Required_argument	"q"
++		"querytype\0"	Required_argument	"q"
++		"port\0"		Required_argument	"p"
++		"retry\0"		Required_argument	"r"
++		"timeout\0"		Required_argument	"t"
++		"stats\0"		Required_argument	"s"
++    ;
++#endif
++
++int nslookup_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
++int nslookup_main(int argc, char **argv)
++{
++	int rc = 1;
++	char *ptr, *chr;
++	struct ns *ns = NULL;
++	struct query *queries = NULL;
++	llist_t *type_strings = NULL;
++	int n_ns = 0, n_queries = 0;
++	int c, opts, option_index = 0;
++	int stats = 0;
++	unsigned int types = 0;
++	HEADER *header;
++
++#if ENABLE_FEATURE_NSLOOKUP_LEDE_LONG_OPTIONS
++	applet_long_options = nslookup_longopts;
++#endif
++
++	opts = getopt32(argv, "+q:*p:+r:+t:+s",
++	                &type_strings, &default_port,
++	                &default_retry, &default_timeout);
++
++	while (type_strings) {
++		ptr = llist_pop(&type_strings);
++
++		/* skip leading text, e.g. when invoked with -querytype=AAAA */
++		if ((chr = strchr(ptr, '=')) != NULL) {
++			ptr = chr;
++			*ptr++ = 0;
++		}
++
++		for (c = 0; qtypes[c].name; c++)
++			if (!strcmp(qtypes[c].name, ptr))
++				break;
++
++		if (!qtypes[c].name) {
++			fprintf(stderr, "Invalid query type \"%s\"\n", ptr);
++			goto out;
++		}
++
++		types |= (1 << c);
++	}
++
++	if (default_port > 65535) {
++		fprintf(stderr, "Invalid server port\n");
++		goto out;
++	}
++
++	if (!default_retry) {
++		fprintf(stderr, "Invalid retry value\n");
++		goto out;
++	}
++
++	if (!default_timeout) {
++		fprintf(stderr, "Invalid timeout value\n");
++		goto out;
++	}
++
++	stats = (opts & 16);
++
++	if (optind >= argc)
++		bb_show_usage();
++
++	for (option_index = optind;
++	     option_index < ((argc - optind) > 1 ? argc - 1 : argc);
++	     option_index++) {
++
++		/* No explicit type given, guess query type.
++		 * If we can convert the domain argument into a ptr (means that
++		 * inet_pton() could read it) we assume a PTR request, else
++		 * we issue A queries. */
++		if (types == 0) {
++			ptr = make_ptr(argv[option_index]);
++
++			if (ptr)
++				add_query(&queries, &n_queries, T_PTR, ptr);
++			else
++				add_query(&queries, &n_queries, T_A, argv[option_index]);
++		}
++		else {
++			for (c = 0; qtypes[c].name; c++)
++				if (types & (1 << c))
++					add_query(&queries, &n_queries, qtypes[c].type,
++					          argv[option_index]);
++		}
++	}
++
++	/* Use given DNS server if present */
++	if (option_index < argc) {
++		if (!add_ns(&ns, &n_ns, argv[option_index])) {
++			fprintf(stderr, "Invalid NS server address \"%s\": %s\n",
++			        argv[option_index], strerror(errno));
++			goto out;
++		}
++	}
++	else {
++		parse_resolvconf(&ns, &n_ns);
++	}
++
++	/* Fall back to localhost if we could not find NS in resolv.conf */
++	if (n_ns == 0) {
++		add_ns(&ns, &n_ns, "127.0.0.1");
++	}
++
++	for (c = 0; c < n_ns; c++) {
++		rc = send_queries(&ns[c], 1, queries, n_queries);
++
++		if (rc < 0) {
++			fprintf(stderr, "Failed to send queries: %s\n", strerror(errno));
++			goto out;
++		} else if (rc > 0) {
++			break;
++		}
++	}
++
++	if (c >= n_ns) {
++		fprintf(stderr,
++			    ";; connection timed out; no servers could be reached\n\n");
++
++		return 1;
++	}
++
++	printf("Server:\t\t%s\n", ns[c].name);
++	printf("Address:\t%s\n", sal2str(&ns[c].addr));
++
++	if (stats) {
++		printf("Replies:\t%d\n", ns[c].replies);
++		printf("Failures:\t%d\n", ns[c].failures);
++	}
++
++	printf("\n");
++
++	for (rc = 0; rc < n_queries; rc++) {
++		if (stats) {
++			printf("Query #%d completed in %lums:\n", rc, queries[rc].latency);
++		}
++
++		if (queries[rc].rcode != 0) {
++			printf("** server can't find %s: %s\n", queries[rc].name,
++			       rcodes[queries[rc].rcode]);
++			continue;
++		}
++
++		c = 0;
++
++		if (queries[rc].rlen) {
++			header = (HEADER *)queries[rc].reply;
++
++			if (!header->aa)
++				printf("Non-authoritative answer:\n");
++
++			c = parse_reply(queries[rc].reply, queries[rc].rlen);
++		}
++
++		if (c == 0)
++			printf("*** Can't find %s: No answer\n", queries[rc].name);
++		else if (c < 0)
++			printf("*** Can't find %s: Parse error\n", queries[rc].name);
++
++		printf("\n");
++	}
++
++	rc = 0;
++
++out:
++	if (n_ns)
++		free(ns);
++
++	if (n_queries)
++		free(queries);
++
++	return rc;
++}
+-- 
+2.1.4
+