glib2 1.1.4-x86-mingw32 → 1.1.5-x86-mingw32

data/vendor/local/include/gnutls/gnutlsxx.h

@@ -0,0 +1,388 @@
+#ifndef GNUTLSXX_H
+# define GNUTLSXX_H
+
+#include <exception>
+#include <vector>
+#include <gnutls/gnutls.h>
+
+namespace gnutls {
+
+class noncopyable
+{
+    protected:
+        noncopyable() { }
+        ~noncopyable() { }
+
+    private:
+        // These are non-implemented.
+        noncopyable(const noncopyable &);
+	noncopyable &operator=(const noncopyable &);
+};
+
+
+class exception: public std::exception
+{
+    public:
+        exception( int x);
+        const char* what() const throw();
+        int get_code();
+    protected:
+        int retcode;
+};
+
+
+class dh_params : private noncopyable
+{
+    public:
+        dh_params();
+        ~dh_params();
+        void import_raw( const gnutls_datum_t & prime,
+                     const gnutls_datum_t & generator);
+        void import_pkcs3( const gnutls_datum_t & pkcs3_params,
+                           gnutls_x509_crt_fmt_t format);
+        void generate( unsigned int bits);
+
+        void export_pkcs3( gnutls_x509_crt_fmt_t format, unsigned char *params_data, size_t * params_data_size);
+        void export_raw( gnutls_datum_t& prime, gnutls_datum_t &generator);
+
+        gnutls_dh_params_t get_params_t() const;
+        dh_params & operator=(const dh_params& src);
+    protected:
+        gnutls_dh_params_t params;
+};
+
+
+class rsa_params : private noncopyable
+{
+    public:
+        rsa_params();
+        ~rsa_params();
+        void import_raw( const gnutls_datum_t & m,
+                     const gnutls_datum_t & e,
+                     const gnutls_datum_t & d,
+                     const gnutls_datum_t & p,
+                     const gnutls_datum_t & q,
+                     const gnutls_datum_t & u);
+        void import_pkcs1( const gnutls_datum_t & pkcs1_params,
+                           gnutls_x509_crt_fmt_t format);
+        void generate( unsigned int bits);
+
+        void export_pkcs1( gnutls_x509_crt_fmt_t format, unsigned char *params_data, size_t * params_data_size);
+        void export_raw(  gnutls_datum_t & m, gnutls_datum_t & e,
+                      gnutls_datum_t & d, gnutls_datum_t & p,
+                      gnutls_datum_t & q, gnutls_datum_t & u);
+        gnutls_rsa_params_t get_params_t() const;
+        rsa_params & operator=(const rsa_params& src);
+
+    protected:
+        gnutls_rsa_params_t params;
+};
+
+class session : private noncopyable
+{
+    protected:
+        gnutls_session_t s;
+    public:
+        session( gnutls_connection_end_t);
+        virtual ~session();
+
+        int bye( gnutls_close_request_t how);
+        int handshake ();
+
+        gnutls_alert_description_t get_alert() const;
+
+        int send_alert ( gnutls_alert_level_t level,
+                         gnutls_alert_description_t desc);
+        int send_appropriate_alert (int err);
+
+        gnutls_cipher_algorithm_t get_cipher() const;
+        gnutls_kx_algorithm_t get_kx () const;
+        gnutls_mac_algorithm_t get_mac () const;
+        gnutls_compression_method_t get_compression () const;
+        gnutls_certificate_type_t get_certificate_type() const;
+
+        // for the handshake
+        void set_private_extensions ( bool allow);
+
+        gnutls_handshake_description_t get_handshake_last_out() const;
+        gnutls_handshake_description_t get_handshake_last_in() const;
+
+        ssize_t send (const void *data, size_t sizeofdata);
+        ssize_t recv (void *data, size_t sizeofdata);
+
+        bool get_record_direction() const;
+
+        // maximum packet size
+        size_t get_max_size() const;
+        void set_max_size(size_t size);
+
+        size_t check_pending() const;
+
+        void prf (size_t label_size, const char *label,
+                        int server_random_first,
+                        size_t extra_size, const char *extra,
+                        size_t outsize, char *out);
+
+        void prf_raw ( size_t label_size, const char *label,
+                      size_t seed_size, const char *seed,
+                      size_t outsize, char *out);
+
+        void set_cipher_priority (const int *list);
+        void set_mac_priority (const int *list);
+        void set_compression_priority (const int *list);
+        void set_kx_priority (const int *list);
+        void set_protocol_priority (const int *list);
+        void set_certificate_type_priority (const int *list);
+
+	/* if you just want some defaults, use the following.
+	 */
+        void set_priority (const char* prio, const char** err_pos);
+        void set_priority (gnutls_priority_t p);
+
+        gnutls_protocol_t get_protocol_version() const;
+
+        // for resuming sessions
+        void set_data ( const void *session_data,
+                        size_t session_data_size);
+        void get_data (void *session_data,
+                       size_t * session_data_size) const;
+        void get_data(gnutls_session_t session,
+                      gnutls_datum_t & data) const;
+        void get_id ( void *session_id,
+                      size_t * session_id_size) const;
+
+        bool is_resumed () const;
+
+        void set_max_handshake_packet_length ( size_t max);
+
+        void clear_credentials();
+        void set_credentials( class credentials & cred);
+
+        void set_transport_ptr( gnutls_transport_ptr_t ptr);
+        void set_transport_ptr( gnutls_transport_ptr_t recv_ptr, gnutls_transport_ptr_t send_ptr);
+        gnutls_transport_ptr_t get_transport_ptr() const;
+        void get_transport_ptr(gnutls_transport_ptr_t & recv_ptr,
+                               gnutls_transport_ptr_t & send_ptr) const;
+
+        void set_transport_lowat (size_t num);
+        void set_transport_push_function( gnutls_push_func push_func);
+        void set_transport_pull_function( gnutls_pull_func pull_func);
+        
+        void set_user_ptr( void* ptr);
+        void *get_user_ptr() const;
+        
+        void send_openpgp_cert( gnutls_openpgp_crt_status_t status);
+
+        gnutls_credentials_type_t get_auth_type() const;
+        gnutls_credentials_type_t get_server_auth_type() const;
+        gnutls_credentials_type_t get_client_auth_type() const;
+
+        // informational stuff
+        void set_dh_prime_bits( unsigned int bits);
+        unsigned int get_dh_secret_bits() const;
+        unsigned int get_dh_peers_public_bits() const;
+        unsigned int get_dh_prime_bits() const;
+        void get_dh_group( gnutls_datum_t & gen, gnutls_datum_t & prime) const;
+        void get_dh_pubkey( gnutls_datum_t & raw_key) const;
+        void get_rsa_export_pubkey( gnutls_datum_t& exponent, gnutls_datum_t& modulus) const;
+        unsigned int get_rsa_export_modulus_bits() const;
+
+        void get_our_certificate(gnutls_datum_t & cert) const;
+        bool get_peers_certificate(std::vector<gnutls_datum_t> &out_certs) const;
+        bool get_peers_certificate(const gnutls_datum_t** certs, unsigned int *certs_size) const;
+
+        time_t get_peers_certificate_activation_time() const;
+        time_t get_peers_certificate_expiration_time() const;
+        void verify_peers_certificate( unsigned int& status) const;
+
+};
+
+// interface for databases
+class DB  : private noncopyable
+{
+    public:
+        virtual ~DB()=0;
+        virtual bool store( const gnutls_datum_t& key, const gnutls_datum_t& data)=0;
+        virtual bool retrieve( const gnutls_datum_t& key, gnutls_datum_t& data)=0;
+        virtual bool remove( const gnutls_datum_t& key)=0;
+};
+
+class server_session: public session
+{
+    public:
+        server_session();
+        ~server_session();
+        void db_remove() const;
+
+        void set_db_cache_expiration (unsigned int seconds);
+        void set_db( const DB& db);
+
+        // returns true if session is expired
+        bool db_check_entry ( gnutls_datum_t &session_data) const;
+
+        // server side only
+        const char *get_srp_username() const;
+        const char *get_psk_username() const;
+
+        void get_server_name (void *data, size_t * data_length,
+                          unsigned int *type, unsigned int indx) const;
+
+        int rehandshake();
+        void set_certificate_request( gnutls_certificate_request_t);
+};
+
+class client_session: public session
+{
+    public:
+        client_session();
+        ~client_session();
+
+        void set_server_name (gnutls_server_name_type_t type,
+                          const void *name, size_t name_length);
+
+        bool get_request_status();
+};
+
+
+class credentials  : private noncopyable
+{
+    public:
+        virtual ~credentials() { }
+        gnutls_credentials_type_t get_type() const;
+    protected:
+        friend class session;
+        credentials(gnutls_credentials_type_t t);
+        void* ptr() const;
+        void set_ptr(void* ptr);
+        gnutls_credentials_type_t type;
+    private:
+        void *cred;
+};
+
+class certificate_credentials: public credentials
+{
+    public:
+        ~certificate_credentials();
+        certificate_credentials();
+        
+        void free_keys ();
+        void free_cas ();
+        void free_ca_names ();
+        void free_crls ();
+
+        void set_dh_params ( const dh_params &params);
+        void set_rsa_export_params ( const rsa_params& params);
+        void set_verify_flags ( unsigned int flags);
+        void set_verify_limits ( unsigned int max_bits, unsigned int max_depth);
+
+        void set_x509_trust_file(const char *cafile, gnutls_x509_crt_fmt_t type);
+        void set_x509_trust(const gnutls_datum_t & CA, gnutls_x509_crt_fmt_t type);
+        // FIXME: use classes instead of gnutls_x509_crt_t
+        void set_x509_trust ( gnutls_x509_crt_t * ca_list, int ca_list_size);
+
+        void set_x509_crl_file( const char *crlfile, gnutls_x509_crt_fmt_t type);
+        void set_x509_crl(const gnutls_datum_t & CRL, gnutls_x509_crt_fmt_t type);
+        void set_x509_crl ( gnutls_x509_crl_t * crl_list, int crl_list_size);
+
+        void set_x509_key_file(const char *certfile, const char *KEYFILE, gnutls_x509_crt_fmt_t type);
+        void set_x509_key(const gnutls_datum_t & CERT, const gnutls_datum_t & KEY, gnutls_x509_crt_fmt_t type);
+        // FIXME: use classes
+        void set_x509_key ( gnutls_x509_crt_t * cert_list, int cert_list_size,
+                       gnutls_x509_privkey_t key);
+        
+
+        void set_simple_pkcs12_file( const char *pkcs12file,
+                 gnutls_x509_crt_fmt_t type, const char *password);
+        
+    protected:
+        gnutls_certificate_credentials_t cred;
+};
+
+class certificate_server_credentials: public certificate_credentials
+{
+    public:
+        void set_retrieve_function( gnutls_certificate_server_retrieve_function* func);
+        void set_params_function( gnutls_params_function* func);
+};
+
+class certificate_client_credentials: public certificate_credentials
+{
+    public:
+        void set_retrieve_function( gnutls_certificate_client_retrieve_function* func);
+};
+
+
+
+
+class anon_server_credentials: public credentials
+{
+    public:
+        anon_server_credentials();
+        ~anon_server_credentials();
+        void set_dh_params ( const dh_params &params);
+        void set_params_function ( gnutls_params_function * func);
+    protected:
+        gnutls_anon_server_credentials_t cred;
+};
+
+class anon_client_credentials: public credentials
+{
+    public:
+        anon_client_credentials();
+        ~anon_client_credentials();
+    protected:
+        gnutls_anon_client_credentials_t cred;
+};
+
+
+class srp_server_credentials: public credentials
+{
+    public:
+        srp_server_credentials();
+        ~srp_server_credentials();
+        void set_credentials_file (const char *password_file, const char *password_conf_file);
+        void set_credentials_function( gnutls_srp_server_credentials_function *func);
+    protected:
+        gnutls_srp_server_credentials_t cred;
+};
+
+class srp_client_credentials: public credentials
+{
+    public:
+        srp_client_credentials();
+        ~srp_client_credentials();
+        void set_credentials (const char *username, const char *password);
+        void set_credentials_function( gnutls_srp_client_credentials_function* func);
+    protected:
+        gnutls_srp_client_credentials_t cred;
+};
+
+
+class psk_server_credentials: public credentials
+{
+    public:
+        psk_server_credentials();
+        ~psk_server_credentials();
+        void set_credentials_file(const char* password_file);
+        void set_credentials_function( gnutls_psk_server_credentials_function* func);
+        void set_dh_params ( const dh_params &params);
+        void set_params_function (gnutls_params_function * func);
+    protected:
+        gnutls_psk_server_credentials_t cred;
+};
+
+class psk_client_credentials: public credentials
+{
+    public:
+        psk_client_credentials();
+        ~psk_client_credentials();
+        void set_credentials (const char *username, const gnutls_datum_t& key, gnutls_psk_key_flags flags);
+        void set_credentials_function( gnutls_psk_client_credentials_function* func);
+    protected:
+        gnutls_psk_client_credentials_t cred;
+};
+
+
+} /* namespace */
+
+#endif                          /* GNUTLSXX_H */

