gnutls

gnutls

Synopsis

#define             LIBGNUTLS_VERSION
#define             LIBGNUTLS_VERSION_MAJOR
#define             LIBGNUTLS_VERSION_MINOR
#define             LIBGNUTLS_VERSION_PATCH
#define             LIBGNUTLS_VERSION_NUMBER
#define             HAVE_SSIZE_T
#define             GNUTLS_CIPHER_RIJNDAEL_128_CBC
#define             GNUTLS_CIPHER_RIJNDAEL_256_CBC
#define             GNUTLS_CIPHER_RIJNDAEL_CBC
#define             GNUTLS_CIPHER_ARCFOUR
enum                gnutls_cipher_algorithm_t;
enum                gnutls_kx_algorithm_t;
enum                gnutls_params_type_t;
enum                gnutls_credentials_type_t;
#define             GNUTLS_MAC_SHA
#define             GNUTLS_DIG_SHA
enum                gnutls_mac_algorithm_t;
enum                gnutls_digest_algorithm_t;
#define             GNUTLS_MAX_ALGORITHM_NUM
#define             GNUTLS_COMP_ZLIB
enum                gnutls_compression_method_t;
enum                gnutls_connection_end_t;
enum                gnutls_alert_level_t;
enum                gnutls_alert_description_t;
enum                gnutls_handshake_description_t;
enum                gnutls_certificate_status_t;
enum                gnutls_certificate_request_t;
enum                gnutls_openpgp_crt_status_t;
enum                gnutls_close_request_t;
#define             GNUTLS_TLS1
enum                gnutls_protocol_t;
enum                gnutls_certificate_type_t;
enum                gnutls_x509_crt_fmt_t;
enum                gnutls_certificate_print_formats_t;
enum                gnutls_pk_algorithm_t;
const char*         gnutls_pk_algorithm_get_name        (gnutls_pk_algorithm_t algorithm);
#define             GNUTLS_SIGN_RSA_SHA
#define             GNUTLS_SIGN_DSA_SHA
enum                gnutls_sign_algorithm_t;
const char*         gnutls_sign_algorithm_get_name      (gnutls_sign_algorithm_talgorithm );
typedef             gnutls_transport_ptr_t;
struct              gnutls_session_int;
typedef             gnutls_session_t;
struct              gnutls_dh_params_int;
typedef             gnutls_dh_params_t;
struct              gnutls_x509_privkey_int;
typedef             gnutls_rsa_params_t;
struct              gnutls_priority_st;
typedef             gnutls_priority_t;
int                 gnutls_init                         (gnutls_session_t *session,
                                                         gnutls_connection_end_t con_end);
void                gnutls_deinit                       (gnutls_session_t session);
int                 gnutls_bye                          (gnutls_session_t session,
                                                         gnutls_close_request_t how);
int                 gnutls_handshake                    (gnutls_session_t session);
int                 gnutls_rehandshake                  (gnutls_session_t session);
gnutls_alert_description_t gnutls_alert_get             (gnutls_session_t session);
int                 gnutls_alert_send                   (gnutls_session_t session,
                                                         gnutls_alert_level_t level,
                                                         gnutls_alert_description_t desc);
int                 gnutls_alert_send_appropriate       (gnutls_session_t session,
                                                         int err);
const char*         gnutls_alert_get_name               (gnutls_alert_description_t alert);
gnutls_cipher_algorithm_t gnutls_cipher_get             (gnutls_session_t session);
gnutls_kx_algorithm_t gnutls_kx_get                     (gnutls_session_t session);
gnutls_mac_algorithm_t gnutls_mac_get                   (gnutls_session_t session);
gnutls_compression_method_t gnutls_compression_get      (gnutls_session_tsession );
gnutls_certificate_type_t gnutls_certificate_type_get   (gnutls_session_tsession );
size_t              gnutls_cipher_get_key_size          (gnutls_cipher_algorithm_t algorithm);
size_t              gnutls_mac_get_key_size             (gnutls_mac_algorithm_t algorithm);
const char*         gnutls_cipher_get_name              (gnutls_cipher_algorithm_t algorithm);
const char*         gnutls_mac_get_name                 (gnutls_mac_algorithm_t algorithm);
const char*         gnutls_compression_get_name         (gnutls_compression_method_talgorithm );
const char*         gnutls_kx_get_name                  (gnutls_kx_algorithm_t algorithm);
const char*         gnutls_certificate_type_get_name    (gnutls_certificate_type_ttype );
gnutls_mac_algorithm_t gnutls_mac_get_id                (const char *name);
gnutls_compression_method_t gnutls_compression_get_id   (const char *name);
gnutls_cipher_algorithm_t gnutls_cipher_get_id          (const char *name);
gnutls_kx_algorithm_t gnutls_kx_get_id                  (const char *name);
gnutls_protocol_t   gnutls_protocol_get_id              (const char *name);
gnutls_certificate_type_t gnutls_certificate_type_get_id
                                                        (const char *name);
const gnutls_cipher_algorithm_t* gnutls_cipher_list     (void);
const gnutls_mac_algorithm_t* gnutls_mac_list           (void);
const gnutls_compression_method_t* gnutls_compression_list
                                                        (void);
const gnutls_protocol_t* gnutls_protocol_list           (void);
const gnutls_certificate_type_t* gnutls_certificate_type_list
                                                        (void);
const gnutls_kx_algorithm_t* gnutls_kx_list             (void);
const char*         gnutls_cipher_suite_info            (size_t i,
                                                         char *id,
                                                         gnutls_kx_algorithm_t *kx,
                                                         gnutls_cipher_algorithm_t *cipher,
                                                         gnutls_mac_algorithm_t *mac,
                                                         gnutls_protocol_t *version);
int                 gnutls_error_is_fatal               (int error);
int                 gnutls_error_to_alert               (int err,
                                                         int *level);
