* options.h, keyserver.c (parse_keyserver_uri, keyserver_spawn,
[gnupg.git] / sm / call-dirmngr.c
index 4e3de36..a1d94e2 100644 (file)
 #include "../assuan/assuan.h"
 #include "i18n.h"
 
+struct membuf {
+  size_t len;
+  size_t size;
+  char *buf;
+  int out_of_core;
+};
+
+
+
 static ASSUAN_CONTEXT dirmngr_ctx = NULL;
+static int force_pipe_server = 0;
 
-struct cipher_parm_s {
+struct inq_certificate_parm_s {
   ASSUAN_CONTEXT ctx;
-  const char *ciphertext;
-  size_t ciphertextlen;
+  KsbaCert cert;
 };
 
-struct genkey_parm_s {
+struct lookup_parm_s {
+  CTRL ctrl;
   ASSUAN_CONTEXT ctx;
-  const char *sexp;
-  size_t sexplen;
+  void (*cb)(void *, KsbaCert);
+  void *cb_value;
+  struct membuf data;
+  int error;
 };
 
 
-struct membuf {
-  size_t len;
-  size_t size;
-  char *buf;
-  int out_of_core;
-};
+
+
+/* A simple implementation of a dynamic buffer.  Use init_membuf() to
+   create a buffer, put_membuf to append bytes and get_membuf to
+   release and return the buffer.  Allocation errors are detected but
+   only returned at the final get_membuf(), this helps not to clutter
+   the code with out of core checks.  */
+
+static void
+init_membuf (struct membuf *mb, int initiallen)
+{
+  mb->len = 0;
+  mb->size = initiallen;
+  mb->out_of_core = 0;
+  mb->buf = xtrymalloc (initiallen);
+  if (!mb->buf)
+      mb->out_of_core = 1;
+}
+
+static void
+put_membuf (struct membuf *mb, const void *buf, size_t len)
+{
+  if (mb->out_of_core)
+    return;
+
+  if (mb->len + len >= mb->size)
+    {
+      char *p;
+      
+      mb->size += len + 1024;
+      p = xtryrealloc (mb->buf, mb->size);
+      if (!p)
+        {
+          mb->out_of_core = 1;
+          return;
+        }
+      mb->buf = p;
+    }
+  memcpy (mb->buf + mb->len, buf, len);
+  mb->len += len;
+}
+
+static void *
+get_membuf (struct membuf *mb, size_t *len)
+{
+  char *p;
+
+  if (mb->out_of_core)
+    {
+      xfree (mb->buf);
+      mb->buf = NULL;
+      return NULL;
+    }
+
+  p = mb->buf;
+  *len = mb->len;
+  mb->buf = NULL;
+  mb->out_of_core = 1; /* don't allow a reuse */
+  return p;
+}
+
+
 
 
 \f
@@ -64,20 +132,22 @@ start_dirmngr (void)
 {
   int rc;
   char *infostr, *p;
+  ASSUAN_CONTEXT ctx;
 
   if (dirmngr_ctx)
     return 0; /* fixme: We need a context for each thread or serialize
-                 the access to the agent (which is suitable given that
-                 the agent is not MT */
+                 the access to the dirmngr */
 
-  infostr = getenv ("DIRMNGR_INFO");
+  infostr = force_pipe_server? NULL : getenv ("DIRMNGR_INFO");
   if (!infostr)
     {
       const char *pgmname;
-      ASSUAN_CONTEXT ctx;
       const char *argv[3];
+      int no_close_list[3];
+      int i;
 
-      log_info (_("no running dirmngr - starting one\n"));
+      if (opt.verbose)
+        log_info (_("no running dirmngr - starting one\n"));
       
       if (fflush (NULL))
         {
@@ -86,7 +156,7 @@ start_dirmngr (void)
         }
 
       if (!opt.dirmngr_program || !*opt.dirmngr_program)
-        opt.dirmngr_program = "/usr/sbin/dirmngr";
+        opt.dirmngr_program = GNUPG_DEFAULT_DIRMNGR;
       if ( !(pgmname = strrchr (opt.dirmngr_program, '/')))
         pgmname = opt.dirmngr_program;
       else
@@ -96,31 +166,62 @@ start_dirmngr (void)
       argv[1] = "--server";
       argv[2] = NULL;
 
+      i=0;
+      if (log_get_fd () != -1)
+        no_close_list[i++] = log_get_fd ();
+      no_close_list[i++] = fileno (stderr);
+      no_close_list[i] = -1;
+
       /* connect to the agent and perform initial handshaking */
-      rc = assuan_pipe_connect (&ctx, opt.dirmngr_program, (char**)argv, 0);
-      if (rc)
-        {
-          log_error ("can't connect to the dirmngr: %s\n", assuan_strerror (rc));
-          return seterr (No_Dirmngr);
-        }
-      dirmngr_ctx = ctx;
+      rc = assuan_pipe_connect (&ctx, opt.dirmngr_program, (char**)argv,
+                                no_close_list);
     }
   else
     {
+      int prot;
+      int pid;
+
       infostr = xstrdup (infostr);
-      if ( !(p = strchr (infostr, ':')) || p == infostr
-           /* || (p-infostr)+1 >= sizeof client_addr.sun_path */)
+      if ( !(p = strchr (infostr, ':')) || p == infostr)
         {
           log_error (_("malformed DIRMNGR_INFO environment variable\n"));
           xfree (infostr);
-          return seterr (General_Error);
+          force_pipe_server = 1;
+          return start_dirmngr ();
+        }
+      *p++ = 0;
+      pid = atoi (p);
+      while (*p && *p != ':')
+        p++;
+      prot = *p? atoi (p+1) : 0;
+      if (prot != 1)
+        {
+          log_error (_("dirmngr protocol version %d is not supported\n"),
+                     prot);
+          xfree (infostr);
+          force_pipe_server = 1;
+          return start_dirmngr ();
+        }
+
+      rc = assuan_socket_connect (&ctx, infostr, pid);
+      xfree (infostr);
+      if (rc == ASSUAN_Connect_Failed)
+        {
+          log_error (_("can't connect to the dirmngr - trying fall back\n"));
+          force_pipe_server = 1;
+          return start_dirmngr ();
         }
-      *p = 0;
-      log_error (_("socket based dirmngr communication not yet implemented\n"));
-      return seterr (Not_Implemented);
     }
 
-  log_debug ("connection to dirmngr established\n");
+  if (rc)
+    {
+      log_error ("can't connect to the dirmngr: %s\n", assuan_strerror (rc));
+      return seterr (No_Dirmngr);
+    }
+  dirmngr_ctx = ctx;
+
+  if (DBG_ASSUAN)
+    log_debug ("connection to dirmngr established\n");
   return 0;
 }
 
@@ -130,16 +231,48 @@ start_dirmngr (void)
 static AssuanError
 inq_certificate (void *opaque, const char *line)
 {
+  struct inq_certificate_parm_s *parm = opaque;
   AssuanError rc;
+  const unsigned char *der;
+  size_t derlen;
 
-  if (strncmp (line, "SENDCERT ", 9) || !line[9])
+  if (!(!strncmp (line, "SENDCERT", 8) && (line[8] == ' ' || !line[8])))
     {
       log_error ("unsupported inquiry `%s'\n", line);
       return ASSUAN_Inquire_Unknown;
     }
+  line += 8;
+
+  if (!*line)
+    { /* send the current certificate */
+      der = ksba_cert_get_image (parm->cert, &derlen);
+      if (!der)
+        rc = ASSUAN_Inquire_Error;
+      else
+        rc = assuan_send_data (parm->ctx, der, derlen);
+    }
+  else 
+    { /* send the given certificate */
+      int err;
+      KsbaCert cert;
+
+      err = gpgsm_find_cert (line, &cert);
+      if (err)
+        {
+          log_error ("certificate not found: %s\n", gnupg_strerror (err));
+          rc = ASSUAN_Inquire_Error;
+        }
+      else
+        {
+          der = ksba_cert_get_image (cert, &derlen);
+          if (!der)
+            rc = ASSUAN_Inquire_Error;
+          else
+            rc = assuan_send_data (parm->ctx, der, derlen);
+          ksba_cert_release (cert);
+        }
+    }
 
-  /*  rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);*/
-  rc = 0;
   return rc; 
 }
 
@@ -158,6 +291,7 @@ gpgsm_dirmngr_isvalid (KsbaCert cert)
   int rc;
   char *certid;
   char line[ASSUAN_LINELENGTH];
+  struct inq_certificate_parm_s parm;
 
   rc = start_dirmngr ();
   if (rc)
@@ -170,13 +304,192 @@ gpgsm_dirmngr_isvalid (KsbaCert cert)
       return seterr (General_Error);
     }
 
+  if (opt.verbose > 1)
+    {
+      char *fpr = gpgsm_get_fingerprint_string (cert, GCRY_MD_SHA1);
+      log_info ("asking dirmngr about %s\n", fpr);
+      xfree (fpr);
+    }
+
+  parm.ctx = dirmngr_ctx;
+  parm.cert = cert;
+
   snprintf (line, DIM(line)-1, "ISVALID %s", certid);
   line[DIM(line)-1] = 0;
   xfree (certid);
 
-  rc = assuan_transact (dirmngr_ctx, line, NULL, NULL, inq_certificate, NULL);
+  rc = assuan_transact (dirmngr_ctx, line, NULL, NULL,
+                        inq_certificate, &parm, NULL, NULL);
+  if (opt.verbose > 1)
+    log_info ("response of dirmngr: %s\n", rc? assuan_strerror (rc): "okay");
   return map_assuan_err (rc);
 }
 
 
+\f
+/* Lookup helpers*/
+static AssuanError
+lookup_cb (void *opaque, const void *buffer, size_t length)
+{
+  struct lookup_parm_s *parm = opaque;
+  size_t len;
+  char *buf;
+  KsbaCert cert;
+  int rc;
+
+  if (parm->error)
+    return 0;
+
+  if (buffer)
+    {
+      put_membuf (&parm->data, buffer, length);
+      return 0;
+    }
+  /* END encountered - process what we have */
+  buf = get_membuf (&parm->data, &len);
+  if (!buf)
+    {
+      parm->error = GNUPG_Out_Of_Core;
+      return 0;
+    }
+
+  cert = ksba_cert_new ();
+  if (!cert)
+    {
+      parm->error = GNUPG_Out_Of_Core;
+      return 0;
+    }
+  rc = ksba_cert_init_from_mem (cert, buf, len);
+  if (rc)
+    {
+      log_error ("failed to parse a certificate: %s\n", ksba_strerror (rc));
+    }
+  else
+    {
+      parm->cb (parm->cb_value, cert);
+    }
+
+  ksba_cert_release (cert);
+  init_membuf (&parm->data, 4096);
+  return 0;
+}
+
+/* Return a properly escaped pattern from NAMES.  The only error
+   return is NULL to indicate a malloc failure. */
+static char *
+pattern_from_strlist (STRLIST names)
+{
+  STRLIST sl;
+  int n;
+  const char *s;
+  char *pattern, *p;
+
+  for (n=0, sl=names; sl; sl = sl->next)
+    {
+      for (s=sl->d; *s; s++, n++)
+       {
+          if (*s == '%' || *s == ' ' || *s == '+')
+            n += 2;
+       }
+      n++;
+    }
+
+  p = pattern = xtrymalloc (n+1);
+  if (!pattern)
+    return NULL;
+
+  for (n=0, sl=names; sl; sl = sl->next)
+    {
+      for (s=sl->d; *s; s++)
+        {
+          switch (*s)
+            {
+            case '%':
+              *p++ = '%';
+              *p++ = '2';
+              *p++ = '5';
+              break;
+            case ' ':
+              *p++ = '%';
+              *p++ = '2';
+              *p++ = '0';
+              break;
+            case '+':
+              *p++ = '%';
+              *p++ = '2';
+              *p++ = 'B';
+              break;
+            default:
+              *p++ = *s;
+              break;
+            }
+        }
+      *p++ = ' ';
+    }
+  if (p == pattern)
+    *pattern = 0; /* is empty */
+  else
+    p[-1] = '\0'; /* remove trailing blank */
+  
+  return pattern;
+}
+
+static AssuanError
+lookup_status_cb (void *opaque, const char *line)
+{
+  struct lookup_parm_s *parm = opaque;
+
+  if (!strncmp (line, "TRUNCATED", 9) && (line[9]==' ' || !line[9]))
+    {
+      if (parm->ctrl)
+        {
+          for (line +=9; *line == ' '; line++)
+            ;
+          gpgsm_status (parm->ctrl, STATUS_TRUNCATED, line);
+        }
+    }
+  return 0;
+}
+
+
+/* Run the Directroy Managers lookup command using the apptern
+   compiled from the strings given in NAMES.  The caller must provide
+   the callback CB which will be passed cert by cert.  Note that CTRL
+   is optional. */
+int 
+gpgsm_dirmngr_lookup (CTRL ctrl, STRLIST names,
+                      void (*cb)(void*, KsbaCert), void *cb_value)
+{ 
+  int rc;
+  char *pattern;
+  char line[ASSUAN_LINELENGTH];
+  struct lookup_parm_s parm;
+  size_t len;
+
+  rc = start_dirmngr ();
+  if (rc)
+    return rc;
+
+  pattern = pattern_from_strlist (names);
+  if (!pattern)
+    return GNUPG_Out_Of_Core;
+  snprintf (line, DIM(line)-1, "LOOKUP %s", pattern);
+  line[DIM(line)-1] = 0;
+  xfree (pattern);
+
+  parm.ctrl = ctrl;
+  parm.ctx = dirmngr_ctx;
+  parm.cb = cb;
+  parm.cb_value = cb_value;
+  parm.error = 0;
+  init_membuf (&parm.data, 4096);
+
+  rc = assuan_transact (dirmngr_ctx, line, lookup_cb, &parm,
+                        NULL, NULL, lookup_status_cb, &parm);
+  xfree (get_membuf (&parm.data, &len));
+  if (rc)
+    return map_assuan_err (rc);
+  return parm.error;
+}
+