* gcrypt.h (gcry_md_get_algo): Reverted to old API. This is a
authorWerner Koch <wk@gnupg.org>
Fri, 13 Jun 2003 11:38:22 +0000 (11:38 +0000)
committerWerner Koch <wk@gnupg.org>
Fri, 13 Jun 2003 11:38:22 +0000 (11:38 +0000)
convenience function anyway and error checking is not approriate.
(gcry_md_is_enabled): New.
(gcry_md_is_secure): Replaced macro by function and reverted to old
API.

NEWS
cipher/ChangeLog
cipher/cipher.c
cipher/md.c
doc/ChangeLog
doc/gcrypt.texi
src/ChangeLog
src/gcrypt.h

diff --git a/NEWS b/NEWS
index 8cb7117..e64df61 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -31,6 +31,11 @@ Noteworthy changes in version 1.1.13 (unreleased)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 gcry_pk_decrypt         ENHANCED: Allows flag to return complete S-expression.
 gcry_cipher_reset      NEW
+gcry_md_open            CHANGED
+gcry_md_copy            CHANGED
+gcry_md_is_enabled      NEW
+gcry_md_is_secure       REPLACED macro by a function.
+  ... fixme add other changes ...
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Noteworthy changes in version 1.1.12 (2003-01-20)
index 99bc6ec..2debac8 100644 (file)
@@ -1,5 +1,23 @@
+2003-06-13  Werner Koch  <wk@gnupg.org>
+
+       * md.c (gcry_md_get_algo): Reverted to old API.  This is a
+       convenience function anyway and error checking is not approriate.
+       (gcry_md_is_secure): New.
+       (gcry_md_is_enabled): New.
+
+2003-06-12  Werner Koch  <wk@gnupg.org>
+
+       * cipher.c (gcry_cipher_open): Make sure HANDLE is set to NULL on
+       error.
+
 2003-06-11  Werner Koch  <wk@gnupg.org>
 
+       * md.c (gcry_md_open): Make sure H receives either NULL or an
+       valid handle.
+       (gcry_md_copy): Swapped arguments so that it is more in lione with
+       md_open and most other API fucntions like memcpy (destination
+       comes first).  Make sure HANDLE is set to NULL on error.
+       
        * rijndael.c (do_encrypt): Hack to force correct alignment.  It
        seems not to be not sufficient, though.  We should rework this
        fucntions and remove all these ugly casts.  Let the compiler
index 4221a79..b69e35e 100644 (file)
@@ -512,10 +512,9 @@ cipher_get_blocksize (int id)
 
 
 /****************
- * Open a cipher handle for use with algorithm ALGO, in mode MODE
- * and return the handle.  Return NULL and set the internal error variable
- * if something goes wrong.
- */
+ * Open a cipher handle for use with algorithm ALGO, in mode MODE and
+ * return the handle.  Put NULL into HANDLER and return and error code
+ * if something goes wrong.  */
 
 gpg_error_t
 gcry_cipher_open (gcry_cipher_hd_t *handle,
@@ -627,8 +626,8 @@ gcry_cipher_open (gcry_cipher_hd_t *handle,
          ath_mutex_unlock (&ciphers_registered_lock);
        }
     }
-  else
-    *handle = h;
+
+  *handle = err ? NULL : h;
 
   return gpg_error (err);
 }
index 08bc06d..7e68dec 100644 (file)
@@ -460,7 +460,8 @@ md_open (gcry_md_hd_t *h, int algo, int secure, int hmac)
 /* 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. */
+   gcry_md_enable. H is guaranteed to be a valid handle or NULL on
+   error.  */
 gpg_error_t
 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
 {
@@ -473,9 +474,9 @@ gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
     {
       err = md_open (&hd, algo, (flags & GCRY_MD_FLAG_SECURE),
                     (flags & GCRY_MD_FLAG_HMAC));
-      if (! err)
-       *h = hd;
     }
+
+  *h = err? NULL : hd;
   return gpg_error (err);
 }
 
@@ -635,9 +636,11 @@ md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
 }
 
 gpg_error_t
