Fixed version number
[libgcrypt.git] / src / gcrypt.h
index 0ea8455..b691102 100644 (file)
 #include <stdarg.h>
 #include <string.h>
 
-#define GPG_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_GCRYPT
-
-/* Support for libgpg-error.  */
-#ifdef USE_LIBGPG_ERROR
 #include <gpg-error.h>
-#else
-
-/* Only use free slots, never change or reorder the existing
-   entries.  */
-typedef enum
-  {
-    GPG_ERR_SOURCE_GCRYPT = 1,
-
-    /* This is one more than the largest allowed entry.  */
-    GPG_ERR_SOURCE_DIM = 256
-  } gpg_err_source_t;
-
-\f
-/* The error code type gpg_err_code_t.  */
-
-/* Only use free slots, never change or reorder the existing
-   entries.  */
-typedef enum
-  {
-    GPG_ERR_NO_ERROR = 0,              /* An error that is not an error.  */
-    GPG_ERR_GENERAL = 1,
-    GPG_ERR_UNKNOWN_PACKET = 2,
-    GPG_ERR_UNKNOWN_VERSION = 3,       /* Unknown version (in packet).  */
-    GPG_ERR_PUBKEY_ALGO        = 4,            /* Invalid public key algorithm.  */
-    GPG_ERR_DIGEST_ALGO = 5,           /* Invalid digest algorithm.  */
-    GPG_ERR_BAD_PUBKEY = 6,            /* Bad public key.  */
-    GPG_ERR_BAD_SECKEY = 7,            /* Bad secret key.  */
-    GPG_ERR_BAD_SIGNATURE = 8,         /* Bad signature.  */
-    GPG_ERR_NO_PUBKEY = 9,             /* Public key not found.  */
-    GPG_ERR_CHECKSUM = 10,             /* Checksum error.  */
-    GPG_ERR_BAD_PASSPHRASE = 11,       /* Bad passphrase.  */
-    GPG_ERR_CIPHER_ALGO = 12,          /* Invalid cipher algorithm.  */
-    GPG_ERR_KEYRING_OPEN = 13,
-    GPG_ERR_INV_PACKET = 14,
-    GPG_ERR_INV_ARMOR = 15,
-    GPG_ERR_NO_USER_ID = 16,
-    GPG_ERR_NO_SECKEY = 17,            /* Secret key not available.  */
-    GPG_ERR_WRONG_SECKEY = 18,         /* Wrong secret key used.  */
-    GPG_ERR_BAD_KEY = 19,              /* Bad (session) key.  */
-    GPG_ERR_COMPR_ALGO = 20,           /* Unknown compress algorithm.  */
-
-    /* Codes 21 to 29 are free to be used.  */
-
-    GPG_ERR_BAD_MPI = 30,              /* Problem with an MPI's value.  */
-    GPG_ERR_INV_PASSPHRASE = 31,       /* Invalid passphrase.  */
-    GPG_ERR_SIG_CLASS = 32,
-    GPG_ERR_RESOURCE_LIMIT = 33,
-    GPG_ERR_INV_KEYRING = 34,
-    GPG_ERR_TRUSTDB = 35,              /* A problem with the trustdb.  */
-    GPG_ERR_BAD_CERT = 36,             /* Bad certificate.  */
-    GPG_ERR_INV_USER_ID = 37,
-    GPG_ERR_UNEXPECTED = 38,
-    GPG_ERR_TIME_CONFLICT = 39,
-    GPG_ERR_KEYSERVER = 40,
-    GPG_ERR_WRONG_PUBKEY_ALGO = 41,    /* Wrong public key algorithm.  */
-    GPG_ERR_TRIBUTE_TO_D_A = 42,
-    GPG_ERR_WEAK_KEY = 43,             /* Weak encryption key.  */
-    GPG_ERR_INV_KEYLEN = 44,           /* Invalid length of a key.  */
-    GPG_ERR_INV_ARG = 45,              /* Invalid argument.  */
-    GPG_ERR_BAD_URI = 46,              /* Syntax error in URI.  */
-    GPG_ERR_INV_URI = 47,              /* Unsupported scheme and similar.  */
-    GPG_ERR_NETWORK = 48,              /* General network error.  */
-    GPG_ERR_UNKNOWN_HOST = 49,
-    GPG_ERR_SELFTEST_FAILED = 50,
-    GPG_ERR_NOT_ENCRYPTED = 51,
-    GPG_ERR_NOT_PROCESSED = 52,
-    GPG_ERR_UNUSABLE_PUBKEY = 53,
-    GPG_ERR_UNUSABLE_SECKEY = 54,
-    GPG_ERR_INV_VALUE = 55,
-    GPG_ERR_BAD_CERT_CHAIN = 56,
-    GPG_ERR_MISSING_CERT = 57,
-    GPG_ERR_NO_DATA = 58,
-    GPG_ERR_BUG = 59,
-    GPG_ERR_NOT_SUPPORTED = 60,
-    GPG_ERR_INV_OP = 61,               /* Invalid operation code.  */
-    GPG_ERR_TIMEOUT = 62,               /* Something timed out. */
-    GPG_ERR_INTERNAL = 63,             /* Internal error.  */
-    GPG_ERR_EOF_GCRYPT = 64,           /* Compatibility for gcrypt.  */
-    GPG_ERR_INV_OBJ = 65,              /* An object is not valid.  */
-    GPG_ERR_TOO_SHORT = 66,            /* Provided object is too short.  */
-    GPG_ERR_TOO_LARGE = 67,            /* Provided object is too large.  */
-    GPG_ERR_NO_OBJ = 68,               /* Missing item in an object.  */
-    GPG_ERR_NOT_IMPLEMENTED = 69,      /* Not implemented.  */
-    GPG_ERR_CONFLICT = 70,             /* Conflicting use.  */
-    GPG_ERR_INV_CIPHER_MODE = 71,      /* Invalid cipher mode.  */ 
-    GPG_ERR_INV_FLAG = 72,             /* Invalid flag.  */
-    GPG_ERR_INV_HANDLE = 73,            /* Invalid handle.  */
-
-    /* Code 74 is free to be used.  */
-
-    GPG_ERR_INCOMPLETE_LINE = 75,
-    GPG_ERR_INV_RESPONSE = 76,
-    GPG_ERR_NO_AGENT = 77,
-    GPG_ERR_AGENT = 78,
-    GPG_ERR_INV_DATA = 79,
-    GPG_ERR_ASSUAN_SERVER_FAULT = 80,
-    GPG_ERR_ASSUAN = 81,               /* Catch all assuan error.  */
-    GPG_ERR_INV_SESSION_KEY = 82,
-    GPG_ERR_INV_SEXP = 83,
-    GPG_ERR_UNSUPPORTED_ALGORITHM = 84,
-    GPG_ERR_NO_PIN_ENTRY = 85,
-    GPG_ERR_PIN_ENTRY = 86,
-    GPG_ERR_BAD_PIN = 87,
-    GPG_ERR_INV_NAME = 88,
-    GPG_ERR_BAD_DATA = 89,
-    GPG_ERR_INV_PARAMETER = 90,
-
-    /* Code 91 is free to be used.  */
-
-    GPG_ERR_NO_DIRMNGR = 92,
-    GPG_ERR_DIRMNGR = 93,
-    GPG_ERR_CERT_REVOKED = 94,
-    GPG_ERR_NO_CRL_KNOWN = 95,
-    GPG_ERR_CRL_TOO_OLD = 96,
-    GPG_ERR_LINE_TOO_LONG = 97,
-    GPG_ERR_NOT_TRUSTED = 98,
-    GPG_ERR_CANCELED = 109,
-    GPG_ERR_BAD_CA_CERT = 100,
-    GPG_ERR_CERT_EXPIRED = 101,                /* Key signature expired.  */
-    GPG_ERR_CERT_TOO_YOUNG = 102,
-    GPG_ERR_UNSUPPORTED_CERT = 103,
-    GPG_ERR_UNKNOWN_SEXP = 104,
-    GPG_ERR_UNSUPPORTED_PROTECTION = 105,
-    GPG_ERR_CORRUPTED_PROTECTION = 106,
-    GPG_ERR_AMBIGUOUS_NAME = 107,
-    GPG_ERR_CARD = 108,
-    GPG_ERR_CARD_RESET = 109,
-    GPG_ERR_CARD_REMOVED = 110,
-    GPG_ERR_INV_CARD = 111,
-    GPG_ERR_CARD_NOT_PRESENT = 112,
-    GPG_ERR_NO_PKCS15_APP = 113,
-    GPG_ERR_NOT_CONFIRMED = 114,
-    GPG_ERR_CONFIGURATION = 115,
-    GPG_ERR_NO_POLICY_MATCH = 116,
-    GPG_ERR_INV_INDEX = 117,
-    GPG_ERR_INV_ID = 118,
-    GPG_ERR_NO_SCDAEMON = 119,
-    GPG_ERR_SCDAEMON = 120,
-    GPG_ERR_UNSUPPORTED_PROTOCOL = 121,
-    GPG_ERR_BAD_PIN_METHOD = 122,
-    GPG_ERR_CARD_NOT_INITIALIZED = 123,
-    GPG_ERR_UNSUPPORTED_OPERATION = 124,
-    GPG_ERR_WRONG_KEY_USAGE = 125,
-    GPG_ERR_NOTHING_FOUND = 126,        /* Operation failed due to an
-                                           unsuccessful find operation.  */
-    GPG_ERR_WRONG_BLOB_TYPE = 127,      /* Keybox BLOB of wrong type.  */
-    GPG_ERR_MISSING_VALUE = 128,        /* A required value is missing.  */
-
-    /* 129 to 149 are free to be used.  */
-
-    GPG_ERR_INV_ENGINE = 150,
-    GPG_ERR_PUBKEY_NOT_TRUSTED = 151,
-    GPG_ERR_DECRYPT_FAILED = 152,
-    GPG_ERR_KEY_EXPIRED = 153,
-    GPG_ERR_SIG_EXPIRED = 154,         /* Data signature expired.  */
-
-    /* 155 to 200 are free to be used.  */
-
-    /* Error codes pertaining to S-expressions.  */
-    GPG_ERR_SEXP_INV_LEN_SPEC = 201,
-    GPG_ERR_SEXP_STRING_TOO_LONG = 202,
-    GPG_ERR_SEXP_UNMATCHED_PAREN = 203, 
-    GPG_ERR_SEXP_NOT_CANONICAL = 204, 
-    GPG_ERR_SEXP_BAD_CHARACTER = 205, 
-    GPG_ERR_SEXP_BAD_QUOTATION = 206,  /* Or invalid hex or octal value.  */
-    GPG_ERR_SEXP_ZERO_PREFIX = 207,    /* First character of length is 0.  */
-    GPG_ERR_SEXP_NESTED_DH = 208,      /* Nested display hints.  */
-    GPG_ERR_SEXP_UNMATCHED_DH = 209,   /* Unmatched display hint.  */
-    GPG_ERR_SEXP_UNEXPECTED_PUNC = 210,        /* Unexpected reserved punctuation. */
-    GPG_ERR_SEXP_BAD_HEX_CHAR = 211,
-    GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212,
-    GPG_ERR_SEXP_BAD_OCT_CHAR = 213,
-
-    /* 213 to 1023 are free to be used.  */
-
-    /* For free use by non-GnuPG components.  */
-    GPG_ERR_USER_1 = 1024,
-    GPG_ERR_USER_2 = 1025,
-    GPG_ERR_USER_3 = 1026,
-    GPG_ERR_USER_4 = 1027,
-    GPG_ERR_USER_5 = 1028,
-    GPG_ERR_USER_6 = 1029,
-    GPG_ERR_USER_7 = 1030,
-    GPG_ERR_USER_8 = 1031,
-    GPG_ERR_USER_9 = 1032,
-    GPG_ERR_USER_10 = 1033,
-    GPG_ERR_USER_11 = 1034,
-    GPG_ERR_USER_12 = 1035,
-    GPG_ERR_USER_13 = 1036,
-    GPG_ERR_USER_14 = 1037,
-    GPG_ERR_USER_15 = 1038,
-    GPG_ERR_USER_16 = 1039,
-
-    /* 1040 to 16381 are free to be used.  */
-
-    GPG_ERR_UNKNOWN_ERRNO = 16382,
-    GPG_ERR_EOF = 16383,               /* This was once a -1.  Pity.  */
-
-    /* The following error codes are used to map system errors.  */
-    GPG_ERR_E2BIG = 16384,
-    GPG_ERR_EACCES = 16385,
-    GPG_ERR_EADDRINUSE = 16386,
-    GPG_ERR_EADDRNOTAVAIL = 16387,
-    GPG_ERR_EADV = 16388,
-    GPG_ERR_EAFNOSUPPORT = 16389,
-    GPG_ERR_EAGAIN = 16390,
-    GPG_ERR_EALREADY = 16391,
-    GPG_ERR_EAUTH = 16392,
-    GPG_ERR_EBACKGROUND = 16393,
-    GPG_ERR_EBADE = 16394,
-    GPG_ERR_EBADF = 16395,
-    GPG_ERR_EBADFD = 16396,
-    GPG_ERR_EBADMSG = 16397,
-    GPG_ERR_EBADR = 16398,
-    GPG_ERR_EBADRPC = 16399,
-    GPG_ERR_EBADRQC = 16400,
-    GPG_ERR_EBADSLT = 16401,
-    GPG_ERR_EBFONT = 16402,
-    GPG_ERR_EBUSY = 16403,
-    GPG_ERR_ECANCELED = 16404,
-    GPG_ERR_ECHILD = 16405,
-    GPG_ERR_ECHRNG = 16406,
-    GPG_ERR_ECOMM = 16407,
-    GPG_ERR_ECONNABORTED = 16408,
-    GPG_ERR_ECONNREFUSED = 16409,
-    GPG_ERR_ECONNRESET = 16410,
-    GPG_ERR_ED = 16411,
-    GPG_ERR_EDEADLK = 16412,
-    GPG_ERR_EDEADLOCK = 16413,
-    GPG_ERR_EDESTADDRREQ = 16414,
-    GPG_ERR_EDIED = 16415,
-    GPG_ERR_EDOM = 16416,
-    GPG_ERR_EDOTDOT = 16417,
-    GPG_ERR_EDQUOT = 16418,
-    GPG_ERR_EEXIST = 16419,
-    GPG_ERR_EFAULT = 16420,
-    GPG_ERR_EFBIG = 16421,
-    GPG_ERR_EFTYPE = 16422,
-    GPG_ERR_EGRATUITOUS = 16423,
-    GPG_ERR_EGREGIOUS = 16424,
-    GPG_ERR_EHOSTDOWN = 16425,
-    GPG_ERR_EHOSTUNREACH = 16426,
-    GPG_ERR_EIDRM = 16427,
-    GPG_ERR_EIEIO = 16428,
-    GPG_ERR_EILSEQ = 16429,
-    GPG_ERR_EINPROGRESS = 16430,
-    GPG_ERR_EINTR = 16431,
-    GPG_ERR_EINVAL = 16432,
-    GPG_ERR_EIO = 16433,
-    GPG_ERR_EISCONN = 16434,
-    GPG_ERR_EISDIR = 16435,
-    GPG_ERR_EISNAM = 16436,
-    GPG_ERR_EL2HLT = 16437,
-    GPG_ERR_EL2NSYNC = 16438,
-    GPG_ERR_EL3HLT = 16439,
-    GPG_ERR_EL3RST = 16440,
-    GPG_ERR_ELIBACC = 16441,
-    GPG_ERR_ELIBBAD = 16442,
-    GPG_ERR_ELIBEXEC = 16443,
-    GPG_ERR_ELIBMAX = 16444,
-    GPG_ERR_ELIBSCN = 16445,
-    GPG_ERR_ELNRNG = 16446,
-    GPG_ERR_ELOOP = 16447,
-    GPG_ERR_EMEDIUMTYPE = 16448,
-    GPG_ERR_EMFILE = 16449,
-    GPG_ERR_EMLINK = 16450,
-    GPG_ERR_EMSGSIZE = 16451,
-    GPG_ERR_EMULTIHOP = 16452,
-    GPG_ERR_ENAMETOOLONG = 16453,
-    GPG_ERR_ENAVAIL = 16454,
-    GPG_ERR_ENEEDAUTH = 16455,
-    GPG_ERR_ENETDOWN = 16456,
-    GPG_ERR_ENETRESET = 16457,
-    GPG_ERR_ENETUNREACH = 16458,
-    GPG_ERR_ENFILE = 16459,
-    GPG_ERR_ENOANO = 16460,
-    GPG_ERR_ENOBUFS = 16461,
-    GPG_ERR_ENOCSI = 16462,
-    GPG_ERR_ENODATA = 16463,
-    GPG_ERR_ENODEV = 16464,
-    GPG_ERR_ENOENT = 16465,
-    GPG_ERR_ENOEXEC = 16466,
-    GPG_ERR_ENOLCK = 16467,
-    GPG_ERR_ENOLINK = 16468,
-    GPG_ERR_ENOMEDIUM = 16469,
-    GPG_ERR_ENOMEM = 16470,
-    GPG_ERR_ENOMSG = 16471,
-    GPG_ERR_ENONET = 16472,
-    GPG_ERR_ENOPKG = 16473,
-    GPG_ERR_ENOPROTOOPT = 16474,
-    GPG_ERR_ENOSPC = 16475,
-    GPG_ERR_ENOSR = 16476,
-    GPG_ERR_ENOSTR = 16477,
-    GPG_ERR_ENOSYS = 16478,
-    GPG_ERR_ENOTBLK = 16479,
-    GPG_ERR_ENOTCONN = 16480,
-    GPG_ERR_ENOTDIR = 16481,
-    GPG_ERR_ENOTEMPTY = 16482,
-    GPG_ERR_ENOTNAM = 16483,
-    GPG_ERR_ENOTSOCK = 16484,
-    GPG_ERR_ENOTSUP = 16485,
-    GPG_ERR_ENOTTY = 16486,
-    GPG_ERR_ENOTUNIQ = 16487,
-    GPG_ERR_ENXIO = 16488,
-    GPG_ERR_EOPNOTSUPP = 16489,
-    GPG_ERR_EOVERFLOW = 16490,
-    GPG_ERR_EPERM = 16491,
-    GPG_ERR_EPFNOSUPPORT = 16492,
-    GPG_ERR_EPIPE = 16493,
-    GPG_ERR_EPROCLIM = 16494,
-    GPG_ERR_EPROCUNAVAIL = 16495,
-    GPG_ERR_EPROGMISMATCH = 16496,
-    GPG_ERR_EPROGUNAVAIL = 16497,
-    GPG_ERR_EPROTO = 16498,
-    GPG_ERR_EPROTONOSUPPORT = 16499,
-    GPG_ERR_EPROTOTYPE = 16500,
-    GPG_ERR_ERANGE = 16501,
-    GPG_ERR_EREMCHG = 16502,
-    GPG_ERR_EREMOTE = 16503,
-    GPG_ERR_EREMOTEIO = 16504,
-    GPG_ERR_ERESTART = 16505,
-    GPG_ERR_EROFS = 16506,
-    GPG_ERR_ERPCMISMATCH = 16507,
-    GPG_ERR_ESHUTDOWN = 16508,
-    GPG_ERR_ESOCKTNOSUPPORT = 16509,
-    GPG_ERR_ESPIPE = 16510,
-    GPG_ERR_ESRCH = 16511,
-    GPG_ERR_ESRMNT = 16512,
-    GPG_ERR_ESTALE = 16513,
-    GPG_ERR_ESTRPIPE = 16514,
-    GPG_ERR_ETIME = 16515,
-    GPG_ERR_ETIMEDOUT = 16516,
-    GPG_ERR_ETOOMANYREFS = 16517,
-    GPG_ERR_ETXTBSY = 16518,
-    GPG_ERR_EUCLEAN = 16519,
-    GPG_ERR_EUNATCH = 16520,
-    GPG_ERR_EUSERS = 16521,
-    GPG_ERR_EWOULDBLOCK = 16522,
-    GPG_ERR_EXDEV = 16523,
-    GPG_ERR_EXFULL = 16524,
-
-    /* 16525 to 32677 are free to be used for more system errors.  */
-
-    /* This is one more than the largest allowed entry.  */
-    GPG_ERR_CODE_DIM = 32768
-  } gpg_err_code_t;
-
-\f
-/* The error value type gpg_error_t.  */
-
-/* We would really like to use bit-fields in a struct, but using
-   structs as return values can cause binary compatibility issues, in
-   particular if you want to do it effeciently (also see
-   -freg-struct-return option to GCC).  */
-typedef unsigned int gpg_error_t;
-
-/* We use the lowest 16 bits of gpg_error_t for error codes.  The 17th
-   bit indicates system errors.  */
-#define GPG_ERR_CODE_MASK      (GPG_ERR_CODE_DIM - 1)
-#define GPG_ERR_SYSTEM_ERROR   16384
-
-/* Bits 18 to 24 are reserved.  */
-
-/* We use the upper 8 bits of gpg_error_t for error sources.  */
-#define GPG_ERR_SOURCE_MASK    (GPG_ERR_SOURCE_DIM - 1)
-#define GPG_ERR_SOURCE_SHIFT   24
-
-\f
-/* Constructor and accessor functions.  */
-
-/* Construct an error value from an error code and source.  Within a
-   subsystem, use gpg_error.  */
-static __inline__ gpg_error_t
-gpg_err_make (gpg_err_source_t source, gpg_err_code_t code)
-{
-  return code == GPG_ERR_NO_ERROR ? GPG_ERR_NO_ERROR
-    : (((source & GPG_ERR_SOURCE_MASK) << GPG_ERR_SOURCE_SHIFT)
-       | (code & GPG_ERR_CODE_MASK));
-}
-
-
-/* The user should define GPG_ERR_SOURCE_DEFAULT before including this
-   file to specify a default source for gpg_error.  */
-#ifndef GPG_ERR_SOURCE_DEFAULT
-#define GPG_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_UNKNOWN
-#endif
-
-static __inline__ gpg_error_t
-gpg_error (gpg_err_code_t code)
-{
-  return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, code);
-}
-
-
-/* Retrieve the error code from an error value.  */
-static __inline__ gpg_err_code_t
-gpg_err_code (gpg_error_t err)
-{
-  return err & GPG_ERR_CODE_MASK;
-}
 
