Occurences of gnutls_openpgp_key were renamed to gnutls_openpgp_cert,

leaving an API compatibility layer.

diff --git a/NEWS b/NEWS
index 84eedc149c043424ff4ce7f6ee69da64a754965f..bac715f3d6100ada1ef1641399596d3a7fd87d11 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -3,6 +3,28 @@ Copyright (C) 2004, 2005, 2006, 2007 Simon Josefsson
 Copyright (C) 2000, 2001, 2002, 2003, 2004 Nikos Mavroyanopoulos
 See the end for copying conditions.
 
+* Version 2.1.4 (unreleased)
+
+** API and ABI modifications:
+gnutls_openpgp_key_t: RENAMED to gnutls_openpgp_cert_t
+gnutls_openpgp_key_status_t: RENAMEDS gnutls_openpgp_cert_status_t
+gnutls_openpgp_send_key: RENAMED to gnutls_openpgp_send_cert
+gnutls_openpgp_key_init: RENAMED to gnutls_openpgp_cert_init
+gnutls_openpgp_key_import: RENAMED to gnutls_openpgp_cert_import
+gnutls_openpgp_key_export: RENAMED to gnutls_openpgp_cert_export
+gnutls_openpgp_key_check_hostname: RENAMED to gnutls_openpgp_cert_check_hostname
+gnutls_openpgp_key_get_creation_time: RENAMED to gnutls_openpgp_cert_get_creation_time
+gnutls_openpgp_key_get_expiration_time: RENAMED to gnutls_openpgp_cert_get_expiration_time
+gnutls_openpgp_key_get_fingerprint: RENAMED to gnutls_openpgp_cert_get_fingerprint
+gnutls_openpgp_key_get_version: RENAMED to gnutls_openpgp_cert_get_version
+gnutls_openpgp_key_get_pk_algorithm: RENAMED to gnutls_openpgp_cert_get_pk_algorithm
+gnutls_openpgp_key_get_name: RENAMED to gnutls_openpgp_cert_get_name
+gnutls_openpgp_key_deinit: RENAMED to gnutls_openpgp_cert_deinit
+gnutls_openpgp_key_get_id: RENAMED to gnutls_openpgp_cert_get_id
+gnutls_openpgp_key_get_key_usage: RENAMED to gnutls_openpgp_cert_get_key_usage
+gnutls_openpgp_key_verify_ring: RENAMED to gnutls_openpgp_cert_verify_ring
+gnutls_openpgp_key_verify_self: RENAMED to gnutls_openpgp_cert_verify_self
+
 * Version 2.1.3 (released 2007-10-17)
 
 ** TLS authorization support removed.

diff --git a/doc/gnutls.texi b/doc/gnutls.texi
index 0f911024325aa699ac940d5ca6075f3a75532680..5d6c9a4fb01629b9becbe94c41acdec95c8bd37d 100644 (file)
--- a/doc/gnutls.texi
+++ b/doc/gnutls.texi
@@ -1850,7 +1850,7 @@ belong to the actual owner.
 @subsection @acronym{OpenPGP} Keys
 
 In @acronym{GnuTLS} the @acronym{OpenPGP} key structures
-@xcite{RFC2440} are handled using the @code{gnutls_openpgp_key_t} type
+@xcite{RFC2440} are handled using the @code{gnutls_openpgp_cert_t} type
 and the corresponding private keys with the
 @code{gnutls_openpgp_privkey_t} type. All the prototypes for the key
 handling functions can be found at @file{gnutls/openpgp.h}.