void                gnutls_perror                       (int error);
const char*         gnutls_strerror                     (int error);
void                gnutls_handshake_set_private_extensions
                                                        (gnutls_session_t session,
                                                         int allow);
gnutls_handshake_description_t gnutls_handshake_get_last_out
                                                        (gnutls_session_t session);
gnutls_handshake_description_t gnutls_handshake_get_last_in
                                                        (gnutls_session_t session);
ssize_t             gnutls_record_send                  (gnutls_session_t session,
                                                         const void *data,
                                                         size_t sizeofdata);
ssize_t             gnutls_record_recv                  (gnutls_session_t session,
                                                         void *data,
                                                         size_t sizeofdata);
#define             gnutls_read
#define             gnutls_write
void                gnutls_session_enable_compatibility_mode
                                                        (gnutls_session_t session);
void                gnutls_record_disable_padding       (gnutls_session_t session);
int                 gnutls_record_get_direction         (gnutls_session_t session);
size_t              gnutls_record_get_max_size          (gnutls_session_t session);
ssize_t             gnutls_record_set_max_size          (gnutls_session_t session,
                                                         size_t size);
size_t              gnutls_record_check_pending         (gnutls_session_t session);
int                 gnutls_prf                          (gnutls_session_t session,
                                                         size_t label_size,
                                                         const char *label,
                                                         int server_random_first,
                                                         size_t extra_size,
                                                         const char *extra,
                                                         size_t outsize,
                                                         char *out);
int                 gnutls_prf_raw                      (gnutls_session_t session,
                                                         size_t label_size,
                                                         const char *label,
                                                         size_t seed_size,
                                                         const char *seed,
                                                         size_t outsize,
                                                         char *out);
int                 (*gnutls_ext_recv_func)             (gnutls_session_t session,
                                                         unsigned char *data,
                                                         size_t len);
int                 (*gnutls_ext_send_func)             (gnutls_session_t session,
                                                         unsigned char *data,
                                                         size_t len);
enum                gnutls_ext_parse_type_t;
int                 gnutls_ext_register                 (int type,
                                                         const char *name,
                                                         gnutls_ext_parse_type_t parse_type,
                                                         gnutls_ext_recv_func recv_func,
                                                         gnutls_ext_send_func send_func);
enum                gnutls_server_name_type_t;
int                 gnutls_server_name_set              (gnutls_session_t session,
                                                         gnutls_server_name_type_t type,
                                                         const void *name,
                                                         size_t name_length);
int                 gnutls_server_name_get              (gnutls_session_t session,
                                                         void *data,
                                                         size_t *data_length,
                                                         unsigned int *type,
                                                         unsigned int indx);
void                gnutls_oprfi_enable_client          (gnutls_session_t session,
                                                         size_t len,
                                                         unsigned char *data);
int                 (*gnutls_oprfi_callback_func)       (gnutls_session_t session,
                                                         void *userdata,
                                                         size_t oprfi_len,
                                                         unsigned char *in_oprfi,
                                                         unsigned char *out_oprfi);
void                gnutls_oprfi_enable_server          (gnutls_session_t session,
                                                         gnutls_oprfi_callback_func cb,
                                                         void *userdata);
