libcli/dns: Add dns_lookup
authorVolker Lendecke <vl@samba.org>
Tue, 2 Jan 2018 12:56:56 +0000 (13:56 +0100)
committerVolker Lendecke <vl@samba.org>
Tue, 15 Jan 2019 06:53:21 +0000 (07:53 +0100)
Wrapper function to parse resolv.conf and talk to multiple nameservers. This is
the code where we might want to add a "working nameserver" cache. glibc always
looks at the first configured nameserver. If that's dead, glibc runs into a
timeout and only then asks the second one that might succeed. When more than
one dns query is to be performed, these timeouts add up.

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>
libcli/dns/dns_lookup.c [new file with mode: 0644]
libcli/dns/dns_lookup.h [new file with mode: 0644]
libcli/dns/dns_lookuptest.c [new file with mode: 0644]
libcli/dns/wscript_build

diff --git a/libcli/dns/dns_lookup.c b/libcli/dns/dns_lookup.c
new file mode 100644 (file)
index 0000000..6fc912c
--- /dev/null
@@ -0,0 +1,326 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  Internal DNS query structures
+ *  Copyright (C) Volker Lendecke 2018
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "replace.h"
+#include "libcli/dns/dns_lookup.h"
+#include "libcli/dns/resolvconf.h"
+#include "libcli/dns/libdns.h"
+#include "lib/util/tevent_unix.h"
+#include "lib/util/samba_util.h"
+#include "lib/util/debug.h"
+
+struct dns_lookup_state {
+       struct tevent_context *ev;
+       const char *name;
+       enum dns_qclass qclass;
+       enum dns_qtype qtype;
+
+       char **nameservers;
+       size_t num_nameservers;
+       size_t num_sent;
+
+       struct tevent_req **dns_subreqs;
+       struct tevent_req *wait_subreq;
+
+       struct dns_name_packet *reply;
+};
+
+static int dns_lookup_send_next(struct tevent_req *req);
+
+static void dns_lookup_done(struct tevent_req *subreq);
+static void dns_lookup_waited(struct tevent_req *subreq);
+
+struct tevent_req *dns_lookup_send(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *ev,
+                                  FILE *resolv_conf_fp,
+                                  const char *name,
+                                  enum dns_qclass qclass,
+                                  enum dns_qtype qtype)
+{
+       struct tevent_req *req;
+       struct dns_lookup_state *state;
+       FILE *fp = resolv_conf_fp;
+       int ret;
+
+       req = tevent_req_create(mem_ctx, &state, struct dns_lookup_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->name = name;
+       state->qclass = qclass;
+       state->qtype = qtype;
+
+       if (resolv_conf_fp == NULL) {
+               fp = fopen("/etc/resolv.conf", "r");
+               if (fp == NULL) {
+                       tevent_req_error(req, errno);
+                       return tevent_req_post(req, ev);
+               }
+       }
+
+       ret = parse_resolvconf_fp(
+               fp,
+               state,
+               &state->nameservers,
+               &state->num_nameservers);
+
+       if (resolv_conf_fp == NULL) {
+               fclose(fp);
+       }
+
+       if (ret != 0) {
+               tevent_req_error(req, ret);
+               return tevent_req_post(req, ev);
+       }
+
+       if (state->num_nameservers == 0) {
+               /*
+                * glibc's getaddrinfo returns EAI_AGAIN when no
+                * nameservers are configured. EAGAIN seems closest.
+                */
+               tevent_req_error(req, EAGAIN);
+               return tevent_req_post(req, ev);
+       }
+
+       state->dns_subreqs = talloc_zero_array(
+               state,
+               struct tevent_req *,
+               state->num_nameservers);
+
+       if (tevent_req_nomem(state->dns_subreqs, req)) {
+               return tevent_req_post(req, ev);
+       }
+
+       ret = dns_lookup_send_next(req);
+       if (tevent_req_error(req, ret)) {
+               return tevent_req_post(req, ev);
+       }
+
+       return req;
+}
+
+static int dns_lookup_send_next(struct tevent_req *req)
+{
+       struct dns_lookup_state *state = tevent_req_data(
+               req, struct dns_lookup_state);
+
+       DBG_DEBUG("Sending DNS request #%zu to %s\n",
+                 state->num_sent,
+                 state->nameservers[state->num_sent]);
+
+       state->dns_subreqs[state->num_sent] = dns_cli_request_send(
+               state->dns_subreqs,
+               state->ev,
+               state->nameservers[state->num_sent],
+               state->name,
+               state->qclass,
+               state->qtype);
+
+       if (state->dns_subreqs[state->num_sent] == NULL) {
+               return ENOMEM;
+       }
+       tevent_req_set_callback(state->dns_subreqs[state->num_sent],
+                               dns_lookup_done,
+                               req);
+       state->num_sent += 1;
+
+       if (state->num_sent == state->num_nameservers) {
+               /*
+                * No more nameservers left
+                */
+               DBG_DEBUG("cancelling wait_subreq\n");
+               TALLOC_FREE(state->wait_subreq);
+               return 0;
+       }
+
+       if (state->wait_subreq != NULL) {
+               /*
+                * This can happen if we fire the next request upon
+                * dns_cli_request returning a network-level error
+                */
+               return 0;
+       }
+
+       state->wait_subreq = tevent_wakeup_send(
+               state,
+               state->ev,
+               tevent_timeval_current_ofs(1, 0));
+       if (state->wait_subreq == NULL) {
+               return ENOMEM;
+       }
+       tevent_req_set_callback(state->wait_subreq, dns_lookup_waited, req);
+
+       return 0;
+}
+
+static void dns_lookup_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct dns_lookup_state *state = tevent_req_data(
+               req, struct dns_lookup_state);
+       int dns_cli_request_ret;
+       size_t i;
+
+       dns_cli_request_ret = dns_cli_request_recv(
+               subreq,
+               state,
+               &state->reply);
+
+       for (i = 0; i < state->num_nameservers; i++) {
+               if (state->dns_subreqs[i] == subreq) {
+                       break;
+               }
+       }
+
+       TALLOC_FREE(subreq);
+
+       if (i == state->num_nameservers) {
+               /* should never happen */
+               DBG_WARNING("Failed to find subreq");
+               tevent_req_error(req, EINVAL);
+               return;
+       }
+       state->dns_subreqs[i] = NULL;
+
+       if (dns_cli_request_ret == 0) {
+               /*
+                * Success, cancel everything else
+                */
+               TALLOC_FREE(state->dns_subreqs);
+               TALLOC_FREE(state->wait_subreq);
+               tevent_req_done(req);
+               return;
+       }
+
+       DBG_DEBUG("dns_cli_request[%zu] returned %s\n", i,
+                 strerror(dns_cli_request_ret));
+
+       if (state->num_sent < state->num_nameservers) {
+               /*
+                * We have a nameserver left to try
+                */
+               int ret;
+
+               ret = dns_lookup_send_next(req);
+               if (tevent_req_error(req, ret)) {
+                       return;
+               }
+       }
+
+       DBG_DEBUG("looking for outstanding requests\n");
+
+       for (i = 0; i<state->num_nameservers; i++) {
+               if (state->dns_subreqs[i] != NULL) {
+                       break;
+               }
+       }
+
+       DBG_DEBUG("i=%zu, num_nameservers=%zu\n",
+                 i, state->num_nameservers);
+
+       if (i == state->num_nameservers) {
+               /*
+                * Report the lower-level error if we have nothing
+                * outstanding anymore
+                */
+               tevent_req_error(req, dns_cli_request_ret);
+               return;
+       }
+
+       /*
+        * Do nothing: We have other nameservers that might come back
+        * with something good.
+        */
+}
+
+static void dns_lookup_waited(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct dns_lookup_state *state = tevent_req_data(
+               req, struct dns_lookup_state);
+       int ret;
+       bool ok;
+
+       DBG_DEBUG("waited\n");
+
+       ok = tevent_wakeup_recv(subreq);
+       TALLOC_FREE(subreq);
+       if (!ok) {
+               tevent_req_oom(req);
+               return;
+       }
+       state->wait_subreq = NULL;
+
+       ret = dns_lookup_send_next(req);
+       if (tevent_req_error(req, ret)) {
+               return;
+       }
+
+       /*
+        * dns_lookup_send_next() has already triggered the next wakeup
+        */
+}
+
+int dns_lookup_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                   struct dns_name_packet **reply)
+{
+       struct dns_lookup_state *state = tevent_req_data(
+               req, struct dns_lookup_state);
+       int err;
+
+       if (tevent_req_is_unix_error(req, &err)) {
+               return err;
+       }
+
+       *reply = talloc_move(mem_ctx, &state->reply);
+
+       tevent_req_received(req);
+       return 0;
+}
+
+int dns_lookup(FILE *resolv_conf_fp,
+              const char *name,
+              enum dns_qclass qclass,
+              enum dns_qtype qtype,
+              TALLOC_CTX *mem_ctx,
+              struct dns_name_packet **reply)
+{
+       struct tevent_context *ev;
+       struct tevent_req *req;
+       int ret = ENOMEM;
+
+       ev = samba_tevent_context_init(mem_ctx);
+       if (ev == NULL) {
+               goto fail;
+       }
+       req = dns_lookup_send(ev, ev, resolv_conf_fp, name, qclass, qtype);
+       if (req == NULL) {
+               goto fail;
+       }
+       if (!tevent_req_poll_unix(req, ev, &ret)) {
+               goto fail;
+       }
+       ret = dns_lookup_recv(req, mem_ctx, reply);
+fail:
+       TALLOC_FREE(ev);
+       return ret;
+}
diff --git a/libcli/dns/dns_lookup.h b/libcli/dns/dns_lookup.h
new file mode 100644 (file)
index 0000000..157a3d2
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  Internal DNS query structures
+ *  Copyright (C) Volker Lendecke 2018
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __LIBCLI_DNS_DNS_LOOKUP_H__
+#define __LIBCLI_DNS_DNS_LOOKUP_H__
+
+#include "replace.h"
+#include "system/network.h"
+#include <tevent.h>
+#include "lib/util/data_blob.h"
+#include "lib/util/time.h"
+#include "librpc/gen_ndr/dns.h"
+
+struct tevent_req *dns_lookup_send(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *ev,
+                                  FILE *resolv_conf_fp,
+                                  const char *name,
+                                  enum dns_qclass qclass,
+                                  enum dns_qtype qtype);
+int dns_lookup_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                   struct dns_name_packet **reply);
+int dns_lookup(FILE *resolv_conf_fp,
+              const char *name,
+              enum dns_qclass qclass,
+              enum dns_qtype qtype,
+              TALLOC_CTX *mem_ctx,
+              struct dns_name_packet **reply);
+
+#endif
diff --git a/libcli/dns/dns_lookuptest.c b/libcli/dns/dns_lookuptest.c
new file mode 100644 (file)
index 0000000..c8e0343
--- /dev/null
@@ -0,0 +1,55 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  Internal DNS query structures
+ *  Copyright (C) Volker Lendecke 2018
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <talloc.h>
+#include <errno.h>
+#include "libcli/dns/dns_lookup.h"
+#include "lib/util/debug.h"
+
+static int dns_lookuptest1(void)
+{
+       struct dns_name_packet *reply = NULL;
+       int ret;
+
+       ret = dns_lookup(NULL, "www.samba.org", DNS_QCLASS_IN, DNS_QTYPE_A,
+                        NULL, &reply);
+       if (ret != 0) {
+               fprintf(stderr, "dns_lookup failed: %s\n", strerror(ret));
+               return ret;
+       }
+
+       TALLOC_FREE(reply);
+       return 0;
+}
+
+int main(int argc, const char *argv[]) {
+       int ret;
+
+       setup_logging(argv[0], DEBUG_DEFAULT_STDERR);
+       debug_parse_levels("10");
+
+       ret = dns_lookuptest1();
+       if (ret != 0) {
+               return 1;
+       }
+
+       return 0;
+}
index 0d7c746..d06f84d 100644 (file)
@@ -8,3 +8,12 @@ bld.SAMBA_BINARY('resolvconftest',
                   source='resolvconftest.c',
                   deps='clidns',
                   install=False)
+
+bld.SAMBA_SUBSYSTEM('dns_lookup',
+                    source='dns_lookup.c',
+                    public_deps='clidns')
+
+bld.SAMBA_BINARY('dns_lookuptest',
+                  source='dns_lookuptest.c',
+                  deps='dns_lookup',
+                  install=False)