doc/
[gpgme.git] / gpgme / gpgme.h
index 2fc4d67..ed1d25b 100644 (file)
@@ -1,30 +1,32 @@
-/* gpgme.h -  GnuPG Made Easy
- *     Copyright (C) 2000 Werner Koch (dd9jn)
- *      Copyright (C) 2001, 2002 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.
- *
- * 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 this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
+/* gpgme.h - Public interface to GnuPG Made Easy.
+   Copyright (C) 2000 Werner Koch (dd9jn)
+   Copyright (C) 2001, 2002, 2003 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.
+   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.  */
 
 #ifndef GPGME_H
 #define GPGME_H
 
-#include <stdio.h> /* For FILE *.  */
+/* Include stdio.h for the FILE type definition.  */
+#include <stdio.h>
+
 #ifdef _MSC_VER
   typedef long off_t;
+  typedef long ssize_t;
 #else
 # include <sys/types.h>
 #endif
@@ -36,93 +38,164 @@ extern "C" {
 #endif
 #endif
 
+#include <gpg-error.h>
+
+\f
+/* Check for compiler features.  */
+#if __GNUC__
+#define _GPGME_GCC_VERSION (__GNUC__ * 10000 \
+                            + __GNUC_MINOR__ * 100 \
+                            + __GNUC_PATCHLEVEL__)
+
+#if _GPGME_GCC_VERSION > 30100
+#define _GPGME_DEPRECATED      __attribute__ ((__deprecated__))
+#endif
+#endif
 
+#ifndef _GPGME_DEPRECATED
+#define _GPGME_DEPRECATED
+#endif
+
+\f
 /* The version of this header should match the one of the library.  Do
    not use this symbol in your application, use gpgme_check_version
    instead.  The purpose of this macro is to let autoconf (using the
    AM_PATH_GPGME macro) check that this header matches the installed
    library.  Warning: Do not edit the next line.  configure will do
    that for you!  */
-#define GPGME_VERSION "0.3.10"
+#define GPGME_VERSION "0.4.2"
 
+\f
+/* Some opaque data types used by GPGME.  */
 
-/* The opaque data types used by GPGME.  */
-
-/* The context holds some global state and configration options as
+/* The context holds some global state and configration options, as
    well as the results of a crypto operation.  */
-struct gpgme_context_s;
-typedef struct gpgme_context_s *GpgmeCtx;
+struct gpgme_context;
+typedef struct gpgme_context *gpgme_ctx_t;
 
-/* The data object used by GPGME to exchange arbitrary data.  */
-struct gpgme_data_s;
-typedef struct gpgme_data_s *GpgmeData;
+/* The data object is used by GPGME to exchange arbitrary data.  */
+struct gpgme_data;
+typedef struct gpgme_data *gpgme_data_t;
 
-/* A list of recipients to be used in an encryption operation.  */
-struct gpgme_recipients_s;
-typedef struct gpgme_recipients_s *GpgmeRecipients;
+\f
+/* Wrappers for the libgpg-error library.  */
 
-/* A key from the keyring.  */
-struct gpgme_key_s;
-typedef struct gpgme_key_s *GpgmeKey;
+typedef gpg_error_t gpgme_error_t;
+typedef gpg_err_code_t gpgme_err_code_t;
+typedef gpg_err_source_t gpgme_err_source_t;
+
+
+static __inline__ gpgme_error_t
+gpgme_err_make (gpgme_err_source_t source, gpgme_err_code_t code)
+{
+  return gpg_err_make (source, code);
+}
+
+
+/* The user can define GPG_ERR_SOURCE_DEFAULT before including this
+   file to specify a default source for gpg_error.  */
+#ifndef GPGME_ERR_SOURCE_DEFAULT
+#define GPGME_ERR_SOURCE_DEFAULT  GPG_ERR_SOURCE_USER_1
+#endif
+
+static __inline__ gpgme_error_t
+gpgme_error (gpgme_err_code_t code)
+{
+  return gpgme_err_make (GPGME_ERR_SOURCE_DEFAULT, code);
+}
+
+
+static __inline__ gpgme_err_code_t
+gpgme_err_code (gpgme_error_t err)
+{
+  return gpg_err_code (err);
+}
+
+
+static __inline__ gpgme_err_source_t
+gpgme_err_source (gpgme_error_t err)
+{
+  return gpg_err_source (err);
+}
+
+
+/* Return a pointer to a string containing a description of the error
+   code in the error value ERR.  */
+const char *gpgme_strerror (gpgme_error_t err);
+
+
+/* Return a pointer to a string containing a description of the error
+   source in the error value ERR.  */
+const char *gpgme_strsource (gpgme_error_t err);
+
+
+/* Retrieve the error code for the system error ERR.  This returns
+   GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
+   this).  */
+gpgme_err_code_t gpgme_err_code_from_errno (int err);
+
+
+/* Retrieve the system error for the error code CODE.  This returns 0
+   if CODE is not a system error code.  */
+int gpgme_err_code_to_errno (gpgme_err_code_t code);
+
+  
+/* Return an error value with the error source SOURCE and the system
+   error ERR.  */
+gpgme_error_t gpgme_err_make_from_errno (gpgme_err_source_t source, int err);
 
-/* A trust item.  */
-struct gpgme_trust_item_s;
-typedef struct gpgme_trust_item_s *GpgmeTrustItem;
 
+/* Return an error value with the system error ERR.  */
+gpgme_err_code_t gpgme_error_from_errno (int err);
 
-/* The error numbers used by GPGME.  */
+\f
+/* The possible encoding mode of gpgme_data_t objects.  */
 typedef enum
   {
-    GPGME_EOF                = -1,
-    GPGME_No_Error           = 0,
-    GPGME_General_Error      = 1,
-    GPGME_Out_Of_Core        = 2,
-    GPGME_Invalid_Value      = 3,
-    GPGME_Busy               = 4,
-    GPGME_No_Request         = 5,
-    GPGME_Exec_Error         = 6,
-    GPGME_Too_Many_Procs     = 7,
-    GPGME_Pipe_Error         = 8,
-    GPGME_No_Recipients      = 9,
-    GPGME_No_Data            = 10,
-    GPGME_Conflict           = 11,
-    GPGME_Not_Implemented    = 12,
-    GPGME_Read_Error         = 13,
-    GPGME_Write_Error        = 14,
-    GPGME_Invalid_Type       = 15,
-    GPGME_Invalid_Mode       = 16,
-    GPGME_File_Error         = 17,  /* errno is set in this case.  */
-    GPGME_Decryption_Failed  = 18,
-    GPGME_No_Passphrase      = 19,
-    GPGME_Canceled           = 20,
-    GPGME_Invalid_Key        = 21,
-    GPGME_Invalid_Engine     = 22,
-    GPGME_Invalid_Recipients = 23
+    GPGME_DATA_ENCODING_NONE   = 0,    /* Not specified.  */
+    GPGME_DATA_ENCODING_BINARY = 1,
+    GPGME_DATA_ENCODING_BASE64 = 2,
+    GPGME_DATA_ENCODING_ARMOR  = 3     /* Either PEM or OpenPGP Armor.  */
   }
-GpgmeError;
+gpgme_data_encoding_t;
 
-/* The possible types of GpgmeData objects.  */
+\f
+/* Public key algorithms from libgcrypt.  */
 typedef enum
   {
-    GPGME_DATA_TYPE_NONE = 0,
-    GPGME_DATA_TYPE_MEM  = 1,
-    GPGME_DATA_TYPE_FD   = 2,
-    GPGME_DATA_TYPE_FILE = 3,
-    GPGME_DATA_TYPE_CB   = 4
+    GPGME_PK_RSA   = 1,
+    GPGME_PK_RSA_E = 2,
+    GPGME_PK_RSA_S = 3,
+    GPGME_PK_ELG_E = 16,
+    GPGME_PK_DSA   = 17,
+    GPGME_PK_ELG   = 20
   }
-GpgmeDataType;
+gpgme_pubkey_algo_t;
+
 
-/* The possible encoding mode of GpgmeData objects.  */
+/* Hash algorithms from libgcrypt.  */
 typedef enum
   {
-    GPGME_DATA_ENCODING_NONE   = 0, /* i.e. not specified */
-    GPGME_DATA_ENCODING_BINARY = 1,
-    GPGME_DATA_ENCODING_BASE64 = 2, 
-    GPGME_DATA_ENCODING_ARMOR  = 3 /* Either PEM or OpenPGP Armor */
+    GPGME_MD_NONE          = 0,  
+    GPGME_MD_MD5           = 1,
+    GPGME_MD_SHA1          = 2,
+    GPGME_MD_RMD160        = 3,
+    GPGME_MD_MD2           = 5,
+    GPGME_MD_TIGER         = 6,   /* TIGER/192. */
+    GPGME_MD_HAVAL         = 7,   /* HAVAL, 5 pass, 160 bit. */
+    GPGME_MD_SHA256        = 8,
+    GPGME_MD_SHA384        = 9,
+    GPGME_MD_SHA512        = 10,
+    GPGME_MD_MD4           = 301,
+    GPGME_MD_CRC32        = 302,
+    GPGME_MD_CRC32_RFC1510 = 303,
+    GPGME_MD_CRC24_RFC2440 = 304
   }
-GpgmeDataEncoding;
+gpgme_hash_algo_t;
 
-/* The possible signature stati.  */
+\f
+/* The possible signature stati.  Deprecated, use error value in sig
+   status.  */
 typedef enum
   {
     GPGME_SIG_STAT_NONE  = 0,
@@ -135,23 +208,8 @@ typedef enum
     GPGME_SIG_STAT_GOOD_EXP = 7,
     GPGME_SIG_STAT_GOOD_EXPKEY = 8
   }
