No OneTemporary
Actions

Size

81 KB

Subscribers

None

View Options

	diff --git a/dirmngr/dns-stuff.c b/dirmngr/dns-stuff.c
	index 70554f6f3..6849af4be 100644
	--- a/dirmngr/dns-stuff.c
	+++ b/dirmngr/dns-stuff.c
	@@ -1,1374 +1,1396 @@
	/* dns-stuff.c - DNS related code including CERT RR (rfc-4398)
	* Copyright (C) 2003, 2005, 2006, 2009 Free Software Foundation, Inc.
	* Copyright (C) 2005, 2006, 2009, 2015 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* This file is free software; you can redistribute it and/or modify
	* it under the terms of either
	*
	* - 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,
	* 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 <https://www.gnu.org/licenses/>.
	*/

	#include <config.h>
	#include <sys/types.h>
	#ifdef HAVE_W32_SYSTEM
	# ifdef HAVE_WINSOCK2_H
	# include <winsock2.h>
	# endif
	# include <windows.h>
	#else
	# include <netinet/in.h>
	# include <arpa/nameser.h>
	# include <resolv.h>
	# include <netdb.h>
	#endif
	#include <string.h>
	#include <unistd.h>
	#ifdef USE_ADNS
	# include <adns.h>
	#endif

	#if !defined(HAVE_GETADDRINFO) && !defined(USE_ADNS)
	# error Either getaddrinfo or the ADNS library is required.
	#endif

	#ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth. */
	# undef USE_NPTH
	#endif
	#ifdef USE_NPTH
	# include <npth.h>
	#endif

	#include "util.h"
	#include "host2net.h"
	#include "dns-stuff.h"

	#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

	/* We allow the use of 0 instead of AF_UNSPEC - check this assumption. */
	#if AF_UNSPEC != 0
	# error AF_UNSPEC does not have the value 0
	#endif

	/* Windows does not support the AI_ADDRCONFIG flag - use zero instead. */
	#ifndef AI_ADDRCONFIG
	# define AI_ADDRCONFIG 0
	#endif

	/* Provide a replacement function for older ADNS versions. */
	#ifndef HAVE_ADNS_FREE
	# define adns_free(a) free ((a))
	#endif

	/* Not every installation has gotten around to supporting SRVs or
	CERTs yet... */
	#ifndef T_SRV
	#define T_SRV 33
	#endif
	#ifndef T_CERT
	# define T_CERT 37
	#endif

	/* ADNS has no support for CERT yet. */
	#define my_adns_r_cert 37


	/* The default nameserver used with ADNS in Tor mode. */
	#define DEFAULT_NAMESERVER "8.8.8.8"


	/* If set Tor mode shall be used. */
	static int tor_mode;

	/* 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];

	/* A string to hold the credentials presented to Tor. */
	#ifdef USE_ADNS
	static char tor_credentials[50];
	#endif

	/* Sets the module in Tor mode. Returns 0 is this is possible or an
	error code. */
	gpg_error_t
	enable_dns_tormode (int new_circuit)
	{
	(void) new_circuit;

	#if defined(USE_DNS_CERT) && defined(USE_ADNS)
	# if HAVE_ADNS_IF_TORMODE
	if (!*tor_credentials \|\| new_circuit)
	{
	static unsigned int counter;

	gpgrt_snprintf (tor_credentials, sizeof tor_credentials,
	"dirmngr-%lu:p%u",
	(unsigned long)getpid (), counter);
	counter++;
	}
	tor_mode = 1;
	return 0;
	# endif
	#endif

	return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	}


	/* 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;
	}


	/* 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;
	}
	}


	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;
	#ifdef EAI_NODATA
	case EAI_NODATA: err = gpg_error (GPG_ERR_NO_DATA); break;
	#endif
	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;
	#ifndef HAVE_W32_SYSTEM
	# ifdef EAI_ADDRFAMILY
	case EAI_ADDRFAMILY:err = gpg_error (GPG_ERR_EADDRNOTAVAIL); break;
	# endif
	case EAI_SYSTEM: err = gpg_error_from_syserror (); break;
	#endif
	default: err = gpg_error (GPG_ERR_UNKNOWN_ERRNO); break;
	}
	return err;
	}

	+#ifdef USE_ADNS
	+static gpg_error_t
	+map_adns_status_to_gpg_error (adns_status status)
	+{
	+ gpg_err_code_t ec;
	+
	+ switch (status)
	+ {
	+ /* case adns_s_netunreach: ec = GPG_ERR_ENETUNREACH; break; */
	+ default: ec = GPG_ERR_GENERAL; break;
	+ }
	+ return gpg_error (ec);
	+}
	+#endif /USE_ADNS/
	+

	#ifdef USE_ADNS
	/* Init ADNS and store the new state at R_STATE. Returns 0 on
	success; prints an error message and returns an error code on
	failure. */
	static gpg_error_t
	my_adns_init (adns_state *r_state)
	{
	gpg_error_t err = 0;
	int ret;

	if (tor_mode)
	{
	char *cfgstr;

	if (!*tor_nameserver)
	set_dns_nameserver (NULL);

	cfgstr = xtryasprintf ("nameserver %s\n"
	"options adns_tormode adns_sockscred:%s",
	tor_nameserver, tor_credentials);
	if (!cfgstr)
	err = gpg_error_from_syserror ();
	else
	{
	ret = adns_init_strcfg (r_state, adns_if_debug /adns_if_noerrprint/, NULL, cfgstr);
	if (ret)
	err = gpg_error_from_errno (ret);
	xfree (cfgstr);
	}
	}
	else
	{
	ret = adns_init (r_state, adns_if_noerrprint, NULL);
	if (ret)
	err = gpg_error_from_errno (ret);
	}

	if (err)
	{
	log_error ("error initializing adns: %s\n", gpg_strerror (err));
	return err;
	}
	return 0;
	}
	#endif /USE_ADNS/


	#ifdef USE_ADNS
	/* Resolve a name using the ADNS library. See resolve_dns_name for
	the description. */
	static gpg_error_t
	resolve_name_adns (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;
	int ret;
	dns_addrinfo_t daihead = NULL;
	dns_addrinfo_t dai;
	adns_state state;
	adns_answer *answer = NULL;
	int count;

	(void)want_family;

	*r_dai = NULL;
	if (r_canonname)
	*r_canonname = NULL;

	if (want_socktype != SOCK_STREAM && want_socktype != SOCK_DGRAM)
	return gpg_error (GPG_ERR_ESOCKTNOSUPPORT);

	err = my_adns_init (&state);
	if (err)
	return err;

	my_unprotect ();
	ret = adns_synchronous (state, name, adns_r_addr,
	adns_qf_quoteok_query, &answer);
	my_protect ();
	if (ret)
	{
	err = gpg_error (gpg_err_code_from_errno (ret));
	log_error ("DNS query failed: %s\n", gpg_strerror (err));
	goto leave;
	}

	err = gpg_error (GPG_ERR_NOT_FOUND);
	if (answer->status != adns_s_ok \|\| answer->type != adns_r_addr)
	{
	+ err = map_adns_status_to_gpg_error (answer->status);
	+ if (gpg_err_code (err) == GPG_ERR_GENERAL)
	+ err = gpg_error (GPG_ERR_NOT_FOUND);
	log_error ("DNS query returned an error: %s (%s)\n",
	adns_strerror (answer->status),
	adns_errabbrev (answer->status));
	goto leave;
	}

	if (r_canonname && answer->cname)
	{
	*r_canonname = xtrystrdup (answer->cname);
	if (!*r_canonname)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	for (count = 0; count < answer->nrrs; count++)
	{
	int len;
	adns_rr_addr *addr;

	len = answer->rrs.addr[count].len;
	addr = &answer->rrs.addr[count];
	if (addr->addr.sa.sa_family != AF_INET6
	&& addr->addr.sa.sa_family != AF_INET)
	continue;

	dai = xtrymalloc (sizeof *dai + len - 1);
	if (!dai)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	dai->family = addr->addr.sa.sa_family;
	dai->socktype = want_socktype == SOCK_STREAM? SOCK_STREAM : SOCK_DGRAM;
	dai->protocol = want_socktype == SOCK_STREAM? IPPROTO_TCP : IPPROTO_UDP;
	dai->addrlen = len;
	memcpy (dai->addr, &addr->addr.sa, len);
	((struct sockaddr_in *) dai->addr)->sin_port = htons (port);
	dai->next = daihead;
	daihead = dai;
	err = 0;
	}

	leave:
	adns_free (answer);
	adns_finish (state);
	if (err)
	{
	if (r_canonname)
	{
	xfree (*r_canonname);
	*r_canonname = NULL;
	}
	free_dns_addrinfo (daihead);
	}
	else
	*r_dai = daihead;
	return err;
	}
	#endif /USE_ADNS/


	#ifndef USE_ADNS
	/* 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;
	hints.ai_flags = AI_ADDRCONFIG;
	if (r_canonname)
	hints.ai_flags \|= AI_CANONNAME;

	if (port)
	snprintf (portstr, sizeof portstr, "%hu", port);
	else
	*portstr = 0;

	/* We can't use the the AI_IDN flag because that does the conversion
	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;
	err = map_eai_to_gpg_error (ret);
	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;
	}

	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;

	dai = xtrymalloc (sizeof *dai + ai->ai_addrlen - 1);
	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;
	}
	#endif /!USE_ADNS/


	/* Resolve an address using the standard system function. */
	static gpg_error_t
	resolve_addr_standard (const struct sockaddr *addr, int addrlen,
	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
	ec = getnameinfo (addr, addrlen, buffer, buflen, NULL, 0, NI_NAMEREQD);

	if (!ec && *buffer == '[')
	ec = EAI_FAIL; /* A name may never start with a bracket. */
	else if (ec == EAI_NONAME)
	{
	p = buffer;
	if (addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
	{
	*p++ = '[';
	buflen -= 2;
	}
	ec = getnameinfo (addr, addrlen, p, buflen, NULL, 0, NI_NUMERICHOST);
	if (!ec && addr->sa_family == AF_INET6 && (flags & DNS_WITHBRACKET))
	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;
	}


	/* 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)
	{
	#ifdef USE_ADNS
	return resolve_name_adns (name, port, want_family, want_socktype,
	r_ai, r_canonname);
	#else
	return resolve_name_standard (name, port, want_family, want_socktype,
	r_ai, r_canonname);
	#endif
	}


	gpg_error_t
	resolve_dns_addr (const struct sockaddr *addr, int addrlen,
	unsigned int flags, char **r_name)
	{
	#ifdef USE_ADNS_disabled_for_now
	return resolve_addr_adns (addr, addrlen, flags, r_name);
	#else
	return resolve_addr_standard (addr, addrlen, flags, r_name);
	#endif
	}


	/* Check whether NAME is an IP address. Returns true if it is either
	an IPv6 or IPv4 numerical address. */
	int
	is_ip_address (const char *name)
	{
	const char *s;
	int ndots, dblcol, n;

	if (*name == '[')
	return 1; /* yes: A legal DNS name may not contain this character;
	this mut be bracketed v6 address. */
	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)
	return 1; /* Yes: At least 2 colons indicate an v6 address. */

	legacy:
	/* Check whether it is legacy IP address. */
	ndots = n = 0;
	for (s=name; *s; s++)
	{
	if (*s == '.')
	{
	if (s[1] == '.')
	return 0; /* No: Douple dot. */
	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. */
	}
	return !!(ndots == 3);
	}


	/* 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. */
	}


	/* 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
	R_FPR and its length at R_FPRLEN; an URL is is allocated as a
	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)
	{
	#ifdef USE_DNS_CERT
	#ifdef USE_ADNS
	gpg_error_t err;
	int ret;
	adns_state state;
	adns_answer *answer = NULL;
	unsigned int ctype;
	int count;

	if (r_key)
	*r_key = NULL;
	if (r_keylen)
	*r_keylen = 0;
	*r_fpr = NULL;
	*r_fprlen = 0;
	*r_url = NULL;

	err = my_adns_init (&state);
	if (err)
	return err;

	my_unprotect ();
	ret = adns_synchronous (state, name,
	(adns_r_unknown
	\| (want_certtype < DNS_CERTTYPE_RRBASE
	? my_adns_r_cert
	: (want_certtype - DNS_CERTTYPE_RRBASE))),
	adns_qf_quoteok_query, &answer);
	my_protect ();
	if (ret)
	{
	err = gpg_error (gpg_err_code_from_errno (ret));
	/* log_error ("DNS query failed: %s\n", gpg_strerror (err)); */
	adns_finish (state);
	return err;
	}
	if (answer->status != adns_s_ok)
	{
	/* log_error ("DNS query returned an error: %s (%s)\n", */
	/* adns_strerror (answer->status), */
	/* adns_errabbrev (answer->status)); */
	- err = gpg_error (GPG_ERR_NOT_FOUND);
	+ err = map_adns_status_to_gpg_error (answer->status);
	+ if (gpg_err_code (err) == GPG_ERR_GENERAL)
	+ err = gpg_error (GPG_ERR_NOT_FOUND);
	goto leave;
	}

	err = gpg_error (GPG_ERR_NOT_FOUND);
	for (count = 0; count < answer->nrrs; count++)
	{
	int datalen = answer->rrs.byteblock[count].len;
	const unsigned char *data = answer->rrs.byteblock[count].data;

	/* First check for our generic RR hack. */
	if (datalen
	&& want_certtype >= DNS_CERTTYPE_RRBASE
	&& ((want_certtype - DNS_CERTTYPE_RRBASE)
	== (answer->type & ~adns_r_unknown)))
	{
	/* Found the requested record - return it. */
	*r_key = xtrymalloc (datalen);
	if (!*r_key)
	err = gpg_error_from_syserror ();
	else
	{
	memcpy (*r_key, data, datalen);
	*r_keylen = datalen;
	err = 0;
	}
	goto leave;
	}

	if (datalen < 5)
	continue; /* Truncated CERT record - skip. */

	ctype = buf16_to_uint (data);
	/* (key tag and algorithm fields are not required.) */
	data += 5;
	datalen -= 5;

	if (want_certtype && want_certtype != ctype)
	; /* Not of the requested certtype. */
	else if (ctype == DNS_CERTTYPE_PGP && datalen >= 11 && r_key && r_keylen)
	{
	/* CERT type is PGP. Gpg checks for a minimum length of 11,
	thus we do the same. */
	*r_key = xtrymalloc (datalen);
	if (!*r_key)
	err = gpg_error_from_syserror ();
	else
	{
	memcpy (*r_key, data, datalen);
	*r_keylen = datalen;
	err = 0;
	}
	goto leave;
	}
	else if (ctype == DNS_CERTTYPE_IPGP && datalen && datalen < 1023
	&& datalen >= data[0] + 1 && r_fpr && r_fprlen && r_url)
	{
	/* CERT type is IPGP. We made sure that the data is
	plausible and that the caller requested this
	information. */
	*r_fprlen = data[0];
	if (*r_fprlen)
	{
	r_fpr = xtrymalloc (r_fprlen);
	if (!*r_fpr)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	memcpy (r_fpr, data + 1, r_fprlen);
	}
	else
	*r_fpr = NULL;

	if (datalen > *r_fprlen + 1)
	{
	r_url = xtrymalloc (datalen - (r_fprlen + 1) + 1);
	if (!*r_url)
	{
	err = gpg_error_from_syserror ();
	xfree (*r_fpr);
	*r_fpr = NULL;
	goto leave;
	}
	memcpy (*r_url,
	data + (r_fprlen + 1), datalen - (r_fprlen + 1));
	(r_url)[datalen - (r_fprlen + 1)] = '\0';
	}
	else
	*r_url = NULL;

	err = 0;
	goto leave;
	}
	}

	leave:
	adns_free (answer);
	adns_finish (state);
	return err;

	#else /!USE_ADNS/

	gpg_error_t err;
	unsigned char *answer;
	int r;
	u16 count;

	if (r_key)
	*r_key = NULL;
	if (r_keylen)
	*r_keylen = 0;
	*r_fpr = NULL;
	*r_fprlen = 0;
	*r_url = NULL;

	/* Allocate a 64k buffer which is the limit for an DNS response. */
	answer = xtrymalloc (65536);
	if (!answer)
	return gpg_error_from_syserror ();

	err = gpg_error (GPG_ERR_NOT_FOUND);
	r = res_query (name, C_IN,
	(want_certtype < DNS_CERTTYPE_RRBASE
	? T_CERT
	: (want_certtype - DNS_CERTTYPE_RRBASE)),
	answer, 65536);
	/* Not too big, not too small, no errors and at least 1 answer. */
	if (r >= sizeof (HEADER) && r <= 65536
	&& (((HEADER )(void ) answer)->rcode) == NOERROR
	&& (count = ntohs (((HEADER )(void ) answer)->ancount)))
	{
	int rc;
	unsigned char pt, emsg;

	emsg = &answer[r];

	pt = &answer[sizeof (HEADER)];

	/* Skip over the query */

	rc = dn_skipname (pt, emsg);
	if (rc == -1)
	{
	err = gpg_error (GPG_ERR_INV_OBJ);
	goto leave;
	}
	pt += rc + QFIXEDSZ;

	/* There are several possible response types for a CERT request.
	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)
	{
	err = gpg_error (GPG_ERR_INV_OBJ);
	goto leave;
	}

	pt += rc;

	/* Truncated message? 15 bytes takes us to the point where
	we start looking at the ctype. */
	if ((emsg - pt) < 15)
	break;

	type = buf16_to_u16 (pt);
	pt += 2;

	class = buf16_to_u16 (pt);
	pt += 2;

	if (class != C_IN)
	break;

	/* ttl */
	pt += 4;

	/* data length */
	dlen = buf16_to_u16 (pt);
	pt += 2;

	/* Check the type and parse. */
	if (want_certtype >= DNS_CERTTYPE_RRBASE
	&& type == (want_certtype - DNS_CERTTYPE_RRBASE)
	&& r_key)
	{
	*r_key = xtrymalloc (dlen);
	if (!*r_key)
	err = gpg_error_from_syserror ();
	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)
	{
	/* We got a CERT type. */
	ctype = buf16_to_u16 (pt);
	pt += 2;

	/* Skip the CERT key tag and algo which we don't need. */
	pt += 3;

	dlen -= 5;

	/* 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)
	{
	/* PGP type */
	*r_key = xtrymalloc (dlen);
	if (!*r_key)
	err = gpg_error_from_syserror ();
	else
	{
	memcpy (*r_key, pt, dlen);
	*r_keylen = dlen;
	err = 0;
	}
	goto leave;
	}
	else if (ctype == DNS_CERTTYPE_IPGP
	&& dlen && dlen < 1023 && dlen >= pt[0] + 1)
	{
	/* IPGP type */
	*r_fprlen = pt[0];
	if (*r_fprlen)
	{
	r_fpr = xtrymalloc (r_fprlen);
	if (!*r_fpr)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	memcpy (r_fpr, &pt[1], r_fprlen);
	}
	else
	*r_fpr = NULL;

	if (dlen > *r_fprlen + 1)
	{
	r_url = xtrymalloc (dlen - (r_fprlen + 1) + 1);
	if (!*r_fpr)
	{
	err = gpg_error_from_syserror ();
	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';
	}
	else
	*r_url = NULL;

	err = 0;
	goto leave;
	}

	/* 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;
	}
	}
	}

	leave:
	xfree (answer);
	return err;

	#endif /!USE_ADNS /
	#else /* !USE_DNS_CERT */
	(void)name;
	if (r_key)
	*r_key = NULL;
	if (r_keylen)
	*r_keylen = 0;
	*r_fpr = NULL;
	*r_fprlen = 0;
	*r_url = NULL;

	return gpg_error (GPG_ERR_NOT_SUPPORTED);
	#endif
	}

	#ifdef USE_DNS_SRV
	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;
	}


	int
	getsrv (const char name,struct srventry *list)
	{
	int srvcount=0;
	u16 count;
	int i, rc;

	*list = NULL;

	#ifdef USE_ADNS
	{
	adns_state state;
	adns_answer *answer = NULL;

	if (my_adns_init (&state))
	return -1;

	my_unprotect ();
	rc = adns_synchronous (state, name, adns_r_srv, adns_qf_quoteok_query,
	&answer);
	my_protect ();
	if (rc)
	{
	log_error ("DNS query failed: %s\n", strerror (rc));
	adns_finish (state);
	return -1;
	}
	if (answer->status != adns_s_ok
	\|\| answer->type != adns_r_srv \|\| !answer->nrrs)
	{
	log_error ("DNS query returned an error or no records: %s (%s)\n",
	adns_strerror (answer->status),
	adns_errabbrev (answer->status));
	adns_free (answer);
	adns_finish (state);
	return 0;
	}

	for (count = 0; count < answer->nrrs; count++)
	{
	struct srventry *srv = NULL;
	struct srventry *newlist;

	if (strlen (answer->rrs.srvha[count].ha.host) >= sizeof srv->target)
	{
	log_info ("hostname in SRV record too long - skipped\n");
	continue;
	}

	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++;

	srv->priority = answer->rrs.srvha[count].priority;
	srv->weight = answer->rrs.srvha[count].weight;
	srv->port = answer->rrs.srvha[count].port;
	strcpy (srv->target, answer->rrs.srvha[count].ha.host);
	}

	adns_free (answer);
	adns_finish (state);
	}
	#else /!USE_ADNS/
	{
	union {
	unsigned char ans[2048];
	HEADER header[1];
	} res;
	unsigned char *answer = res.ans;
	HEADER *header = res.header;
	unsigned char pt, emsg;
	int r;
	u16 dlen;

	/* Do not allow a query using the standard resolver in Tor mode. */
	if (tor_mode)
	return -1;

	+ my_unprotect ();
	r = res_query (name, C_IN, T_SRV, answer, sizeof answer);
	+ my_protect ();
	if (r < sizeof (HEADER) \|\| r > sizeof answer
	\|\| header->rcode != NOERROR \|\| !(count=ntohs (header->ancount)))
	return 0; /* Error or no record found. */

	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)
	{
	struct srventry *srv=NULL;
	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;
	}
	}
	#endif /!USE_ADNS/

	/* 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
	sufficient. */

	{
	static int done;
	if (!done)
	{
	done = 1;
	srand (time (NULL)*getpid());
	}
	}

	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;
	}
	}
	}

	return srvcount;

	fail:
	xfree(*list);
	*list=NULL;
	return -1;
	}
	#endif /USE_DNS_SRV/


	gpg_error_t
	get_dns_cname (const char name, char *r_cname)
	{
	gpg_error_t err;
	int rc;

	*r_cname = NULL;

	#ifdef USE_ADNS
	{
	adns_state state;
	adns_answer *answer = NULL;

	if (my_adns_init (&state))
	return gpg_error (GPG_ERR_GENERAL);

	my_unprotect ();
	rc = adns_synchronous (state, name, adns_r_cname, adns_qf_quoteok_query,
	&answer);
	my_protect ();
	if (rc)
	{
	err = gpg_error (gpg_err_code_from_errno (rc));
	log_error ("DNS query failed: %s\n", gpg_strerror (err));
	adns_finish (state);
	return err;
	}
	if (answer->status != adns_s_ok
	\|\| answer->type != adns_r_cname \|\| answer->nrrs != 1)
	{
	- err = gpg_error (GPG_ERR_GENERAL);
	+ err = map_adns_status_to_gpg_error (answer->status);
	log_error ("DNS query returned an error or no records: %s (%s)\n",
	adns_strerror (answer->status),
	adns_errabbrev (answer->status));
	adns_free (answer);
	adns_finish (state);
	return err;
	}
	*r_cname = xtrystrdup (answer->rrs.str[0]);
	if (!*r_cname)
	err = gpg_error_from_syserror ();
	else
	err = 0;

	adns_free (answer);
	adns_finish (state);
	return err;
	}
	#else /!USE_ADNS/
	{
	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;

	/* Do not allow a query using the standard resolver in Tor mode. */
	if (tor_mode)
	return -1;

	r = res_query (name, C_IN, T_CERT, answer, sizeof answer);
	if (r < sizeof (HEADER) \|\| r > sizeof answer)
	return gpg_error (GPG_ERR_SERVER_FAILED);
	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 ();

	rc = dn_expand (answer, emsg, pt, cname, cnamesize -1);
	if (rc == -1)
	{
	xfree (cname);
	return gpg_error (GPG_ERR_SERVER_FAILED);
	}
	*r_cname = xtryrealloc (cname, strlen (cname)+1);
	if (!*r_cname)
	{
	err = gpg_error_from_syserror ();
	xfree (cname);
	return err;
	}
	return 0;
	}
	#endif /!USE_ADNS/
	}
	diff --git a/dirmngr/ks-engine-hkp.c b/dirmngr/ks-engine-hkp.c
	index 853085163..3b5e75d62 100644
	--- a/dirmngr/ks-engine-hkp.c
	+++ b/dirmngr/ks-engine-hkp.c
	@@ -1,1519 +1,1522 @@
	/* ks-engine-hkp.c - HKP keyserver engine
	* Copyright (C) 2011, 2012 Free Software Foundation, Inc.
	* Copyright (C) 2011, 2012, 2014 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* GnuPG 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.
	*
	* GnuPG 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 <https://www.gnu.org/licenses/>.
	*/

	#include <config.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <assert.h>
	#ifdef HAVE_W32_SYSTEM
	# ifdef HAVE_WINSOCK2_H
	# include <winsock2.h>
	# endif
	# include <windows.h>
	#else /!HAVE_W32_SYSTEM/
	# include <sys/types.h>
	# include <sys/socket.h>
	# include <netdb.h>
	#endif /!HAVE_W32_SYSTEM/

	#include "dirmngr.h"
	#include "misc.h"
	#include "userids.h"
	#include "dns-stuff.h"
	#include "ks-engine.h"

	/* Substitutes for missing Mingw macro. The EAI_SYSTEM mechanism
	seems not to be available (probably because there is only one set
	of error codes anyway). For now we use WSAEINVAL. */
	#ifndef EAI_OVERFLOW
	# define EAI_OVERFLOW EAI_FAIL
	#endif
	#ifdef HAVE_W32_SYSTEM
	# ifndef EAI_SYSTEM
	# define EAI_SYSTEM WSAEINVAL
	# endif
	#endif


	/* Number of seconds after a host is marked as resurrected. */
	#define RESURRECT_INTERVAL (36003) / 3 hours */

	/* To match the behaviour of our old gpgkeys helper code we escape
	more characters than actually needed. */
	#define EXTRA_ESCAPE_CHARS "@!\"#$%&'()*+,-./:;<=>?[\\]^_{\|}~"

	/* How many redirections do we allow. */
	#define MAX_REDIRECTS 2

	/* Number of retries done for a dead host etc. */
	#define SEND_REQUEST_RETRIES 3

	/* Objects used to maintain information about hosts. */
	struct hostinfo_s;
	typedef struct hostinfo_s *hostinfo_t;
	struct hostinfo_s
	{
	time_t lastfail; /* Time we tried to connect and failed. */
	time_t lastused; /* Time of last use. */
	int pool; / A -1 terminated array with indices into
	HOSTTABLE or NULL if NAME is not a pool
	name. */
	int poolidx; /* Index into POOL with the used host. -1 if not set. */
	unsigned int v4:1; /* Host supports AF_INET. */
	unsigned int v6:1; /* Host supports AF_INET6. */
	unsigned int onion:1;/* NAME is an onion (Tor HS) address. */
	unsigned int dead:1; /* Host is currently unresponsive. */
	time_t died_at; /* The time the host was marked dead. If this is
	0 the host has been manually marked dead. */
	char cname; / Canonical name of the host. Only set if this
	is a pool. */
	char v4addr; / A string with the v4 IP address of the host.
	NULL if NAME has a numeric IP address or no v4
	address is available. */
	char v6addr; / A string with the v6 IP address of the host.
	NULL if NAME has a numeric IP address or no v6
	address is available. */
	unsigned short port; /* The port used by the host, 0 if unknown. */
	char name[1]; /* The hostname. */
	};


	/* An array of hostinfo_t for all hosts requested by the caller or
	resolved from a pool name and its allocated size.*/
	static hostinfo_t *hosttable;
	static int hosttable_size;

	/* The number of host slots we initially allocate for HOSTTABLE. */
	#define INITIAL_HOSTTABLE_SIZE 10


	/* Create a new hostinfo object, fill in NAME and put it into
	HOSTTABLE. Return the index into hosttable on success or -1 on
	error. */
	static int
	create_new_hostinfo (const char *name)
	{
	hostinfo_t hi, *newtable;
	int newsize;
	int idx, rc;

	hi = xtrymalloc (sizeof *hi + strlen (name));
	if (!hi)
	return -1;
	strcpy (hi->name, name);
	hi->pool = NULL;
	hi->poolidx = -1;
	hi->lastused = (time_t)(-1);
	hi->lastfail = (time_t)(-1);
	hi->v4 = 0;
	hi->v6 = 0;
	hi->onion = 0;
	hi->dead = 0;
	hi->died_at = 0;
	hi->cname = NULL;
	hi->v4addr = NULL;
	hi->v6addr = NULL;
	hi->port = 0;

	/* Add it to the hosttable. */
	for (idx=0; idx < hosttable_size; idx++)
	if (!hosttable[idx])
	{
	hosttable[idx] = hi;
	return idx;
	}
	/* Need to extend the hosttable. */
	newsize = hosttable_size + INITIAL_HOSTTABLE_SIZE;
	newtable = xtryrealloc (hosttable, newsize * sizeof *hosttable);
	if (!newtable)
	{
	xfree (hi);
	return -1;
	}
	hosttable = newtable;
	idx = hosttable_size;
	hosttable_size = newsize;
	rc = idx;
	hosttable[idx++] = hi;
	while (idx < hosttable_size)
	hosttable[idx++] = NULL;

	return rc;
	}


	/* Find the host NAME in our table. Return the index into the
	hosttable or -1 if not found. */
	static int
	find_hostinfo (const char *name)
	{
	int idx;

	for (idx=0; idx < hosttable_size; idx++)
	if (hosttable[idx] && !ascii_strcasecmp (hosttable[idx]->name, name))
	return idx;
	return -1;
	}


	static int
	sort_hostpool (const void xa, const void xb)
	{
	int a = (int )xa;
	int b = (int )xb;

	assert (a >= 0 && a < hosttable_size);
	assert (b >= 0 && b < hosttable_size);
	assert (hosttable[a]);
	assert (hosttable[b]);

	return ascii_strcasecmp (hosttable[a]->name, hosttable[b]->name);
	}


	/* Return true if the host with the hosttable index TBLIDX is in POOL. */
	static int
	host_in_pool_p (int *pool, int tblidx)
	{
	int i, pidx;

	for (i=0; (pidx = pool[i]) != -1; i++)
	if (pidx == tblidx && hosttable[pidx])
	return 1;
	return 0;
	}


	/* Select a random host. Consult TABLE which indices into the global
	hosttable. Returns index into TABLE or -1 if no host could be
	selected. */
	static int
	select_random_host (int *table)
	{
	int *tbl;
	size_t tblsize;
	int pidx, idx;

	/* We create a new table so that we randomly select only from
	currently alive hosts. */
	for (idx=0, tblsize=0; (pidx = table[idx]) != -1; idx++)
	if (hosttable[pidx] && !hosttable[pidx]->dead)
	tblsize++;
	if (!tblsize)
	return -1; /* No hosts. */

	tbl = xtrymalloc (tblsize * sizeof *tbl);
	if (!tbl)
	return -1;
	for (idx=0, tblsize=0; (pidx = table[idx]) != -1; idx++)
	if (hosttable[pidx] && !hosttable[pidx]->dead)
	tbl[tblsize++] = pidx;

	if (tblsize == 1) /* Save a get_uint_nonce. */
	pidx = tbl[0];
	else
	pidx = tbl[get_uint_nonce () % tblsize];

	xfree (tbl);
	return pidx;
	}


	/* Figure out if a set of DNS records looks like a pool. */
	static int
	arecords_is_pool (dns_addrinfo_t aibuf)
	{
	dns_addrinfo_t ai;
	int n_v6, n_v4;

	n_v6 = n_v4 = 0;
	for (ai = aibuf; ai; ai = ai->next)
	{
	if (ai->family == AF_INET6)
	n_v6++;
	else if (ai->family == AF_INET)
	n_v4++;
	}

	return n_v6 > 1 \|\| n_v4 > 1;
	}


	/* Add the host AI under the NAME into the HOSTTABLE. If PORT is not
	zero, it specifies which port to use to talk to the host. If NAME
	specifies a pool (as indicated by IS_POOL), update the given
	reference table accordingly. */
	static void
	add_host (const char *name, int is_pool,
	const dns_addrinfo_t ai, unsigned short port,
	int reftbl, size_t reftblsize, int refidx)
	{
	gpg_error_t tmperr;
	char *tmphost;
	int idx, tmpidx;
	int is_numeric = 0;
	int i;

	idx = find_hostinfo (name);

	if (!is_pool && !is_ip_address (name))
	{
	/* This is a hostname but not a pool. Use the name
	as given without going through resolve_dns_addr. */
	tmphost = xtrystrdup (name);
	if (!tmphost)
	tmperr = gpg_error_from_syserror ();
	else
	tmperr = 0;
	}
	else
	{
	tmperr = resolve_dns_addr (ai->addr, ai->addrlen,
	DNS_WITHBRACKET, &tmphost);
	if (tmphost && is_ip_address (tmphost))
	is_numeric = 1;
	}

	if (tmperr)
	{
	log_info ("resolve_dns_addr failed while checking '%s': %s\n",
	name, gpg_strerror (tmperr));
	}
	else if ((*refidx) + 1 >= reftblsize)
	{
	log_error ("resolve_dns_addr for '%s': '%s'"
	" [index table full - ignored]\n", name, tmphost);
	}
	else
	{
	if (!is_pool && is_ip_address (name))
	/* Update the original entry. */
	tmpidx = idx;
	else
	tmpidx = find_hostinfo (tmphost);
	log_info ("resolve_dns_addr for '%s': '%s'%s\n",
	name, tmphost,
	tmpidx == -1? "" : " [already known]");

	if (tmpidx == -1) /* Create a new entry. */
	tmpidx = create_new_hostinfo (tmphost);

	if (tmpidx == -1)
	{
	log_error ("map_host for '%s' problem: %s - '%s'"
	" [ignored]\n",
	name, strerror (errno), tmphost);
	}
	else /* Set or update the entry. */
	{
	char *ipaddr = NULL;

	if (port)
	hosttable[tmpidx]->port = port;

	if (!is_numeric)
	{
	xfree (tmphost);
	tmperr = resolve_dns_addr (ai->addr, ai->addrlen,
	(DNS_NUMERICHOST
	\| DNS_WITHBRACKET),
	&tmphost);
	if (tmperr)
	log_info ("resolve_dns_addr failed: %s\n",
	gpg_strerror (tmperr));
	else
	{
	ipaddr = tmphost;
	tmphost = NULL;
	}
	}

	if (ai->family == AF_INET6)
	{
	hosttable[tmpidx]->v6 = 1;
	xfree (hosttable[tmpidx]->v6addr);
	hosttable[tmpidx]->v6addr = ipaddr;
	}
	else if (ai->family == AF_INET)
	{
	hosttable[tmpidx]->v4 = 1;
	xfree (hosttable[tmpidx]->v4addr);
	hosttable[tmpidx]->v4addr = ipaddr;
	}
	else
	BUG ();

	for (i=0; i < *refidx; i++)
	if (reftbl[i] == tmpidx)
	break;
	if (!(i < *refidx) && tmpidx != idx)
	reftbl[(*refidx)++] = tmpidx;
	}
	}
	xfree (tmphost);
	}


	/* Map the host name NAME to the actual to be used host name. This
	allows us to manage round robin DNS names. We use our own strategy
	to choose one of the hosts. For example we skip those hosts which
	failed for some time and we stick to one host for a time
	independent of DNS retry times. If FORCE_RESELECT is true a new
	host is always selected. The selected host is stored as a malloced
	string at R_HOST; on error NULL is stored. If we know the port
	used by the selected host, a string representation is written to
	R_PORTSTR, otherwise it is left untouched. If R_HTTPFLAGS is not
	NULL it will receive flags which are to be passed to http_open. If
	R_POOLNAME is not NULL a malloced name of the pool is stored or
	NULL if it is not a pool. */
	static gpg_error_t
	map_host (ctrl_t ctrl, const char *name, int force_reselect,
	char *r_host, char r_portstr,
	unsigned int r_httpflags, char *r_poolname)
	{
	gpg_error_t err = 0;
	hostinfo_t hi;
	int idx;

	*r_host = NULL;
	if (r_httpflags)
	*r_httpflags = 0;
	if (r_poolname)
	*r_poolname = NULL;

	/* No hostname means localhost. */
	if (!name \|\| !*name)
	{
	*r_host = xtrystrdup ("localhost");
	return *r_host? 0 : gpg_error_from_syserror ();
	}

	/* See whether the host is in our table. */
	idx = find_hostinfo (name);
	if (idx == -1 && is_onion_address (name))
	{
	idx = create_new_hostinfo (name);
	if (idx == -1)
	return gpg_error_from_syserror ();
	hi = hosttable[idx];
	hi->onion = 1;
	}
	else if (idx == -1)
	{
	/* We never saw this host. Allocate a new entry. */
	dns_addrinfo_t aibuf, ai;
	int *reftbl;
	size_t reftblsize;
	int refidx;
	int is_pool = 0;
	char *cname;
	#ifdef USE_DNS_SRV
	char *srvrecord;
	struct srventry *srvs;
	int srvscount;
	#endif /* USE_DNS_SRV */

	reftblsize = 100;
	reftbl = xtrymalloc (reftblsize * sizeof *reftbl);
	if (!reftbl)
	return gpg_error_from_syserror ();
	refidx = 0;

	idx = create_new_hostinfo (name);
	if (idx == -1)
	{
	err = gpg_error_from_syserror ();
	xfree (reftbl);
	return err;
	}
	hi = hosttable[idx];

	-#ifdef USE_DNS_SRV
	- /* Check for SRV records. */
	- srvrecord = xtryasprintf ("_hkp._tcp.%s", name);
	- if (srvrecord == NULL)
	- {
	- err = gpg_error_from_syserror ();
	- xfree (reftbl);
	- return err;
	- }
	-
	- srvscount = getsrv (srvrecord, &srvs);
	- xfree (srvrecord);
	- if (srvscount < 0)
	+#ifdef USE_DNS_SRV
	+ if (!is_ip_address (name))
	{
	- err = gpg_error_from_syserror ();
	- xfree (reftbl);
	- return err;
	- }
	-
	- if (srvscount > 0)
	- {
	- int i;
	- is_pool = srvscount > 1;
	+ /* Check for SRV records. */
	+ srvrecord = xtryasprintf ("_hkp._tcp.%s", name);
	+ if (srvrecord == NULL)
	+ {
	+ err = gpg_error_from_syserror ();
	+ xfree (reftbl);
	+ return err;
	+ }

	- for (i = 0; i < srvscount; i++)
	+ srvscount = getsrv (srvrecord, &srvs);
	+ xfree (srvrecord);
	+ if (srvscount < 0)
	{
	- err = resolve_dns_name (srvs[i].target, 0,
	- AF_UNSPEC, SOCK_STREAM,
	- &ai, &cname);
	- if (err)
	- continue;
	- dirmngr_tick (ctrl);
	- add_host (name, is_pool, ai, srvs[i].port,
	- reftbl, reftblsize, &refidx);
	+ err = gpg_error_from_syserror ();
	+ xfree (reftbl);
	+ return err;
	}

	- xfree (srvs);
	+ if (srvscount > 0)
	+ {
	+ int i;
	+ is_pool = srvscount > 1;
	+
	+ for (i = 0; i < srvscount; i++)
	+ {
	+ err = resolve_dns_name (srvs[i].target, 0,
	+ AF_UNSPEC, SOCK_STREAM,
	+ &ai, &cname);
	+ if (err)
	+ continue;
	+ dirmngr_tick (ctrl);
	+ add_host (name, is_pool, ai, srvs[i].port,
	+ reftbl, reftblsize, &refidx);
	+ }
	+
	+ xfree (srvs);
	+ }
	}
	-#endif /* USE_DNS_SRV */
	+#endif /* USE_DNS_SRV */

	/* Find all A records for this entry and put them into the pool
	list - if any. */
	err = resolve_dns_name (name, 0, 0, SOCK_STREAM, &aibuf, &cname);
	if (err)
	{
	log_error ("resolving '%s' failed: %s\n", name, gpg_strerror (err));
	err = 0;
	}
	else
	{
	/* First figure out whether this is a pool. For a pool we
	use a different strategy than for a plain server: We use
	the canonical name of the pool as the virtual host along
	with the IP addresses. If it is not a pool, we use the
	specified name. */
	if (! is_pool)
	is_pool = arecords_is_pool (aibuf);
	if (is_pool && cname)
	{
	hi->cname = cname;
	cname = NULL;
	}

	for (ai = aibuf; ai; ai = ai->next)
	{
	if (ai->family != AF_INET && ai->family != AF_INET6)
	continue;
	dirmngr_tick (ctrl);

	add_host (name, is_pool, ai, 0, reftbl, reftblsize, &refidx);
	}
	}
	reftbl[refidx] = -1;
	xfree (cname);
	free_dns_addrinfo (aibuf);

	if (refidx && is_pool)
	{
	assert (!hi->pool);
	hi->pool = xtryrealloc (reftbl, (refidx+1) * sizeof *reftbl);
	if (!hi->pool)
	{
	err = gpg_error_from_syserror ();
	log_error ("shrinking index table in map_host failed: %s\n",
	gpg_strerror (err));
	xfree (reftbl);
	return err;
	}
	qsort (hi->pool, refidx, sizeof *reftbl, sort_hostpool);
	}
	else
	xfree (reftbl);
	}

	hi = hosttable[idx];
	if (hi->pool)
	{
	/* Deal with the pool name before selecting a host. */
	if (r_poolname)
	{
	*r_poolname = xtrystrdup (hi->cname? hi->cname : hi->name);
	if (!*r_poolname)
	return gpg_error_from_syserror ();
	}

	/* If the currently selected host is now marked dead, force a
	re-selection . */
	if (force_reselect)
	hi->poolidx = -1;
	else if (hi->poolidx >= 0 && hi->poolidx < hosttable_size
	&& hosttable[hi->poolidx] && hosttable[hi->poolidx]->dead)
	hi->poolidx = -1;

	/* Select a host if needed. */
	if (hi->poolidx == -1)
	{
	hi->poolidx = select_random_host (hi->pool);
	if (hi->poolidx == -1)
	{
	log_error ("no alive host found in pool '%s'\n", name);
	if (r_poolname)
	{
	xfree (*r_poolname);
	*r_poolname = NULL;
	}
	return gpg_error (GPG_ERR_NO_KEYSERVER);
	}
	}

	assert (hi->poolidx >= 0 && hi->poolidx < hosttable_size);
	hi = hosttable[hi->poolidx];
	assert (hi);
	}

	if (hi->dead)
	{
	log_error ("host '%s' marked as dead\n", hi->name);
	if (r_poolname)
	{
	xfree (*r_poolname);
	*r_poolname = NULL;
	}
	return gpg_error (GPG_ERR_NO_KEYSERVER);
	}

	if (r_httpflags)
	{
	/* If the hosttable does not indicate that a certain host
	supports IPv<N>, we explicit set the corresponding http
	flags. The reason for this is that a host might be listed in
	a pool as not v6 only but actually support v6 when later
	the name is resolved by our http layer. */
	if (!hi->v4)
	*r_httpflags \|= HTTP_FLAG_IGNORE_IPv4;
	if (!hi->v6)
	*r_httpflags \|= HTTP_FLAG_IGNORE_IPv6;

	/* Note that we do not set the HTTP_FLAG_FORCE_TOR for onion
	addresses because the http module detects this itself. This
	also allows us to use an onion address without Tor mode being
	enabled. */
	}

	*r_host = xtrystrdup (hi->name);
	if (!*r_host)
	{
	err = gpg_error_from_syserror ();
	if (r_poolname)
	{
	xfree (*r_poolname);
	*r_poolname = NULL;
	}
	return err;
	}
	if (hi->port)
	snprintf (r_portstr, 6 /* five digits and the sentinel */,
	"%hu", hi->port);
	return 0;
	}


	/* Mark the host NAME as dead. NAME may be given as an URL. Returns
	true if a host was really marked as dead or was already marked dead
	(e.g. by a concurrent session). */
	static int
	mark_host_dead (const char *name)
	{
	const char *host;
	char *host_buffer = NULL;
	parsed_uri_t parsed_uri = NULL;
	int done = 0;

	if (name && *name && !http_parse_uri (&parsed_uri, name, 1))
	{
	if (parsed_uri->v6lit)
	{
	host_buffer = strconcat ("[", parsed_uri->host, "]", NULL);
	if (!host_buffer)
	log_error ("out of core in mark_host_dead");
	host = host_buffer;
	}
	else
	host = parsed_uri->host;
	}
	else
	host = name;

	if (host && *host && strcmp (host, "localhost"))
	{
	hostinfo_t hi;
	int idx;

	idx = find_hostinfo (host);
	if (idx != -1)
	{
	hi = hosttable[idx];
	log_info ("marking host '%s' as dead%s\n",
	hi->name, hi->dead? " (again)":"");
	hi->dead = 1;
	hi->died_at = gnupg_get_time ();
	if (!hi->died_at)
	hi->died_at = 1;
	done = 1;
	}
	}

	http_release_parsed_uri (parsed_uri);
	xfree (host_buffer);
	return done;
	}


	/* Mark a host in the hosttable as dead or - if ALIVE is true - as
	alive. */
	gpg_error_t
	ks_hkp_mark_host (ctrl_t ctrl, const char *name, int alive)
	{
	gpg_error_t err = 0;
	hostinfo_t hi, hi2;
	int idx, idx2, idx3, n;

	if (!name \|\| !*name \|\| !strcmp (name, "localhost"))
	return 0;

	idx = find_hostinfo (name);
	if (idx == -1)
	return gpg_error (GPG_ERR_NOT_FOUND);

	hi = hosttable[idx];
	if (alive && hi->dead)
	{
	hi->dead = 0;
	err = ks_printf_help (ctrl, "marking '%s' as alive", name);
	}
	else if (!alive && !hi->dead)
	{
	hi->dead = 1;
	hi->died_at = 0; /* Manually set dead. */
	err = ks_printf_help (ctrl, "marking '%s' as dead", name);
	}

	/* If the host is a pool mark all member hosts. */
	if (!err && hi->pool)
	{
	for (idx2=0; !err && (n=hi->pool[idx2]) != -1; idx2++)
	{
	assert (n >= 0 && n < hosttable_size);

	if (!alive)
	{
	/* Do not mark a host from a pool dead if it is also a
	member in another pool. */
	for (idx3=0; idx3 < hosttable_size; idx3++)
	{
	if (hosttable[idx3]
	&& hosttable[idx3]->pool
	&& idx3 != idx
	&& host_in_pool_p (hosttable[idx3]->pool, n))
	break;
	}
	if (idx3 < hosttable_size)
	continue; /* Host is also a member of another pool. */
	}

	hi2 = hosttable[n];
	if (!hi2)
	;
	else if (alive && hi2->dead)
	{
	hi2->dead = 0;
	err = ks_printf_help (ctrl, "marking '%s' as alive",
	hi2->name);
	}
	else if (!alive && !hi2->dead)
	{
	hi2->dead = 1;
	hi2->died_at = 0; /* Manually set dead. */
	err = ks_printf_help (ctrl, "marking '%s' as dead",
	hi2->name);
	}
	}
	}

	return err;
	}


	/* Debug function to print the entire hosttable. */
	gpg_error_t
	ks_hkp_print_hosttable (ctrl_t ctrl)
	{
	gpg_error_t err;
	int idx, idx2;
	hostinfo_t hi;
	membuf_t mb;
	time_t curtime;
	char p, died;
	const char *diedstr;

	err = ks_print_help (ctrl, "hosttable (idx, ipv6, ipv4, dead, name, time):");
	if (err)
	return err;

	curtime = gnupg_get_time ();
	for (idx=0; idx < hosttable_size; idx++)
	if ((hi=hosttable[idx]))
	{
	if (hi->dead && hi->died_at)
	{
	died = elapsed_time_string (hi->died_at, curtime);
	diedstr = died? died : "error";
	}
	else
	diedstr = died = NULL;
	err = ks_printf_help (ctrl, "%3d %s %s %s %s%s%s%s%s%s%s%s\n",
	idx,
	hi->onion? "O" : hi->v6? "6":" ",
	hi->v4? "4":" ",
	hi->dead? "d":" ",
	hi->name,
	hi->v6addr? " v6=":"",
	hi->v6addr? hi->v6addr:"",
	hi->v4addr? " v4=":"",
	hi->v4addr? hi->v4addr:"",
	diedstr? " (":"",
	diedstr? diedstr:"",
	diedstr? ")":"" );
	xfree (died);
	if (err)
	return err;

	if (hi->cname)
	err = ks_printf_help (ctrl, " . %s", hi->cname);
	if (err)
	return err;

	if (hi->pool)
	{
	init_membuf (&mb, 256);
	put_membuf_printf (&mb, " . -->");
	for (idx2=0; hi->pool[idx2] != -1; idx2++)
	{
	put_membuf_printf (&mb, " %d", hi->pool[idx2]);
	if (hi->poolidx == hi->pool[idx2])
	put_membuf_printf (&mb, "*");
	}
	put_membuf( &mb, "", 1);
	p = get_membuf (&mb, NULL);
	if (!p)
	return gpg_error_from_syserror ();
	err = ks_print_help (ctrl, p);
	xfree (p);
	if (err)
	return err;
	}
	}
	return 0;
	}



	/* Print a help output for the schemata supported by this module. */
	gpg_error_t
	ks_hkp_help (ctrl_t ctrl, parsed_uri_t uri)
	{
	const char const data[] =
	"Handler for HKP URLs:\n"
	" hkp://\n"
	#if HTTP_USE_GNUTLS \|\| HTTP_USE_NTBTLS
	" hkps://\n"
	#endif
	"Supported methods: search, get, put\n";
	gpg_error_t err;

	#if HTTP_USE_GNUTLS \|\| HTTP_USE_NTBTLS
	const char data2[] = " hkp\n hkps";
	#else
	const char data2[] = " hkp";
	#endif

	if (!uri)
	err = ks_print_help (ctrl, data2);
	else if (uri->is_http && (!strcmp (uri->scheme, "hkp")
	\|\| !strcmp (uri->scheme, "hkps")))
	err = ks_print_help (ctrl, data);
	else
	err = 0;

	return err;
	}


	/* Build the remote part of the URL from SCHEME, HOST and an optional
	PORT. Returns an allocated string at R_HOSTPORT or NULL on failure
	If R_POOLNAME is not NULL it receives a malloced string with the
	poolname. */
	static gpg_error_t
	make_host_part (ctrl_t ctrl,
	const char scheme, const char host, unsigned short port,
	int force_reselect,
	char *r_hostport, unsigned int r_httpflags, char **r_poolname)
	{
	gpg_error_t err;
	char portstr[10];
	char *hostname;

	*r_hostport = NULL;

	portstr[0] = 0;
	err = map_host (ctrl, host, force_reselect,
	&hostname, portstr, r_httpflags, r_poolname);
	if (err)
	return err;

	/* Map scheme and port. */
	if (!strcmp (scheme, "hkps") \|\| !strcmp (scheme,"https"))
	{
	scheme = "https";
	if (! *portstr)
	strcpy (portstr, "443");
	}
	else /* HKP or HTTP. */
	{
	scheme = "http";
	if (! *portstr)
	strcpy (portstr, "11371");
	}
	if (port)
	snprintf (portstr, sizeof portstr, "%hu", port);
	else
	{
	/fixme_do_srv_lookup ()/
	}

	*r_hostport = strconcat (scheme, "://", hostname, ":", portstr, NULL);
	xfree (hostname);
	if (!*r_hostport)
	{
	if (r_poolname)
	{
	xfree (*r_poolname);
	*r_poolname = NULL;
	}
	return gpg_error_from_syserror ();
	}
	return 0;
	}


	/* Resolve all known keyserver names and update the hosttable. This
	is mainly useful for debugging because the resolving is anyway done
	on demand. */
	gpg_error_t
	ks_hkp_resolve (ctrl_t ctrl, parsed_uri_t uri)
	{
	gpg_error_t err;
	char *hostport = NULL;

	err = make_host_part (ctrl, uri->scheme, uri->host, uri->port, 1,
	&hostport, NULL, NULL);
	if (err)
	{
	err = ks_printf_help (ctrl, "%s://%s:%hu: resolve failed: %s",
	uri->scheme, uri->host, uri->port,
	gpg_strerror (err));
	}
	else
	{
	err = ks_printf_help (ctrl, "%s", hostport);
	xfree (hostport);
	}
	return err;
	}


	/* Housekeeping function called from the housekeeping thread. It is
	used to mark dead hosts alive so that they may be tried again after
	some time. */
	void
	ks_hkp_housekeeping (time_t curtime)
	{
	int idx;
	hostinfo_t hi;

	for (idx=0; idx < hosttable_size; idx++)
	{
	hi = hosttable[idx];
	if (!hi)
	continue;
	if (!hi->dead)
	continue;
	if (!hi->died_at)
	continue; /* Do not resurrect manually shot hosts. */
	if (hi->died_at + RESURRECT_INTERVAL <= curtime
	\|\| hi->died_at > curtime)
	{
	hi->dead = 0;
	log_info ("resurrected host '%s'", hi->name);
	}
	}
	}


	/* Send an HTTP request. On success returns an estream object at
	R_FP. HOSTPORTSTR is only used for diagnostics. If HTTPHOST is
	not NULL it will be used as HTTP "Host" header. If POST_CB is not
	NULL a post request is used and that callback is called to allow
	writing the post data. If R_HTTP_STATUS is not NULL, the http
	status code will be stored there. */
	static gpg_error_t
	send_request (ctrl_t ctrl, const char request, const char hostportstr,
	const char *httphost, unsigned int httpflags,
	gpg_error_t (post_cb)(void , http_t), void *post_cb_value,
	estream_t r_fp, unsigned int r_http_status)
	{
	gpg_error_t err;
	http_session_t session = NULL;
	http_t http = NULL;
	int redirects_left = MAX_REDIRECTS;
	estream_t fp = NULL;
	char *request_buffer = NULL;

	*r_fp = NULL;

	err = http_session_new (&session, NULL, httphost, HTTP_FLAG_TRUST_DEF);
	if (err)
	goto leave;
	http_session_set_log_cb (session, cert_log_cb);

	once_more:
	err = http_open (&http,
	post_cb? HTTP_REQ_POST : HTTP_REQ_GET,
	request,
	httphost,
	/* fixme: AUTH */ NULL,
	(httpflags
	\|(opt.honor_http_proxy? HTTP_FLAG_TRY_PROXY:0)
	\|(opt.use_tor? HTTP_FLAG_FORCE_TOR:0)),
	ctrl->http_proxy,
	session,
	NULL,
	/FIXME curl->srvtag/NULL);
	if (!err)
	{
	fp = http_get_write_ptr (http);
	/* Avoid caches to get the most recent copy of the key. We set
	both the Pragma and Cache-Control versions of the header, so
	we're good with both HTTP 1.0 and 1.1. */
	es_fputs ("Pragma: no-cache\r\n"
	"Cache-Control: no-cache\r\n", fp);
	if (post_cb)
	err = post_cb (post_cb_value, http);
	if (!err)
	{
	http_start_data (http);
	if (es_ferror (fp))
	err = gpg_error_from_syserror ();
	}
	}
	if (err)
	{
	/* Fixme: After a redirection we show the old host name. */
	log_error (_("error connecting to '%s': %s\n"),
	hostportstr, gpg_strerror (err));
	goto leave;
	}

	/* Wait for the response. */
	dirmngr_tick (ctrl);
	err = http_wait_response (http);
	if (err)
	{
	log_error (_("error reading HTTP response for '%s': %s\n"),
	hostportstr, gpg_strerror (err));
	goto leave;
	}

	if (http_get_tls_info (http, NULL))
	{
	/* Update the httpflags so that a redirect won't fallback to an
	unencrypted connection. */
	httpflags \|= HTTP_FLAG_FORCE_TLS;
	}

	if (r_http_status)
	*r_http_status = http_get_status_code (http);

	switch (http_get_status_code (http))
	{
	case 200:
	err = 0;
	break; /* Success. */

	case 301:
	case 302:
	case 307:
	{
	const char *s = http_get_header (http, "Location");

	log_info (_("URL '%s' redirected to '%s' (%u)\n"),
	request, s?s:"[none]", http_get_status_code (http));
	if (s && *s && redirects_left-- )
	{
	xfree (request_buffer);
	request_buffer = xtrystrdup (s);
	if (request_buffer)
	{
	request = request_buffer;
	http_close (http, 0);
	http = NULL;
	goto once_more;
	}
	err = gpg_error_from_syserror ();
	}
	else
	err = gpg_error (GPG_ERR_NO_DATA);
	log_error (_("too many redirections\n"));
	}
	goto leave;

	case 501:
	err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	goto leave;

	default:
	log_error (_("error accessing '%s': http status %u\n"),
	request, http_get_status_code (http));
	err = gpg_error (GPG_ERR_NO_DATA);
	goto leave;
	}

	/* FIXME: We should register a permanent redirection and whether a
	host has ever used TLS so that future calls will always use
	TLS. */

	fp = http_get_read_ptr (http);
	if (!fp)
	{
	err = gpg_error (GPG_ERR_BUG);
	goto leave;
	}

	/* Return the read stream and close the HTTP context. */
	*r_fp = fp;
	http_close (http, 1);
	http = NULL;

	leave:
	http_close (http, 0);
	http_session_release (session);
	xfree (request_buffer);
	return err;
	}


	/* Helper to evaluate the error code ERR form a send_request() call
	with REQUEST. The function returns true if the caller shall try
	again. TRIES_LEFT points to a variable to track the number of
	retries; this function decrements it and won't return true if it is
	down to zero. */
	static int
	handle_send_request_error (gpg_error_t err, const char *request,
	unsigned int *tries_left)
	{
	int retry = 0;

	switch (gpg_err_code (err))
	{
	case GPG_ERR_ECONNREFUSED:
	case GPG_ERR_ENETUNREACH:
	case GPG_ERR_UNKNOWN_HOST:
	case GPG_ERR_NETWORK:
	if (mark_host_dead (request) && *tries_left)
	retry = 1;
	break;

	case GPG_ERR_ETIMEDOUT:
	if (*tries_left)
	{
	log_info ("selecting a different host due to a timeout\n");
	retry = 1;
	}

	default:
	break;
	}

	if (*tries_left)
	--*tries_left;

	return retry;
	}


	/* Search the keyserver identified by URI for keys matching PATTERN.
	On success R_FP has an open stream to read the data. If
	R_HTTP_STATUS is not NULL, the http status code will be stored
	there. */
	gpg_error_t
	ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
	estream_t r_fp, unsigned int r_http_status)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;
	char fprbuf[2+40+1];
	char *hostport = NULL;
	char *request = NULL;
	estream_t fp = NULL;
	int reselect;
	unsigned int httpflags;
	char *httphost = NULL;
	unsigned int tries = SEND_REQUEST_RETRIES;

	*r_fp = NULL;

	/* Remove search type indicator and adjust PATTERN accordingly.
	Note that HKP keyservers like the 0x to be present when searching
	by keyid. We need to re-format the fingerprint and keyids so to
	remove the gpg specific force-use-of-this-key flag ("!"). */
	err = classify_user_id (pattern, &desc, 1);
	if (err)
	return err;
	switch (desc.mode)
	{
	case KEYDB_SEARCH_MODE_EXACT:
	case KEYDB_SEARCH_MODE_SUBSTR:
	case KEYDB_SEARCH_MODE_MAIL:
	case KEYDB_SEARCH_MODE_MAILSUB:
	pattern = desc.u.name;
	break;
	case KEYDB_SEARCH_MODE_SHORT_KID:
	snprintf (fprbuf, sizeof fprbuf, "0x%08lX", (ulong)desc.u.kid[1]);
	pattern = fprbuf;
	break;
	case KEYDB_SEARCH_MODE_LONG_KID:
	snprintf (fprbuf, sizeof fprbuf, "0x%08lX%08lX",
	(ulong)desc.u.kid[0], (ulong)desc.u.kid[1]);
	pattern = fprbuf;
	break;
	case KEYDB_SEARCH_MODE_FPR16:
	fprbuf[0] = '0';
	fprbuf[1] = 'x';
	bin2hex (desc.u.fpr, 16, fprbuf+2);
	pattern = fprbuf;
	break;
	case KEYDB_SEARCH_MODE_FPR20:
	case KEYDB_SEARCH_MODE_FPR:
	fprbuf[0] = '0';
	fprbuf[1] = 'x';
	bin2hex (desc.u.fpr, 20, fprbuf+2);
	pattern = fprbuf;
	break;
	default:
	return gpg_error (GPG_ERR_INV_USER_ID);
	}

	/* Build the request string. */
	reselect = 0;
	again:
	{
	char *searchkey;

	xfree (hostport); hostport = NULL;
	xfree (httphost); httphost = NULL;
	err = make_host_part (ctrl, uri->scheme, uri->host, uri->port, reselect,
	&hostport, &httpflags, &httphost);
	if (err)
	goto leave;

	searchkey = http_escape_string (pattern, EXTRA_ESCAPE_CHARS);
	if (!searchkey)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	xfree (request);
	request = strconcat (hostport,
	"/pks/lookup?op=index&options=mr&search=",
	searchkey,
	NULL);
	xfree (searchkey);
	if (!request)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	/* Send the request. */
	err = send_request (ctrl, request, hostport, httphost, httpflags,
	NULL, NULL, &fp, r_http_status);
	if (handle_send_request_error (err, request, &tries))
	{
	reselect = 1;
	goto again;
	}
	if (err)
	goto leave;

	err = dirmngr_status (ctrl, "SOURCE", hostport, NULL);
	if (err)
	goto leave;

	/* Peek at the response. */
	{
	int c = es_getc (fp);
	if (c == -1)
	{
	err = es_ferror (fp)?gpg_error_from_syserror ():gpg_error (GPG_ERR_EOF);
	log_error ("error reading response: %s\n", gpg_strerror (err));
	goto leave;
	}
	if (c == '<')
	{
	/* The document begins with a '<': Assume a HTML response,
	which we don't support. */
	err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
	goto leave;
	}
	es_ungetc (c, fp);
	}

	/* Return the read stream. */
	*r_fp = fp;
	fp = NULL;

	leave:
	es_fclose (fp);
	xfree (request);
	xfree (hostport);
	xfree (httphost);
	return err;
	}


	/* Get the key described key the KEYSPEC string from the keyserver
	identified by URI. On success R_FP has an open stream to read the
	data. The data will be provided in a format GnuPG can import
	(either a binary OpenPGP message or an armored one). */
	gpg_error_t
	ks_hkp_get (ctrl_t ctrl, parsed_uri_t uri, const char keyspec, estream_t r_fp)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;
	char kidbuf[2+40+1];
	const char *exactname = NULL;
	char *searchkey = NULL;
	char *hostport = NULL;
	char *request = NULL;
	estream_t fp = NULL;
	int reselect;
	char *httphost = NULL;
	unsigned int httpflags;
	unsigned int tries = SEND_REQUEST_RETRIES;

	*r_fp = NULL;

	/* Remove search type indicator and adjust PATTERN accordingly.
	Note that HKP keyservers like the 0x to be present when searching
	by keyid. We need to re-format the fingerprint and keyids so to
	remove the gpg specific force-use-of-this-key flag ("!"). */
	err = classify_user_id (keyspec, &desc, 1);
	if (err)
	return err;
	switch (desc.mode)
	{
	case KEYDB_SEARCH_MODE_SHORT_KID:
	snprintf (kidbuf, sizeof kidbuf, "0x%08lX", (ulong)desc.u.kid[1]);
	break;
	case KEYDB_SEARCH_MODE_LONG_KID:
	snprintf (kidbuf, sizeof kidbuf, "0x%08lX%08lX",
	(ulong)desc.u.kid[0], (ulong)desc.u.kid[1]);
	break;
	case KEYDB_SEARCH_MODE_FPR20:
	case KEYDB_SEARCH_MODE_FPR:
	/* This is a v4 fingerprint. */
	kidbuf[0] = '0';
	kidbuf[1] = 'x';
	bin2hex (desc.u.fpr, 20, kidbuf+2);
	break;

	case KEYDB_SEARCH_MODE_EXACT:
	exactname = desc.u.name;
	break;

	case KEYDB_SEARCH_MODE_FPR16:
	log_error ("HKP keyservers do not support v3 fingerprints\n");
	default:
	return gpg_error (GPG_ERR_INV_USER_ID);
	}

	searchkey = http_escape_string (exactname? exactname : kidbuf,
	EXTRA_ESCAPE_CHARS);
	if (!searchkey)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	reselect = 0;
	again:
	/* Build the request string. */
	xfree (hostport); hostport = NULL;
	xfree (httphost); httphost = NULL;
	err = make_host_part (ctrl, uri->scheme, uri->host, uri->port, reselect,
	&hostport, &httpflags, &httphost);
	if (err)
	goto leave;

	xfree (request);
	request = strconcat (hostport,
	"/pks/lookup?op=get&options=mr&search=",
	searchkey,
	exactname? "&exact=on":"",
	NULL);
	if (!request)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	/* Send the request. */
	err = send_request (ctrl, request, hostport, httphost, httpflags,
	NULL, NULL, &fp, NULL);
	if (handle_send_request_error (err, request, &tries))
	{
	reselect = 1;
	goto again;
	}
	if (err)
	goto leave;

	err = dirmngr_status (ctrl, "SOURCE", hostport, NULL);
	if (err)
	goto leave;

	/* Return the read stream and close the HTTP context. */
	*r_fp = fp;
	fp = NULL;

	leave:
	es_fclose (fp);
	xfree (request);
	xfree (hostport);
	xfree (httphost);
	xfree (searchkey);
	return err;
	}




	/* Callback parameters for put_post_cb. */
	struct put_post_parm_s
	{
	char *datastring;
	};


	/* Helper for ks_hkp_put. */
	static gpg_error_t
	put_post_cb (void *opaque, http_t http)
	{
	struct put_post_parm_s *parm = opaque;
	gpg_error_t err = 0;
	estream_t fp;
	size_t len;

	fp = http_get_write_ptr (http);
	len = strlen (parm->datastring);

	es_fprintf (fp,
	"Content-Type: application/x-www-form-urlencoded\r\n"
	"Content-Length: %zu\r\n", len+8 /* 8 is for "keytext" */);
	http_start_data (http);
	if (es_fputs ("keytext=", fp) \|\| es_write (fp, parm->datastring, len, NULL))
	err = gpg_error_from_syserror ();
	return err;
	}


	/* Send the key in {DATA,DATALEN} to the keyserver identified by URI. */
	gpg_error_t
	ks_hkp_put (ctrl_t ctrl, parsed_uri_t uri, const void *data, size_t datalen)
	{
	gpg_error_t err;
	char *hostport = NULL;
	char *request = NULL;
	estream_t fp = NULL;
	struct put_post_parm_s parm;
	char *armored = NULL;
	int reselect;
	char *httphost = NULL;
	unsigned int httpflags;
	unsigned int tries = SEND_REQUEST_RETRIES;

	parm.datastring = NULL;

	err = armor_data (&armored, data, datalen);
	if (err)
	goto leave;

	parm.datastring = http_escape_string (armored, EXTRA_ESCAPE_CHARS);
	if (!parm.datastring)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	xfree (armored);
	armored = NULL;

	/* Build the request string. */
	reselect = 0;
	again:
	xfree (hostport); hostport = NULL;
	xfree (httphost); httphost = NULL;
	err = make_host_part (ctrl, uri->scheme, uri->host, uri->port, reselect,
	&hostport, &httpflags, &httphost);
	if (err)
	goto leave;

	xfree (request);
	request = strconcat (hostport, "/pks/add", NULL);
	if (!request)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	/* Send the request. */
	err = send_request (ctrl, request, hostport, httphost, 0,
	put_post_cb, &parm, &fp, NULL);
	if (handle_send_request_error (err, request, &tries))
	{
	reselect = 1;
	goto again;
	}
	if (err)
	goto leave;

	leave:
	es_fclose (fp);
	xfree (parm.datastring);
	xfree (armored);
	xfree (request);
	xfree (hostport);
	xfree (httphost);
	return err;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Dec 24, 10:47 PM (1 d, 7 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: a0/0b/870b2cb041ca8a28a69b587eabfc

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions