dirmngr: Add basic libdns support
[gnupg.git] / dirmngr / ks-engine-hkp.c
index 4075930..8f53432 100644 (file)
@@ -15,7 +15,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #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  (3600*3)  /* 3 hours */
+
 /* To match the behaviour of our old gpgkeys helper code we escape
    more characters than actually needed. */
 #define EXTRA_ESCAPE_CHARS "@!\"#$%&'()*+,-./:;<=>?[\\]^_{|}~"
@@ -47,6 +64,9 @@
 /* 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;
@@ -57,10 +77,22 @@ struct hostinfo_s
   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.  */
+  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.  */
 };
 
@@ -70,7 +102,7 @@ struct hostinfo_s
 static hostinfo_t *hosttable;
 static int hosttable_size;
 
-/* The number of host slots we initally allocate for HOSTTABLE.  */
+/* The number of host slots we initially allocate for HOSTTABLE.  */
 #define INITIAL_HOSTTABLE_SIZE 10
 
 
@@ -94,7 +126,13 @@ create_new_hostinfo (const char *name)
   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++)
@@ -200,131 +238,303 @@ select_random_host (int *table)
 }
 
 
+/* 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. */
-static char *
-map_host (const char *name, int force_reselect)
+   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)
-    return xtrystrdup ("localhost");
+    {
+      *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)
+  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.  */
-      struct addrinfo hints, *aibuf, *ai;
+      dns_addrinfo_t aibuf, ai;
       int *reftbl;
       size_t reftblsize;
       int refidx;
+      int is_pool = 0;
+      char *cname;
+      char *srvrecord;
+      struct srventry *srvs;
+      int srvscount;
 
       reftblsize = 100;
       reftbl = xtrymalloc (reftblsize * sizeof *reftbl);
       if (!reftbl)
-        return NULL;
+        return gpg_error_from_syserror ();
       refidx = 0;
 
       idx = create_new_hostinfo (name);
       if (idx == -1)
         {
+          err = gpg_error_from_syserror ();
           xfree (reftbl);
-          return NULL;
+          return err;
         }
       hi = hosttable[idx];
 
-      /* Find all A records for this entry and put them into the pool
-         list - if any.  */
-      memset (&hints, 0, sizeof (hints));
-      hints.ai_socktype = SOCK_STREAM;
-      if (!getaddrinfo (name, NULL, &hints, &aibuf))
+      if (!is_ip_address (name))
         {
-          for (ai = aibuf; ai; ai = ai->ai_next)
+          /* Check for SRV records.  */
+          srvrecord = xtryasprintf ("_hkp._tcp.%s", name);
+          if (srvrecord == NULL)
             {
-              char tmphost[NI_MAXHOST];
-              int tmpidx;
-              int ec;
-              int i;
+              err = gpg_error_from_syserror ();
+              xfree (reftbl);
+              return err;
+            }
 
-              if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
-                continue;
+          srvscount = getsrv (srvrecord, &srvs);
+          xfree (srvrecord);
+          if (srvscount < 0)
+            {
+              err = gpg_error_from_syserror ();
+              xfree (reftbl);
+              return err;
+            }
 
-              if ((ec=getnameinfo (ai->ai_addr, ai->ai_addrlen,
-                                   tmphost, sizeof tmphost,
-                                   NULL, 0, 0)))
-                {
-                  log_info ("getnameinfo failed while checking '%s': %s\n",
-                            name, gai_strerror (ec));
-                }
-              else if (refidx+1 >= reftblsize)
+          if (srvscount > 0)
+            {
+              int i;
+              is_pool = srvscount > 1;
+
+              for (i = 0; i < srvscount; i++)
                 {
-                  log_error ("getnameinfo returned for '%s': '%s'"
-                            " [index table full - ignored]\n", name, tmphost);
+                  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);
                 }
-              else
-                {
 
-                  if ((tmpidx = find_hostinfo (tmphost)) != -1)
-                    {
-                      log_info ("getnameinfo returned for '%s': '%s'"
-                                " [already known]\n", name, tmphost);
-                      if (ai->ai_family == AF_INET)
-                        hosttable[tmpidx]->v4 = 1;
-                      if (ai->ai_family == AF_INET6)
-                        hosttable[tmpidx]->v6 = 1;
-
-                      for (i=0; i < refidx; i++)
-                        if (reftbl[i] == tmpidx)
-                          break;
-                      if (!(i < refidx) && tmpidx != idx)
-                        reftbl[refidx++] = tmpidx;
-                    }
-                  else
-                    {
-                      log_info ("getnameinfo returned for '%s': '%s'\n",
-                                name, tmphost);
-                      /* 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
-                        {
-                          if (ai->ai_family == AF_INET)
-                            hosttable[tmpidx]->v4 = 1;
-                          if (ai->ai_family == AF_INET6)
-                            hosttable[tmpidx]->v6 = 1;
-
-                          for (i=0; i < refidx; i++)
-                            if (reftbl[i] == tmpidx)
-                              break;
-                          if (!(i < refidx) && tmpidx != idx)
-                            reftbl[refidx++] = tmpidx;
-                        }
-                    }
-                }
+              xfree (srvs);
+            }
+        }
+
+      /* 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;
-      if (refidx)
+      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",
-                         strerror (errno));
+                         gpg_strerror (err));
               xfree (reftbl);
+              return err;
             }
-          qsort (reftbl, refidx, sizeof *reftbl, sort_hostpool);
+          qsort (hi->pool, refidx, sizeof *reftbl, sort_hostpool);
         }
       else
         xfree (reftbl);
@@ -333,6 +543,14 @@ map_host (const char *name, int force_reselect)
   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)
@@ -348,7 +566,12 @@ map_host (const char *name, int force_reselect)
           if (hi->poolidx == -1)
             {
               log_error ("no alive host found in pool '%s'\n", name);
-              return NULL;
+              if (r_poolname)
+                {
+                  xfree (*r_poolname);
+                  *r_poolname = NULL;
+                }
+              return gpg_error (GPG_ERR_NO_KEYSERVER);
             }
         }
 
@@ -360,35 +583,103 @@ map_host (const char *name, int force_reselect)
   if (hi->dead)
     {
       log_error ("host '%s' marked as dead\n", hi->name);
-      return NULL;
+      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.  */
     }
 
-  return xtrystrdup (hi->name);
+  *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.  */
-static void
+/* 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)
 {
-  hostinfo_t hi;
-  int idx;
+  const char *host;
+  char *host_buffer = NULL;
+  parsed_uri_t parsed_uri = NULL;
+  int done = 0;
 
-  if (!name || !*name || !strcmp (name, "localhost"))
-    return;
+  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;
 
-  idx = find_hostinfo (name);
-  if (idx == -1)
-    return;
-  hi = hosttable[idx];
-  log_info ("marking host '%s' as dead%s\n", hi->name, hi->dead? " (again)":"");
-  hi->dead = 1;
+  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.  If the host NAME does not exist a warning status message is
-   printed.  */
+   alive.  */
 gpg_error_t
 ks_hkp_mark_host (ctrl_t ctrl, const char *name, int alive)
 {
@@ -412,6 +703,7 @@ ks_hkp_mark_host (ctrl_t ctrl, const char *name, int alive)
   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);
     }
 
@@ -428,7 +720,7 @@ ks_hkp_mark_host (ctrl_t ctrl, const char *name, int alive)
                  member in another pool.  */
               for (idx3=0; idx3 < hosttable_size; idx3++)
                 {
-                  if (hosttable[idx3] && hosttable[idx3]
+                  if (hosttable[idx3]
                       && hosttable[idx3]->pool
                       && idx3 != idx
                       && host_in_pool_p (hosttable[idx3]->pool, n))
@@ -450,6 +742,7 @@ ks_hkp_mark_host (ctrl_t ctrl, const char *name, int alive)
           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);
             }
@@ -468,20 +761,47 @@ ks_hkp_print_hosttable (ctrl_t ctrl)
   int idx, idx2;
   hostinfo_t hi;
   membuf_t mb;
-  char *p;
+  time_t curtime;
+  char *p, *died;
+  const char *diedstr;
 
-  err = ks_print_help (ctrl, "hosttable (idx, ipv4, ipv6, dead, name):");
+  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]))
       {
-        err = ks_printf_help (ctrl, "%3d %s %s %s %s\n",
-                              idx, hi->v4? "4":" ", hi->v6? "6":" ",
-                              hi->dead? "d":" ", hi->name);
+        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);
@@ -514,12 +834,22 @@ 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, "  hkp");
-  else if (uri->is_http && !strcmp (uri->scheme, "hkp"))
+    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;
@@ -528,27 +858,40 @@ ks_hkp_help (ctrl_t ctrl, parsed_uri_t uri)
 }
 
 
-/* Build the remote part or the URL from SCHEME, HOST and an optional
-   PORT.  Returns an allocated string or NULL on failure and sets
-   ERRNO.  */
-static char *
-make_host_part (const char *scheme, const char *host, unsigned short port,
-                int force_reselect)
+/* 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;
-  char *hostport;
+
+  *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";
-      strcpy (portstr, "443");
+      if (! *portstr)
+        strcpy (portstr, "443");
     }
   else /* HKP or HTTP.  */
     {
       scheme = "http";
-      strcpy (portstr, "11371");
+      if (! *portstr)
+        strcpy (portstr, "11371");
     }
   if (port)
     snprintf (portstr, sizeof portstr, "%hu", port);