-
-/* Retrieve the error source from an error value.  */
-static __inline__ gpg_err_source_t
-gpg_err_source (gpg_error_t err)
-{
-  return (err >> GPG_ERR_SOURCE_SHIFT) & GPG_ERR_SOURCE_MASK;
-}
-
-\f
-/* String functions.  */
-
-/* Return a pointer to a string containing a description of the error
-   code in the error value ERR.  */
-const char *gpg_strerror (gpg_error_t err);
-
-/* Return a pointer to a string containing a description of the error
-   source in the error value ERR.  */
-const char *gpg_strsource (gpg_error_t err);
-
-\f
-/* Mapping of system errors (errno).  */
-
-/* Retrieve the error code for the system error ERR.  This returns
-   GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
-   this).  */
-gpg_err_code_t gpg_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 gpg_err_code_to_errno (gpg_err_code_t code);
-
-\f
-/* Self-documenting convenience functions.  */
-
-static __inline__ gpg_error_t
-gpg_err_make_from_errno (gpg_err_source_t source, int err)
-{
-  return gpg_err_make (source, gpg_err_code_from_errno (err));
-}
-
-
-static __inline__ gpg_error_t
-gpg_error_from_errno (int err)
-{
-  return gpg_error (gpg_err_code_from_errno (err));
-}
-#endif
+/* This is required for error code compatibility. */
+#define _GCRY_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_GCRYPT
 
 #ifdef __cplusplus
 extern "C" {
-#if 0 /* keep Emacsens's auto-indent happy */
+#if 0 /* keep Emacsens' auto-indent happy */
 }
 #endif
 #endif