-GpgmeSigStat;
-
-/* Flags used with the GPGME_ATTR_SIG_SUMMARY. */
-enum 
-  {
-    GPGME_SIGSUM_VALID       = 0x0001,  /* The signature is fully valid */
-    GPGME_SIGSUM_GREEN       = 0x0002,  /* The signature is good. */
-    GPGME_SIGSUM_RED         = 0x0004,  /* The signature is bad. */
-    GPGME_SIGSUM_KEY_REVOKED = 0x0010,  /* One key has been revoked. */
-    GPGME_SIGSUM_KEY_EXPIRED = 0x0020,  /* One key has expired. */
-    GPGME_SIGSUM_SIG_EXPIRED = 0x0040,  /* The signature has expired. */
-    GPGME_SIGSUM_KEY_MISSING = 0x0080,  /* Can't verify: key missing. */
-    GPGME_SIGSUM_CRL_MISSING = 0x0100,  /* CRL not available. */
-    GPGME_SIGSUM_CRL_TOO_OLD = 0x0200,  /* Available CRL is too old. */
-    GPGME_SIGSUM_BAD_POLICY  = 0x0400,  /* A policy was not met. */
-    GPGME_SIGSUM_SYS_ERROR   = 0x0800   /* A system error occured. */
-  };
+_gpgme_sig_stat_t;
+typedef _gpgme_sig_stat_t gpgme_sig_stat_t _GPGME_DEPRECATED;
 
 
 /* The available signature modes.  */
@@ -161,9 +219,11 @@ typedef enum
     GPGME_SIG_MODE_DETACH = 1,
     GPGME_SIG_MODE_CLEAR  = 2
   }
-GpgmeSigMode;
+gpgme_sig_mode_t;
 
-/* The available key and signature attributes.  */
+\f
+/* The available key and signature attributes.  Deprecated, use the
+   individual result structures instead.  */
 typedef enum
   {
     GPGME_ATTR_KEYID        = 1,
@@ -196,10 +256,13 @@ typedef enum
     GPGME_ATTR_CHAINID      = 28,
     GPGME_ATTR_SIG_STATUS   = 29,
     GPGME_ATTR_ERRTOK       = 30,
-    GPGME_ATTR_SIG_SUMMARY  = 31
+    GPGME_ATTR_SIG_SUMMARY  = 31,
+    GPGME_ATTR_SIG_CLASS    = 32
   }
-GpgmeAttr;
+_gpgme_attr_t;
+typedef _gpgme_attr_t gpgme_attr_t _GPGME_DEPRECATED;
 
+\f
 /* The available validities for a trust item or key.  */
 typedef enum
   {
@@ -210,545 +273,1222 @@ typedef enum
     GPGME_VALIDITY_FULL      = 4,
     GPGME_VALIDITY_ULTIMATE  = 5
   }
-GpgmeValidity;
+gpgme_validity_t;
 
+\f
 /* The available protocols.  */
 typedef enum
   {
     GPGME_PROTOCOL_OpenPGP = 0,  /* The default mode.  */
     GPGME_PROTOCOL_CMS     = 1,
-    GPGME_PROTOCOL_AUTO    = 2
   }
-GpgmeProtocol;
-
+gpgme_protocol_t;
 
+\f
 /* The possible stati for the edit operation.  */
-
-typedef enum  {
+typedef enum
+  {
     GPGME_STATUS_EOF,
-    /* mkstatus starts here */
-    GPGME_STATUS_ENTER             , 
-    GPGME_STATUS_LEAVE             ,
-    GPGME_STATUS_ABORT              ,
-
-    GPGME_STATUS_GOODSIG            ,
-    GPGME_STATUS_BADSIG                    ,
-    GPGME_STATUS_ERRSIG                    ,
-
-    GPGME_STATUS_BADARMOR           ,
-
-    GPGME_STATUS_RSA_OR_IDEA        ,
-    GPGME_STATUS_KEYEXPIRED         ,
-    GPGME_STATUS_KEYREVOKED         ,
-
-    GPGME_STATUS_TRUST_UNDEFINED    ,
-    GPGME_STATUS_TRUST_NEVER        ,
-    GPGME_STATUS_TRUST_MARGINAL     ,
-    GPGME_STATUS_TRUST_FULLY        ,
-    GPGME_STATUS_TRUST_ULTIMATE     ,
-
-    GPGME_STATUS_SHM_INFO           ,
-    GPGME_STATUS_SHM_GET           ,
-    GPGME_STATUS_SHM_GET_BOOL       ,
-    GPGME_STATUS_SHM_GET_HIDDEN     ,
-
-    GPGME_STATUS_NEED_PASSPHRASE    ,
-    GPGME_STATUS_VALIDSIG           ,
-    GPGME_STATUS_SIG_ID                    ,
-    GPGME_STATUS_ENC_TO                    ,
-    GPGME_STATUS_NODATA                    ,
-    GPGME_STATUS_BAD_PASSPHRASE     ,
-    GPGME_STATUS_NO_PUBKEY          ,
-    GPGME_STATUS_NO_SECKEY          ,
+    /* mkstatus processing starts here */
+    GPGME_STATUS_ENTER,
+    GPGME_STATUS_LEAVE,
+    GPGME_STATUS_ABORT,
+
+    GPGME_STATUS_GOODSIG,
+    GPGME_STATUS_BADSIG,
+    GPGME_STATUS_ERRSIG,
+
+    GPGME_STATUS_BADARMOR,
+
+    GPGME_STATUS_RSA_OR_IDEA,
+    GPGME_STATUS_KEYEXPIRED,
+    GPGME_STATUS_KEYREVOKED,
+
+    GPGME_STATUS_TRUST_UNDEFINED,
+    GPGME_STATUS_TRUST_NEVER,
+    GPGME_STATUS_TRUST_MARGINAL,
+    GPGME_STATUS_TRUST_FULLY,
+    GPGME_STATUS_TRUST_ULTIMATE,
+
+    GPGME_STATUS_SHM_INFO,
+    GPGME_STATUS_SHM_GET,
+    GPGME_STATUS_SHM_GET_BOOL,
+    GPGME_STATUS_SHM_GET_HIDDEN,
+
+    GPGME_STATUS_NEED_PASSPHRASE,
+    GPGME_STATUS_VALIDSIG,
+    GPGME_STATUS_SIG_ID,
+    GPGME_STATUS_ENC_TO,
+    GPGME_STATUS_NODATA,
+    GPGME_STATUS_BAD_PASSPHRASE,
+    GPGME_STATUS_NO_PUBKEY,
+    GPGME_STATUS_NO_SECKEY,
     GPGME_STATUS_NEED_PASSPHRASE_SYM,
-    GPGME_STATUS_DECRYPTION_FAILED  ,
-    GPGME_STATUS_DECRYPTION_OKAY    ,
-    GPGME_STATUS_MISSING_PASSPHRASE ,
-    GPGME_STATUS_GOOD_PASSPHRASE    ,
-    GPGME_STATUS_GOODMDC            ,
-    GPGME_STATUS_BADMDC                    ,
-    GPGME_STATUS_ERRMDC                    ,
-    GPGME_STATUS_IMPORTED          ,
-    GPGME_STATUS_IMPORT_RES        ,
-    GPGME_STATUS_FILE_START        ,
-    GPGME_STATUS_FILE_DONE         ,
-    GPGME_STATUS_FILE_ERROR        ,
-
-    GPGME_STATUS_BEGIN_DECRYPTION   ,
-    GPGME_STATUS_END_DECRYPTION     ,
-    GPGME_STATUS_BEGIN_ENCRYPTION   ,
-    GPGME_STATUS_END_ENCRYPTION     ,
-
-    GPGME_STATUS_DELETE_PROBLEM     ,
-    GPGME_STATUS_GET_BOOL          ,
-    GPGME_STATUS_GET_LINE          ,
-    GPGME_STATUS_GET_HIDDEN        ,
-    GPGME_STATUS_GOT_IT                    ,
-    GPGME_STATUS_PROGRESS          ,
-    GPGME_STATUS_SIG_CREATED       ,
-    GPGME_STATUS_SESSION_KEY        ,
-    GPGME_STATUS_NOTATION_NAME      ,
-    GPGME_STATUS_NOTATION_DATA      ,
-    GPGME_STATUS_POLICY_URL         ,
-    GPGME_STATUS_BEGIN_STREAM       ,
-    GPGME_STATUS_END_STREAM         ,
-    GPGME_STATUS_KEY_CREATED       ,
-    GPGME_STATUS_USERID_HINT       ,
-    GPGME_STATUS_UNEXPECTED         ,
-    GPGME_STATUS_INV_RECP           ,
-    GPGME_STATUS_NO_RECP            ,
-    GPGME_STATUS_ALREADY_SIGNED     ,
-    GPGME_STATUS_SIGEXPIRED         ,
-    GPGME_STATUS_EXPSIG             ,
-    GPGME_STATUS_EXPKEYSIG          ,
-    GPGME_STATUS_TRUNCATED          ,
-    GPGME_STATUS_ERROR              
-} GpgmeStatusCode;
+    GPGME_STATUS_DECRYPTION_FAILED,
+    GPGME_STATUS_DECRYPTION_OKAY,
+    GPGME_STATUS_MISSING_PASSPHRASE,
+    GPGME_STATUS_GOOD_PASSPHRASE,
+    GPGME_STATUS_GOODMDC,
+    GPGME_STATUS_BADMDC,
+    GPGME_STATUS_ERRMDC,
+    GPGME_STATUS_IMPORTED,
+    GPGME_STATUS_IMPORT_OK,
+    GPGME_STATUS_IMPORT_PROBLEM,
+    GPGME_STATUS_IMPORT_RES,
+    GPGME_STATUS_FILE_START,
+    GPGME_STATUS_FILE_DONE,
+    GPGME_STATUS_FILE_ERROR,
+
+    GPGME_STATUS_BEGIN_DECRYPTION,
+    GPGME_STATUS_END_DECRYPTION,
+    GPGME_STATUS_BEGIN_ENCRYPTION,
+    GPGME_STATUS_END_ENCRYPTION,
+
+    GPGME_STATUS_DELETE_PROBLEM,
+    GPGME_STATUS_GET_BOOL,
+    GPGME_STATUS_GET_LINE,
+    GPGME_STATUS_GET_HIDDEN,
+    GPGME_STATUS_GOT_IT,
+    GPGME_STATUS_PROGRESS,
+    GPGME_STATUS_SIG_CREATED,
+    GPGME_STATUS_SESSION_KEY,
+    GPGME_STATUS_NOTATION_NAME,
+    GPGME_STATUS_NOTATION_DATA,
+    GPGME_STATUS_POLICY_URL,
+    GPGME_STATUS_BEGIN_STREAM,
+    GPGME_STATUS_END_STREAM,
+    GPGME_STATUS_KEY_CREATED,
+    GPGME_STATUS_USERID_HINT,
+    GPGME_STATUS_UNEXPECTED,
+    GPGME_STATUS_INV_RECP,
+    GPGME_STATUS_NO_RECP,
+    GPGME_STATUS_ALREADY_SIGNED,
+    GPGME_STATUS_SIGEXPIRED,
+    GPGME_STATUS_EXPSIG,
+    GPGME_STATUS_EXPKEYSIG,
+    GPGME_STATUS_TRUNCATED,
+    GPGME_STATUS_ERROR
+  }
+gpgme_status_code_t;
 