@@ -557,13 +900,18 @@ make_host_part (const char *scheme, const char *host, unsigned short port,
       /*fixme_do_srv_lookup ()*/
     }
 
-  hostname = map_host (host, force_reselect);
-  if (!hostname)
-    return NULL;
-
-  hostport = strconcat (scheme, "://", hostname, ":", portstr, NULL);
+  *r_hostport = strconcat (scheme, "://", hostname, ":", portstr, NULL);
   xfree (hostname);
-  return hostport;
+  if (!*r_hostport)
+    {
+      if (r_poolname)
+        {
+          xfree (*r_poolname);
+          *r_poolname = NULL;
+        }
+      return gpg_error_from_syserror ();
+    }
+  return 0;
 }
 
 
@@ -576,10 +924,10 @@ ks_hkp_resolve (ctrl_t ctrl, parsed_uri_t uri)
   gpg_error_t err;
   char *hostport = NULL;
 
-  hostport = make_host_part (uri->scheme, uri->host, uri->port, 1);
-  if (!hostport)
+  err = make_host_part (ctrl, uri->scheme, uri->host, uri->port, 1,
+                        &hostport, NULL, NULL);
+  if (err)
     {
-      err = gpg_error_from_syserror ();
       err = ks_printf_help (ctrl, "%s://%s:%hu: resolve failed: %s",
                             uri->scheme, uri->host, uri->port,
                             gpg_strerror (err));
@@ -593,16 +941,48 @@ ks_hkp_resolve (ctrl_t ctrl, parsed_uri_t uri)
 }
 
 
+/* 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 POST_CB is not
+   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.  */
+   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)
+              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;
@@ -610,14 +990,23 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
 
   *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,
-                   0,
-                   /* fixme: proxy*/ NULL,
-                   NULL, 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)
     {
@@ -654,6 +1043,16 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
       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:
@@ -662,6 +1061,7 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
 
     case 301:
     case 302:
+    case 307:
       {
         const char *s = http_get_header (http, "Location");
 
@@ -686,6 +1086,10 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
       }
       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));
@@ -693,6 +1097,10 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
       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)
     {
@@ -707,75 +1115,58 @@ send_request (ctrl_t ctrl, const char *request, const char *hostportstr,
 
  leave:
   http_close (http, 0);
+  http_session_release (session);
   xfree (request_buffer);
   return err;
 }
 
 
-static gpg_error_t
-armor_data (char **r_string, const void *data, size_t datalen)
+/* 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)
 {
-  gpg_error_t err;
-  struct b64state b64state;
-  estream_t fp;
-  long length;
-  char *buffer;
-  size_t nread;
+  int retry = 0;
 
-  *r_string = NULL;
-
-  fp = es_fopenmem (0, "rw");
-  if (!fp)
-    return gpg_error_from_syserror ();
-
-  if ((err=b64enc_start_es (&b64state, fp, "PGP PUBLIC KEY BLOCK"))
-      || (err=b64enc_write (&b64state, data, datalen))
-      || (err = b64enc_finish (&b64state)))
+  switch (gpg_err_code (err))
     {
-      es_fclose (fp);
-      return 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;
 
-  /* FIXME: To avoid the extra buffer allocation estream should
-     provide a function to snatch the internal allocated memory from
-     such a memory stream.  */
-  length = es_ftell (fp);
-  if (length < 0)
-    {
-      err = gpg_error_from_syserror ();
-      es_fclose (fp);
-      return err;
-    }
+    case GPG_ERR_ETIMEDOUT:
+      if (*tries_left)
+        {
+          log_info ("selecting a different host due to a timeout\n");
+          retry = 1;
+        }
 
-  buffer = xtrymalloc (length+1);
-  if (!buffer)
-    {
-      err = gpg_error_from_syserror ();
-      es_fclose (fp);
-      return err;
+    default:
+      break;
     }
 
-  es_rewind (fp);
-  if (es_read (fp, buffer, length, &nread))
-    {
-      err = gpg_error_from_syserror ();
-      es_fclose (fp);
-      return err;
-    }
-  buffer[nread] = 0;
-  es_fclose (fp);
+  if (*tries_left)
+    --*tries_left;
 
-  *r_string = buffer;
-  return 0;
+  return retry;
 }
 