@@ -492,7 +42,7 @@ extern "C" {
    autoconf (using the AM_PATH_GCRYPT macro) check that this header
    matches the installed library.  Note: Do not edit the next line as
    configure may fix the string here.  */
-#define GCRYPT_VERSION "1.1.13-cvs"
+#define GCRYPT_VERSION "1.1.44"
 
 /* Internal: We can't use the convenience macros for the multi
    precision integer functions when building this library. */
@@ -503,7 +53,7 @@ extern "C" {
 #endif
 
 /* We want to use gcc attributes when possible.  Warning: Don't use
-   these macros in your progranms: As indicated by the leading
+   these macros in your programs: As indicated by the leading
    underscore they are subject to change without notice. */
 #ifdef __GNUC__
 
@@ -535,114 +85,79 @@ extern "C" {
 #define _GCRY_GCC_ATTR_MALLOC
 #endif
 
-/* The data object used to hold a multi precision integer.  */
-struct gcry_mpi;
-typedef struct gcry_mpi *gcry_mpi_t;
+/* Wrappers for the libgpg-error library.  */
 
-typedef struct gcry_mpi *GCRY_MPI _GCRY_GCC_ATTR_DEPRECATED;
-typedef struct gcry_mpi *GcryMPI _GCRY_GCC_ATTR_DEPRECATED;
+typedef gpg_error_t gcry_error_t;
+typedef gpg_err_code_t gcry_err_code_t;
+typedef gpg_err_source_t gcry_err_source_t;
 
-\f
-/* The error numbers used by Libgcrypt.  */
+static GPG_ERR_INLINE gcry_error_t
+gcry_err_make (gcry_err_source_t source, gcry_err_code_t code)
+{
+  return gpg_err_make (source, code);
+}
 
-/* These definitions provide some API compatibility.  */
+/* The user can define GPG_ERR_SOURCE_DEFAULT before including this
+   file to specify a default source for gpg_error.  */
+#ifndef GCRY_ERR_SOURCE_DEFAULT
+#define GCRY_ERR_SOURCE_DEFAULT  GPG_ERR_SOURCE_USER_1
+#endif
 
-#ifndef USE_LIBGPG_ERROR
-/* FIXME!!!! */
+static GPG_ERR_INLINE gcry_error_t
+gcry_error (gcry_err_code_t code)
+{
+  return gcry_err_make (GCRY_ERR_SOURCE_DEFAULT, code);
+}
 
-#define gpg_strerror(x) gcry_strerror (x)
+static GPG_ERR_INLINE gcry_err_code_t
+gcry_err_code (gcry_error_t err)
+{
+  return gpg_err_code (err);
+}
 
-#endif
 
+static GPG_ERR_INLINE gcry_err_source_t
+gcry_err_source (gcry_error_t err)
+{
+  return gpg_err_source (err);
+}
 
-/* This is here for API compatibility.  */
-enum
-  {
-    GCRYERR_SUCCESS = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_NO_ERROR & 0xFFFF),
-    GCRYERR_GENERAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_GENERAL & 0xFFFF),
-    GCRYERR_INV_PK_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_PUBKEY_ALGO & 0xFFFF),
-    GCRYERR_INV_MD_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_DIGEST_ALGO & 0xFFFF),
-    GCRYERR_BAD_PUBLIC_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_BAD_PUBKEY & 0xFFFF),
-    GCRYERR_BAD_SECRET_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_BAD_SECKEY & 0xFFFF),
-    GCRYERR_BAD_SIGNATURE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_BAD_SIGNATURE & 0xFFFF),
-    GCRYERR_INV_CIPHER_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_CIPHER_ALGO & 0xFFFF),
-    GCRYERR_BAD_MPI = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_BAD_MPI & 0xFFFF),
-    GCRYERR_WRONG_PK_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_WRONG_PUBKEY_ALGO & 0xFFFF),
-    GCRYERR_WEAK_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_WEAK_KEY & 0xFFFF),
-    GCRYERR_INV_KEYLEN = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_KEYLEN & 0xFFFF),
-    GCRYERR_INV_ARG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_ARG & 0xFFFF),
-    GCRYERR_SELFTEST = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SELFTEST_FAILED & 0xFFFF),
-    GCRYERR_INV_OP = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_OP & 0xFFFF),
-
-    GCRYERR_INTERNAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INTERNAL & 0xFFFF),
-
-    GCRYERR_INV_OBJ = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_OBJ & 0xFFFF),
-    GCRYERR_TOO_SHORT = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_TOO_SHORT & 0xFFFF),
-    GCRYERR_TOO_LARGE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_TOO_LARGE & 0xFFFF),
-    GCRYERR_NO_OBJ = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_NO_OBJ & 0xFFFF),
-    GCRYERR_NOT_IMPL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_NOT_IMPLEMENTED & 0xFFFF),
-    GCRYERR_CONFLICT = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_CONFLICT & 0xFFFF),
-    GCRYERR_INV_CIPHER_MODE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_CIPHER_MODE & 0xFFFF),
-    GCRYERR_INV_FLAG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_INV_FLAG & 0xFFFF),
-    GCRYERR_SEXP_INV_LEN_SPEC = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_INV_LEN_SPEC & 0xFFFF),
-    GCRYERR_SEXP_STRING_TOO_LONG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_STRING_TOO_LONG & 0xFFFF),
-    GCRYERR_SEXP_UNMATCHED_PAREN = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_UNMATCHED_PAREN & 0xFFFF),
-    GCRYERR_SEXP_NOT_CANONICAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_NOT_CANONICAL & 0xFFFF),
-    GCRYERR_SEXP_BAD_CHARACTER = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_BAD_CHARACTER & 0xFFFF),
-    GCRYERR_SEXP_BAD_QUOTATION = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_BAD_QUOTATION & 0xFFFF),
-    GCRYERR_SEXP_ZERO_PREFIX = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_ZERO_PREFIX & 0xFFFF),
-    GCRYERR_SEXP_NESTED_DH = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_NESTED_DH & 0xFFFF),
-    GCRYERR_SEXP_UNMATCHED_DH = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_UNMATCHED_DH & 0xFFFF),
-    GCRYERR_SEXP_UNEXPECTED_PUNC = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_UNEXPECTED_PUNC & 0xFFFF),
-    GCRYERR_SEXP_BAD_HEX_CHAR = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_BAD_HEX_CHAR & 0xFFFF),
-    GCRYERR_SEXP_ODD_HEX_NUMBERS = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_ODD_HEX_NUMBERS & 0xFFFF),
-    GCRYERR_SEXP_BAD_OCT_CHAR = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
-                          | (GPG_ERR_SEXP_BAD_OCT_CHAR & 0xFFFF),
+/* Return a pointer to a string containing a description of the error
+   code in the error value ERR.  */
+const char * gcry_strerror (gcry_error_t err);
 