+\f
+/* The engine information structure.  */
+struct _gpgme_engine_info
+{
+  struct _gpgme_engine_info *next;
 
-/* The available keylist mode flags.  */
-#define GPGME_KEYLIST_MODE_LOCAL  1
-#define GPGME_KEYLIST_MODE_EXTERN 2
-#define GPGME_KEYLIST_MODE_SIGS   4
+  /* The protocol ID.  */
+  gpgme_protocol_t protocol;
+
+  /* The file name of the engine binary.  */
+  const char *file_name;
+
+  /* The version string of the installed engine.  */
+  const char *version;
+
+  /* The minimum version required for GPGME.  */
+  const char *req_version;
+};
+typedef struct _gpgme_engine_info *gpgme_engine_info_t;
+
+\f
+/* A subkey from a key.  */
+struct _gpgme_subkey
+{
+  struct _gpgme_subkey *next;
+
+  /* True if subkey is revoked.  */
+  unsigned int revoked : 1;
+
+  /* True if subkey is expired.  */
+  unsigned int expired : 1;
+
+  /* True if subkey is disabled.  */
+  unsigned int disabled : 1;
+
+  /* True if subkey is invalid.  */
+  unsigned int invalid : 1;
+
+  /* True if subkey can be used for encryption.  */
+  unsigned int can_encrypt : 1;
+
+  /* True if subkey can be used for signing.  */
+  unsigned int can_sign : 1;
+
+  /* True if subkey can be used for certification.  */
+  unsigned int can_certify : 1;
+
+  /* True if subkey is secret.  */
+  unsigned int secret : 1;
+
+  /* True if subkey can be used for authentication.  */
+  unsigned int can_authenticate : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 23;
+  
+  /* Public key algorithm supported by this subkey.  */
+  gpgme_pubkey_algo_t pubkey_algo;
+
+  /* Length of the subkey.  */
+  unsigned int length;
+
+  /* The key ID of the subkey.  */
+  char *keyid;
+
+  /* Internal to GPGME, do not use.  */
+  char _keyid[16 + 1];
+
+  /* The fingerprint of the subkey in hex digit form.  */
+  char *fpr;
+
+  /* The creation timestamp, -1 if invalid, 0 if not available.  */
+  long int timestamp;
+
+  /* The expiration timestamp, 0 if the subkey does not expire.  */
+  long int expires;
+};
+typedef struct _gpgme_subkey *gpgme_subkey_t;
 
+
+/* A signature on a user ID.  */
+struct _gpgme_key_sig
+{
+  struct _gpgme_key_sig *next;
+
+  /* True if the signature is revoked.  */
+  unsigned int revoked : 1;
+
+  /* True if the signature is expired.  */
+  unsigned int expired : 1;
+
+  /* True if the signature is invalid.  */
+  unsigned int invalid : 1;
+
+  /* True if the signature should be exported.  */
+  unsigned int exportable : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 28;
+
+  /* The public key algorithm used to create the signature.  */
+  gpgme_pubkey_algo_t pubkey_algo;
+
+  /* The key ID of key used to create the signature.  */
+  char *keyid;
+
+  /* Internal to GPGME, do not use.  */
+  char _keyid[16 + 1];
+
+  /* The creation timestamp, -1 if invalid, 0 if not available.  */
+  long int timestamp;
+
+  /* The expiration timestamp, 0 if the subkey does not expire.  */
+  long int expires;
+
+  /* Same as in gpgme_signature_t.  */
+  gpgme_error_t status;
+
+  /* Crypto backend specific signature class.  */
+  unsigned int class;
+
+  /* The user ID string.  */
+  char *uid;
+
+  /* The name part of the user ID.  */
+  char *name;
+
+  /* The email part of the user ID.  */
+  char *email;
+
+  /* The comment part of the user ID.  */
+  char *comment;
+};
+typedef struct _gpgme_key_sig *gpgme_key_sig_t;
+
+
+/* An user ID from a key.  */
+struct _gpgme_user_id
+{
+  struct _gpgme_user_id *next;
+
+  /* True if the user ID is revoked.  */
+  unsigned int revoked : 1;
+
+  /* True if the user ID is invalid.  */
+  unsigned int invalid : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 30;
+
+  /* The validity of the user ID.  */
+  gpgme_validity_t validity; 
+
+  /* The user ID string.  */
+  char *uid;
+
+  /* The name part of the user ID.  */
+  char *name;
+
+  /* The email part of the user ID.  */
+  char *email;
+
+  /* The comment part of the user ID.  */
+  char *comment;
+
+  /* The signatures of the user ID.  */
+  gpgme_key_sig_t signatures;
+
+  /* Internal to GPGME, do not use.  */
+  gpgme_key_sig_t _last_keysig;
+};
+typedef struct _gpgme_user_id *gpgme_user_id_t;
+
+
+/* A key from the keyring.  */
+struct _gpgme_key
+{
+  /* Internal to GPGME, do not use.  */
+  unsigned int _refs;
+
+  /* True if key is revoked.  */
+  unsigned int revoked : 1;
+
+  /* True if key is expired.  */
+  unsigned int expired : 1;
+
+  /* True if key is disabled.  */
+  unsigned int disabled : 1;
+
+  /* True if key is invalid.  */
+  unsigned int invalid : 1;
+
+  /* True if key can be used for encryption.  */
+  unsigned int can_encrypt : 1;
+
+  /* True if key can be used for signing.  */
+  unsigned int can_sign : 1;
+
+  /* True if key can be used for certification.  */
+  unsigned int can_certify : 1;
+
+  /* True if key is secret.  */
+  unsigned int secret : 1;
+
+  /* True if key can be used for authentication.  */
+  unsigned int can_authenticate : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 23;
+
+  /* This is the protocol supported by this key.  */
+  gpgme_protocol_t protocol;
+
+  /* If protocol is GPGME_PROTOCOL_CMS, this string contains the
+     issuer serial.  */
+  char *issuer_serial;
+
+  /* If protocol is GPGME_PROTOCOL_CMS, this string contains the
+     issuer name.  */
+  char *issuer_name;
+
+  /* If protocol is GPGME_PROTOCOL_CMS, this string contains the chain
+     ID.  */
+  char *chain_id;
+
+  /* If protocol is GPGME_PROTOCOL_OpenPGP, this field contains the
+     owner trust.  */
+  gpgme_validity_t owner_trust;
+
+  /* The subkeys of the key.  */
+  gpgme_subkey_t subkeys;
+
+  /* The user IDs of the key.  */
+  gpgme_user_id_t uids;
+
+  /* Internal to GPGME, do not use.  */
+  gpgme_subkey_t _last_subkey;
+
+  /* Internal to GPGME, do not use.  */
+  gpgme_user_id_t _last_uid;
+};
+typedef struct _gpgme_key *gpgme_key_t;
+
+
+\f
 /* Types for callback functions.  */
 
 /* Request a passphrase from the user.  */
-typedef const char *(*GpgmePassphraseCb) (void *hook, const char *desc,
-                                         void **r_hd);
+typedef gpgme_error_t (*gpgme_passphrase_cb_t) (void *hook,
+                                               const char *uid_hint,
+                                               const char *passphrase_info,
+                                               int prev_was_bad, int fd);
 
 /* Inform the user about progress made.  */
-typedef void (*GpgmeProgressCb) (void *opaque, const char *what,
-                                int type, int current, int total);
+typedef void (*gpgme_progress_cb_t) (void *opaque, const char *what,
+                                    int type, int current, int total);
 
 /* Interact with the user about an edit operation.  */
-typedef GpgmeError (*GpgmeEditCb) (void *opaque, GpgmeStatusCode status,
-                                  const char *args, const char **reply);
+typedef gpgme_error_t (*gpgme_edit_cb_t) (void *opaque,
+                                         gpgme_status_code_t status,
+                                         const char *args, int fd);
 
+\f
 /* Context management functions.  */
 
 /* Create a new context and return it in CTX.  */
-GpgmeError gpgme_new (GpgmeCtx *ctx);
+gpgme_error_t gpgme_new (gpgme_ctx_t *ctx);
 
 /* Release the context CTX.  */
-void gpgme_release (GpgmeCtx ctx);
-
-/* Retrieve more info about performed signature check.  */
-char *gpgme_get_notation (GpgmeCtx ctx);
+void gpgme_release (gpgme_ctx_t ctx);
 
 /* Set the protocol to be used by CTX to PROTO.  */
-GpgmeError gpgme_set_protocol (GpgmeCtx ctx, GpgmeProtocol proto);
+gpgme_error_t gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t proto);
 
 /* Get the protocol used with CTX */
-GpgmeProtocol gpgme_get_protocol (GpgmeCtx ctx);
+gpgme_protocol_t gpgme_get_protocol (gpgme_ctx_t ctx);
+
+/* Get the string describing protocol PROTO, or NULL if invalid.  */
+const char *gpgme_get_protocol_name (gpgme_protocol_t proto);
 
 /* If YES is non-zero, enable armor mode in CTX, disable it otherwise.  */
