doc/
[gpgme.git] / gpgme / rungpg.c
index 2aaa72c..9f992b7 100644 (file)
@@ -70,7 +70,7 @@ struct fd_data_map_s
 };
 
 
-struct gpg_object_s
+struct engine_gpg
 {
   struct arg_and_data_s *arglist;
   struct arg_and_data_s **argtail;
@@ -124,13 +124,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 +140,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)
@@ -182,7 +182,7 @@ close_notify_handler (int fd, void *opaque)
 }
 
 static gpgme_error_t
-add_arg (GpgObject gpg, const char *arg)
+add_arg (engine_gpg_t gpg, const char *arg)
 {
   struct arg_and_data_s *a;
 
@@ -193,7 +193,7 @@ add_arg (GpgObject gpg, const char *arg)
   if (!a)
     {
       gpg->arg_error = 1;
-      return GPGME_Out_Of_Core;
+      return gpg_error_from_errno (errno);
     }
   a->next = NULL;
   a->data = NULL;
@@ -205,7 +205,7 @@ add_arg (GpgObject gpg, const char *arg)
 }
 
 static gpgme_error_t
-add_data (GpgObject gpg, gpgme_data_t data, int dup_to, int inbound)
+add_data (engine_gpg_t gpg, gpgme_data_t data, int dup_to, int inbound)
 {
   struct arg_and_data_s *a;
 
@@ -216,7 +216,7 @@ add_data (GpgObject gpg, gpgme_data_t data, int dup_to, int inbound)
   if (!a)
     {
       gpg->arg_error = 1;
-      return GPGME_Out_Of_Core;
+      return gpg_error_from_errno (errno);
     }
   a->next = NULL;
   a->data = data;
@@ -292,7 +292,7 @@ free_fd_data_map (struct fd_data_map_s *fd_data_map)
 static void
 gpg_release (void *engine)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   if (!gpg)
     return;
@@ -334,17 +334,14 @@ gpg_release (void *engine)
 static gpgme_error_t
 gpg_new (void **engine)
 {
-  GpgObject gpg;
-  int rc = 0;
+  engine_gpg_t gpg;
+  gpgme_error_t rc = 0;
 
   gpg = calloc (1, sizeof *gpg);
   if (!gpg)
-    {
-      rc = GPGME_Out_Of_Core;
-      goto leave;
-    }
-  gpg->argtail = &gpg->arglist;
+    return gpg_error_from_errno (errno);
 
+  gpg->argtail = &gpg->arglist;
   gpg->status.fd[0] = -1;
   gpg->status.fd[1] = -1;
   gpg->colon.fd[0] = -1;
@@ -360,14 +357,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],
@@ -375,7 +372,7 @@ 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;
@@ -405,7 +402,7 @@ static void
 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;
@@ -416,24 +413,25 @@ static gpgme_error_t
 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;
@@ -445,7 +443,7 @@ static gpgme_error_t
 command_handler (void *opaque, int fd)
 {
   gpgme_error_t err;
-  GpgObject gpg = (GpgObject) opaque;
+  engine_gpg_t gpg = (engine_gpg_t) opaque;
 
   assert (gpg->cmd.used);
   assert (gpg->cmd.code);
@@ -477,7 +475,7 @@ static gpgme_error_t
 gpg_set_command_handler (void *engine, engine_command_handler_t fnc,
                         void *fnc_value, gpgme_data_t linked_data)
 {
-  GpgObject gpg = engine;
+  engine_gpg_t gpg = engine;
 
   add_arg (gpg, "--command-fd");
   /* This is a hack.  We don't have a real data object.  The only
@@ -494,7 +492,7 @@ gpg_set_command_handler (void *engine, engine_command_handler_t fnc,
 
 
 static gpgme_error_t
-build_argv (GpgObject gpg)
+build_argv (engine_gpg_t gpg)
 {
   struct arg_and_data_s *a;
   struct fd_data_map_s *fd_data_map;
@@ -547,21 +545,23 @@ build_argv (GpgObject gpg)
 
   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)
@@ -569,9 +569,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++;
     }
@@ -580,9 +581,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++;
     }
@@ -591,26 +593,29 @@ 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])
     {
+      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 ("");
   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)
@@ -627,9 +632,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)
@@ -637,7 +643,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)
@@ -674,9 +680,10 @@ build_argv (GpgObject gpg)
              argv[argc] = malloc (25);
              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",
@@ -690,9 +697,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++;
         }
@@ -705,7 +713,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;
@@ -738,7 +746,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;
@@ -753,13 +761,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)
     {
@@ -810,7 +818,7 @@ read_status (GpgObject gpg)
                            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.  */
@@ -898,7 +906,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]);
@@ -912,7 +920,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;
@@ -927,12 +935,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)
     {
@@ -992,7 +1000,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]);
@@ -1006,23 +1014,24 @@ 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 (! _gpgme_get_gpg_path ())
-    return GPGME_Invalid_Engine;
+    return gpg_error (GPG_ERR_INV_ENGINE);
 
   /* 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;
+    return gpg_error (GPG_ERR_ENOMEM);
 
   rc = build_argv (gpg);
   if (rc)
@@ -1033,7 +1042,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 */
@@ -1081,9 +1090,10 @@ start (GpgObject gpg)
 
   status = _gpgme_io_spawn (_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 (errno);
 
   /*_gpgme_register_term_handler ( closure, closure_value, pid );*/
 
@@ -1136,7 +1146,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");
@@ -1159,7 +1169,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"
@@ -1169,7 +1179,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);
     }