@@ -1865,7 +1865,7 @@ GPGME (@url{http://www.gnupg.org/related_software/gpgme/}) is
 recommended.
 
 There is one verification function in @acronym{GnuTLS}, the
-@ref{gnutls_openpgp_key_verify_ring}.
+@ref{gnutls_openpgp_cert_verify_ring}.
 This checks an @acronym{OpenPGP} key against a given set of public keys (keyring) and
 returns the key status. The key verification status is the same as in
 @acronym{X.509} certificates, although the meaning and interpretation are

diff --git a/includes/gnutls/gnutls.h.in b/includes/gnutls/gnutls.h.in
index ff238b36c34881190e8f81d45004b0075f89f0ef..7b765ff114d86dfba3488eabe1b0d2ae366ad456 100644 (file)
--- a/includes/gnutls/gnutls.h.in
+++ b/includes/gnutls/gnutls.h.in
@@ -244,9 +244,11 @@ extern "C"
   } gnutls_certificate_request_t;
 
   typedef enum
-  { GNUTLS_OPENPGP_KEY,
-    GNUTLS_OPENPGP_KEY_FINGERPRINT
-  } gnutls_openpgp_key_status_t;
+  { GNUTLS_OPENPGP_CERT,
+    GNUTLS_OPENPGP_CERT_FINGERPRINT
+  } gnutls_openpgp_cert_status_t;
+#define GNUTLS_OPENPGP_KEY GNUTLS_OPENPGP_CERT
+#define GNUTLS_OPENPGP_KEY_FINGERPRINT GNUTLS_OPENPGP_CERT_FINGERPRINT
 
   typedef enum
   {
@@ -803,8 +805,10 @@ extern "C"
   void gnutls_session_set_ptr (gnutls_session_t session, void *ptr);
   void *gnutls_session_get_ptr (gnutls_session_t session);
 
-  void gnutls_openpgp_send_key (gnutls_session_t session,
-                               gnutls_openpgp_key_status_t status);
+#define gnutls_openpgp_send_key gnutls_openpgp_send_cert
+#define gnutls_openpgp_key_status_t gnutls_openpgp_cert_status_t
+  void gnutls_openpgp_send_cert (gnutls_session_t session,
+                               gnutls_openpgp_cert_status_t status);
 
 /* fingerprint 
  * Actually this function returns the hash of the given data.

diff --git a/includes/gnutls/openpgp.h b/includes/gnutls/openpgp.h
index 4529ec30d4e567318ed5601fdc7821db6d1f230d..15715c649b4d1435e789b12be1d4473ea54e878c 100644 (file)
--- a/includes/gnutls/openpgp.h
+++ b/includes/gnutls/openpgp.h
@@ -40,48 +40,63 @@ extern "C"
 /* gnutls_openpgp_cert_t should be defined in gnutls.h
  */
 
-  typedef enum gnutls_openpgp_key_fmt
+  typedef enum gnutls_openpgp_cert_fmt
   { GNUTLS_OPENPGP_FMT_RAW,
     GNUTLS_OPENPGP_FMT_BASE64
-  } gnutls_openpgp_key_fmt_t;
+  } gnutls_openpgp_cert_fmt_t;
+#define gnutls_openpgp_key_fmt_t gnutls_openpgp_cert_fmt_t
+
+#define gnutls_openpgp_key_init gnutls_openpgp_cert_init
+#define gnutls_openpgp_key_deinit gnutls_openpgp_cert_deinit
+#define gnutls_openpgp_key_import gnutls_openpgp_cert_import
+#define gnutls_openpgp_key_export gnutls_openpgp_cert_export
+#define gnutls_openpgp_key_get_key_usage gnutls_openpgp_cert_get_key_usage
+#define gnutls_openpgp_key_get_fingerprint gnutls_openpgp_cert_get_fingerprint
+#define gnutls_openpgp_key_get_pk_algorithm gnutls_openpgp_cert_get_pk_algorithm
+#define gnutls_openpgp_key_get_name gnutls_openpgp_cert_get_name
+#define gnutls_openpgp_key_get_version gnutls_openpgp_cert_get_version
+#define gnutls_openpgp_key_get_creation_time gnutls_openpgp_cert_get_creation_time
+#define gnutls_openpgp_key_get_expiration_time gnutls_openpgp_cert_get_expiration_time
+#define gnutls_openpgp_key_get_id gnutls_openpgp_cert_get_id
+#define gnutls_openpgp_key_check_hostname gnutls_openpgp_cert_check_hostname
 
   /* initializes the memory for gnutls_openpgp_cert_t struct */
-  int gnutls_openpgp_key_init (gnutls_openpgp_cert_t * key);
+  int gnutls_openpgp_cert_init (gnutls_openpgp_cert_t * key);
   /* frees all memory */
-  void gnutls_openpgp_key_deinit (gnutls_openpgp_cert_t key);
+  void gnutls_openpgp_cert_deinit (gnutls_openpgp_cert_t key);
 
-  int gnutls_openpgp_key_import (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_import (gnutls_openpgp_cert_t key,
                                 const gnutls_datum_t * data,
-                                gnutls_openpgp_key_fmt_t format);
-  int gnutls_openpgp_key_export (gnutls_openpgp_cert_t key,
-                                gnutls_openpgp_key_fmt_t format,
+                                gnutls_openpgp_cert_fmt_t format);
+  int gnutls_openpgp_cert_export (gnutls_openpgp_cert_t key,
+                                gnutls_openpgp_cert_fmt_t format,
                                 void *output_data,
                                 size_t * output_data_size);
 
 /* The key_usage flags are defined in gnutls.h. They are
  * the GNUTLS_KEY_* definitions.
  */
-  int gnutls_openpgp_key_get_key_usage (gnutls_openpgp_cert_t cert,
+  int gnutls_openpgp_cert_get_key_usage (gnutls_openpgp_cert_t cert,
                                        unsigned int *key_usage);
-  int gnutls_openpgp_key_get_fingerprint (gnutls_openpgp_cert_t key, void *fpr,
+  int gnutls_openpgp_cert_get_fingerprint (gnutls_openpgp_cert_t key, void *fpr,
                                          size_t * fprlen);
 
-  int gnutls_openpgp_key_get_name (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_get_name (gnutls_openpgp_cert_t key,
                                   int idx, char *buf, size_t * sizeof_buf);
 
   gnutls_pk_algorithm_t
-  gnutls_openpgp_key_get_pk_algorithm (gnutls_openpgp_cert_t key,
+  gnutls_openpgp_cert_get_pk_algorithm (gnutls_openpgp_cert_t key,
                                       unsigned int *bits);
 
-  int gnutls_openpgp_key_get_version (gnutls_openpgp_cert_t key);
+  int gnutls_openpgp_cert_get_version (gnutls_openpgp_cert_t key);
 
-  time_t gnutls_openpgp_key_get_creation_time (gnutls_openpgp_cert_t key);
-  time_t gnutls_openpgp_key_get_expiration_time (gnutls_openpgp_cert_t key);
+  time_t gnutls_openpgp_cert_get_creation_time (gnutls_openpgp_cert_t key);
+  time_t gnutls_openpgp_cert_get_expiration_time (gnutls_openpgp_cert_t key);
 
-  int gnutls_openpgp_key_get_id (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_get_id (gnutls_openpgp_cert_t key,
                                 unsigned char keyid[8]);
 
-  int gnutls_openpgp_key_check_hostname (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_check_hostname (gnutls_openpgp_cert_t key,
                                         const char *hostname);
 
 /* privkey stuff.
@@ -93,7 +108,7 @@ extern "C"
                                           unsigned int *bits);
   int gnutls_openpgp_privkey_import (gnutls_openpgp_privkey_t key,
                                     const gnutls_datum_t * data,
-                                    gnutls_openpgp_key_fmt_t format,
+                                    gnutls_openpgp_cert_fmt_t format,
                                     const char *pass, unsigned int flags);
   int gnutls_openpgp_privkey_sign_hash (gnutls_openpgp_privkey_t key,
                                        const gnutls_datum_t * hash,
@@ -109,19 +124,19 @@ extern "C"
 
   int gnutls_openpgp_keyring_import (gnutls_openpgp_keyring_t keyring,
                                     const gnutls_datum_t * data,
-                                    gnutls_openpgp_key_fmt_t format);
+                                    gnutls_openpgp_cert_fmt_t format);
 
   int gnutls_openpgp_keyring_check_id (gnutls_openpgp_keyring_t ring,
                                       const unsigned char keyid[8],
                                       unsigned int flags);
 
 
-  int gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_verify_ring (gnutls_openpgp_cert_t key,
                                      gnutls_openpgp_keyring_t keyring,
                                      unsigned int flags, unsigned int *verify
                                      /* the output of the verification */ );
 
-  int gnutls_openpgp_key_verify_self (gnutls_openpgp_cert_t key,
+  int gnutls_openpgp_cert_verify_self (gnutls_openpgp_cert_t key,
                                      unsigned int flags,
                                      unsigned int *verify);
 

diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index 3681a7dca947d6b5d0c263cb708010318ef00254..5084ed5d8d782d490cd8c1b99b1336c7a466593c 100644 (file)
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -481,14 +481,14 @@ cleanup:
     {
       if (st.deinit_all)
        {
-         if (_E_gnutls_openpgp_key_deinit == NULL ||
+         if (_E_gnutls_openpgp_cert_deinit == NULL ||
              _E_gnutls_openpgp_privkey_deinit == NULL)
            {
              gnutls_assert ();
              return GNUTLS_E_INIT_LIBEXTRA;
            }
 
-         _E_gnutls_openpgp_key_deinit (st.cert.pgp);
+         _E_gnutls_openpgp_cert_deinit (st.cert.pgp);
          _E_gnutls_openpgp_privkey_deinit (st.key.pgp);
        }
     }

diff --git a/lib/gnutls_cert.c b/lib/gnutls_cert.c
index c1281a24ab19459ec1395dd06ab4208bc732cc81..21c7340acb9accc7064198ae78c41f0b748f44e3 100644 (file)
--- a/lib/gnutls_cert.c
+++ b/lib/gnutls_cert.c
@@ -719,7 +719,7 @@ _gnutls_raw_privkey_to_gkey (gnutls_privkey * key,
          return GNUTLS_E_INIT_LIBEXTRA;
        }
       return _E_gnutls_openpgp_raw_privkey_to_gkey (key, raw_key,
-                                                   (gnutls_openpgp_key_fmt_t)
+                                                   (gnutls_openpgp_cert_fmt_t)
                                                    key_enc);
     default:
       gnutls_assert ();

diff --git a/lib/gnutls_extra_hooks.c b/lib/gnutls_extra_hooks.c
index 667270f9df20b89c61e2549f8d87b90a2e617ee9..1d6673240d8ef1ea16aeca7c36f49795308ace9d 100644 (file)
--- a/lib/gnutls_extra_hooks.c
+++ b/lib/gnutls_extra_hooks.c
@@ -29,17 +29,17 @@
    _gnutls_add_openpgp_functions(), typically invoked by
    libgnutls_extra. */
 _gnutls_openpgp_verify_key_func _E_gnutls_openpgp_verify_key = NULL;
-_gnutls_openpgp_key_creation_time_func
+_gnutls_openpgp_cert_creation_time_func
 _E_gnutls_openpgp_get_raw_key_creation_time = NULL;
-_gnutls_openpgp_key_expiration_time_func
+_gnutls_openpgp_cert_expiration_time_func
 _E_gnutls_openpgp_get_raw_key_expiration_time = NULL;
 _gnutls_openpgp_fingerprint_func _E_gnutls_openpgp_fingerprint = NULL;
-_gnutls_openpgp_key_request_func _E_gnutls_openpgp_request_key = NULL;
+_gnutls_openpgp_cert_request_func _E_gnutls_openpgp_request_key = NULL;
 _gnutls_openpgp_raw_key_to_gcert_func _E_gnutls_openpgp_raw_key_to_gcert = NULL;
 _gnutls_openpgp_raw_privkey_to_gkey_func _E_gnutls_openpgp_raw_privkey_to_gkey = NULL;
 _gnutls_openpgp_cert_to_gcert_func _E_gnutls_openpgp_cert_to_gcert = NULL;
 _gnutls_openpgp_privkey_to_gkey_func _E_gnutls_openpgp_privkey_to_gkey = NULL;
-_gnutls_openpgp_key_deinit_func _E_gnutls_openpgp_key_deinit = NULL;
+_gnutls_openpgp_cert_deinit_func _E_gnutls_openpgp_cert_deinit = NULL;
 _gnutls_openpgp_keyring_deinit_func _E_gnutls_openpgp_keyring_deinit = NULL;
 _gnutls_openpgp_privkey_deinit_func _E_gnutls_openpgp_privkey_deinit = NULL;
 
@@ -48,15 +48,15 @@ _gnutls_openpgp_privkey_deinit_func _E_gnutls_openpgp_privkey_deinit = NULL;
 extern void
 _gnutls_add_openpgp_functions
 (_gnutls_openpgp_verify_key_func verify_key,
- _gnutls_openpgp_key_creation_time_func key_creation_time,
- _gnutls_openpgp_key_expiration_time_func key_expiration_time,
+ _gnutls_openpgp_cert_creation_time_func key_creation_time,
+ _gnutls_openpgp_cert_expiration_time_func key_expiration_time,
  _gnutls_openpgp_fingerprint_func fingerprint,
- _gnutls_openpgp_key_request_func request_key,
+ _gnutls_openpgp_cert_request_func request_key,
  _gnutls_openpgp_raw_key_to_gcert_func raw_key_to_gcert,
  _gnutls_openpgp_raw_privkey_to_gkey_func raw_privkey_to_gkey,
  _gnutls_openpgp_cert_to_gcert_func key_to_gcert,
  _gnutls_openpgp_privkey_to_gkey_func privkey_to_gkey,
- _gnutls_openpgp_key_deinit_func key_deinit,
+ _gnutls_openpgp_cert_deinit_func key_deinit,
  _gnutls_openpgp_keyring_deinit_func keyring_deinit,
  _gnutls_openpgp_privkey_deinit_func privkey_deinit)
 {
@@ -69,7 +69,7 @@ _gnutls_add_openpgp_functions
   _E_gnutls_openpgp_raw_privkey_to_gkey = raw_privkey_to_gkey;
   _E_gnutls_openpgp_cert_to_gcert = key_to_gcert;
   _E_gnutls_openpgp_privkey_to_gkey = privkey_to_gkey;
-  _E_gnutls_openpgp_key_deinit = key_deinit;
+  _E_gnutls_openpgp_cert_deinit = key_deinit;
   _E_gnutls_openpgp_keyring_deinit = keyring_deinit;
   _E_gnutls_openpgp_privkey_deinit = privkey_deinit;
 

diff --git a/lib/gnutls_extra_hooks.h b/lib/gnutls_extra_hooks.h
index da36addaa1966ed4081a92a8a38affc2dab8c8af..15f4f931fef67aa36ecb589cb265f423d4ed0f8f 100644 (file)
--- a/lib/gnutls_extra_hooks.h
+++ b/lib/gnutls_extra_hooks.h
@@ -33,13 +33,13 @@ typedef int (*_gnutls_openpgp_verify_key_func)
  const gnutls_datum_t *, int,
  unsigned int *);
 
-typedef time_t (*_gnutls_openpgp_key_creation_time_func)
+typedef time_t (*_gnutls_openpgp_cert_creation_time_func)
 (const gnutls_datum_t *);
 
-typedef time_t (*_gnutls_openpgp_key_expiration_time_func)
+typedef time_t (*_gnutls_openpgp_cert_expiration_time_func)
 (const gnutls_datum_t *);
 
-typedef int (*_gnutls_openpgp_key_request_func)
+typedef int (*_gnutls_openpgp_cert_request_func)
 (gnutls_session_t, gnutls_datum_t *,
  const gnutls_certificate_credentials_t,
  opaque *, int);
@@ -54,7 +54,7 @@ typedef int (*_gnutls_openpgp_raw_key_to_gcert_func)
 typedef int (*_gnutls_openpgp_raw_privkey_to_gkey_func)
 (gnutls_privkey *,
  const gnutls_datum_t *,
- gnutls_openpgp_key_fmt_t);
+ gnutls_openpgp_cert_fmt_t);
 
 typedef int (*_gnutls_openpgp_cert_to_gcert_func)
 (gnutls_cert *, gnutls_openpgp_cert_t);
@@ -63,7 +63,7 @@ typedef int (*_gnutls_openpgp_privkey_to_gkey_func)
 (gnutls_privkey *,
  gnutls_openpgp_privkey_t);
 
-typedef void (*_gnutls_openpgp_key_deinit_func)
+typedef void (*_gnutls_openpgp_cert_deinit_func)
 (gnutls_openpgp_cert_t);
 
 typedef void (*_gnutls_openpgp_keyring_deinit_func)
@@ -77,30 +77,30 @@ typedef void (*_gnutls_openpgp_privkey_deinit_func)
    are declared here, because this file is included by auth_cert.c and
    gnutls_cert.c too.  */
 extern _gnutls_openpgp_verify_key_func _E_gnutls_openpgp_verify_key;
-extern _gnutls_openpgp_key_creation_time_func
+extern _gnutls_openpgp_cert_creation_time_func
 _E_gnutls_openpgp_get_raw_key_creation_time;
-extern _gnutls_openpgp_key_expiration_time_func
+extern _gnutls_openpgp_cert_expiration_time_func
 _E_gnutls_openpgp_get_raw_key_expiration_time;
 extern _gnutls_openpgp_fingerprint_func _E_gnutls_openpgp_fingerprint;
-extern _gnutls_openpgp_key_request_func _E_gnutls_openpgp_request_key;
+extern _gnutls_openpgp_cert_request_func _E_gnutls_openpgp_request_key;
 extern _gnutls_openpgp_raw_key_to_gcert_func _E_gnutls_openpgp_raw_key_to_gcert;
 extern _gnutls_openpgp_raw_privkey_to_gkey_func _E_gnutls_openpgp_raw_privkey_to_gkey;
 extern _gnutls_openpgp_cert_to_gcert_func _E_gnutls_openpgp_cert_to_gcert;
 extern _gnutls_openpgp_privkey_to_gkey_func _E_gnutls_openpgp_privkey_to_gkey;
-extern _gnutls_openpgp_key_deinit_func _E_gnutls_openpgp_key_deinit;
+extern _gnutls_openpgp_cert_deinit_func _E_gnutls_openpgp_cert_deinit;
 extern _gnutls_openpgp_keyring_deinit_func _E_gnutls_openpgp_keyring_deinit;
 extern _gnutls_openpgp_privkey_deinit_func _E_gnutls_openpgp_privkey_deinit;
 
 extern void _gnutls_add_openpgp_functions
 (_gnutls_openpgp_verify_key_func verify_key,
- _gnutls_openpgp_key_creation_time_func key_creation_time,
- _gnutls_openpgp_key_expiration_time_func key_expiration_time,
+ _gnutls_openpgp_cert_creation_time_func key_creation_time,
+ _gnutls_openpgp_cert_expiration_time_func key_expiration_time,
  _gnutls_openpgp_fingerprint_func fingerprint,
- _gnutls_openpgp_key_request_func request_key,
+ _gnutls_openpgp_cert_request_func request_key,
  _gnutls_openpgp_raw_key_to_gcert_func raw_key_to_gcert,
  _gnutls_openpgp_raw_privkey_to_gkey_func raw_privkey_to_gkey,
  _gnutls_openpgp_cert_to_gcert_func key_to_gcert,
  _gnutls_openpgp_privkey_to_gkey_func privkey_to_gkey,
- _gnutls_openpgp_key_deinit_func key_deinit,
+ _gnutls_openpgp_cert_deinit_func key_deinit,
  _gnutls_openpgp_keyring_deinit_func keyring_deinit,
  _gnutls_openpgp_privkey_deinit_func privkey_deinit);

diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 9f03aa009bd2e318bad959f6b73b6c23b116e1e1..db4bca712e85d00c400dc0cec95b08a57aff0029 100644 (file)
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -618,9 +618,9 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
 }
 
 /**
-  * gnutls_openpgp_send_key - This function will order gnutls to send the openpgp fingerprint instead of the key
+  * gnutls_openpgp_send_cert - This function will order gnutls to send the openpgp fingerprint instead of the key
   * @session: is a pointer to a #gnutls_session_t structure.
-  * @status: is one of OPENPGP_KEY, or OPENPGP_KEY_FINGERPRINT
+  * @status: is one of GNUTLS_OPENPGP_CERT, or GNUTLS_OPENPGP_CERT_FINGERPRINT
   *
   * This function will order gnutls to send the key fingerprint instead
   * of the key in the initial handshake procedure. This should be used
@@ -629,8 +629,8 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
   *
   **/
 void
-gnutls_openpgp_send_key (gnutls_session_t session,
-                        gnutls_openpgp_key_status_t status)
+gnutls_openpgp_send_cert (gnutls_session_t session,
+                        gnutls_openpgp_cert_status_t status)
 {
   session->internals.pgp_fingerprint = status;
 }

diff --git a/libextra/gnutls_extra.c b/libextra/gnutls_extra.c
index efca9566dfa2e1aa15b7e8df37304ceca6c8342c..fde3388fbc2ffc4abcc44e19a94c1215cfd1877d 100644 (file)
--- a/libextra/gnutls_extra.c
+++ b/libextra/gnutls_extra.c
@@ -152,7 +152,7 @@ gnutls_global_init_extra (void)
                                 _gnutls_openpgp_raw_privkey_to_gkey,
                                 _gnutls_openpgp_cert_to_gcert,
                                 _gnutls_openpgp_privkey_to_gkey,
-                                gnutls_openpgp_key_deinit,
+                                gnutls_openpgp_cert_deinit,
                                 gnutls_openpgp_keyring_deinit,
                                 gnutls_openpgp_privkey_deinit);
 

diff --git a/libextra/gnutls_openpgp.c b/libextra/gnutls_openpgp.c
index 82066586a6785ba01b8528d0c1749fc4b4d65fd5..cc867975da3e6b67217342028b8a203a86ec5667 100644 (file)
--- a/libextra/gnutls_openpgp.c
+++ b/libextra/gnutls_openpgp.c
@@ -307,7 +307,7 @@ openpgp_pk_to_gnutls_cert (gnutls_cert * cert, cdk_pkt_pubkey_t pk)
 int
 _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
                                     const gnutls_datum_t * raw_key,
-                                    gnutls_openpgp_key_fmt_t format)
+                                    gnutls_openpgp_cert_fmt_t format)
 {
   cdk_kbnode_t snode = NULL;
   cdk_packet_t pkt;
@@ -999,7 +999,7 @@ _gnutls_openpgp_cert_to_gcert (gnutls_cert * gcert, gnutls_openpgp_cert_t cert)
   gcert->cert_type = GNUTLS_CRT_OPENPGP;
 
 
-  ret = gnutls_openpgp_key_export (cert, GNUTLS_OPENPGP_FMT_RAW, 
+  ret = gnutls_openpgp_cert_export (cert, GNUTLS_OPENPGP_FMT_RAW, 
                                   NULL, &der_size);
   if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
@@ -1014,7 +1014,7 @@ _gnutls_openpgp_cert_to_gcert (gnutls_cert * gcert, gnutls_openpgp_cert_t cert)
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  ret = gnutls_openpgp_key_export (cert, GNUTLS_OPENPGP_FMT_RAW, 
+  ret = gnutls_openpgp_cert_export (cert, GNUTLS_OPENPGP_FMT_RAW, 
                                   der, &der_size);
   if (ret < 0)
     {

diff --git a/libextra/openpgp/compat.c b/libextra/openpgp/compat.c
index 4cc976d5b45874231ebf153dbdfe369459e81bc6..3f7328c5163e7e3f76fefbf04ea3623e600fcd54 100644 (file)
--- a/libextra/openpgp/compat.c
+++ b/libextra/openpgp/compat.c
@@ -59,14 +59,14 @@ _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t cred,
       return GNUTLS_E_NO_CERTIFICATE_FOUND;
     }
 
-  ret = gnutls_openpgp_key_init (&key);
+  ret = gnutls_openpgp_cert_init (&key);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_openpgp_key_import (key, &cert_list[0], GNUTLS_OPENPGP_FMT_RAW);
+  ret = gnutls_openpgp_cert_import (key, &cert_list[0], GNUTLS_OPENPGP_FMT_RAW);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -75,7 +75,7 @@ _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t cred,
 
   if (cred->keyring != NULL)
     {
-      ret = gnutls_openpgp_key_verify_ring (key, cred->keyring, 0, &verify);
+      ret = gnutls_openpgp_cert_verify_ring (key, cred->keyring, 0, &verify);
       if (ret < 0)
        {
          gnutls_assert ();
@@ -84,7 +84,7 @@ _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t cred,
     }
 
   /* Now try the self signature. */
-  ret = gnutls_openpgp_key_verify_self (key, 0, &verify_self);
+  ret = gnutls_openpgp_cert_verify_self (key, 0, &verify_self);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -100,7 +100,7 @@ _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t cred,
   ret = 0;
 
 leave:
-  gnutls_openpgp_key_deinit (key);
+  gnutls_openpgp_cert_deinit (key);
 
   return ret;
 }
@@ -121,22 +121,22 @@ _gnutls_openpgp_fingerprint (const gnutls_datum_t * cert,
   gnutls_openpgp_cert_t key;
   int ret;
 
-  ret = gnutls_openpgp_key_init (&key);
+  ret = gnutls_openpgp_cert_init (&key);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_openpgp_key_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
+  ret = gnutls_openpgp_cert_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_openpgp_key_get_fingerprint (key, fpr, fprlen);
-  gnutls_openpgp_key_deinit (key);
+  ret = gnutls_openpgp_cert_get_fingerprint (key, fpr, fprlen);
+  gnutls_openpgp_cert_deinit (key);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -159,23 +159,23 @@ _gnutls_openpgp_get_raw_key_creation_time (const gnutls_datum_t * cert)
   int ret;
   time_t tim;
 
-  ret = gnutls_openpgp_key_init (&key);
+  ret = gnutls_openpgp_cert_init (&key);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_openpgp_key_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
+  ret = gnutls_openpgp_cert_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  tim = gnutls_openpgp_key_get_creation_time (key);
+  tim = gnutls_openpgp_cert_get_creation_time (key);
 
-  gnutls_openpgp_key_deinit (key);
+  gnutls_openpgp_cert_deinit (key);
 
   return tim;
 }
@@ -195,23 +195,23 @@ _gnutls_openpgp_get_raw_key_expiration_time (const gnutls_datum_t * cert)
   int ret;
   time_t tim;
 
-  ret = gnutls_openpgp_key_init (&key);
+  ret = gnutls_openpgp_cert_init (&key);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_openpgp_key_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
+  ret = gnutls_openpgp_cert_import (key, cert, GNUTLS_OPENPGP_FMT_RAW);
   if (ret < 0)
     {
       gnutls_assert ();
       return ret;
     }
 
-  tim = gnutls_openpgp_key_get_expiration_time (key);
+  tim = gnutls_openpgp_cert_get_expiration_time (key);
 
-  gnutls_openpgp_key_deinit (key);
+  gnutls_openpgp_cert_deinit (key);
 
   return tim;
 }

diff --git a/libextra/openpgp/extras.c b/libextra/openpgp/extras.c
index adf534eb320d95f827c9013fda10f883bcf6dac1..db3355530fe87af18a5ed47a91c6a4480461045e 100644 (file)
--- a/libextra/openpgp/extras.c
+++ b/libextra/openpgp/extras.c
@@ -134,7 +134,7 @@ gnutls_openpgp_keyring_check_id (gnutls_openpgp_keyring_t ring,
 int
 gnutls_openpgp_keyring_import (gnutls_openpgp_keyring_t keyring,
                               const gnutls_datum_t *data,
-                              gnutls_openpgp_key_fmt_t format)
+                              gnutls_openpgp_cert_fmt_t format)
 {
   cdk_error_t err;
   cdk_stream_t input;

diff --git a/libextra/openpgp/gnutls_openpgp.h b/libextra/openpgp/gnutls_openpgp.h
index 8d07de304e966494586c96ace368f0f9640185bf..79d81c698476a2ea105e24bbc9da766a682ba0d1 100644 (file)
--- a/libextra/openpgp/gnutls_openpgp.h
+++ b/libextra/openpgp/gnutls_openpgp.h
@@ -66,7 +66,7 @@ int _gnutls_openpgp_raw_key_to_gcert (gnutls_cert * cert,
 int
 _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
                                     const gnutls_datum_t * raw_key,
-                                    gnutls_openpgp_key_fmt_t format);
+                                    gnutls_openpgp_cert_fmt_t format);
 
 int
 _gnutls_openpgp_request_key (gnutls_session_t,

diff --git a/libextra/openpgp/openpgp.h b/libextra/openpgp/openpgp.h
index c6177c2675bb9dbd20e87ade4fb4dd254b813961..5d1bdde7772dd467982ad633e55233fbb92413a8 100644 (file)
--- a/libextra/openpgp/openpgp.h
+++ b/libextra/openpgp/openpgp.h
@@ -6,11 +6,11 @@
 #endif
 
 /* The format the OpenPGP key is stored in. */
-typedef enum gnutls_openpgp_key_fmt_t
+typedef enum gnutls_openpgp_cert_fmt_t
 {
   GNUTLS_OPENPGP_FMT_RAW, 
   GNUTLS_OPENPGP_FMT_BASE64
-} gnutls_openpgp_key_fmt_t;
+} gnutls_openpgp_cert_fmt_t;
 
 #ifdef ENABLE_OPENPGP
 
@@ -40,42 +40,42 @@ typedef struct gnutls_openpgp_keyring_int
 typedef struct gnutls_openpgp_keyring_int *gnutls_openpgp_keyring_t;
 
 int _gnutls_map_cdk_rc (int rc);
-int gnutls_openpgp_key_get_name (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_get_name (gnutls_openpgp_cert_t key,
                                 int idx, char *buf, size_t * sizeof_buf);
-int gnutls_openpgp_key_get_fingerprint (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_get_fingerprint (gnutls_openpgp_cert_t key,
                                        void *fpr, size_t * fprlen);
 gnutls_pk_algorithm_t
-gnutls_openpgp_key_get_pk_algorithm (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_get_pk_algorithm (gnutls_openpgp_cert_t key,
                                     unsigned int *bits);
-int gnutls_openpgp_key_get_version (gnutls_openpgp_cert_t key);
-time_t gnutls_openpgp_key_get_creation_time (gnutls_openpgp_cert_t key);
-time_t gnutls_openpgp_key_get_expiration_time (gnutls_openpgp_cert_t key);
-int gnutls_openpgp_key_get_id (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_get_version (gnutls_openpgp_cert_t key);
+time_t gnutls_openpgp_cert_get_creation_time (gnutls_openpgp_cert_t key);
+time_t gnutls_openpgp_cert_get_expiration_time (gnutls_openpgp_cert_t key);
+int gnutls_openpgp_cert_get_id (gnutls_openpgp_cert_t key,
                               unsigned char keyid[8]);
 
-int gnutls_openpgp_key_init (gnutls_openpgp_cert_t * key);
-void gnutls_openpgp_key_deinit (gnutls_openpgp_cert_t key);
-int gnutls_openpgp_key_import (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_init (gnutls_openpgp_cert_t * key);
+void gnutls_openpgp_cert_deinit (gnutls_openpgp_cert_t key);
+int gnutls_openpgp_cert_import (gnutls_openpgp_cert_t key,
                               const gnutls_datum_t * data,
-                              gnutls_openpgp_key_fmt_t format);
-int gnutls_openpgp_key_export (gnutls_openpgp_cert_t key,
-                              gnutls_openpgp_key_fmt_t format,
+                              gnutls_openpgp_cert_fmt_t format);
+int gnutls_openpgp_cert_export (gnutls_openpgp_cert_t key,
+                              gnutls_openpgp_cert_fmt_t format,
                               void *output_data, size_t * output_data_size);
 
 void gnutls_openpgp_keyring_deinit (gnutls_openpgp_keyring_t keyring);
 int gnutls_openpgp_keyring_init (gnutls_openpgp_keyring_t * keyring);
 int gnutls_openpgp_keyring_import (gnutls_openpgp_keyring_t keyring,
                                   const gnutls_datum_t * data,
-                                  gnutls_openpgp_key_fmt_t format);
+                                  gnutls_openpgp_cert_fmt_t format);
 int gnutls_openpgp_keyring_check_id (gnutls_openpgp_keyring_t ring,
                                     const unsigned char keyid[8],
                                     unsigned int flags);
 
-int gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_verify_ring (gnutls_openpgp_cert_t key,
                                    gnutls_openpgp_keyring_t keyring,
                                    unsigned int flags, unsigned int *verify);
 
-int gnutls_openpgp_key_verify_self (gnutls_openpgp_cert_t key,
+int gnutls_openpgp_cert_verify_self (gnutls_openpgp_cert_t key,
                                    unsigned int flags, unsigned int *verify);
 
 int _gnutls_openpgp_cert_to_gcert (gnutls_cert * gcert,

diff --git a/libextra/openpgp/pgp.c b/libextra/openpgp/pgp.c
index 15c4f5a1f4830bea486ff261da636c73339a84cb..ae0f42f92b57247be740640ddd59e9add0bf1148 100644 (file)
--- a/libextra/openpgp/pgp.c
+++ b/libextra/openpgp/pgp.c
@@ -34,7 +34,7 @@
 
 
 /**
- * gnutls_openpgp_key_init - This function initializes a gnutls_openpgp_cert_t structure
+ * gnutls_openpgp_cert_init - This function initializes a gnutls_openpgp_cert_t structure
  * @key: The structure to be initialized
  *
  * This function will initialize an OpenPGP key structure. 
@@ -43,7 +43,7 @@
  *
  **/
 int
-gnutls_openpgp_key_init (gnutls_openpgp_cert_t * key)
+gnutls_openpgp_cert_init (gnutls_openpgp_cert_t * key)
 {
   *key = gnutls_calloc (1, sizeof (gnutls_openpgp_cert_int));
 
@@ -53,13 +53,13 @@ gnutls_openpgp_key_init (gnutls_openpgp_cert_t * key)
 }
 
 /**
- * gnutls_openpgp_key_deinit - This function deinitializes memory used by a gnutls_openpgp_cert_t structure
+ * gnutls_openpgp_cert_deinit - This function deinitializes memory used by a gnutls_openpgp_cert_t structure
  * @key: The structure to be initialized
  *
  * This function will deinitialize a key structure. 
  **/
 void
-gnutls_openpgp_key_deinit (gnutls_openpgp_cert_t key)
+gnutls_openpgp_cert_deinit (gnutls_openpgp_cert_t key)
 {
   if (!key)
     return;
@@ -74,10 +74,10 @@ gnutls_openpgp_key_deinit (gnutls_openpgp_cert_t key)
 }
 
 /**
-  * gnutls_openpgp_key_import - This function will import a RAW or BASE64 encoded key
+  * gnutls_openpgp_cert_import - This function will import a RAW or BASE64 encoded key
   * @key: The structure to store the parsed key.
   * @data: The RAW or BASE64 encoded key.
-  * @format: One of gnutls_openpgp_key_fmt_t elements.
+  * @format: One of gnutls_openpgp_cert_fmt_t elements.
   *
   * This function will convert the given RAW or Base64 encoded key
   * to the native gnutls_openpgp_cert_t format. The output will be stored in 'key'.
@@ -85,9 +85,9 @@ gnutls_openpgp_key_deinit (gnutls_openpgp_cert_t key)
   * Returns 0 on success.
   **/
 int
-gnutls_openpgp_key_import (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_import (gnutls_openpgp_cert_t key,
                           const gnutls_datum_t * data,
-                          gnutls_openpgp_key_fmt_t format)
+                          gnutls_openpgp_cert_fmt_t format)
 {
   cdk_stream_t inp;  
   int rc;
@@ -120,9 +120,9 @@ gnutls_openpgp_key_import (gnutls_openpgp_cert_t key,
 }
 
 /**
-  * gnutls_openpgp_key_export - This function will export a RAW or BASE64 encoded key
+  * gnutls_openpgp_cert_export - This function will export a RAW or BASE64 encoded key
   * @key: Holds the key.
-  * @format: One of gnutls_openpgp_key_fmt_t elements.
+  * @format: One of gnutls_openpgp_cert_fmt_t elements.
   * @output_data: will contain the key base64 encoded or raw
   * @output_data_size: holds the size of output_data (and will be replaced by the actual size of parameters)
   *
@@ -134,8 +134,8 @@ gnutls_openpgp_key_import (gnutls_openpgp_cert_t key,
   *
   **/
 int
-gnutls_openpgp_key_export (gnutls_openpgp_cert_t key,
-                          gnutls_openpgp_key_fmt_t format,
+gnutls_openpgp_cert_export (gnutls_openpgp_cert_t key,
+                          gnutls_openpgp_cert_fmt_t format,
                           void *output_data, size_t * output_data_size)
 {
   size_t input_data_size = *output_data_size;
@@ -185,7 +185,7 @@ gnutls_openpgp_key_export (gnutls_openpgp_cert_t key,
 
 
 /**
- * gnutls_openpgp_key_get_fingerprint - Gets the fingerprint
+ * gnutls_openpgp_cert_get_fingerprint - Gets the fingerprint
  * @key: the raw data that contains the OpenPGP public key.
  * @fpr: the buffer to save the fingerprint, must hold at least 20 bytes.
  * @fprlen: the integer to save the length of the fingerprint.
@@ -194,7 +194,7 @@ gnutls_openpgp_key_export (gnutls_openpgp_cert_t key,
  * the fingerprint can be 16 or 20 bytes.
  **/
 int
-gnutls_openpgp_key_get_fingerprint (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_get_fingerprint (gnutls_openpgp_cert_t key,
                                    void *fpr, size_t * fprlen)
 {
   cdk_packet_t pkt;
@@ -250,7 +250,7 @@ _gnutls_openpgp_count_key_names (gnutls_openpgp_cert_t key)
 
 
 /**
- * gnutls_openpgp_key_get_name - Extracts the userID
+ * gnutls_openpgp_cert_get_name - Extracts the userID
  * @key: the structure that contains the OpenPGP public key.
  * @idx: the index of the ID to extract
  * @buf: a pointer to a structure to hold the name
@@ -264,7 +264,7 @@ _gnutls_openpgp_count_key_names (gnutls_openpgp_cert_t key)
  *
  **/
 int
-gnutls_openpgp_key_get_name (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_get_name (gnutls_openpgp_cert_t key,
                             int idx, char *buf, size_t * sizeof_buf)
 {
   cdk_kbnode_t ctx = NULL, p;
@@ -319,7 +319,7 @@ gnutls_openpgp_key_get_name (gnutls_openpgp_cert_t key,
 }
 
 /**
-  * gnutls_openpgp_key_get_pk_algorithm - This function returns the key's PublicKey algorithm
+  * gnutls_openpgp_cert_get_pk_algorithm - This function returns the key's PublicKey algorithm
   * @key: is an OpenPGP key
   * @bits: if bits is non null it will hold the size of the parameters' in bits
   *
@@ -335,7 +335,7 @@ gnutls_openpgp_key_get_name (gnutls_openpgp_cert_t key,
   *
   **/
 gnutls_pk_algorithm_t
-gnutls_openpgp_key_get_pk_algorithm (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_get_pk_algorithm (gnutls_openpgp_cert_t key,
                                     unsigned int *bits)
 {
   cdk_packet_t pkt;
@@ -364,13 +364,13 @@ gnutls_openpgp_key_get_pk_algorithm (gnutls_openpgp_cert_t key,
 
 
 /**
- * gnutls_openpgp_key_get_version - Extracts the version of the key.
+ * gnutls_openpgp_cert_get_version - Extracts the version of the key.
  * @key: the structure that contains the OpenPGP public key.
  *
  * Extract the version of the OpenPGP key.
  **/
 int
-gnutls_openpgp_key_get_version (gnutls_openpgp_cert_t key)
+gnutls_openpgp_cert_get_version (gnutls_openpgp_cert_t key)
 {
   cdk_packet_t pkt;
   int version;
@@ -389,13 +389,13 @@ gnutls_openpgp_key_get_version (gnutls_openpgp_cert_t key)
 
 
 /**
- * gnutls_openpgp_key_get_creation_time - Extract the timestamp
+ * gnutls_openpgp_cert_get_creation_time - Extract the timestamp
  * @key: the structure that contains the OpenPGP public key.
  *
  * Returns the timestamp when the OpenPGP key was created.
  **/
 time_t
-gnutls_openpgp_key_get_creation_time (gnutls_openpgp_cert_t key)
+gnutls_openpgp_cert_get_creation_time (gnutls_openpgp_cert_t key)
 {
   cdk_packet_t pkt;
   time_t timestamp;
@@ -414,14 +414,14 @@ gnutls_openpgp_key_get_creation_time (gnutls_openpgp_cert_t key)
 
 
 /**
- * gnutls_openpgp_key_get_expiration_time - Extract the expire date
+ * gnutls_openpgp_cert_get_expiration_time - Extract the expire date
  * @key: the structure that contains the OpenPGP public key.
  *
  * Returns the time when the OpenPGP key expires. A value of '0' means
  * that the key doesn't expire at all.
  **/
 time_t
-gnutls_openpgp_key_get_expiration_time (gnutls_openpgp_cert_t key)
+gnutls_openpgp_cert_get_expiration_time (gnutls_openpgp_cert_t key)
 {
   cdk_packet_t pkt;
   time_t expiredate;
@@ -439,14 +439,14 @@ gnutls_openpgp_key_get_expiration_time (gnutls_openpgp_cert_t key)
 }
 
 /**
- * gnutls_openpgp_key_get_id - Gets the keyID
+ * gnutls_openpgp_cert_get_id - Gets the keyID
  * @key: the structure that contains the OpenPGP public key.
  * @keyid: the buffer to save the keyid.
  *
  * Returns the 64-bit keyID of the OpenPGP key.
  **/
 int
-gnutls_openpgp_key_get_id (gnutls_openpgp_cert_t key, unsigned char keyid[8])
+gnutls_openpgp_cert_get_id (gnutls_openpgp_cert_t key, unsigned char keyid[8])
 {
   cdk_packet_t pkt;
   uint32_t kid[2];
@@ -475,7 +475,7 @@ gnutls_openpgp_key_get_id (gnutls_openpgp_cert_t key, unsigned char keyid[8])
 }
 
 /**
-  * gnutls_openpgp_key_check_hostname - This function compares the given hostname with the hostname in the key
+  * gnutls_openpgp_cert_check_hostname - This function compares the given hostname with the hostname in the key
   * @key: should contain an gnutls_openpgp_cert_t structure
   * @hostname: A null terminated string that contains a DNS name
   *
@@ -487,7 +487,7 @@ gnutls_openpgp_key_get_id (gnutls_openpgp_cert_t key, unsigned char keyid[8])
   *
   **/
 int
-gnutls_openpgp_key_check_hostname (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_check_hostname (gnutls_openpgp_cert_t key,
                                   const char *hostname)
 {
   char dnsname[MAX_CN];
@@ -499,7 +499,7 @@ gnutls_openpgp_key_check_hostname (gnutls_openpgp_cert_t key,
   for (i = 0; !(ret < 0); i++)
     {
       dnsnamesize = sizeof (dnsname);
-      ret = gnutls_openpgp_key_get_name (key, i, dnsname, &dnsnamesize);
+      ret = gnutls_openpgp_cert_get_name (key, i, dnsname, &dnsnamesize);
       /* FIXME: ret is not used */
       if (_gnutls_hostname_compare (dnsname, hostname))
        return 1;
@@ -510,7 +510,7 @@ gnutls_openpgp_key_check_hostname (gnutls_openpgp_cert_t key,
 }
 
 /**
- * gnutls_openpgp_key_get_key_usage - This function returns the key's usage
+ * gnutls_openpgp_cert_get_key_usage - This function returns the key's usage
  * @key: should contain a gnutls_openpgp_cert_t structure
  * @key_usage: where the key usage bits will be stored
  *
@@ -522,7 +522,7 @@ gnutls_openpgp_key_check_hostname (gnutls_openpgp_cert_t key,
  *
  */
 int
-gnutls_openpgp_key_get_key_usage (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_get_key_usage (gnutls_openpgp_cert_t key,
                                  unsigned int *key_usage)
 {
   cdk_packet_t pkt;

diff --git a/libextra/openpgp/pgpverify.c b/libextra/openpgp/pgpverify.c
index c1150d1a46f7e6f9aeb55dbd80307933940aea59..ba489475444e53629483420431429da4e050dfc4 100644 (file)
--- a/libextra/openpgp/pgpverify.c
+++ b/libextra/openpgp/pgpverify.c
@@ -34,7 +34,7 @@
 
 
 /**
- * gnutls_openpgp_key_verify_ring - Verify all signatures in the key
+ * gnutls_openpgp_cert_verify_ring - Verify all signatures in the key
  * @key: the structure that holds the key.
  * @keyring: holds the keyring to check against
  * @flags: unused (should be 0)
@@ -56,7 +56,7 @@
  * Returns 0 on success.
  **/
 int
-gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_verify_ring (gnutls_openpgp_cert_t key,
                                gnutls_openpgp_keyring_t keyring,
                                unsigned int flags, unsigned int *verify)
 {
@@ -98,7 +98,7 @@ gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
   /* Check if the key is included in the ring. */
   if (!(flags & GNUTLS_VERIFY_DO_NOT_ALLOW_SAME))
     {
-      rc = gnutls_openpgp_key_get_id (key, id);
+      rc = gnutls_openpgp_cert_get_id (key, id);
       if (rc < 0)
        {
          gnutls_assert ();
@@ -116,7 +116,7 @@ gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
 
 
 /**
- * gnutls_openpgp_key_verify_self - Verify the self signature on the key
+ * gnutls_openpgp_cert_verify_self - Verify the self signature on the key
  * @key: the structure that holds the key.
  * @flags: unused (should be 0)
  * @verify: will hold the key verification output.
@@ -130,7 +130,7 @@ gnutls_openpgp_key_verify_ring (gnutls_openpgp_cert_t key,
  * Returns 0 on success.
  **/
 int
-gnutls_openpgp_key_verify_self (gnutls_openpgp_cert_t key,
+gnutls_openpgp_cert_verify_self (gnutls_openpgp_cert_t key,
                                unsigned int flags, unsigned int *verify)
 {
   int status;

diff --git a/libextra/openpgp/privkey.c b/libextra/openpgp/privkey.c
index 4865e0557a8b673e7355b066b978c1f6dd7a7edd..632d2a42f561a0157ef965bc80052cbb02597858 100644 (file)
--- a/libextra/openpgp/privkey.c
+++ b/libextra/openpgp/privkey.c
@@ -74,7 +74,7 @@ gnutls_openpgp_privkey_deinit (gnutls_openpgp_privkey_t key)
  * gnutls_openpgp_privkey_import - This function will import a RAW or BASE64 encoded key
  * @key: The structure to store the parsed key.
  * @data: The RAW or BASE64 encoded key.
- * @format: One of gnutls_openpgp_key_fmt_t elements.
+ * @format: One of gnutls_openpgp_cert_fmt_t elements.
  * @pass: Unused for now
  * @flags: should be zero
  *
@@ -87,7 +87,7 @@ gnutls_openpgp_privkey_deinit (gnutls_openpgp_privkey_t key)
 int
 gnutls_openpgp_privkey_import (gnutls_openpgp_privkey_t key,
                               const gnutls_datum_t * data,
-                              gnutls_openpgp_key_fmt_t format,
+                              gnutls_openpgp_cert_fmt_t format,
                               const char *pass, unsigned int flags)
 {
   int rc;

diff --git a/src/common.c b/src/common.c
index 961c229374c39b259177dfe38b98dacdf292d842..37da0d40760d43d4334865e7b14b96cf9cd9a289 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -291,7 +291,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
   const char *cstr;
   char name[256];
   size_t name_len = sizeof (name);
-  gnutls_openpgp_key_t crt;
+  gnutls_openpgp_cert_t crt;
   const gnutls_datum_t *cert_list;
   int cert_list_size = 0;
   time_t expiret;
@@ -303,9 +303,9 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
     {
       unsigned int algo, bits;
 
-      gnutls_openpgp_key_init (&crt);
+      gnutls_openpgp_cert_init (&crt);
       ret =
-       gnutls_openpgp_key_import (crt, &cert_list[0],
+       gnutls_openpgp_cert_import (crt, &cert_list[0],
                                   GNUTLS_OPENPGP_FMT_RAW);
       if (ret < 0)
        {
@@ -320,7 +320,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
          size = sizeof (buffer);
 
          ret =
-           gnutls_openpgp_key_export (crt,
+           gnutls_openpgp_cert_export (crt,
                                       GNUTLS_OPENPGP_FMT_BASE64,
                                       buffer, &size);
          if (ret < 0)
@@ -338,7 +338,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
                                 * if it matches the name of the host we
                                 * connected to.
                                 */
-         if (gnutls_openpgp_key_check_hostname (crt, hostname) == 0)
+         if (gnutls_openpgp_cert_check_hostname (crt, hostname) == 0)
            {
              printf
                (" # The hostname in the key does NOT match '%s'.\n",
@@ -350,8 +350,8 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
            }
        }
 
-      activet = gnutls_openpgp_key_get_creation_time (crt);
-      expiret = gnutls_openpgp_key_get_expiration_time (crt);
+      activet = gnutls_openpgp_cert_get_creation_time (crt);
+      expiret = gnutls_openpgp_cert_get_expiration_time (crt);
 
       printf (" # Key was created at: %s", my_ctime (&activet));
       printf (" # Key expires: ");
@@ -360,7 +360,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
       else
        printf ("Never\n");
 
-      if (gnutls_openpgp_key_get_fingerprint (crt, digest, &digest_size) >= 0)
+      if (gnutls_openpgp_cert_get_fingerprint (crt, digest, &digest_size) >= 0)
        {
          print = raw_to_string (digest, digest_size);
 
@@ -368,7 +368,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
                  gnutls_openpgp_key_get_version (crt));
 
          bits = 0;
-         algo = gnutls_openpgp_key_get_pk_algorithm (crt, &bits);
+         algo = gnutls_openpgp_cert_get_pk_algorithm (crt, &bits);
 
          printf (" # PGP Key public key algorithm: ");
          cstr = SU (gnutls_pk_algorithm_get_name (algo));
@@ -378,7 +378,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
            printf (" # PGP Key fingerprint: %s\n", print);
 
          name_len = sizeof (name);
-         if (gnutls_openpgp_key_get_name (crt, 0, name, &name_len) < 0)
+         if (gnutls_openpgp_cert_get_name (crt, 0, name, &name_len) < 0)
            {
              fprintf (stderr, "Could not extract name\n");
            }
@@ -389,7 +389,7 @@ print_openpgp_info (gnutls_session_t session, const char *hostname)
 
        }
 
-      gnutls_openpgp_key_deinit (crt);
+      gnutls_openpgp_cert_deinit (crt);
 
     }
 }