-void gpgme_set_armor (GpgmeCtx ctx, int yes);
+void gpgme_set_armor (gpgme_ctx_t ctx, int yes);
 
 /* Return non-zero if armor mode is set in CTX.  */
-int gpgme_get_armor (GpgmeCtx ctx);
+int gpgme_get_armor (gpgme_ctx_t ctx);
 
 /* If YES is non-zero, enable text mode in CTX, disable it otherwise.  */
-void gpgme_set_textmode (GpgmeCtx ctx, int yes);
+void gpgme_set_textmode (gpgme_ctx_t ctx, int yes);
 
 /* Return non-zero if text mode is set in CTX.  */
-int gpgme_get_textmode (GpgmeCtx ctx);
+int gpgme_get_textmode (gpgme_ctx_t ctx);
 
 /* Include up to NR_OF_CERTS certificates in an S/MIME message.  */
-void gpgme_set_include_certs (GpgmeCtx ctx, int nr_of_certs);
+void gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs);
 
 /* Return the number of certs to include in an S/MIME message.  */
-int gpgme_get_include_certs (GpgmeCtx ctx);
+int gpgme_get_include_certs (gpgme_ctx_t ctx);
+
+/* The available keylist mode flags.  */
+typedef enum
+  {
+    GPGME_KEYLIST_MODE_LOCAL  = 1,
+    GPGME_KEYLIST_MODE_EXTERN = 2,
+    GPGME_KEYLIST_MODE_SIGS   = 4
+  }
+gpgme_keylist_mode_t;
 
 /* Set keylist mode in CTX to MODE.  */
-GpgmeError gpgme_set_keylist_mode (GpgmeCtx ctx, int mode);
+gpgme_error_t gpgme_set_keylist_mode (gpgme_ctx_t ctx,
+                                     gpgme_keylist_mode_t mode);
 
 /* Get keylist mode in CTX.  */
-int gpgme_get_keylist_mode (GpgmeCtx ctx);
+gpgme_keylist_mode_t gpgme_get_keylist_mode (gpgme_ctx_t ctx);
 
 /* Set the passphrase callback function in CTX to CB.  HOOK_VALUE is
    passed as first argument to the passphrase callback function.  */
-void gpgme_set_passphrase_cb (GpgmeCtx ctx,
-                              GpgmePassphraseCb cb, void *hook_value);
+void gpgme_set_passphrase_cb (gpgme_ctx_t ctx,
+                              gpgme_passphrase_cb_t cb, void *hook_value);
 
 /* Get the current passphrase callback function in *CB and the current
    hook value in *HOOK_VALUE.  */
-void gpgme_get_passphrase_cb (GpgmeCtx ctx, GpgmePassphraseCb *cb,
+void gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *cb,
                              void **hook_value);
 
 /* Set the progress callback function in CTX to CB.  HOOK_VALUE is
    passed as first argument to the progress callback function.  */
-void gpgme_set_progress_cb (GpgmeCtx c, GpgmeProgressCb cb, void *hook_value);
+void gpgme_set_progress_cb (gpgme_ctx_t c, gpgme_progress_cb_t cb,
+                           void *hook_value);
 
 /* Get the current progress callback function in *CB and the current
    hook value in *HOOK_VALUE.  */
-void gpgme_get_progress_cb (GpgmeCtx ctx, GpgmeProgressCb *cb,
+void gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *cb,
                            void **hook_value);
 
+\f
+/* Return a statically allocated string with the name of the public
+   key algorithm ALGO, or NULL if that name is not known.  */
+const char *gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo);
+
+/* Return a statically allocated string with the name of the hash
+   algorithm ALGO, or NULL if that name is not known.  */
+const char *gpgme_hash_algo_name (gpgme_hash_algo_t algo);
+
+\f
 /* Delete all signers from CTX.  */
-void gpgme_signers_clear (GpgmeCtx ctx);
+void gpgme_signers_clear (gpgme_ctx_t ctx);
 
 /* Add KEY to list of signers in CTX.  */
-GpgmeError gpgme_signers_add (GpgmeCtx ctx, const GpgmeKey key);
+gpgme_error_t gpgme_signers_add (gpgme_ctx_t ctx, const gpgme_key_t key);
 
 /* Return the SEQth signer's key in CTX.  */
-GpgmeKey gpgme_signers_enum (const GpgmeCtx ctx, int seq);
+gpgme_key_t gpgme_signers_enum (const gpgme_ctx_t ctx, int seq);
 
 /* Retrieve the signature status of signature IDX in CTX after a
    successful verify operation in R_STAT (if non-null).  The creation
    time stamp of the signature is returned in R_CREATED (if non-null).
-   The function returns a string containing the fingerprint.  */
-const char *gpgme_get_sig_status (GpgmeCtx ctx, int idx,
-                                  GpgmeSigStat *r_stat, time_t *r_created);
+   The function returns a string containing the fingerprint.
+   Deprecated, use verify result directly.  */
+const char *gpgme_get_sig_status (gpgme_ctx_t ctx, int idx,
+                                  _gpgme_sig_stat_t *r_stat,
+                                 time_t *r_created) _GPGME_DEPRECATED;
 
 /* Retrieve certain attributes of a signature.  IDX is the index
    number of the signature after a successful verify operation.  WHAT
    is an attribute where GPGME_ATTR_EXPIRE is probably the most useful
    one.  WHATIDX is to be passed as 0 for most attributes . */
-unsigned long gpgme_get_sig_ulong_attr (GpgmeCtx c, int idx,
-                                        GpgmeAttr what, int whatidx);
-const char *gpgme_get_sig_string_attr (GpgmeCtx c, int idx,
-                                      GpgmeAttr what, int whatidx);
+unsigned long gpgme_get_sig_ulong_attr (gpgme_ctx_t c, int idx,
+                                        _gpgme_attr_t what, int whatidx)
+     _GPGME_DEPRECATED;
+const char *gpgme_get_sig_string_attr (gpgme_ctx_t c, int idx,
+                                      _gpgme_attr_t what, int whatidx)
+     _GPGME_DEPRECATED;
 
 
 /* Get the key used to create signature IDX in CTX and return it in
    R_KEY.  */
-GpgmeError gpgme_get_sig_key (GpgmeCtx ctx, int idx, GpgmeKey *r_key);
-
-/* Return a string with more info about the last crypto operating in CTX.
-   RESERVED should be zero.  The user has to free the string.  */
-char *gpgme_get_op_info (GpgmeCtx ctx, int reserved);
-
+gpgme_error_t gpgme_get_sig_key (gpgme_ctx_t ctx, int idx, gpgme_key_t *r_key)
+     _GPGME_DEPRECATED;
 
+\f
 /* Run control.  */
 
 /* The type of an I/O callback function.  */
-typedef void (*GpgmeIOCb) (void *data, int fd);
+typedef gpgme_error_t (*gpgme_io_cb_t) (void *data, int fd);
 
 /* The type of a function that can register FNC as the I/O callback
    function for the file descriptor FD with direction dir (0: for writing,
    1: for reading).  FNC_DATA should be passed as DATA to FNC.  The
    function should return a TAG suitable for the corresponding
-   GpgmeRemoveIOCb, and an error value.  */
-typedef GpgmeError (*GpgmeRegisterIOCb) (void *data, int fd, int dir,
-                                        GpgmeIOCb fnc, void *fnc_data,
-                                        void **tag);
+   gpgme_remove_io_cb_t, and an error value.  */
+typedef gpgme_error_t (*gpgme_register_io_cb_t) (void *data, int fd, int dir,
+                                                gpgme_io_cb_t fnc,
+                                                void *fnc_data, void **tag);
 
 /* The type of a function that can remove a previously registered I/O
    callback function given TAG as returned by the register
    function.  */
-typedef void (*GpgmeRemoveIOCb) (void *tag);
+typedef void (*gpgme_remove_io_cb_t) (void *tag);
 
-typedef enum { GPGME_EVENT_DONE,
-              GPGME_EVENT_NEXT_KEY,
-              GPGME_EVENT_NEXT_TRUSTITEM } GpgmeEventIO;
+typedef enum
+  {
+    GPGME_EVENT_START,
+    GPGME_EVENT_DONE,
+    GPGME_EVENT_NEXT_KEY,
+    GPGME_EVENT_NEXT_TRUSTITEM
+  }
+gpgme_event_io_t;
 
 /* The type of a function that is called when a context finished an
    operation.  */
-typedef void (*GpgmeEventIOCb) (void *data, GpgmeEventIO type,
-                               void *type_data);
+typedef void (*gpgme_event_io_cb_t) (void *data, gpgme_event_io_t type,
+                                    void *type_data);
 
-struct GpgmeIOCbs
+struct gpgme_io_cbs
 {
-  GpgmeRegisterIOCb add;
+  gpgme_register_io_cb_t add;
   void *add_priv;
-  GpgmeRemoveIOCb remove;
-  GpgmeEventIOCb event;
+  gpgme_remove_io_cb_t remove;
+  gpgme_event_io_cb_t event;
   void *event_priv;
 };
+typedef struct gpgme_io_cbs *gpgme_io_cbs_t;
 
 /* Set the I/O callback functions in CTX to IO_CBS.  */
-void gpgme_set_io_cbs (GpgmeCtx ctx, struct GpgmeIOCbs *io_cbs);
+void gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs);
 
 /* Get the current I/O callback functions.  */
-void gpgme_get_io_cbs (GpgmeCtx ctx, struct GpgmeIOCbs *io_cbs);
-
-/* Cancel a pending operation in CTX.  */
-void gpgme_cancel (GpgmeCtx ctx);
+void gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs);
 
 /* Process the pending operation and, if HANG is non-zero, wait for
    the pending operation to finish.  */
-GpgmeCtx gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang);
-
-
-/* Functions to handle recipients.  */
-
-/* Create a new recipients set and return it in R_RSET.  */
-GpgmeError gpgme_recipients_new (GpgmeRecipients *r_rset);
+gpgme_ctx_t gpgme_wait (gpgme_ctx_t ctx, gpgme_error_t *status, int hang);
 
