2007-07-17 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / rungpg.c
index c89e39e..a8fc8ad 100644 (file)
@@ -1,22 +1,23 @@
 /* rungpg.c - Gpg Engine.
    Copyright (C) 2000 Werner Koch (dd9jn)
-   Copyright (C) 2001, 2002, 2003 g10 Code GmbH
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 g10 Code GmbH
  
    This file is part of GPGME.
  
    GPGME 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 2 of the License, or
-   (at your option) any later version.
+   under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of
+   the License, or (at your option) any later version.
+   
    GPGME 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 GPGME; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Lesser General Public License for more details.
+   
+   You should have received a copy of the GNU Lesser General Public
+   License along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 #if HAVE_CONFIG_H
 #include <config.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <signal.h>
-#include <fcntl.h>
-#include "unistd.h"
+#include <unistd.h>
+#include <locale.h>
 
 #include "gpgme.h"
 #include "util.h"
 #include "ops.h"
 #include "wait.h"
 #include "context.h"  /*temp hack until we have GpmeData methods to do I/O */
-#include "io.h"
+#include "priv-io.h"
 #include "sema.h"
 #include "debug.h"
 
@@ -70,11 +67,17 @@ struct fd_data_map_s
 };
 
 
-struct gpg_object_s
+typedef gpgme_error_t (*colon_preprocessor_t) (char *line, char **rline);
+
+struct engine_gpg
 {
+  char *file_name;
+
+  char *lc_messages;
+  char *lc_ctype;
+
   struct arg_and_data_s *arglist;
   struct arg_and_data_s **argtail;
-  int arg_error;
 
   struct
   {
@@ -83,7 +86,7 @@ struct gpg_object_s
     char *buffer;
     size_t readpos;
     int eof;
-    EngineStatusHandler fnc;
+    engine_status_handler_t fnc;
     void *fnc_value;
     void *tag;
   } status;
@@ -96,9 +99,10 @@ struct gpg_object_s
     char *buffer;
     size_t readpos;
     int eof;
-    EngineColonLineHandler fnc;  /* this indicate use of this structrue */
+    engine_colon_line_handler_t fnc;  /* this indicate use of this structrue */
     void *fnc_value;
     void *tag;
+    colon_preprocessor_t preprocess_fnc;
   } colon;
 
   char **argv;  
@@ -109,11 +113,11 @@ struct gpg_object_s
   {
     int used;
     int fd;
+    void *cb_data;
     int idx;           /* Index in fd_data_map */
-    gpgme_data_t cb_data;   /* hack to get init the above idx later */
     gpgme_status_code_t code;  /* last code */
     char *keyword;       /* what has been requested (malloced) */
-    EngineCommandHandler fnc; 
+    engine_command_handler_t fnc; 
     void *fnc_value;
     /* The kludges never end.  This is used to couple command handlers
        with output data in edit key mode.  */
@@ -124,13 +128,13 @@ struct gpg_object_s
   struct gpgme_io_cbs io_cbs;
 };
 
-typedef struct gpg_object_s *GpgObject;
+typedef struct engine_gpg *engine_gpg_t;
 
 \f
 static void
 gpg_io_event (void *engine, gpgme_event_io_t type, void *type_data)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   if (gpg->io_cbs.event)
     (*gpg->io_cbs.event) (gpg->io_cbs.event_priv, type, type_data);
@@ -140,7 +144,7 @@ gpg_io_event (void *engine, gpgme_event_io_t type, void *type_data)
 static void
 close_notify_handler (int fd, void *opaque)
 {
-  GpgObject gpg = opaque;
+  engine_gpg_t gpg = opaque;
   assert (fd != -1);
 
   if (gpg->status.fd[0] == fd)
@@ -181,8 +185,10 @@ close_notify_handler (int fd, void *opaque)
     }
 }
 
+/* If FRONT is true, push at the front of the list.  Use this for
+   options added late in the process.  */
 static gpgme_error_t
-add_arg (GpgObject gpg, const char *arg)
+add_arg_ext (engine_gpg_t gpg, const char *arg, int front)
 {
   struct arg_and_data_s *a;
 
@@ -191,21 +197,40 @@ add_arg (GpgObject gpg, const char *arg)
 
   a = malloc (sizeof *a + strlen (arg));
   if (!a)
-    {
-      gpg->arg_error = 1;
-      return GPGME_Out_Of_Core;
-    }
-  a->next = NULL;
+    return gpg_error_from_errno (errno);
+
   a->data = NULL;
   a->dup_to = -1;
   strcpy (a->arg, arg);
-  *gpg->argtail = a;
-  gpg->argtail = &a->next;
+  if (front)
+    {
+      a->next = gpg->arglist;
+      if (!gpg->arglist)
+       {
+         /* If this is the first argument, we need to update the tail
+            pointer.  */
+         gpg->argtail = &a->next;
+       }
+      gpg->arglist = a;
+    }
+  else
+    {
+      a->next = NULL;
+      *gpg->argtail = a;
+      gpg->argtail = &a->next;
+    }
+
   return 0;
 }
 
 static gpgme_error_t
-add_data (GpgObject gpg, gpgme_data_t data, int dup_to, int inbound)
+add_arg (engine_gpg_t gpg, const char *arg)
+{
+  return add_arg_ext (gpg, arg, 0);
+}
+
+static gpgme_error_t
+add_data (engine_gpg_t gpg, gpgme_data_t data, int dup_to, int inbound)
 {
   struct arg_and_data_s *a;
 
@@ -214,10 +239,7 @@ add_data (GpgObject gpg, gpgme_data_t data, int dup_to, int inbound)
 
   a = malloc (sizeof *a - 1);
   if (!a)
-    {
-      gpg->arg_error = 1;
-      return GPGME_Out_Of_Core;
-    }
+    return gpg_error_from_errno (errno);
   a->next = NULL;
   a->data = data;
   a->inbound = inbound;
@@ -237,17 +259,11 @@ add_data (GpgObject gpg, gpgme_data_t data, int dup_to, int inbound)
 }
 
 \f
-static const char *
-gpg_get_version (void)
+static char *
+gpg_get_version (const char *file_name)
 {
-  static const char *gpg_version;
-  DEFINE_STATIC_LOCK (gpg_version_lock);
-
-  LOCK (gpg_version_lock);
-  if (!gpg_version)
-    gpg_version = _gpgme_get_program_version (_gpgme_get_gpg_path ());
-  UNLOCK (gpg_version_lock);
-  return gpg_version;
+  return _gpgme_get_program_version (file_name ? file_name
+                                    : _gpgme_get_gpg_path ());
 }
 
 
@@ -289,58 +305,97 @@ free_fd_data_map (struct fd_data_map_s *fd_data_map)
 }
 
 