enum                gnutls_supplemental_data_format_type_t;
const char*         gnutls_supplemental_get_name        (gnutls_supplemental_data_format_type_t type);
int                 gnutls_cipher_set_priority          (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_mac_set_priority             (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_compression_set_priority     (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_kx_set_priority              (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_protocol_set_priority        (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_certificate_type_set_priority
                                                        (gnutls_session_t session,
                                                         const int *list);
int                 gnutls_priority_init                (gnutls_priority_t *,
                                                         const char *priority,
                                                         const char **err_pos);
void                gnutls_priority_deinit              (gnutls_priority_t );
int                 gnutls_priority_set                 (gnutls_session_t session,
                                                         gnutls_priority_t );
int                 gnutls_priority_set_direct          (gnutls_session_t session,
                                                         const char *priority,
                                                         const char **err_pos);
int                 gnutls_set_default_priority         (gnutls_session_t session);
int                 gnutls_set_default_export_priority  (gnutls_session_t session);
const char*         gnutls_cipher_suite_get_name        (gnutls_kx_algorithm_tkx_algorithm ,
                                                         gnutls_cipher_algorithm_tcipher_algorithm ,
                                                         gnutls_mac_algorithm_tmac_algorithm );
gnutls_protocol_t   gnutls_protocol_get_version         (gnutls_session_t session);
const char*         gnutls_protocol_get_name            (gnutls_protocol_t version);
int                 gnutls_session_set_data             (gnutls_session_t session,
                                                         const void *session_data,
                                                         size_t session_data_size);
int                 gnutls_session_get_data             (gnutls_session_t session,
                                                         void *session_data,
                                                         size_t *session_data_size);
int                 gnutls_session_get_data2            (gnutls_session_t session,
                                                         gnutls_datum_t *data);
#define             GNUTLS_MAX_SESSION_ID
int                 gnutls_session_get_id               (gnutls_session_t session,
                                                         void *session_id,
                                                         size_t *session_id_size);
#define             TLS_MASTER_SIZE
#define             TLS_RANDOM_SIZE
const void*         gnutls_session_get_server_random    (gnutls_session_t session);
const void*         gnutls_session_get_client_random    (gnutls_session_t session);
const void*         gnutls_session_get_master_secret    (gnutls_session_t session);
int                 gnutls_session_is_resumed           (gnutls_session_t session);
int                 (*gnutls_db_store_func)             (void *,
                                                         gnutls_datum_t key,
                                                         gnutls_datum_t data);
int                 (*gnutls_db_remove_func)            (void *,
                                                         gnutls_datum_t key);
gnutls_datum_t      (*gnutls_db_retr_func)              (void *,
                                                         gnutls_datum_t key);
void                gnutls_db_set_cache_expiration      (gnutls_session_t session,
                                                         int seconds);
void                gnutls_db_remove_session            (gnutls_session_t session);
void                gnutls_db_set_retrieve_function     (gnutls_session_t session,
                                                         gnutls_db_retr_func retr_func);
void                gnutls_db_set_remove_function       (gnutls_session_t session,
                                                         gnutls_db_remove_func rem_func);
void                gnutls_db_set_store_function        (gnutls_session_t session,
                                                         gnutls_db_store_func store_func);
void                gnutls_db_set_ptr                   (gnutls_session_t session,
                                                         void *ptr);
void*               gnutls_db_get_ptr                   (gnutls_session_t session);
int                 gnutls_db_check_entry               (gnutls_session_t session,
                                                         gnutls_datum_t session_entry);
int                 (*gnutls_handshake_post_client_hello_func)
                                                        (gnutls_session_t );
void                gnutls_handshake_set_post_client_hello_function
                                                        (gnutls_session_t ,
                                                         gnutls_handshake_post_client_hello_func );
void                gnutls_handshake_set_max_packet_length
                                                        (gnutls_session_t session,
                                                         size_t max);
const char*         gnutls_check_version                (const char *req_version);
void                gnutls_credentials_clear            (gnutls_session_t session);
int                 gnutls_credentials_set              (gnutls_session_t session,
                                                         gnutls_credentials_type_t type,
                                                         void *cred);
#define             gnutls_cred_set
struct              gnutls_certificate_credentials_st;
void                gnutls_anon_free_server_credentials (gnutls_anon_server_credentials_t sc);
int                 gnutls_anon_allocate_server_credentials
                                                        (gnutls_anon_server_credentials_t *sc);
void                gnutls_anon_set_server_dh_params    (gnutls_anon_server_credentials_t res,
                                                         gnutls_dh_params_t dh_params);
void                gnutls_anon_set_server_params_function
                                                        (gnutls_anon_server_credentials_tres ,
                                                         gnutls_params_function *func);
void                gnutls_anon_free_client_credentials (gnutls_anon_client_credentials_tsc );
int                 gnutls_anon_allocate_client_credentials
                                                        (gnutls_anon_client_credentials_t *sc);
void                gnutls_certificate_free_credentials (gnutls_certificate_credentials_tsc );
int                 gnutls_certificate_allocate_credentials
                                                        (gnutls_certificate_credentials_t *res);
void                gnutls_certificate_free_keys        (gnutls_certificate_credentials_t sc);
void                gnutls_certificate_free_cas         (gnutls_certificate_credentials_t sc);
void                gnutls_certificate_free_ca_names    (gnutls_certificate_credentials_t sc);
void                gnutls_certificate_free_crls        (gnutls_certificate_credentials_t sc);
void                gnutls_certificate_set_dh_params    (gnutls_certificate_credentials_t res,
                                                         gnutls_dh_params_t dh_params);
void                gnutls_certificate_set_rsa_export_params
                                                        (gnutls_certificate_credentials_tres ,
                                                         gnutls_rsa_params_t rsa_params);
void                gnutls_certificate_set_verify_flags (gnutls_certificate_credentials_tres ,
                                                         unsigned int flags);
void                gnutls_certificate_set_verify_limits
                                                        (gnutls_certificate_credentials_tres ,
                                                         unsigned int max_bits,
                                                         unsigned int max_depth);
int                 gnutls_certificate_set_x509_trust_file
                                                        (gnutls_certificate_credentials_tres ,
                                                         const char *CAFILE,
                                                         gnutls_x509_crt_fmt_t type);
int                 gnutls_certificate_set_x509_trust_mem
                                                        (gnutls_certificate_credentials_tres ,
                                                         const gnutls_datum_t *CA,
                                                         gnutls_x509_crt_fmt_t type);
int                 gnutls_certificate_set_x509_crl_file
                                                        (gnutls_certificate_credentials_tres ,
                                                         const char *crlfile,
                                                         gnutls_x509_crt_fmt_t type);
int                 gnutls_certificate_set_x509_crl_mem (gnutls_certificate_credentials_tres ,
                                                         const gnutls_datum_t *CRL,
                                                         gnutls_x509_crt_fmt_t type);
int                 gnutls_certificate_set_x509_key_file
                                                        (gnutls_certificate_credentials_tres ,
                                                         const char *CERTFILE,
                                                         const char *KEYFILE,
                                                         gnutls_x509_crt_fmt_t type);
int                 gnutls_certificate_set_x509_key_mem (gnutls_certificate_credentials_tres ,
                                                         const gnutls_datum_t *CERT,
                                                         const gnutls_datum_t *KEY,
                                                         gnutls_x509_crt_fmt_t type);
void                gnutls_certificate_send_x509_rdn_sequence
                                                        (gnutls_session_t session,
                                                         int status);
int                 gnutls_certificate_set_x509_simple_pkcs12_file
                                                        (gnutls_certificate_credentials_t res,
                                                         const char *pkcs12file,
                                                         gnutls_x509_crt_fmt_t type,
                                                         const char *password);
typedef             gnutls_x509_privkey_t;
struct              gnutls_x509_crl_int;
typedef             gnutls_x509_crl_t;
struct              gnutls_x509_crt_int;
typedef             gnutls_x509_crt_t;
struct              gnutls_openpgp_keyring_int;
typedef             gnutls_openpgp_keyring_t;
int                 gnutls_certificate_set_x509_key     (gnutls_certificate_credentials_t res,
                                                         gnutls_x509_crt_t *cert_list,
                                                         int cert_list_size,
                                                         gnutls_x509_privkey_t key);
int                 gnutls_certificate_set_x509_trust   (gnutls_certificate_credentials_t res,
                                                         gnutls_x509_crt_t *ca_list,
                                                         int ca_list_size);
int                 gnutls_certificate_set_x509_crl     (gnutls_certificate_credentials_t res,
                                                         gnutls_x509_crl_t *crl_list,
                                                         int crl_list_size);
void                gnutls_certificate_get_x509_cas     (gnutls_certificate_credentials_t sc,
                                                         gnutls_x509_crt_t **x509_ca_list,
                                                         unsigned int *ncas);
void                gnutls_certificate_get_x509_crls    (gnutls_certificate_credentials_t sc,
                                                         gnutls_x509_crl_t **x509_crl_list,
                                                         unsigned int *ncrls);
void                gnutls_certificate_get_openpgp_keyring
                                                        (gnutls_certificate_credentials_t sc,
                                                         gnutls_openpgp_keyring_t *keyring);
int                 gnutls_global_init                  (void);
void                gnutls_global_deinit                (void);
void*               (*gnutls_alloc_function)            (size_t );
void*               (*gnutls_calloc_function)           (size_t ,
                                                         size_t );
int                 (*gnutls_is_secure_function)        (const void *);
void                (*gnutls_free_function)             (void *);
void*               (*gnutls_realloc_function)          (void *,
                                                         size_t );
void                gnutls_global_set_mem_functions     (gnutls_alloc_function gt_alloc_func,
                                                         gnutls_alloc_functiongt_secure_alloc_func ,
                                                         gnutls_is_secure_functiongt_is_secure_func ,
                                                         gnutls_realloc_function gt_realloc_func,
                                                         gnutls_free_function gt_free_func);
extern              gnutls_alloc_function gnutls_malloc;
extern              gnutls_alloc_function gnutls_secure_malloc;
extern              gnutls_realloc_function gnutls_realloc;
extern              gnutls_calloc_function gnutls_calloc;
extern              gnutls_free_function gnutls_free;
char*               gnutls_strdup                       (const char *);
void                (*gnutls_log_func)                  (...,
                                                         const char *);
void                gnutls_global_set_log_function      (gnutls_log_func log_func);
void                gnutls_global_set_log_level         (int level);
int                 gnutls_dh_params_init               (gnutls_dh_params_t *dh_params);
void                gnutls_dh_params_deinit             (gnutls_dh_params_t dh_params);
int                 gnutls_dh_params_import_raw         (gnutls_dh_params_t dh_params,
                                                         const gnutls_datum_t *prime,
                                                         const gnutls_datum_t *generator);
int                 gnutls_dh_params_import_pkcs3       (gnutls_dh_params_t params,
                                                         const gnutls_datum_t *pkcs3_params,
                                                         gnutls_x509_crt_fmt_t format);
int                 gnutls_dh_params_generate2          (gnutls_dh_params_t params,
                                                         unsigned int bits);
int                 gnutls_dh_params_export_pkcs3       (gnutls_dh_params_t params,
                                                         gnutls_x509_crt_fmt_t format,
                                                         unsigned char *params_data,
                                                         size_t *params_data_size);
int                 gnutls_dh_params_export_raw         (gnutls_dh_params_t params,
                                                         gnutls_datum_t *prime,
                                                         gnutls_datum_t *generator,
                                                         unsigned int *bits);
int                 gnutls_dh_params_cpy                (gnutls_dh_params_t dst,
                                                         gnutls_dh_params_t src);
int                 gnutls_rsa_params_init              (gnutls_rsa_params_t *rsa_params);
void                gnutls_rsa_params_deinit            (gnutls_rsa_params_t rsa_params);
int                 gnutls_rsa_params_cpy               (gnutls_rsa_params_t dst,
                                                         gnutls_rsa_params_t src);
int                 gnutls_rsa_params_import_raw        (gnutls_rsa_params_t rsa_params,
                                                         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);
int                 gnutls_rsa_params_generate2         (gnutls_rsa_params_t params,
                                                         unsigned int bits);
int                 gnutls_rsa_params_export_raw        (gnutls_rsa_params_t params,
                                                         gnutls_datum_t *m,
                                                         gnutls_datum_t *e,
                                                         gnutls_datum_t *d,
                                                         gnutls_datum_t *p,
                                                         gnutls_datum_t *q,
                                                         gnutls_datum_t *u,
                                                         unsigned int *bits);
int                 gnutls_rsa_params_export_pkcs1      (gnutls_rsa_params_t params,
                                                         gnutls_x509_crt_fmt_t format,
                                                         unsigned char *params_data,
                                                         size_t *params_data_size);
int                 gnutls_rsa_params_import_pkcs1      (gnutls_rsa_params_t params,
                                                         const gnutls_datum_t *pkcs1_params,
                                                         gnutls_x509_crt_fmt_t format);
ssize_t             (*gnutls_pull_func)                 (gnutls_transport_ptr_t ,
                                                         void *,
                                                         size_t );
ssize_t             (*gnutls_push_func)                 (gnutls_transport_ptr_t ,
                                                         const void *,
                                                         size_t );
void                gnutls_transport_set_ptr            (gnutls_session_t session,
                                                         gnutls_transport_ptr_t ptr);
void                gnutls_transport_set_ptr2           (gnutls_session_t session,
                                                         gnutls_transport_ptr_t recv_ptr,
                                                         gnutls_transport_ptr_t send_ptr);
gnutls_transport_ptr_t gnutls_transport_get_ptr         (gnutls_session_t session);
void                gnutls_transport_get_ptr2           (gnutls_session_t session,
                                                         gnutls_transport_ptr_t *recv_ptr,
                                                         gnutls_transport_ptr_t *send_ptr);
void                gnutls_transport_set_lowat          (gnutls_session_t session,
                                                         int num);
void                gnutls_transport_set_push_function  (gnutls_session_t session,
                                                         gnutls_push_func push_func);
void                gnutls_transport_set_pull_function  (gnutls_session_t session,
                                                         gnutls_pull_func pull_func);
void                gnutls_transport_set_errno          (gnutls_session_t session,
                                                         int err);
void                gnutls_transport_set_global_errno   (int err);
void                gnutls_session_set_ptr              (gnutls_session_t session,
                                                         void *ptr);
void*               gnutls_session_get_ptr              (gnutls_session_t session);
void                gnutls_openpgp_send_cert            (gnutls_session_t session,
                                                         gnutls_openpgp_crt_status_t status);
int                 gnutls_fingerprint                  (gnutls_digest_algorithm_t algo,
                                                         const gnutls_datum_t *data,
                                                         void *result,
                                                         size_t *result_size);
void                gnutls_srp_free_client_credentials  (gnutls_srp_client_credentials_tsc );
int                 gnutls_srp_allocate_client_credentials
                                                        (gnutls_srp_client_credentials_t *sc);
int                 gnutls_srp_set_client_credentials   (gnutls_srp_client_credentials_t res,
                                                         const char *username,
                                                         const char *password);
void                gnutls_srp_free_server_credentials  (gnutls_srp_server_credentials_tsc );
int                 gnutls_srp_allocate_server_credentials
                                                        (gnutls_srp_server_credentials_t *sc);
int                 gnutls_srp_set_server_credentials_file
                                                        (gnutls_srp_server_credentials_tres ,
                                                         const char *password_file,
                                                         const char *password_conf_file);
const char*         gnutls_srp_server_get_username      (gnutls_session_t session);
int                 gnutls_srp_verifier                 (const char *username,
                                                         const char *password,
                                                         const gnutls_datum_t *salt,
                                                         const gnutls_datum_t *generator,
                                                         const gnutls_datum_t *prime,
                                                         gnutls_datum_t *res);
extern              const gnutls_datum_t gnutls_srp_2048_group_prime;
extern              const gnutls_datum_t gnutls_srp_2048_group_generator;
extern              const gnutls_datum_t gnutls_srp_1536_group_prime;
extern              const gnutls_datum_t gnutls_srp_1536_group_generator;
extern              const gnutls_datum_t gnutls_srp_1024_group_prime;
extern              const gnutls_datum_t gnutls_srp_1024_group_generator;
void                gnutls_srp_set_server_credentials_function
                                                        (gnutls_srp_server_credentials_t cred,
                                                         gnutls_srp_server_credentials_function *func);
void                gnutls_srp_set_client_credentials_function
                                                        (gnutls_srp_client_credentials_t cred,
                                                         gnutls_srp_client_credentials_function *func);
int                 gnutls_srp_base64_encode            (const gnutls_datum_t *data,
                                                         char *result,
                                                         size_t *result_size);
int                 gnutls_srp_base64_encode_alloc      (const gnutls_datum_t *data,
                                                         gnutls_datum_t *result);
int                 gnutls_srp_base64_decode            (const gnutls_datum_t *b64_data,
                                                         char *result,
                                                         size_t *result_size);
int                 gnutls_srp_base64_decode_alloc      (const gnutls_datum_t *b64_data,
                                                         gnutls_datum_t *result);
enum                gnutls_psk_key_flags;
void                gnutls_psk_free_client_credentials  (gnutls_psk_client_credentials_tsc );
int                 gnutls_psk_allocate_client_credentials
                                                        (gnutls_psk_client_credentials_t *sc);
int                 gnutls_psk_set_client_credentials   (gnutls_psk_client_credentials_t res,
                                                         const char *username,
                                                         const gnutls_datum_t *key,
                                                         gnutls_psk_key_flags format);
void                gnutls_psk_free_server_credentials  (gnutls_psk_server_credentials_tsc );
int                 gnutls_psk_allocate_server_credentials
                                                        (gnutls_psk_server_credentials_t *sc);
int                 gnutls_psk_set_server_credentials_file
                                                        (gnutls_psk_server_credentials_tres ,
                                                         const char *password_file);
int                 gnutls_psk_set_server_credentials_hint
                                                        (gnutls_psk_server_credentials_t res,
                                                         const char *hint);
const char*         gnutls_psk_server_get_username      (gnutls_session_t session);
const char*         gnutls_psk_client_get_hint          (gnutls_session_t session);
void                gnutls_psk_set_server_credentials_function
                                                        (gnutls_psk_server_credentials_t cred,
                                                         gnutls_psk_server_credentials_function *func);
void                gnutls_psk_set_client_credentials_function
                                                        (gnutls_psk_client_credentials_t cred,
                                                         gnutls_psk_client_credentials_function *func);
int                 gnutls_hex_encode                   (const gnutls_datum_t *data,
                                                         char *result,
                                                         size_t *result_size);
int                 gnutls_hex_decode                   (const gnutls_datum_t *hex_data,
                                                         char *result,
                                                         size_t *result_size);
void                gnutls_psk_set_server_dh_params     (gnutls_psk_server_credentials_t res,
                                                         gnutls_dh_params_t dh_params);
void                gnutls_psk_set_server_params_function
                                                        (gnutls_psk_server_credentials_tres ,
                                                         gnutls_params_function *func);
int                 gnutls_psk_netconf_derive_key       (const char *password,
                                                         const char *psk_identity,
                                                         const char *psk_identity_hint,
                                                         gnutls_datum_t *output_key);
enum                gnutls_x509_subject_alt_name_t;
struct              gnutls_openpgp_crt_int;
typedef             gnutls_openpgp_crt_t;
struct              gnutls_openpgp_privkey_int;
typedef             gnutls_openpgp_privkey_t;
gnutls_credentials_type_t gnutls_auth_get_type          (gnutls_session_t session);
gnutls_credentials_type_t gnutls_auth_server_get_type   (gnutls_session_t session);
gnutls_credentials_type_t gnutls_auth_client_get_type   (gnutls_session_t session);
void                gnutls_dh_set_prime_bits            (gnutls_session_t session,
                                                         unsigned int bits);
int                 gnutls_dh_get_secret_bits           (gnutls_session_t session);
int                 gnutls_dh_get_peers_public_bits     (gnutls_session_t session);
int                 gnutls_dh_get_prime_bits            (gnutls_session_t session);
int                 gnutls_dh_get_group                 (gnutls_session_t session,
                                                         gnutls_datum_t *raw_gen,
                                                         gnutls_datum_t *raw_prime);
int                 gnutls_dh_get_pubkey                (gnutls_session_t session,
                                                         gnutls_datum_t *raw_key);
int                 gnutls_rsa_export_get_pubkey        (gnutls_session_t session,
                                                         gnutls_datum_t *exponent,
                                                         gnutls_datum_t *modulus);
int                 gnutls_rsa_export_get_modulus_bits  (gnutls_session_t session);
int                 (*gnutls_sign_func)                 (gnutls_session_t session,
                                                         void *userdata,
                                                         gnutls_certificate_type_t cert_type,
                                                         const gnutls_datum_t *cert,
                                                         const gnutls_datum_t *hash,
                                                         gnutls_datum_t *signature);
void                gnutls_sign_callback_set            (gnutls_session_t session,
                                                         gnutls_sign_func sign_func,
                                                         void *userdata);
gnutls_sign_func    gnutls_sign_callback_get            (gnutls_session_t session,
                                                         void **userdata);
void                gnutls_certificate_client_set_retrieve_function
                                                        (gnutls_certificate_credentials_t cred,
                                                         gnutls_certificate_client_retrieve_function *func);
void                gnutls_certificate_server_set_retrieve_function
                                                        (gnutls_certificate_credentials_t cred,
                                                         gnutls_certificate_server_retrieve_function *func);
void                gnutls_certificate_server_set_request
                                                        (gnutls_session_t session,
                                                         gnutls_certificate_request_treq );
const gnutls_datum_t* gnutls_certificate_get_peers      (gnutls_session_tsession ,
                                                         unsigned int *list_size);
const gnutls_datum_t* gnutls_certificate_get_ours       (gnutls_session_tsession );
time_t              gnutls_certificate_activation_time_peers
                                                        (gnutls_session_t session);
time_t              gnutls_certificate_expiration_time_peers
                                                        (gnutls_session_t session);
int                 gnutls_certificate_client_get_request_status
                                                        (gnutls_session_t session);
int                 gnutls_certificate_verify_peers2    (gnutls_session_t session,
                                                         unsigned int *status);
int                 gnutls_certificate_verify_peers     (gnutls_session_t session);
int                 gnutls_pem_base64_encode            (const char *msg,
                                                         const gnutls_datum_t *data,
                                                         char *result,
                                                         size_t *result_size);
int                 gnutls_pem_base64_decode            (const char *header,
                                                         const gnutls_datum_t *b64_data,
                                                         unsigned char *result,
                                                         size_t *result_size);
int                 gnutls_pem_base64_encode_alloc      (const char *msg,
                                                         const gnutls_datum_t *data,
                                                         gnutls_datum_t *result);
int                 gnutls_pem_base64_decode_alloc      (const char *header,
                                                         const gnutls_datum_t *b64_data,
                                                         gnutls_datum_t *result);
#define             GNUTLS_KEY_DIGITAL_SIGNATURE
#define             GNUTLS_KEY_NON_REPUDIATION
#define             GNUTLS_KEY_KEY_ENCIPHERMENT
#define             GNUTLS_KEY_DATA_ENCIPHERMENT
#define             GNUTLS_KEY_KEY_AGREEMENT
#define             GNUTLS_KEY_KEY_CERT_SIGN
#define             GNUTLS_KEY_CRL_SIGN
#define             GNUTLS_KEY_ENCIPHER_ONLY
#define             GNUTLS_KEY_DECIPHER_ONLY
void                gnutls_certificate_set_params_function
                                                        (gnutls_certificate_credentials_t res,
                                                         gnutls_params_function *func);
void                gnutls_anon_set_params_function     (gnutls_anon_server_credentials_t res,
                                                         gnutls_params_function *func);
void                gnutls_psk_set_params_function      (gnutls_psk_server_credentials_t res,
                                                         gnutls_params_function *func);
int                 gnutls_hex2bin                      (const char *hex_data,
                                                         size_t hex_size,
                                                         char *bin_data,
                                                         size_t *bin_size);
#define             GNUTLS_E_SUCCESS
#define             GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM
#define             GNUTLS_E_UNKNOWN_CIPHER_TYPE
#define             GNUTLS_E_LARGE_PACKET
#define             GNUTLS_E_UNSUPPORTED_VERSION_PACKET
#define             GNUTLS_E_UNEXPECTED_PACKET_LENGTH
#define             GNUTLS_E_INVALID_SESSION
#define             GNUTLS_E_FATAL_ALERT_RECEIVED
#define             GNUTLS_E_UNEXPECTED_PACKET
#define             GNUTLS_E_WARNING_ALERT_RECEIVED
#define             GNUTLS_E_ERROR_IN_FINISHED_PACKET
#define             GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET
#define             GNUTLS_E_UNKNOWN_CIPHER_SUITE
#define             GNUTLS_E_UNWANTED_ALGORITHM
#define             GNUTLS_E_MPI_SCAN_FAILED
#define             GNUTLS_E_DECRYPTION_FAILED
#define             GNUTLS_E_MEMORY_ERROR
#define             GNUTLS_E_DECOMPRESSION_FAILED
#define             GNUTLS_E_COMPRESSION_FAILED
#define             GNUTLS_E_AGAIN
#define             GNUTLS_E_EXPIRED
#define             GNUTLS_E_DB_ERROR
#define             GNUTLS_E_SRP_PWD_ERROR
#define             GNUTLS_E_INSUFFICIENT_CREDENTIALS
#define             GNUTLS_E_INSUFICIENT_CREDENTIALS
#define             GNUTLS_E_INSUFFICIENT_CRED
#define             GNUTLS_E_INSUFICIENT_CRED
#define             GNUTLS_E_HASH_FAILED
#define             GNUTLS_E_BASE64_DECODING_ERROR
#define             GNUTLS_E_MPI_PRINT_FAILED
#define             GNUTLS_E_REHANDSHAKE
#define             GNUTLS_E_GOT_APPLICATION_DATA
#define             GNUTLS_E_RECORD_LIMIT_REACHED
#define             GNUTLS_E_ENCRYPTION_FAILED
#define             GNUTLS_E_PK_ENCRYPTION_FAILED
#define             GNUTLS_E_PK_DECRYPTION_FAILED
#define             GNUTLS_E_PK_SIGN_FAILED
#define             GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION
#define             GNUTLS_E_KEY_USAGE_VIOLATION
#define             GNUTLS_E_NO_CERTIFICATE_FOUND
#define             GNUTLS_E_INVALID_REQUEST
#define             GNUTLS_E_SHORT_MEMORY_BUFFER
#define             GNUTLS_E_INTERRUPTED
#define             GNUTLS_E_PUSH_ERROR
#define             GNUTLS_E_PULL_ERROR
#define             GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER
#define             GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
#define             GNUTLS_E_PKCS1_WRONG_PAD
#define             GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION
#define             GNUTLS_E_INTERNAL_ERROR
#define             GNUTLS_E_DH_PRIME_UNACCEPTABLE
#define             GNUTLS_E_FILE_ERROR
#define             GNUTLS_E_TOO_MANY_EMPTY_PACKETS
#define             GNUTLS_E_UNKNOWN_PK_ALGORITHM
#define             GNUTLS_E_INIT_LIBEXTRA
#define             GNUTLS_E_LIBRARY_VERSION_MISMATCH
#define             GNUTLS_E_NO_TEMPORARY_RSA_PARAMS
#define             GNUTLS_E_LZO_INIT_FAILED
#define             GNUTLS_E_NO_COMPRESSION_ALGORITHMS
#define             GNUTLS_E_NO_CIPHER_SUITES
#define             GNUTLS_E_OPENPGP_GETKEY_FAILED
#define             GNUTLS_E_PK_SIG_VERIFY_FAILED
#define             GNUTLS_E_ILLEGAL_SRP_USERNAME
#define             GNUTLS_E_SRP_PWD_PARSING_ERROR
#define             GNUTLS_E_NO_TEMPORARY_DH_PARAMS
#define             GNUTLS_E_ASN1_ELEMENT_NOT_FOUND
#define             GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND
#define             GNUTLS_E_ASN1_DER_ERROR
#define             GNUTLS_E_ASN1_VALUE_NOT_FOUND
#define             GNUTLS_E_ASN1_GENERIC_ERROR
#define             GNUTLS_E_ASN1_VALUE_NOT_VALID
#define             GNUTLS_E_ASN1_TAG_ERROR
#define             GNUTLS_E_ASN1_TAG_IMPLICIT
#define             GNUTLS_E_ASN1_TYPE_ANY_ERROR
#define             GNUTLS_E_ASN1_SYNTAX_ERROR
#define             GNUTLS_E_ASN1_DER_OVERFLOW
#define             GNUTLS_E_OPENPGP_UID_REVOKED
#define             GNUTLS_E_CERTIFICATE_ERROR
#define             GNUTLS_E_X509_CERTIFICATE_ERROR
#define             GNUTLS_E_CERTIFICATE_KEY_MISMATCH
#define             GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE
#define             GNUTLS_E_X509_UNKNOWN_SAN
#define             GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED
#define             GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE
#define             GNUTLS_E_UNKNOWN_HASH_ALGORITHM
#define             GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE
#define             GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE
#define             GNUTLS_E_INVALID_PASSWORD
#define             GNUTLS_E_MAC_VERIFY_FAILED
#define             GNUTLS_E_CONSTRAINT_ERROR
#define             GNUTLS_E_WARNING_IA_IPHF_RECEIVED
#define             GNUTLS_E_WARNING_IA_FPHF_RECEIVED
#define             GNUTLS_E_IA_VERIFY_FAILED
#define             GNUTLS_E_UNKNOWN_ALGORITHM
#define             GNUTLS_E_BASE64_ENCODING_ERROR
#define             GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY
#define             GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY
#define             GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY
#define             GNUTLS_E_OPENPGP_KEYRING_ERROR
#define             GNUTLS_E_X509_UNSUPPORTED_OID
#define             GNUTLS_E_RANDOM_FAILED
#define             GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR
#define             GNUTLS_E_OPENPGP_SUBKEY_ERROR
#define             GNUTLS_E_CRYPTO_ALREADY_REGISTERED
#define             GNUTLS_E_HANDSHAKE_TOO_LARGE
#define             GNUTLS_E_UNIMPLEMENTED_FEATURE
#define             GNUTLS_E_APPLICATION_ERROR_MAX
#define             GNUTLS_E_APPLICATION_ERROR_MIN

Description

A longer description goes here.

Details

LIBGNUTLS_VERSION

#define LIBGNUTLS_VERSION "2.5.2"

LIBGNUTLS_VERSION_MAJOR

#define LIBGNUTLS_VERSION_MAJOR 2

LIBGNUTLS_VERSION_MINOR

#define LIBGNUTLS_VERSION_MINOR 5

LIBGNUTLS_VERSION_PATCH

#define LIBGNUTLS_VERSION_PATCH 2

LIBGNUTLS_VERSION_NUMBER

#define LIBGNUTLS_VERSION_NUMBER 0x020502

HAVE_SSIZE_T

# define HAVE_SSIZE_T

GNUTLS_CIPHER_RIJNDAEL_128_CBC

#define GNUTLS_CIPHER_RIJNDAEL_128_CBC GNUTLS_CIPHER_AES_128_CBC

GNUTLS_CIPHER_RIJNDAEL_256_CBC

#define GNUTLS_CIPHER_RIJNDAEL_256_CBC GNUTLS_CIPHER_AES_256_CBC

GNUTLS_CIPHER_RIJNDAEL_CBC

#define GNUTLS_CIPHER_RIJNDAEL_CBC GNUTLS_CIPHER_AES_128_CBC

GNUTLS_CIPHER_ARCFOUR

#define GNUTLS_CIPHER_ARCFOUR GNUTLS_CIPHER_ARCFOUR_128

enum gnutls_cipher_algorithm_t

  typedef enum gnutls_cipher_algorithm
  {
    GNUTLS_CIPHER_UNKNOWN = 0,
    GNUTLS_CIPHER_NULL = 1,
    GNUTLS_CIPHER_ARCFOUR_128,
    GNUTLS_CIPHER_3DES_CBC,
    GNUTLS_CIPHER_AES_128_CBC,
    GNUTLS_CIPHER_AES_256_CBC,
    GNUTLS_CIPHER_ARCFOUR_40,
    GNUTLS_CIPHER_CAMELLIA_128_CBC,
    GNUTLS_CIPHER_CAMELLIA_256_CBC,
    GNUTLS_CIPHER_RC2_40_CBC = 90,
    GNUTLS_CIPHER_DES_CBC,

    /* used only for PGP internals. Ignored in TLS/SSL 
     */
    GNUTLS_CIPHER_IDEA_PGP_CFB=200,
    GNUTLS_CIPHER_3DES_PGP_CFB,
    GNUTLS_CIPHER_CAST5_PGP_CFB,
    GNUTLS_CIPHER_BLOWFISH_PGP_CFB,
    GNUTLS_CIPHER_SAFER_SK128_PGP_CFB,
    GNUTLS_CIPHER_AES128_PGP_CFB,
    GNUTLS_CIPHER_AES192_PGP_CFB,
    GNUTLS_CIPHER_AES256_PGP_CFB,
    GNUTLS_CIPHER_TWOFISH_PGP_CFB,
  } gnutls_cipher_algorithm_t;

enum gnutls_kx_algorithm_t

  typedef enum
  {
    GNUTLS_KX_UNKNOWN = 0,
    GNUTLS_KX_RSA = 1,
    GNUTLS_KX_DHE_DSS,
    GNUTLS_KX_DHE_RSA,
    GNUTLS_KX_ANON_DH,
    GNUTLS_KX_SRP,
    GNUTLS_KX_RSA_EXPORT,
    GNUTLS_KX_SRP_RSA,
    GNUTLS_KX_SRP_DSS,
    GNUTLS_KX_PSK,
    GNUTLS_KX_DHE_PSK
  } gnutls_kx_algorithm_t;

enum gnutls_params_type_t

  typedef enum
  {
    GNUTLS_PARAMS_RSA_EXPORT = 1,
    GNUTLS_PARAMS_DH
  } gnutls_params_type_t;

enum gnutls_credentials_type_t

  typedef enum
  {
    GNUTLS_CRD_CERTIFICATE = 1,
    GNUTLS_CRD_ANON,
    GNUTLS_CRD_SRP,
    GNUTLS_CRD_PSK,
    GNUTLS_CRD_IA
  } gnutls_credentials_type_t;

GNUTLS_MAC_SHA

#define GNUTLS_MAC_SHA GNUTLS_MAC_SHA1

GNUTLS_DIG_SHA

#define GNUTLS_DIG_SHA GNUTLS_DIG_SHA1

enum gnutls_mac_algorithm_t

  typedef enum
  {
    GNUTLS_MAC_UNKNOWN = 0,
    GNUTLS_MAC_NULL = 1,
    GNUTLS_MAC_MD5,
    GNUTLS_MAC_SHA1,
    GNUTLS_MAC_RMD160,
    GNUTLS_MAC_MD2,
    GNUTLS_MAC_SHA256,
    GNUTLS_MAC_SHA384,
    GNUTLS_MAC_SHA512
    /* If you add anything here, make sure you align with
       gnutls_digest_algorithm_t, in particular SHA-224. */
  } gnutls_mac_algorithm_t;

enum gnutls_digest_algorithm_t

  typedef enum
  {
    GNUTLS_DIG_NULL = GNUTLS_MAC_NULL,
    GNUTLS_DIG_MD5 = GNUTLS_MAC_MD5,
    GNUTLS_DIG_SHA1 = GNUTLS_MAC_SHA1,
    GNUTLS_DIG_RMD160 = GNUTLS_MAC_RMD160,
    GNUTLS_DIG_MD2 = GNUTLS_MAC_MD2,
    GNUTLS_DIG_SHA256 = GNUTLS_MAC_SHA256,
    GNUTLS_DIG_SHA384 = GNUTLS_MAC_SHA384,
    GNUTLS_DIG_SHA512 = GNUTLS_MAC_SHA512,
    GNUTLS_DIG_SHA224
  } gnutls_digest_algorithm_t;

GNUTLS_MAX_ALGORITHM_NUM

#define GNUTLS_MAX_ALGORITHM_NUM 16

GNUTLS_COMP_ZLIB

#define GNUTLS_COMP_ZLIB GNUTLS_COMP_DEFLATE

enum gnutls_compression_method_t

  typedef enum
  {
    GNUTLS_COMP_UNKNOWN = 0,
    GNUTLS_COMP_NULL = 1,
    GNUTLS_COMP_DEFLATE,
    GNUTLS_COMP_LZO		/* only available if gnutls-extra has
				   been initialized
				 */
  } gnutls_compression_method_t;

enum gnutls_connection_end_t

  typedef enum
  {
    GNUTLS_SERVER = 1,
    GNUTLS_CLIENT
  } gnutls_connection_end_t;

enum gnutls_alert_level_t

  typedef enum
  {
    GNUTLS_AL_WARNING = 1,
    GNUTLS_AL_FATAL
  } gnutls_alert_level_t;

enum gnutls_alert_description_t

  typedef enum
  {
    GNUTLS_A_CLOSE_NOTIFY,
    GNUTLS_A_UNEXPECTED_MESSAGE = 10,
    GNUTLS_A_BAD_RECORD_MAC = 20,
    GNUTLS_A_DECRYPTION_FAILED,
    GNUT