2015-10-21 10:29:02 +02:00
|
|
|
|
/* dns-stuff.c - DNS related code including CERT RR (rfc-4398)
|
2015-10-22 09:22:41 +02:00
|
|
|
|
* Copyright (C) 2003, 2005, 2006, 2009 Free Software Foundation, Inc.
|
2016-12-01 15:45:51 +01:00
|
|
|
|
* Copyright (C) 2005, 2006, 2009, 2015. 2016 Werner Koch
|
2006-06-16 11:49:27 +00:00
|
|
|
|
*
|
2015-10-21 10:29:02 +02:00
|
|
|
|
* This file is part of GnuPG.
|
2006-06-16 11:49:27 +00:00
|
|
|
|
*
|
Change license for some files in common to LGPLv3+/GPLv2+.
Having the LGPL on the common GnuPG code helps to share code
between GnuPG and related projects (like GPGME and Libassuan). This
is good for interoperability and to reduces bugs.
* common/asshelp.c, common/asshelp.h, common/asshelp2.c, common/b64dec.c
* common/b64enc.c, common/convert.c, common/dns-cert.c
* common/dns-cert.h common/exechelp-posix.c, common/exechelp-w32.c
* common/exechelp-w32ce.c, common/exechelp.h, common/get-passphrase.c
* common/get-passphrase.h, common/gettime.c, common/gpgrlhelp.c
* common/helpfile.c, common/homedir.c, common/http.c, common/http.h
* common/i18n.c, common/init.c, common/init.h, common/iobuf.c
* common/iobuf.h, common/localename.c, common/membuf.c, common/membuf.h
* common/miscellaneous.c, common/openpgp-oid.c, common/openpgpdefs.h
* common/percent.c, common/pka.c, common/pka.h, common/session-env.c
* common/session-env.h, common/sexp-parse.h, common/sexputil.c
* common/signal.c, common/srv.c, common/srv.h, common/ssh-utils.c
* common/ssh-utils.h, common/sysutils.c, common/sysutils.h
* common/tlv.c, common/tlv.h, common/ttyio.c, common/ttyio.h
* common/userids.c, common/userids.h, common/xasprintf.c: Change
license to LGPLv3+/GPLv2+/
2012-04-20 15:43:06 +02:00
|
|
|
|
* This file is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of either
|
2006-06-16 11:49:27 +00:00
|
|
|
|
*
|
Change license for some files in common to LGPLv3+/GPLv2+.
Having the LGPL on the common GnuPG code helps to share code
between GnuPG and related projects (like GPGME and Libassuan). This
is good for interoperability and to reduces bugs.
* common/asshelp.c, common/asshelp.h, common/asshelp2.c, common/b64dec.c
* common/b64enc.c, common/convert.c, common/dns-cert.c
* common/dns-cert.h common/exechelp-posix.c, common/exechelp-w32.c
* common/exechelp-w32ce.c, common/exechelp.h, common/get-passphrase.c
* common/get-passphrase.h, common/gettime.c, common/gpgrlhelp.c
* common/helpfile.c, common/homedir.c, common/http.c, common/http.h
* common/i18n.c, common/init.c, common/init.h, common/iobuf.c
* common/iobuf.h, common/localename.c, common/membuf.c, common/membuf.h
* common/miscellaneous.c, common/openpgp-oid.c, common/openpgpdefs.h
* common/percent.c, common/pka.c, common/pka.h, common/session-env.c
* common/session-env.h, common/sexp-parse.h, common/sexputil.c
* common/signal.c, common/srv.c, common/srv.h, common/ssh-utils.c
* common/ssh-utils.h, common/sysutils.c, common/sysutils.h
* common/tlv.c, common/tlv.h, common/ttyio.c, common/ttyio.h
* common/userids.c, common/userids.h, common/xasprintf.c: Change
license to LGPLv3+/GPLv2+/
2012-04-20 15:43:06 +02:00
|
|
|
|
* - the GNU Lesser General Public License as published by the Free
|
|
|
|
|
* Software Foundation; either version 3 of the License, or (at
|
|
|
|
|
* your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* or
|
|
|
|
|
*
|
|
|
|
|
* - the GNU General Public License as published by the Free
|
|
|
|
|
* Software Foundation; either version 2 of the License, or (at
|
|
|
|
|
* your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* or both in parallel, as here.
|
|
|
|
|
*
|
|
|
|
|
* This file is distributed in the hope that it will be useful,
|
2006-06-16 11:49:27 +00:00
|
|
|
|
* 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
|
2016-11-05 12:02:19 +01:00
|
|
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
2006-06-16 11:49:27 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <sys/types.h>
|
2015-10-21 17:55:56 +02:00
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
2016-12-17 21:54:45 +01:00
|
|
|
|
# define WIN32_LEAN_AND_MEAN
|
2015-10-21 17:55:56 +02:00
|
|
|
|
# ifdef HAVE_WINSOCK2_H
|
|
|
|
|
# include <winsock2.h>
|
2009-12-08 12:20:11 +00:00
|
|
|
|
# endif
|
2015-10-21 17:55:56 +02:00
|
|
|
|
# include <windows.h>
|
2016-12-17 21:54:45 +01:00
|
|
|
|
# include <iphlpapi.h>
|
2015-10-21 17:55:56 +02:00
|
|
|
|
#else
|
2016-12-01 15:45:51 +01:00
|
|
|
|
# if HAVE_SYSTEM_RESOLVER
|
|
|
|
|
# include <netinet/in.h>
|
2017-04-12 10:00:37 +09:00
|
|
|
|
# include <arpa/nameser.h>
|
2016-12-01 15:45:51 +01:00
|
|
|
|
# include <resolv.h>
|
|
|
|
|
# endif
|
2015-10-21 17:55:56 +02:00
|
|
|
|
# include <netdb.h>
|
2009-12-08 12:20:11 +00:00
|
|
|
|
#endif
|
2017-05-25 11:33:07 +02:00
|
|
|
|
#ifdef HAVE_STAT
|
|
|
|
|
# include <sys/stat.h>
|
|
|
|
|
#endif
|
2015-10-21 17:55:56 +02:00
|
|
|
|
#include <string.h>
|
2015-10-28 10:14:07 +01:00
|
|
|
|
#include <unistd.h>
|
2015-10-21 22:11:59 +02:00
|
|
|
|
|
2016-12-17 21:54:45 +01:00
|
|
|
|
|
2016-12-05 17:31:37 +01:00
|
|
|
|
/* William Ahern's DNS library, included as a source copy. */
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
# include "dns.h"
|
|
|
|
|
#endif
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-14 10:47:53 +01:00
|
|
|
|
/* dns.c has a dns_p_free but it is not exported. We use our own
|
|
|
|
|
* wrapper here so that we do not accidentally use xfree which would
|
|
|
|
|
* be wrong for dns.c allocated data. */
|
|
|
|
|
#define dns_free(a) free ((a))
|
|
|
|
|
|
|
|
|
|
|
2015-11-12 13:31:59 +01:00
|
|
|
|
#ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth. */
|
|
|
|
|
# undef USE_NPTH
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef USE_NPTH
|
|
|
|
|
# include <npth.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
#include "./dirmngr-err.h"
|
2017-03-07 20:21:23 +09:00
|
|
|
|
#include "../common/util.h"
|
|
|
|
|
#include "../common/host2net.h"
|
2015-10-21 10:29:02 +02:00
|
|
|
|
#include "dns-stuff.h"
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2015-11-12 13:31:59 +01:00
|
|
|
|
#ifdef USE_NPTH
|
|
|
|
|
# define my_unprotect() npth_unprotect ()
|
|
|
|
|
# define my_protect() npth_protect ()
|
|
|
|
|
#else
|
|
|
|
|
# define my_unprotect() do { } while(0)
|
|
|
|
|
# define my_protect() do { } while(0)
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-10-28 08:55:01 +01:00
|
|
|
|
/* We allow the use of 0 instead of AF_UNSPEC - check this assumption. */
|
2015-10-24 16:27:47 +02:00
|
|
|
|
#if AF_UNSPEC != 0
|
|
|
|
|
# error AF_UNSPEC does not have the value 0
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-10-28 08:55:01 +01:00
|
|
|
|
/* Windows does not support the AI_ADDRCONFIG flag - use zero instead. */
|
2015-10-26 15:53:31 +01:00
|
|
|
|
#ifndef AI_ADDRCONFIG
|
|
|
|
|
# define AI_ADDRCONFIG 0
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-10-22 09:22:41 +02:00
|
|
|
|
/* Not every installation has gotten around to supporting SRVs or
|
|
|
|
|
CERTs yet... */
|
|
|
|
|
#ifndef T_SRV
|
|
|
|
|
#define T_SRV 33
|
|
|
|
|
#endif
|
2017-04-12 10:19:27 +09:00
|
|
|
|
#undef T_CERT
|
|
|
|
|
#define T_CERT 37
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2016-12-15 10:59:36 +01:00
|
|
|
|
/* The standard SOCKS and TOR ports. */
|
|
|
|
|
#define SOCKS_PORT 1080
|
|
|
|
|
#define TOR_PORT 9050
|
|
|
|
|
#define TOR_PORT2 9150 /* (Used by the Tor browser) */
|
|
|
|
|
|
2015-11-12 13:20:18 +01:00
|
|
|
|
|
2016-12-08 12:51:52 +01:00
|
|
|
|
/* The default nameserver used in Tor mode. */
|
2015-11-12 13:20:18 +01:00
|
|
|
|
#define DEFAULT_NAMESERVER "8.8.8.8"
|
|
|
|
|
|
2016-12-20 09:53:58 +01:00
|
|
|
|
/* The default timeout in seconds for libdns requests. */
|
|
|
|
|
#define DEFAULT_TIMEOUT 30
|
|
|
|
|
|
|
|
|
|
|
2017-05-25 11:33:07 +02:00
|
|
|
|
#define RESOLV_CONF_NAME "/etc/resolv.conf"
|
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
/* Two flags to enable verbose and debug mode. */
|
|
|
|
|
static int opt_verbose;
|
|
|
|
|
static int opt_debug;
|
|
|
|
|
|
2016-12-20 09:53:58 +01:00
|
|
|
|
/* The timeout in seconds for libdns requests. */
|
|
|
|
|
static int opt_timeout;
|
|
|
|
|
|
2017-01-24 16:36:28 +01:00
|
|
|
|
/* The flag to disable IPv4 access - right now this only skips
|
|
|
|
|
* returned A records. */
|
|
|
|
|
static int opt_disable_ipv4;
|
|
|
|
|
|
2017-04-03 20:56:12 +02:00
|
|
|
|
/* The flag to disable IPv6 access - right now this only skips
|
|
|
|
|
* returned AAAA records. */
|
|
|
|
|
static int opt_disable_ipv6;
|
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
/* If set force the use of the standard resolver. */
|
|
|
|
|
static int standard_resolver;
|
2015-11-12 13:20:18 +01:00
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
/* If set use recursive resolver when available. */
|
|
|
|
|
static int recursive_resolver;
|
|
|
|
|
|
2015-10-20 19:03:26 +02:00
|
|
|
|
/* If set Tor mode shall be used. */
|
|
|
|
|
static int tor_mode;
|
2009-12-08 12:20:11 +00:00
|
|
|
|
|
2015-11-12 13:20:18 +01:00
|
|
|
|
/* A string with the nameserver IP address used with Tor.
|
|
|
|
|
(40 should be sufficient for v6 but we add some extra for a scope.) */
|
|
|
|
|
static char tor_nameserver[40+20];
|
|
|
|
|
|
2016-12-16 20:25:02 +01:00
|
|
|
|
/* Two strings to hold the credentials presented to Tor. */
|
|
|
|
|
static char tor_socks_user[30];
|
|
|
|
|
static char tor_socks_password[20];
|
|
|
|
|
|
2015-11-09 20:44:13 +01:00
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-14 10:47:53 +01:00
|
|
|
|
/* Libdns gobal data. */
|
2016-12-15 10:59:36 +01:00
|
|
|
|
struct libdns_s
|
2016-12-14 10:47:53 +01:00
|
|
|
|
{
|
|
|
|
|
struct dns_resolv_conf *resolv_conf;
|
|
|
|
|
struct dns_hosts *hosts;
|
|
|
|
|
struct dns_hints *hints;
|
|
|
|
|
|
|
|
|
|
struct sockaddr_storage socks_host;
|
|
|
|
|
} libdns;
|
2016-12-16 21:00:14 +01:00
|
|
|
|
|
|
|
|
|
/* If this flag is set, libdns shall be reinited for the next use. */
|
|
|
|
|
static int libdns_reinit_pending;
|
|
|
|
|
|
2016-12-16 21:56:23 +01:00
|
|
|
|
/* The Tor port to be used. */
|
|
|
|
|
static int libdns_tor_port;
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
2016-12-16 21:00:14 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
/* Calling this function with YES set to True forces the use of the
|
|
|
|
|
* standard resolver even if dirmngr has been built with support for
|
|
|
|
|
* an alternative resolver. */
|
|
|
|
|
void
|
|
|
|
|
enable_standard_resolver (int yes)
|
|
|
|
|
{
|
|
|
|
|
standard_resolver = yes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return true if the standard resolver is used. */
|
|
|
|
|
int
|
|
|
|
|
standard_resolver_p (void)
|
|
|
|
|
{
|
|
|
|
|
return standard_resolver;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
/* Calling this function with YES switches libdns into recursive mode.
|
|
|
|
|
* It has no effect on the standard resolver. */
|
|
|
|
|
void
|
|
|
|
|
enable_recursive_resolver (int yes)
|
|
|
|
|
{
|
|
|
|
|
recursive_resolver = yes;
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-16 21:00:14 +01:00
|
|
|
|
libdns_reinit_pending = 1;
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#endif
|
2016-12-14 15:36:25 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return true iff the recursive resolver is used. */
|
|
|
|
|
int
|
|
|
|
|
recursive_resolver_p (void)
|
|
|
|
|
{
|
|
|
|
|
#if USE_LIBDNS
|
|
|
|
|
return !standard_resolver && recursive_resolver;
|
|
|
|
|
#else
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-03 12:03:28 +01:00
|
|
|
|
/* Puts this module eternally into Tor mode. When called agained with
|
|
|
|
|
* NEW_CIRCUIT request a new TOR circuit for the next DNS query. */
|
|
|
|
|
void
|
2015-11-09 20:44:13 +01:00
|
|
|
|
enable_dns_tormode (int new_circuit)
|
2015-10-20 19:03:26 +02:00
|
|
|
|
{
|
2016-12-16 20:25:02 +01:00
|
|
|
|
if (!*tor_socks_user || new_circuit)
|
2016-12-08 12:51:52 +01:00
|
|
|
|
{
|
|
|
|
|
static unsigned int counter;
|
2015-11-09 20:44:13 +01:00
|
|
|
|
|
2016-12-16 20:25:02 +01:00
|
|
|
|
gpgrt_snprintf (tor_socks_user, sizeof tor_socks_user,
|
|
|
|
|
"dirmngr-%lu", (unsigned long)getpid ());
|
|
|
|
|
gpgrt_snprintf (tor_socks_password, sizeof tor_socks_password,
|
|
|
|
|
"p%u", counter);
|
2016-12-08 12:51:52 +01:00
|
|
|
|
counter++;
|
|
|
|
|
}
|
|
|
|
|
tor_mode = 1;
|
2015-10-20 19:03:26 +02:00
|
|
|
|
}
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2015-11-12 13:20:18 +01:00
|
|
|
|
|
2017-02-01 17:54:14 +01:00
|
|
|
|
/* Disable tor mode. */
|
|
|
|
|
void
|
|
|
|
|
disable_dns_tormode (void)
|
|
|
|
|
{
|
|
|
|
|
tor_mode = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
/* Set verbosity and debug mode for this module. */
|
|
|
|
|
void
|
|
|
|
|
set_dns_verbose (int verbose, int debug)
|
|
|
|
|
{
|
|
|
|
|
opt_verbose = verbose;
|
|
|
|
|
opt_debug = debug;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-24 16:36:28 +01:00
|
|
|
|
/* Set the Disable-IPv4 flag so that the name resolver does not return
|
|
|
|
|
* A addresses. */
|
|
|
|
|
void
|
|
|
|
|
set_dns_disable_ipv4 (int yes)
|
|
|
|
|
{
|
|
|
|
|
opt_disable_ipv4 = !!yes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-04-03 20:56:12 +02:00
|
|
|
|
/* Set the Disable-IPv6 flag so that the name resolver does not return
|
|
|
|
|
* AAAA addresses. */
|
|
|
|
|
void
|
|
|
|
|
set_dns_disable_ipv6 (int yes)
|
|
|
|
|
{
|
|
|
|
|
opt_disable_ipv6 = !!yes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-20 09:53:58 +01:00
|
|
|
|
/* Set the timeout for libdns requests to SECONDS. A value of 0 sets
|
|
|
|
|
* the default timeout and values are capped at 10 minutes. */
|
|
|
|
|
void
|
|
|
|
|
set_dns_timeout (int seconds)
|
|
|
|
|
{
|
|
|
|
|
if (!seconds)
|
|
|
|
|
seconds = DEFAULT_TIMEOUT;
|
|
|
|
|
else if (seconds < 1)
|
|
|
|
|
seconds = 1;
|
|
|
|
|
else if (seconds > 600)
|
|
|
|
|
seconds = 600;
|
|
|
|
|
|
|
|
|
|
opt_timeout = seconds;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-11-12 13:20:18 +01:00
|
|
|
|
/* Change the default IP address of the nameserver to IPADDR. The
|
|
|
|
|
address needs to be a numerical IP address and will be used for the
|
|
|
|
|
next DNS query. Note that this is only used in Tor mode. */
|
|
|
|
|
void
|
|
|
|
|
set_dns_nameserver (const char *ipaddr)
|
|
|
|
|
{
|
|
|
|
|
strncpy (tor_nameserver, ipaddr? ipaddr : DEFAULT_NAMESERVER,
|
|
|
|
|
sizeof tor_nameserver -1);
|
|
|
|
|
tor_nameserver[sizeof tor_nameserver -1] = 0;
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-16 21:00:14 +01:00
|
|
|
|
libdns_reinit_pending = 1;
|
2016-12-16 21:56:23 +01:00
|
|
|
|
libdns_tor_port = 0; /* Start again with the default port. */
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#endif
|
2015-11-12 13:20:18 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-10-21 17:55:56 +02:00
|
|
|
|
/* Free an addressinfo linked list as returned by resolve_dns_name. */
|
|
|
|
|
void
|
|
|
|
|
free_dns_addrinfo (dns_addrinfo_t ai)
|
|
|
|
|
{
|
|
|
|
|
while (ai)
|
|
|
|
|
{
|
|
|
|
|
dns_addrinfo_t next = ai->next;
|
|
|
|
|
xfree (ai);
|
|
|
|
|
ai = next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-17 21:54:45 +01:00
|
|
|
|
|
|
|
|
|
#ifndef HAVE_W32_SYSTEM
|
2016-12-14 10:30:29 +01:00
|
|
|
|
/* Return H_ERRNO mapped to a gpg-error code. Will never return 0. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
get_h_errno_as_gpg_error (void)
|
|
|
|
|
{
|
|
|
|
|
gpg_err_code_t ec;
|
|
|
|
|
|
|
|
|
|
switch (h_errno)
|
|
|
|
|
{
|
2016-12-23 16:05:01 +09:00
|
|
|
|
case HOST_NOT_FOUND: ec = GPG_ERR_NO_NAME; break;
|
2016-12-14 10:30:29 +01:00
|
|
|
|
case TRY_AGAIN: ec = GPG_ERR_TRY_LATER; break;
|
|
|
|
|
case NO_RECOVERY: ec = GPG_ERR_SERVER_FAILED; break;
|
|
|
|
|
case NO_DATA: ec = GPG_ERR_NO_DATA; break;
|
|
|
|
|
default: ec = GPG_ERR_UNKNOWN_ERRNO; break;
|
|
|
|
|
}
|
|
|
|
|
return gpg_error (ec);
|
|
|
|
|
}
|
2016-12-17 21:54:45 +01:00
|
|
|
|
#endif /*!HAVE_W32_SYSTEM*/
|
2015-10-21 17:55:56 +02:00
|
|
|
|
|
2015-10-24 16:27:47 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
map_eai_to_gpg_error (int ec)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
switch (ec)
|
|
|
|
|
{
|
|
|
|
|
case EAI_AGAIN: err = gpg_error (GPG_ERR_EAGAIN); break;
|
|
|
|
|
case EAI_BADFLAGS: err = gpg_error (GPG_ERR_INV_FLAG); break;
|
|
|
|
|
case EAI_FAIL: err = gpg_error (GPG_ERR_SERVER_FAILED); break;
|
|
|
|
|
case EAI_MEMORY: err = gpg_error (GPG_ERR_ENOMEM); break;
|
2016-01-27 13:55:31 +01:00
|
|
|
|
#ifdef EAI_NODATA
|
2015-10-24 16:27:47 +02:00
|
|
|
|
case EAI_NODATA: err = gpg_error (GPG_ERR_NO_DATA); break;
|
2016-01-27 13:55:31 +01:00
|
|
|
|
#endif
|
2015-10-24 16:27:47 +02:00
|
|
|
|
case EAI_NONAME: err = gpg_error (GPG_ERR_NO_NAME); break;
|
|
|
|
|
case EAI_SERVICE: err = gpg_error (GPG_ERR_NOT_SUPPORTED); break;
|
|
|
|
|
case EAI_FAMILY: err = gpg_error (GPG_ERR_EAFNOSUPPORT); break;
|
|
|
|
|
case EAI_SOCKTYPE: err = gpg_error (GPG_ERR_ESOCKTNOSUPPORT); break;
|
2015-10-26 15:53:31 +01:00
|
|
|
|
#ifndef HAVE_W32_SYSTEM
|
2016-01-27 13:55:31 +01:00
|
|
|
|
# ifdef EAI_ADDRFAMILY
|
2015-10-26 15:53:31 +01:00
|
|
|
|
case EAI_ADDRFAMILY:err = gpg_error (GPG_ERR_EADDRNOTAVAIL); break;
|
2016-01-27 13:55:31 +01:00
|
|
|
|
# endif
|
2015-10-24 16:27:47 +02:00
|
|
|
|
case EAI_SYSTEM: err = gpg_error_from_syserror (); break;
|
2015-10-26 15:53:31 +01:00
|
|
|
|
#endif
|
2015-10-24 16:27:47 +02:00
|
|
|
|
default: err = gpg_error (GPG_ERR_UNKNOWN_ERRNO); break;
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-05 17:31:37 +01:00
|
|
|
|
static gpg_error_t
|
2016-12-14 10:47:53 +01:00
|
|
|
|
libdns_error_to_gpg_error (int serr)
|
2016-12-05 17:31:37 +01:00
|
|
|
|
{
|
|
|
|
|
gpg_err_code_t ec;
|
|
|
|
|
|
2016-12-14 10:47:53 +01:00
|
|
|
|
switch (serr)
|
2016-12-05 17:31:37 +01:00
|
|
|
|
{
|
2016-12-14 10:47:53 +01:00
|
|
|
|
case 0: ec = 0; break;
|
|
|
|
|
|
|
|
|
|
case DNS_ENOBUFS: ec = GPG_ERR_BUFFER_TOO_SHORT; break;
|
|
|
|
|
case DNS_EILLEGAL: ec = GPG_ERR_INV_OBJ; break;
|
|
|
|
|
case DNS_EORDER: ec = GPG_ERR_INV_ORDER; break;
|
|
|
|
|
case DNS_ESECTION: ec = GPG_ERR_DNS_SECTION; break;
|
|
|
|
|
case DNS_EUNKNOWN: ec = GPG_ERR_DNS_UNKNOWN; break;
|
|
|
|
|
case DNS_EADDRESS: ec = GPG_ERR_DNS_ADDRESS; break;
|
|
|
|
|
case DNS_ENOQUERY: ec = GPG_ERR_DNS_NO_QUERY; break;
|
|
|
|
|
case DNS_ENOANSWER:ec = GPG_ERR_DNS_NO_ANSWER; break;
|
|
|
|
|
case DNS_EFETCHED: ec = GPG_ERR_ALREADY_FETCHED; break;
|
|
|
|
|
case DNS_ESERVICE: ec = GPG_ERR_NOT_SUPPORTED; break;
|
|
|
|
|
case DNS_ENONAME: ec = GPG_ERR_NO_NAME; break;
|
|
|
|
|
case DNS_EFAIL: ec = GPG_ERR_SERVER_FAILED; break;
|
|
|
|
|
case DNS_ECONNFIN: ec = GPG_ERR_DNS_CLOSED; break;
|
|
|
|
|
case DNS_EVERIFY: ec = GPG_ERR_DNS_VERIFY; break;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
default:
|
2016-12-14 10:47:53 +01:00
|
|
|
|
if (serr >= 0)
|
|
|
|
|
ec = gpg_err_code_from_errno (serr);
|
|
|
|
|
else
|
|
|
|
|
ec = GPG_ERR_DNS_UNKNOWN;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return gpg_error (ec);
|
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
2017-05-25 11:33:07 +02:00
|
|
|
|
/* Return true if resolve.conf changed since it was last loaded. */
|
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
static int
|
|
|
|
|
resolv_conf_changed_p (void)
|
|
|
|
|
{
|
|
|
|
|
#if defined(HAVE_W32_SYSTEM) || !defined(HAVE_STAT)
|
|
|
|
|
return 0;
|
|
|
|
|
#else
|
|
|
|
|
static time_t last_mtime;
|
|
|
|
|
const char *fname = RESOLV_CONF_NAME;
|
|
|
|
|
struct stat statbuf;
|
2017-05-25 20:26:54 +02:00
|
|
|
|
int changed = 0;
|
2017-05-25 11:33:07 +02:00
|
|
|
|
|
|
|
|
|
if (stat (fname, &statbuf))
|
|
|
|
|
{
|
|
|
|
|
log_error ("stat'ing '%s' failed: %s\n",
|
|
|
|
|
fname, gpg_strerror (gpg_error_from_syserror ()));
|
|
|
|
|
last_mtime = 1; /* Force a "changed" result the next time stat
|
|
|
|
|
* works. */
|
|
|
|
|
}
|
2017-05-25 20:26:54 +02:00
|
|
|
|
else if (!last_mtime)
|
|
|
|
|
last_mtime = statbuf.st_mtime;
|
|
|
|
|
else if (last_mtime != statbuf.st_mtime)
|
2017-05-25 11:33:07 +02:00
|
|
|
|
{
|
2017-05-25 20:26:54 +02:00
|
|
|
|
changed = 1;
|
2017-05-25 11:33:07 +02:00
|
|
|
|
last_mtime = statbuf.st_mtime;
|
|
|
|
|
}
|
2017-05-25 20:26:54 +02:00
|
|
|
|
|
2017-05-25 11:33:07 +02:00
|
|
|
|
return changed;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-15 10:59:36 +01:00
|
|
|
|
/* Initialize libdns. Returns 0 on success; prints a diagnostic and
|
|
|
|
|
* returns an error code on failure. */
|
2016-12-05 17:31:37 +01:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
libdns_init (void)
|
|
|
|
|
{
|
2016-12-15 10:59:36 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct libdns_s ld;
|
|
|
|
|
int derr;
|
|
|
|
|
char *cfgstr = NULL;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-16 21:00:14 +01:00
|
|
|
|
if (libdns.resolv_conf)
|
|
|
|
|
return 0; /* Already initialized. */
|
|
|
|
|
|
2016-12-15 10:59:36 +01:00
|
|
|
|
memset (&ld, 0, sizeof ld);
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-15 10:59:36 +01:00
|
|
|
|
ld.resolv_conf = dns_resconf_open (&derr);
|
|
|
|
|
if (!ld.resolv_conf)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
log_error ("failed to allocate DNS resconf object: %s\n",
|
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-15 10:59:36 +01:00
|
|
|
|
if (tor_mode)
|
|
|
|
|
{
|
|
|
|
|
if (!*tor_nameserver)
|
|
|
|
|
set_dns_nameserver (NULL);
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-16 21:56:23 +01:00
|
|
|
|
if (!libdns_tor_port)
|
|
|
|
|
libdns_tor_port = TOR_PORT;
|
|
|
|
|
|
2016-12-15 10:59:36 +01:00
|
|
|
|
cfgstr = xtryasprintf ("[%s]:53", tor_nameserver);
|
|
|
|
|
if (!cfgstr)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
err = libdns_error_to_gpg_error
|
|
|
|
|
(dns_resconf_pton (&ld.resolv_conf->nameserver[0], cfgstr));
|
|
|
|
|
if (err)
|
|
|
|
|
log_error ("failed to set nameserver '%s': %s\n",
|
|
|
|
|
cfgstr, gpg_strerror (err));
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
ld.resolv_conf->options.tcp = DNS_RESCONF_TCP_SOCKS;
|
|
|
|
|
|
|
|
|
|
xfree (cfgstr);
|
2016-12-16 21:56:23 +01:00
|
|
|
|
cfgstr = xtryasprintf ("[%s]:%d", "127.0.0.1", libdns_tor_port);
|
2016-12-15 10:59:36 +01:00
|
|
|
|
if (!cfgstr)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
err = libdns_error_to_gpg_error
|
|
|
|
|
(dns_resconf_pton (&ld.socks_host, cfgstr));
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error ("failed to set socks server '%s': %s\n",
|
|
|
|
|
cfgstr, gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-12-17 21:54:45 +01:00
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
|
|
|
|
ULONG ninfo_len;
|
|
|
|
|
PFIXED_INFO ninfo;
|
|
|
|
|
PIP_ADDR_STRING pip;
|
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
|
|
ninfo_len = 2048;
|
|
|
|
|
ninfo = xtrymalloc (ninfo_len);
|
|
|
|
|
if (!ninfo)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GetNetworkParams (ninfo, &ninfo_len))
|
|
|
|
|
{
|
|
|
|
|
log_error ("GetNetworkParms failed: %s\n", w32_strerror (-1));
|
|
|
|
|
err = gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
xfree (ninfo);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (idx=0, pip = &(ninfo->DnsServerList);
|
|
|
|
|
pip && idx < DIM (ld.resolv_conf->nameserver);
|
|
|
|
|
pip = pip->Next)
|
|
|
|
|
{
|
2016-12-20 09:53:58 +01:00
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: dnsserver[%d] '%s'\n", idx, pip->IpAddress.String);
|
2016-12-17 21:54:45 +01:00
|
|
|
|
err = libdns_error_to_gpg_error
|
|
|
|
|
(dns_resconf_pton (&ld.resolv_conf->nameserver[idx],
|
|
|
|
|
pip->IpAddress.String));
|
|
|
|
|
if (err)
|
|
|
|
|
log_error ("failed to set nameserver[%d] '%s': %s\n",
|
|
|
|
|
idx, pip->IpAddress.String, gpg_strerror (err));
|
|
|
|
|
else
|
|
|
|
|
idx++;
|
|
|
|
|
}
|
|
|
|
|
xfree (ninfo);
|
|
|
|
|
|
|
|
|
|
#else /* Unix */
|
|
|
|
|
const char *fname;
|
|
|
|
|
|
2017-05-25 11:33:07 +02:00
|
|
|
|
fname = RESOLV_CONF_NAME;
|
|
|
|
|
resolv_conf_changed_p (); /* Reset timestamp. */
|
2016-12-15 10:59:36 +01:00
|
|
|
|
err = libdns_error_to_gpg_error
|
|
|
|
|
(dns_resconf_loadpath (ld.resolv_conf, fname));
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error ("failed to load '%s': %s\n", fname, gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fname = "/etc/nsswitch.conf";
|
|
|
|
|
err = libdns_error_to_gpg_error
|
|
|
|
|
(dns_nssconf_loadpath (ld.resolv_conf, fname));
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
2017-02-13 20:09:26 +01:00
|
|
|
|
/* This is not a fatal error: nsswitch.conf is not used on
|
|
|
|
|
* all systems; assume classic behavior instead. */
|
|
|
|
|
if (gpg_err_code (err) != GPG_ERR_ENOENT)
|
|
|
|
|
log_error ("failed to load '%s': %s\n", fname, gpg_strerror (err));
|
2017-01-23 11:39:10 +01:00
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: fallback resolution order, files then DNS\n");
|
2017-01-19 01:21:42 -05:00
|
|
|
|
ld.resolv_conf->lookup[0] = 'f';
|
|
|
|
|
ld.resolv_conf->lookup[1] = 'b';
|
|
|
|
|
ld.resolv_conf->lookup[2] = '\0';
|
|
|
|
|
err = GPG_ERR_NO_ERROR;
|
2016-12-15 10:59:36 +01:00
|
|
|
|
}
|
2017-02-13 20:09:26 +01:00
|
|
|
|
else if (!strchr (ld.resolv_conf->lookup, 'b'))
|
|
|
|
|
{
|
2017-03-07 10:30:13 +01:00
|
|
|
|
/* No DNS resolution type found in the list. This might be
|
2017-02-13 20:09:26 +01:00
|
|
|
|
* due to systemd based systems which allow for custom
|
|
|
|
|
* keywords which are not known to us and thus we do not
|
2017-04-28 10:06:33 +09:00
|
|
|
|
* know whether DNS is wanted or not. Because DNS is
|
2017-02-13 20:09:26 +01:00
|
|
|
|
* important for our infrastructure, we forcefully append
|
|
|
|
|
* DNS to the end of the list. */
|
|
|
|
|
if (strlen (ld.resolv_conf->lookup)+2 < sizeof ld.resolv_conf->lookup)
|
|
|
|
|
{
|
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: appending DNS to resolution order\n");
|
|
|
|
|
strcat (ld.resolv_conf->lookup, "b");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
log_error ("failed to append DNS to resolution order\n");
|
|
|
|
|
}
|
2016-12-17 21:54:45 +01:00
|
|
|
|
|
|
|
|
|
#endif /* Unix */
|
2016-12-15 10:59:36 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ld.hosts = dns_hosts_open (&derr);
|
|
|
|
|
if (!ld.hosts)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
2017-03-21 14:18:25 +01:00
|
|
|
|
log_error ("failed to initialize hosts file: %s\n", gpg_strerror (err));
|
2016-12-15 10:59:36 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2017-03-21 14:18:25 +01:00
|
|
|
|
{
|
|
|
|
|
#if HAVE_W32_SYSTEM
|
2017-04-03 19:10:50 +02:00
|
|
|
|
char *hosts_path = xtryasprintf ("%s\\System32\\drivers\\etc\\hosts",
|
2017-03-21 14:18:25 +01:00
|
|
|
|
getenv ("SystemRoot"));
|
|
|
|
|
if (! hosts_path)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
derr = dns_hosts_loadpath (ld.hosts, hosts_path);
|
|
|
|
|
xfree (hosts_path);
|
|
|
|
|
#else
|
|
|
|
|
derr = dns_hosts_loadpath (ld.hosts, "/etc/hosts");
|
2017-04-03 20:20:27 +02:00
|
|
|
|
#endif
|
2017-03-21 14:18:25 +01:00
|
|
|
|
if (derr)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
log_error ("failed to load hosts file: %s\n", gpg_strerror (err));
|
2017-04-03 19:10:50 +02:00
|
|
|
|
err = 0; /* Do not bail out - having no /etc/hosts is legal. */
|
2017-03-21 14:18:25 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-14 13:01:45 +09:00
|
|
|
|
ld.resolv_conf->options.recurse = recursive_resolver_p ();
|
|
|
|
|
|
2016-12-05 17:31:37 +01:00
|
|
|
|
/* dns_hints_local for stub mode, dns_hints_root for recursive. */
|
2016-12-15 10:59:36 +01:00
|
|
|
|
ld.hints = (recursive_resolver
|
|
|
|
|
? dns_hints_root (ld.resolv_conf, &derr)
|
|
|
|
|
: dns_hints_local (ld.resolv_conf, &derr));
|
|
|
|
|
if (!ld.hints)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
2017-03-21 14:22:13 +01:00
|
|
|
|
log_error ("failed to load DNS hints: %s\n", gpg_strerror (err));
|
2016-12-15 10:59:36 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* All fine. Make the data global. */
|
|
|
|
|
libdns = ld;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2017-01-02 15:47:24 +01:00
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: libdns initialized%s\n", tor_mode?" (tor mode)":"");
|
|
|
|
|
|
2016-12-05 17:31:37 +01:00
|
|
|
|
leave:
|
2016-12-15 10:59:36 +01:00
|
|
|
|
xfree (cfgstr);
|
|
|
|
|
return err;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
|
2016-12-16 21:00:14 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
/* Deinitialize libdns. */
|
|
|
|
|
static void
|
|
|
|
|
libdns_deinit (void)
|
|
|
|
|
{
|
|
|
|
|
struct libdns_s ld;
|
|
|
|
|
|
|
|
|
|
if (!libdns.resolv_conf)
|
|
|
|
|
return; /* Not initialized. */
|
|
|
|
|
|
|
|
|
|
ld = libdns;
|
|
|
|
|
memset (&libdns, 0, sizeof libdns);
|
|
|
|
|
dns_hints_close (ld.hints);
|
|
|
|
|
dns_hosts_close (ld.hosts);
|
|
|
|
|
dns_resconf_close (ld.resolv_conf);
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
2016-12-16 21:56:23 +01:00
|
|
|
|
|
2016-12-16 21:00:14 +01:00
|
|
|
|
/* SIGHUP action handler for this module. With FORCE set objects are
|
|
|
|
|
* all immediately released. */
|
|
|
|
|
void
|
|
|
|
|
reload_dns_stuff (int force)
|
|
|
|
|
{
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-16 21:00:14 +01:00
|
|
|
|
if (force)
|
|
|
|
|
{
|
|
|
|
|
libdns_deinit ();
|
|
|
|
|
libdns_reinit_pending = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
2017-01-03 12:03:28 +01:00
|
|
|
|
{
|
|
|
|
|
libdns_reinit_pending = 1;
|
|
|
|
|
libdns_tor_port = 0; /* Start again with the default port. */
|
|
|
|
|
}
|
2016-12-23 16:05:01 +09:00
|
|
|
|
#else
|
|
|
|
|
(void)force;
|
|
|
|
|
#endif
|
2016-12-16 21:00:14 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
/*
|
|
|
|
|
* Initialize libdns if needed and open a dns_resolver context.
|
|
|
|
|
* Returns 0 on success and stores the new context at R_RES. On
|
|
|
|
|
* failure an error code is returned and NULL stored at R_RES.
|
|
|
|
|
*/
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
libdns_res_open (struct dns_resolver **r_res)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct dns_resolver *res;
|
|
|
|
|
int derr;
|
|
|
|
|
|
|
|
|
|
*r_res = NULL;
|
|
|
|
|
|
2017-05-25 11:33:07 +02:00
|
|
|
|
/* Force a reload if resolv.conf has changed. */
|
|
|
|
|
if (resolv_conf_changed_p ())
|
|
|
|
|
{
|
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: resolv.conf changed - forcing reload\n");
|
|
|
|
|
libdns_reinit_pending = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-16 21:00:14 +01:00
|
|
|
|
if (libdns_reinit_pending)
|
|
|
|
|
{
|
|
|
|
|
libdns_reinit_pending = 0;
|
|
|
|
|
libdns_deinit ();
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_init ();
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2016-12-20 09:53:58 +01:00
|
|
|
|
if (!opt_timeout)
|
|
|
|
|
set_dns_timeout (0);
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
res = dns_res_open (libdns.resolv_conf, libdns.hosts, libdns.hints, NULL,
|
2016-12-16 20:25:02 +01:00
|
|
|
|
dns_opts (.socks_host = &libdns.socks_host,
|
|
|
|
|
.socks_user = tor_socks_user,
|
|
|
|
|
.socks_password = tor_socks_password ),
|
|
|
|
|
&derr);
|
2016-12-16 20:09:27 +01:00
|
|
|
|
if (!res)
|
|
|
|
|
return libdns_error_to_gpg_error (derr);
|
|
|
|
|
|
|
|
|
|
*r_res = res;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
|
|
|
|
|
2016-12-16 21:56:23 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2017-01-02 15:47:24 +01:00
|
|
|
|
/* Helper to test whether we need to try again after having switched
|
2016-12-16 21:56:23 +01:00
|
|
|
|
* the Tor port. */
|
|
|
|
|
static int
|
|
|
|
|
libdns_switch_port_p (gpg_error_t err)
|
|
|
|
|
{
|
|
|
|
|
if (tor_mode && gpg_err_code (err) == GPG_ERR_ECONNREFUSED
|
|
|
|
|
&& libdns_tor_port == TOR_PORT)
|
|
|
|
|
{
|
|
|
|
|
/* Switch port and try again. */
|
2016-12-19 23:27:02 +01:00
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: switching from SOCKS port %d to %d\n",
|
|
|
|
|
TOR_PORT, TOR_PORT2);
|
2016-12-16 21:56:23 +01:00
|
|
|
|
libdns_tor_port = TOR_PORT2;
|
|
|
|
|
libdns_reinit_pending = 1;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
/* Wrapper around dns_res_submit. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
libdns_res_submit (struct dns_resolver *res, const char *qname,
|
|
|
|
|
enum dns_type qtype, enum dns_class qclass)
|
|
|
|
|
{
|
|
|
|
|
return libdns_error_to_gpg_error (dns_res_submit (res, qname, qtype, qclass));
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
/* Standard event handling loop. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
libdns_res_wait (struct dns_resolver *res)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
while ((err = libdns_error_to_gpg_error (dns_res_check (res)))
|
|
|
|
|
&& gpg_err_code (err) == GPG_ERR_EAGAIN)
|
|
|
|
|
{
|
2016-12-20 09:53:58 +01:00
|
|
|
|
if (dns_res_elapsed (res) > opt_timeout)
|
2016-12-16 20:09:27 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_DNS_TIMEOUT);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
my_unprotect ();
|
|
|
|
|
dns_res_poll (res, 1);
|
|
|
|
|
my_protect ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-05 17:31:37 +01:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
resolve_name_libdns (const char *name, unsigned short port,
|
|
|
|
|
int want_family, int want_socktype,
|
|
|
|
|
dns_addrinfo_t *r_dai, char **r_canonname)
|
|
|
|
|
{
|
2016-12-14 10:47:53 +01:00
|
|
|
|
gpg_error_t err;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
dns_addrinfo_t daihead = NULL;
|
|
|
|
|
dns_addrinfo_t dai;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
struct dns_resolver *res = NULL;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
struct dns_addrinfo *ai = NULL;
|
|
|
|
|
struct addrinfo hints;
|
|
|
|
|
struct addrinfo *ent;
|
|
|
|
|
char portstr_[21];
|
2016-12-14 10:47:53 +01:00
|
|
|
|
char *portstr = NULL;
|
2017-02-15 19:17:08 +01:00
|
|
|
|
char *namebuf = NULL;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
int derr;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
*r_dai = NULL;
|
|
|
|
|
if (r_canonname)
|
|
|
|
|
*r_canonname = NULL;
|
|
|
|
|
|
|
|
|
|
memset (&hints, 0, sizeof hints);
|
|
|
|
|
hints.ai_family = want_family;
|
|
|
|
|
hints.ai_socktype = want_socktype;
|
|
|
|
|
hints.ai_flags = AI_ADDRCONFIG;
|
|
|
|
|
if (r_canonname)
|
|
|
|
|
hints.ai_flags |= AI_CANONNAME;
|
|
|
|
|
|
|
|
|
|
if (port)
|
2016-12-14 10:47:53 +01:00
|
|
|
|
{
|
|
|
|
|
snprintf (portstr_, sizeof portstr_, "%hu", port);
|
|
|
|
|
portstr = portstr_;
|
|
|
|
|
}
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_open (&res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2017-02-15 19:17:08 +01:00
|
|
|
|
|
|
|
|
|
if (is_ip_address (name))
|
|
|
|
|
{
|
|
|
|
|
hints.ai_flags |= AI_NUMERICHOST;
|
|
|
|
|
/* libdns does not grok brackets - remove them. */
|
|
|
|
|
if (*name == '[' && name[strlen(name)-1] == ']')
|
|
|
|
|
{
|
|
|
|
|
namebuf = xtrymalloc (strlen (name));
|
|
|
|
|
if (!namebuf)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
strcpy (namebuf, name+1);
|
|
|
|
|
namebuf[strlen (namebuf)-1] = 0;
|
|
|
|
|
name = namebuf;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-14 10:47:53 +01:00
|
|
|
|
ai = dns_ai_open (name, portstr, 0, &hints, res, &derr);
|
|
|
|
|
if (!ai)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Loop over all records. */
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (dns_ai_nextent (&ent, ai));
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_ENOENT)
|
|
|
|
|
{
|
|
|
|
|
if (daihead)
|
|
|
|
|
err = 0; /* We got some results, we're good. */
|
|
|
|
|
break; /* Ready. */
|
|
|
|
|
}
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_EAGAIN)
|
|
|
|
|
{
|
2016-12-20 09:53:58 +01:00
|
|
|
|
if (dns_ai_elapsed (ai) > opt_timeout)
|
2016-12-14 10:47:53 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_DNS_TIMEOUT);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
my_unprotect ();
|
|
|
|
|
dns_ai_poll (ai, 1);
|
|
|
|
|
my_protect ();
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
if (r_canonname && ! *r_canonname && ent && ent->ai_canonname)
|
|
|
|
|
{
|
|
|
|
|
*r_canonname = xtrystrdup (ent->ai_canonname);
|
|
|
|
|
if (!*r_canonname)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2017-01-02 10:00:33 +01:00
|
|
|
|
/* Libdns appends the root zone part which is problematic
|
|
|
|
|
* for most other functions - strip it. */
|
|
|
|
|
if (**r_canonname && (*r_canonname)[strlen (*r_canonname)-1] == '.')
|
|
|
|
|
(*r_canonname)[strlen (*r_canonname)-1] = 0;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-04-13 14:33:33 +09:00
|
|
|
|
dai = xtrymalloc (sizeof *dai);
|
2016-12-05 17:31:37 +01:00
|
|
|
|
if (dai == NULL)
|
|
|
|
|
{
|
2016-12-14 10:47:53 +01:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2016-12-05 17:31:37 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dai->family = ent->ai_family;
|
|
|
|
|
dai->socktype = ent->ai_socktype;
|
|
|
|
|
dai->protocol = ent->ai_protocol;
|
|
|
|
|
dai->addrlen = ent->ai_addrlen;
|
|
|
|
|
memcpy (dai->addr, ent->ai_addr, ent->ai_addrlen);
|
|
|
|
|
dai->next = daihead;
|
|
|
|
|
daihead = dai;
|
|
|
|
|
|
|
|
|
|
xfree (ent);
|
2016-12-14 10:47:53 +01:00
|
|
|
|
}
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
dns_ai_close (ai);
|
|
|
|
|
dns_res_close (res);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
if (r_canonname)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_canonname);
|
|
|
|
|
*r_canonname = NULL;
|
|
|
|
|
}
|
|
|
|
|
free_dns_addrinfo (daihead);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*r_dai = daihead;
|
|
|
|
|
|
2017-02-15 19:17:08 +01:00
|
|
|
|
xfree (namebuf);
|
2016-12-05 17:31:37 +01:00
|
|
|
|
return err;
|
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2015-10-28 08:55:01 +01:00
|
|
|
|
|
2015-10-21 17:55:56 +02:00
|
|
|
|
/* Resolve a name using the standard system function. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
resolve_name_standard (const char *name, unsigned short port,
|
|
|
|
|
int want_family, int want_socktype,
|
|
|
|
|
dns_addrinfo_t *r_dai, char **r_canonname)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
dns_addrinfo_t daihead = NULL;
|
|
|
|
|
dns_addrinfo_t dai;
|
|
|
|
|
struct addrinfo *aibuf = NULL;
|
|
|
|
|
struct addrinfo hints, *ai;
|
|
|
|
|
char portstr[21];
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
*r_dai = NULL;
|
|
|
|
|
if (r_canonname)
|
|
|
|
|
*r_canonname = NULL;
|
|
|
|
|
|
|
|
|
|
memset (&hints, 0, sizeof hints);
|
|
|
|
|
hints.ai_family = want_family;
|
|
|
|
|
hints.ai_socktype = want_socktype;
|
2015-10-24 16:27:47 +02:00
|
|
|
|
hints.ai_flags = AI_ADDRCONFIG;
|
2015-10-21 17:55:56 +02:00
|
|
|
|
if (r_canonname)
|
2015-10-24 16:27:47 +02:00
|
|
|
|
hints.ai_flags |= AI_CANONNAME;
|
2017-01-16 09:10:46 +01:00
|
|
|
|
if (is_ip_address (name))
|
|
|
|
|
hints.ai_flags |= AI_NUMERICHOST;
|
2015-10-21 17:55:56 +02:00
|
|
|
|
|
|
|
|
|
if (port)
|
|
|
|
|
snprintf (portstr, sizeof portstr, "%hu", port);
|
|
|
|
|
else
|
|
|
|
|
*portstr = 0;
|
|
|
|
|
|
2017-02-20 16:19:50 -05:00
|
|
|
|
/* We can't use the AI_IDN flag because that does the conversion
|
2015-10-21 17:55:56 +02:00
|
|
|
|
using the current locale. However, GnuPG always used UTF-8. To
|
|
|
|
|
support IDN we would need to make use of the libidn API. */
|
|
|
|
|
ret = getaddrinfo (name, *portstr? portstr : NULL, &hints, &aibuf);
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
aibuf = NULL;
|
2015-10-24 16:27:47 +02:00
|
|
|
|
err = map_eai_to_gpg_error (ret);
|
2015-10-25 16:38:07 +01:00
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_NAME)
|
|
|
|
|
{
|
|
|
|
|
/* There seems to be a bug in the glibc getaddrinfo function
|
|
|
|
|
if the CNAME points to a long list of A and AAAA records
|
|
|
|
|
in which case the function return NO_NAME. Let's do the
|
|
|
|
|
CNAME redirection again. */
|
|
|
|
|
char *cname;
|
|
|
|
|
|
|
|
|
|
if (get_dns_cname (name, &cname))
|
|
|
|
|
goto leave; /* Still no success. */
|
|
|
|
|
|
|
|
|
|
ret = getaddrinfo (cname, *portstr? portstr : NULL, &hints, &aibuf);
|
|
|
|
|
xfree (cname);
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
aibuf = NULL;
|
|
|
|
|
err = map_eai_to_gpg_error (ret);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
err = 0; /* Yep, now it worked. */
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
goto leave;
|
2015-10-21 17:55:56 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (r_canonname && aibuf && aibuf->ai_canonname)
|
|
|
|
|
{
|
|
|
|
|
*r_canonname = xtrystrdup (aibuf->ai_canonname);
|
|
|
|
|
if (!*r_canonname)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (ai = aibuf; ai; ai = ai->ai_next)
|
|
|
|
|
{
|
|
|
|
|
if (ai->ai_family != AF_INET6 && ai->ai_family != AF_INET)
|
|
|
|
|
continue;
|
2017-01-24 16:36:28 +01:00
|
|
|
|
if (opt_disable_ipv4 && ai->ai_family == AF_INET)
|
|
|
|
|
continue;
|
2017-04-03 20:56:12 +02:00
|
|
|
|
if (opt_disable_ipv6 && ai->ai_family == AF_INET6)
|
|
|
|
|
continue;
|
2015-10-21 17:55:56 +02:00
|
|
|
|
|
2017-04-13 14:33:33 +09:00
|
|
|
|
dai = xtrymalloc (sizeof *dai);
|
2015-10-21 17:55:56 +02:00
|
|
|
|
dai->family = ai->ai_family;
|
|
|
|
|
dai->socktype = ai->ai_socktype;
|
|
|
|
|
dai->protocol = ai->ai_protocol;
|
|
|
|
|
dai->addrlen = ai->ai_addrlen;
|
|
|
|
|
memcpy (dai->addr, ai->ai_addr, ai->ai_addrlen);
|
|
|
|
|
dai->next = daihead;
|
|
|
|
|
daihead = dai;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
if (aibuf)
|
|
|
|
|
freeaddrinfo (aibuf);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
if (r_canonname)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_canonname);
|
|
|
|
|
*r_canonname = NULL;
|
|
|
|
|
}
|
|
|
|
|
free_dns_addrinfo (daihead);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*r_dai = daihead;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-16 19:03:39 +01:00
|
|
|
|
/* This a wrapper around getaddrinfo with slightly different semantics.
|
|
|
|
|
NAME is the name to resolve.
|
|
|
|
|
PORT is the requested port or 0.
|
|
|
|
|
WANT_FAMILY is either 0 (AF_UNSPEC), AF_INET6, or AF_INET4.
|
|
|
|
|
WANT_SOCKETTYPE is either SOCK_STREAM or SOCK_DGRAM.
|
|
|
|
|
|
|
|
|
|
On success the result is stored in a linked list with the head
|
|
|
|
|
stored at the address R_AI; the caller must call gpg_addrinfo_free
|
|
|
|
|
on this. If R_CANONNAME is not NULL the official name of the host
|
|
|
|
|
is stored there as a malloced string; if that name is not available
|
|
|
|
|
NULL is stored. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
resolve_dns_name (const char *name, unsigned short port,
|
|
|
|
|
int want_family, int want_socktype,
|
|
|
|
|
dns_addrinfo_t *r_ai, char **r_canonname)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
if (!standard_resolver)
|
|
|
|
|
{
|
|
|
|
|
err = resolve_name_libdns (name, port, want_family, want_socktype,
|
|
|
|
|
r_ai, r_canonname);
|
|
|
|
|
if (err && libdns_switch_port_p (err))
|
|
|
|
|
err = resolve_name_libdns (name, port, want_family, want_socktype,
|
|
|
|
|
r_ai, r_canonname);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
err = resolve_name_standard (name, port, want_family, want_socktype,
|
|
|
|
|
r_ai, r_canonname);
|
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: resolve_dns_name(%s): %s\n", name, gpg_strerror (err));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef USE_LIBDNS
|
|
|
|
|
/* Resolve an address using libdns. */
|
|
|
|
|
static gpg_error_t
|
2017-04-13 14:33:33 +09:00
|
|
|
|
resolve_addr_libdns (const struct sockaddr_storage *addr, int addrlen,
|
2017-01-16 19:03:39 +01:00
|
|
|
|
unsigned int flags, char **r_name)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char host[DNS_D_MAXNAME + 1];
|
2017-01-23 16:32:44 +01:00
|
|
|
|
struct dns_resolver *res = NULL;
|
2017-01-16 19:03:39 +01:00
|
|
|
|
struct dns_packet *ans = NULL;
|
|
|
|
|
struct dns_ptr ptr;
|
|
|
|
|
int derr;
|
|
|
|
|
|
|
|
|
|
*r_name = NULL;
|
|
|
|
|
|
|
|
|
|
/* First we turn ADDR into a DNS name (with ".arpa" suffix). */
|
|
|
|
|
err = 0;
|
2017-04-13 14:33:33 +09:00
|
|
|
|
if (addr->ss_family == AF_INET6)
|
2017-01-16 19:03:39 +01:00
|
|
|
|
{
|
|
|
|
|
const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *)addr;
|
|
|
|
|
if (!dns_aaaa_arpa (host, sizeof host, (void*)&a6->sin6_addr))
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_OBJ);
|
|
|
|
|
}
|
2017-04-13 14:33:33 +09:00
|
|
|
|
else if (addr->ss_family == AF_INET)
|
2017-01-16 19:03:39 +01:00
|
|
|
|
{
|
|
|
|
|
const struct sockaddr_in *a4 = (const struct sockaddr_in *)addr;
|
|
|
|
|
if (!dns_a_arpa (host, sizeof host, (void*)&a4->sin_addr))
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_OBJ);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
err = gpg_error (GPG_ERR_EAFNOSUPPORT);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
err = libdns_res_open (&res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
err = libdns_res_submit (res, host, DNS_T_PTR, DNS_C_IN);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
err = libdns_res_wait (res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
ans = dns_res_fetch (res, &derr);
|
|
|
|
|
if (!ans)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the rcode. */
|
|
|
|
|
switch (dns_p_rcode (ans))
|
|
|
|
|
{
|
|
|
|
|
case DNS_RC_NOERROR:
|
|
|
|
|
break;
|
|
|
|
|
case DNS_RC_NXDOMAIN:
|
|
|
|
|
err = gpg_error (GPG_ERR_NO_NAME);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
err = GPG_ERR_SERVER_FAILED;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Parse the result. */
|
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
struct dns_rr rr;
|
|
|
|
|
struct dns_rr_i rri;
|
|
|
|
|
|
|
|
|
|
memset (&rri, 0, sizeof rri);
|
|
|
|
|
dns_rr_i_init (&rri, ans);
|
|
|
|
|
rri.section = DNS_S_ALL & ~DNS_S_QD;
|
|
|
|
|
rri.name = host;
|
|
|
|
|
rri.type = DNS_T_PTR;
|
|
|
|
|
|
|
|
|
|
if (!dns_rr_grep (&rr, 1, &rri, ans, &derr))
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = libdns_error_to_gpg_error (dns_ptr_parse (&ptr, &rr, ans));
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Copy result. */
|
|
|
|
|
*r_name = xtrystrdup (ptr.host);
|
|
|
|
|
if (!*r_name)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
/* Libdns appends the root zone part which is problematic
|
|
|
|
|
* for most other functions - strip it. */
|
|
|
|
|
if (**r_name && (*r_name)[strlen (*r_name)-1] == '.')
|
|
|
|
|
(*r_name)[strlen (*r_name)-1] = 0;
|
|
|
|
|
}
|
|
|
|
|
else /* GPG_ERR_NO_NAME */
|
|
|
|
|
{
|
|
|
|
|
char *buffer, *p;
|
|
|
|
|
int buflen;
|
|
|
|
|
int ec;
|
|
|
|
|
|
|
|
|
|
buffer = ptr.host;
|
|
|
|
|
buflen = sizeof ptr.host;
|
|
|
|
|
|
|
|
|
|
p = buffer;
|
2017-04-13 14:33:33 +09:00
|
|
|
|
if (addr->ss_family == AF_INET6 && (flags & DNS_WITHBRACKET))
|
2017-01-16 19:03:39 +01:00
|
|
|
|
{
|
|
|
|
|
*p++ = '[';
|
|
|
|
|
buflen -= 2;
|
|
|
|
|
}
|
2017-04-13 14:33:33 +09:00
|
|
|
|
ec = getnameinfo ((const struct sockaddr *)addr,
|
|
|
|
|
addrlen, p, buflen, NULL, 0, NI_NUMERICHOST);
|
2017-01-16 19:03:39 +01:00
|
|
|
|
if (ec)
|
|
|
|
|
{
|
|
|
|
|
err = map_eai_to_gpg_error (ec);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2017-04-13 14:33:33 +09:00
|
|
|
|
if (addr->ss_family == AF_INET6 && (flags & DNS_WITHBRACKET))
|
2017-01-16 19:03:39 +01:00
|
|
|
|
strcat (buffer, "]");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
dns_free (ans);
|
|
|
|
|
dns_res_close (res);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
#endif /*USE_LIBDNS*/
|
|
|
|
|
|
|
|
|
|
|
2015-10-24 16:27:47 +02:00
|
|
|
|
/* Resolve an address using the standard system function. */
|
|
|
|
|
static gpg_error_t
|
2017-04-13 14:33:33 +09:00
|
|
|
|
resolve_addr_standard (const struct sockaddr_storage *addr, int addrlen,
|
2015-10-24 16:27:47 +02:00
|
|
|
|
unsigned int flags, char **r_name)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int ec;
|
|
|
|
|
char *buffer, *p;
|
|
|
|
|
int buflen;
|
|
|
|
|
|
|
|
|
|
*r_name = NULL;
|
|
|
|
|
|
|
|
|
|
buflen = NI_MAXHOST;
|
|
|
|
|
buffer = xtrymalloc (buflen + 2 + 1);
|
|
|
|
|
if (!buffer)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
|
|
|
|
|
if ((flags & DNS_NUMERICHOST) || tor_mode)
|
|
|
|
|
ec = EAI_NONAME;
|
|
|
|
|
else
|
2017-04-13 14:33:33 +09:00
|
|
|
|
ec = getnameinfo ((const struct sockaddr *)addr,
|
|
|
|
|
addrlen, buffer, buflen, NULL, 0, NI_NAMEREQD);
|
2015-10-24 16:27:47 +02:00
|
|
|
|
|
|
|
|
|
if (!ec && *buffer == '[')
|
|
|
|
|
ec = EAI_FAIL; /* A name may never start with a bracket. */
|
|
|
|
|
else if (ec == EAI_NONAME)
|
|
|
|
|
{
|
|
|
|
|
p = buffer;
|
2017-04-13 14:33:33 +09:00
|
|
|
|
if (addr->ss_family == AF_INET6 && (flags & DNS_WITHBRACKET))
|
2015-10-24 16:27:47 +02:00
|
|
|
|
{
|
|
|
|
|
*p++ = '[';
|
|
|
|
|
buflen -= 2;
|
|
|
|
|
}
|
2017-04-13 14:33:33 +09:00
|
|
|
|
ec = getnameinfo ((const struct sockaddr *)addr,
|
|
|
|
|
addrlen, p, buflen, NULL, 0, NI_NUMERICHOST);
|
|
|
|
|
if (!ec && addr->ss_family == AF_INET6 && (flags & DNS_WITHBRACKET))
|
2015-10-24 16:27:47 +02:00
|
|
|
|
strcat (buffer, "]");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ec)
|
|
|
|
|
err = map_eai_to_gpg_error (ec);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
p = xtryrealloc (buffer, strlen (buffer)+1);
|
|
|
|
|
if (!p)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
buffer = p;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
else
|
|
|
|
|
*r_name = buffer;
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-16 19:03:39 +01:00
|
|
|
|
/* A wrapper around getnameinfo. */
|
2015-10-21 17:55:56 +02:00
|
|
|
|
gpg_error_t
|
2017-04-13 14:33:33 +09:00
|
|
|
|
resolve_dns_addr (const struct sockaddr_storage *addr, int addrlen,
|
2017-01-16 19:03:39 +01:00
|
|
|
|
unsigned int flags, char **r_name)
|
2015-10-21 17:55:56 +02:00
|
|
|
|
{
|
2016-12-19 23:27:02 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2017-01-16 19:03:39 +01:00
|
|
|
|
/* Note that we divert to the standard resolver for NUMERICHOST. */
|
|
|
|
|
if (!standard_resolver && !(flags & DNS_NUMERICHOST))
|
2016-12-16 21:56:23 +01:00
|
|
|
|
{
|
2017-01-16 19:03:39 +01:00
|
|
|
|
err = resolve_addr_libdns (addr, addrlen, flags, r_name);
|
2016-12-16 21:56:23 +01:00
|
|
|
|
if (err && libdns_switch_port_p (err))
|
2017-01-16 19:03:39 +01:00
|
|
|
|
err = resolve_addr_libdns (addr, addrlen, flags, r_name);
|
2016-12-16 21:56:23 +01:00
|
|
|
|
}
|
2016-12-19 23:27:02 +01:00
|
|
|
|
else
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2017-01-16 19:03:39 +01:00
|
|
|
|
err = resolve_addr_standard (addr, addrlen, flags, r_name);
|
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
if (opt_debug)
|
2017-01-16 19:03:39 +01:00
|
|
|
|
log_debug ("dns: resolve_dns_addr(): %s\n", gpg_strerror (err));
|
2016-12-19 23:27:02 +01:00
|
|
|
|
return err;
|
2015-10-21 17:55:56 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-12 21:09:42 +01:00
|
|
|
|
/* Check whether NAME is an IP address. Returns a true if it is
|
|
|
|
|
* either an IPv6 or a IPv4 numerical address. The actual return
|
|
|
|
|
* values can also be used to identify whether it is v4 or v6: The
|
|
|
|
|
* true value will surprisingly be 4 for IPv4 and 6 for IPv6. */
|
2015-10-24 16:27:47 +02:00
|
|
|
|
int
|
|
|
|
|
is_ip_address (const char *name)
|
|
|
|
|
{
|
|
|
|
|
const char *s;
|
|
|
|
|
int ndots, dblcol, n;
|
|
|
|
|
|
|
|
|
|
if (*name == '[')
|
2017-01-12 21:09:42 +01:00
|
|
|
|
return 6; /* yes: A legal DNS name may not contain this character;
|
2017-02-15 19:17:08 +01:00
|
|
|
|
this must be bracketed v6 address. */
|
2015-10-24 16:27:47 +02:00
|
|
|
|
if (*name == '.')
|
|
|
|
|
return 0; /* No. A leading dot is not a valid IP address. */
|
|
|
|
|
|
|
|
|
|
/* Check whether this is a v6 address. */
|
|
|
|
|
ndots = n = dblcol = 0;
|
|
|
|
|
for (s=name; *s; s++)
|
|
|
|
|
{
|
|
|
|
|
if (*s == ':')
|
|
|
|
|
{
|
|
|
|
|
ndots++;
|
|
|
|
|
if (s[1] == ':')
|
|
|
|
|
{
|
|
|
|
|
ndots++;
|
|
|
|
|
if (dblcol)
|
|
|
|
|
return 0; /* No: Only one "::" allowed. */
|
|
|
|
|
dblcol++;
|
|
|
|
|
if (s[1])
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
n = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (*s == '.')
|
|
|
|
|
goto legacy;
|
|
|
|
|
else if (!strchr ("0123456789abcdefABCDEF", *s))
|
|
|
|
|
return 0; /* No: Not a hex digit. */
|
|
|
|
|
else if (++n > 4)
|
|
|
|
|
return 0; /* To many digits in a group. */
|
|
|
|
|
}
|
|
|
|
|
if (ndots > 7)
|
|
|
|
|
return 0; /* No: Too many colons. */
|
|
|
|
|
else if (ndots > 1)
|
2017-01-12 21:09:42 +01:00
|
|
|
|
return 6; /* Yes: At least 2 colons indicate an v6 address. */
|
2015-10-24 16:27:47 +02:00
|
|
|
|
|
|
|
|
|
legacy:
|
|
|
|
|
/* Check whether it is legacy IP address. */
|
|
|
|
|
ndots = n = 0;
|
|
|
|
|
for (s=name; *s; s++)
|
|
|
|
|
{
|
|
|
|
|
if (*s == '.')
|
|
|
|
|
{
|
|
|
|
|
if (s[1] == '.')
|
2017-02-01 08:18:44 +01:00
|
|
|
|
return 0; /* No: Double dot. */
|
2015-10-24 16:27:47 +02:00
|
|
|
|
if (atoi (s+1) > 255)
|
|
|
|
|
return 0; /* No: Ipv4 byte value too large. */
|
|
|
|
|
ndots++;
|
|
|
|
|
n = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (!strchr ("0123456789", *s))
|
|
|
|
|
return 0; /* No: Not a digit. */
|
|
|
|
|
else if (++n > 3)
|
|
|
|
|
return 0; /* No: More than 3 digits. */
|
|
|
|
|
}
|
2017-01-12 21:09:42 +01:00
|
|
|
|
return (ndots == 3)? 4 : 0;
|
2015-10-24 16:27:47 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-10-26 16:32:03 +01:00
|
|
|
|
/* Return true if NAME is an onion address. */
|
|
|
|
|
int
|
|
|
|
|
is_onion_address (const char *name)
|
|
|
|
|
{
|
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
|
|
len = name? strlen (name) : 0;
|
|
|
|
|
if (len < 8 || strcmp (name + len - 6, ".onion"))
|
|
|
|
|
return 0;
|
|
|
|
|
/* Note that we require at least 2 characters before the suffix. */
|
|
|
|
|
return 1; /* Yes. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-05 17:31:37 +01:00
|
|
|
|
/* libdns version of get_dns_cert. */
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-05 17:31:37 +01:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
get_dns_cert_libdns (const char *name, int want_certtype,
|
|
|
|
|
void **r_key, size_t *r_keylen,
|
|
|
|
|
unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
|
|
|
|
|
{
|
2016-12-14 14:11:33 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct dns_resolver *res = NULL;
|
|
|
|
|
struct dns_packet *ans = NULL;
|
|
|
|
|
struct dns_rr rr;
|
|
|
|
|
struct dns_rr_i rri;
|
|
|
|
|
char host[DNS_D_MAXNAME + 1];
|
|
|
|
|
int derr;
|
|
|
|
|
int qtype;
|
|
|
|
|
|
2017-01-16 19:03:39 +01:00
|
|
|
|
/* Get the query type from WANT_CERTTYPE (which in general indicates
|
2016-12-14 14:11:33 +01:00
|
|
|
|
* the subtype we want). */
|
|
|
|
|
qtype = (want_certtype < DNS_CERTTYPE_RRBASE
|
|
|
|
|
? T_CERT
|
|
|
|
|
: (want_certtype - DNS_CERTTYPE_RRBASE));
|
|
|
|
|
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_open (&res);
|
2016-12-14 14:11:33 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
if (dns_d_anchor (host, sizeof host, name, strlen (name)) >= sizeof host)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_ENAMETOOLONG);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_submit (res, name, qtype, DNS_C_IN);
|
2016-12-14 14:11:33 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_wait (res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-12-14 14:11:33 +01:00
|
|
|
|
|
|
|
|
|
ans = dns_res_fetch (res, &derr);
|
|
|
|
|
if (!ans)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the rcode. */
|
|
|
|
|
switch (dns_p_rcode (ans))
|
|
|
|
|
{
|
|
|
|
|
case DNS_RC_NOERROR: break;
|
|
|
|
|
case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
|
|
|
|
|
default: err = GPG_ERR_SERVER_FAILED; break;
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
memset (&rri, 0, sizeof rri);
|
|
|
|
|
dns_rr_i_init (&rri, ans);
|
|
|
|
|
rri.section = DNS_S_ALL & ~DNS_S_QD;
|
|
|
|
|
rri.name = host;
|
|
|
|
|
rri.type = qtype;
|
|
|
|
|
|
|
|
|
|
err = gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
while (dns_rr_grep (&rr, 1, &rri, ans, &derr))
|
|
|
|
|
{
|
|
|
|
|
unsigned char *rp = ans->data + rr.rd.p;
|
|
|
|
|
unsigned short len = rr.rd.len;
|
|
|
|
|
u16 subtype;
|
|
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
|
{
|
|
|
|
|
/* Definitely too short - skip. */
|
|
|
|
|
}
|
|
|
|
|
else if (want_certtype >= DNS_CERTTYPE_RRBASE
|
|
|
|
|
&& rr.type == (want_certtype - DNS_CERTTYPE_RRBASE)
|
|
|
|
|
&& r_key)
|
|
|
|
|
{
|
|
|
|
|
*r_key = xtrymalloc (len);
|
|
|
|
|
if (!*r_key)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*r_key, rp, len);
|
|
|
|
|
*r_keylen = len;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else if (want_certtype >= DNS_CERTTYPE_RRBASE)
|
|
|
|
|
{
|
|
|
|
|
/* We did not found the requested RR - skip. */
|
|
|
|
|
}
|
|
|
|
|
else if (rr.type == T_CERT && len > 5)
|
|
|
|
|
{
|
|
|
|
|
/* We got a CERT type. */
|
|
|
|
|
subtype = buf16_to_u16 (rp);
|
|
|
|
|
rp += 2; len -= 2;
|
|
|
|
|
|
|
|
|
|
/* Skip the CERT key tag and algo which we don't need. */
|
|
|
|
|
rp += 3; len -= 3;
|
|
|
|
|
|
|
|
|
|
if (want_certtype && want_certtype != subtype)
|
|
|
|
|
; /* Not the requested subtype - skip. */
|
|
|
|
|
else if (subtype == DNS_CERTTYPE_PGP && len && r_key && r_keylen)
|
|
|
|
|
{
|
|
|
|
|
/* PGP subtype */
|
|
|
|
|
*r_key = xtrymalloc (len);
|
|
|
|
|
if (!*r_key)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*r_key, rp, len);
|
|
|
|
|
*r_keylen = len;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else if (subtype == DNS_CERTTYPE_IPGP
|
|
|
|
|
&& len && len < 1023 && len >= rp[0] + 1)
|
|
|
|
|
{
|
|
|
|
|
/* IPGP type */
|
|
|
|
|
*r_fprlen = rp[0];
|
|
|
|
|
if (*r_fprlen)
|
|
|
|
|
{
|
|
|
|
|
*r_fpr = xtrymalloc (*r_fprlen);
|
|
|
|
|
if (!*r_fpr)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
memcpy (*r_fpr, rp+1, *r_fprlen);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*r_fpr = NULL;
|
|
|
|
|
|
|
|
|
|
if (len > *r_fprlen + 1)
|
|
|
|
|
{
|
|
|
|
|
*r_url = xtrymalloc (len - (*r_fprlen + 1) + 1);
|
|
|
|
|
if (!*r_url)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
xfree (*r_fpr);
|
|
|
|
|
*r_fpr = NULL;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
memcpy (*r_url, rp + *r_fprlen + 1, len - (*r_fprlen + 1));
|
|
|
|
|
(*r_url)[len - (*r_fprlen + 1)] = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*r_url = NULL;
|
|
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Unknown subtype or record too short - skip. */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Not a requested type - skip. */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
dns_free (ans);
|
|
|
|
|
dns_res_close (res);
|
|
|
|
|
return err;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
/* Standard resolver version of get_dns_cert. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
get_dns_cert_standard (const char *name, int want_certtype,
|
|
|
|
|
void **r_key, size_t *r_keylen,
|
|
|
|
|
unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_SYSTEM_RESOLVER
|
2011-11-30 17:14:08 +01:00
|
|
|
|
gpg_error_t err;
|
2006-06-16 11:49:27 +00:00
|
|
|
|
unsigned char *answer;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
int r;
|
2006-06-16 11:49:27 +00:00
|
|
|
|
u16 count;
|
|
|
|
|
|
2011-11-30 17:14:08 +01:00
|
|
|
|
/* Allocate a 64k buffer which is the limit for an DNS response. */
|
|
|
|
|
answer = xtrymalloc (65536);
|
|
|
|
|
if (!answer)
|
2015-10-28 08:55:01 +01:00
|
|
|
|
return gpg_error_from_syserror ();
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error (GPG_ERR_NOT_FOUND);
|
2015-10-06 19:57:00 +02:00
|
|
|
|
r = res_query (name, C_IN,
|
|
|
|
|
(want_certtype < DNS_CERTTYPE_RRBASE
|
|
|
|
|
? T_CERT
|
|
|
|
|
: (want_certtype - DNS_CERTTYPE_RRBASE)),
|
|
|
|
|
answer, 65536);
|
2006-06-16 11:49:27 +00:00
|
|
|
|
/* Not too big, not too small, no errors and at least 1 answer. */
|
2011-11-30 17:14:08 +01:00
|
|
|
|
if (r >= sizeof (HEADER) && r <= 65536
|
2016-02-15 10:55:34 +09:00
|
|
|
|
&& (((HEADER *)(void *) answer)->rcode) == NOERROR
|
|
|
|
|
&& (count = ntohs (((HEADER *)(void *) answer)->ancount)))
|
2006-06-16 11:49:27 +00:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
unsigned char *pt, *emsg;
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2011-11-28 18:35:19 +01:00
|
|
|
|
emsg = &answer[r];
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
2011-11-28 18:35:19 +01:00
|
|
|
|
pt = &answer[sizeof (HEADER)];
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
|
|
|
|
/* Skip over the query */
|
|
|
|
|
|
2011-11-28 18:35:19 +01:00
|
|
|
|
rc = dn_skipname (pt, emsg);
|
|
|
|
|
if (rc == -1)
|
2011-11-30 17:14:08 +01:00
|
|
|
|
{
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error (GPG_ERR_INV_OBJ);
|
2011-11-30 17:14:08 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-11-28 18:35:19 +01:00
|
|
|
|
pt += rc + QFIXEDSZ;
|
2006-06-16 11:49:27 +00:00
|
|
|
|
|
|
|
|
|
/* There are several possible response types for a CERT request.
|
2011-11-28 18:35:19 +01:00
|
|
|
|
We're interested in the PGP (a key) and IPGP (a URI) types.
|
|
|
|
|
Skip all others. TODO: A key is better than a URI since
|
|
|
|
|
we've gone through all this bother to fetch it, so favor that
|
|
|
|
|
if we have both PGP and IPGP? */
|
|
|
|
|
|
|
|
|
|
while (count-- > 0 && pt < emsg)
|
|
|
|
|
{
|
|
|
|
|
u16 type, class, dlen, ctype;
|
|
|
|
|
|
|
|
|
|
rc = dn_skipname (pt, emsg); /* the name we just queried for */
|
|
|
|
|
if (rc == -1)
|
2011-11-30 17:14:08 +01:00
|
|
|
|
{
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error (GPG_ERR_INV_OBJ);
|
2011-11-30 17:14:08 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
|
|
|
|
pt += rc;
|
|
|
|
|
|
|
|
|
|
/* Truncated message? 15 bytes takes us to the point where
|
|
|
|
|
we start looking at the ctype. */
|
|
|
|
|
if ((emsg - pt) < 15)
|
|
|
|
|
break;
|
|
|
|
|
|
2015-02-11 10:27:57 +01:00
|
|
|
|
type = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-02-11 10:27:57 +01:00
|
|
|
|
class = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
|
2011-11-28 18:35:19 +01:00
|
|
|
|
if (class != C_IN)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* ttl */
|
|
|
|
|
pt += 4;
|
|
|
|
|
|
|
|
|
|
/* data length */
|
2015-02-11 10:27:57 +01:00
|
|
|
|
dlen = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* Check the type and parse. */
|
2015-10-06 19:57:00 +02:00
|
|
|
|
if (want_certtype >= DNS_CERTTYPE_RRBASE
|
|
|
|
|
&& type == (want_certtype - DNS_CERTTYPE_RRBASE)
|
|
|
|
|
&& r_key)
|
|
|
|
|
{
|
|
|
|
|
*r_key = xtrymalloc (dlen);
|
|
|
|
|
if (!*r_key)
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2015-10-06 19:57:00 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*r_key, pt, dlen);
|
|
|
|
|
*r_keylen = dlen;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else if (want_certtype >= DNS_CERTTYPE_RRBASE)
|
|
|
|
|
{
|
|
|
|
|
/* We did not found the requested RR. */
|
|
|
|
|
pt += dlen;
|
|
|
|
|
}
|
|
|
|
|
else if (type == T_CERT)
|
2011-11-28 18:35:19 +01:00
|
|
|
|
{
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* We got a CERT type. */
|
|
|
|
|
ctype = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* Skip the CERT key tag and algo which we don't need. */
|
|
|
|
|
pt += 3;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
dlen -= 5;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* 15 bytes takes us to here */
|
|
|
|
|
if (want_certtype && want_certtype != ctype)
|
|
|
|
|
; /* Not of the requested certtype. */
|
|
|
|
|
else if (ctype == DNS_CERTTYPE_PGP && dlen && r_key && r_keylen)
|
2015-04-23 15:42:56 +02:00
|
|
|
|
{
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* PGP type */
|
|
|
|
|
*r_key = xtrymalloc (dlen);
|
|
|
|
|
if (!*r_key)
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2015-10-06 17:34:13 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*r_key, pt, dlen);
|
|
|
|
|
*r_keylen = dlen;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
goto leave;
|
2015-04-23 15:42:56 +02:00
|
|
|
|
}
|
2015-10-06 17:34:13 +02:00
|
|
|
|
else if (ctype == DNS_CERTTYPE_IPGP
|
|
|
|
|
&& dlen && dlen < 1023 && dlen >= pt[0] + 1)
|
2011-11-28 18:35:19 +01:00
|
|
|
|
{
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* IPGP type */
|
|
|
|
|
*r_fprlen = pt[0];
|
|
|
|
|
if (*r_fprlen)
|
2011-11-30 17:14:08 +01:00
|
|
|
|
{
|
2015-10-06 17:34:13 +02:00
|
|
|
|
*r_fpr = xtrymalloc (*r_fprlen);
|
|
|
|
|
if (!*r_fpr)
|
|
|
|
|
{
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2015-10-06 17:34:13 +02:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
memcpy (*r_fpr, &pt[1], *r_fprlen);
|
2011-11-30 17:14:08 +01:00
|
|
|
|
}
|
2015-10-06 17:34:13 +02:00
|
|
|
|
else
|
|
|
|
|
*r_fpr = NULL;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
if (dlen > *r_fprlen + 1)
|
2011-11-30 17:14:08 +01:00
|
|
|
|
{
|
2015-10-06 17:34:13 +02:00
|
|
|
|
*r_url = xtrymalloc (dlen - (*r_fprlen + 1) + 1);
|
2016-12-14 14:11:33 +01:00
|
|
|
|
if (!*r_url)
|
2015-10-06 17:34:13 +02:00
|
|
|
|
{
|
2015-10-28 08:55:01 +01:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2015-10-06 17:34:13 +02:00
|
|
|
|
xfree (*r_fpr);
|
|
|
|
|
*r_fpr = NULL;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
memcpy (*r_url, &pt[*r_fprlen + 1],
|
|
|
|
|
dlen - (*r_fprlen + 1));
|
|
|
|
|
(*r_url)[dlen - (*r_fprlen + 1)] = '\0';
|
2011-11-30 17:14:08 +01:00
|
|
|
|
}
|
2015-10-06 17:34:13 +02:00
|
|
|
|
else
|
|
|
|
|
*r_url = NULL;
|
|
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
goto leave;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-10-06 17:34:13 +02:00
|
|
|
|
/* No subtype matches, so continue with the next answer. */
|
|
|
|
|
pt += dlen;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Not a requested type - might be a CNAME. Try next item. */
|
|
|
|
|
pt += dlen;
|
2011-11-28 18:35:19 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2006-06-16 11:49:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-11-30 17:14:08 +01:00
|
|
|
|
leave:
|
2011-11-28 18:35:19 +01:00
|
|
|
|
xfree (answer);
|
2011-11-30 17:14:08 +01:00
|
|
|
|
return err;
|
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
#else /*!HAVE_SYSTEM_RESOLVER*/
|
|
|
|
|
|
2010-03-22 12:46:05 +00:00
|
|
|
|
(void)name;
|
2016-12-01 15:45:51 +01:00
|
|
|
|
(void)want_certtype;
|
|
|
|
|
(void)r_key;
|
|
|
|
|
(void)r_keylen;
|
|
|
|
|
(void)r_fpr;
|
|
|
|
|
(void)r_fprlen;
|
|
|
|
|
(void)r_url;
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_SUPPORTED);
|
|
|
|
|
|
|
|
|
|
#endif /*!HAVE_SYSTEM_RESOLVER*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Returns 0 on success or an error code. If a PGP CERT record was
|
|
|
|
|
found, the malloced data is returned at (R_KEY, R_KEYLEN) and
|
|
|
|
|
the other return parameters are set to NULL/0. If an IPGP CERT
|
|
|
|
|
record was found the fingerprint is stored as an allocated block at
|
2017-02-20 16:19:50 -05:00
|
|
|
|
R_FPR and its length at R_FPRLEN; an URL is allocated as a
|
2016-12-01 15:45:51 +01:00
|
|
|
|
string and returned at R_URL. If WANT_CERTTYPE is 0 this function
|
|
|
|
|
returns the first CERT found with a supported type; it is expected
|
|
|
|
|
that only one CERT record is used. If WANT_CERTTYPE is one of the
|
|
|
|
|
supported certtypes only records with this certtype are considered
|
|
|
|
|
and the first found is returned. (R_KEY,R_KEYLEN) are optional. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
get_dns_cert (const char *name, int want_certtype,
|
|
|
|
|
void **r_key, size_t *r_keylen,
|
|
|
|
|
unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
|
|
|
|
|
{
|
2016-12-19 23:27:02 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
2015-02-25 16:34:19 +01:00
|
|
|
|
if (r_key)
|
|
|
|
|
*r_key = NULL;
|
2015-04-23 15:42:56 +02:00
|
|
|
|
if (r_keylen)
|
2016-09-20 10:19:44 +02:00
|
|
|
|
*r_keylen = 0;
|
2014-02-10 20:14:14 +01:00
|
|
|
|
*r_fpr = NULL;
|
|
|
|
|
*r_fprlen = 0;
|
|
|
|
|
*r_url = NULL;
|
2010-03-22 12:46:05 +00:00
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-01 15:45:51 +01:00
|
|
|
|
if (!standard_resolver)
|
2016-12-16 21:56:23 +01:00
|
|
|
|
{
|
|
|
|
|
err = get_dns_cert_libdns (name, want_certtype, r_key, r_keylen,
|
|
|
|
|
r_fpr, r_fprlen, r_url);
|
|
|
|
|
if (err && libdns_switch_port_p (err))
|
|
|
|
|
err = get_dns_cert_libdns (name, want_certtype, r_key, r_keylen,
|
|
|
|
|
r_fpr, r_fprlen, r_url);
|
|
|
|
|
}
|
2016-12-19 23:27:02 +01:00
|
|
|
|
else
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-19 23:27:02 +01:00
|
|
|
|
err = get_dns_cert_standard (name, want_certtype, r_key, r_keylen,
|
|
|
|
|
r_fpr, r_fprlen, r_url);
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("dns: get_dns_cert(%s): %s\n", name, gpg_strerror (err));
|
|
|
|
|
return err;
|
2006-06-16 11:49:27 +00:00
|
|
|
|
}
|
2015-10-22 09:22:41 +02:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
2015-10-22 09:22:41 +02:00
|
|
|
|
static int
|
|
|
|
|
priosort(const void *a,const void *b)
|
|
|
|
|
{
|
|
|
|
|
const struct srventry *sa=a,*sb=b;
|
|
|
|
|
if(sa->priority>sb->priority)
|
|
|
|
|
return 1;
|
|
|
|
|
else if(sa->priority<sb->priority)
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
/* Libdns based helper for getsrv. Note that it is expected that NULL
|
|
|
|
|
* is stored at the address of LIST and 0 is stored at the address of
|
|
|
|
|
* R_COUNT. */
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-14 10:30:29 +01:00
|
|
|
|
static gpg_error_t
|
2016-12-19 23:27:02 +01:00
|
|
|
|
getsrv_libdns (const char *name, struct srventry **list, unsigned int *r_count)
|
2016-12-05 17:31:37 +01:00
|
|
|
|
{
|
2016-12-14 10:47:53 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct dns_resolver *res = NULL;
|
|
|
|
|
struct dns_packet *ans = NULL;
|
|
|
|
|
struct dns_rr rr;
|
|
|
|
|
struct dns_rr_i rri;
|
|
|
|
|
char host[DNS_D_MAXNAME + 1];
|
|
|
|
|
int derr;
|
2016-12-19 23:27:02 +01:00
|
|
|
|
unsigned int srvcount = 0;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_open (&res);
|
2016-12-14 10:47:53 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
if (dns_d_anchor (host, sizeof host, name, strlen (name)) >= sizeof host)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_ENAMETOOLONG);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_submit (res, name, DNS_T_SRV, DNS_C_IN);
|
2016-12-14 10:47:53 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_wait (res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
|
|
|
|
ans = dns_res_fetch (res, &derr);
|
|
|
|
|
if (!ans)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the rcode. */
|
|
|
|
|
switch (dns_p_rcode (ans))
|
|
|
|
|
{
|
|
|
|
|
case DNS_RC_NOERROR: break;
|
|
|
|
|
case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
|
|
|
|
|
default: err = GPG_ERR_SERVER_FAILED; break;
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
memset (&rri, 0, sizeof rri);
|
|
|
|
|
dns_rr_i_init (&rri, ans);
|
|
|
|
|
rri.section = DNS_S_ALL & ~DNS_S_QD;
|
|
|
|
|
rri.name = host;
|
|
|
|
|
rri.type = DNS_T_SRV;
|
|
|
|
|
|
|
|
|
|
while (dns_rr_grep (&rr, 1, &rri, ans, &derr))
|
|
|
|
|
{
|
|
|
|
|
struct dns_srv dsrv;
|
|
|
|
|
struct srventry *srv;
|
|
|
|
|
struct srventry *newlist;
|
|
|
|
|
|
|
|
|
|
err = libdns_error_to_gpg_error (dns_srv_parse(&dsrv, &rr, ans));
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
newlist = xtryrealloc (*list, (srvcount+1)*sizeof(struct srventry));
|
|
|
|
|
if (!newlist)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
*list = newlist;
|
|
|
|
|
memset (&(*list)[srvcount], 0, sizeof(struct srventry));
|
|
|
|
|
srv = &(*list)[srvcount];
|
|
|
|
|
srvcount++;
|
|
|
|
|
srv->priority = dsrv.priority;
|
|
|
|
|
srv->weight = dsrv.weight;
|
|
|
|
|
srv->port = dsrv.port;
|
|
|
|
|
mem2str (srv->target, dsrv.target, sizeof srv->target);
|
2017-01-08 18:00:38 +01:00
|
|
|
|
/* Libdns appends the root zone part which is problematic for
|
|
|
|
|
* most other functions - strip it. */
|
|
|
|
|
if (*srv->target && (srv->target)[strlen (srv->target)-1] == '.')
|
|
|
|
|
(srv->target)[strlen (srv->target)-1] = 0;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*r_count = srvcount;
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (*list);
|
|
|
|
|
*list = NULL;
|
|
|
|
|
}
|
|
|
|
|
dns_free (ans);
|
|
|
|
|
dns_res_close (res);
|
|
|
|
|
return err;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
/* Standard resolver based helper for getsrv. Note that it is
|
|
|
|
|
* expected that NULL is stored at the address of LIST and 0 is stored
|
|
|
|
|
* at the address of R_COUNT. */
|
2016-12-14 10:47:53 +01:00
|
|
|
|
static gpg_error_t
|
2016-12-19 23:27:02 +01:00
|
|
|
|
getsrv_standard (const char *name,
|
|
|
|
|
struct srventry **list, unsigned int *r_count)
|
2016-12-01 15:45:51 +01:00
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_SYSTEM_RESOLVER
|
|
|
|
|
union {
|
|
|
|
|
unsigned char ans[2048];
|
|
|
|
|
HEADER header[1];
|
|
|
|
|
} res;
|
|
|
|
|
unsigned char *answer = res.ans;
|
|
|
|
|
HEADER *header = res.header;
|
|
|
|
|
unsigned char *pt, *emsg;
|
|
|
|
|
int r, rc;
|
|
|
|
|
u16 dlen;
|
2016-12-19 23:27:02 +01:00
|
|
|
|
unsigned int srvcount = 0;
|
2016-12-01 15:45:51 +01:00
|
|
|
|
u16 count;
|
|
|
|
|
|
|
|
|
|
/* Do not allow a query using the standard resolver in Tor mode. */
|
|
|
|
|
if (tor_mode)
|
2016-12-14 10:30:29 +01:00
|
|
|
|
return gpg_error (GPG_ERR_NOT_ENABLED);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
|
|
|
|
my_unprotect ();
|
2016-12-14 10:30:29 +01:00
|
|
|
|
r = res_query (name, C_IN, T_SRV, answer, sizeof res.ans);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
my_protect ();
|
2016-12-14 10:30:29 +01:00
|
|
|
|
if (r < 0)
|
|
|
|
|
return get_h_errno_as_gpg_error ();
|
|
|
|
|
if (r < sizeof (HEADER))
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
if (r > sizeof res.ans)
|
|
|
|
|
return gpg_error (GPG_ERR_SYSTEM_BUG);
|
|
|
|
|
if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
|
|
|
|
|
return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found. */
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
|
|
|
|
emsg = &answer[r];
|
|
|
|
|
pt = &answer[sizeof(HEADER)];
|
|
|
|
|
|
|
|
|
|
/* Skip over the query */
|
|
|
|
|
rc = dn_skipname (pt, emsg);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
pt += rc + QFIXEDSZ;
|
|
|
|
|
|
|
|
|
|
while (count-- > 0 && pt < emsg)
|
|
|
|
|
{
|
2016-12-14 10:30:29 +01:00
|
|
|
|
struct srventry *srv;
|
2016-12-01 15:45:51 +01:00
|
|
|
|
u16 type, class;
|
|
|
|
|
struct srventry *newlist;
|
|
|
|
|
|
|
|
|
|
newlist = xtryrealloc (*list, (srvcount+1)*sizeof(struct srventry));
|
|
|
|
|
if (!newlist)
|
|
|
|
|
goto fail;
|
|
|
|
|
*list = newlist;
|
|
|
|
|
memset (&(*list)[srvcount], 0, sizeof(struct srventry));
|
|
|
|
|
srv = &(*list)[srvcount];
|
|
|
|
|
srvcount++;
|
|
|
|
|
|
|
|
|
|
rc = dn_skipname (pt, emsg); /* The name we just queried for. */
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
goto fail;
|
|
|
|
|
pt += rc;
|
|
|
|
|
|
|
|
|
|
/* Truncated message? */
|
|
|
|
|
if ((emsg-pt) < 16)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
type = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
/* We asked for SRV and got something else !? */
|
|
|
|
|
if (type != T_SRV)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
class = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
/* We asked for IN and got something else !? */
|
|
|
|
|
if (class != C_IN)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
pt += 4; /* ttl */
|
|
|
|
|
dlen = buf16_to_u16 (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
|
|
|
|
|
srv->priority = buf16_to_ushort (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
srv->weight = buf16_to_ushort (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
srv->port = buf16_to_ushort (pt);
|
|
|
|
|
pt += 2;
|
|
|
|
|
|
|
|
|
|
/* Get the name. 2782 doesn't allow name compression, but
|
|
|
|
|
* dn_expand still works to pull the name out of the packet. */
|
|
|
|
|
rc = dn_expand (answer, emsg, pt, srv->target, sizeof srv->target);
|
|
|
|
|
if (rc == 1 && srv->target[0] == 0) /* "." */
|
|
|
|
|
{
|
|
|
|
|
xfree(*list);
|
|
|
|
|
*list = NULL;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
goto fail;
|
|
|
|
|
pt += rc;
|
|
|
|
|
/* Corrupt packet? */
|
|
|
|
|
if (dlen != rc+6)
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
*r_count = srvcount;
|
|
|
|
|
return 0;
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
xfree (*list);
|
|
|
|
|
*list = NULL;
|
2016-12-14 10:30:29 +01:00
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
|
|
|
|
#else /*!HAVE_SYSTEM_RESOLVER*/
|
|
|
|
|
|
|
|
|
|
(void)name;
|
|
|
|
|
(void)list;
|
2016-12-14 10:30:29 +01:00
|
|
|
|
(void)r_count;
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_SUPPORTED);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
|
|
|
|
#endif /*!HAVE_SYSTEM_RESOLVER*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-01-08 18:04:59 +01:00
|
|
|
|
/* Query a SRV record for SERVICE and PROTO for NAME. If SERVICE is
|
|
|
|
|
* NULL, NAME is expected to contain the full query name. Note that
|
|
|
|
|
* we do not return NONAME but simply store 0 at R_COUNT. On error an
|
|
|
|
|
* error code is returned and 0 stored at R_COUNT. */
|
2016-12-19 23:27:02 +01:00
|
|
|
|
gpg_error_t
|
2017-01-08 18:04:59 +01:00
|
|
|
|
get_dns_srv (const char *name, const char *service, const char *proto,
|
|
|
|
|
struct srventry **list, unsigned int *r_count)
|
2016-12-01 15:45:51 +01:00
|
|
|
|
{
|
2016-12-14 10:30:29 +01:00
|
|
|
|
gpg_error_t err;
|
2017-01-08 18:04:59 +01:00
|
|
|
|
char *namebuffer = NULL;
|
2016-12-19 23:27:02 +01:00
|
|
|
|
unsigned int srvcount;
|
2016-12-01 15:45:51 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
*list = NULL;
|
2016-12-19 23:27:02 +01:00
|
|
|
|
*r_count = 0;
|
2016-12-14 10:30:29 +01:00
|
|
|
|
srvcount = 0;
|
2017-01-08 18:04:59 +01:00
|
|
|
|
|
|
|
|
|
/* If SERVICE is given construct the query from it and PROTO. */
|
|
|
|
|
if (service)
|
|
|
|
|
{
|
|
|
|
|
namebuffer = xtryasprintf ("_%s._%s.%s",
|
|
|
|
|
service, proto? proto:"tcp", name);
|
|
|
|
|
if (!namebuffer)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
name = namebuffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-05 17:31:37 +01:00
|
|
|
|
if (!standard_resolver)
|
2016-12-16 21:56:23 +01:00
|
|
|
|
{
|
|
|
|
|
err = getsrv_libdns (name, list, &srvcount);
|
|
|
|
|
if (err && libdns_switch_port_p (err))
|
|
|
|
|
err = getsrv_libdns (name, list, &srvcount);
|
|
|
|
|
}
|
2016-12-01 15:45:51 +01:00
|
|
|
|
else
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-14 10:30:29 +01:00
|
|
|
|
err = getsrv_standard (name, list, &srvcount);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
if (err)
|
2016-12-19 23:27:02 +01:00
|
|
|
|
{
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_NAME)
|
|
|
|
|
err = 0;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-10-22 09:22:41 +02:00
|
|
|
|
|
|
|
|
|
/* Now we have an array of all the srv records. */
|
|
|
|
|
|
|
|
|
|
/* Order by priority */
|
|
|
|
|
qsort(*list,srvcount,sizeof(struct srventry),priosort);
|
|
|
|
|
|
|
|
|
|
/* For each priority, move the zero-weighted items first. */
|
|
|
|
|
for (i=0; i < srvcount; i++)
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
|
|
|
|
|
for (j=i;j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
|
|
|
|
|
{
|
|
|
|
|
if((*list)[j].weight==0)
|
|
|
|
|
{
|
|
|
|
|
/* Swap j with i */
|
|
|
|
|
if(j!=i)
|
|
|
|
|
{
|
|
|
|
|
struct srventry temp;
|
|
|
|
|
|
|
|
|
|
memcpy (&temp,&(*list)[j],sizeof(struct srventry));
|
|
|
|
|
memcpy (&(*list)[j],&(*list)[i],sizeof(struct srventry));
|
|
|
|
|
memcpy (&(*list)[i],&temp,sizeof(struct srventry));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Run the RFC-2782 weighting algorithm. We don't need very high
|
|
|
|
|
quality randomness for this, so regular libc srand/rand is
|
2015-10-28 10:14:07 +01:00
|
|
|
|
sufficient. */
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
static int done;
|
|
|
|
|
if (!done)
|
|
|
|
|
{
|
|
|
|
|
done = 1;
|
|
|
|
|
srand (time (NULL)*getpid());
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-10-22 09:22:41 +02:00
|
|
|
|
|
|
|
|
|
for (i=0; i < srvcount; i++)
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
float prio_count=0,chose;
|
|
|
|
|
|
|
|
|
|
for (j=i; j < srvcount && (*list)[i].priority == (*list)[j].priority; j++)
|
|
|
|
|
{
|
|
|
|
|
prio_count+=(*list)[j].weight;
|
|
|
|
|
(*list)[j].run_count=prio_count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
chose=prio_count*rand()/RAND_MAX;
|
|
|
|
|
|
|
|
|
|
for (j=i;j<srvcount && (*list)[i].priority==(*list)[j].priority;j++)
|
|
|
|
|
{
|
|
|
|
|
if (chose<=(*list)[j].run_count)
|
|
|
|
|
{
|
|
|
|
|
/* Swap j with i */
|
|
|
|
|
if(j!=i)
|
|
|
|
|
{
|
|
|
|
|
struct srventry temp;
|
|
|
|
|
|
|
|
|
|
memcpy(&temp,&(*list)[j],sizeof(struct srventry));
|
|
|
|
|
memcpy(&(*list)[j],&(*list)[i],sizeof(struct srventry));
|
|
|
|
|
memcpy(&(*list)[i],&temp,sizeof(struct srventry));
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
leave:
|
|
|
|
|
if (opt_debug)
|
|
|
|
|
{
|
|
|
|
|
if (err)
|
|
|
|
|
log_debug ("dns: getsrv(%s): %s\n", name, gpg_strerror (err));
|
|
|
|
|
else
|
|
|
|
|
log_debug ("dns: getsrv(%s) -> %u records\n", name, srvcount);
|
|
|
|
|
}
|
|
|
|
|
if (!err)
|
|
|
|
|
*r_count = srvcount;
|
2017-01-08 18:04:59 +01:00
|
|
|
|
xfree (namebuffer);
|
2016-12-19 23:27:02 +01:00
|
|
|
|
return err;
|
2015-10-22 09:22:41 +02:00
|
|
|
|
}
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
|
|
|
|
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-05 17:31:37 +01:00
|
|
|
|
/* libdns version of get_dns_cname. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
get_dns_cname_libdns (const char *name, char **r_cname)
|
|
|
|
|
{
|
2016-12-14 10:47:53 +01:00
|
|
|
|
gpg_error_t err;
|
2016-12-16 20:09:27 +01:00
|
|
|
|
struct dns_resolver *res;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
struct dns_packet *ans = NULL;
|
|
|
|
|
struct dns_cname cname;
|
|
|
|
|
int derr;
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_open (&res);
|
2016-12-14 10:47:53 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_submit (res, name, DNS_T_CNAME, DNS_C_IN);
|
2016-12-14 10:47:53 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2016-12-16 20:09:27 +01:00
|
|
|
|
err = libdns_res_wait (res);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
|
|
|
|
ans = dns_res_fetch (res, &derr);
|
|
|
|
|
if (!ans)
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the rcode. */
|
|
|
|
|
switch (dns_p_rcode (ans))
|
|
|
|
|
{
|
|
|
|
|
case DNS_RC_NOERROR: break;
|
|
|
|
|
case DNS_RC_NXDOMAIN: err = gpg_error (GPG_ERR_NO_NAME); break;
|
|
|
|
|
default: err = GPG_ERR_SERVER_FAILED; break;
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Parse the result into CNAME. */
|
|
|
|
|
err = libdns_error_to_gpg_error (dns_p_study (ans));
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
if (!dns_d_cname (&cname, sizeof cname, name, strlen (name), ans, &derr))
|
|
|
|
|
{
|
|
|
|
|
err = libdns_error_to_gpg_error (derr);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy result. */
|
|
|
|
|
*r_cname = xtrystrdup (cname.host);
|
|
|
|
|
if (!*r_cname)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2017-01-02 10:00:33 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Libdns appends the root zone part which is problematic
|
|
|
|
|
* for most other functions - strip it. */
|
|
|
|
|
if (**r_cname && (*r_cname)[strlen (*r_cname)-1] == '.')
|
|
|
|
|
(*r_cname)[strlen (*r_cname)-1] = 0;
|
|
|
|
|
}
|
2016-12-14 10:47:53 +01:00
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
dns_free (ans);
|
|
|
|
|
dns_res_close (res);
|
|
|
|
|
return err;
|
2016-12-05 17:31:37 +01:00
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-05 17:31:37 +01:00
|
|
|
|
|
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
/* Standard resolver version of get_dns_cname. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
get_dns_cname_standard (const char *name, char **r_cname)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_SYSTEM_RESOLVER
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int rc;
|
|
|
|
|
union {
|
|
|
|
|
unsigned char ans[2048];
|
|
|
|
|
HEADER header[1];
|
|
|
|
|
} res;
|
|
|
|
|
unsigned char *answer = res.ans;
|
|
|
|
|
HEADER *header = res.header;
|
|
|
|
|
unsigned char *pt, *emsg;
|
|
|
|
|
int r;
|
|
|
|
|
char *cname;
|
|
|
|
|
int cnamesize = 1025;
|
|
|
|
|
u16 count;
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
/* Do not allow a query using the standard resolver in Tor mode. */
|
|
|
|
|
if (tor_mode)
|
|
|
|
|
return -1;
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-14 10:30:29 +01:00
|
|
|
|
my_unprotect ();
|
|
|
|
|
r = res_query (name, C_IN, T_CERT, answer, sizeof res.ans);
|
|
|
|
|
my_protect ();
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return get_h_errno_as_gpg_error ();
|
|
|
|
|
if (r < sizeof (HEADER))
|
2016-12-01 15:45:51 +01:00
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
2016-12-14 10:30:29 +01:00
|
|
|
|
if (r > sizeof res.ans)
|
|
|
|
|
return gpg_error (GPG_ERR_SYSTEM_BUG);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
if (header->rcode != NOERROR || !(count=ntohs (header->ancount)))
|
|
|
|
|
return gpg_error (GPG_ERR_NO_NAME); /* Error or no record found. */
|
|
|
|
|
if (count != 1)
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
|
|
|
|
|
emsg = &answer[r];
|
|
|
|
|
pt = &answer[sizeof(HEADER)];
|
|
|
|
|
rc = dn_skipname (pt, emsg);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
|
|
|
|
|
pt += rc + QFIXEDSZ;
|
|
|
|
|
if (pt >= emsg)
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
|
|
|
|
|
rc = dn_skipname (pt, emsg);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
pt += rc + 2 + 2 + 4;
|
|
|
|
|
if (pt+2 >= emsg)
|
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
|
|
|
|
pt += 2; /* Skip rdlen */
|
|
|
|
|
|
|
|
|
|
cname = xtrymalloc (cnamesize);
|
|
|
|
|
if (!cname)
|
|
|
|
|
return gpg_error_from_syserror ();
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
rc = dn_expand (answer, emsg, pt, cname, cnamesize -1);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
{
|
|
|
|
|
xfree (cname);
|
2015-10-25 16:38:07 +01:00
|
|
|
|
return gpg_error (GPG_ERR_SERVER_FAILED);
|
2016-12-01 15:45:51 +01:00
|
|
|
|
}
|
|
|
|
|
*r_cname = xtryrealloc (cname, strlen (cname)+1);
|
|
|
|
|
if (!*r_cname)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
xfree (cname);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
#else /*!HAVE_SYSTEM_RESOLVER*/
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
(void)name;
|
|
|
|
|
(void)r_cname;
|
2016-12-14 10:30:29 +01:00
|
|
|
|
return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
|
2015-10-25 16:38:07 +01:00
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
#endif /*!HAVE_SYSTEM_RESOLVER*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
gpg_error_t
|
|
|
|
|
get_dns_cname (const char *name, char **r_cname)
|
|
|
|
|
{
|
2016-12-19 23:27:02 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
2016-12-01 15:45:51 +01:00
|
|
|
|
*r_cname = NULL;
|
|
|
|
|
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#ifdef USE_LIBDNS
|
2016-12-01 15:45:51 +01:00
|
|
|
|
if (!standard_resolver)
|
2016-12-16 21:56:23 +01:00
|
|
|
|
{
|
|
|
|
|
err = get_dns_cname_libdns (name, r_cname);
|
|
|
|
|
if (err && libdns_switch_port_p (err))
|
|
|
|
|
err = get_dns_cname_libdns (name, r_cname);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2016-12-14 15:36:25 +01:00
|
|
|
|
#endif /*USE_LIBDNS*/
|
2016-12-01 15:45:51 +01:00
|
|
|
|
|
2016-12-19 23:27:02 +01:00
|
|
|
|
err = get_dns_cname_standard (name, r_cname);
|
|
|
|
|
if (opt_debug)
|
|
|
|
|
log_debug ("get_dns_cname(%s)%s%s\n", name,
|
|
|
|
|
err ? ": " : " -> ",
|
|
|
|
|
err ? gpg_strerror (err) : *r_cname);
|
|
|
|
|
return err;
|
2015-10-25 16:38:07 +01:00
|
|
|
|
}
|