-/* Release the recipients set RSET.  */
-void gpgme_recipients_release (GpgmeRecipients rset);
+\f
+/* Functions to handle data objects.  */
 
-/* Add NAME to the recipients set RSET.  */
-GpgmeError gpgme_recipients_add_name (GpgmeRecipients rset, const char *name);
+/* Read up to SIZE bytes into buffer BUFFER from the data object with
+   the handle HANDLE.  Return the number of characters read, 0 on EOF
+   and -1 on error.  If an error occurs, errno is set.  */
+typedef ssize_t (*gpgme_data_read_cb_t) (void *handle, void *buffer,
+                                        size_t size);
 
-/* Add NAME with validity AL to the recipients set RSET.  */
-GpgmeError gpgme_recipients_add_name_with_validity (GpgmeRecipients rset,
-                                                    const char *name,
-                                                   GpgmeValidity val);
+/* Write up to SIZE bytes from buffer BUFFER to the data object with
+   the handle HANDLE.  Return the number of characters written, or -1
+   on error.  If an error occurs, errno is set.  */
+typedef ssize_t (*gpgme_data_write_cb_t) (void *handle, const void *buffer,
+                                         size_t size);
 
-/* Return the number of recipients in RSET.  */
-unsigned int gpgme_recipients_count (const GpgmeRecipients rset);
+/* Set the current position from where the next read or write starts
+   in the data object with the handle HANDLE to OFFSET, relativ to
+   WHENCE.  */
+typedef off_t (*gpgme_data_seek_cb_t) (void *handle, off_t offset, int whence);
 
-/* Create a new enumeration handle for the recipients set RSET and
-   return it in ITER.  */
-GpgmeError gpgme_recipients_enum_open (const GpgmeRecipients rset,
-                                      void **iter);
+/* Close the data object with the handle DL.  */
+typedef void (*gpgme_data_release_cb_t) (void *handle);
 
-/* Return the next recipient from the recipient set RSET in the
-   enumerator ITER.  */
-const char *gpgme_recipients_enum_read (const GpgmeRecipients rset,
-                                       void **iter);
+struct gpgme_data_cbs
+{
+  gpgme_data_read_cb_t read;
+  gpgme_data_write_cb_t write;
+  gpgme_data_seek_cb_t seek;
+  gpgme_data_release_cb_t release;
+};
+typedef struct gpgme_data_cbs *gpgme_data_cbs_t;
 
-/* Destroy the enumerator ITER for the recipient set RSET.  */
-GpgmeError gpgme_recipients_enum_close (const GpgmeRecipients rset,
-                                       void **iter);
+/* Read up to SIZE bytes into buffer BUFFER from the data object with
+   the handle DH.  Return the number of characters read, 0 on EOF and
+   -1 on error.  If an error occurs, errno is set.  */
+ssize_t gpgme_data_read (gpgme_data_t dh, void *buffer, size_t size);
 
+/* Write up to SIZE bytes from buffer BUFFER to the data object with
+   the handle DH.  Return the number of characters written, or -1 on
+   error.  If an error occurs, errno is set.  */
+ssize_t gpgme_data_write (gpgme_data_t dh, const void *buffer, size_t size);
 
-/* Functions to handle data objects.  */
+/* Set the current position from where the next read or write starts
+   in the data object with the handle DH to OFFSET, relativ to
+   WHENCE.  */
+off_t gpgme_data_seek (gpgme_data_t dh, off_t offset, int whence);
 
 /* Create a new data buffer and return it in R_DH.  */
-GpgmeError gpgme_data_new (GpgmeData *r_dh);
+gpgme_error_t gpgme_data_new (gpgme_data_t *r_dh);
+
+/* Destroy the data buffer DH.  */
+void gpgme_data_release (gpgme_data_t dh);
 
 /* Create a new data buffer filled with SIZE bytes starting from
    BUFFER.  If COPY is zero, copying is delayed until necessary, and
    the data is taken from the original location when needed.  */
-GpgmeError gpgme_data_new_from_mem (GpgmeData *r_dh,
-                                   const char *buffer, size_t size,
-                                   int copy);
-
-/* Create a new data buffer which retrieves the data from the callback
-   function READ_CB.  */
-GpgmeError gpgme_data_new_with_read_cb (GpgmeData *r_dh,
-                                       int (*read_cb) (void*,char *,size_t,size_t*),
-                                       void *read_cb_value);
-
-/* Create a new data buffer filled with the content of file FNAME.
-   COPY must be non-zero (delayed reads are not supported yet).  */
-GpgmeError gpgme_data_new_from_file (GpgmeData *r_dh,
-                                    const char *fname,
-                                    int copy);
-
-/* Create a new data buffer filled with LENGTH bytes starting from
-   OFFSET within the file FNAME or stream FP (exactly one must be
-   non-zero).  */
-GpgmeError gpgme_data_new_from_filepart (GpgmeData *r_dh,
-                                        const char *fname, FILE *fp,
-                                        off_t offset, size_t length);
-
-/* Destroy the data buffer DH.  */
-void gpgme_data_release (GpgmeData dh);
+gpgme_error_t gpgme_data_new_from_mem (gpgme_data_t *r_dh,
+                                      const char *buffer, size_t size,
+                                      int copy);
 
 /* Destroy the data buffer DH and return a pointer to its content.
    The memory has be to released with free by the user.  It's size is
    returned in R_LEN.  */
-char *gpgme_data_release_and_get_mem (GpgmeData dh, size_t *r_len);
+char *gpgme_data_release_and_get_mem (gpgme_data_t dh, size_t *r_len);
+
+gpgme_error_t gpgme_data_new_from_cbs (gpgme_data_t *dh,
+                                      gpgme_data_cbs_t cbs,
+                                      void *handle);
+
+gpgme_error_t gpgme_data_new_from_fd (gpgme_data_t *dh, int fd);
 
-/* Return the type of the data buffer DH.  */
-GpgmeDataType gpgme_data_get_type (GpgmeData dh);
+gpgme_error_t gpgme_data_new_from_stream (gpgme_data_t *dh, FILE *stream);
 
 /* Return the encoding attribute of the data buffer DH */
-GpgmeDataEncoding gpgme_data_get_encoding (GpgmeData dh);
+gpgme_data_encoding_t gpgme_data_get_encoding (gpgme_data_t dh);
 
 /* Set the encoding attribute of data buffer DH to ENC */
-GpgmeError gpgme_data_set_encoding (GpgmeData dh, GpgmeDataEncoding enc);
+gpgme_error_t gpgme_data_set_encoding (gpgme_data_t dh,
+                                      gpgme_data_encoding_t enc);
 
-/* Reset the read pointer in DH.  */
-GpgmeError gpgme_data_rewind (GpgmeData dh);
 
-/* Read LENGTH bytes from the data object DH and store them in the
-   memory starting at BUFFER.  The number of bytes actually read is
-   returned in NREAD.  */
-GpgmeError gpgme_data_read (GpgmeData dh, void *buffer,
-                           size_t length, size_t *nread);
 
-/* Write LENGTH bytes starting from BUFFER into the data object DH.  */
-GpgmeError gpgme_data_write (GpgmeData dh, const void *buffer, size_t length);
+/* Create a new data buffer which retrieves the data from the callback
+   function READ_CB.  Deprecated, please use gpgme_data_new_from_cbs
+   instead.  */
+gpgme_error_t gpgme_data_new_with_read_cb (gpgme_data_t *r_dh,
+                                          int (*read_cb) (void*,char *,
+                                                          size_t,size_t*),
+                                          void *read_cb_value)
+     _GPGME_DEPRECATED;
+
+/* Create a new data buffer filled with the content of file FNAME.
+   COPY must be non-zero.  For delayed read, please use
+   gpgme_data_new_from_fd or gpgme_data_new_from stream instead.  */
+gpgme_error_t gpgme_data_new_from_file (gpgme_data_t *r_dh,
+                                       const char *fname,
+                                       int copy);
+
+/* Create a new data buffer filled with LENGTH bytes starting from
+   OFFSET within the file FNAME or stream FP (exactly one must be
+   non-zero).  */
+gpgme_error_t gpgme_data_new_from_filepart (gpgme_data_t *r_dh,
+                                           const char *fname, FILE *fp,
+                                           off_t offset, size_t length);
 
+/* Reset the read pointer in DH.  Deprecated, please use
+   gpgme_data_seek instead.  */
+gpgme_error_t gpgme_data_rewind (gpgme_data_t dh) _GPGME_DEPRECATED;
 
+\f
 /* Key and trust functions.  */
 
+/* Get the key with the fingerprint FPR from the crypto backend.  If
+   SECRET is true, get the secret key.  */
+gpgme_error_t gpgme_get_key (gpgme_ctx_t ctx, const char *fpr,
+                            gpgme_key_t *r_key, int secret);
+
 /* Acquire a reference to KEY.  */
-void gpgme_key_ref (GpgmeKey key);
+void gpgme_key_ref (gpgme_key_t key);
 
 /* Release a reference to KEY.  If this was the last one the key is
    destroyed.  */