-  };
+/* Return a pointer to a string containing a description of the error
+   source in the error value ERR.  */
+const char *gcry_strsource (gcry_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).  */
+gcry_err_code_t gcry_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 gcry_err_code_to_errno (gcry_err_code_t code);
+
+/* Return an error value with the error source SOURCE and the system
+   error ERR.  */
+gcry_error_t gcry_err_make_from_errno (gcry_err_source_t source, int err);
+
+/* Return an error value with the system error ERR.  */
+gcry_err_code_t gcry_error_from_errno (int err);
+
+/* The data object used to hold a multi precision integer.  */
+struct gcry_mpi;
+typedef struct gcry_mpi *gcry_mpi_t;
+
+typedef struct gcry_mpi *GCRY_MPI _GCRY_GCC_ATTR_DEPRECATED;
+typedef struct gcry_mpi *GcryMPI _GCRY_GCC_ATTR_DEPRECATED;
+
+\f
 
 /* Check that the library fulfills the version requirement.  */
 const char *gcry_check_version (const char *req_version);
 
-/* Map an error number to a string. */
-const char *gcry_strerror (gpg_error_t ec);
-
 /* Codes for function dispatchers.  */
 
 /* Codes used with the gcry_control function. */
@@ -691,11 +206,12 @@ enum gcry_ctl_cmds
     GCRYCTL_SET_CBC_MAC = 42,
     GCRYCTL_SET_CTR = 43,
     GCRYCTL_ENABLE_QUICK_RANDOM = 44,