+static gpgme_error_t
+gpg_cancel (void *engine)
+{
+  engine_gpg_t gpg = engine;
+
+  if (!gpg)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  if (gpg->status.fd[0] != -1)
+    _gpgme_io_close (gpg->status.fd[0]);
+  if (gpg->status.fd[1] != -1)
+    _gpgme_io_close (gpg->status.fd[1]);
+  if (gpg->colon.fd[0] != -1)
+    _gpgme_io_close (gpg->colon.fd[0]);
+  if (gpg->colon.fd[1] != -1)
+    _gpgme_io_close (gpg->colon.fd[1]);
+  if (gpg->fd_data_map)
+    {
+      free_fd_data_map (gpg->fd_data_map);
+      gpg->fd_data_map = NULL;
+    }
+  if (gpg->cmd.fd != -1)
+    _gpgme_io_close (gpg->cmd.fd);
+
+  return 0;
+}
+
 static void
 gpg_release (void *engine)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   if (!gpg)
     return;
 
+  gpg_cancel (engine);
+
+  if (gpg->file_name)
+    free (gpg->file_name);
+
+  if (gpg->lc_messages)
+    free (gpg->lc_messages);
+  if (gpg->lc_ctype)
+    free (gpg->lc_ctype);
+
   while (gpg->arglist)
     {
       struct arg_and_data_s *next = gpg->arglist->next;
 
-      free (gpg->arglist);
+      if (gpg->arglist)
+       free (gpg->arglist);
       gpg->arglist = next;
     }
 
-  free (gpg->status.buffer);
-  free (gpg->colon.buffer);
+  if (gpg->status.buffer)
+    free (gpg->status.buffer);
+  if (gpg->colon.buffer)
+    free (gpg->colon.buffer);
   if (gpg->argv)
     free_argv (gpg->argv);
-  gpgme_data_release (gpg->cmd.cb_data);
-  free (gpg->cmd.keyword);
+  if (gpg->cmd.keyword)
+    free (gpg->cmd.keyword);
 
-  if (gpg->status.fd[0] != -1)
-    _gpgme_io_close (gpg->status.fd[0]);
-  if (gpg->status.fd[1] != -1)
-    _gpgme_io_close (gpg->status.fd[1]);
-  if (gpg->colon.fd[0] != -1)
-    _gpgme_io_close (gpg->colon.fd[0]);
-  if (gpg->colon.fd[1] != -1)
-    _gpgme_io_close (gpg->colon.fd[1]);
-  free_fd_data_map (gpg->fd_data_map);
-  if (gpg->cmd.fd != -1)
-    _gpgme_io_close (gpg->cmd.fd);
   free (gpg);
 }
 
 
 static gpgme_error_t