-void gpgme_key_unref (GpgmeKey key);
-void gpgme_key_release (GpgmeKey key);
-
-/* Get the data from key KEY in a XML string, which has to be released
-   with free by the user.  */
-char *gpgme_key_get_as_xml (GpgmeKey key);
+void gpgme_key_unref (gpgme_key_t key);
+void gpgme_key_release (gpgme_key_t key);
 
 /* Return the value of the attribute WHAT of KEY, which has to be
-   representable by a string.  IDX specifies the sub key or
-   user ID for attributes related to sub keys or user IDs.  */
-const char *gpgme_key_get_string_attr (GpgmeKey key, GpgmeAttr what,
-                                      const void *reserved, int idx);
+   representable by a string.  IDX specifies the sub key or user ID
+   for attributes related to sub keys or user IDs.  Deprecated, use
+   key structure directly instead. */
+const char *gpgme_key_get_string_attr (gpgme_key_t key, _gpgme_attr_t what,
+                                      const void *reserved, int idx)
+     _GPGME_DEPRECATED;
 
 /* Return the value of the attribute WHAT of KEY, which has to be
    representable by an unsigned integer.  IDX specifies the sub key or
-   user ID for attributes related to sub keys or user IDs.  */
-unsigned long gpgme_key_get_ulong_attr (GpgmeKey key, GpgmeAttr what,
-                                       const void *reserved, int idx);
-
-/* Release the trust item ITEM.  */
-void gpgme_trust_item_release (GpgmeTrustItem item);
-
-/* Return the value of the attribute WHAT of ITEM, which has to be
-   representable by a string.  */
-const char *gpgme_trust_item_get_string_attr (GpgmeTrustItem item,
-                                             GpgmeAttr what,
-                                             const void *reserved, int idx);
+   user ID for attributes related to sub keys or user IDs.
+   Deprecated, use key structure directly instead.  */
+unsigned long gpgme_key_get_ulong_attr (gpgme_key_t key, _gpgme_attr_t what,
+                                       const void *reserved, int idx)
+     _GPGME_DEPRECATED;
+
+/* Return the value of the attribute WHAT of a signature on user ID
+   UID_IDX in KEY, which has to be representable by a string.  IDX
+   specifies the signature.  Deprecated, use key structure directly
+   instead.  */
+const char *gpgme_key_sig_get_string_attr (gpgme_key_t key, int uid_idx,
+                                          _gpgme_attr_t what,
+                                          const void *reserved, int idx)
+     _GPGME_DEPRECATED;
+
+/* Return the value of the attribute WHAT of a signature on user ID
+   UID_IDX in KEY, which has to be representable by an unsigned
+   integer string.  IDX specifies the signature.  Deprecated, use key
+   structure directly instead.  */
+unsigned long gpgme_key_sig_get_ulong_attr (gpgme_key_t key, int uid_idx,
+                                           _gpgme_attr_t what,
+                                           const void *reserved, int idx)
+     _GPGME_DEPRECATED;
+
+\f
+/* Crypto Operations.  */
+
+struct _gpgme_invalid_key
+{
+  struct _gpgme_invalid_key *next;
+  char *fpr;
+  gpgme_error_t reason;
+};
+typedef struct _gpgme_invalid_key *gpgme_invalid_key_t;
 
-/* Return the value of the attribute WHAT of KEY, which has to be
-   representable by an integer.  IDX specifies a running index if the
-   attribute appears more than once in the key.  */
-int gpgme_trust_item_get_int_attr (GpgmeTrustItem item, GpgmeAttr what,
-                                  const void *reserved, int idx);
+\f
+/* Encryption.  */
+struct _gpgme_op_encrypt_result
+{
+  /* The list of invalid recipients.  */
+  gpgme_invalid_key_t invalid_recipients;
+};
+typedef struct _gpgme_op_encrypt_result *gpgme_encrypt_result_t;
 
+/* Retrieve a pointer to the result of the encrypt operation.  */
+gpgme_encrypt_result_t gpgme_op_encrypt_result (gpgme_ctx_t ctx);
 
-/* Crypto operation function.  */
+/* The valid encryption flags.  */
+typedef enum
+  {
+    GPGME_ENCRYPT_ALWAYS_TRUST = 1
+  }
+gpgme_encrypt_flags_t;
 
 /* Encrypt plaintext PLAIN within CTX for the recipients RECP and
    store the resulting ciphertext in CIPHER.  */
-GpgmeError gpgme_op_encrypt_start (GpgmeCtx ctx,
-                                  GpgmeRecipients recp,
-                                  GpgmeData plain, GpgmeData cipher);
-GpgmeError gpgme_op_encrypt (GpgmeCtx ctx,
-                            GpgmeRecipients recp,
-                            GpgmeData plain, GpgmeData cipher);
+gpgme_error_t gpgme_op_encrypt_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
+                                     gpgme_encrypt_flags_t flags,
+                                     gpgme_data_t plain, gpgme_data_t cipher);
+gpgme_error_t gpgme_op_encrypt (gpgme_ctx_t ctx, gpgme_key_t recp[],
+                               gpgme_encrypt_flags_t flags,
+                               gpgme_data_t plain, gpgme_data_t cipher);
 
 /* Encrypt plaintext PLAIN within CTX for the recipients RECP and
    store the resulting ciphertext in CIPHER.  Also sign the ciphertext
    with the signers in CTX.  */
-GpgmeError gpgme_op_encrypt_sign_start (GpgmeCtx ctx,
-                                       GpgmeRecipients recp,
-                                       GpgmeData plain, GpgmeData cipher);
-GpgmeError gpgme_op_encrypt_sign (GpgmeCtx ctx,
-                                 GpgmeRecipients recp,
-                                 GpgmeData plain, GpgmeData cipher);
+gpgme_error_t gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx,
+                                          gpgme_key_t recp[],
+                                          gpgme_encrypt_flags_t flags,
+                                          gpgme_data_t plain,
+                                          gpgme_data_t cipher);
+gpgme_error_t gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t recp[],
+                                    gpgme_encrypt_flags_t flags,
+                                    gpgme_data_t plain, gpgme_data_t cipher);
+
+\f
+/* Decryption.  */
+struct _gpgme_op_decrypt_result
+{
+  char *unsupported_algorithm;
+};
+typedef struct _gpgme_op_decrypt_result *gpgme_decrypt_result_t;
+
+/* Retrieve a pointer to the result of the decrypt operation.  */
+gpgme_decrypt_result_t gpgme_op_decrypt_result (gpgme_ctx_t ctx);
 
 /* Decrypt ciphertext CIPHER within CTX and store the resulting
    plaintext in PLAIN.  */
-GpgmeError gpgme_op_decrypt_start (GpgmeCtx ctx,
-                                  GpgmeData cipher, GpgmeData plain);
-GpgmeError gpgme_op_decrypt (GpgmeCtx ctx,
-                            GpgmeData cipher, GpgmeData plain);
+gpgme_error_t gpgme_op_decrypt_start (gpgme_ctx_t ctx, gpgme_data_t cipher,
+                                     gpgme_data_t plain);
+gpgme_error_t gpgme_op_decrypt (gpgme_ctx_t ctx,
+                               gpgme_data_t cipher, gpgme_data_t plain);
 
 /* Decrypt ciphertext CIPHER and make a signature verification within
    CTX and store the resulting plaintext in PLAIN.  */
-GpgmeError gpgme_op_decrypt_verify_start (GpgmeCtx ctx,
-                                         GpgmeData cipher, GpgmeData plain);
-GpgmeError gpgme_op_decrypt_verify (GpgmeCtx ctx,
-                                   GpgmeData cipher, GpgmeData plain,
-                                   GpgmeSigStat *r_status);
-
-/* Sign the plaintext PLAIN and store the signature in SIG.  Only
-   detached signatures are supported for now.  */
-GpgmeError gpgme_op_sign_start (GpgmeCtx ctx,
-                               GpgmeData plain, GpgmeData sig,
-                               GpgmeSigMode mode);
-GpgmeError gpgme_op_sign (GpgmeCtx ctx,
-                         GpgmeData plain, GpgmeData sig,
-                         GpgmeSigMode mode);
+gpgme_error_t gpgme_op_decrypt_verify_start (gpgme_ctx_t ctx,
+                                            gpgme_data_t cipher,
+                                            gpgme_data_t plain);
+gpgme_error_t gpgme_op_decrypt_verify (gpgme_ctx_t ctx, gpgme_data_t cipher,
+                                      gpgme_data_t plain);
+
+\f
+/* Signing.  */
+struct _gpgme_new_signature
+{
+  struct _gpgme_new_signature *next;
+
+  /* The type of the signature.  */
+  gpgme_sig_mode_t type;
+
+  /* The public key algorithm used to create the signature.  */
+  gpgme_pubkey_algo_t pubkey_algo;
+
+  /* The hash algorithm used to create the signature.  */
+  gpgme_hash_algo_t hash_algo;
+
+  /* Internal to GPGME, do not use.  Must be set to the same value as
+     CLASS below.  */
+  unsigned long _obsolete_class;
+
+  /* Signature creation time.  */
+  long int timestamp;
+
+  /* The fingerprint of the signature.  */
+  char *fpr;
+
+  /* Crypto backend specific signature class.  */
+  unsigned int class;
+};
+typedef struct _gpgme_new_signature *gpgme_new_signature_t;
+
+struct _gpgme_op_sign_result
+{
+  /* The list of invalid signers.  */
+  gpgme_invalid_key_t invalid_signers;
+  gpgme_new_signature_t signatures;
+};
+typedef struct _gpgme_op_sign_result *gpgme_sign_result_t;
+
+/* Retrieve a pointer to the result of the signing operation.  */
+gpgme_sign_result_t gpgme_op_sign_result (gpgme_ctx_t ctx);
+
+/* Sign the plaintext PLAIN and store the signature in SIG.  */
+gpgme_error_t gpgme_op_sign_start (gpgme_ctx_t ctx,
+                                  gpgme_data_t plain, gpgme_data_t sig,
+                                  gpgme_sig_mode_t mode);
+gpgme_error_t gpgme_op_sign (gpgme_ctx_t ctx,
+                            gpgme_data_t plain, gpgme_data_t sig,
+                            gpgme_sig_mode_t mode);
+
+\f
+/* Verify.  */
+struct _gpgme_sig_notation
+{
+  struct _gpgme_sig_notation *next;
+
+  /* If NAME is a null pointer, then VALUE contains a policy URL
+     rather than a notation.  */
+  char *name;
+  char *value;
+};
+typedef struct _gpgme_sig_notation *gpgme_sig_notation_t;
+
+/* Flags used for the SUMMARY field in a gpgme_signature_t.  */
+typedef enum
+  {
+    GPGME_SIGSUM_VALID       = 0x0001,  /* The signature is fully valid.  */
+    GPGME_SIGSUM_GREEN       = 0x0002,  /* The signature is good.  */
+    GPGME_SIGSUM_RED         = 0x0004,  /* The signature is bad.  */
+    GPGME_SIGSUM_KEY_REVOKED = 0x0010,  /* One key has been revoked.  */
+    GPGME_SIGSUM_KEY_EXPIRED = 0x0020,  /* One key has expired.  */
+    GPGME_SIGSUM_SIG_EXPIRED = 0x0040,  /* The signature has expired.  */
+    GPGME_SIGSUM_KEY_MISSING = 0x0080,  /* Can't verify: key missing.  */
+    GPGME_SIGSUM_CRL_MISSING = 0x0100,  /* CRL not available.  */
+    GPGME_SIGSUM_CRL_TOO_OLD = 0x0200,  /* Available CRL is too old.  */
+    GPGME_SIGSUM_BAD_POLICY  = 0x0400,  /* A policy was not met.  */
+    GPGME_SIGSUM_SYS_ERROR   = 0x0800   /* A system error occured.  */
+  }
+gpgme_sigsum_t;
+
+struct _gpgme_signature
+{
+  struct _gpgme_signature *next;
+
+  /* A summary of the signature status.  */
+  gpgme_sigsum_t summary;
+
+  /* The fingerprint or key ID of the signature.  */
+  char *fpr;
+
+  /* The status of the signature.  */
+  gpgme_error_t status;
+
+  /* Notation data and policy URLs.  */
+  gpgme_sig_notation_t notations;
+
+  /* Signature creation time.  */
+  unsigned long timestamp;
+
+  /* Signature exipration time or 0.  */
+  unsigned long exp_timestamp;
+
+  int wrong_key_usage : 1;
+
+  /* Internal to GPGME, do not use.  */
+  int _unused : 31;
+
+  gpgme_validity_t validity;
+  gpgme_error_t validity_reason;
+};
+typedef struct _gpgme_signature *gpgme_signature_t;
+
+struct _gpgme_op_verify_result
+{
+  gpgme_signature_t signatures;
+};
+typedef struct _gpgme_op_verify_result *gpgme_verify_result_t;
+
+/* Retrieve a pointer to the result of the verify operation.  */
+gpgme_verify_result_t gpgme_op_verify_result (gpgme_ctx_t ctx);
 
 /* Verify within CTX that SIG is a valid signature for TEXT.  */