+    GCRYCTL_SET_RANDOM_SEED_FILE = 45,
+    GCRYCTL_UPDATE_RANDOM_SEED_FILE = 46
   };
 
 /* Perform various operations defined by CMD. */
-gpg_error_t gcry_control (enum gcry_ctl_cmds CMD, ...);
-
+gcry_error_t gcry_control (enum gcry_ctl_cmds CMD, ...);
 
 \f
 /* S-expression management. */ 
@@ -720,27 +236,27 @@ enum gcry_sexp_format
 /* Create an new S-expression object from BUFFER of size LENGTH and
    return it in RETSEXP.  With AUTODETECT set to 0 the data in BUFFER
    is expected to be in canonized format.  */
-gpg_error_t gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
+gcry_error_t gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
                           int autodetect);
 
  /* Same as gcry_sexp_new but allows to pass a FREEFNC which has the
    effect to transfer ownership of BUFFER to the created object.  */
-gpg_error_t gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
+gcry_error_t gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
                              int autodetect, void (*freefnc) (void *));
 
 /* Scan BUFFER and return a new S-expression object in RETSEXP.  This
    function expects a printf like string in BUFFER.  */
-gpg_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
                             const char *buffer, size_t length);
 
 /* Same as gcry_sexp_sscan but expects a string in FORMAT and can thus
    only be used for certain encodings.  */
-gpg_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
                             const char *format, ...);
 
 /* Like gcry_sexp_build, but uses an array instead of variable
    function arguments.  */
-gpg_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
                                   const char *format, void **arg_list);
 
 /* Release the S-expression object SEXP */
@@ -749,7 +265,7 @@ void gcry_sexp_release (gcry_sexp_t sexp);
 /* Calculate the length of an canonized S-expresion in BUFFER and
    check for a valid encoding. */
 size_t gcry_sexp_canon_len (const unsigned char *buffer, size_t length, 
-                            size_t *erroff, gpg_error_t *errcode);
+                            size_t *erroff, gcry_error_t *errcode);
 
 /* Copies the S-expression object SEXP into BUFFER using the format
    specified in MODE.  */
@@ -760,7 +276,6 @@ size_t gcry_sexp_sprint (gcry_sexp_t sexp, int mode, char *buffer,
    to Libgcrypt's logging stream.  */
 void gcry_sexp_dump (const gcry_sexp_t a);
 
-
 gcry_sexp_t gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b);
 gcry_sexp_t gcry_sexp_alist (const gcry_sexp_t *array);
 gcry_sexp_t gcry_sexp_vlist (const gcry_sexp_t a, ...);
@@ -876,26 +391,37 @@ int gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v);
 int gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v);
 
 /* Convert the external representation of an integer stored in BUFFER
-   with a size of (*NBYTES) in a newly create MPI returned in RET_MPI.
-   For certain formats a length is not required and may be passed as
-   NULL.  After a successful operation NBYTES received the number of
-   bytes actually scanned. */
-gpg_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
-                   const char *buffer, size_t *nbytes);
+   with a length of BUFLEN into a newly create MPI returned in
+   RET_MPI.  If NSCANNED is not NULL, it will receive the number of
+   bytes actually scanned after a successful operation. */
+gcry_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
+                            const unsigned char *buffer, size_t buflen, 
+                            size_t *nscanned);
 
 /* Convert the big integer A into the external representation
    described by FORMAT and store it in the provided BUFFER which has
-   the size (*NBYTES).  NBYTES receives the actual length of the
-   external representation. */
-gpg_error_t gcry_mpi_print (enum gcry_mpi_format format,
-                           char *buffer, size_t *nbytes, const gcry_mpi_t a);
-
-/* Convert the big integer A int the external representation desribed
+   been allocated by the user with a size of BUFLEN bytes.  NWRITTEN
+   receives the actual length of the external representation unless it
+   has been passed as NULL. */
+gcry_error_t gcry_mpi_print (enum gcry_mpi_format format,
+                             unsigned char *buffer, size_t buflen,
+                             size_t *nwritten,
+                             const gcry_mpi_t a);
+
+/* Convert the big integer A int the external representation described
    by FORMAT and store it in a newly allocated buffer which address
-   will be put into BUFFER.  NBYTES receives the actual lengths of the
+   will be put into BUFFER.  NWRITTEN receives the actual lengths of the
    external representation. */
-gpg_error_t gcry_mpi_aprint (enum gcry_mpi_format format,
-                            void **buffer, size_t *nbytes, const gcry_mpi_t a);
+gcry_error_t gcry_mpi_aprint (enum gcry_mpi_format format,
+                              unsigned char **buffer, size_t *nwritten,
+                              const gcry_mpi_t a);
+
+/* Dump the value of A in a format suitable for debugging to
+   Libgcrypt's logging stream.  Note that one leading space but no
+   trailing space or linefeed will be printed.  It is okay to pass
+   NULL for A. */
+void gcry_mpi_dump (const gcry_mpi_t a);
+
 
 /* W = U + V.  */
 void gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
@@ -970,7 +496,8 @@ void     gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n);
 void     gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n);
 
 /* Store NBITS of the value P points to in A and mark A as an opaque
-   value. */
+   value.  WARNING: Never use an opaque MPI for anything thing else then 
+   gcry_mpi_release, gcry_mpi_get_opaque. */
 gcry_mpi_t gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits);
 
 /* Return a pointer to an opaque value stored in A and return its size
@@ -1072,9 +599,11 @@ enum gcry_cipher_algos
     /* other cipher numbers are above 300 for OpenPGP reasons. */
     GCRY_CIPHER_ARCFOUR     = 301,  /* fully compatible with RSA's RC4 (tm). */
     GCRY_CIPHER_DES         = 302,  /* Yes, this is single key 56 bit DES. */
-    GCRY_CIPHER_SERPENT128  = 303,
-    GCRY_CIPHER_SERPENT192  = 304,
-    GCRY_CIPHER_SERPENT256  = 305,
+    GCRY_CIPHER_TWOFISH128  = 303,
+    GCRY_CIPHER_SERPENT128  = 304,
+    GCRY_CIPHER_SERPENT192  = 305,
+    GCRY_CIPHER_SERPENT256  = 306,
+    
   };
 
 /* The Rijndael algorithm is basically AES, so provide some macros. */
@@ -1109,22 +638,22 @@ enum gcry_cipher_flags
 
 /* Create a handle for algorithm ALGO to be used in MODE.  FLAGS may
    be given as an bitwise OR of the gcry_cipher_flags values. */
-gpg_error_t gcry_cipher_open (gcry_cipher_hd_t *handle,
+gcry_error_t gcry_cipher_open (gcry_cipher_hd_t *handle,
                              int algo, int mode, unsigned int flags);
 
 /* Close the cioher handle H and release all resource. */
 void gcry_cipher_close (gcry_cipher_hd_t h);
 
 /* Perform various operations on the cipher object H. */
-gpg_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
+gcry_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
                             size_t buflen);
 
 /* Retrieve various information about the cipher object H. */
-gpg_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
+gcry_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
                              size_t *nbytes);
 
 /* Retrieve various information about the cipher algorithm ALGO. */