-gcry_md_copy (gcry_md_hd_t hd, gcry_md_hd_t *handle)
+gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
 {
   gpg_err_code_t err = md_copy (hd, handle);
+  if (err)
+    *handle = NULL;
   return gpg_error (err);
 }
 
@@ -966,16 +969,10 @@ md_get_algo (gcry_md_hd_t a)
   return r ? r->digest->id : 0;
 }
 
-gpg_error_t
-gcry_md_get_algo (gcry_md_hd_t hd, int *id)
+int
+gcry_md_get_algo (gcry_md_hd_t hd)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
-  int algo = md_get_algo (hd);
-  if (! algo)
-    err = GPG_ERR_GENERAL;     /* FIXME?  */
-  else
-    *id = algo;
-  return gpg_error (err);
+  return md_get_algo (hd);
 }
 
 
@@ -1189,3 +1186,27 @@ gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
 
   return gpg_error (err);
 }
+
+
+int
+gcry_md_is_secure (gcry_md_hd_t a) 
+{
+  size_t value;
+
+  if (gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
+    value = 1; /* It seems to be better to assume secure memory on
+                  error. */
+  return value;
+}
+
+
+int
+gcry_md_is_enabled (gcry_md_hd_t a, int algo) 
+{
+  size_t value;
+
+  if (gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
+    value = 0;
+  return value;
+}
+
index ba5325b..82b579c 100644 (file)
@@ -1,3 +1,7 @@
+2003-06-11  Werner Koch  <wk@gnupg.org>
+
+       * gcrypt.texi (Hash Functions): Document possible values of HD.
+
 2003-06-09  Moritz Schulte  <moritz@g10code.com>
 
        * gcrypt.texi (Version Check): Changed description of
index 0184d7e..bd316b4 100644 (file)
@@ -635,13 +635,13 @@ are also supported.
 To use most of these function it is necessary to create a context;  this
 is done using:
 
-@deftypefun gpg_error_t gcry_md_open (gcry_md_hd_t *hd, int @var{algo},
-unsigned int @var{flags})
+@deftypefun gpg_error_t gcry_md_open (gcry_md_hd_t *@var{hd}, int @var{algo}, unsigned int @var{flags})
 
 Create a message digest object for algorithm @var{algo}.  @var{flags}
-may be given as an bitwise OR of constants described below.
-@var{algo} may be given as @code{0} if the algorithms to use are later
-set using @code{gcry_md_enable}.
+may be given as an bitwise OR of constants described below.  @var{algo}
+may be given as @code{0} if the algorithms to use are later set using
+@code{gcry_md_enable}. @var{hd} is guaranteed to either receive a valid
+handle or NULL.
 
 The following algorithms are supported:
 
@@ -720,6 +720,9 @@ If you want CBC message authenentication codes based on a cipher, see
 @end table
 @c begin table of hash flags
 
+You may use the function @code{gcry_md_is_enabled} to later check
+whether an algorithm has been enabled.
+
 @end deftypefun
 @c end function gcry_md_open
 
@@ -773,7 +776,7 @@ might not even be possible if the data is received from a pipe), a
 snapshot of the current hash context can be taken and turned into a new
 context:
 
-@deftypefun gpg_error_t gcry_md_copy (gcry_md_hd_t @var{h}, gcry_md_hd_t *@var{h2})
+@deftypefun gpg_error_t gcry_md_copy (gcry_md_hd_t *@var{h2}, gcry_md_hd_t @var{h})
 
 Create a new digest object as an exact copy of the object described by
 handle @var{h} and store it in @var{h2}.  The context is not reset and
@@ -913,7 +916,7 @@ In some situations it might be hard to remember the algorithm used for
 the ongoing hashing. The following function might be used to get that
 information:
 
-@deftypefun gpg_error_t gcry_md_get_algo (gcry_md_hd_t @var{h}, int *@var{algo})
+@deftypefun int gcry_md_get_algo (gcry_md_hd_t @var{h})
 
 Retrieve the algorithm used with the handle @var{h}. Note, that this
 does not work reliable if more than one algorithm is enabled in @var{h}.
@@ -923,10 +926,18 @@ The following macro might also be useful:
 
 @deftypefun int gcry_md_is_secure (gcry_md_hd_t @var{h})
 
-This macro return true when the digest object @var{h} is allocated in "secure
-memory"; i.e. @var{h} was created with the @code{GCRY_MD_FLAG_SECURE}.
+This function returns true when the digest object @var{h} is allocated
+in "secure memory"; i.e. @var{h} was created with the
+@code{GCRY_MD_FLAG_SECURE}.
 @end deftypefun
 
+@deftypefun int gcry_md_is_enabled (gcry_md_hd_t @var{h}, int @var{algo})
+
+This function returns true when the agorithm @var{algo} has been enabled
+for the digest object @var{h}.
+@end deftypefun
+
+
 
 Tracking bugs related to hashing is often a cumbersome task which
 requires to add a lot of printf statements into the code.  Libgcrypt
index aead129..1a75a03 100644 (file)
@@ -1,3 +1,18 @@
+2003-06-13  Werner Koch  <wk@gnupg.org>
+
+       * gcrypt.h (gcry_md_get_algo): Reverted to old API.  This is a
+       convenience function anyway and error checking is not approriate.
+       (gcry_md_is_enabled): New.
+       (gcry_md_is_secure): Replaed macro by function and reverted to old
+       API.
+
+2003-06-11  Werner Koch  <wk@gnupg.org>
+
+       * gcrypt.h (GCRYERR): Define _GCRY_ERR_SOURCE_DEFAULT instead of
+       GPG_ERR_SOURCE_DEFAULT, so that libgpg-error still works despite
+       the use of the old gcrypt error codes.
+       (gcry_md_copy): Swapped arguments.
+       
 2003-06-09  Moritz Schulte  <moritz@g10code.com>
 
        * Makefile.am: Support for libgpg-error.
index 0ea8455..d2aa6cb 100644 (file)
@@ -24,7 +24,8 @@
 #include <stdarg.h>
 #include <string.h>
 
-#define GPG_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_GCRYPT
+/* This is required for error code compatibility. */
+#define _GCRY_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_GCRYPT
 
 /* Support for libgpg-error.  */
 #ifdef USE_LIBGPG_ERROR
@@ -558,81 +559,81 @@ typedef struct gcry_mpi *GcryMPI _GCRY_GCC_ATTR_DEPRECATED;
 /* This is here for API compatibility.  */
 enum
   {
-    GCRYERR_SUCCESS = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SUCCESS = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_NO_ERROR & 0xFFFF),
-    GCRYERR_GENERAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_GENERAL = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_GENERAL & 0xFFFF),
-    GCRYERR_INV_PK_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_PK_ALGO = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_PUBKEY_ALGO & 0xFFFF),
-    GCRYERR_INV_MD_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_MD_ALGO = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_DIGEST_ALGO & 0xFFFF),
-    GCRYERR_BAD_PUBLIC_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_BAD_PUBLIC_KEY = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_BAD_PUBKEY & 0xFFFF),
-    GCRYERR_BAD_SECRET_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_BAD_SECRET_KEY = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_BAD_SECKEY & 0xFFFF),
-    GCRYERR_BAD_SIGNATURE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_BAD_SIGNATURE = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_BAD_SIGNATURE & 0xFFFF),
-    GCRYERR_INV_CIPHER_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_CIPHER_ALGO = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_CIPHER_ALGO & 0xFFFF),
-    GCRYERR_BAD_MPI = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_BAD_MPI = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_BAD_MPI & 0xFFFF),
-    GCRYERR_WRONG_PK_ALGO = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_WRONG_PK_ALGO = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_WRONG_PUBKEY_ALGO & 0xFFFF),
-    GCRYERR_WEAK_KEY = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_WEAK_KEY = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_WEAK_KEY & 0xFFFF),
-    GCRYERR_INV_KEYLEN = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_KEYLEN = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_KEYLEN & 0xFFFF),
-    GCRYERR_INV_ARG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_ARG = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_ARG & 0xFFFF),
-    GCRYERR_SELFTEST = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SELFTEST = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SELFTEST_FAILED & 0xFFFF),
-    GCRYERR_INV_OP = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_OP = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_OP & 0xFFFF),
 