data/vendor/local/include/gnutls/openpgp.h

@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation
+ *
+ * Author: Nikos Mavrogiannopoulos
+ *
+ * This file is part of GNUTLS.
+ *
+ * The GNUTLS library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ */
+
+/* This file contains the types and prototypes for the OpenPGP
+ * key and private key parsing functions.
+ */
+
+#ifndef GNUTLS_OPENPGP_H
+# define GNUTLS_OPENPGP_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <gnutls/gnutls.h>
+
+/* Openpgp certificate stuff 
+ */
+
+  typedef enum gnutls_openpgp_crt_fmt
+  { GNUTLS_OPENPGP_FMT_RAW,
+    GNUTLS_OPENPGP_FMT_BASE64
+  } gnutls_openpgp_crt_fmt_t;
+
+  typedef unsigned char gnutls_openpgp_keyid_t[8];
+    
+/* gnutls_openpgp_cert_t should be defined in gnutls.h
+ */
+
+  /* initializes the memory for gnutls_openpgp_crt_t struct */
+  int gnutls_openpgp_crt_init (gnutls_openpgp_crt_t * key);
+  /* frees all memory */
+  void gnutls_openpgp_crt_deinit (gnutls_openpgp_crt_t key);
+
+  int gnutls_openpgp_crt_import (gnutls_openpgp_crt_t key,
+				 const gnutls_datum_t * data,
+				 gnutls_openpgp_crt_fmt_t format);
+  int gnutls_openpgp_crt_export (gnutls_openpgp_crt_t key,
+				 gnutls_openpgp_crt_fmt_t format,
+				 void *output_data,
+				 size_t * output_data_size);
+
+  int gnutls_openpgp_crt_print (gnutls_openpgp_crt_t cert,
+		       gnutls_certificate_print_formats_t format,
+		       gnutls_datum_t *out);
+
+/* The key_usage flags are defined in gnutls.h. They are
+ * the GNUTLS_KEY_* definitions.
+ */
+  int gnutls_openpgp_crt_get_key_usage (gnutls_openpgp_crt_t cert,
+					unsigned int *key_usage);
+  int gnutls_openpgp_crt_get_fingerprint (gnutls_openpgp_crt_t key, void *fpr,
+					  size_t * fprlen);
+  int gnutls_openpgp_crt_get_subkey_fingerprint (gnutls_openpgp_crt_t key,
+						 unsigned int idx,
+						 void *fpr, size_t * fprlen);
+
+  int gnutls_openpgp_crt_get_name (gnutls_openpgp_crt_t key,
+				   int idx, char *buf, size_t * sizeof_buf);
+
+  gnutls_pk_algorithm_t
+  gnutls_openpgp_crt_get_pk_algorithm (gnutls_openpgp_crt_t key,
+				       unsigned int *bits);
+
+  int gnutls_openpgp_crt_get_version (gnutls_openpgp_crt_t key);
+
+  time_t gnutls_openpgp_crt_get_creation_time (gnutls_openpgp_crt_t key);
+  time_t gnutls_openpgp_crt_get_expiration_time (gnutls_openpgp_crt_t key);
+
+  int gnutls_openpgp_crt_get_key_id (gnutls_openpgp_crt_t key,
+				 gnutls_openpgp_keyid_t keyid);
+
+  int gnutls_openpgp_crt_check_hostname (gnutls_openpgp_crt_t key,
+					 const char *hostname);
+
+  int gnutls_openpgp_crt_get_revoked_status (gnutls_openpgp_crt_t key);
+
+  int gnutls_openpgp_crt_get_subkey_count (gnutls_openpgp_crt_t key);
+  int gnutls_openpgp_crt_get_subkey_idx (gnutls_openpgp_crt_t key, const gnutls_openpgp_keyid_t keyid);
+  int gnutls_openpgp_crt_get_subkey_revoked_status (gnutls_openpgp_crt_t key, unsigned int idx);
+  gnutls_pk_algorithm_t gnutls_openpgp_crt_get_subkey_pk_algorithm (gnutls_openpgp_crt_t key,
+    unsigned int idx, unsigned int *bits);
+  time_t gnutls_openpgp_crt_get_subkey_creation_time (gnutls_openpgp_crt_t key, unsigned int idx);
+  time_t gnutls_openpgp_crt_get_subkey_expiration_time (gnutls_openpgp_crt_t key, unsigned int idx);
+  int gnutls_openpgp_crt_get_subkey_id (gnutls_openpgp_crt_t key, unsigned int idx, gnutls_openpgp_keyid_t keyid);
+  int gnutls_openpgp_crt_get_subkey_usage (gnutls_openpgp_crt_t key, unsigned int idx,
+				  unsigned int *key_usage);
+
+  int gnutls_openpgp_crt_get_subkey_pk_dsa_raw (gnutls_openpgp_crt_t crt, unsigned int idx,
+				gnutls_datum_t * p, gnutls_datum_t * q,
+				gnutls_datum_t * g, gnutls_datum_t * y);
+  int gnutls_openpgp_crt_get_subkey_pk_rsa_raw (gnutls_openpgp_crt_t crt, unsigned int idx,
+				gnutls_datum_t * m, gnutls_datum_t * e);
+  int gnutls_openpgp_crt_get_pk_dsa_raw (gnutls_openpgp_crt_t crt, 
+				gnutls_datum_t * p, gnutls_datum_t * q,
+				gnutls_datum_t * g, gnutls_datum_t * y);
+  int gnutls_openpgp_crt_get_pk_rsa_raw (gnutls_openpgp_crt_t crt, 
+				gnutls_datum_t * m, gnutls_datum_t * e);
+
+  int gnutls_openpgp_crt_get_preferred_key_id (gnutls_openpgp_crt_t key, gnutls_openpgp_keyid_t keyid);
+  int gnutls_openpgp_crt_set_preferred_key_id (gnutls_openpgp_crt_t key, const gnutls_openpgp_keyid_t keyid);
+
+/* privkey stuff.
+ */
+  int gnutls_openpgp_privkey_init (gnutls_openpgp_privkey_t * key);
+  void gnutls_openpgp_privkey_deinit (gnutls_openpgp_privkey_t key);
+  gnutls_pk_algorithm_t
+  gnutls_openpgp_privkey_get_pk_algorithm (gnutls_openpgp_privkey_t key,
+					   unsigned int *bits);
+  int gnutls_openpgp_privkey_import (gnutls_openpgp_privkey_t key,
+				     const gnutls_datum_t * data,
+				     gnutls_openpgp_crt_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,
+				  gnutls_datum_t * signature);
+  int gnutls_openpgp_privkey_get_fingerprint (gnutls_openpgp_privkey_t key,
+				    void *fpr, size_t * fprlen);
+  int
+  gnutls_openpgp_privkey_get_subkey_fingerprint (gnutls_openpgp_privkey_t key,
+						 unsigned int idx,
+						 void *fpr, size_t * fprlen);
+  int gnutls_openpgp_privkey_get_key_id (gnutls_openpgp_privkey_t key, gnutls_openpgp_keyid_t keyid);
+  int gnutls_openpgp_privkey_get_subkey_count (gnutls_openpgp_privkey_t key);
+  int gnutls_openpgp_privkey_get_subkey_idx (gnutls_openpgp_privkey_t key, const gnutls_openpgp_keyid_t keyid);
+
+  int gnutls_openpgp_privkey_get_subkey_revoked_status (gnutls_openpgp_privkey_t key, unsigned int idx);
+
+  int gnutls_openpgp_privkey_get_revoked_status (gnutls_openpgp_privkey_t key);
+
+  gnutls_pk_algorithm_t gnutls_openpgp_privkey_get_subkey_pk_algorithm (gnutls_openpgp_privkey_t key,
+    unsigned int idx, unsigned int *bits);
+
+  time_t gnutls_openpgp_privkey_get_subkey_expiration_time (gnutls_openpgp_privkey_t key, unsigned int idx);
+
+  int gnutls_openpgp_privkey_get_subkey_id (gnutls_openpgp_privkey_t key, unsigned int idx, gnutls_openpgp_keyid_t keyid);
+
+  time_t gnutls_openpgp_privkey_get_subkey_creation_time (gnutls_openpgp_privkey_t key, unsigned int idx);
+
+  int gnutls_openpgp_privkey_export_subkey_dsa_raw (gnutls_openpgp_privkey_t crt, unsigned int idx,
+				    gnutls_datum_t * p, gnutls_datum_t * q,
+				    gnutls_datum_t * g, gnutls_datum_t * y,
+				    gnutls_datum_t * x);
+  int gnutls_openpgp_privkey_export_subkey_rsa_raw (gnutls_openpgp_privkey_t crt, unsigned int idx,
+				    gnutls_datum_t * m, gnutls_datum_t * e,
+				    gnutls_datum_t * d, gnutls_datum_t * p,
+				    gnutls_datum_t * q, gnutls_datum_t * u);
+
+  int gnutls_openpgp_privkey_export_dsa_raw (gnutls_openpgp_privkey_t crt, 
+				    gnutls_datum_t * p, gnutls_datum_t * q,
+				    gnutls_datum_t * g, gnutls_datum_t * y,
+				    gnutls_datum_t * x);
+  int gnutls_openpgp_privkey_export_rsa_raw (gnutls_openpgp_privkey_t crt, 
+				    gnutls_datum_t * m, gnutls_datum_t * e,
+				    gnutls_datum_t * d, gnutls_datum_t * p,
+				    gnutls_datum_t * q, gnutls_datum_t * u);
+
+  int gnutls_openpgp_privkey_export (gnutls_openpgp_privkey_t key,
+			   gnutls_openpgp_crt_fmt_t format,
+			   const char* password, unsigned int flags,
+			   void *output_data, size_t * output_data_size);
+
+  int gnutls_openpgp_privkey_set_preferred_key_id (gnutls_openpgp_privkey_t key, const gnutls_openpgp_keyid_t keyid);
+  int gnutls_openpgp_privkey_get_preferred_key_id (gnutls_openpgp_privkey_t key, gnutls_openpgp_keyid_t keyid);
+  
+  int gnutls_openpgp_crt_get_auth_subkey( gnutls_openpgp_crt_t crt, gnutls_openpgp_keyid_t keyid, unsigned int flag);
+
+/* Keyring stuff.
+ */
+
+  int gnutls_openpgp_keyring_init (gnutls_openpgp_keyring_t * keyring);
+  void gnutls_openpgp_keyring_deinit (gnutls_openpgp_keyring_t keyring);
+
+  int gnutls_openpgp_keyring_import (gnutls_openpgp_keyring_t keyring,
+				     const gnutls_datum_t * data,
+				     gnutls_openpgp_crt_fmt_t format);
+
+  int gnutls_openpgp_keyring_check_id (gnutls_openpgp_keyring_t ring,
+				       const gnutls_openpgp_keyid_t keyid,
+				       unsigned int flags);
+
+
+  int gnutls_openpgp_crt_verify_ring (gnutls_openpgp_crt_t key,
+				      gnutls_openpgp_keyring_t keyring,
+				      unsigned int flags, unsigned int *verify
+				      /* the output of the verification */ );
+
+  int gnutls_openpgp_crt_verify_self (gnutls_openpgp_crt_t key,
+				      unsigned int flags,
+				      unsigned int *verify);
+
+  int gnutls_openpgp_keyring_get_crt (gnutls_openpgp_keyring_t ring, unsigned int idx, 
+    gnutls_openpgp_crt_t* cert);
+
+  int gnutls_openpgp_keyring_get_crt_count (gnutls_openpgp_keyring_t ring);
+
+
+
+/**
+ * gnutls_openpgp_recv_key_func - Callback prototype to get OpenPGP keys
+ * @session: a TLS session
+ * @keyfpr: key fingerprint
+ * @keyfpr_length: length of key fingerprint
+ * @key: output key.
+ *
+ * A callback of this type is used to retrieve OpenPGP keys.  Only
+ * useful on the server, and will only be used if the peer send a key
+ * fingerprint instead of a full key.  See also
+ * gnutls_openpgp_set_recv_key_function().
+ *
+ */
+  typedef int (*gnutls_openpgp_recv_key_func) (gnutls_session_t session,
+					       const unsigned char *keyfpr,
+					       unsigned int keyfpr_length,
+					       gnutls_datum_t * key);
+
+  void gnutls_openpgp_set_recv_key_function (gnutls_session_t session,
+					     gnutls_openpgp_recv_key_func
+					     func);
+
+
+
+/* certificate authentication stuff.
+ */
+  int gnutls_certificate_set_openpgp_key (gnutls_certificate_credentials_t
+					  res, gnutls_openpgp_crt_t key,
+					  gnutls_openpgp_privkey_t pkey);
+
+  int
+    gnutls_certificate_set_openpgp_key_file (gnutls_certificate_credentials_t
+					     res, const char *CERTFILE,
+					     const char *KEYFILE, gnutls_openpgp_crt_fmt_t);
+  int gnutls_certificate_set_openpgp_key_mem (gnutls_certificate_credentials_t
+					      res,
+					      const gnutls_datum_t * CERT,
+					      const gnutls_datum_t * KEY, gnutls_openpgp_crt_fmt_t);
+
+  int gnutls_certificate_set_openpgp_key_file2 (gnutls_certificate_credentials_t
+					     res, const char *CERTFILE,
+					     const char *KEYFILE, const char* keyid, 
+					     gnutls_openpgp_crt_fmt_t);
+  int gnutls_certificate_set_openpgp_key_mem2 (gnutls_certificate_credentials_t
+					      res,
+					      const gnutls_datum_t * CERT,
+					      const gnutls_datum_t * KEY, 
+					      const char* keyid, 
+					      gnutls_openpgp_crt_fmt_t);
+
+  int
+    gnutls_certificate_set_openpgp_keyring_mem
+    (gnutls_certificate_credentials_t c, const unsigned char *data,
+     size_t dlen, gnutls_openpgp_crt_fmt_t);
+
+  int
+    gnutls_certificate_set_openpgp_keyring_file
+    (gnutls_certificate_credentials_t c, const char *file, gnutls_openpgp_crt_fmt_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GNUTLS_OPENPGP_H */