-gpg_error_t gcry_cipher_algo_info (int algo, int what, void *buffer,
+gcry_error_t gcry_cipher_algo_info (int algo, int what, void *buffer,
                                   size_t *nbytes);
 
 /* Map the cipher algorithm id ALGO to a string representation of that
@@ -1137,7 +666,7 @@ const char *gcry_cipher_algo_name (int algo) _GCRY_GCC_ATTR_PURE;
 int gcry_cipher_map_name (const char *name) _GCRY_GCC_ATTR_PURE;
 
 /* Given an ASN.1 object identifier in standard IETF dotted decimal
-   format in STING, return the encryption mode associated with that
+   format in STRING, return the encryption mode associated with that
    OID or 0 if not known or applicable. */
 int gcry_cipher_mode_from_oid (const char *string) _GCRY_GCC_ATTR_PURE;
 
@@ -1145,12 +674,12 @@ int gcry_cipher_mode_from_oid (const char *string) _GCRY_GCC_ATTR_PURE;
    into the buffer OUT which has an allocated length of OUTSIZE.  For
    most algorithms it is possible to pass NULL for in and 0 for INLEN
    and do a in-place decryption of the data provided in OUT.  */
-gpg_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h,
+gcry_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h,
                                 unsigned char *out, size_t outsize,
                                 const unsigned char *in, size_t inlen);
 
 /* The counterpart to gcry_cipher_encrypt.  */
-gpg_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
+gcry_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
                                 unsigned char *out, size_t outsize,
                                 const unsigned char *in, size_t inlen);
 
@@ -1182,17 +711,22 @@ gpg_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
                                                    (char*)(k), (l) )
 
 /* Retrieved the key length used with algorithm A. */
-#define gcry_cipher_get_algo_keylen(a, b) \
-           gcry_cipher_algo_info( (a), GCRYCTL_GET_KEYLEN, NULL, b)
+size_t gcry_cipher_get_algo_keylen (int algo);
 
 /* Retrieve the block length used with algorithm A. */
-#define gcry_cipher_get_algo_blklen(a, b) \
-           gcry_cipher_algo_info( (a), GCRYCTL_GET_BLKLEN, NULL, b)
+size_t gcry_cipher_get_algo_blklen (int algo);
 
 /* Return 0 if the algorithm A is available for use. */
 #define gcry_cipher_test_algo(a) \
            gcry_cipher_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
 
+/* Get a list consisting of the IDs of the loaded cipher modules.  If
+   LIST is zero, write the number of loaded cipher modules to
+   LIST_LENGTH and return.  If LIST is non-zero, the first
+   *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
+   according size.  In case there are less cipher modules than
+   *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
+gcry_error_t gcry_cipher_list (int *list, int *list_length);
 
 \f
 /************************************
@@ -1218,32 +752,32 @@ enum gcry_pk_algos
 
 /* Encrypt the DATA using the public key PKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey);
+gcry_error_t gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey);
 
 /* Decrypt the DATA using the private key SKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
+gcry_error_t gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
 
 /* Sign the DATA using the private key SKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
+gcry_error_t gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
 
 /* Check the signature SIGVAL on DATA using the public key PKEY. */
-gpg_error_t gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey);
+gcry_error_t gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey);
 
-/* Check that KEY (either private or public) is sane. */
-gpg_error_t gcry_pk_testkey (gcry_sexp_t key);
+/* Check that private KEY is sane. */
+gcry_error_t gcry_pk_testkey (gcry_sexp_t key);
 
 /* Generate a new key pair according to the parameters given in
    S_PARMS.  The new key pair is returned in as an S-expression in
    R_KEY. */
-gpg_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
+gcry_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
 
 /* Catch all function for miscellaneous operations. */
-gpg_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
+gcry_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
 
 /* Retrieve information about the public key algorithm ALGO. */
-gpg_error_t gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes);
+gcry_error_t gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes);
 
 /* Map the public key algorithm id ALGO to a string representation of the
    algorithm name.  For unknown algorithms this functions returns an
@@ -1266,8 +800,182 @@ unsigned char *gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array);
 #define gcry_pk_test_algo(a) \
            gcry_pk_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
 
+/* Get a list consisting of the IDs of the loaded pubkey modules.  If
+   LIST is zero, write the number of loaded pubkey modules to
+   LIST_LENGTH and return.  If LIST is non-zero, the first
+   *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
+   according size.  In case there are less pubkey modules than
+   *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
+gcry_error_t gcry_pk_list (int *list, int *list_length);
+
+/* Alternative interface for asymetric cryptography.  */
+
+/* The algorithm IDs. */
+typedef enum gcry_ac_id
+  {
+    GCRY_AC_RSA = 1,
+    GCRY_AC_DSA = 17,
+    GCRY_AC_ELG = 20,
+    GCRY_AC_ELG_E = 16,
+  }
+gcry_ac_id_t;
+
+/* Key types.  */
+typedef enum gcry_ac_key_type
+  {
+    GCRY_AC_KEY_SECRET,
+    GCRY_AC_KEY_PUBLIC,
+  }
+gcry_ac_key_type_t;
+
+/* Flags for data. */
+#define GCRY_AC_FLAG_DATA_NO_BLINDING 1 << 0
+
+/* This type represents a `data set'.  */
+typedef struct gcry_ac_data *gcry_ac_data_t;
+
+/* This type represents a single `key', either a secret one or a
+   public one.  */
+typedef struct gcry_ac_key *gcry_ac_key_t;
+
+/* This type represents a `key pair' containing a secret and a public
+   key.  */
+typedef struct gcry_ac_key_pair *gcry_ac_key_pair_t;
+
+/* This type represents a `handle' that is needed by functions
+   performing cryptographic operations.  */
+typedef struct gcry_ac_handle *gcry_ac_handle_t;
+
+/* The caller of gcry_ac_key_pair_generate can provide one of these
+   structures in order to influence the key generation process in an
+   algorithm-specific way.  */
+typedef struct gcry_ac_key_spec_rsa
+{
+  gcry_mpi_t e;                        /* E to use.  */
+} gcry_ac_key_spec_rsa_t;
+
+/* Returns a new, empty data set in DATA.  */
+gcry_error_t gcry_ac_data_new (gcry_ac_data_t *data);
+
+/* Destroy the data set DATA.  */
+void gcry_ac_data_destroy (gcry_ac_data_t data);
+
+/* Add the value MPI to DATA with the label NAME.  If there is already
+   a value with that label, replace it, otherwise add it.  */
+gcry_error_t gcry_ac_data_set (gcry_ac_data_t data,
+                             const char *name,
+                             gcry_mpi_t mpi);
+
+/* Create a copy of the data set DATA and store it in DATA_CP.  */
+gcry_error_t gcry_ac_data_copy (gcry_ac_data_t *data_cp,
+                              gcry_ac_data_t data);
+
+/* Return the number of named MPI values inside of the data set
+   DATA.  */
+unsigned int gcry_ac_data_length (gcry_ac_data_t data);
+
+/* Store the value labelled with NAME found in DATA in MPI or NULL if
+   a value with that label was not found.  */
+gcry_error_t gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
+                                  gcry_mpi_t *mpi);
+
+/* Return the MPI value with index IDX contained in the data set
+   DATA.  */
+gcry_error_t gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int idx,
+                                   const char **name, gcry_mpi_t *mpi);
+
+/* Destroy any values contained in the data set DATA.  */
+void gcry_ac_data_clear (gcry_ac_data_t data);
+
+/* Create a new ac handle.  */
+gcry_error_t gcry_ac_open (gcry_ac_handle_t *handle,
+                         gcry_ac_id_t algorithm,
+                         unsigned int flags);
+
+/* Destroy an ac handle.  */
+void gcry_ac_close (gcry_ac_handle_t handle);
+
+/* Initialize a key from a given data set.  */
+gcry_error_t gcry_ac_key_init (gcry_ac_key_t *key,
+                             gcry_ac_handle_t handle,
+                             gcry_ac_key_type_t type,
+                             gcry_ac_data_t data);
+
+/* Generate a new key pair.  */
+gcry_error_t gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
+                                      gcry_ac_key_pair_t *key_pair,
+                                      unsigned int nbits,
+                                      void *spec);
+
+/* Returns a specified key from a key pair.  */
+gcry_ac_key_t gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair,
+                                       gcry_ac_key_type_t which);
+
+/* Returns the data set contained in the key KEY.  */
+gcry_ac_data_t gcry_ac_key_data_get (gcry_ac_key_t key);
+
+/* Verify that the key KEY is sane.  */
+gcry_error_t gcry_ac_key_test (gcry_ac_key_t key);
+
+/* Return the number of bits of the key KEY in NBITS.  */
+gcry_error_t gcry_ac_key_get_nbits (gcry_ac_key_t key,
+                                  unsigned int *nbits);
+
+/* Write the 20 byte long key grip of the key KEY to KEY_GRIP.  */
+gcry_error_t gcry_ac_key_get_grip (gcry_ac_key_t key,
+                                 unsigned char *key_grip);
+
+/* Destroy a key.  */
+void gcry_ac_key_destroy (gcry_ac_key_t key);
+
+/* Destroy a key pair.  */
+void gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair);
+
+/* Encrypt the plain text MPI value DATA_PLAIN with the key KEY under
+   the control of the flags FLAGS and store the resulting data set
+   into DATA_ENCRYPTED.  */
+gcry_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle,
+                                 unsigned int flags,
+                                 gcry_ac_key_t key,
+                                 gcry_mpi_t data_plain,
+                                 gcry_ac_data_t *data_encrypted);
+
+/* Decrypt the decrypted data contained in the data set DATA_ENCRYPTED
+   with the key KEY under the control of the flags FLAGS and store the
+   resulting plain text MPI value in DATA_PLAIN.  */
+gcry_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle,
+                                 unsigned int flags,
+                                 gcry_ac_key_t key,
+                                 gcry_mpi_t *data_plain,
+                                 gcry_ac_data_t data_encrypted);
+
+/* Sign the data contained in DATA with the key KEY and store the
+   resulting signature in the data set DATA_SIGNATURE.  */
+gcry_error_t gcry_ac_data_sign (gcry_ac_handle_t handle,
+                              gcry_ac_key_t key,
+                              gcry_mpi_t data,
+                              gcry_ac_data_t *data_signature);
+
+/* Verify that the signature contained in the data set DATA_SIGNATURE
+   is indeed the result of signing the data contained in DATA with the
+   secret key belonging to the public key KEY.  */
+gcry_error_t gcry_ac_data_verify (gcry_ac_handle_t handle,
+                                gcry_ac_key_t key,
+                                gcry_mpi_t data,
+                                gcry_ac_data_t data_signature);
+
+/* Store the textual representation of the algorithm whose id is given
+   in ALGORITHM in NAME.  */
+gcry_error_t gcry_ac_id_to_name (gcry_ac_id_t algorithm,
+                               const char **name);
+
+/* Store the numeric ID of the algorithm whose textual representation
+   is contained in NAME in ALGORITHM.  */
+gcry_error_t gcry_ac_name_to_id (const char *name,
+                               gcry_ac_id_t *algorithm);
 
 \f