-
 \f
 /* Search the keyserver identified by URI for keys matching PATTERN.
-   On success R_FP has an open stream to read the data.  */
+   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)
+               estream_t *r_fp, unsigned int *r_http_status)
 {
   gpg_error_t err;
   KEYDB_SEARCH_DESC desc;
@@ -783,6 +1174,10 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
   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;
 
@@ -811,12 +1206,16 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
       pattern = fprbuf;
       break;
     case KEYDB_SEARCH_MODE_FPR16:
-      bin2hex (desc.u.fpr, 16, fprbuf);
+      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:
-      bin2hex (desc.u.fpr, 20, fprbuf);
+      fprbuf[0] = '0';
+      fprbuf[1] = 'x';
+      bin2hex (desc.u.fpr, 20, fprbuf+2);
       pattern = fprbuf;
       break;
     default:
@@ -824,15 +1223,17 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
     }
 
   /* Build the request string.  */
+  reselect = 0;
+ again:
   {
     char *searchkey;
 
-    hostport = make_host_part (uri->scheme, uri->host, uri->port, 0);
-    if (!hostport)
-      {
-        err = gpg_error_from_syserror ();
-        goto leave;
-      }
+    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)
@@ -841,6 +1242,7 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
         goto leave;
       }
 
+    xfree (request);
     request = strconcat (hostport,
                          "/pks/lookup?op=index&options=mr&search=",
                          searchkey,
@@ -854,7 +1256,17 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
   }
 
   /* Send the request.  */
-  err = send_request (ctrl, request, hostport, NULL, NULL, &fp);
+  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;
 
@@ -885,22 +1297,30 @@ ks_hkp_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
   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.  */
+   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[40+1];
+  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;
 
@@ -914,16 +1334,22 @@ ks_hkp_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec, estream_t *r_fp)
   switch (desc.mode)
     {
     case KEYDB_SEARCH_MODE_SHORT_KID:
-      snprintf (kidbuf, sizeof kidbuf, "%08lX", (ulong)desc.u.kid[1]);
+      snprintf (kidbuf, sizeof kidbuf, "0x%08lX", (ulong)desc.u.kid[1]);
       break;
     case KEYDB_SEARCH_MODE_LONG_KID:
-      snprintf (kidbuf, sizeof kidbuf, "%08lX%08lX",
+      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. */
-      bin2hex (desc.u.fpr, 20, kidbuf);
+      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:
@@ -932,17 +1358,29 @@ ks_hkp_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec, estream_t *r_fp)
       return gpg_error (GPG_ERR_INV_USER_ID);
     }
 
-  /* Build the request string.  */
-  hostport = make_host_part (uri->scheme, uri->host, uri->port, 0);
-  if (!hostport)
+  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=0x",
-                       kidbuf,
+                       "/pks/lookup?op=get&options=mr&search=",
+                       searchkey,
+                       exactname? "&exact=on":"",
                        NULL);
   if (!request)
     {
@@ -951,7 +1389,17 @@ ks_hkp_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec, estream_t *r_fp)
     }
 
   /* Send the request.  */
-  err = send_request (ctrl, request, hostport, NULL, NULL, &fp);
+  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;
 
@@ -963,6 +1411,8 @@ ks_hkp_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec, estream_t *r_fp)
   es_fclose (fp);
   xfree (request);
   xfree (hostport);
+  xfree (httphost);
+  xfree (searchkey);
   return err;
 }
 
@@ -998,7 +1448,7 @@ put_post_cb (void *opaque, http_t http)
 }
 
 
-/* Send the key in {DATA,DATALEN} to the keyserver identified by  URI.  */
+/* 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)
 {
@@ -1008,6 +1458,10 @@ ks_hkp_put (ctrl_t ctrl, parsed_uri_t uri, const void *data, size_t datalen)
   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;
 
@@ -1025,13 +1479,16 @@ ks_hkp_put (ctrl_t ctrl, parsed_uri_t uri, const void *data, size_t datalen)
   armored = NULL;
 
   /* Build the request string.  */
-  hostport = make_host_part (uri->scheme, uri->host, uri->port, 0);
-  if (!hostport)
-    {
-      err = gpg_error_from_syserror ();
-      goto leave;
-    }
+  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)
     {
@@ -1040,7 +1497,13 @@ ks_hkp_put (ctrl_t ctrl, parsed_uri_t uri, const void *data, size_t datalen)
     }
 
   /* Send the request.  */
-  err = send_request (ctrl, request, hostport, put_post_cb, &parm, &fp);
+  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;
 
@@ -1050,5 +1513,6 @@ ks_hkp_put (ctrl_t ctrl, parsed_uri_t uri, const void *data, size_t datalen)
   xfree (armored);
   xfree (request);
   xfree (hostport);
+  xfree (httphost);
   return err;
 }