-gpg_new (void **engine)
+gpg_new (void **engine, const char *file_name, const char *home_dir)
 {
-  GpgObject gpg;
-  int rc = 0;
+  engine_gpg_t gpg;
+  gpgme_error_t rc = 0;
+  char *dft_display = NULL;
+  char dft_ttyname[64];
+  char *dft_ttytype = NULL;
 
   gpg = calloc (1, sizeof *gpg);
   if (!gpg)
+    return gpg_error_from_errno (errno);
+
+  if (file_name)
     {
-      rc = GPGME_Out_Of_Core;
-      goto leave;
+      gpg->file_name = strdup (file_name);
+      if (!gpg->file_name)
+       {
+         rc = gpg_error_from_errno (errno);
+         goto leave;
+       }
     }
-  gpg->argtail = &gpg->arglist;
 
+  gpg->argtail = &gpg->arglist;
   gpg->status.fd[0] = -1;
   gpg->status.fd[1] = -1;
   gpg->colon.fd[0] = -1;
@@ -356,14 +411,14 @@ gpg_new (void **engine)
   gpg->status.buffer = malloc (gpg->status.bufsize);
   if (!gpg->status.buffer)
     {
-      rc = GPGME_Out_Of_Core;
+      rc = gpg_error_from_errno (errno);
       goto leave;
     }
   /* In any case we need a status pipe - create it right here and
      don't handle it with our generic gpgme_data_t mechanism.  */
   if (_gpgme_io_pipe (gpg->status.fd, 1) == -1)
     {
-      rc = GPGME_Pipe_Error;
+      rc = gpg_error_from_errno (errno);
       goto leave;
     }
   if (_gpgme_io_set_close_notify (gpg->status.fd[0],
@@ -371,20 +426,82 @@ gpg_new (void **engine)
       || _gpgme_io_set_close_notify (gpg->status.fd[1],
                                     close_notify_handler, gpg))
     {
-      rc = GPGME_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
   gpg->status.eof = 0;
-  add_arg (gpg, "--status-fd");
+
+  if (home_dir)
+    {
+      rc = add_arg (gpg, "--homedir");
+      if (!rc)
+       rc = add_arg (gpg, home_dir);
+      if (rc)
+       goto leave;
+    }
+
+  rc = add_arg (gpg, "--status-fd");
+  if (rc)
+    goto leave;
+
   {
     char buf[25];
-    sprintf (buf, "%d", gpg->status.fd[1]);
-    add_arg (gpg, buf);
+    _gpgme_io_fd2str (buf, sizeof (buf), gpg->status.fd[1]);
+    rc = add_arg (gpg, buf);
+    if (rc)
+      goto leave;
   }
-  add_arg (gpg, "--no-tty");
-  add_arg (gpg, "--charset");
-  add_arg (gpg, "utf8");
-  add_arg (gpg, "--enable-progress-filter");
+
+  rc = add_arg (gpg, "--no-tty");
+  if (!rc)
+    rc = add_arg (gpg, "--charset");
+  if (!rc)
+    rc = add_arg (gpg, "utf8");
+  if (!rc)
+    rc = add_arg (gpg, "--enable-progress-filter");
+  if (rc)
+    goto leave;
+
+  rc = _gpgme_getenv ("DISPLAY", &dft_display);
+  if (dft_display)
+    {
+      rc = add_arg (gpg, "--display");
+      if (!rc)
+       rc = add_arg (gpg, dft_display);
+
+      free (dft_display);
+    }
+  if (rc)
+    goto leave;
+
+  if (isatty (1))
+    {
+      int err;
+
+      err = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
+      if (err)
+       rc = gpg_error_from_errno (errno);
+      else
+       {
+         rc = add_arg (gpg, "--ttyname");
+         if (!rc)
+           rc = add_arg (gpg, dft_ttyname);
+         if (!rc)
+           {
+             rc = _gpgme_getenv ("TERM", &dft_ttytype);
+             if (!rc)
+               goto leave;
+
+             rc = add_arg (gpg, "--ttytype");
+             if (!rc)
+               rc = add_arg (gpg, dft_ttytype);
+
+             free (dft_ttytype);
+           }
+       }
+      if (rc)
+       goto leave;
+    }
 
  leave:
   if (rc)
@@ -395,12 +512,55 @@ gpg_new (void **engine)
 }
 
 
+static gpgme_error_t
+gpg_set_locale (void *engine, int category, const char *value)
+{
+  engine_gpg_t gpg = engine;
+
+  if (category == LC_CTYPE)
+    {
+      if (gpg->lc_ctype)
+        {
+          free (gpg->lc_ctype);
+          gpg->lc_ctype = NULL;
+        }
+      if (value)
+       {
+         gpg->lc_ctype = strdup (value);
+         if (!gpg->lc_ctype)
+           return gpg_error_from_syserror ();
+       }
+    }
+#ifdef LC_MESSAGES
+  else if (category == LC_MESSAGES)
+    {
+      if (gpg->lc_messages)
+        {
+          free (gpg->lc_messages);
+          gpg->lc_messages = NULL;
+        }
+      if (value)
+       {
+         gpg->lc_messages = strdup (value);
+         if (!gpg->lc_messages)
+           return gpg_error_from_syserror ();
+       }
+    }
+#endif /* LC_MESSAGES */
+  else
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  return 0;
+}
+
+
 /* Note, that the status_handler is allowed to modifiy the args
    value.  */
 static void
-gpg_set_status_handler (void *engine, EngineStatusHandler fnc, void *fnc_value)
+gpg_set_status_handler (void *engine, engine_status_handler_t fnc,
+                       void *fnc_value)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   gpg->status.fnc = fnc;
   gpg->status.fnc_value = fnc_value;
@@ -408,27 +568,28 @@ gpg_set_status_handler (void *engine, EngineStatusHandler fnc, void *fnc_value)
 
 /* Kludge to process --with-colon output.  */
 static gpgme_error_t
-gpg_set_colon_line_handler (void *engine, EngineColonLineHandler fnc,
+gpg_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,
                            void *fnc_value)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   gpg->colon.bufsize = 1024;
   gpg->colon.readpos = 0;
   gpg->colon.buffer = malloc (gpg->colon.bufsize);
   if (!gpg->colon.buffer)
-    return GPGME_Out_Of_Core;
+    return gpg_error_from_errno (errno);
 
   if (_gpgme_io_pipe (gpg->colon.fd, 1) == -1) 
     {
+      int saved_errno = errno;
       free (gpg->colon.buffer);
       gpg->colon.buffer = NULL;
-      return GPGME_Pipe_Error;
+      return gpg_error_from_errno (saved_errno);
     }
   if (_gpgme_io_set_close_notify (gpg->colon.fd[0], close_notify_handler, gpg)
       || _gpgme_io_set_close_notify (gpg->colon.fd[1],
                                     close_notify_handler, gpg))
-    return GPGME_General_Error;
+    return gpg_error (GPG_ERR_GENERAL);
   gpg->colon.eof = 0;
   gpg->colon.fnc = fnc;
   gpg->colon.fnc_value = fnc_value;
@@ -436,60 +597,26 @@ gpg_set_colon_line_handler (void *engine, EngineColonLineHandler fnc,
 }
 
 
-/* Here we handle --command-fd.  This works closely together with the
-   status handler.  */
 static gpgme_error_t
-command_cb (void *opaque, char *buffer, size_t length, size_t *nread)
+command_handler (void *opaque, int fd)
 {
   gpgme_error_t err;
-  GpgObject gpg = opaque;
-  const char *value;
-  int value_len;
+  engine_gpg_t gpg = (engine_gpg_t) opaque;
+  int processed = 0;
 
-  DEBUG0 ("command_cb: enter\n");
   assert (gpg->cmd.used);
-  if (!buffer || !length || !nread)
-    return 0; /* These values are reserved for extensions.  */
-  *nread = 0;
-  if (!gpg->cmd.code)
-    {
-      DEBUG0 ("command_cb: no code\n");
-      return -1;
-    }
-    
-  if (!gpg->cmd.fnc)
-    {
-      DEBUG0 ("command_cb: no user cb\n");
-      return -1;
-    }
+  assert (gpg->cmd.code);
+  assert (gpg->cmd.fnc);
 
-  /* FIXME catch error */
-  err = gpg->cmd.fnc (gpg->cmd.fnc_value, 
-                     gpg->cmd.code, gpg->cmd.keyword, &value);
+  err = gpg->cmd.fnc (gpg->cmd.fnc_value, gpg->cmd.code, gpg->cmd.keyword, fd,
+                     &processed);
   if (err)
     return err;
 
-  if (!value)
-    {
-      DEBUG0 ("command_cb: no data from user cb\n");
-      gpg->cmd.fnc (gpg->cmd.fnc_value, 0, value, &value);
-      return -1;
-    }
-
-  value_len = strlen (value);
-  if (value_len + 1 > length)
-    {
-      DEBUG0 ("command_cb: too much data from user cb\n");
-      gpg->cmd.fnc (gpg->cmd.fnc_value, 0, value, &value);
-      return -1;
-    }
+  /* We always need to send at least a newline character.  */
+  if (!processed)
+    _gpgme_io_write (fd, "\n", 1);
 
-  memcpy (buffer, value, value_len);
-  if (!value_len || (value_len && value[value_len-1] != '\n')) 
-    buffer[value_len++] = '\n';
-  *nread = value_len;
-    
-  gpg->cmd.fnc (gpg->cmd.fnc_value, 0, value, &value);
   gpg->cmd.code = 0;
   /* And sleep again until read_status will wake us up again.  */
   /* XXX We must check if there are any more fds active after removing
@@ -502,27 +629,32 @@ command_cb (void *opaque, char *buffer, size_t length, size_t *nread)
 }
 
 
+
 /* The Fnc will be called to get a value for one of the commands with
    a key KEY.  If the Code pssed to FNC is 0, the function may release
    resources associated with the returned value from another call.  To
    match such a second call to a first call, the returned value from
    the first call is passed as keyword.  */
 static gpgme_error_t
-gpg_set_command_handler (void *engine, EngineCommandHandler fnc,
+gpg_set_command_handler (void *engine, engine_command_handler_t fnc,
                         void *fnc_value, gpgme_data_t linked_data)
 {
-  GpgObject gpg = engine;
-  gpgme_data_t tmp;
-  gpgme_error_t err;
+  engine_gpg_t gpg = engine;
+  gpgme_error_t rc;
+
+  rc = add_arg (gpg, "--command-fd");
+  if (rc)
+    return rc;
+
+  /* This is a hack.  We don't have a real data object.  The only
+     thing that matters is that we use something unique, so we use the
+     address of the cmd structure in the gpg object.  */
+  rc = add_data (gpg, (void *) &gpg->cmd, -2, 0);
+  if (rc)
+    return rc;
 
-  err = gpgme_data_new_with_read_cb (&tmp, command_cb, gpg);
-  if (err)
-    return err;
-        
-  add_arg (gpg, "--command-fd");
-  add_data (gpg, tmp, -2, 0);
-  gpg->cmd.cb_data = tmp;
   gpg->cmd.fnc = fnc;
+  gpg->cmd.cb_data = (void *) &gpg->cmd;
   gpg->cmd.fnc_value = fnc_value;
   gpg->cmd.linked_data = linked_data;
   gpg->cmd.used = 1;
@@ -531,8 +663,9 @@ gpg_set_command_handler (void *engine, EngineCommandHandler fnc,
 
 
 static gpgme_error_t
-build_argv (GpgObject gpg)
+build_argv (engine_gpg_t gpg)
 {
+  gpgme_error_t err;
   struct arg_and_data_s *a;
   struct fd_data_map_s *fd_data_map;
   size_t datac=0, argc=0;  
@@ -544,9 +677,13 @@ build_argv (GpgObject gpg)
   /* We don't want to use the agent with a malformed environment
      variable.  This is only a very basic test but sufficient to make
      our life in the regression tests easier. */
-  p = getenv ("GPG_AGENT_INFO");
+  err = _gpgme_getenv ("GPG_AGENT_INFO", &p);
+  if (err)
+    return err;
   use_agent = (p && strchr (p, ':'));
-       
+  if (p)
+    free (p);
+
   if (gpg->argv)
     {
       free_argv (gpg->argv);
@@ -579,26 +716,28 @@ build_argv (GpgObject gpg)
   if (use_agent)
     argc++;
   if (!gpg->cmd.used)
-    argc++;
-  argc += 2; /* --comment */
+    argc++;    /* --batch */
+  argc += 1;   /* --no-sk-comment */
 
   argv = calloc (argc + 1, sizeof *argv);
   if (!argv)
-    return GPGME_Out_Of_Core;
+    return gpg_error_from_errno (errno);
   fd_data_map = calloc (datac + 1, sizeof *fd_data_map);
   if (!fd_data_map)
     {
+      int saved_errno = errno;
       free_argv (argv);
-      return GPGME_Out_Of_Core;
+      return gpg_error_from_errno (saved_errno);
     }
 
   argc = datac = 0;
   argv[argc] = strdup ("gpg"); /* argv[0] */
   if (!argv[argc])
     {
+      int saved_errno = errno;
       free (fd_data_map);
       free_argv (argv);
-      return GPGME_Out_Of_Core;
+      return gpg_error_from_errno (saved_errno);
     }
   argc++;
   if (need_special)
@@ -606,9 +745,10 @@ build_argv (GpgObject gpg)
       argv[argc] = strdup ("--enable-special-filenames");
       if (!argv[argc])
        {
+         int saved_errno = errno;
          free (fd_data_map);
          free_argv (argv);
-         return GPGME_Out_Of_Core;
+         return gpg_error_from_errno (saved_errno);
         }
       argc++;
     }
@@ -617,9 +757,10 @@ build_argv (GpgObject gpg)
       argv[argc] = strdup ("--use-agent");
       if (!argv[argc])
        {
+         int saved_errno = errno;
          free (fd_data_map);
          free_argv (argv);
-         return GPGME_Out_Of_Core;
+         return gpg_error_from_errno (saved_errno);
         }
       argc++;
     }
@@ -628,26 +769,20 @@ build_argv (GpgObject gpg)
       argv[argc] = strdup ("--batch");
       if (!argv[argc])
        {
+         int saved_errno = errno;
          free (fd_data_map);
          free_argv (argv);
-         return GPGME_Out_Of_Core;
+         return gpg_error_from_errno (saved_errno);
         }
       argc++;
     }
-  argv[argc] = strdup ("--comment");
-  if (!argv[argc])
-    {
-      free (fd_data_map);
-      free_argv (argv);
-      return GPGME_Out_Of_Core;
-    }
-  argc++;
-  argv[argc] = strdup ("");
+  argv[argc] = strdup ("--no-sk-comment");
   if (!argv[argc])
     {
+      int saved_errno = errno;
       free (fd_data_map);
       free_argv (argv);
-      return GPGME_Out_Of_Core;
+      return gpg_error_from_errno (saved_errno);
     }
   argc++;
   for (a = gpg->arglist; a; a = a->next)
@@ -664,9 +799,10 @@ build_argv (GpgObject gpg)
            if (_gpgme_io_pipe (fds, fd_data_map[datac].inbound ? 1 : 0)
                == -1)
              {
+               int saved_errno = errno;
                free (fd_data_map);
                free_argv (argv);
-               return GPGME_Pipe_Error;
+               return gpg_error (saved_errno);
              }
            if (_gpgme_io_set_close_notify (fds[0],
                                            close_notify_handler, gpg)
@@ -674,7 +810,7 @@ build_argv (GpgObject gpg)
                                               close_notify_handler,
                                               gpg))
              {
-               return GPGME_General_Error;
+               return gpg_error (GPG_ERR_GENERAL);
              }
            /* If the data_type is FD, we have to do a dup2 here.  */
            if (fd_data_map[datac].inbound)
@@ -708,16 +844,27 @@ build_argv (GpgObject gpg)
          fd_data_map[datac].dup_to = a->dup_to;
          if (a->dup_to == -1)
            {
-             argv[argc] = malloc (25);
+             char *ptr;
+             int buflen = 25;
+
+             argv[argc] = malloc (buflen);
              if (!argv[argc])
                {
+                 int saved_errno = errno;
                  free (fd_data_map);
                  free_argv (argv);
-                 return GPGME_Out_Of_Core;
+                 return gpg_error_from_errno (saved_errno);
                 }
-             sprintf (argv[argc], 
-                      a->print_fd ? "%d" : "-&%d",
-                      fd_data_map[datac].peer_fd);
+
+             ptr = argv[argc];
+             if (!a->print_fd)
+               {
+                 *(ptr++) = '-';
+                 *(ptr++) = '&';
+                 buflen -= 2;
+               }
+             
+             _gpgme_io_fd2str (ptr, buflen, fd_data_map[datac].peer_fd);
              argc++;
             }
          datac++;
@@ -727,9 +874,10 @@ build_argv (GpgObject gpg)
          argv[argc] = strdup (a->arg);
          if (!argv[argc])
            {
+             int saved_errno = errno;
              free (fd_data_map);
              free_argv (argv);
-             return GPGME_Out_Of_Core;
+             return gpg_error_from_errno (saved_errno);
             }
             argc++;
         }
@@ -742,7 +890,7 @@ build_argv (GpgObject gpg)
 
 
 static gpgme_error_t
-add_io_cb (GpgObject gpg, int fd, int dir, gpgme_io_cb_t handler, void *data,
+add_io_cb (engine_gpg_t gpg, int fd, int dir, gpgme_io_cb_t handler, void *data,
           void **tag)
 {
   gpgme_error_t err;
@@ -775,7 +923,7 @@ status_cmp (const void *ap, const void *bp)
    with status line code we know about and skip all other stuff
    without buffering (i.e. without extending the buffer).  */
 static gpgme_error_t
-read_status (GpgObject gpg)
+read_status (engine_gpg_t gpg)
 {
   char *p;
   int nread;
@@ -790,13 +938,13 @@ read_status (GpgObject gpg)
       bufsize += 1024;
       buffer = realloc (buffer, bufsize);
       if (!buffer)
-       return GPGME_Out_Of_Core;
+       return gpg_error_from_errno (errno);
     }
 
   nread = _gpgme_io_read (gpg->status.fd[0],
                          buffer + readpos, bufsize-readpos);
   if (nread == -1)
-    return GPGME_Read_Error;
+    return gpg_error_from_errno (errno);
 
   if (!nread)
     {
@@ -818,6 +966,8 @@ read_status (GpgObject gpg)
          if (*p == '\n')
            {
              /* (we require that the last line is terminated by a LF) */
+             if (p > buffer && p[-1] == '\r')
+               p[-1] = 0;
              *p = 0;
              if (!strncmp (buffer, "[GNUPG:] ", 9)
                  && buffer[9] >= 'A' && buffer[9] <= 'Z')
@@ -843,42 +993,20 @@ read_status (GpgObject gpg)
                              || r->code == GPGME_STATUS_GET_HIDDEN))
                        {
                          gpg->cmd.code = r->code;
-                         free (gpg->cmd.keyword);
+                         if (gpg->cmd.keyword)
+                           free (gpg->cmd.keyword);
                          gpg->cmd.keyword = strdup (rest);
                          if (!gpg->cmd.keyword)
-                           return GPGME_Out_Of_Core;
+                           return gpg_error_from_errno (errno);
                          /* This should be the last thing we have
                             received and the next thing will be that
                             the command handler does its action.  */
                          if (nread > 1)
-                           DEBUG0 ("ERROR, unexpected data in read_status");
-
-                         /* Before we can actually add the command
-                            fd, we might have to flush the linked
-                            output data pipe.  */
-                         if (gpg->cmd.linked_idx != -1
-                             && gpg->fd_data_map[gpg->cmd.linked_idx].fd != -1)
-                           {
-                             struct io_select_fd_s fds;
-                             fds.fd = gpg->fd_data_map[gpg->cmd.linked_idx].fd;
-                             fds.for_read = 1;
-                             fds.for_write = 0;
-                             fds.frozen = 0;
-                             fds.opaque = NULL;
-                             do
-                               {
-                                 fds.signaled = 0;
-                                 _gpgme_io_select (&fds, 1, 1);
-                                 if (fds.signaled)
-                                   _gpgme_data_inbound_handler
-                                     (gpg->cmd.linked_data, fds.fd);
-                               }
-                             while (fds.signaled);
-                           }
+                           TRACE0 (DEBUG_CTX, "gpgme:read_status", 0,
+                                   "error: unexpected data");
 
                          add_io_cb (gpg, gpg->cmd.fd, 0,
-                                    _gpgme_data_outbound_handler,
-                                    gpg->fd_data_map[gpg->cmd.idx].data,
+                                    command_handler, gpg,
                                     &gpg->fd_data_map[gpg->cmd.idx].tag);
                          gpg->fd_data_map[gpg->cmd.idx].fd = gpg->cmd.fd;
                          gpg->cmd.fd = -1;
@@ -896,6 +1024,31 @@ read_status (GpgObject gpg)
                        {
                          if (gpg->cmd.used)
                            {
+                             /* Before we can actually add the
+                                command fd, we might have to flush
+                                the linked output data pipe.  */
+                             if (gpg->cmd.linked_idx != -1
+                                 && gpg->fd_data_map[gpg->cmd.linked_idx].fd
+                                 != -1)
+                               {
+                                 struct io_select_fd_s fds;
+                                 fds.fd =
+                                   gpg->fd_data_map[gpg->cmd.linked_idx].fd;
+                                 fds.for_read = 1;
+                                 fds.for_write = 0;
+                                 fds.frozen = 0;
+                                 fds.opaque = NULL;
+                                 do
+                                   {
+                                     fds.signaled = 0;
+                                     _gpgme_io_select (&fds, 1, 1);
+                                     if (fds.signaled)
+                                       _gpgme_data_inbound_handler
+                                         (gpg->cmd.linked_data, fds.fd);
+                                   }
+                                 while (fds.signaled);
+                               }
+
                              /* XXX We must check if there are any
                                 more fds active after removing this
                                 one.  */
@@ -935,7 +1088,7 @@ read_status (GpgObject gpg)
 static gpgme_error_t
 status_handler (void *opaque, int fd)
 {
-  GpgObject gpg = opaque;
+  engine_gpg_t gpg = opaque;
   int err;
 
   assert (fd == gpg->status.fd[0]);
@@ -949,7 +1102,7 @@ status_handler (void *opaque, int fd)
 
 
 static gpgme_error_t
-read_colon_line (GpgObject gpg)
+read_colon_line (engine_gpg_t gpg)
 {
   char *p;
   int nread;
@@ -964,12 +1117,12 @@ read_colon_line (GpgObject gpg)
       bufsize += 1024;
       buffer = realloc (buffer, bufsize);
       if (!buffer) 
-       return GPGME_Out_Of_Core;
+       return gpg_error_from_errno (errno);
     }
 
   nread = _gpgme_io_read (gpg->colon.fd[0], buffer+readpos, bufsize-readpos);
   if (nread == -1)
-    return GPGME_Read_Error;
+    return gpg_error_from_errno (errno);
 
   if (!nread)
     {
@@ -987,14 +1140,27 @@ read_colon_line (GpgObject gpg)
            {
              /* (we require that the last line is terminated by a LF)
                 and we skip empty lines.  Note: we use UTF8 encoding
-                and escaping of special characters We require at
+                and escaping of special characters We require at
                 least one colon to cope with some other printed
                 information.  */
              *p = 0;
              if (*buffer && strchr (buffer, ':'))
                {
+                 char *line = NULL;
+
+                 if (gpg->colon.preprocess_fnc)
+                   {
+                     gpgme_error_t err;
+
+                     err = gpg->colon.preprocess_fnc (buffer, &line);
+                     if (err)
+                       return err;
+                   }
+
                  assert (gpg->colon.fnc);
-                 gpg->colon.fnc (gpg->colon.fnc_value, buffer);
+                 gpg->colon.fnc (gpg->colon.fnc_value, line ? line : buffer);
+                 if (line)
+                   free (line);
                }
             
              /* To reuse the buffer for the next line we have to
@@ -1029,7 +1195,7 @@ read_colon_line (GpgObject gpg)
 static gpgme_error_t
 colon_line_handler (void *opaque, int fd)
 {
-  GpgObject gpg = opaque;
+  engine_gpg_t gpg = opaque;
   gpgme_error_t rc = 0;
 
   assert (fd == gpg->colon.fd[0]);
@@ -1043,23 +1209,37 @@ colon_line_handler (void *opaque, int fd)
 
 
 static gpgme_error_t
-start (GpgObject gpg)
+start (engine_gpg_t gpg)
 {
   gpgme_error_t rc;
+  int saved_errno;
   int i, n;
   int status;
   struct spawn_fd_item_s *fd_child_list, *fd_parent_list;
 
   if (!gpg)
-    return GPGME_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  if (!gpg->file_name && !_gpgme_get_gpg_path ())
+    return gpg_error (GPG_ERR_INV_ENGINE);
 
-  if (! _gpgme_get_gpg_path ())
-    return GPGME_Invalid_Engine;
+  if (gpg->lc_ctype)
+    {
+      rc = add_arg_ext (gpg, gpg->lc_ctype, 1);
+      if (!rc)
+       rc = add_arg_ext (gpg, "--lc-ctype", 1);
+      if (rc)
+       return rc;
+    }
 
-  /* Kludge, so that we don't need to check the return code of all the
-     add_arg ().  We bail out here instead.  */
-  if (gpg->arg_error)
-    return GPGME_Out_Of_Core;
+  if (gpg->lc_messages)
+    {
+      rc = add_arg_ext (gpg, gpg->lc_messages, 1);
+      if (!rc)
+       rc = add_arg_ext (gpg, "--lc-messages", 1);
+      if (rc)
+       return rc;
+    }
 
   rc = build_argv (gpg);
   if (rc)
@@ -1070,7 +1250,7 @@ start (GpgObject gpg)
     n++;
   fd_child_list = calloc (n + n, sizeof *fd_child_list);
   if (!fd_child_list)
-    return GPGME_Out_Of_Core;
+    return gpg_error_from_errno (errno);
   fd_parent_list = fd_child_list + n;
 
   /* build the fd list for the child */
@@ -1116,11 +1296,13 @@ start (GpgObject gpg)
   fd_parent_list[n].fd = -1;
   fd_parent_list[n].dup_to = -1;
 
-  status = _gpgme_io_spawn (_gpgme_get_gpg_path (),
+  status = _gpgme_io_spawn (gpg->file_name ? gpg->file_name :
+                           _gpgme_get_gpg_path (),
                            gpg->argv, fd_child_list, fd_parent_list);
+  saved_errno = errno;
   free (fd_child_list);
   if (status == -1)
-    return GPGME_Exec_Error;
+    return gpg_error_from_errno (saved_errno);
 
   /*_gpgme_register_term_handler ( closure, closure_value, pid );*/
 
@@ -1173,7 +1355,7 @@ start (GpgObject gpg)
 static gpgme_error_t
 gpg_decrypt (void *engine, gpgme_data_t ciph, gpgme_data_t plain)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, "--decrypt");
@@ -1196,7 +1378,7 @@ gpg_decrypt (void *engine, gpgme_data_t ciph, gpgme_data_t plain)
 static gpgme_error_t
 gpg_delete (void *engine, gpgme_key_t key, int allow_secret)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, allow_secret ? "--delete-secret-and-public-key"
@@ -1206,7 +1388,7 @@ gpg_delete (void *engine, gpgme_key_t key, int allow_secret)
   if (!err)
     {
       if (!key->subkeys || !key->subkeys->fpr)
-       err = GPGME_Invalid_Key;
+       return gpg_error (GPG_ERR_INV_VALUE);
       else
        err = add_arg (gpg, key->subkeys->fpr);
     }
@@ -1218,7 +1400,7 @@ gpg_delete (void *engine, gpgme_key_t key, int allow_secret)
 
 
 static gpgme_error_t
-append_args_from_signers (GpgObject gpg, gpgme_ctx_t ctx /* FIXME */)
+append_args_from_signers (engine_gpg_t gpg, gpgme_ctx_t ctx /* FIXME */)
 {
   gpgme_error_t err = 0;
   int i;
@@ -1242,26 +1424,111 @@ append_args_from_signers (GpgObject gpg, gpgme_ctx_t ctx /* FIXME */)
 
 
 static gpgme_error_t
-gpg_edit (void *engine, gpgme_key_t key, gpgme_data_t out,
+append_args_from_sig_notations (engine_gpg_t gpg, gpgme_ctx_t ctx /* FIXME */)
+{
+  gpgme_error_t err = 0;
+  gpgme_sig_notation_t notation;
+
+  notation = gpgme_sig_notation_get (ctx);
+
+  while (!err && notation)
+    {
+      if (notation->name
+         && !(notation->flags & GPGME_SIG_NOTATION_HUMAN_READABLE))
+       err = gpg_error (GPG_ERR_INV_VALUE);
+      else if (notation->name)
+       {
+         char *arg;
+
+         /* Maximum space needed is one byte for the "critical" flag,
+            the name, one byte for '=', the value, and a terminating
+            '\0'.  */
+
+         arg = malloc (1 + notation->name_len + 1 + notation->value_len + 1);
+         if (!arg)
+           err = gpg_error_from_errno (errno);
+
+         if (!err)
+           {
+             char *argp = arg;
+
+             if (notation->critical)
+               *(argp++) = '!';
+
+             memcpy (argp, notation->name, notation->name_len);
+             argp += notation->name_len;
+
+             *(argp++) = '=';
+
+             /* We know that notation->name is '\0' terminated.  */
+             strcpy (argp, notation->value);
+           }
+
+         if (!err)
+           err = add_arg (gpg, "--sig-notation");
+         if (!err)
+           err = add_arg (gpg, arg);
+
+         if (arg)
+           free (arg);
+       }
+      else
+       {
+         /* This is a policy URL.  */
+
+         char *value;
+
+         if (notation->critical)
+           {
+             value = malloc (1 + notation->value_len + 1);
+             if (!value)
+               err = gpg_error_from_errno (errno);
+             else
+               {
+                 value[0] = '!';
+                 /* We know that notation->value is '\0' terminated.  */
+                 strcpy (&value[1], notation->value);
+               }
+           }
+         else
+           value = notation->value;
+
+         if (!err)
+           err = add_arg (gpg, "--sig-policy-url");
+         if (!err)
+           err = add_arg (gpg, value);
+
+         if (value != notation->value)
+           free (value);
+       }
+
+      notation = notation->next;
+    }
+  return err;
+}
+
+
+static gpgme_error_t
+gpg_edit (void *engine, int type, gpgme_key_t key, gpgme_data_t out,
          gpgme_ctx_t ctx /* FIXME */)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, "--with-colons");
   if (!err)
     err = append_args_from_signers (gpg, ctx);
   if (!err)
-  err = add_arg (gpg, "--edit-key");
+  err = add_arg (gpg, type == 0 ? "--edit-key" : "--card-edit");
   if (!err)
     err = add_data (gpg, out, 1, 1);
   if (!err)
     err = add_arg (gpg, "--");
-  if (!err)
+  if (!err && type == 0)
     {
       const char *s = key->subkeys ? key->subkeys->fpr : NULL;
       if (!s)
-       err = GPGME_Invalid_Key;
+       err = gpg_error (GPG_ERR_INV_VALUE);
       else
        err = add_arg (gpg, s);
     }
@@ -1273,29 +1540,32 @@ gpg_edit (void *engine, gpgme_key_t key, gpgme_data_t out,
 
 
 static gpgme_error_t
-append_args_from_recipients (GpgObject gpg, const gpgme_recipients_t rset)
+append_args_from_recipients (engine_gpg_t gpg, gpgme_key_t recp[])
 {
   gpgme_error_t err = 0;
-  gpgme_user_id_t uid;
+  int i = 0;
 
-  assert (rset);
-  for (uid = rset->list; uid; uid = uid->next)
+  while (recp[i])
     {
-      err = add_arg (gpg, "-r");
+      if (!recp[i]->subkeys || !recp[i]->subkeys->fpr)
+       err = gpg_error (GPG_ERR_INV_VALUE);
+      if (!err)
+       err = add_arg (gpg, "-r");
       if (!err)
-       err = add_arg (gpg, uid->uid);
+       err = add_arg (gpg, recp[i]->subkeys->fpr);
       if (err)
        break;
+      i++;
     }    
   return err;
 }
 
 
 static gpgme_error_t
-gpg_encrypt (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
-            gpgme_data_t ciph, int use_armor)
+gpg_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
+            gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
   int symmetric = !recp;
 
@@ -1308,7 +1578,7 @@ gpg_encrypt (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
     {
       /* If we know that all recipients are valid (full or ultimate trust)
         we can suppress further checks.  */
-      if (!err && !symmetric && _gpgme_recipients_all_valid (recp))
+      if (!err && !symmetric && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
        err = add_arg (gpg, "--always-trust");
 
       if (!err)
@@ -1322,6 +1592,13 @@ gpg_encrypt (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
     err = add_arg (gpg, "-");
   if (!err)
     err = add_data (gpg, ciph, 1, 1);
+  if (gpgme_data_get_file_name (plain))
+    {
+      if (!err)
+       err = add_arg (gpg, "--set-filename");
+      if (!err)
+       err = add_arg (gpg, gpgme_data_get_file_name (plain));
+    }
   if (!err)
     err = add_arg (gpg, "--");
   if (!err)
@@ -1335,11 +1612,12 @@ gpg_encrypt (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
 
 
 static gpgme_error_t
-gpg_encrypt_sign (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
+gpg_encrypt_sign (void *engine, gpgme_key_t recp[],
+                 gpgme_encrypt_flags_t flags, gpgme_data_t plain,
                  gpgme_data_t ciph, int use_armor,
                  gpgme_ctx_t ctx /* FIXME */)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, "--encrypt");
@@ -1349,8 +1627,8 @@ gpg_encrypt_sign (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
     err = add_arg (gpg, "--armor");
 
   /* If we know that all recipients are valid (full or ultimate trust)
-   * we can suppress further checks */
-  if (!err && _gpgme_recipients_all_valid (recp))
+     we can suppress further checks.  */
+  if (!err && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
     err = add_arg (gpg, "--always-trust");
 
   if (!err)
@@ -1358,6 +1636,8 @@ gpg_encrypt_sign (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
 
   if (!err)
     err = append_args_from_signers (gpg, ctx);
+  if (!err)
+    err = append_args_from_sig_notations (gpg, ctx);
 
   /* Tell the gpg object about the data.  */
   if (!err)
@@ -1366,6 +1646,13 @@ gpg_encrypt_sign (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
     err = add_arg (gpg, "-");
   if (!err)
     err = add_data (gpg, ciph, 1, 1);
+  if (gpgme_data_get_file_name (plain))
+    {
+      if (!err)
+       err = add_arg (gpg, "--set-filename");
+      if (!err)
+       err = add_arg (gpg, gpgme_data_get_file_name (plain));
+    }
   if (!err)
     err = add_arg (gpg, "--");
   if (!err)
@@ -1379,12 +1666,15 @@ gpg_encrypt_sign (void *engine, gpgme_recipients_t recp, gpgme_data_t plain,
 
 
 static gpgme_error_t
-gpg_export (void *engine, gpgme_recipients_t recp, gpgme_data_t keydata,
-           int use_armor)
+gpg_export (void *engine, const char *pattern, unsigned int reserved,
+           gpgme_data_t keydata, int use_armor)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
+  if (reserved)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
   err = add_arg (gpg, "--export");
   if (!err && use_armor)
     err = add_arg (gpg, "--armor");
@@ -1393,16 +1683,38 @@ gpg_export (void *engine, gpgme_recipients_t recp, gpgme_data_t keydata,
   if (!err)
     err = add_arg (gpg, "--");
 
+  if (!err && pattern && *pattern)
+    err = add_arg (gpg, pattern);
+
   if (!err)
-    {
-      void *ec;
-      const char *s;
+    err = start (gpg);
 
-      err = gpgme_recipients_enum_open (recp, &ec);
-      while (!err && (s = gpgme_recipients_enum_read (recp, &ec)))
-       err = add_arg (gpg, s);
-      if (!err)
-       err = gpgme_recipients_enum_close (recp, &ec);
+  return err;
+}
+
+
+static gpgme_error_t
+gpg_export_ext (void *engine, const char *pattern[], unsigned int reserved,
+               gpgme_data_t keydata, int use_armor)
+{
+  engine_gpg_t gpg = engine;
+  gpgme_error_t err;
+
+  if (reserved)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  err = add_arg (gpg, "--export");
+  if (!err && use_armor)
+    err = add_arg (gpg, "--armor");
+  if (!err)
+    err = add_data (gpg, keydata, 1, 1);
+  if (!err)
+    err = add_arg (gpg, "--");
+
+  if (pattern)
+    {
+      while (!err && *pattern && **pattern)
+       err = add_arg (gpg, *(pattern++));
     }
 
   if (!err)
@@ -1416,18 +1728,18 @@ static gpgme_error_t
 gpg_genkey (void *engine, gpgme_data_t help_data, int use_armor,
            gpgme_data_t pubkey, gpgme_data_t seckey)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   if (!gpg)
-    return GPGME_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
 
   /* We need a special mechanism to get the fd of a pipe here, so that
      we can use this for the %pubring and %secring parameters.  We
      don't have this yet, so we implement only the adding to the
      standard keyrings.  */
   if (pubkey || seckey)
-    return err = GPGME_Not_Implemented;
+    return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 
   err = add_arg (gpg, "--gen-key");
   if (!err && use_armor)
@@ -1445,7 +1757,7 @@ gpg_genkey (void *engine, gpgme_data_t help_data, int use_armor,
 static gpgme_error_t
 gpg_import (void *engine, gpgme_data_t keydata)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, "--import");
@@ -1459,13 +1771,107 @@ gpg_import (void *engine, gpgme_data_t keydata)
 }
 
 
+/* The output for external keylistings in GnuPG is different from all
+   the other key listings.  We catch this here with a special
+   preprocessor that reformats the colon handler lines.  */
+static gpgme_error_t
+gpg_keylist_preprocess (char *line, char **r_line)
+{
+  enum
+    {
+      RT_NONE, RT_INFO, RT_PUB, RT_UID
+    }
+  rectype = RT_NONE;
+#define NR_FIELDS 16
+  char *field[NR_FIELDS];
+  int fields = 0;
+
+  *r_line = NULL;
+
+  while (line && fields < NR_FIELDS)
+    {
+      field[fields++] = line;
+      line = strchr (line, ':');
+      if (line)
+       *(line++) = '\0';
+    }
+
+  if (!strcmp (field[0], "info"))
+    rectype = RT_INFO;
+  else if (!strcmp (field[0], "pub"))
+    rectype = RT_PUB;
+  else if (!strcmp (field[0], "uid"))
+    rectype = RT_UID;
+  else 
+    rectype = RT_NONE;
+
+  switch (rectype)
+    {
+    case RT_INFO:
+      /* FIXME: Eventually, check the version number at least.  */
+      return 0;
+
+    case RT_PUB:
+      if (fields < 7)
+       return 0;
+
+      /* The format is:
+
+        pub:<keyid>:<algo>:<keylen>:<creationdate>:<expirationdate>:<flags>
+
+        as defined in 5.2. Machine Readable Indexes of the OpenPGP
+        HTTP Keyserver Protocol (draft). 
+
+        We want:
+        pub:o<flags>:<keylen>:<algo>:<keyid>:<creatdate>:<expdate>::::::::
+      */
+
+      if (asprintf (r_line, "pub:o%s:%s:%s:%s:%s:%s::::::::",
+                   field[6], field[3], field[2], field[1],
+                   field[4], field[5]) < 0)
+       return gpg_error_from_errno (errno);
+      return 0;
+
+    case RT_UID:
+      /* The format is:
+
+         uid:<escaped uid string>:<creationdate>:<expirationdate>:<flags>
+
+        as defined in 5.2. Machine Readable Indexes of the OpenPGP
+        HTTP Keyserver Protocol (draft). 
+
+        We want:
+        uid:o<flags>::::<creatdate>:<expdate>:::<uid>:
+      */
+
+      if (asprintf (r_line, "uid:o%s::::%s:%s:::%s:",
+                   field[4], field[2], field[3], field[1]) < 0)
+       return gpg_error_from_errno (errno);
+      return 0;
+
+    case RT_NONE:
+      /* Unknown record.  */
+      break;
+    }
+  return 0;
+
+}
+
+
 static gpgme_error_t
 gpg_keylist (void *engine, const char *pattern, int secret_only,
-            int keylist_mode)
+            gpgme_keylist_mode_t mode)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
+  if (mode & GPGME_KEYLIST_MODE_EXTERN)
+    {
+      if ((mode & GPGME_KEYLIST_MODE_LOCAL)
+         || secret_only)
+       return gpg_error (GPG_ERR_NOT_SUPPORTED);
+    }
+  
   err = add_arg (gpg, "--with-colons");
   if (!err)
     err = add_arg (gpg, "--fixed-list-mode");
@@ -1473,11 +1879,28 @@ gpg_keylist (void *engine, const char *pattern, int secret_only,
     err = add_arg (gpg, "--with-fingerprint");
   if (!err)
     err = add_arg (gpg, "--with-fingerprint");
+  if (!err && (mode & GPGME_KEYLIST_MODE_SIGS)
+      && (mode & GPGME_KEYLIST_MODE_SIG_NOTATIONS))
+    {
+      err = add_arg (gpg, "--list-options");
+      if (!err)
+       err = add_arg (gpg, "show-sig-subpackets=\"20,26\"");
+    }
   if (!err)
-    err = add_arg (gpg, secret_only ? "--list-secret-keys"
-                  : ((keylist_mode & GPGME_KEYLIST_MODE_SIGS)
-                     ? "--check-sigs" : "--list-keys"));
-  
+    {
+      if (mode & GPGME_KEYLIST_MODE_EXTERN)
+       {
+         err = add_arg (gpg, "--search-keys");
+         gpg->colon.preprocess_fnc = gpg_keylist_preprocess;
+       }
+      else
+       {
+         err = add_arg (gpg, secret_only ? "--list-secret-keys"
+                        : ((mode & GPGME_KEYLIST_MODE_SIGS)
+                           ? "--check-sigs" : "--list-keys"));
+       }
+    }
+
   /* Tell the gpg object about the data.  */
   if (!err)
     err = add_arg (gpg, "--");
@@ -1493,13 +1916,13 @@ gpg_keylist (void *engine, const char *pattern, int secret_only,
 
 static gpgme_error_t
 gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
-                int reserved, int keylist_mode)
+                int reserved, gpgme_keylist_mode_t mode)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   if (reserved)
-    return GPGME_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
 
   err = add_arg (gpg, "--with-colons");
   if (!err)
@@ -1508,17 +1931,23 @@ gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
     err = add_arg (gpg, "--with-fingerprint");
   if (!err)
     err = add_arg (gpg, "--with-fingerprint");
+  if (!err && (mode & GPGME_KEYLIST_MODE_SIGS)
+      && (mode & GPGME_KEYLIST_MODE_SIG_NOTATIONS))
+    {
+      err = add_arg (gpg, "--list-options");
+      if (!err)
+       err = add_arg (gpg, "show-sig-subpackets=\"20,26\"");
+    }
   if (!err)
     err = add_arg (gpg, secret_only ? "--list-secret-keys"
-                  : ((keylist_mode & GPGME_KEYLIST_MODE_SIGS)
+                  : ((mode & GPGME_KEYLIST_MODE_SIGS)
                      ? "--check-sigs" : "--list-keys"));
-
-  /* Tell the gpg object about the data.  */
   if (!err)
     err = add_arg (gpg, "--");
-  if (!err && pattern && *pattern)
+
+  if (pattern)
     {
-      while (*pattern && **pattern)
+      while (!err && *pattern && **pattern)
        err = add_arg (gpg, *(pattern++));
     }
 
@@ -1534,7 +1963,7 @@ gpg_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
          gpgme_sig_mode_t mode, int use_armor, int use_textmode,
          int include_certs, gpgme_ctx_t ctx /* FIXME */)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   if (mode == GPGME_SIG_MODE_CLEAR)
@@ -1547,11 +1976,21 @@ gpg_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
       if (!err && use_armor)
        err = add_arg (gpg, "--armor");
       if (!err && use_textmode)
-       add_arg (gpg, "--textmode");
+       err = add_arg (gpg, "--textmode");
     }
 
   if (!err)
     err = append_args_from_signers (gpg, ctx);
+  if (!err)
+    err = append_args_from_sig_notations (gpg, ctx);
+
+  if (gpgme_data_get_file_name (in))
+    {
+      if (!err)
+       err = add_arg (gpg, "--set-filename");
+      if (!err)
+       err = add_arg (gpg, gpgme_data_get_file_name (in));
+    }
 
   /* Tell the gpg object about the data.  */
   if (!err)
@@ -1568,7 +2007,7 @@ gpg_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
 static gpgme_error_t
 gpg_trustlist (void *engine, const char *pattern)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err;
 
   err = add_arg (gpg, "--with-colons");
@@ -1592,7 +2031,7 @@ static gpgme_error_t
 gpg_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
            gpgme_data_t plaintext)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
   gpgme_error_t err = 0;
 
   if (plaintext)
@@ -1635,7 +2074,7 @@ gpg_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
 static void
 gpg_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   gpg->io_cbs = *io_cbs;
 }
@@ -1651,15 +2090,18 @@ struct engine_ops _gpgme_engine_ops_gpg =
 
     /* Member functions.  */
     gpg_release,
+    NULL,                              /* reset */
     gpg_set_status_handler,
     gpg_set_command_handler,
     gpg_set_colon_line_handler,
+    gpg_set_locale,
     gpg_decrypt,
     gpg_delete,
     gpg_edit,
     gpg_encrypt,
     gpg_encrypt_sign,
     gpg_export,
+    gpg_export_ext,
     gpg_genkey,
     gpg_import,
     gpg_keylist,
@@ -1668,5 +2110,6 @@ struct engine_ops _gpgme_engine_ops_gpg =
     gpg_trustlist,
     gpg_verify,
     gpg_set_io_cbs,
-    gpg_io_event
+    gpg_io_event,
+    gpg_cancel
   };