+
 /************************************
  *                                  *
  *   cryptograhic hash functions    *
@@ -1294,49 +1002,56 @@ enum gcry_md_algos
     GCRY_MD_CRC24_RFC2440      = 304
   };
 
-/* Flags used with the open function. */
+/* Flags used with the open function.  */
 enum gcry_md_flags
   {
-    GCRY_MD_FLAG_SECURE = 1,  /* Allocate all buffers in "secure" memory */
-    GCRY_MD_FLAG_HMAC  = 2   /* Make an HMAC out of this algorithm. */
+    GCRY_MD_FLAG_SECURE = 1,  /* Allocate all buffers in "secure"
+                                memory.  */
+    GCRY_MD_FLAG_HMAC  = 2   /* Make an HMAC out of this
+                                algorithm.  */
   };
 
-
-/* This object is used to hold a handle to an message digest object.  */
+/* Forward declaration.  */
 struct gcry_md_context;
-struct gcry_md_handle 
-  { /* This structure is private - only to be used by the gcry_md_  macros. */
-    struct gcry_md_context *ctx;
-    int  bufpos;
-    int  bufsize;
-    unsigned char buf[1];
-  };
-typedef struct gcry_md_handle *gcry_md_hd_t;
 
+/* This object is used to hold a handle to a message digest object.
+   This structure is private - only to be used by the public gcry_md_*
+   macros.  */
+typedef struct gcry_md_handle 
+{
+  /* Actual context.  */
+  struct gcry_md_context *ctx;
+  
+  /* Buffer management.  */
+  int  bufpos;
+  int  bufsize;
+  unsigned char buf[1];
+} *gcry_md_hd_t;
+
+/* Compatibility types, do not use them.  */
 typedef struct gcry_md_handle *GCRY_MD_HD _GCRY_GCC_ATTR_DEPRECATED;
 typedef struct gcry_md_handle *GcryMDHd _GCRY_GCC_ATTR_DEPRECATED;
 
-
 /* Create a message digest object for algorithm ALGO.  FLAGS may be
    given as an bitwise OR of the gcry_md_flags values.  ALGO may be
    given as 0 if the algorithms to be used are later set using
-   gcry_md_enable. */
-gpg_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
+   gcry_md_enable.  */
+gcry_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
 
-/* Release the message digest object HD. */
+/* Release the message digest object HD.  */
 void gcry_md_close (gcry_md_hd_t hd);
 
-/* Add the message digest algorithm ALGO to the digest object HD. */
-gpg_error_t gcry_md_enable( gcry_md_hd_t hd, int algo );
+/* Add the message digest algorithm ALGO to the digest object HD.  */
+gcry_error_t gcry_md_enable (gcry_md_hd_t hd, int algo);
 
-/* Create a new digest object as an exact copy of the object HD. */
-gpg_error_t gcry_md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *bhd);
+/* Create a new digest object as an exact copy of the object HD.  */
+gcry_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
 
-/* Reset the digest object HD to its initial state. */
+/* Reset the digest object HD to its initial state.  */
 void gcry_md_reset (gcry_md_hd_t hd);
 
 /* Perform various operations on the digets object HD. */
-gpg_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd, unsigned char *buffer,
+gcry_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd, unsigned char *buffer,
                         size_t buflen);
 
 /* Pass LENGTH bytes of data in BUFFER to the digest object HD so that
@@ -1358,18 +1073,25 @@ void gcry_md_hash_buffer (int algo, void *digest,
 
 /* Retrieve the algorithm used with HD.  This does not work reliable
    if more than one algorithm is enabled in HD. */
-gpg_error_t gcry_md_get_algo (gcry_md_hd_t hd, int *algo);
+int gcry_md_get_algo (gcry_md_hd_t hd);
 
 /* Retrieve the length in bytes of the digest yielded by algorithm
    ALGO. */
 unsigned int gcry_md_get_algo_dlen (int algo);
 
+/* Return true if the the algorithm ALGO is enabled in the digest
+   object A. */
+int gcry_md_is_enabled (gcry_md_hd_t a, int algo);
+
+/* Return true if the digest object A is allocated in "secure" memory. */
+int gcry_md_is_secure (gcry_md_hd_t a);
+
 /* Retrieve various information about the object H.  */
-gpg_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
+gcry_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
                          size_t *nbytes);
 
 /* Retrieve various information about the algorithm ALGO.  */
