/* vi: set sw=4 ts=4: */ //config:config NSLOOKUP //config: bool "nslookup (4.5 kb)" //config: default y //config: help //config: nslookup is a tool to query Internet name servers. //config: //config:config NSLOOKUP_BIG //config: bool "Use internal resolver code instead of libc" //config: depends on NSLOOKUP //config: default y //config: //config:config FEATURE_NSLOOKUP_LONG_OPTIONS //config: bool "Enable long options" //config: default y //config: depends on NSLOOKUP_BIG && LONG_OPTS //applet:IF_NSLOOKUP(APPLET(nslookup, BB_DIR_USR_BIN, BB_SUID_DROP)) //kbuild:lib-$(CONFIG_NSLOOKUP) += nslookup.o //usage:#define nslookup_trivial_usage //usage: "[HOST] [SERVER]" //usage:#define nslookup_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_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 #include /* for IFNAMSIZ */ //#include //#include #include "libbb.h" #include "common_bufsiz.h" #if !ENABLE_NSLOOKUP_BIG /* * Mini nslookup implementation for busybox * * Copyright (C) 1999,2000 by Lineo, inc. and John Beppu * Copyright (C) 1999,2000,2001 by John Beppu * * Correct default name server display and explicit name server option * added by Ben Zeckel June 2001 * * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ /* * I'm only implementing non-interactive mode; * I totally forgot nslookup even had an interactive mode. * * This applet is the only user of res_init(). Without it, * you may avoid pulling in _res global from libc. */ /* Examples of 'standard' nslookup output * $ nslookup yahoo.com * Server: 128.193.0.10 * Address: 128.193.0.10#53 * * Non-authoritative answer: * Name: yahoo.com * Address: 216.109.112.135 * Name: yahoo.com * Address: 66.94.234.13 * * $ nslookup 204.152.191.37 * Server: 128.193.4.20 * Address: 128.193.4.20#53 * * Non-authoritative answer: * 37.191.152.204.in-addr.arpa canonical name = 37.32-27.191.152.204.in-addr.arpa. * 37.32-27.191.152.204.in-addr.arpa name = zeus-pub2.kernel.org. * * Authoritative answers can be found from: * 32-27.191.152.204.in-addr.arpa nameserver = ns1.kernel.org. * 32-27.191.152.204.in-addr.arpa nameserver = ns2.kernel.org. * 32-27.191.152.204.in-addr.arpa nameserver = ns3.kernel.org. * ns1.kernel.org internet address = 140.211.167.34 * ns2.kernel.org internet address = 204.152.191.4 * ns3.kernel.org internet address = 204.152.191.36 */ static int print_host(const char *hostname, const char *header) { /* We can't use xhost2sockaddr() - we want to get ALL addresses, * not just one */ struct addrinfo *result = NULL; int rc; struct addrinfo hint; memset(&hint, 0 , sizeof(hint)); /* hint.ai_family = AF_UNSPEC; - zero anyway */ /* Needed. Or else we will get each address thrice (or more) * for each possible socket type (tcp,udp,raw...): */ hint.ai_socktype = SOCK_STREAM; // hint.ai_flags = AI_CANONNAME; rc = getaddrinfo(hostname, NULL /*service*/, &hint, &result); if (rc == 0) { struct addrinfo *cur = result; unsigned cnt = 0; printf("%-10s %s\n", header, hostname); // puts(cur->ai_canonname); ? while (cur) { char *dotted, *revhost; dotted = xmalloc_sockaddr2dotted_noport(cur->ai_addr); revhost = xmalloc_sockaddr2hostonly_noport(cur->ai_addr); printf("Address %u: %s%c", ++cnt, dotted, revhost ? ' ' : '\n'); if (revhost) { puts(revhost); if (ENABLE_FEATURE_CLEAN_UP) free(revhost); } if (ENABLE_FEATURE_CLEAN_UP) free(dotted); cur = cur->ai_next; } } else { #if ENABLE_VERBOSE_RESOLUTION_ERRORS bb_error_msg("can't resolve '%s': %s", hostname, gai_strerror(rc)); #else bb_error_msg("can't resolve '%s'", hostname); #endif } if (ENABLE_FEATURE_CLEAN_UP && result) freeaddrinfo(result); return (rc != 0); } /* lookup the default nameserver and display it */ static void server_print(void) { char *server; struct sockaddr *sa; #if ENABLE_FEATURE_IPV6 sa = (struct sockaddr*)_res._u._ext.nsaddrs[0]; if (!sa) #endif sa = (struct sockaddr*)&_res.nsaddr_list[0]; server = xmalloc_sockaddr2dotted_noport(sa); print_host(server, "Server:"); if (ENABLE_FEATURE_CLEAN_UP) free(server); bb_putchar('\n'); } /* alter the global _res nameserver structure to use an explicit dns server instead of what is in /etc/resolv.conf */ static void set_default_dns(const char *server) { len_and_sockaddr *lsa; if (!server) return; /* NB: this works even with, say, "[::1]:5353"! :) */ lsa = xhost2sockaddr(server, 53); if (lsa->u.sa.sa_family == AF_INET) { _res.nscount = 1; /* struct copy */ _res.nsaddr_list[0] = lsa->u.sin; } #if ENABLE_FEATURE_IPV6 /* Hoped libc can cope with IPv4 address there too. * No such luck, glibc 2.4 segfaults even with IPv6, * maybe I misunderstand how to make glibc use IPv6 addr? * (uclibc 0.9.31+ should work) */ if (lsa->u.sa.sa_family == AF_INET6) { // glibc neither SEGVs nor sends any dgrams with this // (strace shows no socket ops): //_res.nscount = 0; _res._u._ext.nscount = 1; /* store a pointer to part of malloc'ed lsa */ _res._u._ext.nsaddrs[0] = &lsa->u.sin6; /* must not free(lsa)! */ } #endif } int nslookup_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int nslookup_main(int argc, char **argv) { /* We allow 1 or 2 arguments. * The first is the name to be looked up and the second is an * optional DNS server with which to do the lookup. * More than 3 arguments is an error to follow the pattern of the * standard nslookup */ if (!argv[1] || argv[1][0] == '-' || argc > 3) bb_show_usage(); /* initialize DNS structure _res used in printing the default * name server and in the explicit name server option feature. */ res_init(); /* rfc2133 says this enables IPv6 lookups */ /* (but it also says "may be enabled in /etc/resolv.conf") */ /*_res.options |= RES_USE_INET6;*/ set_default_dns(argv[2]); server_print(); /* getaddrinfo and friends are free to request a resolver * reinitialization. Just in case, set_default_dns() again * after getaddrinfo (in server_print). This reportedly helps * with bug 675 "nslookup does not properly use second argument" * at least on Debian Wheezy and Openwrt AA (eglibc based). */ set_default_dns(argv[2]); return print_host(argv[1], "Name:"); } #else /****** A version from LEDE / OpenWRT ******/ /* * musl compatible nslookup * * Copyright (C) 2017 Jo-Philipp Wich * * 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. */ #if 0 # define dbg(...) fprintf(stderr, __VA_ARGS__) #else # define dbg(...) ((void)0) #endif 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 const struct { int type; const char *name; } qtypes[] = { { ns_t_soa, "SOA" }, { ns_t_ns, "NS" }, { ns_t_a, "A" }, #if ENABLE_FEATURE_IPV6 { ns_t_aaaa, "AAAA" }, #endif { ns_t_cname, "CNAME" }, { ns_t_mx, "MX" }, { ns_t_txt, "TXT" }, { ns_t_ptr, "PTR" }, { ns_t_any, "ANY" }, { } }; static const char *const rcodes[] = { "NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED", "YXDOMAIN", "YXRRSET", "NXRRSET", "NOTAUTH", "NOTZONE", "RESERVED11", "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15", "BADVERS" }; #if ENABLE_FEATURE_IPV6 static const char v4_mapped[] = { 0,0,0,0,0,0,0,0,0,0,0xff,0xff }; #endif struct globals { unsigned default_port; unsigned default_retry; unsigned default_timeout; } FIX_ALIASING; #define G (*(struct globals*)bb_common_bufsiz1) #define INIT_G() do { \ setup_common_bufsiz(); \ G.default_port = 53; \ G.default_retry = 2; \ G.default_timeout = 5; \ } while (0) static int parse_reply(const unsigned char *msg, size_t len, int *bb_style_counter) { 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; } if (bb_style_counter && *bb_style_counter == 1) printf("Name: %s\n", ns_rr_name(rr)); 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)); if (bb_style_counter) printf("Address %d: %s\n", (*bb_style_counter)++, astr); else printf("Name:\t%s\nAddress: %s\n", ns_rr_name(rr), astr); break; #if ENABLE_FEATURE_IPV6 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)); if (bb_style_counter) printf("Address %d: %s\n", (*bb_style_counter)++, astr); else printf("%s\thas AAAA address %s\n", ns_rr_name(rr), astr); break; #endif 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 *hash; unsigned port = G.default_port; IF_FEATURE_IPV6(unsigned scope;) dbg("%s: addrstr:'%s'\n", __func__, addrstr); hash = strchr(addrstr, '#'); if (hash) { *hash++ = '\0'; port = bb_strtou(hash, NULL, 10); if (errno || port > 65535) { errno = EINVAL; return -1; } } #if ENABLE_FEATURE_IPV6 scope = 0; hash = strchr(addrstr, '%'); if (hash) { char ifname[IFNAMSIZ]; int i; hash++; for (i = 0; hash[i] != '\0' && hash[i] != '#'; i++) { if (i >= IFNAMSIZ) { errno = ENODEV; return -1; } ifname[i] = hash[i]; } ifname[i] = '\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; } #endif if (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(char resbuf[80], const char *addrstr) { unsigned char addr[16]; int i; #if ENABLE_FEATURE_IPV6 if (inet_pton(AF_INET6, addrstr, addr)) { if (memcmp(addr, v4_mapped, 12) != 0) { char *ptr = resbuf; for (i = 0; i < 16; i++) { *ptr++ = 0x20 | bb_hexdigits_upcase[(unsigned char)addr[15 - i] & 0xf]; *ptr++ = '.'; *ptr++ = 0x20 | bb_hexdigits_upcase[(unsigned char)addr[15 - i] >> 4]; *ptr++ = '.'; } strcpy(ptr, "ip6.arpa"); } else { sprintf(resbuf, "%u.%u.%u.%u.in-addr.arpa", addr[15], addr[14], addr[13], addr[12]); } return resbuf; } #endif if (inet_pton(AF_INET, addrstr, addr)) { sprintf(resbuf, "%u.%u.%u.%u.in-addr.arpa", addr[3], addr[2], addr[1], addr[0]); return resbuf; } return NULL; } #if ENABLE_FEATURE_IPV6 static void to_v4_mapped(len_and_sockaddr *a) { if (a->u.sa.sa_family != AF_INET) return; /* Order is important */ //FIXME: port? memcpy(a->u.sin6.sin6_addr.s6_addr + 12, &a->u.sin.sin_addr, 4); memcpy(a->u.sin6.sin6_addr.s6_addr, v4_mapped, 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); } #endif /* * 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 = G.default_timeout * 1000, retry_interval, servfail_retry = 0; len_and_sockaddr from = { }; 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); #if ENABLE_FEATURE_IPV6 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; } } #endif /* Get local address and open/bind a socket */ #if ENABLE_FEATURE_IPV6 fd = socket(from.u.sa.sa_family, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); /* Handle case where system lacks IPv6 support */ if (fd < 0) { if (from.u.sa.sa_family != AF_INET6 || errno != EAFNOSUPPORT) bb_perror_msg_and_die("socket"); fd = xsocket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); from.u.sa.sa_family = AF_INET; } #else fd = xsocket(from.u.sa.sa_family, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); #endif xbind(fd, &from.u.sa, from.len); #if ENABLE_FEATURE_IPV6 /* Convert any IPv4 addresses in a mixed environment to v4-mapped */ if (from.u.sa.sa_family == AF_INET6) { setsockopt_1(fd, IPPROTO_IPV6, IPV6_V6ONLY); for (nn = 0; nn < n_ns; nn++) to_v4_mapped(&ns[nn].addr); } #endif pfd.fd = fd; pfd.events = POLLIN; retry_interval = timeout / G.default_retry; t0 = t2 = monotonic_ms(); t1 = t2 - retry_interval; for (; t2 - t0 < timeout; t2 = monotonic_ms()) { 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) == 0) break; if (qn >= n_queries || queries[qn].rlen) continue; queries[qn].rcode = queries[next_query].reply[3] & 15; queries[qn].latency = monotonic_ms() - 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; } ///FIXME: use standard lsa = xhost2sockaddr(host, port) instead 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 }; dbg("%s: addr:'%s'\n", __func__, addr); 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) : G.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; #if ! ENABLE_FEATURE_IPV6 if (aip->ai_addr->sa_family != AF_INET) continue; #endif 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 = xrealloc(*ns, sizeof(**ns) * (*n_ns + 1)); *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; FILE *resolv; resolv = fopen("/etc/resolv.conf", "r"); if (resolv) { char line[128], *p; while (fgets(line, sizeof(line), resolv)) { p = strtok(line, " \t\n"); if (!p || strcmp(p, "nameserver") != 0) continue; p = strtok(NULL, " \t\n"); if (!p) continue; if (!add_ns(ns, n_ns, xstrdup(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 *new_q; int pos; ssize_t qlen; pos = *n_queries; *n_queries = pos + 1; *queries = new_q = xrealloc(*queries, sizeof(**queries) * (pos + 1)); dbg("new query#%u type %u for '%s'\n", pos, type, dname); new_q += pos; memset(new_q, 0, sizeof(*new_q)); qlen = res_mkquery(QUERY, dname, C_IN, type, NULL, 0, NULL, new_q->query, sizeof(new_q->query)); new_q->qlen = qlen; new_q->name = dname; return new_q; } //FIXME: use xmalloc_sockaddr2dotted[_noport]() instead of sal2str() #define SIZEOF_SAL2STR_BUF (INET6_ADDRSTRLEN + 1 + IFNAMSIZ + 1 + 5 + 1) static char *sal2str(char buf[SIZEOF_SAL2STR_BUF], len_and_sockaddr *a) { char *p = buf; #if ENABLE_FEATURE_IPV6 if (a->u.sa.sa_family == AF_INET6) { inet_ntop(AF_INET6, &a->u.sin6.sin6_addr, buf, SIZEOF_SAL2STR_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 #endif { inet_ntop(AF_INET, &a->u.sin.sin_addr, buf, SIZEOF_SAL2STR_BUF); p += strlen(p); } sprintf(p, "#%hu", ntohs(a->u.sin.sin_port)); return buf; } int nslookup_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int nslookup_main(int argc UNUSED_PARAM, char **argv) { struct ns *ns; struct query *queries; llist_t *type_strings; int n_ns, n_queries; int bb_style_counter = 0; unsigned types; int rc; int opts; enum { OPT_stats = (1 << 4), }; INIT_G(); type_strings = NULL; #if ENABLE_FEATURE_NSLOOKUP_LONG_OPTIONS opts = getopt32long(argv, "^" "+" /* '+': stop at first non-option (why?) */ "q:*p:+r:+t:+s" "\0" "-1:q::", /* minimum 1 arg, -q is a list */ "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" No_argument "s", &type_strings, &G.default_port, &G.default_retry, &G.default_timeout ); #else opts = getopt32(argv, "^" "+" /* '+': stop at first non-option (why?) */ "q:*p:+r:+t:+s" "\0" "-1:q::", /* minimum 1 arg, -q is a list */ &type_strings, &G.default_port, &G.default_retry, &G.default_timeout ); #endif if (G.default_port > 65535) bb_error_msg_and_die("invalid server port"); if (G.default_retry == 0) bb_error_msg_and_die("invalid retry value"); if (G.default_timeout == 0) bb_error_msg_and_die("invalid timeout value"); types = 0; while (type_strings) { int c; char *ptr, *chr; ptr = llist_pop(&type_strings); /* skip leading text, e.g. when invoked with -querytype=AAAA */ chr = strchr(ptr, '='); if (chr) ptr = chr + 1; for (c = 0;; c++) { if (!qtypes[c].name) bb_error_msg_and_die("invalid query type \"%s\"", ptr); if (strcmp(qtypes[c].name, ptr) == 0) break; } types |= (1 << c); } argv += optind; n_queries = 0; queries = NULL; do { /* 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+AAAA queries and switch to an output format * mimicking the one of the traditional nslookup applet. */ if (types == 0) { char *ptr; char buf80[80]; ptr = make_ptr(buf80, *argv); if (ptr) { add_query(&queries, &n_queries, T_PTR, ptr); } else { bb_style_counter = 1; add_query(&queries, &n_queries, T_A, *argv); #if ENABLE_FEATURE_IPV6 add_query(&queries, &n_queries, T_AAAA, *argv); #endif } } else { int c; for (c = 0; qtypes[c].name; c++) { if (types & (1 << c)) add_query(&queries, &n_queries, qtypes[c].type, *argv); } } argv++; } while (argv[0] && argv[1]); /* Use given DNS server if present */ n_ns = 0; ns = NULL; if (argv[0]) { if (!add_ns(&ns, &n_ns, argv[0])) bb_error_msg_and_die("invalid NS server address \"%s\"", argv[0]); } 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 (rc = 0; rc < n_ns; rc++) { int c = send_queries(&ns[rc], 1, queries, n_queries); if (c < 0) bb_perror_msg_and_die("can't send queries"); if (c > 0) break; rc++; if (rc >= n_ns) { fprintf(stderr, ";; connection timed out; no servers could be reached\n\n"); return EXIT_FAILURE; } } printf("Server:\t\t%s\n", ns[rc].name); { char buf[SIZEOF_SAL2STR_BUF]; printf("Address:\t%s\n", sal2str(buf, &ns[rc].addr)); } if (opts & OPT_stats) { printf("Replies:\t%d\n", ns[rc].replies); printf("Failures:\t%d\n", ns[rc].failures); } printf("\n"); for (rc = 0; rc < n_queries; rc++) { int c; if (opts & OPT_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; if (!bb_style_counter) { header = (HEADER *)queries[rc].reply; if (!header->aa) printf("Non-authoritative answer:\n"); c = parse_reply(queries[rc].reply, queries[rc].rlen, NULL); } else { c = parse_reply(queries[rc].reply, queries[rc].rlen, &bb_style_counter); } } 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); if (!bb_style_counter) printf("\n"); } if (ENABLE_FEATURE_CLEAN_UP) { free(ns); if (n_queries) free(queries); } return EXIT_SUCCESS; } #endif