-GpgmeError gpgme_op_verify_start (GpgmeCtx ctx,
-                                 GpgmeData sig, GpgmeData text);
-GpgmeError gpgme_op_verify (GpgmeCtx ctx,
-                           GpgmeData sig, GpgmeData text,
-                           GpgmeSigStat *r_status);
+gpgme_error_t gpgme_op_verify_start (gpgme_ctx_t ctx, gpgme_data_t sig,
+                                    gpgme_data_t signed_text,
+                                    gpgme_data_t plaintext);
+gpgme_error_t gpgme_op_verify (gpgme_ctx_t ctx, gpgme_data_t sig,
+                              gpgme_data_t signed_text,
+                              gpgme_data_t plaintext);
+
+\f
+/* Import.  */
+enum
+  {
+    /* The key was new.  */
+    GPGME_IMPORT_NEW = 1,
+
+    /* The key contained new user IDs.  */
+    GPGME_IMPORT_UID = 2,
+
+    /* The key contained new signatures.  */
+    GPGME_IMPORT_SIG = 4,
+
+    /* The key contained new sub keys.  */
+    GPGME_IMPORT_SUBKEY        = 8,
+
+    /* The key contained a secret key.  */
+    GPGME_IMPORT_SECRET = 16
+  };
+
+struct _gpgme_import_status
+{
+  struct _gpgme_import_status *next;
+
+  /* Fingerprint.  */
+  char *fpr;
+
+  /* If a problem occured, the reason why the key could not be
+     imported.  Otherwise GPGME_No_Error.  */
+  gpgme_error_t result;
+
+  /* The result of the import, the GPGME_IMPORT_* values bit-wise
+     ORed.  0 means the key was already known and no new components
+     have been added.  */
+  unsigned int status;
+};
+typedef struct _gpgme_import_status *gpgme_import_status_t;
+
+/* Import.  */
+struct _gpgme_op_import_result
+{
+  /* Number of considered keys.  */
+  int considered;
+
+  /* Keys without user ID.  */
+  int no_user_id;
+
+  /* Imported keys.  */
+  int imported;
+
+  /* Imported RSA keys.  */
+  int imported_rsa;
+
+  /* Unchanged keys.  */
+  int unchanged;
+
+  /* Number of new user ids.  */
+  int new_user_ids;
+
+  /* Number of new sub keys.  */
+  int new_sub_keys;
+
+  /* Number of new signatures.  */
+  int new_signatures;
+
+  /* Number of new revocations.  */
+  int new_revocations;
+
+  /* Number of secret keys read.  */
+  int secret_read;
+
+  /* Number of secret keys imported.  */
+  int secret_imported;
+
+  /* Number of secret keys unchanged.  */
+  int secret_unchanged;
+
+  /* Number of new keys skipped.  */
+  int skipped_new_keys;
+
+  /* Number of keys not imported.  */
+  int not_imported;
+
+  /* List of keys for which an import was attempted.  */
+  gpgme_import_status_t imports;
+};
+typedef struct _gpgme_op_import_result *gpgme_import_result_t;
+
+/* Retrieve a pointer to the result of the import operation.  */
+gpgme_import_result_t gpgme_op_import_result (gpgme_ctx_t ctx);
 
 /* Import the key in KEYDATA into the keyring.  */
-GpgmeError gpgme_op_import_start (GpgmeCtx ctx, GpgmeData keydata);
-GpgmeError gpgme_op_import (GpgmeCtx ctx, GpgmeData keydata);
-GpgmeError gpgme_op_import_ext (GpgmeCtx ctx, GpgmeData keydata, int *nr);
+gpgme_error_t gpgme_op_import_start (gpgme_ctx_t ctx, gpgme_data_t keydata);
+gpgme_error_t gpgme_op_import (gpgme_ctx_t ctx, gpgme_data_t keydata);
+gpgme_error_t gpgme_op_import_ext (gpgme_ctx_t ctx, gpgme_data_t keydata,
+                                  int *nr) _GPGME_DEPRECATED;
+
+\f
+/* Export the keys found by PATTERN into KEYDATA.  */
+gpgme_error_t gpgme_op_export_start (gpgme_ctx_t ctx, const char *pattern,
+                                    unsigned int reserved,
+                                    gpgme_data_t keydata);
+gpgme_error_t gpgme_op_export (gpgme_ctx_t ctx, const char *pattern,
+                              unsigned int reserved, gpgme_data_t keydata);
+
+gpgme_error_t gpgme_op_export_ext_start (gpgme_ctx_t ctx,
+                                        const char *pattern[],
+                                        unsigned int reserved,
+                                        gpgme_data_t keydata);
+gpgme_error_t gpgme_op_export_ext (gpgme_ctx_t ctx, const char *pattern[],
+                                  unsigned int reserved,
+                                  gpgme_data_t keydata);
+
+\f
+/* Key generation.  */
+struct _gpgme_op_genkey_result
+{
+  /* A primary key was generated.  */
+  unsigned int primary : 1;
 
-/* Export the keys listed in RECP into KEYDATA.  */
-GpgmeError gpgme_op_export_start (GpgmeCtx ctx, GpgmeRecipients recp,
-                                 GpgmeData keydata);
-GpgmeError gpgme_op_export (GpgmeCtx ctx, GpgmeRecipients recp,
-                           GpgmeData keydata);
+  /* A sub key was generated.  */
+  unsigned int sub : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 30;
+
+  /* The fingerprint of the generated key.  */
+  char *fpr;
+};
+typedef struct _gpgme_op_genkey_result *gpgme_genkey_result_t;
 
 /* Generate a new keypair and add it to the keyring.  PUBKEY and
    SECKEY should be null for now.  PARMS specifies what keys should be
    generated.  */
-GpgmeError gpgme_op_genkey_start (GpgmeCtx ctx, const char *parms,
-                                 GpgmeData pubkey, GpgmeData seckey);
-GpgmeError gpgme_op_genkey (GpgmeCtx ctx, const char *parms,
-                           GpgmeData pubkey, GpgmeData seckey);
+gpgme_error_t gpgme_op_genkey_start (gpgme_ctx_t ctx, const char *parms,
+                                    gpgme_data_t pubkey, gpgme_data_t seckey);
+gpgme_error_t gpgme_op_genkey (gpgme_ctx_t ctx, const char *parms,
+                              gpgme_data_t pubkey, gpgme_data_t seckey);
+
+/* Retrieve a pointer to the result of the genkey operation.  */
+gpgme_genkey_result_t gpgme_op_genkey_result (gpgme_ctx_t ctx);
 
+\f
 /* Delete KEY from the keyring.  If ALLOW_SECRET is non-zero, secret
    keys are also deleted.  */
-GpgmeError gpgme_op_delete_start (GpgmeCtx ctx, const GpgmeKey key,
-                                 int allow_secret);
-GpgmeError gpgme_op_delete (GpgmeCtx ctx, const GpgmeKey key,
-                           int allow_secret);
+gpgme_error_t gpgme_op_delete_start (gpgme_ctx_t ctx, const gpgme_key_t key,
+                                    int allow_secret);
+gpgme_error_t gpgme_op_delete (gpgme_ctx_t ctx, const gpgme_key_t key,
+                              int allow_secret);
 
+\f
 /* Edit the key KEY.  Send status and command requests to FNC and
    output of edit commands to OUT.  */
-GpgmeError gpgme_op_edit_start (GpgmeCtx ctx, GpgmeKey key,
-                         GpgmeEditCb fnc, void *fnc_value,
-                         GpgmeData out);
-GpgmeError gpgme_op_edit (GpgmeCtx ctx, GpgmeKey key,
-                         GpgmeEditCb fnc, void *fnc_value,
-                         GpgmeData out);
+gpgme_error_t gpgme_op_edit_start (gpgme_ctx_t ctx, gpgme_key_t key,
+                                  gpgme_edit_cb_t fnc, void *fnc_value,
+                                  gpgme_data_t out);
+gpgme_error_t gpgme_op_edit (gpgme_ctx_t ctx, gpgme_key_t key,
+                            gpgme_edit_cb_t fnc, void *fnc_value,
+                            gpgme_data_t out);
+
+\f
+/* Key management functions.  */
+struct _gpgme_op_keylist_result
+{
+  unsigned int truncated : 1;
+
+  /* Internal to GPGME, do not use.  */
+  unsigned int _unused : 31;
+};
+typedef struct _gpgme_op_keylist_result *gpgme_keylist_result_t;
 