-gpg_error_t gcry_md_algo_info (int algo, int what, void *buffer,
+gcry_error_t gcry_md_algo_info (int algo, int what, void *buffer,
                               size_t *nbytes);
 
 /* Map the digest algorithm id ALGO to a string representation of the
@@ -1383,7 +1105,7 @@ int gcry_md_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
 
 /* For use with the HMAC feature, the set MAC key to the KEY of
    KEYLEN. */
-gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
+gcry_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
 
 /* Update the hash(s) of H with the character C.  This is a buffered
    version of the gcry_md_write function. */
@@ -1400,10 +1122,6 @@ gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
 #define gcry_md_final(a) \
            gcry_md_ctl ((a), GCRYCTL_FINALIZE, NULL, 0)
 
-/* Return true when the digest object is allocated in "secure" memory. */
-#define gcry_md_is_secure(a, b) \
-           gcry_md_info ((a), GCRYCTL_IS_SECURE, NULL, (b))
-
 /* Return 0 if the algorithm A is available for use. */
 #define gcry_md_test_algo(a) \
            gcry_md_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
@@ -1425,6 +1143,14 @@ gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
 #define gcry_md_stop_debug(a,b) \
            gcry_md_ctl( (a), GCRYCTL_STOP_DUMP, (b), 0 )
 
+/* Get a list consisting of the IDs of the loaded message digest
+   modules.  If LIST is zero, write the number of loaded message
+   digest modules to LIST_LENGTH and return.  If LIST is non-zero, the
+   first *LIST_LENGTH algorithm IDs are stored in LIST, which must be
+   of according size.  In case there are less message digest modules
+   than *LIST_LENGTH, *LIST_LENGTH is updated to the correct
+   number.  */
+gcry_error_t gcry_md_list (int *list, int *list_length);
 
 \f
 /************************************
@@ -1437,13 +1163,13 @@ gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
    to use WEAK for random number which don't need to be
    cryptographically strong, STRONG for session keys and VERY_STRONG
    for key material. */
-enum gcry_random_level
+typedef enum gcry_random_level
   {
     GCRY_WEAK_RANDOM = 0,
     GCRY_STRONG_RANDOM = 1,
     GCRY_VERY_STRONG_RANDOM = 2
-  };
-
+  }
+gcry_random_level_t;
 
 /* Fill BUFFER with LENGTH bytes of random, using random numbers of
    quality LEVEL. */
@@ -1453,7 +1179,7 @@ void gcry_randomize (unsigned char *buffer, size_t length,
 /* Add the external random from BUFFER with LENGTH bytes into the
    pool. QUALITY should either be -1 for unknown or in the range of 0
    to 100 */
-gpg_error_t gcry_random_add_bytes (const void *buffer, size_t length,
+gcry_error_t gcry_random_add_bytes (const void *buffer, size_t length,
                                   int quality);
 
 /* Return NBYTES of allocated random using a random numbers of quality
@@ -1473,6 +1199,51 @@ void *gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
 void gcry_mpi_randomize (gcry_mpi_t w,
                          unsigned int nbits, enum gcry_random_level level);
 
+/* Prime interface.  */
+
+typedef int (*gcry_prime_check_func_t) (void *arg, int mode,
+                                       gcry_mpi_t candidate);
+
+/* Flags for gcry_prime_generate():  */
+
+/* Allocate prime numbers and factors in secure memory.  */
+#define GCRY_PRIME_FLAG_SECRET         (1 << 0)
+
+/* Make sure that at least one prime factor is of size
+   `FACTOR_BITS'.  */
+#define GCRY_PRIME_FLAG_SPECIAL_FACTOR (1 << 1)
+
+/* Generate a new prime number of PRIME_BITS bits and store it in
+   PRIME.  If FACTOR_BITS is non-zero, one of the prime factors of
+   (prime - 1) / 2 must be FACTOR_BITS bits long.  If FACTORS is
+   non-zero, allocate a new, NULL-terminated array holding the prime
+   factors and store it in FACTORS.  FLAGS might be used to influence
+   the prime number generation process.  */
+gcry_error_t gcry_prime_generate (gcry_mpi_t *prime,
+                                 unsigned int prime_bits,
+                                 unsigned int factor_bits,
+                                 gcry_mpi_t **factors,
+                                 gcry_prime_check_func_t cb_func,
+                                 void *cb_arg,
+                                 gcry_random_level_t random_level,
+                                 unsigned int flags);
+
+/* Find a generator for PRIME where the factorization of (prime-1) is
+   in the NULL terminated array FACTORS. Return the generator as a
+   newly allocated MPI in R_G.  If START_G is not NULL, use this as
+   teh start for the search. */
+gcry_error_t gcry_prime_group_generator (gcry_mpi_t *r_g,
+                                         gcry_mpi_t prime, gcry_mpi_t *factors,
+                                         gcry_mpi_t start_g);
+
+
+/* Convenience function to release the FACTORS array. */
+void gcry_prime_release_factors (gcry_mpi_t *factors);
+
+
+/* Check wether the number X is prime.  */
+gcry_error_t gcry_prime_check (gcry_mpi_t x, unsigned int flags);
+
 
 \f
 /************************************
@@ -1493,39 +1264,56 @@ enum gcry_log_levels
     GCRY_LOG_DEBUG  = 100
   };
 
+/* Type for progress handlers.  */
+typedef void (*gcry_handler_progress_t) (void *, const char *, int, int, int);
+
+/* Type for memory allocation handlers.  */
+typedef void *(*gcry_handler_alloc_t) (size_t n);
+
+/* Type for secure memory check handlers.  */
+typedef int (*gcry_handler_secure_check_t) (const void *);
+
+/* Type for memory reallocation handlers.  */
+typedef void *(*gcry_handler_realloc_t) (void *p, size_t n);
+
+/* Type for memory free handlers.  */
+typedef void (*gcry_handler_free_t) (void *);
+
+/* Type for out-of-memory handlers.  */
+typedef int (*gcry_handler_no_mem_t) (void *, size_t, unsigned int);
+
+/* Type for fatal error handlers.  */
+typedef void (*gcry_handler_error_t) (void *, int, const char *);
+
+/* Type for logging handlers.  */
+typedef void (*gcry_handler_log_t) (void *, int, const char *, va_list);
 
 /* Certain operations can provide progress information.  This function
    is used to register a handler for retrieving these information. */
-void gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
-                                void *cb_data);
-
+void gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data);
 
 
 /* Register a custom memory allocation functions. */
-void gcry_set_allocation_handler (void *(*new_alloc_func)(size_t n),
-                                 void *(*new_alloc_secure_func)(size_t n),
-                                 int (*new_is_secure_func)(const void*),
-                                 void *(*new_realloc_func)(void *p, size_t n),
-                                 void (*new_free_func)(void*));
+void gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
+                                 gcry_handler_alloc_t func_alloc_secure,
+                                 gcry_handler_secure_check_t func_secure_check,
+                                 gcry_handler_realloc_t func_realloc,
+                                 gcry_handler_free_t func_free);
 
 /* Register a function used instead of the internal out of memory
    handler. */
-void gcry_set_outofcore_handler (int (*h)(void*, size_t, unsigned int),
-                                 void *opaque );
+void gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque);
 
 /* Register a function used instead of the internal fatal error
    handler. */
-void gcry_set_fatalerror_handler (void (*fnc)(void*,int, const char*),
-                                  void *opaque);
-
-/* Reserved for future use. */
-void gcry_set_gettext_handler (const char *(*f)(const char*));
+void gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque);
 
 /* Register a function used instead of the internal logging
    facility. */
-void gcry_set_log_handler (void (*f)(void*,int, const char*, va_list),
-                           void *opaque);
+void gcry_set_log_handler (gcry_handler_log_t f, void *opaque);
 
+/* Reserved for future use. */
+void gcry_set_gettext_handler (const char *(*f)(const char*));
 
 /* Libgcrypt uses its own memory allocation.  It is important to use
    gcry_free () to release memory allocated by libgcrypt. */
@@ -1546,17 +1334,10 @@ void  gcry_free (void *a);
 /* Return true if A is allocated in "secure" memory. */
 int gcry_is_secure (const void *a) _GCRY_GCC_ATTR_PURE;
 
-#if 0
-/* FIXME.  */
-#ifndef GCRYPT_NO_MPI_MACROS
-#ifndef DID_MPI_TYPEDEF
-    typedef struct gcry_mpi *MPI;
-#define DID_MPI_TYPEDEF
-#endif
-#endif /* GCRYPT_NO_MPI_MACROS */
-#endif
+/* Include support for Libgcrypt modules.  */
+#include <gcrypt-module.h>
 
-#if 0 /* keep Emacsens's auto-indent happy */
+#if 0 /* keep Emacsens' auto-indent happy */
 {
 #endif
 #ifdef __cplusplus