-    GCRYERR_INTERNAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INTERNAL = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INTERNAL & 0xFFFF),
 
-    GCRYERR_INV_OBJ = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_OBJ = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_OBJ & 0xFFFF),
-    GCRYERR_TOO_SHORT = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_TOO_SHORT = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_TOO_SHORT & 0xFFFF),
-    GCRYERR_TOO_LARGE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_TOO_LARGE = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_TOO_LARGE & 0xFFFF),
-    GCRYERR_NO_OBJ = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_NO_OBJ = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_NO_OBJ & 0xFFFF),
-    GCRYERR_NOT_IMPL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_NOT_IMPL = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_NOT_IMPLEMENTED & 0xFFFF),
-    GCRYERR_CONFLICT = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_CONFLICT = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_CONFLICT & 0xFFFF),
-    GCRYERR_INV_CIPHER_MODE = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_CIPHER_MODE = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_CIPHER_MODE & 0xFFFF),
-    GCRYERR_INV_FLAG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_INV_FLAG = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_INV_FLAG & 0xFFFF),
-    GCRYERR_SEXP_INV_LEN_SPEC = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_INV_LEN_SPEC = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_INV_LEN_SPEC & 0xFFFF),
-    GCRYERR_SEXP_STRING_TOO_LONG = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_STRING_TOO_LONG = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_STRING_TOO_LONG & 0xFFFF),
-    GCRYERR_SEXP_UNMATCHED_PAREN = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_UNMATCHED_PAREN = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_UNMATCHED_PAREN & 0xFFFF),
-    GCRYERR_SEXP_NOT_CANONICAL = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_NOT_CANONICAL = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_NOT_CANONICAL & 0xFFFF),
-    GCRYERR_SEXP_BAD_CHARACTER = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_BAD_CHARACTER = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_BAD_CHARACTER & 0xFFFF),
-    GCRYERR_SEXP_BAD_QUOTATION = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_BAD_QUOTATION = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_BAD_QUOTATION & 0xFFFF),
-    GCRYERR_SEXP_ZERO_PREFIX = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_ZERO_PREFIX = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_ZERO_PREFIX & 0xFFFF),
-    GCRYERR_SEXP_NESTED_DH = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_NESTED_DH = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_NESTED_DH & 0xFFFF),
-    GCRYERR_SEXP_UNMATCHED_DH = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_UNMATCHED_DH = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_UNMATCHED_DH & 0xFFFF),
-    GCRYERR_SEXP_UNEXPECTED_PUNC = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_UNEXPECTED_PUNC = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_UNEXPECTED_PUNC & 0xFFFF),
-    GCRYERR_SEXP_BAD_HEX_CHAR = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_BAD_HEX_CHAR = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_BAD_HEX_CHAR & 0xFFFF),
-    GCRYERR_SEXP_ODD_HEX_NUMBERS = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_ODD_HEX_NUMBERS = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_ODD_HEX_NUMBERS & 0xFFFF),
-    GCRYERR_SEXP_BAD_OCT_CHAR = ((GPG_ERR_SOURCE_DEFAULT & 0xFF) << 24)
+    GCRYERR_SEXP_BAD_OCT_CHAR = ((_GCRY_ERR_SOURCE_DEFAULT & 0xFF) << 24)
                           | (GPG_ERR_SEXP_BAD_OCT_CHAR & 0xFFFF),
 
   };
@@ -1330,7 +1331,7 @@ void gcry_md_close (gcry_md_hd_t hd);
 gpg_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);
+gpg_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
 
 /* Reset the digest object HD to its initial state. */
 void gcry_md_reset (gcry_md_hd_t hd);
@@ -1358,12 +1359,19 @@ 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,
                          size_t *nbytes);
@@ -1400,10 +1408,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 )