-/* Key management functions */
+/* Retrieve a pointer to the result of the key listing operation.  */
+gpgme_keylist_result_t gpgme_op_keylist_result (gpgme_ctx_t ctx);
 
 /* Start a keylist operation within CTX, searching for keys which
    match PATTERN.  If SECRET_ONLY is true, only secret keys are
    returned.  */
-GpgmeError gpgme_op_keylist_start (GpgmeCtx ctx,
-                                  const char *pattern, int secret_only);
-GpgmeError gpgme_op_keylist_ext_start (GpgmeCtx ctx, const char *pattern[],
-                                      int secret_only, int reserved);
+gpgme_error_t gpgme_op_keylist_start (gpgme_ctx_t ctx, const char *pattern,
+                                     int secret_only);
+gpgme_error_t gpgme_op_keylist_ext_start (gpgme_ctx_t ctx,
+                                         const char *pattern[],
+                                         int secret_only, int reserved);
 
 /* Return the next key from the keylist in R_KEY.  */
-GpgmeError gpgme_op_keylist_next (GpgmeCtx ctx, GpgmeKey *r_key);
+gpgme_error_t gpgme_op_keylist_next (gpgme_ctx_t ctx, gpgme_key_t *r_key);
 
 /* Terminate a pending keylist operation within CTX.  */
-GpgmeError gpgme_op_keylist_end (GpgmeCtx ctx);
+gpgme_error_t gpgme_op_keylist_end (gpgme_ctx_t ctx);
+
+\f
+/* Trust items and operations.  */
+
+struct _gpgme_trust_item
+{
+  /* Internal to GPGME, do not use.  */
+  unsigned int _refs;
+
+  /* The key ID to which the trust item belongs.  */
+  char *keyid;
+
+  /* Internal to GPGME, do not use.  */
+  char _keyid[16 + 1];
+
+  /* The type of the trust item, 1 refers to a key, 2 to a user ID.  */
+  int type;
 
+  /* The trust level.  */
+  int level;
+
+  /* The owner trust if TYPE is 1.  */
+  char *owner_trust;
+
+  /* Internal to GPGME, do not use.  */
+  char _owner_trust[2];
+
+  /* The calculated validity.  */
+  char *validity;
+  /* Internal to GPGME, do not use.  */
+  char _validity[2];
+
+  /* The user name if TYPE is 2.  */
+  char *name;
+};
+typedef struct _gpgme_trust_item *gpgme_trust_item_t;
 
 /* Start a trustlist operation within CTX, searching for trust items
    which match PATTERN.  */
-GpgmeError gpgme_op_trustlist_start (GpgmeCtx ctx,
-                                    const char *pattern, int max_level);
+gpgme_error_t gpgme_op_trustlist_start (gpgme_ctx_t ctx,
+                                       const char *pattern, int max_level);
 
 /* Return the next trust item from the trustlist in R_ITEM.  */
-GpgmeError gpgme_op_trustlist_next (GpgmeCtx ctx, GpgmeTrustItem *r_item);
+gpgme_error_t gpgme_op_trustlist_next (gpgme_ctx_t ctx,
+                                      gpgme_trust_item_t *r_item);
 
 /* Terminate a pending trustlist operation within CTX.  */
-GpgmeError gpgme_op_trustlist_end (GpgmeCtx ctx);
+gpgme_error_t gpgme_op_trustlist_end (gpgme_ctx_t ctx);
 
+/* Acquire a reference to ITEM.  */
+void gpgme_trust_item_ref (gpgme_trust_item_t item);
 
-/* Various functions.  */
+/* Release a reference to ITEM.  If this was the last one the trust
+   item is destroyed.  */
+void gpgme_trust_item_unref (gpgme_trust_item_t item);
 
-/* Check that the library fulfills the version requirement.  */
-const char *gpgme_check_version (const char *req_version);
+/* Release the trust item ITEM.  Deprecated, use
+   gpgme_trust_item_unref.  */
+void gpgme_trust_item_release (gpgme_trust_item_t item) _GPGME_DEPRECATED;
 
-/* Check that the backend engine is available.  DEPRECATED.  */
-GpgmeError  gpgme_check_engine (void);
+/* Return the value of the attribute WHAT of ITEM, which has to be
+   representable by a string.  Deprecated, use trust item structure
+   directly.  */
+const char *gpgme_trust_item_get_string_attr (gpgme_trust_item_t item,
+                                             _gpgme_attr_t what,
+                                             const void *reserved, int idx)
+     _GPGME_DEPRECATED;
 
-/* Retrieve information about the backend engines.  */
-const char *gpgme_get_engine_info (void);
+/* Return the value of the attribute WHAT of KEY, which has to be
+   representable by an integer.  IDX specifies a running index if the
+   attribute appears more than once in the key.  Deprecated, use trust
+   item structure directly.  */
+int gpgme_trust_item_get_int_attr (gpgme_trust_item_t item, _gpgme_attr_t what,
+                                  const void *reserved, int idx)
+     _GPGME_DEPRECATED;
 
-/* Return a string describing ERR.  */
-const char *gpgme_strerror (GpgmeError err);
+\f
+/* Various functions.  */
 
-/* Register an idle function.  */
-typedef void (*GpgmeIdleFunc)(void);
-GpgmeIdleFunc gpgme_register_idle (GpgmeIdleFunc idle);
+/* Check that the library fulfills the version requirement.  */
+const char *gpgme_check_version (const char *req_version);
 
+/* Retrieve information about the backend engines.  */
+gpgme_error_t gpgme_get_engine_info (gpgme_engine_info_t *engine_info);
 
+\f
 /* Engine support functions.  */
 
 /* Verify that the engine implementing PROTO is installed and
    available.  */
-GpgmeError gpgme_engine_check_version (GpgmeProtocol proto);
-
+gpgme_error_t gpgme_engine_check_version (gpgme_protocol_t proto);
+
+\f
+/* Deprecated types.  */
+typedef gpgme_ctx_t GpgmeCtx _GPGME_DEPRECATED;
+typedef gpgme_data_t GpgmeData _GPGME_DEPRECATED;
+typedef gpgme_error_t GpgmeError _GPGME_DEPRECATED;
+typedef gpgme_data_encoding_t GpgmeDataEncoding _GPGME_DEPRECATED;
+typedef gpgme_pubkey_algo_t GpgmePubKeyAlgo _GPGME_DEPRECATED;
+typedef gpgme_hash_algo_t GpgmeHashAlgo _GPGME_DEPRECATED;
+typedef gpgme_sig_stat_t GpgmeSigStat _GPGME_DEPRECATED;
+typedef gpgme_sig_mode_t GpgmeSigMode _GPGME_DEPRECATED;
+typedef gpgme_attr_t GpgmeAttr _GPGME_DEPRECATED;
+typedef gpgme_validity_t GpgmeValidity _GPGME_DEPRECATED;
+typedef gpgme_protocol_t GpgmeProtocol _GPGME_DEPRECATED;
+typedef gpgme_engine_info_t GpgmeEngineInfo _GPGME_DEPRECATED;
+typedef gpgme_subkey_t GpgmeSubkey _GPGME_DEPRECATED;
+typedef gpgme_key_sig_t GpgmeKeySig _GPGME_DEPRECATED;
+typedef gpgme_user_id_t GpgmeUserID _GPGME_DEPRECATED;
+typedef gpgme_key_t GpgmeKey _GPGME_DEPRECATED;
+typedef gpgme_passphrase_cb_t GpgmePassphraseCb _GPGME_DEPRECATED;
+typedef gpgme_progress_cb_t GpgmeProgressCb _GPGME_DEPRECATED;
+typedef gpgme_io_cb_t GpgmeIOCb _GPGME_DEPRECATED;
+typedef gpgme_register_io_cb_t GpgmeRegisterIOCb _GPGME_DEPRECATED;
+typedef gpgme_remove_io_cb_t GpgmeRemoveIOCb _GPGME_DEPRECATED;
+typedef gpgme_event_io_t GpgmeEventIO _GPGME_DEPRECATED;
+typedef gpgme_event_io_cb_t GpgmeEventIOCb _GPGME_DEPRECATED;
+#define GpgmeIOCbs gpgme_io_cbs
+typedef gpgme_data_read_cb_t GpgmeDataReadCb _GPGME_DEPRECATED;
+typedef gpgme_data_write_cb_t GpgmeDataWriteCb _GPGME_DEPRECATED;
+typedef gpgme_data_seek_cb_t GpgmeDataSeekCb _GPGME_DEPRECATED;
+typedef gpgme_data_release_cb_t GpgmeDataReleaseCb _GPGME_DEPRECATED;
+#define GpgmeDataCbs gpgme_data_cbs
+typedef gpgme_encrypt_result_t GpgmeEncryptResult _GPGME_DEPRECATED;
+typedef gpgme_sig_notation_t GpgmeSigNotation _GPGME_DEPRECATED;
+typedef        gpgme_signature_t GpgmeSignature _GPGME_DEPRECATED;
+typedef gpgme_verify_result_t GpgmeVerifyResult _GPGME_DEPRECATED;
+typedef gpgme_import_status_t GpgmeImportStatus _GPGME_DEPRECATED;
+typedef gpgme_import_result_t GpgmeImportResult _GPGME_DEPRECATED;
+typedef gpgme_genkey_result_t GpgmeGenKeyResult _GPGME_DEPRECATED;
+typedef        gpgme_trust_item_t GpgmeTrustItem _GPGME_DEPRECATED;
+typedef gpgme_status_code_t GpgmeStatusCode _GPGME_DEPRECATED;
 
 #ifdef __cplusplus
 }