@@ -1181,7 +1191,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;
@@ -1208,7 +1218,7 @@ static gpgme_error_t
 gpg_edit (void *engine, 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");
@@ -1224,7 +1234,7 @@ gpg_edit (void *engine, gpgme_key_t key, gpgme_data_t out,
     {
       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);
     }
@@ -1236,28 +1246,32 @@ gpg_edit (void *engine, gpgme_key_t key, gpgme_data_t out,
 
 
 static gpgme_error_t
-append_args_from_recipients (GpgObject gpg, gpgme_user_id_t uid)
+append_args_from_recipients (engine_gpg_t gpg, gpgme_key_t recp[])
 {
   gpgme_error_t err = 0;
+  int i = 0;
 
-  while (uid)
+  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;
-      uid = uid->next;
+      i++;
     }    
   return err;
 }
 
 
 static gpgme_error_t
-gpg_encrypt (void *engine, gpgme_user_id_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;
 
@@ -1270,7 +1284,7 @@ gpg_encrypt (void *engine, gpgme_user_id_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_user_ids_all_valid (recp))
+      if (!err && !symmetric && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
        err = add_arg (gpg, "--always-trust");
 
       if (!err)
@@ -1297,11 +1311,12 @@ gpg_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
 
 
 static gpgme_error_t
-gpg_encrypt_sign (void *engine, gpgme_user_id_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");
@@ -1311,8 +1326,8 @@ gpg_encrypt_sign (void *engine, gpgme_user_id_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_user_ids_all_valid (recp))
+     we can suppress further checks.  */
+  if (!err && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
     err = add_arg (gpg, "--always-trust");
 
   if (!err)
@@ -1341,12 +1356,43 @@ gpg_encrypt_sign (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
 
 
 static gpgme_error_t
-gpg_export (void *engine, gpgme_user_id_t uids, gpgme_data_t keydata,
-           int use_armor)
+gpg_export (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 (!err && pattern && *pattern)
+    err = add_arg (gpg, pattern);
+
+  if (!err)
+    err = start (gpg);
+
+  return err;
+}
+
+
+static gpgme_error_t
+gpg_export_ext (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");
@@ -1355,10 +1401,10 @@ gpg_export (void *engine, gpgme_user_id_t uids, gpgme_data_t keydata,
   if (!err)
     err = add_arg (gpg, "--");
 
-  while (!err && uids)
+  if (pattern)
     {
-      err = add_arg (gpg, uids->uid);
-      uids = uids->next;
+      while (!err && *pattern && **pattern)
+       err = add_arg (gpg, *(pattern++));
     }
 
   if (!err)
@@ -1372,18 +1418,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)
@@ -1401,7 +1447,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");
@@ -1417,9 +1463,9 @@ gpg_import (void *engine, gpgme_data_t keydata)
 
 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;
 
   err = add_arg (gpg, "--with-colons");
@@ -1431,7 +1477,7 @@ gpg_keylist (void *engine, const char *pattern, int secret_only,
     err = add_arg (gpg, "--with-fingerprint");
   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.  */
@@ -1449,13 +1495,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)
@@ -1466,15 +1512,14 @@ gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
     err = add_arg (gpg, "--with-fingerprint");
   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++));
     }
 
@@ -1490,7 +1535,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)
@@ -1524,7 +1569,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");
@@ -1548,7 +1593,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)
@@ -1591,7 +1636,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;
 }
@@ -1616,6 +1661,7 @@ struct engine_ops _gpgme_engine_ops_gpg =
     gpg_encrypt,
     gpg_encrypt_sign,
     gpg_export,
+    gpg_export_ext,
     gpg_genkey,
     gpg_import,
     gpg_keylist,