commit 1c893a971fa8d04ada6c66aa9ebf525b03ed4426
parent 41886bcf92e8e6b943c9f0697a75f4a380952f52
Author: lv-426 <oxcafebaby@yahoo.com>
Date: Mon, 11 Aug 2008 03:40:22 +0000
gnutls code cleanup
symbol refactoring
Diffstat:
129 files changed, 3961 insertions(+), 6809 deletions(-)
diff --git a/src/daemon/connection.c b/src/daemon/connection.c
@@ -1648,7 +1648,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
#if HTTPS_SUPPORT
if (connection->daemon->options & MHD_USE_SSL)
{
- ret = gnutls_record_send (connection->tls_session,
+ ret = MHD_gnutls_record_send (connection->tls_session,
&connection->response->
data[connection->
response_write_position -
diff --git a/src/daemon/connection_https.c b/src/daemon/connection_https.c
@@ -55,7 +55,7 @@ int MHD_connection_handle_idle (struct MHD_Connection *connection);
static void
MHD_tls_connection_close (struct MHD_Connection *connection)
{
- gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
+ MHD_gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
connection->tls_session->internals.read_eof = 1;
SHUTDOWN (connection->socket_fd, SHUT_RDWR);
@@ -129,7 +129,7 @@ MHD_get_session_info (struct MHD_Connection *con, enum MHD_InfoType infoType)
static ssize_t
MHDS_con_read (struct MHD_Connection *connection)
{
- ssize_t size = gnutls_record_recv (connection->tls_session,
+ ssize_t size = MHD_gnutls_record_recv (connection->tls_session,
&connection->read_buffer[connection->
read_buffer_offset],
connection->read_buffer_size);
@@ -139,7 +139,7 @@ MHDS_con_read (struct MHD_Connection *connection)
static ssize_t
MHDS_con_write (struct MHD_Connection *connection)
{
- ssize_t sent = gnutls_record_send (connection->tls_session,
+ ssize_t sent = MHD_gnutls_record_send (connection->tls_session,
&connection->write_buffer[connection->
write_buffer_send_offset],
connection->write_buffer_append_offset
@@ -147,6 +147,16 @@ MHDS_con_write (struct MHD_Connection *connection)
return sent;
}
+/**
+ * This function was created to handle per-connection processing that
+ * has to happen even if the socket cannot be read or written to. All
+ * implementations (multithreaded, external select, internal select)
+ * call this function.
+ *
+ * @param connection being handled
+ * @return MHD_YES if we should continue to process the
+ * connection (not dead yet), MHD_NO if it died
+ */
int
MHD_tls_connection_handle_idle (struct MHD_Connection *connection)
{
@@ -236,7 +246,7 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
if (connection->state == MHD_TLS_CONNECTION_INIT ||
connection->state == MHD_TLS_HELLO_REQUEST)
{
- ret = gnutls_handshake (connection->tls_session);
+ ret = MHD_gnutls_handshake (connection->tls_session);
if (ret == 0)
{
/* set connection state to enable HTTP processing */
@@ -274,10 +284,10 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
case GNUTLS_ALERT:
/*
- * this call of _gnutls_recv_int expects 0 bytes read.
+ * this call of mhd_gtls_recv_int expects 0 bytes read.
* done to decrypt alert message
*/
- _gnutls_recv_int (connection->tls_session, GNUTLS_ALERT,
+ mhd_gtls_recv_int (connection->tls_session, GNUTLS_ALERT,
GNUTLS_HANDSHAKE_FINISHED, 0, 0);
/* CLOSE_NOTIFY */
@@ -294,7 +304,7 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
#if HAVE_MESSAGES
MHD_DLOG (connection->daemon,
"Received TLS alert: %s\n",
- gnutls_alert_get_name ((int) connection->tls_session->
+ MHD_gnutls_alert_get_name ((int) connection->tls_session->
internals.last_alert));
#endif
return MHD_YES;
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
@@ -88,7 +88,7 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
CLOSE (daemon->socket_fd);
return -1;
}
- return gnutls_certificate_set_x509_key_file (daemon->x509_cred,
+ return MHD_gnutls_certificate_set_x509_key_file (daemon->x509_cred,
daemon->https_cert_path,
daemon->https_key_path,
GNUTLS_X509_FMT_PEM);
@@ -101,7 +101,7 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
cert.data = (unsigned char *) daemon->https_mem_cert;
cert.size = strlen (daemon->https_mem_cert);
- return gnutls_certificate_set_x509_key_mem (daemon->x509_cred, &cert,
+ return MHD_gnutls_certificate_set_x509_key_mem (daemon->x509_cred, &cert,
&key, GNUTLS_X509_FMT_PEM);
}
else
@@ -122,16 +122,16 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
switch (daemon->cred_type)
{
case MHD_GNUTLS_CRD_ANON:
- ret = gnutls_anon_allocate_server_credentials (&daemon->anon_cred);
- ret += gnutls_dh_params_init (&daemon->dh_params);
+ ret = MHD_gnutls_anon_allocate_server_credentials (&daemon->anon_cred);
+ ret += MHD_gnutls_dh_params_init (&daemon->dh_params);
if (ret != 0) {
return GNUTLS_E_MEMORY_ERROR;
}
- gnutls_dh_params_generate2 (daemon->dh_params, 1024);
- gnutls_anon_set_server_dh_params (daemon->anon_cred, daemon->dh_params);
+ MHD_gnutls_dh_params_generate2 (daemon->dh_params, 1024);
+ MHD_gnutls_anon_set_server_dh_params (daemon->anon_cred, daemon->dh_params);
break;
case MHD_GNUTLS_CRD_CERTIFICATE:
- ret = gnutls_certificate_allocate_credentials (&daemon->x509_cred) ;
+ ret = MHD_gnutls_certificate_allocate_credentials (&daemon->x509_cred) ;
if (ret != 0) {
return GNUTLS_E_MEMORY_ERROR;
}
@@ -150,7 +150,7 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
}
inline static int
-_set_priority (priority_st * st, const int *list)
+_set_priority (mhd_gtls_priority_st * st, const int *list)
{
int num = 0, i;
@@ -322,23 +322,23 @@ MHD_TLS_init_connection (void *data)
/* initialize connection state */
con->state = MHD_TLS_CONNECTION_INIT;
- gnutls_init (&con->tls_session, GNUTLS_SERVER);
+ MHD_gnutls_init (&con->tls_session, GNUTLS_SERVER);
/* sets cipher priorities */
- gnutls_priority_set (con->tls_session, con->daemon->priority_cache);
+ MHD_gnutls_priority_set (con->tls_session, con->daemon->priority_cache);
switch (con->daemon->cred_type)
{
/* set needed credentials for certificate authentication. */
case MHD_GNUTLS_CRD_CERTIFICATE:
- gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_CERTIFICATE,
+ MHD_gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_CERTIFICATE,
con->daemon->x509_cred);
break;
case MHD_GNUTLS_CRD_ANON:
/* set needed credentials for anonymous authentication. */
- gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_ANON,
+ MHD_gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_ANON,
con->daemon->anon_cred);
- gnutls_dh_set_prime_bits (con->tls_session, 1024);
+ MHD_gnutls_dh_set_prime_bits (con->tls_session, 1024);
break;
default:
@@ -351,11 +351,11 @@ MHD_TLS_init_connection (void *data)
}
/* TODO avoid gnutls blocking recv / write calls
- gnutls_transport_set_pull_function(tls_session, &recv);
- gnutls_transport_set_push_function(tls_session, &send);
+ MHD_gnutls_transport_set_pull_function(tls_session, &recv);
+ MHD_gnutls_transport_set_push_function(tls_session, &send);
*/
- gnutls_transport_set_ptr (con->tls_session,
+ MHD_gnutls_transport_set_ptr (con->tls_session,
(gnutls_transport_ptr_t) ((void *) con->
socket_fd));
@@ -580,7 +580,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
#if HTTPS_SUPPORT
if (pos->tls_session != 0)
{
- gnutls_deinit (pos->tls_session);
+ MHD_gnutls_deinit (pos->tls_session);
}
#endif
free (pos->addr);
@@ -839,6 +839,7 @@ MHD_start_daemon_va (unsigned int options,
if ((options & MHD_USE_IPv6) != 0)
{
memset (&servaddr6, 0, sizeof (struct sockaddr_in6));
+ /* todo impl IPv6 address setting */
servaddr6.sin6_family = AF_INET6;
servaddr6.sin6_port = htons (port);
servaddr = (struct sockaddr *) &servaddr6;
@@ -847,6 +848,7 @@ MHD_start_daemon_va (unsigned int options,
else
{
memset (&servaddr4, 0, sizeof (struct sockaddr_in));
+ inet_pton (AF_INET, ip, &servaddr4.sin_addr);
servaddr4.sin_family = AF_INET;
servaddr4.sin_port = htons (port);
servaddr = (struct sockaddr *) &servaddr4;
@@ -899,10 +901,10 @@ MHD_start_daemon_va (unsigned int options,
{
/* lock gnutls_global mutex since it uses reference counting */
pthread_mutex_lock (&gnutls_init_mutex);
- gnutls_global_init ();
+ MHD_gnutls_global_init ();
pthread_mutex_unlock (&gnutls_init_mutex);
/* set default priorities */
- gnutls_priority_init (&retVal->priority_cache, "", NULL);
+ MHD_tls_set_default_priority (&retVal->priority_cache, "", NULL);
retVal->cred_type = MHD_GNUTLS_CRD_CERTIFICATE;
}
#endif
@@ -1119,10 +1121,10 @@ MHD_start_daemon (unsigned int options,
{
/* lock gnutls_global mutex since it uses reference counting */
pthread_mutex_lock (&gnutls_init_mutex);
- gnutls_global_init ();
+ MHD_gnutls_global_init ();
pthread_mutex_unlock (&gnutls_init_mutex);
/* set default priorities */
- gnutls_priority_init (&retVal->priority_cache, "", NULL);
+ MHD_tls_set_default_priority (&retVal->priority_cache, "", NULL);
retVal->cred_type = MHD_GNUTLS_CRD_CERTIFICATE;
}
#endif
@@ -1320,16 +1322,16 @@ MHD_stop_daemon (struct MHD_Daemon *daemon)
#if HTTPS_SUPPORT
if (daemon->options & MHD_USE_SSL)
{
- gnutls_priority_deinit (daemon->priority_cache);
+ MHD_gnutls_priority_deinit (daemon->priority_cache);
if (daemon->x509_cred)
- gnutls_certificate_free_credentials (daemon->x509_cred);
+ MHD_gnutls_certificate_free_credentials (daemon->x509_cred);
if (daemon->anon_cred)
- gnutls_anon_free_server_credentials (daemon->anon_cred);
+ MHD_gnutls_anon_free_server_credentials (daemon->anon_cred);
/* lock gnutls_global mutex since it uses reference counting */
pthread_mutex_lock (&gnutls_init_mutex);
- gnutls_global_deinit ();
+ MHD_gnutls_global_deinit ();
pthread_mutex_unlock (&gnutls_init_mutex);
}
#endif
diff --git a/src/daemon/https/compat.h b/src/daemon/https/compat.h
@@ -40,7 +40,7 @@
#define gnutls_openpgp_key_status gnutls_openpgp_key_status_t
#define gnutls_certificate_request gnutls_certificate_request_t
#define gnutls_certificate_status gnutls_certificate_status_t
-#define gnutls_session gnutls_session_t
+#define gnutls_session mhd_gtls_session_t
#define gnutls_alert_level gnutls_alert_level_t
#define gnutls_alert_description gnutls_alert_description_t
#define gnutls_x509_subject_alt_name gnutls_x509_subject_alt_name_t
@@ -56,13 +56,13 @@
#define gnutls_pkcs12_bag_type gnutls_pkcs12_bag_type_t
#define gnutls_pkcs12_bag gnutls_pkcs12_bag_t
#define gnutls_pkcs12 gnutls_pkcs12_t
-#define gnutls_certificate_credentials gnutls_certificate_credentials_t
-#define gnutls_anon_server_credentials gnutls_anon_server_credentials_t
-#define gnutls_anon_client_credentials gnutls_anon_client_credentials_t
+#define gnutls_certificate_credentials mhd_gtls_cert_credentials_t
+#define gnutls_anon_server_credentials mhd_gtls_anon_server_credentials_t
+#define gnutls_anon_client_credentials mhd_gtls_anon_client_credentials_t
#define gnutls_srp_client_credentials gnutls_srp_client_credentials_t
#define gnutls_srp_server_credentials gnutls_srp_server_credentials_t
-#define gnutls_dh_params gnutls_dh_params_t
-#define gnutls_rsa_params gnutls_rsa_params_t
+#define gnutls_dh_params mhd_gtls_dh_params_t
+#define gnutls_rsa_params mhd_gtls_rsa_params_t
#define gnutls_params_type gnutls_params_type_t
#define gnutls_credentials_type gnutls_credentials_type_t
#define gnutls_certificate_type gnutls_certificate_type_t
@@ -78,7 +78,7 @@
#define gnutls_openpgp_key_fmt_t gnutls_openpgp_crt_fmt_t
#define GNUTLS_OPENPGP_KEY GNUTLS_OPENPGP_CERT
#define GNUTLS_OPENPGP_KEY_FINGERPRINT GNUTLS_OPENPGP_CERT_FINGERPRINT
-#define gnutls_openpgp_send_key gnutls_openpgp_send_cert
+#define gnutls_openpgp_send_key MHD_gtls_openpgp_send_cert
#define gnutls_openpgp_key_status_t gnutls_openpgp_crt_status_t
#define gnutls_openpgp_key_t gnutls_openpgp_crt_t
#define gnutls_openpgp_key_init gnutls_openpgp_crt_init
diff --git a/src/daemon/https/extra.h b/src/daemon/https/extra.h
@@ -47,7 +47,7 @@ extern "C"
} gnutls_openpgp_crt_fmt_t;
/**
- * gnutls_openpgp_recv_key_func - Callback prototype to get OpenPGP keys
+ * mhd_gtls_openpgp_recv_key_func - Callback prototype to get OpenPGP keys
* @session: a TLS session
* @keyfpr: key fingerprint
* @keyfpr_length: length of key fingerprint
@@ -59,32 +59,32 @@ extern "C"
* gnutls_openpgp_set_recv_key_function().
*
*/
- typedef int (*gnutls_openpgp_recv_key_func) (gnutls_session_t session,
+ typedef int (*mhd_gtls_openpgp_recv_key_func) (mhd_gtls_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
+ void gnutls_openpgp_set_recv_key_function (mhd_gtls_session_t session,
+ mhd_gtls_openpgp_recv_key_func
func);
int
- gnutls_certificate_set_openpgp_key_file (gnutls_certificate_credentials_t
+ gnutls_certificate_set_openpgp_key_file (mhd_gtls_cert_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
+ int gnutls_certificate_set_openpgp_key_mem (mhd_gtls_cert_credentials_t
res,
const gnutls_datum_t * CERT,
const gnutls_datum_t * KEY, gnutls_openpgp_crt_fmt_t);
int
gnutls_certificate_set_openpgp_keyring_mem
- (gnutls_certificate_credentials_t c, const unsigned char *data,
+ (mhd_gtls_cert_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);
+ (mhd_gtls_cert_credentials_t c, const char *file, gnutls_openpgp_crt_fmt_t);
/* TLS/IA stuff
*/
@@ -99,7 +99,7 @@ extern "C"
/* TLS/IA credential
*/
- typedef int (*gnutls_ia_avp_func) (gnutls_session_t session, void *ptr,
+ typedef int (*gnutls_ia_avp_func) (mhd_gtls_session_t session, void *ptr,
const char *last, size_t lastlen,
char **next, size_t * nextlen);
@@ -142,35 +142,35 @@ extern "C"
cred);
/* TLS/IA handshake. */
- extern int gnutls_ia_handshake_p (gnutls_session_t session);
+ extern int gnutls_ia_handshake_p (mhd_gtls_session_t session);
- extern int gnutls_ia_handshake (gnutls_session_t session);
+ extern int gnutls_ia_handshake (mhd_gtls_session_t session);
/* TLS/IA low level interface. */
extern int
- gnutls_ia_permute_inner_secret (gnutls_session_t session,
+ gnutls_ia_permute_inner_secret (mhd_gtls_session_t session,
size_t session_keys_size,
const char *session_keys);
- extern int gnutls_ia_endphase_send (gnutls_session_t session,
+ extern int gnutls_ia_endphase_send (mhd_gtls_session_t session,
int final_p);
- extern int gnutls_ia_verify_endphase (gnutls_session_t session,
+ extern int gnutls_ia_verify_endphase (mhd_gtls_session_t session,
const char *checksum);
- extern ssize_t gnutls_ia_send (gnutls_session_t session,
+ extern ssize_t gnutls_ia_send (mhd_gtls_session_t session,
const char *data, size_t sizeofdata);
- extern ssize_t gnutls_ia_recv (gnutls_session_t session,
+ extern ssize_t gnutls_ia_recv (mhd_gtls_session_t session,
char *data, size_t sizeofdata);
/* Utility stuff. */
- extern int gnutls_ia_generate_challenge (gnutls_session_t session,
+ extern int gnutls_ia_generate_challenge (mhd_gtls_session_t session,
size_t buffer_size,
char *buffer);
- extern void gnutls_ia_extract_inner_secret (gnutls_session_t session,
+ extern void gnutls_ia_extract_inner_secret (mhd_gtls_session_t session,
char *buffer);
/* Define whether inner phases are wanted. */
- extern void gnutls_ia_enable (gnutls_session_t session,
+ extern void gnutls_ia_enable (mhd_gtls_session_t session,
int allow_skip_on_resume);
int gnutls_global_init_extra (void);
diff --git a/src/daemon/https/gnutls.h b/src/daemon/https/gnutls.h
@@ -42,21 +42,8 @@ extern "C"
#define LIBGNUTLS_VERSION "2.2.3"
-#define LIBGNUTLS_VERSION_MAJOR 2
-#define LIBGNUTLS_VERSION_MINOR 2
-#define LIBGNUTLS_VERSION_PATCH 3
-
-#define LIBGNUTLS_VERSION_NUMBER 0x020203
-
/* Get size_t. */
#include <stddef.h>
-/* Get ssize_t. */
-#ifndef HAVE_SSIZE_T
-# define HAVE_SSIZE_T
-#include <sys/types.h>
-#endif
-/* Get time_t. */
-#include <time.h>
#include <compat.h>
#define GNUTLS_CIPHER_RIJNDAEL_128_CBC GNUTLS_CIPHER_AES_128_CBC
@@ -64,6 +51,10 @@ extern "C"
#define GNUTLS_CIPHER_RIJNDAEL_CBC GNUTLS_CIPHER_AES_128_CBC
#define GNUTLS_CIPHER_ARCFOUR GNUTLS_CIPHER_ARCFOUR_128
+#define GNUTLS_MAX_SESSION_ID 32
+#define TLS_MASTER_SIZE 48
+#define TLS_RANDOM_SIZE 32
+
#include "microhttpd.h"
typedef enum
@@ -72,11 +63,6 @@ extern "C"
GNUTLS_PARAMS_DH
} gnutls_params_type_t;
-/* TODO clean
-#define GNUTLS_MAC_SHA GNUTLS_MAC_SHA1
-#define GNUTLS_DIG_SHA GNUTLS_DIG_SHA1
-*/
-
/* exported for other gnutls headers. This is the maximum number of
* algorithms (ciphers, kx or macs).
*/
@@ -148,11 +134,11 @@ extern "C"
*/
typedef enum
{
- GNUTLS_CERT_INVALID = 2, /* will be set if the certificate
- * was not verified.
- */
- GNUTLS_CERT_REVOKED = 32, /* in X.509 this will be set only if CRLs are checked
- */
+ GNUTLS_CERT_INVALID = 2, /* will be set if the certificate
+ * was not verified.
+ */
+ GNUTLS_CERT_REVOKED = 32, /* in X.509 this will be set only if CRLs are checked
+ */
/* Those are extra information about the verification
* process. Will be set only if the certificate was
@@ -187,10 +173,6 @@ extern "C"
GNUTLS_X509_FMT_PEM
} gnutls_x509_crt_fmt_t;
- const char *gnutls_pk_algorithm_get_name (gnutls_pk_algorithm_t algorithm);
-
-#define GNUTLS_SIGN_RSA_SHA GNUTLS_SIGN_RSA_SHA1
-#define GNUTLS_SIGN_DSA_SHA GNUTLS_SIGN_DSA_SHA1
typedef enum
{
GNUTLS_SIGN_UNKNOWN = 0,
@@ -204,25 +186,22 @@ extern "C"
GNUTLS_SIGN_RSA_SHA512
} gnutls_sign_algorithm_t;
- const char *gnutls_sign_algorithm_get_name (gnutls_sign_algorithm_t
- algorithm);
-
/* If you want to change this, then also change the define in
* gnutls_int.h, and recompile.
*/
- typedef void * gnutls_transport_ptr_t;
+ typedef void *gnutls_transport_ptr_t;
- struct gnutls_session_int;
- typedef struct gnutls_session_int * gnutls_session_t;
+ struct MHD_gtls_session_int;
+ typedef struct MHD_gtls_session_int * mhd_gtls_session_t;
- struct gnutls_dh_params_int;
- typedef struct gnutls_dh_params_int *gnutls_dh_params_t;
+ struct MHD_gtls_dh_params_int;
+ typedef struct MHD_gtls_dh_params_int * mhd_gtls_dh_params_t;
- struct gnutls_x509_privkey_int; /* XXX ugly. */
- typedef struct gnutls_x509_privkey_int *gnutls_rsa_params_t; /* XXX ugly. */
+ struct MHD_gtls_x509_privkey_int; /* XXX ugly. */
+ typedef struct MHD_gtls_x509_privkey_int * mhd_gtls_rsa_params_t; /* XXX ugly. */
- struct gnutls_priority_st;
- typedef struct gnutls_priority_st * gnutls_priority_t;
+ struct MHD_gtls_priority_st;
+ typedef struct MHD_gtls_priority_st *gnutls_priority_t;
typedef struct
{
@@ -236,387 +215,330 @@ extern "C"
gnutls_params_type_t type;
union params
{
- gnutls_dh_params_t dh;
- gnutls_rsa_params_t rsa_export;
+ mhd_gtls_dh_params_t dh;
+ mhd_gtls_rsa_params_t rsa_export;
} params;
int deinit;
} gnutls_params_st;
- typedef int gnutls_params_function (gnutls_session_t, gnutls_params_type_t,
- gnutls_params_st *);
+ typedef int gnutls_params_function (mhd_gtls_session_t, gnutls_params_type_t,
+ gnutls_params_st *);
/* internal functions */
-
- int gnutls_init (gnutls_session_t * session,
- gnutls_connection_end_t con_end);
- void gnutls_deinit (gnutls_session_t session);
-#define _gnutls_deinit(x) gnutls_deinit(x)
-
- 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);
-
-/* get information on the current session */
- 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_t
- session);
- gnutls_certificate_type_t gnutls_certificate_type_get (gnutls_session_t
- session);
-
- size_t gnutls_cipher_get_key_size (gnutls_cipher_algorithm_t algorithm);
- size_t gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm);
+ int MHD_gnutls_global_init (void);
+ void MHD_gnutls_global_deinit (void);
+
+ int MHD_gnutls_init (mhd_gtls_session_t * session,
+ gnutls_connection_end_t con_end);
+ void MHD_gnutls_deinit (mhd_gtls_session_t session);
+
+ int MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how);
+ int MHD_gnutls_handshake (mhd_gtls_session_t session);
+ int MHD_gnutls_rehandshake (mhd_gtls_session_t session);
+ gnutls_alert_description_t gnutls_alert_get (mhd_gtls_session_t session);
+ int MHD_gnutls_alert_send (mhd_gtls_session_t session,
+ gnutls_alert_level_t level,
+ gnutls_alert_description_t desc);
+ int MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err);
+ const char * MHD_gnutls_alert_get_name (gnutls_alert_description_t alert);
+
+// gnutls_cipher_algorithm_t gnutls_cipher_get (mhd_gtls_session_t session);
+// gnutls_kx_algorithm_t gnutls_kx_get (mhd_gtls_session_t session);
+// gnutls_mac_algorithm_t gnutls_mac_get (mhd_gtls_session_t session);
+// gnutls_compression_method_t gnutls_compression_get (mhd_gtls_session_t
+// session);
+// gnutls_certificate_type_t gnutls_certificate_type_get (mhd_gtls_session_t
+// session);
+
+ size_t MHD_gnutls_cipher_get_key_size (gnutls_cipher_algorithm_t algorithm);
+ size_t MHD_gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm);
/* the name of the specified algorithms */
- 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_t
- algorithm);
- const char *gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm);
- const char *gnutls_certificate_type_get_name (gnutls_certificate_type_t
- type);
-
- 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 char * MHD_gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm);
+ const char * MHD_gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm);
+ const char * MHD_gnutls_compression_get_name (gnutls_compression_method_t
+ algorithm);
+ const char * MHD_gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm);
+ const char * MHD_gnutls_certificate_type_get_name (gnutls_certificate_type_t
+ type);
+
+ gnutls_mac_algorithm_t MHD_gtls_mac_get_id (const char *name);
+ gnutls_compression_method_t MHD_gtls_compression_get_id (const char *name);
+ gnutls_cipher_algorithm_t MHD_gtls_cipher_get_id (const char *name);
+ gnutls_kx_algorithm_t MHD_gtls_kx_get_id (const char *name);
+ gnutls_protocol_t MHD_gtls_protocol_get_id (const char *name);
+ gnutls_certificate_type_t MHD_gtls_certificate_type_get_id (const char *name);
/* list supported algorithms */
- 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);
+ const gnutls_cipher_algorithm_t * MHD_gtls_cipher_list (void);
+ const gnutls_mac_algorithm_t * MHD_gtls_mac_list (void);
+ const gnutls_compression_method_t * MHD_gtls_compression_list (void);
+ const gnutls_protocol_t * MHD_gtls_protocol_list (void);
+ const gnutls_certificate_type_t * MHD_gtls_certificate_type_list (void);
+ const gnutls_kx_algorithm_t * MHD_gtls_kx_list (void);
/* error functions */
- 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);
-
-/* Semi-internal functions.
- */
- 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);
-
-/* Record layer functions.
+ int MHD_gtls_error_is_fatal (int error);
+ int MHD_gtls_error_to_alert (int err, int *level);
+ void MHD_gtls_perror (int error);
+ const char * MHD_gtls_strerror (int error);
+
+ void MHD_gtls_handshake_set_private_extensions (mhd_gtls_session_t session,
+ int allow);
+ gnutls_handshake_description_t
+ MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session);
+ gnutls_handshake_description_t
+ MHD_gtls_handshake_get_last_in (mhd_gtls_session_t session);
+
+/*
+ * Record layer functions.
*/
- 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 gnutls_record_recv
-#define gnutls_write gnutls_record_send
+ ssize_t MHD_gnutls_record_send (mhd_gtls_session_t session, const void *data,
+ size_t sizeofdata);
+ ssize_t MHD_gnutls_record_recv (mhd_gtls_session_t session, void *data,
+ size_t sizeofdata);
- void gnutls_session_enable_compatibility_mode (gnutls_session_t session);
+ /* provides extra compatibility */
+ void MHD_gtls_record_disable_padding (mhd_gtls_session_t session);
+ size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
- void gnutls_record_disable_padding (gnutls_session_t session);
+ int MHD_gnutls_record_get_direction (mhd_gtls_session_t session);
+ size_t MHD_gnutls_record_get_max_size (mhd_gtls_session_t session);
+ ssize_t MHD_gnutls_record_set_max_size (mhd_gtls_session_t session, size_t size);
- 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);
+ int MHD_gnutls_prf (mhd_gtls_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);
- 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);
-
-/* TLS Extensions */
+ int MHD_gnutls_prf_raw (mhd_gtls_session_t session,
+ size_t label_size, const char *label,
+ size_t seed_size, const char *seed,
+ size_t outsize, char *out);
+/*
+ * TLS Extensions
+ */
typedef enum
{
GNUTLS_NAME_DNS = 1
} 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 MHD_gnutls_server_name_set (mhd_gtls_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);
+ int MHD_gnutls_server_name_get (mhd_gtls_session_t session,
+ void *data, size_t * data_length,
+ unsigned int *type, unsigned int indx);
/* Opaque PRF Input
* http://tools.ietf.org/id/draft-rescorla-tls-opaque-prf-input-00.txt
*/
void
- gnutls_oprfi_enable_client (gnutls_session_t session,
- size_t len,
- unsigned char *data);
+ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
+ size_t len, unsigned char *data);
- typedef int (*gnutls_oprfi_callback_func) (gnutls_session_t session,
- void *userdata,
- size_t oprfi_len,
- const unsigned char *in_oprfi,
- unsigned char *out_oprfi);
+ typedef int (*gnutls_oprfi_callback_func) (mhd_gtls_session_t session,
+ void *userdata,
+ size_t oprfi_len,
+ const unsigned char *in_oprfi,
+ unsigned char *out_oprfi);
void
- gnutls_oprfi_enable_server (gnutls_session_t session,
- gnutls_oprfi_callback_func cb,
- void *userdata);
+ MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
+ gnutls_oprfi_callback_func cb,
+ void *userdata);
/* Supplemental data, RFC 4680. */
typedef enum
- {
- GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
- } gnutls_supplemental_data_format_type_t;
-
- const char *gnutls_supplemental_get_name
- (gnutls_supplemental_data_format_type_t type);
-
-/* functions to set priority of cipher suites
- */
- 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);
-
-/* if you just want some defaults, use the following.
- */
- 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);
-
- /* for compatibility
- */
- int gnutls_set_default_priority (gnutls_session_t session);
- int gnutls_set_default_export_priority (gnutls_session_t session);
-
-/* Returns the name of a cipher suite */
- const char *gnutls_cipher_suite_get_name (gnutls_kx_algorithm_t
- kx_algorithm,
- gnutls_cipher_algorithm_t
- cipher_algorithm,
- gnutls_mac_algorithm_t
- mac_algorithm);
+ {
+ GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
+ } gnutls_supplemental_data_format_type_t;
+
+ const char * MHD_gtls_supplemental_get_name
+ (gnutls_supplemental_data_format_type_t type);
+
+ int MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session, const int *list);
+ int MHD_gnutls_mac_set_priority (mhd_gtls_session_t session, const int *list);
+ int MHD_gnutls_compression_set_priority (mhd_gtls_session_t session,
+ const int *list);
+ int MHD_gnutls_kx_set_priority (mhd_gtls_session_t session, const int *list);
+ int MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session,
+ const int *list);
+ int MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
+ const int *list);
+
+ int MHD_tls_set_default_priority (gnutls_priority_t *, const char *priority,
+ const char **err_pos);
+ void MHD_gnutls_priority_deinit (gnutls_priority_t);
+
+ int MHD_gnutls_priority_set (mhd_gtls_session_t session, gnutls_priority_t);
+ int MHD_gnutls_priority_set_direct (mhd_gtls_session_t session,
+ const char *priority, const char **err_pos);
/* get the currently used protocol version */
- gnutls_protocol_t gnutls_protocol_get_version (gnutls_session_t session);
-
- const char *gnutls_protocol_get_name (gnutls_protocol_t version);
+ gnutls_protocol_t MHD_gnutls_protocol_get_version (mhd_gtls_session_t session);
+ const char * MHD_gnutls_protocol_get_name (gnutls_protocol_t version);
-/* get/set session
+/*
+ * get/set session
*/
- 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);
-
-/* returns the session ID */
-#define GNUTLS_MAX_SESSION_ID 32
- int gnutls_session_get_id (gnutls_session_t session, void *session_id,
- size_t * session_id_size);
+// int gnutls_session_set_data (mhd_gtls_session_t session,
+// const void *session_data,
+// size_t session_data_size);
+// int gnutls_session_get_data (mhd_gtls_session_t session, void *session_data,
+// size_t * session_data_size);
+// int gnutls_session_get_data2 (mhd_gtls_session_t session,
+// gnutls_datum_t * data);
+
+ int MHD_gtls_session_get_id (mhd_gtls_session_t session, void *session_id,
+ size_t * session_id_size);
/* returns security values.
* Do not use them unless you know what you're doing.
*/
-#define TLS_MASTER_SIZE 48
-#define TLS_RANDOM_SIZE 32
- 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);
+ const void * MHD_gtls_session_get_server_random (mhd_gtls_session_t session);
+ const void * MHD_gtls_session_get_client_random (mhd_gtls_session_t session);
+ const void * MHD_gtls_session_get_master_secret (mhd_gtls_session_t session);
-/* checks if this session is a resumed one
- */
- int gnutls_session_is_resumed (gnutls_session_t session);
-
- typedef int (*gnutls_db_store_func) (void *, gnutls_datum_t key,
- gnutls_datum_t data);
- typedef int (*gnutls_db_remove_func) (void *, gnutls_datum_t key);
- typedef 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);
-
- typedef 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);
-
-/* Functions for setting/clearing credentials
- */
- void gnutls_credentials_clear (gnutls_session_t session);
-
-/* cred is a structure defined by the kx algorithm
- */
- int gnutls_credentials_set (gnutls_session_t session,
- gnutls_credentials_type_t type, void *cred);
-#define gnutls_cred_set gnutls_credentials_set
+ int MHD_gtls_session_is_resumed (mhd_gtls_session_t session);
-/* Credential structures - used in gnutls_credentials_set(); */
+ typedef int (*gnutls_handshake_post_client_hello_func) (mhd_gtls_session_t);
+ void MHD_gnutls_handshake_set_post_client_hello_function (mhd_gtls_session_t,
+ gnutls_handshake_post_client_hello_func);
- struct gnutls_certificate_credentials_st;
- typedef struct gnutls_certificate_credentials_st
- *gnutls_certificate_credentials_t;
- typedef gnutls_certificate_credentials_t
- gnutls_certificate_server_credentials;
- typedef gnutls_certificate_credentials_t
- gnutls_certificate_client_credentials;
+ void MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session,
+ size_t max);
- typedef struct gnutls_anon_server_credentials_st
- *gnutls_anon_server_credentials_t;
- typedef struct gnutls_anon_client_credentials_st
- *gnutls_anon_client_credentials_t;
+/*
+ * Functions for setting/clearing credentials
+ */
+ void MHD_gnutls_credentials_clear (mhd_gtls_session_t session);
- void gnutls_anon_free_server_credentials (gnutls_anon_server_credentials_t sc);
- int gnutls_anon_allocate_server_credentials (gnutls_anon_server_credentials_t * sc);
+/*
+ * cred is a structure defined by the kx algorithm
+ */
+ int MHD_gnutls_credentials_set (mhd_gtls_session_t session,
+ gnutls_credentials_type_t type, void *cred);
+
+/* Credential structures - used in MHD_gnutls_credentials_set(); */
+ struct mhd_gtls_certificate_credentials_st;
+ typedef struct mhd_gtls_certificate_credentials_st
+ * mhd_gtls_cert_credentials_t;
+ typedef mhd_gtls_cert_credentials_t
+ mhd_gtls_cert_server_credentials;
+ typedef mhd_gtls_cert_credentials_t
+ mhd_gtls_cert_client_credentials;
+
+ typedef struct mhd_gtls_anon_server_credentials_st
+ * mhd_gtls_anon_server_credentials_t;
+ typedef struct mhd_gtls_anon_client_credentials_st
+ * mhd_gtls_anon_client_credentials_t;
+
+ void MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t
+ sc);
+ int
+ MHD_gnutls_anon_allocate_server_credentials (mhd_gtls_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 MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
+ mhd_gtls_dh_params_t dh_params);
void
- gnutls_anon_set_server_params_function (gnutls_anon_server_credentials_t
- res,
- gnutls_params_function * func);
+ MHD_gnutls_anon_set_server_params_function (mhd_gtls_anon_server_credentials_t
+ res,
+ gnutls_params_function * func);
- void gnutls_anon_free_client_credentials (gnutls_anon_client_credentials_t
- sc);
+ void MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t
+ sc);
int
- gnutls_anon_allocate_client_credentials (gnutls_anon_client_credentials_t
- * sc);
+ MHD_gnutls_anon_allocate_client_credentials (mhd_gtls_anon_client_credentials_t
+ * sc);
-/* CERTFILE is an x509 certificate in PEM form.
- * KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
- */
- void gnutls_certificate_free_credentials (gnutls_certificate_credentials_t
- sc);
+ void MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t
+ sc);
int
- gnutls_certificate_allocate_credentials (gnutls_certificate_credentials_t
- * res);
+ MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_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 MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc);
+ void MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc);
+ void MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc);
+ void MHD_gnutls_certificate_free_crls (mhd_gtls_cert_credentials_t sc);
- void gnutls_certificate_set_dh_params (gnutls_certificate_credentials_t res,
- gnutls_dh_params_t dh_params);
+ void MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
+ mhd_gtls_dh_params_t dh_params);
void
- gnutls_certificate_set_rsa_export_params (gnutls_certificate_credentials_t
- res,
- gnutls_rsa_params_t rsa_params);
- void gnutls_certificate_set_verify_flags (gnutls_certificate_credentials_t
- res, unsigned int flags);
- void gnutls_certificate_set_verify_limits (gnutls_certificate_credentials_t
- res, unsigned int max_bits,
- unsigned int max_depth);
-
- int gnutls_certificate_set_x509_trust_file (gnutls_certificate_credentials_t
- res, const char *CAFILE,
- gnutls_x509_crt_fmt_t type);
- int gnutls_certificate_set_x509_trust_mem (gnutls_certificate_credentials_t
- res, const gnutls_datum_t * CA,
- gnutls_x509_crt_fmt_t type);
-
- int gnutls_certificate_set_x509_crl_file (gnutls_certificate_credentials_t
- res, const char *crlfile,
- gnutls_x509_crt_fmt_t type);
- int gnutls_certificate_set_x509_crl_mem (gnutls_certificate_credentials_t
- res, const gnutls_datum_t * CRL,
- gnutls_x509_crt_fmt_t type);
-
- int gnutls_certificate_set_x509_key_file (gnutls_certificate_credentials_t
- res, const char *CERTFILE,
- const char *KEYFILE,
- gnutls_x509_crt_fmt_t type);
- int gnutls_certificate_set_x509_key_mem (gnutls_certificate_credentials_t
- res, 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);
-
-
- extern 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);
-
-/* New functions to allow setting already parsed X.509 stuff.
+ MHD_gnutls_certificate_set_rsa_export_params (mhd_gtls_cert_credentials_t
+ res,
+ mhd_gtls_rsa_params_t rsa_params);
+ void MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
+ res, unsigned int flags);
+ void MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
+ res, unsigned int max_bits,
+ unsigned int max_depth);
+
+ int MHD_gnutls_certificate_set_x509_trust_file (mhd_gtls_cert_credentials_t
+ res, const char *CAFILE,
+ gnutls_x509_crt_fmt_t type);
+ int MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
+ res, const gnutls_datum_t * CA,
+ gnutls_x509_crt_fmt_t type);
+
+ int MHD_gnutls_certificate_set_x509_crl_file (mhd_gtls_cert_credentials_t
+ res, const char *crlfile,
+ gnutls_x509_crt_fmt_t type);
+ int MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
+ res, const gnutls_datum_t * CRL,
+ gnutls_x509_crt_fmt_t type);
+
+ /*
+ * CERTFILE is an x509 certificate in PEM form.
+ * KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
+ */
+ int MHD_gnutls_certificate_set_x509_key_file (mhd_gtls_cert_credentials_t
+ res, const char *CERTFILE,
+ const char *KEYFILE,
+ gnutls_x509_crt_fmt_t type);
+ int MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
+ res, const gnutls_datum_t * CERT,
+ const gnutls_datum_t * KEY,
+ gnutls_x509_crt_fmt_t type);
+
+ void MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t session,
+ int status);
+
+/*
+ * New functions to allow setting already parsed X.509 stuff.
*/
- struct gnutls_x509_privkey_int;
- typedef struct gnutls_x509_privkey_int *gnutls_x509_privkey_t;
+ struct MHD_gtls_x509_privkey_int;
+ typedef struct MHD_gtls_x509_privkey_int *gnutls_x509_privkey_t;
struct gnutls_x509_crl_int;
typedef struct gnutls_x509_crl_int *gnutls_x509_crl_t;
struct gnutls_x509_crt_int;
- typedef struct gnutls_x509_crt_int * gnutls_x509_crt_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);
+ typedef struct gnutls_x509_crt_int *gnutls_x509_crt_t;
+
+// int gnutls_certificate_set_x509_key (mhd_gtls_cert_credentials_t res,
+// gnutls_x509_crt_t * cert_list,
+// int cert_list_size,
+// gnutls_x509_privkey_t key);
+// int gnutls_certificate_set_x509_trust (mhd_gtls_cert_credentials_t res,
+// gnutls_x509_crt_t * ca_list,
+// int ca_list_size);
+// int gnutls_certificate_set_x509_crl (mhd_gtls_cert_credentials_t res,
+// gnutls_x509_crl_t * crl_list,
+// int crl_list_size);
/* global state functions
*/
- int gnutls_global_init (void);
- void gnutls_global_deinit (void);
+
typedef void *(*gnutls_alloc_function) (size_t);
typedef void *(*gnutls_calloc_function) (size_t, size_t);
@@ -625,13 +547,13 @@ extern "C"
typedef void *(*gnutls_realloc_function) (void *, size_t);
extern void
- gnutls_global_set_mem_functions (gnutls_alloc_function gt_alloc_func,
- gnutls_alloc_function
- gt_secure_alloc_func,
- gnutls_is_secure_function
- gt_is_secure_func,
- gnutls_realloc_function gt_realloc_func,
- gnutls_free_function gt_free_func);
+ MHD_gtls_global_set_mem_functions (gnutls_alloc_function gt_alloc_func,
+ gnutls_alloc_function
+ gt_secure_alloc_func,
+ gnutls_is_secure_function
+ gt_is_secure_func,
+ gnutls_realloc_function gt_realloc_func,
+ gnutls_free_function gt_free_func);
/* For use in callbacks */
extern gnutls_alloc_function gnutls_malloc;
@@ -643,235 +565,225 @@ extern "C"
extern char *(*gnutls_strdup) (const char *);
typedef void (*gnutls_log_func) (int, const char *);
- void gnutls_global_set_log_function (gnutls_log_func log_func);
- void gnutls_global_set_log_level (int level);
+ void MHD_gtls_global_set_log_function (gnutls_log_func log_func);
+ void MHD_gtls_global_set_log_level (int level);
-/* Diffie Hellman parameter handling.
- */
- 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);
-
-
-/* RSA params
+/*
+ * Diffie Hellman parameter handling.
*/
- 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);
-
-/* Session stuff
+ int MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params);
+ void MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params);
+ int MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params,
+ unsigned int bits);
+// int MHD_gnutls_dh_params_import_raw (mhd_gtls_dh_params_t dh_params,
+// const gnutls_datum_t * prime,
+// const gnutls_datum_t * generator);
+// int MHD_gnutls_dh_params_export_raw (mhd_gtls_dh_params_t params,
+// gnutls_datum_t * prime,
+// gnutls_datum_t * generator,
+// unsigned int *bits);
+// int gnutls_dh_params_import_pkcs3 (mhd_gtls_dh_params_t params,
+// const gnutls_datum_t * pkcs3_params,
+// gnutls_x509_crt_fmt_t format);
+
+// int gnutls_dh_params_export_pkcs3 (mhd_gtls_dh_params_t params,
+// gnutls_x509_crt_fmt_t format,
+// unsigned char *params_data,
+// size_t * params_data_size);
+
+/* RSA params */
+ int MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params);
+ void MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params);
+ int MHD_gnutls_rsa_params_generate2 (mhd_gtls_rsa_params_t params,
+ unsigned int bits);
+
+// int gnutls_rsa_params_import_raw (mhd_gtls_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_export_raw (mhd_gtls_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);
+
+/*
+ * Session stuff
*/
- typedef ssize_t (*gnutls_pull_func) (gnutls_transport_ptr_t, void *,
- size_t);
- typedef 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);
+ typedef ssize_t (* mhd_gtls_pull_func) (gnutls_transport_ptr_t, void *,
+ size_t);
+ typedef ssize_t (* mhd_gtls_push_func) (gnutls_transport_ptr_t, const void *,
+ size_t);
+ void MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
+ gnutls_transport_ptr_t ptr);
+ void MHD_gnutls_transport_set_ptr2 (mhd_gtls_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 MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num);
- void gnutls_transport_set_lowat (gnutls_session_t session, int num);
+ void MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
+ mhd_gtls_push_func push_func);
+ void MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
+ mhd_gtls_pull_func pull_func);
- 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 MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err);
+ void MHD_gnutls_transport_set_global_errno (int err);
- void gnutls_transport_set_errno (gnutls_session_t session, int err);
- void gnutls_transport_set_global_errno (int err);
-
-/* session specific
+/*
+ * session specific
*/
- void gnutls_session_set_ptr (gnutls_session_t session, void *ptr);
- void *gnutls_session_get_ptr (gnutls_session_t session);
+ void MHD_gnutls_session_set_ptr (mhd_gtls_session_t session, void *ptr);
+ void * MHD_gtls_session_get_ptr (mhd_gtls_session_t session);
- void gnutls_openpgp_send_cert (gnutls_session_t session,
- gnutls_openpgp_crt_status_t status);
+ void MHD_gtls_openpgp_send_cert (mhd_gtls_session_t session,
+ gnutls_openpgp_crt_status_t status);
-/* fingerprint
- * Actually this function returns the hash of the given data.
+/*
+ * this function returns the hash of the given data.
*/
- int gnutls_fingerprint (gnutls_digest_algorithm_t algo,
- const gnutls_datum_t * data, void *result,
- size_t * result_size);
-
+ int MHD_gnutls_fingerprint (gnutls_digest_algorithm_t algo,
+ const gnutls_datum_t * data, void *result,
+ size_t * result_size);
-/* SRP
+/*
+ * SRP
*/
-
- typedef struct gnutls_srp_server_credentials_st
- *gnutls_srp_server_credentials_t;
- typedef struct gnutls_srp_client_credentials_st
- *gnutls_srp_client_credentials_t;
-
- void gnutls_srp_free_client_credentials (gnutls_srp_client_credentials_t
- sc);
- 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_t
- sc);
- int gnutls_srp_allocate_server_credentials (gnutls_srp_server_credentials_t
- * sc);
- int gnutls_srp_set_server_credentials_file (gnutls_srp_server_credentials_t
- res, const char *password_file,
- const char *password_conf_file);
-
- const char *gnutls_srp_server_get_username (gnutls_session_t session);
-
- extern 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);
-
-/* The static parameters defined in draft-ietf-tls-srp-05
- * Those should be used as input to gnutls_srp_verifier().
+// typedef struct gnutls_srp_server_credentials_st
+// *gnutls_srp_server_credentials_t;
+// typedef struct gnutls_srp_client_credentials_st
+// *gnutls_srp_client_credentials_t;
+//
+// void gnutls_srp_free_client_credentials (gnutls_srp_client_credentials_t
+// sc);
+// 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_t
+// sc);
+// int gnutls_srp_allocate_server_credentials (gnutls_srp_server_credentials_t
+// * sc);
+// int gnutls_srp_set_server_credentials_file (gnutls_srp_server_credentials_t
+// res, const char *password_file,
+// const char *password_conf_file);
+//
+// const char *gnutls_srp_server_get_username (mhd_gtls_session_t session);
+//
+// extern 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);
+//
+///* The static parameters defined in draft-ietf-tls-srp-05
+// * Those should be used as input to gnutls_srp_verifier().
+// */
+// 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;
+//
+// typedef int gnutls_srp_server_credentials_function (mhd_gtls_session_t,
+// const char *username,
+// gnutls_datum_t * salt,
+// gnutls_datum_t *
+// verifier,
+// gnutls_datum_t *
+// generator,
+// gnutls_datum_t * prime);
+// void
+// gnutls_srp_set_server_credentials_function
+// (gnutls_srp_server_credentials_t cred,
+// gnutls_srp_server_credentials_function * func);
+//
+// typedef int gnutls_srp_client_credentials_function (mhd_gtls_session_t,
+// char **, char **);
+// 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);
+
+/*
+ * PSK stuff
*/
- 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;
-
- typedef int gnutls_srp_server_credentials_function (gnutls_session_t,
- const char *username,
- gnutls_datum_t * salt,
- gnutls_datum_t *
- verifier,
- gnutls_datum_t *
- generator,
- gnutls_datum_t * prime);
- void
- gnutls_srp_set_server_credentials_function
- (gnutls_srp_server_credentials_t cred,
- gnutls_srp_server_credentials_function * func);
-
- typedef int gnutls_srp_client_credentials_function (gnutls_session_t,
- char **, char **);
- 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);
-
-/* PSK stuff */
- typedef struct gnutls_psk_server_credentials_st
- *gnutls_psk_server_credentials_t;
- typedef struct gnutls_psk_client_credentials_st
- *gnutls_psk_client_credentials_t;
-
- typedef enum gnutls_psk_key_flags
- {
- GNUTLS_PSK_KEY_RAW = 0,
- GNUTLS_PSK_KEY_HEX
- } gnutls_psk_key_flags;
-
- void gnutls_psk_free_client_credentials (gnutls_psk_client_credentials_t
- sc);
- 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_t
- sc);
- int gnutls_psk_allocate_server_credentials (gnutls_psk_server_credentials_t
- * sc);
- int gnutls_psk_set_server_credentials_file (gnutls_psk_server_credentials_t
- res, const char *password_file);
-
- const char *gnutls_psk_server_get_username (gnutls_session_t session);
-
- typedef int gnutls_psk_server_credentials_function (gnutls_session_t,
- const char *username,
- gnutls_datum_t * key);
- void
- gnutls_psk_set_server_credentials_function
- (gnutls_psk_server_credentials_t cred,
- gnutls_psk_server_credentials_function * func);
-
- typedef int gnutls_psk_client_credentials_function (gnutls_session_t,
- char **username,
- gnutls_datum_t * key);
- 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_t
- res,
- gnutls_params_function * func);
+// typedef struct gnutls_psk_server_credentials_st
+// *gnutls_psk_server_credentials_t;
+// typedef struct gnutls_psk_client_credentials_st
+// *gnutls_psk_client_credentials_t;
+//
+// typedef enum gnutls_psk_key_flags
+// {
+// GNUTLS_PSK_KEY_RAW = 0,
+// GNUTLS_PSK_KEY_HEX
+// } gnutls_psk_key_flags;
+//
+// void gnutls_psk_free_client_credentials (gnutls_psk_client_credentials_t
+// sc);
+// 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_t
+// sc);
+// int gnutls_psk_allocate_server_credentials (gnutls_psk_server_credentials_t
+// * sc);
+// int gnutls_psk_set_server_credentials_file (gnutls_psk_server_credentials_t
+// res, const char *password_file);
+//
+// const char *gnutls_psk_server_get_username (mhd_gtls_session_t session);
+//
+// typedef int gnutls_psk_server_credentials_function (mhd_gtls_session_t,
+// const char *username,
+// gnutls_datum_t * key);
+// void
+// gnutls_psk_set_server_credentials_function
+// (gnutls_psk_server_credentials_t cred,
+// gnutls_psk_server_credentials_function * func);
+//
+// typedef int gnutls_psk_client_credentials_function (mhd_gtls_session_t,
+// char **username,
+// gnutls_datum_t * key);
+// 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,
+// mhd_gtls_dh_params_t dh_params);
+//
+// void gnutls_psk_set_server_params_function (gnutls_psk_server_credentials_t
+// res,
+// gnutls_params_function * func);
typedef enum gnutls_x509_subject_alt_name_t
{
@@ -901,7 +813,7 @@ extern "C"
gnutls_x509_crt_t *x509;
gnutls_openpgp_crt_t pgp;
} cert;
- unsigned int ncerts; /* one for pgp keys */
+ unsigned int ncerts; /* one for pgp keys */
union key
{
@@ -909,118 +821,122 @@ extern "C"
gnutls_openpgp_privkey_t pgp;
} key;
- unsigned int deinit_all; /* if non zero all keys will be deinited */
+ unsigned int deinit_all; /* if non zero all keys will be deinited */
} gnutls_retr_st;
- typedef int gnutls_certificate_client_retrieve_function (gnutls_session_t,
- const
- gnutls_datum_t *
- req_ca_rdn,
- int nreqs,
- const
- gnutls_pk_algorithm_t
- * pk_algos,
- int
- pk_algos_length,
- gnutls_retr_st *);
- typedef int gnutls_certificate_server_retrieve_function (gnutls_session_t,
- gnutls_retr_st *);
-
-
- /* Functions that allow auth_info_t structures handling
+ typedef int gnutls_certificate_client_retrieve_function (mhd_gtls_session_t,
+ const
+ gnutls_datum_t *
+ req_ca_rdn,
+ int nreqs,
+ const
+ gnutls_pk_algorithm_t
+ * pk_algos,
+ int
+ pk_algos_length,
+ gnutls_retr_st *);
+
+ typedef int gnutls_certificate_server_retrieve_function (mhd_gtls_session_t,
+ gnutls_retr_st *);
+
+ /*
+ * Functions that allow auth_info_t structures handling
*/
-
- gnutls_credentials_type_t gnutls_auth_get_type (gnutls_session_t session);
+ gnutls_credentials_type_t MHD_gtls_auth_get_type (mhd_gtls_session_t session);
gnutls_credentials_type_t
- gnutls_auth_server_get_type (gnutls_session_t session);
+ MHD_gtls_auth_server_get_type (mhd_gtls_session_t session);
gnutls_credentials_type_t
- gnutls_auth_client_get_type (gnutls_session_t session);
-
- /* DH */
+ MHD_gtls_auth_client_get_type (mhd_gtls_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);
-
- /* RSA */
- 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);
-
- /* X509PKI */
+ /*
+ * DH
+ */
+ void MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session, unsigned int bits);
+ int MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session);
+ int MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session);
+ int MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session);
+
+ int MHD_gnutls_dh_get_group (mhd_gtls_session_t session, gnutls_datum_t * raw_gen,
+ gnutls_datum_t * raw_prime);
+ int MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
+ gnutls_datum_t * raw_key);
+
+ /*
+ * RSA
+ */
+ int MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
+ gnutls_datum_t * exponent,
+ gnutls_datum_t * modulus);
+ int MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session);
/* External signing callback. Experimental. */
- typedef 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);
+ typedef int (*gnutls_sign_func) (mhd_gtls_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 MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
+ gnutls_sign_func sign_func, void *userdata);
+ gnutls_sign_func
+ MHD_gtls_sign_callback_get (mhd_gtls_session_t session, void **userdata);
/* These are set on the credentials structure.
*/
- void gnutls_certificate_client_set_retrieve_function
- (gnutls_certificate_credentials_t cred,
+ void MHD_gtls_certificate_client_set_retrieve_function
+ (mhd_gtls_cert_credentials_t cred,
gnutls_certificate_client_retrieve_function * func);
- void gnutls_certificate_server_set_retrieve_function
- (gnutls_certificate_credentials_t cred,
+ void MHD_gtls_certificate_server_set_retrieve_function
+ (mhd_gtls_cert_credentials_t cred,
gnutls_certificate_server_retrieve_function * func);
- void gnutls_certificate_server_set_request (gnutls_session_t session,
- gnutls_certificate_request_t
- req);
+ void MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
+ gnutls_certificate_request_t
+ req);
- /* get data from the session
- */
- const gnutls_datum_t *gnutls_certificate_get_peers (gnutls_session_t
- session,
- unsigned int
- *list_size);
- const gnutls_datum_t *gnutls_certificate_get_ours (gnutls_session_t
- session);
+ /* get data from the session */
+ const gnutls_datum_t * MHD_gtls_certificate_get_peers (mhd_gtls_session_t
+ session,
+ unsigned int
+ *list_size);
+ const gnutls_datum_t * MHD_gtls_certificate_get_ours (mhd_gtls_session_t
+ session);
- time_t gnutls_certificate_activation_time_peers (gnutls_session_t session);
- time_t gnutls_certificate_expiration_time_peers (gnutls_session_t session);
+ time_t MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session);
+ time_t MHD_gtls_certificate_expiration_time_peers (mhd_gtls_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 MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t session);
+ int MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
+ unsigned int *status);
/* this is obsolete (?). */
- 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);
-
- int gnutls_global_init (void);
-
- /* key_usage will be an OR of the following values:
- */
-
+ int MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session);
+
+ int MHD_gtls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
+ char *result, size_t * result_size);
+ int MHD_gtls_pem_base64_decode (const char *header,
+ const gnutls_datum_t * b64_data,
+ unsigned char *result, size_t * result_size);
+
+ int MHD_gtls_pem_base64_encode_alloc (const char *msg,
+ const gnutls_datum_t * data,
+ gnutls_datum_t * result);
+ int MHD_gtls_pem_base64_decode_alloc (const char *header,
+ const gnutls_datum_t * b64_data,
+ gnutls_datum_t * result);
+
+ // void
+ // gnutls_certificate_set_params_function (mhd_gtls_cert_credentials_t
+ // res,
+ // gnutls_params_function * func);
+ // void gnutls_anon_set_params_function (mhd_gtls_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);
+
+
+ /* key_usage will be an OR of the following values: */
/* when the key is to be used for signing: */
#define GNUTLS_KEY_DIGITAL_SIGNATURE 128
#define GNUTLS_KEY_NON_REPUDIATION 64
@@ -1033,51 +949,42 @@ extern "C"
#define GNUTLS_KEY_ENCIPHER_ONLY 1
#define GNUTLS_KEY_DECIPHER_ONLY 32768
- 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);
-
- /* Gnutls error codes. The mapping to a TLS alert is also shown in
- * comments.
+ /*
+ * Error codes. TLS alert mapping shown in comments.
*/
-
#define GNUTLS_E_SUCCESS 0
#define GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM -3
#define GNUTLS_E_UNKNOWN_CIPHER_TYPE -6
#define GNUTLS_E_LARGE_PACKET -7
-#define GNUTLS_E_UNSUPPORTED_VERSION_PACKET -8 /* GNUTLS_A_PROTOCOL_VERSION */
-#define GNUTLS_E_UNEXPECTED_PACKET_LENGTH -9 /* GNUTLS_A_RECORD_OVERFLOW */
+#define GNUTLS_E_UNSUPPORTED_VERSION_PACKET -8 /* GNUTLS_A_PROTOCOL_VERSION */
+#define GNUTLS_E_UNEXPECTED_PACKET_LENGTH -9 /* GNUTLS_A_RECORD_OVERFLOW */
#define GNUTLS_E_INVALID_SESSION -10
#define GNUTLS_E_FATAL_ALERT_RECEIVED -12
-#define GNUTLS_E_UNEXPECTED_PACKET -15 /* GNUTLS_A_UNEXPECTED_MESSAGE */
+#define GNUTLS_E_UNEXPECTED_PACKET -15 /* GNUTLS_A_UNEXPECTED_MESSAGE */
#define GNUTLS_E_WARNING_ALERT_RECEIVED -16
#define GNUTLS_E_ERROR_IN_FINISHED_PACKET -18
#define GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET -19
-#define GNUTLS_E_UNKNOWN_CIPHER_SUITE -21 /* GNUTLS_A_HANDSHAKE_FAILURE */
+#define GNUTLS_E_UNKNOWN_CIPHER_SUITE -21 /* GNUTLS_A_HANDSHAKE_FAILURE */
#define GNUTLS_E_UNWANTED_ALGORITHM -22
#define GNUTLS_E_MPI_SCAN_FAILED -23
-#define GNUTLS_E_DECRYPTION_FAILED -24 /* GNUTLS_A_DECRYPTION_FAILED, GNUTLS_A_BAD_RECORD_MAC */
+#define GNUTLS_E_DECRYPTION_FAILED -24 /* GNUTLS_A_DECRYPTION_FAILED, GNUTLS_A_BAD_RECORD_MAC */
#define GNUTLS_E_MEMORY_ERROR -25
-#define GNUTLS_E_DECOMPRESSION_FAILED -26 /* GNUTLS_A_DECOMPRESSION_FAILURE */
+#define GNUTLS_E_DECOMPRESSION_FAILED -26 /* GNUTLS_A_DECOMPRESSION_FAILURE */
#define GNUTLS_E_COMPRESSION_FAILED -27
#define GNUTLS_E_AGAIN -28
#define GNUTLS_E_EXPIRED -29
#define GNUTLS_E_DB_ERROR -30
#define GNUTLS_E_SRP_PWD_ERROR -31
#define GNUTLS_E_INSUFFICIENT_CREDENTIALS -32
-#define GNUTLS_E_INSUFICIENT_CREDENTIALS GNUTLS_E_INSUFFICIENT_CREDENTIALS /* for backwards compatibility only */
+#define GNUTLS_E_INSUFICIENT_CREDENTIALS GNUTLS_E_INSUFFICIENT_CREDENTIALS /* for backwards compatibility only */
#define GNUTLS_E_INSUFFICIENT_CRED GNUTLS_E_INSUFFICIENT_CREDENTIALS
-#define GNUTLS_E_INSUFICIENT_CRED GNUTLS_E_INSUFFICIENT_CREDENTIALS /* for backwards compatibility only */
+#define GNUTLS_E_INSUFICIENT_CRED GNUTLS_E_INSUFFICIENT_CREDENTIALS /* for backwards compatibility only */
#define GNUTLS_E_HASH_FAILED -33
#define GNUTLS_E_BASE64_DECODING_ERROR -34
#define GNUTLS_E_MPI_PRINT_FAILED -35
-#define GNUTLS_E_REHANDSHAKE -37 /* GNUTLS_A_NO_RENEGOTIATION */
+#define GNUTLS_E_REHANDSHAKE -37 /* GNUTLS_A_NO_RENEGOTIATION */
#define GNUTLS_E_GOT_APPLICATION_DATA -38
#define GNUTLS_E_RECORD_LIMIT_REACHED -39
#define GNUTLS_E_ENCRYPTION_FAILED -40
@@ -1087,13 +994,13 @@ extern "C"
#define GNUTLS_E_PK_SIGN_FAILED -46
#define GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION -47
#define GNUTLS_E_KEY_USAGE_VIOLATION -48
-#define GNUTLS_E_NO_CERTIFICATE_FOUND -49 /* GNUTLS_A_BAD_CERTIFICATE */
+#define GNUTLS_E_NO_CERTIFICATE_FOUND -49 /* GNUTLS_A_BAD_CERTIFICATE */
#define GNUTLS_E_INVALID_REQUEST -50
#define GNUTLS_E_SHORT_MEMORY_BUFFER -51
#define GNUTLS_E_INTERRUPTED -52
#define GNUTLS_E_PUSH_ERROR -53
#define GNUTLS_E_PULL_ERROR -54
-#define GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER -55 /* GNUTLS_A_ILLEGAL_PARAMETER */
+#define GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER -55 /* GNUTLS_A_ILLEGAL_PARAMETER */
#define GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE -56
#define GNUTLS_E_PKCS1_WRONG_PAD -57
#define GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION -58
@@ -1144,7 +1051,7 @@ extern "C"
#define GNUTLS_E_CERTIFICATE_ERROR -43
#define GNUTLS_E_X509_CERTIFICATE_ERROR GNUTLS_E_CERTIFICATE_ERROR
#define GNUTLS_E_CERTIFICATE_KEY_MISMATCH -60
-#define GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE -61 /* GNUTLS_A_UNSUPPORTED_CERTIFICATE */
+#define GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE -61 /* GNUTLS_A_UNSUPPORTED_CERTIFICATE */
#define GNUTLS_E_X509_UNKNOWN_SAN -62
#define GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED -94
#define GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE -95
@@ -1152,7 +1059,7 @@ extern "C"
#define GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE -97
#define GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE -98
#define GNUTLS_E_INVALID_PASSWORD -99
-#define GNUTLS_E_MAC_VERIFY_FAILED -100 /* for PKCS #12 MAC */
+#define GNUTLS_E_MAC_VERIFY_FAILED -100 /* for PKCS #12 MAC */
#define GNUTLS_E_CONSTRAINT_ERROR -101
#define GNUTLS_E_WARNING_IA_IPHF_RECEIVED -102
@@ -1163,7 +1070,7 @@ extern "C"
#define GNUTLS_E_UNKNOWN_ALGORITHM -105
#define GNUTLS_E_BASE64_ENCODING_ERROR -201
-#define GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY -202 /* obsolete */
+#define GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY -202 /* obsolete */
#define GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY -202
#define GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY -203
@@ -1183,4 +1090,4 @@ extern "C"
}
#endif
-#endif /* GNUTLS_H */
+#endif /* GNUTLS_H */
diff --git a/src/daemon/https/list.h b/src/daemon/https/list.h
@@ -1,449 +0,0 @@
-/*
- * Copyright (C) 2001,2002 Paul Sheer
- *
- * This file is part of GNUTLS.
- *
- * GNUTLS is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNUTLS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-/*
- SOAP:
-
- Academics always want to implement hash tables (i.e. dictionaries),
- singly or doubly linked lists, and queues, because ... well ... they
- know how.
-
- These datatypes are nonsense for the following reasons:
- hash tables: Hash tables are a mapping of some
- string to some data, where that data is going to
- be accessed COMPLETELY RANDOMLY. This is what it
- is for. However it is extremely rare to have a
- large number of data elements which really are
- being accessed in a completely random way.
-
- lists: appending and searching through lists is always
- slow because these operations search all the way
- through the list.
-
- queues: whats the difference between a queue and a list?
- very little really.
-
- The system implemented here is a doubly linked list with previous
- search index that can be appended or prepended with no overhead,
- implemented entirely in macros. It is hence as versatile as a
- doubly/singly linked list or queue and blazingly fast. Hence doing
- sequential searches where the next search result is likely to be
- closely indexed to the previous (usual case), is efficient.
-
- Of course this doesn't mean you should use this as a hash table
- where you REALLY need a hash table.
-
-*/
-
-/********** example usage **********/
-/*
-
-#include "list.h"
-
-extern void free (void *x);
-extern char *strdup (char *s);
-
-// consider a list of elements containing an `int' and a `char *'
-LIST_TYPE_DECLARE (names, char *s; int i;);
-
-// for sorting, to compare elements
-static int cm (names **a, names **b)
-{
- return strcmp ((*a)->s, (*b)->s);
-}
-
-// to free the contents of an element
-static void free_item (names *a)
-{
- free (a->s);
- a->s = 0; // say
- a->i = 0; // say
-}
-
-int main (int argc, char **argv)
-{
-// you can separate these into LIST_TYPE_DECLARE(), LIST_DECLARE() and linit() if needed.
- LIST_DECLARE_INIT (l, names, free_item);
- names *j;
-
- lappend (l);
- l.tail->s = strdup ("hello");
- l.tail->i = 1;
- lappend (l);
- l.tail->s = strdup ("there");
- l.tail->i = 2;
- lappend (l);
- l.tail->s = strdup ("my");
- l.tail->i = 3;
- lappend (l);
- l.tail->s = strdup ("name");
- l.tail->i = 4;
- lappend (l);
- l.tail->s = strdup ("is");
- l.tail->i = 5;
- lappend (l);
- l.tail->s = strdup ("fred");
- l.tail->i = 6;
-
- printf ("%ld\n\n", lcount (l));
- lloopforward (l, j, printf ("%d %s\n", j->i, j->s));
- printf ("\n");
-
- lsort (l, cm);
- lloopforward (l, j, printf ("%d %s\n", j->i, j->s));
-
- lloopreverse (l, j, if (j->i <= 3) ldeleteinc (l, j););
-
- printf ("\n");
- lloopforward (l, j, printf ("%d %s\n", j->i, j->s));
-
- ldeleteall (l);
-
- printf ("\n");
- lloopforward (l, j, printf ("%d %s\n", j->i, j->s));
- return 0;
-}
-
-*/
-
-
-#ifndef _LIST_H
-#define _LIST_H
-
-/* the `search' member points to the last found.
- this speeds up repeated searches on the same list-item,
- the consecutive list-item, or the pre-consecutive list-item.
- this obviates the need for a hash table for 99% of
- cercumstances the time */
-struct list
-{
- long length;
- long item_size;
- struct list_item
- {
- struct list_item *next;
- struct list_item *prev;
- char data[1];
- } *head, *tail, *search;
- void (*free_func) (struct list_item *);
-};
-
-/* declare a list of type `x', also called `x' having members `typelist' */
-
-#define LIST_TYPE_DECLARE(type,typelist) \
- typedef struct type { \
- struct type *next; \
- struct type *prev; \
- typelist \
- } type
-
-#define LIST_DECLARE(l,type) \
- struct { \
- long length; \
- long item_size; \
- type *head, *tail, *search; \
- void (*free_func) (type *); \
- } l
-
-#define LIST_DECLARE_INIT(l,type,free) \
- struct { \
- long length; \
- long item_size; \
- type *head, *tail, *search; \
- void (*free_func) (type *); \
- } l = {0, sizeof (type), 0, 0, 0, (void (*) (type *)) free}
-
-#define linit(l,type,free) \
- { \
- memset (&(l), 0, sizeof (l)); \
- (l).item_size = sizeof (type); \
- (l).free_func = free; \
- }
-
-/* returns a pointer to the data of an item */
-#define ldata(i) ((void *) &((i)->data[0]))
-
-/* returns a pointer to the list head */
-#define lhead(l) ((l).head)
-
-/* returns a pointer to the list tail */
-#define ltail(l) ((l).tail)
-
-#define lnewsearch(l) \
- (l).search = 0;
-
-/* adds to the beginning of the list */
-#define lprepend(l) \
- { \
- struct list_item *__t; \
- __t = (struct list_item *) malloc ((l).item_size); \
- memset (__t, 0, (l).item_size); \
- __t->next = (l).head; \
- if (__t->next) \
- __t->next->prev = __t; \
- __t->prev = 0; \
- if (!(l).tail) \
- (l).tail = __t; \
- (l).head = __t; \
- length++; \
- }
-
-/* adds to the end of the list */
-#define lappend(l) \
- { \
- struct list_item *__t; \
- __t = (struct list_item *) malloc ((l).item_size); \
- memset (__t, 0, (l).item_size); \
- __t->prev = (struct list_item *) (l).tail; \
- if (__t->prev) \
- __t->prev->next = __t; \
- __t->next = 0; \
- if (!(l).head) \
- (l).head = (void *) __t; \
- (l).tail = (void *) __t; \
- (l).length++; \
- }
-
-/* you should free these manually */
-#define lunlink(l,e) \
- { \
- struct list_item *__t; \
- (l).search = 0; \
- __t = (void *) e; \
- if ((void *) (l).head == (void *) __t) \
- (l).head = (l).head->next; \
- if ((void *) (l).tail == (void *) __t) \
- (l).tail = (l).tail->prev; \
- if (__t->next) \
- __t->next->prev = __t->prev; \
- if (__t->prev) \
- __t->prev->next = __t->next; \
- (l).length--; \
- }
-
-/* deletes list entry at point e, and increments e to the following list entry */
-#define ldeleteinc(l,e) \
- { \
- struct list_item *__t; \
- (l).search = 0; \
- __t = (void *) e; \
- if ((void *) (l).head == (void *) __t) \
- (l).head = (l).head->next; \
- if ((void *) (l).tail == (void *) __t) \
- (l).tail = (l).tail->prev; \
- if (__t->next) \
- __t->next->prev = __t->prev; \
- if (__t->prev) \
- __t->prev->next = __t->next; \
- __t = __t->next; \
- if ((l).free_func) \
- (*(l).free_func) ((void *) e); \
- free (e); \
- e = (void *) __t; \
- (l).length--; \
- }
-
-/* deletes list entry at point e, and deccrements e to the preceding list emtry */
-#define ldeletedec(l,e) \
- { \
- struct list_item *__t; \
- (l).search = 0; \
- __t = (void *) e; \
- if ((void *) (l).head == (void *) __t) \
- (l).head = (l).head->next; \
- if ((void *) (l).tail == (void *) __t) \
- (l).tail = (l).tail->prev; \
- if (__t->next) \
- __t->next->prev = __t->prev; \
- if (__t->prev) \
- __t->prev->next = __t->next; \
- __t = __t->prev; \
- if ((l).free_func) \
- (*(l).free_func) ((void *) e); \
- free (e); \
- e = (void *) __t; \
- (l).length--; \
- }
-
-/* p and q must be consecutive and neither must be zero */
-#define linsert(l,p,q) \
- { \
- struct list_item *__t; \
- __t = (struct list_item *) malloc ((l).item_size); \
- memset (__t, 0, (l).item_size); \
- __t->prev = (void *) p; \
- __t->next = (void *) q; \
- q->prev = (void *) __t; \
- p->next = (void *) __t; \
- (l).length++; \
- }
-
-/* p and q must be consecutive and neither must be zero */
-#define ldeleteall(l) \
- { \
- (l).search = 0; \
- while ((l).head) { \
- struct list_item *__p; \
- __p = (struct list_item *) (l).head; \
- lunlink(l, __p); \
- if ((l).free_func) \
- (*(l).free_func) ((void *) __p); \
- free (__p); \
- } \
- }
-
-#define lloopstart(l,i) \
- for (i = (void *) (l).head; i;) { \
- struct list_item *__tl; \
- __tl = (void *) i->next; \
-
-#define lloopend(l,i) \
- i = (void *) __tl; \
- } \
-
-#define lloopforward(l,i,op) \
- { \
- for (i = (void *) (l).head; i;) { \
- struct list_item *__t; \
- __t = (void *) i->next; \
- op; \
- i = (void *) __t; \
- } \
- }
-
-#define lloopreverse(l,i,op) \
- { \
- for (i = (void *) (l).tail; i;) { \
- struct list_item *__t; \
- __t = (void *) i->prev; \
- op; \
- i = (void *) __t; \
- } \
- }
-
-#define lindex(l,i,n) \
- { \
- int __k; \
- for (__k = 0, i = (void *) (l).head; i && __k != n; i = i->next, __k++); \
- }
-
-#define lsearchforward(l,i,op) \
- { \
- int __found = 0; \
- if (!__found) \
- if ((i = (void *) (l).search)) { \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- if (!__found) \
- if ((i = (void *) (l).search->next)) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- if (!__found) \
- if ((i = (void *) (l).search->prev)) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- } \
- if (!__found) \
- for (i = (void *) (l).head; i; i = i->next) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- break; \
- } \
- }
-
-#define lsearchreverse(l,i,op) \
- { \
- int __found = 0; \
- if (!__found) \
- if ((i = (void *) (l).search)) { \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- if (!__found) \
- if ((i = (void *) (l).search->prev)) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- if (!__found) \
- if ((i = (void *) (l).search->next)) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- } \
- } \
- if (!__found) \
- for (i = (void *) (l).tail; i; i = i->prev) \
- if (op) { \
- __found = 1; \
- (l).search = (void *) i; \
- break; \
- } \
- }
-
-#define lcount(l) ((l).length)
-
-/* sort with comparison function see qsort(3) */
-#define larray(l,a) \
- { \
- long __i; \
- struct list_item *__p; \
- a = (void *) malloc (((l).length + 1) * sizeof (void *)); \
- for (__i = 0, __p = (void *) (l).head; __p; __p = __p->next, __i++) \
- a[__i] = (void *) __p; \
- a[__i] = 0; \
- } \
-
-/* sort with comparison function see qsort(3) */
-#define llist(l,a) \
- { \
- struct list_item *__p; \
- (l).head = (void *) a[0]; \
- (l).search = 0; \
- __p = (void *) a[0]; \
- __p->prev = 0; \
- for (__j = 1; a[__j]; __j++, __p = __p->next) { \
- __p->next = (void *) a[__j]; \
- __p->next->prev = __p; \
- } \
- (l).tail = (void *) __p; \
- __p->next = 0; \
- } \
-
-/* sort with comparison function see qsort(3) */
-#define lsort(l,compare) \
- { \
- void **__t; \
- long __j; \
- larray (l,__t); \
- qsort (__t, (l).length, sizeof (void *), (int (*) (const void *, const void *)) compare); \
- llist (l,__t); \
- free (__t); \
- } \
-
-#endif /* _LIST_H */
diff --git a/src/daemon/https/openpgp/compat.c b/src/daemon/https/openpgp/compat.c
@@ -42,7 +42,7 @@
* may use GnuPG for that purpose, or any other external PGP application.
-*/
int
-_gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t cred,
+_gnutls_openpgp_verify_key (const mhd_gtls_cert_credentials_t cred,
const gnutls_datum_t * cert_list,
int cert_list_length, unsigned int *status)
{
diff --git a/src/daemon/https/openpgp/extras.c b/src/daemon/https/openpgp/extras.c
@@ -100,8 +100,8 @@ gnutls_openpgp_keyring_check_id (gnutls_openpgp_keyring_t ring,
cdk_pkt_pubkey_t pk;
uint32_t id[2];
- id[0] = _gnutls_read_uint32 (keyid);
- id[1] = _gnutls_read_uint32 (&keyid[4]);
+ id[0] = mhd_gtls_read_uint32 (keyid);
+ id[1] = mhd_gtls_read_uint32 (&keyid[4]);
if (!cdk_keydb_get_pk (ring->db, id, &pk))
{
diff --git a/src/daemon/https/openpgp/gnutls_extra.c b/src/daemon/https/openpgp/gnutls_extra.c
@@ -43,7 +43,7 @@ static int _gnutls_init_extra = 0;
* This function initializes the global state of gnutls-extra library
* to defaults. Returns zero on success.
*
- * Note that gnutls_global_init() has to be called before this
+ * Note that MHD_gnutls_global_init() has to be called before this
* function. If this function is not called then the gnutls-extra
* library will not be usable.
*
diff --git a/src/daemon/https/openpgp/gnutls_extra.h b/src/daemon/https/openpgp/gnutls_extra.h
@@ -25,14 +25,14 @@
#include <auth_cert.h>
typedef int (*OPENPGP_VERIFY_KEY_FUNC) (const
- gnutls_certificate_credentials_t,
+ mhd_gtls_cert_credentials_t,
const gnutls_datum_t *, int,
unsigned int *);
typedef time_t (*OPENPGP_KEY_CREATION_TIME_FUNC) (const gnutls_datum_t *);
typedef time_t (*OPENPGP_KEY_EXPIRATION_TIME_FUNC) (const gnutls_datum_t *);
-typedef int (*OPENPGP_KEY_REQUEST) (gnutls_session_t, gnutls_datum_t *,
- const gnutls_certificate_credentials_t,
+typedef int (*OPENPGP_KEY_REQUEST) (mhd_gtls_session_t, gnutls_datum_t *,
+ const mhd_gtls_cert_credentials_t,
opaque *, int);
typedef int (*OPENPGP_FINGERPRINT) (const gnutls_datum_t *,
diff --git a/src/daemon/https/openpgp/gnutls_ia.c b/src/daemon/https/openpgp/gnutls_ia.c
@@ -71,7 +71,7 @@ static const char challenge_label[] = "inner application challenge";
this return E_AGAIN and E_INTERRUPTED, call this function again
with data==NULL&&sizeofdata=0NULL until it returns successfully. */
static ssize_t
-_gnutls_send_inner_application (gnutls_session_t session,
+_gnutls_send_inner_application (mhd_gtls_session_t session,
gnutls_ia_apptype_t msg_type,
const char *data, size_t sizeofdata)
{
@@ -90,11 +90,11 @@ _gnutls_send_inner_application (gnutls_session_t session,
}
*(unsigned char *) p = (unsigned char) (msg_type & 0xFF);
- _gnutls_write_uint24 (sizeofdata, p + 1);
+ mhd_gtls_write_uint24 (sizeofdata, p + 1);
memcpy (p + 4, data, sizeofdata);
}
- len = _gnutls_send_int (session, GNUTLS_INNER_APPLICATION, -1, p, plen);
+ len = mhd_gtls_send_int (session, GNUTLS_INNER_APPLICATION, -1, p, plen);
if (p)
gnutls_free (p);
@@ -106,14 +106,14 @@ _gnutls_send_inner_application (gnutls_session_t session,
*MSG_TYPE, and the data in DATA of max SIZEOFDATA size. Return the
number of bytes read, or an error code. */
static ssize_t
-_gnutls_recv_inner_application (gnutls_session_t session,
+_gnutls_recv_inner_application (mhd_gtls_session_t session,
gnutls_ia_apptype_t * msg_type,
opaque * data, size_t sizeofdata)
{
ssize_t len;
opaque pkt[4];
- len = _gnutls_recv_int (session, GNUTLS_INNER_APPLICATION, -1, pkt, 4);
+ len = mhd_gtls_recv_int (session, GNUTLS_INNER_APPLICATION, -1, pkt, 4);
if (len != 4)
{
gnutls_assert ();
@@ -121,7 +121,7 @@ _gnutls_recv_inner_application (gnutls_session_t session,
}
*msg_type = pkt[0];
- len = _gnutls_read_uint24 (&pkt[1]);
+ len = mhd_gtls_read_uint24 (&pkt[1]);
if (*msg_type != GNUTLS_IA_APPLICATION_PAYLOAD && len != CHECKSUM_SIZE)
{
@@ -140,7 +140,7 @@ _gnutls_recv_inner_application (gnutls_session_t session,
{
int tmplen = len;
- len = _gnutls_recv_int (session, GNUTLS_INNER_APPLICATION, -1,
+ len = mhd_gtls_recv_int (session, GNUTLS_INNER_APPLICATION, -1,
data, tmplen);
if (len != tmplen)
{
@@ -159,7 +159,7 @@ _gnutls_recv_inner_application (gnutls_session_t session,
respectively). LABEL and LABEL_SIZE is used as the label. The
result is placed in pre-allocated OUT of OUTSIZE length. */
static int
-_gnutls_ia_prf (gnutls_session_t session,
+_gnutls_ia_prf (mhd_gtls_session_t session,
size_t label_size,
const char *label,
size_t extra_size,
@@ -181,7 +181,7 @@ _gnutls_ia_prf (gnutls_session_t session,
TLS_RANDOM_SIZE);
memcpy (seed + 2 * TLS_RANDOM_SIZE, extra, extra_size);
- ret = _gnutls_PRF (session, session->security_parameters.inner_secret,
+ ret = mhd_gtls_PRF (session, session->security_parameters.inner_secret,
TLS_MASTER_SIZE,
label, label_size, seed, seedsize, outsize, out);
@@ -192,7 +192,7 @@ _gnutls_ia_prf (gnutls_session_t session,
/**
* gnutls_ia_permute_inner_secret:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @session_keys_size: Size of generated session keys (0 if none).
* @session_keys: Generated session keys, used to permute inner secret
* (NULL if none).
@@ -205,7 +205,7 @@ _gnutls_ia_prf (gnutls_session_t session,
* Return value: Return zero on success, or a negative error code.
**/
int
-gnutls_ia_permute_inner_secret (gnutls_session_t session,
+gnutls_ia_permute_inner_secret (mhd_gtls_session_t session,
size_t session_keys_size,
const char *session_keys)
{
@@ -220,7 +220,7 @@ gnutls_ia_permute_inner_secret (gnutls_session_t session,
/**
* gnutls_ia_generate_challenge:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @buffer_size: size of output buffer.
* @buffer: pre-allocated buffer to contain @buffer_size bytes of output.
*
@@ -230,7 +230,7 @@ gnutls_ia_permute_inner_secret (gnutls_session_t session,
* Return value: Returns 0 on success, or an negative error code.
**/
int
-gnutls_ia_generate_challenge (gnutls_session_t session,
+gnutls_ia_generate_challenge (mhd_gtls_session_t session,
size_t buffer_size, char *buffer)
{
return _gnutls_ia_prf (session,
@@ -240,7 +240,7 @@ gnutls_ia_generate_challenge (gnutls_session_t session,
/**
* gnutls_ia_extract_inner_secret:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @buffer: pre-allocated buffer to hold 48 bytes of inner secret.
*
* Copy the 48 bytes large inner secret into the specified buffer
@@ -255,14 +255,14 @@ gnutls_ia_generate_challenge (gnutls_session_t session,
* key from the inner secret.
**/
void
-gnutls_ia_extract_inner_secret (gnutls_session_t session, char *buffer)
+gnutls_ia_extract_inner_secret (mhd_gtls_session_t session, char *buffer)
{
memcpy (buffer, session->security_parameters.inner_secret, TLS_MASTER_SIZE);
}
/**
* gnutls_ia_endphase_send:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @final_p: Set iff this should signal the final phase.
*
* Send a TLS/IA end phase message.
@@ -276,7 +276,7 @@ gnutls_ia_extract_inner_secret (gnutls_session_t session, char *buffer)
* Return value: Return 0 on success, or an error code.
**/
int
-gnutls_ia_endphase_send (gnutls_session_t session, int final_p)
+gnutls_ia_endphase_send (mhd_gtls_session_t session, int final_p)
{
opaque local_checksum[CHECKSUM_SIZE];
int client = session->security_parameters.entity == GNUTLS_CLIENT;
@@ -286,7 +286,7 @@ gnutls_ia_endphase_send (gnutls_session_t session, int final_p)
ssize_t len;
int ret;
- ret = _gnutls_PRF (session, session->security_parameters.inner_secret,
+ ret = mhd_gtls_PRF (session, session->security_parameters.inner_secret,
TLS_MASTER_SIZE, label, size_of_label - 1,
/* XXX specification unclear on seed. */
"", 0, CHECKSUM_SIZE, local_checksum);
@@ -300,7 +300,7 @@ gnutls_ia_endphase_send (gnutls_session_t session, int final_p)
/* XXX Instead of calling this function over and over...?
* while (len == GNUTLS_E_AGAIN || len == GNUTLS_E_INTERRUPTED)
- * len = _gnutls_io_write_flush(session);
+ * len = mhd_gtls_io_write_flush(session);
*/
if (len < 0)
@@ -314,7 +314,7 @@ gnutls_ia_endphase_send (gnutls_session_t session, int final_p)
/**
* gnutls_ia_verify_endphase:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @checksum: 12-byte checksum data, received from gnutls_ia_recv().
*
* Verify TLS/IA end phase checksum data. If verification fails, the
@@ -330,7 +330,7 @@ gnutls_ia_endphase_send (gnutls_session_t session, int final_p)
* %GNUTLS_E_IA_VERIFY_FAILED is returned.
**/
int
-gnutls_ia_verify_endphase (gnutls_session_t session, const char *checksum)
+gnutls_ia_verify_endphase (mhd_gtls_session_t session, const char *checksum)
{
char local_checksum[CHECKSUM_SIZE];
int client = session->security_parameters.entity == GNUTLS_CLIENT;
@@ -339,7 +339,7 @@ gnutls_ia_verify_endphase (gnutls_session_t session, const char *checksum)
sizeof (client_finished_label);
int ret;
- ret = _gnutls_PRF (session, session->security_parameters.inner_secret,
+ ret = mhd_gtls_PRF (session, session->security_parameters.inner_secret,
TLS_MASTER_SIZE,
label, size_of_label - 1,
"", 0, CHECKSUM_SIZE, local_checksum);
@@ -351,7 +351,7 @@ gnutls_ia_verify_endphase (gnutls_session_t session, const char *checksum)
if (memcmp (local_checksum, checksum, CHECKSUM_SIZE) != 0)
{
- ret = gnutls_alert_send (session, GNUTLS_AL_FATAL,
+ ret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
GNUTLS_A_INNER_APPLICATION_VERIFICATION);
if (ret < 0)
{
@@ -367,7 +367,7 @@ gnutls_ia_verify_endphase (gnutls_session_t session, const char *checksum)
/**
* gnutls_ia_send: Send peer the specified TLS/IA data.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @data: contains the data to send
* @sizeofdata: is the length of the data
*
@@ -393,7 +393,7 @@ gnutls_ia_verify_endphase (gnutls_session_t session, const char *checksum)
* Returns the number of bytes sent, or a negative error code.
**/
ssize_t
-gnutls_ia_send (gnutls_session_t session, const char *data, size_t sizeofdata)
+gnutls_ia_send (mhd_gtls_session_t session, const char *data, size_t sizeofdata)
{
ssize_t len;
@@ -406,7 +406,7 @@ gnutls_ia_send (gnutls_session_t session, const char *data, size_t sizeofdata)
/**
* gnutls_ia_recv - read data from the TLS/IA protocol
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @data: the buffer that the data will be read into, must hold >= 12 bytes.
* @sizeofdata: the number of requested bytes, must be >= 12.
*
@@ -433,7 +433,7 @@ gnutls_ia_send (gnutls_session_t session, const char *data, size_t sizeofdata)
* application phase finished message has been sent by the server.
**/
ssize_t
-gnutls_ia_recv (gnutls_session_t session, char *data, size_t sizeofdata)
+gnutls_ia_recv (mhd_gtls_session_t session, char *data, size_t sizeofdata)
{
gnutls_ia_apptype_t msg_type;
ssize_t len;
@@ -453,7 +453,7 @@ gnutls_ia_recv (gnutls_session_t session, char *data, size_t sizeofdata)
though. */
int
-_gnutls_ia_client_handshake (gnutls_session_t session)
+_gnutls_ia_client_handshake (mhd_gtls_session_t session)
{
char *buf = NULL;
size_t buflen = 0;
@@ -461,7 +461,7 @@ _gnutls_ia_client_handshake (gnutls_session_t session)
ssize_t len;
int ret;
const struct gnutls_ia_client_credentials_st *cred =
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
if (cred == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -476,7 +476,7 @@ _gnutls_ia_client_handshake (gnutls_session_t session)
if (ret)
{
int tmpret;
- tmpret = gnutls_alert_send (session, GNUTLS_AL_FATAL,
+ tmpret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
GNUTLS_A_INNER_APPLICATION_FAILURE);
if (tmpret < 0)
gnutls_assert ();
@@ -522,14 +522,14 @@ _gnutls_ia_client_handshake (gnutls_session_t session)
}
int
-_gnutls_ia_server_handshake (gnutls_session_t session)
+_gnutls_ia_server_handshake (mhd_gtls_session_t session)
{
gnutls_ia_apptype_t msg_type;
ssize_t len;
char buf[1024];
int ret;
const struct gnutls_ia_server_credentials_st *cred =
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
if (cred == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -563,7 +563,7 @@ _gnutls_ia_server_handshake (gnutls_session_t session)
if (ret < 0)
{
int tmpret;
- tmpret = gnutls_alert_send (session, GNUTLS_AL_FATAL,
+ tmpret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
GNUTLS_A_INNER_APPLICATION_FAILURE);
if (tmpret < 0)
gnutls_assert ();
@@ -594,18 +594,18 @@ _gnutls_ia_server_handshake (gnutls_session_t session)
/**
* gnutls_ia_handshake_p:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
- * Predicate to be used after gnutls_handshake() to decide whether to
+ * Predicate to be used after MHD_gnutls_handshake() to decide whether to
* invoke gnutls_ia_handshake(). Usable by both clients and servers.
*
* Return value: non-zero if TLS/IA handshake is expected, zero
* otherwise.
**/
int
-gnutls_ia_handshake_p (gnutls_session_t session)
+gnutls_ia_handshake_p (mhd_gtls_session_t session)
{
- tls_ext_st *ext = &session->security_parameters.extensions;
+ mhd_gtls_ext_st *ext = &session->security_parameters.extensions;
/* Either local side or peer doesn't do TLS/IA: don't do IA */
@@ -614,7 +614,7 @@ gnutls_ia_handshake_p (gnutls_session_t session)
/* Not resuming or we don't allow skipping on resumption locally: do IA */
- if (!ext->gnutls_ia_allowskip || !gnutls_session_is_resumed (session))
+ if (!ext->gnutls_ia_allowskip || !MHD_gtls_session_is_resumed (session))
return 1;
/* If we're resuming and we and the peer both allow skipping on resumption:
@@ -626,15 +626,15 @@ gnutls_ia_handshake_p (gnutls_session_t session)
/**
* gnutls_ia_handshake:
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Perform a TLS/IA handshake. This should be called after
- * gnutls_handshake() iff gnutls_ia_handshake_p().
+ * MHD_gnutls_handshake() iff gnutls_ia_handshake_p().
*
* Return 0 on success, or an error code.
**/
int
-gnutls_ia_handshake (gnutls_session_t session)
+gnutls_ia_handshake (mhd_gtls_session_t session)
{
int ret;
@@ -696,11 +696,11 @@ gnutls_ia_free_client_credentials (gnutls_ia_client_credentials_t sc)
* server, and to get a new AVP to send to the server.
*
* The callback's function form is:
- * int (*avp_func) (gnutls_session_t session, void *ptr,
+ * int (*avp_func) (mhd_gtls_session_t session, void *ptr,
* const char *last, size_t lastlen,
* char **next, size_t *nextlen);
*
- * The @session parameter is the #gnutls_session_t structure
+ * The @session parameter is the #mhd_gtls_session_t structure
* corresponding to the current session. The @ptr parameter is the
* application hook pointer, set through
* gnutls_ia_set_client_avp_ptr(). The AVP received from the server
@@ -802,11 +802,11 @@ gnutls_ia_free_server_credentials (gnutls_ia_server_credentials_t sc)
* Set the TLS/IA AVP callback handler used for the session.
*
* The callback's function form is:
- * int (*avp_func) (gnutls_session_t session, void *ptr,
+ * int (*avp_func) (mhd_gtls_session_t session, void *ptr,
* const char *last, size_t lastlen,
* char **next, size_t *nextlen);
*
- * The @session parameter is the #gnutls_session_t structure
+ * The @session parameter is the #mhd_gtls_session_t structure
* corresponding to the current session. The @ptr parameter is the
* application hook pointer, set through
* gnutls_ia_set_server_avp_ptr(). The AVP received from the client
@@ -873,7 +873,7 @@ gnutls_ia_get_server_avp_ptr (gnutls_ia_server_credentials_t cred)
/**
* gnutls_ia_enable - Indicate willingness for TLS/IA application phases
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @allow_skip_on_resume: non-zero if local party allows to skip the
* TLS/IA application phases for a resumed session.
*
@@ -897,7 +897,7 @@ gnutls_ia_get_server_avp_ptr (gnutls_ia_server_credentials_t cred)
* functions.
**/
void
-gnutls_ia_enable (gnutls_session_t session, int allow_skip_on_resume)
+gnutls_ia_enable (mhd_gtls_session_t session, int allow_skip_on_resume)
{
session->security_parameters.extensions.gnutls_ia_enable = 1;
session->security_parameters.extensions.gnutls_ia_allowskip =
diff --git a/src/daemon/https/openpgp/gnutls_openpgp.c b/src/daemon/https/openpgp/gnutls_openpgp.c
@@ -36,7 +36,7 @@
#define OPENPGP_NAME_SIZE 256
-#define datum_append(x, y, z) _gnutls_datum_append_m (x, y, z, gnutls_realloc)
+#define datum_append(x, y, z) mhd_gtls_datum_append_m (x, y, z, gnutls_realloc)
static void
release_mpi_array (mpi_t * arr, size_t n)
@@ -46,7 +46,7 @@ release_mpi_array (mpi_t * arr, size_t n)
while (arr && n--)
{
x = *arr;
- _gnutls_mpi_release (&x);
+ mhd_gtls_mpi_release (&x);
*arr = NULL;
arr++;
}
@@ -137,7 +137,7 @@ openpgp_pk_to_gnutls_cert (gnutls_cert * cert, cdk_pkt_pubkey_t pk)
{
nbytes = sizeof (buf) / sizeof (buf[0]);
cdk_pk_get_mpi (pk, i, buf, nbytes, &nbytes, NULL);
- rc = _gnutls_mpi_scan_pgp (&cert->params[i], buf, &nbytes);
+ rc = mhd_gtls_mpi_scan_pgp (&cert->params[i], buf, &nbytes);
if (rc)
{
rc = GNUTLS_E_MPI_SCAN_FAILED;
@@ -221,7 +221,7 @@ _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
{
nbytes = sizeof (buf) / sizeof (buf[0]);
cdk_pk_get_mpi (sk->pk, i, buf, nbytes, &nbytes, NULL);
- rc = _gnutls_mpi_scan_pgp (&pkey->params[i], buf, &nbytes);
+ rc = mhd_gtls_mpi_scan_pgp (&pkey->params[i], buf, &nbytes);
if (rc)
{
rc = GNUTLS_E_MPI_SCAN_FAILED;
@@ -235,7 +235,7 @@ _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
{
nbytes = sizeof (buf) / sizeof (buf[0]);
cdk_sk_get_mpi (sk, j, buf, nbytes, &nbytes, NULL);
- rc = _gnutls_mpi_scan_pgp (&pkey->params[i], buf, &nbytes);
+ rc = mhd_gtls_mpi_scan_pgp (&pkey->params[i], buf, &nbytes);
if (rc)
{
rc = GNUTLS_E_MPI_SCAN_FAILED;
@@ -298,19 +298,19 @@ _gnutls_openpgp_raw_key_to_gcert (gnutls_cert * cert,
}
/**
- * gnutls_certificate_set_openpgp_key - Used to set keys in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * gnutls_certificate_set_openpgp_key - Used to set keys in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @key: contains an openpgp public key
* @pkey: is an openpgp private key
*
* This function sets a certificate/private key pair in the
- * gnutls_certificate_credentials_t structure. This function may be called
+ * mhd_gtls_cert_credentials_t structure. This function may be called
* more than once (in case multiple keys/certificates exist for the
* server).
*
**/
int
-gnutls_certificate_set_openpgp_key (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_key (mhd_gtls_cert_credentials_t
res, gnutls_openpgp_crt_t crt,
gnutls_openpgp_privkey_t pkey)
{
@@ -318,7 +318,7 @@ gnutls_certificate_set_openpgp_key (gnutls_certificate_credentials_t
/* this should be first */
- res->pkey = gnutls_realloc_fast (res->pkey,
+ res->pkey = mhd_gtls_realloc_fast (res->pkey,
(res->ncerts + 1) *
sizeof (gnutls_privkey));
if (res->pkey == NULL)
@@ -334,7 +334,7 @@ gnutls_certificate_set_openpgp_key (gnutls_certificate_credentials_t
return ret;
}
- res->cert_list = gnutls_realloc_fast (res->cert_list,
+ res->cert_list = mhd_gtls_realloc_fast (res->cert_list,
(1 +
res->ncerts) *
sizeof (gnutls_cert *));
@@ -344,7 +344,7 @@ gnutls_certificate_set_openpgp_key (gnutls_certificate_credentials_t
return GNUTLS_E_MEMORY_ERROR;
}
- res->cert_list_length = gnutls_realloc_fast (res->cert_list_length,
+ res->cert_list_length = mhd_gtls_realloc_fast (res->cert_list_length,
(1 +
res->ncerts) * sizeof (int));
if (res->cert_list_length == NULL)
@@ -489,7 +489,7 @@ stream_to_datum (cdk_stream_t inp, gnutls_datum_t * raw)
* should only contain one key which should not be encrypted.
**/
int
-gnutls_certificate_set_openpgp_key_mem (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_key_mem (mhd_gtls_cert_credentials_t
res, const gnutls_datum_t * icert,
const gnutls_datum_t * ikey,
gnutls_openpgp_crt_fmt_t format)
@@ -551,7 +551,7 @@ gnutls_certificate_set_openpgp_key_mem (gnutls_certificate_credentials_t
* should only contain one key which should not be encrypted.
**/
int
-gnutls_certificate_set_openpgp_key_file (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_key_file (mhd_gtls_cert_credentials_t
res, const char *certfile,
const char *keyfile,
gnutls_openpgp_crt_fmt_t format)
@@ -652,7 +652,7 @@ gnutls_openpgp_count_key_names (const gnutls_datum_t * cert)
*
**/
int
-gnutls_certificate_set_openpgp_keyring_file (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_keyring_file (mhd_gtls_cert_credentials_t
c, const char *file,
gnutls_openpgp_crt_fmt_t format)
{
@@ -696,7 +696,7 @@ gnutls_certificate_set_openpgp_keyring_file (gnutls_certificate_credentials_t
*
**/
int
-gnutls_certificate_set_openpgp_keyring_mem (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_keyring_mem (mhd_gtls_cert_credentials_t
c, const opaque * data,
size_t dlen,
gnutls_openpgp_crt_fmt_t format)
@@ -749,7 +749,7 @@ gnutls_certificate_set_openpgp_keyring_mem (gnutls_certificate_credentials_t
/*-
* _gnutls_openpgp_request_key - Receives a key from a database, key server etc
* @ret - a pointer to gnutls_datum_t structure.
- * @cred - a gnutls_certificate_credentials_t structure.
+ * @cred - a mhd_gtls_cert_credentials_t structure.
* @key_fingerprint - The keyFingerprint
* @key_fingerprint_size - the size of the fingerprint
*
@@ -758,8 +758,8 @@ gnutls_certificate_set_openpgp_keyring_mem (gnutls_certificate_credentials_t
*
-*/
int
-_gnutls_openpgp_request_key (gnutls_session_t session, gnutls_datum_t * ret,
- const gnutls_certificate_credentials_t cred,
+_gnutls_openpgp_request_key (mhd_gtls_session_t session, gnutls_datum_t * ret,
+ const mhd_gtls_cert_credentials_t cred,
opaque * key_fpr, int key_fpr_size)
{
int rc = 0;
@@ -836,8 +836,8 @@ error:
*
**/
void
-gnutls_openpgp_set_recv_key_function (gnutls_session_t session,
- gnutls_openpgp_recv_key_func func)
+gnutls_openpgp_set_recv_key_function (mhd_gtls_session_t session,
+ mhd_gtls_openpgp_recv_key_func func)
{
session->internals.openpgp_recv_key_func = func;
}
@@ -870,7 +870,7 @@ _gnutls_openpgp_privkey_to_gkey (gnutls_privkey * dest,
cleanup:
for (i = 0; i < src->pkey.params_size; i++)
- _gnutls_mpi_release (&dest->params[i]);
+ mhd_gtls_mpi_release (&dest->params[i]);
return ret;
}
@@ -954,7 +954,7 @@ gnutls_openpgp_privkey_sign_hash (gnutls_openpgp_privkey_t key,
return GNUTLS_E_INVALID_REQUEST;
}
- result = _gnutls_sign (key->pkey.pk_algorithm, key->pkey.params,
+ result = mhd_gtls_sign (key->pkey.pk_algorithm, key->pkey.params,
key->pkey.params_size, hash, signature);
if (result < 0)
{
diff --git a/src/daemon/https/openpgp/gnutls_openpgp.h b/src/daemon/https/openpgp/gnutls_openpgp.h
@@ -31,17 +31,17 @@ typedef enum
}key_attr_t;
int
-gnutls_certificate_set_openpgp_key_file (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_key_file (mhd_gtls_cert_credentials_t
res, const char *CERTFILE,
const char *KEYFILE, gnutls_openpgp_crt_fmt_t);
int gnutls_openpgp_count_key_names (const gnutls_datum_t * cert);
int gnutls_certificate_set_openpgp_keyring_file
-(gnutls_certificate_credentials_t c, const char *file, gnutls_openpgp_crt_fmt_t);
+(mhd_gtls_cert_credentials_t c, const char *file, gnutls_openpgp_crt_fmt_t);
int
-gnutls_certificate_set_openpgp_keyring_mem (gnutls_certificate_credentials_t
+gnutls_certificate_set_openpgp_keyring_mem (mhd_gtls_cert_credentials_t
c, const opaque * data,
size_t dlen, gnutls_openpgp_crt_fmt_t);
@@ -63,12 +63,12 @@ _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
gnutls_openpgp_crt_fmt_t format);
int
-_gnutls_openpgp_request_key (gnutls_session_t,
+_gnutls_openpgp_request_key (mhd_gtls_session_t,
gnutls_datum_t * ret,
- const gnutls_certificate_credentials_t cred,
+ const mhd_gtls_cert_credentials_t cred,
opaque * key_fpr, int key_fpr_size);
-int _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t,
+int _gnutls_openpgp_verify_key (const mhd_gtls_cert_credentials_t,
const gnutls_datum_t * cert_list,
int cert_list_length, unsigned int *status);
int _gnutls_openpgp_fingerprint (const gnutls_datum_t * cert,
diff --git a/src/daemon/https/openpgp/openpgp.h b/src/daemon/https/openpgp/openpgp.h
@@ -117,7 +117,7 @@ int gnutls_openpgp_crt_verify_self(gnutls_openpgp_crt_t key,
/* certificate authentication stuff.
*/
-int gnutls_certificate_set_openpgp_key(gnutls_certificate_credentials_t
+int gnutls_certificate_set_openpgp_key(mhd_gtls_cert_credentials_t
res,
gnutls_openpgp_crt_t key,
gnutls_openpgp_privkey_t pkey);
diff --git a/src/daemon/https/openpgp/pgp_privkey.c b/src/daemon/https/openpgp/pgp_privkey.c
@@ -64,7 +64,7 @@ gnutls_openpgp_privkey_deinit (gnutls_openpgp_privkey_t key)
if (!key)
return;
- _gnutls_gkey_deinit (&key->pkey);
+ mhd_gtls_gkey_deinit (&key->pkey);
gnutls_free (key);
}
diff --git a/src/daemon/https/tests.c b/src/daemon/https/tests.c
@@ -37,8 +37,8 @@
#include <tests.h>
extern gnutls_srp_client_credentials_t srp_cred;
-extern gnutls_anon_client_credentials_t anon_cred;
-extern gnutls_certificate_credentials_t xcred;
+extern mhd_gtls_anon_client_credentials_t anon_cred;
+extern mhd_gtls_cert_credentials_t xcred;
extern int verbose;
@@ -54,13 +54,13 @@ static int sfree = 0;
static int handshake_output = 0;
int
-do_handshake (gnutls_session_t session)
+do_handshake (mhd_gtls_session_t session)
{
int ret, alert;
do
{
- ret = gnutls_handshake (session);
+ ret = MHD_gnutls_handshake (session);
}
while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN);
@@ -74,7 +74,7 @@ do_handshake (gnutls_session_t session)
alert = gnutls_alert_get (session);
printf ("\n");
printf ("*** Received alert [%d]: %s\n",
- alert, gnutls_alert_get_name (alert));
+ alert, MHD_gnutls_alert_get_name (alert));
}
}
@@ -98,7 +98,7 @@ do_handshake (gnutls_session_t session)
gnutls_session_get_data (session, session_data, &session_data_size);
session_id_size = sizeof (session_id);
- gnutls_session_get_id (session, session_id, &session_id_size);
+ MHD_gtls_session_get_id (session, session_id, &session_id_size);
return TEST_SUCCEED;
}
@@ -118,43 +118,43 @@ static const int mac_priority[16] =
{ MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_MAC_MD5, 0 };
static const int cert_type_priority[16] = { MHD_GNUTLS_CRT_X509, 0 };
-#define ADD_ALL_CIPHERS(session) gnutls_cipher_set_priority(session, cipher_priority)
-#define ADD_ALL_COMP(session) gnutls_compression_set_priority(session, comp_priority)
-#define ADD_ALL_MACS(session) gnutls_mac_set_priority(session, mac_priority)
-#define ADD_ALL_KX(session) gnutls_kx_set_priority(session, kx_priority)
-#define ADD_ALL_PROTOCOLS(session) gnutls_protocol_set_priority(session, protocol_priority)
-#define ADD_ALL_CERTTYPES(session) gnutls_certificate_type_set_priority(session, cert_type_priority)
+#define ADD_ALL_CIPHERS(session) MHD_gnutls_cipher_set_priority(session, cipher_priority)
+#define ADD_ALL_COMP(session) MHD_gnutls_compression_set_priority(session, comp_priority)
+#define ADD_ALL_MACS(session) MHD_gnutls_mac_set_priority(session, mac_priority)
+#define ADD_ALL_KX(session) MHD_gnutls_kx_set_priority(session, kx_priority)
+#define ADD_ALL_PROTOCOLS(session) MHD_gnutls_protocol_set_priority(session, protocol_priority)
+#define ADD_ALL_CERTTYPES(session) MHD_gnutls_certificate_type_set_priority(session, cert_type_priority)
static void
-ADD_KX (gnutls_session_t session, int kx)
+ADD_KX (mhd_gtls_session_t session, int kx)
{
static int _kx_priority[] = { 0, 0 };
_kx_priority[0] = kx;
- gnutls_kx_set_priority (session, _kx_priority);
+ MHD_gnutls_kx_set_priority (session, _kx_priority);
}
static void
-ADD_KX2 (gnutls_session_t session, int kx1, int kx2)
+ADD_KX2 (mhd_gtls_session_t session, int kx1, int kx2)
{
static int _kx_priority[] = { 0, 0, 0 };
_kx_priority[0] = kx1;
_kx_priority[1] = kx2;
- gnutls_kx_set_priority (session, _kx_priority);
+ MHD_gnutls_kx_set_priority (session, _kx_priority);
}
static void
-ADD_CIPHER (gnutls_session_t session, int cipher)
+ADD_CIPHER (mhd_gtls_session_t session, int cipher)
{
static int _cipher_priority[] = { 0, 0 };
_cipher_priority[0] = cipher;
- gnutls_cipher_set_priority (session, _cipher_priority);
+ MHD_gnutls_cipher_set_priority (session, _cipher_priority);
}
static void
-ADD_CIPHER4 (gnutls_session_t session, int cipher1, int cipher2, int cipher3,
+ADD_CIPHER4 (mhd_gtls_session_t session, int cipher1, int cipher2, int cipher3,
int cipher4)
{
static int _cipher_priority[] = { 0, 0, 0, 0, 0 };
@@ -163,61 +163,61 @@ ADD_CIPHER4 (gnutls_session_t session, int cipher1, int cipher2, int cipher3,
_cipher_priority[2] = cipher3;
_cipher_priority[3] = cipher4;
- gnutls_cipher_set_priority (session, _cipher_priority);
+ MHD_gnutls_cipher_set_priority (session, _cipher_priority);
}
static void
-ADD_MAC (gnutls_session_t session, int mac)
+ADD_MAC (mhd_gtls_session_t session, int mac)
{
static int _mac_priority[] = { 0, 0 };
_mac_priority[0] = mac;
- gnutls_mac_set_priority (session, _mac_priority);
+ MHD_gnutls_mac_set_priority (session, _mac_priority);
}
static void
-ADD_COMP (gnutls_session_t session, int c)
+ADD_COMP (mhd_gtls_session_t session, int c)
{
static int _comp_priority[] = { 0, 0 };
_comp_priority[0] = c;
- gnutls_compression_set_priority (session, _comp_priority);
+ MHD_gnutls_compression_set_priority (session, _comp_priority);
}
static void
-ADD_CERTTYPE (gnutls_session_t session, int ctype)
+ADD_CERTTYPE (mhd_gtls_session_t session, int ctype)
{
static int _ct_priority[] = { 0, 0 };
_ct_priority[0] = ctype;
- gnutls_certificate_type_set_priority (session, _ct_priority);
+ MHD_gnutls_certificate_type_set_priority (session, _ct_priority);
}
static void
-ADD_PROTOCOL (gnutls_session_t session, int protocol)
+ADD_PROTOCOL (mhd_gtls_session_t session, int protocol)
{
static int _proto_priority[] = { 0, 0 };
_proto_priority[0] = protocol;
- gnutls_protocol_set_priority (session, _proto_priority);
+ MHD_gnutls_protocol_set_priority (session, _proto_priority);
}
static void
-ADD_PROTOCOL3 (gnutls_session_t session, int p1, int p2, int p3)
+ADD_PROTOCOL3 (mhd_gtls_session_t session, int p1, int p2, int p3)
{
static int _proto_priority[] = { 0, 0, 0, 0 };
_proto_priority[0] = p1;
_proto_priority[1] = p2;
_proto_priority[2] = p3;
- gnutls_protocol_set_priority (session, _proto_priority);
+ MHD_gnutls_protocol_set_priority (session, _proto_priority);
}
#ifdef ENABLE_SRP
static int srp_detected;
int
-_test_srp_username_callback (gnutls_session_t session,
+_test_srp_username_callback (mhd_gtls_session_t session,
char **username, char **password)
{
srp_detected = 1;
@@ -226,7 +226,7 @@ _test_srp_username_callback (gnutls_session_t session,
}
test_code_t
-test_srp (gnutls_session_t session)
+test_srp (mhd_gtls_session_t session)
{
int ret;
@@ -242,7 +242,7 @@ test_srp (gnutls_session_t session)
gnutls_srp_set_client_credentials_function (srp_cred,
_test_srp_username_callback);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_SRP, srp_cred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_SRP, srp_cred);
ret = do_handshake (session);
@@ -256,7 +256,7 @@ test_srp (gnutls_session_t session)
#endif
test_code_t
-test_server (gnutls_session_t session)
+test_server (mhd_gtls_session_t session)
{
int ret, i = 0;
char buf[5 * 1024];
@@ -275,14 +275,14 @@ test_server (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret != TEST_SUCCEED)
return TEST_FAILED;
- gnutls_record_send (session, snd_buf, sizeof (snd_buf) - 1);
- ret = gnutls_record_recv (session, buf, sizeof (buf) - 1);
+ MHD_gnutls_record_send (session, snd_buf, sizeof (snd_buf) - 1);
+ ret = MHD_gnutls_record_recv (session, buf, sizeof (buf) - 1);
if (ret < 0)
return TEST_FAILED;
@@ -313,7 +313,7 @@ static gnutls_datum_t exp = { NULL, 0 }, mod =
NULL, 0};
test_code_t
-test_export (gnutls_session_t session)
+test_export (mhd_gtls_session_t session)
{
int ret;
@@ -324,21 +324,21 @@ test_export (gnutls_session_t session)
ADD_KX (session, MHD_GNUTLS_KX_RSA_EXPORT);
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
{
export_true = 1;
- gnutls_rsa_export_get_pubkey (session, &exp, &mod);
+ MHD_gtls_rsa_export_get_pubkey (session, &exp, &mod);
}
return ret;
}
test_code_t
-test_export_info (gnutls_session_t session)
+test_export_info (mhd_gtls_session_t session)
{
int ret2, ret;
gnutls_datum_t exp2, mod2;
@@ -354,13 +354,13 @@ test_export_info (gnutls_session_t session)
ADD_KX (session, MHD_GNUTLS_KX_RSA_EXPORT);
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
{
- ret2 = gnutls_rsa_export_get_pubkey (session, &exp2, &mod2);
+ ret2 = MHD_gtls_rsa_export_get_pubkey (session, &exp2, &mod2);
if (ret2 >= 0)
{
printf ("\n");
@@ -390,7 +390,7 @@ test_export_info (gnutls_session_t session)
static gnutls_datum_t pubkey = { NULL, 0 };
test_code_t
-test_dhe (gnutls_session_t session)
+test_dhe (mhd_gtls_session_t session)
{
int ret;
@@ -401,17 +401,17 @@ test_dhe (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_KX2 (session, MHD_GNUTLS_KX_DHE_RSA, MHD_GNUTLS_KX_DHE_DSS);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
- gnutls_dh_get_pubkey (session, &pubkey);
+ MHD_gnutls_dh_get_pubkey (session, &pubkey);
return ret;
}
test_code_t
-test_dhe_group (gnutls_session_t session)
+test_dhe_group (mhd_gtls_session_t session)
{
int ret, ret2;
gnutls_datum_t gen, prime, pubkey2;
@@ -427,11 +427,11 @@ test_dhe_group (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_KX2 (session, MHD_GNUTLS_KX_DHE_RSA, MHD_GNUTLS_KX_DHE_DSS);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
- ret2 = gnutls_dh_get_group (session, &gen, &prime);
+ ret2 = MHD_gnutls_dh_get_group (session, &gen, &prime);
if (ret2 >= 0)
{
printf ("\n");
@@ -444,7 +444,7 @@ test_dhe_group (gnutls_session_t session)
if (print)
printf (" Prime [%d bits]: %s\n", prime.size * 8, print);
- gnutls_dh_get_pubkey (session, &pubkey2);
+ MHD_gnutls_dh_get_pubkey (session, &pubkey2);
print = raw_to_string (pubkey2.data, pubkey2.size);
if (print)
printf (" Pubkey [%d bits]: %s\n", pubkey2.size * 8, print);
@@ -459,7 +459,7 @@ test_dhe_group (gnutls_session_t session)
}
test_code_t
-test_ssl3 (gnutls_session_t session)
+test_ssl3 (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -468,7 +468,7 @@ test_ssl3 (gnutls_session_t session)
ADD_PROTOCOL (session, MHD_GNUTLS_SSL3);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
@@ -485,7 +485,7 @@ got_alarm (int k)
}
test_code_t
-test_bye (gnutls_session_t session)
+test_bye (mhd_gtls_session_t session)
{
int ret;
char data[20];
@@ -501,13 +501,13 @@ test_bye (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_FAILED)
return ret;
- ret = gnutls_bye (session, GNUTLS_SHUT_WR);
+ ret = MHD_gnutls_bye (session, GNUTLS_SHUT_WR);
if (ret < 0)
return TEST_FAILED;
@@ -521,7 +521,7 @@ test_bye (gnutls_session_t session)
do
{
- ret = gnutls_record_recv (session, data, sizeof (data));
+ ret = MHD_gnutls_record_recv (session, data, sizeof (data));
}
while (ret > 0);
@@ -544,7 +544,7 @@ test_bye (gnutls_session_t session)
test_code_t
-test_aes (gnutls_session_t session)
+test_aes (mhd_gtls_session_t session)
{
int ret;
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_AES_128_CBC);
@@ -553,7 +553,7 @@ test_aes (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
@@ -561,7 +561,7 @@ test_aes (gnutls_session_t session)
#ifdef ENABLE_CAMELLIA
test_code_t
-test_camellia (gnutls_session_t session)
+test_camellia (mhd_gtls_session_t session)
{
int ret;
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC);
@@ -570,7 +570,7 @@ test_camellia (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
@@ -578,7 +578,7 @@ test_camellia (gnutls_session_t session)
#endif
test_code_t
-test_openpgp1 (gnutls_session_t session)
+test_openpgp1 (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -587,7 +587,7 @@ test_openpgp1 (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_FAILED)
@@ -600,7 +600,7 @@ test_openpgp1 (gnutls_session_t session)
}
test_code_t
-test_unknown_ciphersuites (gnutls_session_t session)
+test_unknown_ciphersuites (mhd_gtls_session_t session)
{
int ret;
#ifdef ENABLE_CAMELLIA
@@ -616,14 +616,14 @@ test_unknown_ciphersuites (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
}
test_code_t
-test_md5 (gnutls_session_t session)
+test_md5 (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -632,7 +632,7 @@ test_md5 (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_MAC (session, MHD_GNUTLS_MAC_MD5);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
@@ -640,7 +640,7 @@ test_md5 (gnutls_session_t session)
#ifdef HAVE_LIBZ
test_code_t
-test_zlib (gnutls_session_t session)
+test_zlib (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -649,7 +649,7 @@ test_zlib (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
@@ -657,10 +657,10 @@ test_zlib (gnutls_session_t session)
#endif
test_code_t
-test_lzo (gnutls_session_t session)
+test_lzo (mhd_gtls_session_t session)
{
int ret;
- gnutls_handshake_set_private_extensions (session, 1);
+ MHD_gtls_handshake_set_private_extensions (session, 1);
ADD_ALL_CIPHERS (session);
ADD_COMP (session, MHD_GNUTLS_COMP_LZO);
@@ -668,7 +668,7 @@ test_lzo (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
@@ -676,7 +676,7 @@ test_lzo (gnutls_session_t session)
}
test_code_t
-test_sha (gnutls_session_t session)
+test_sha (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -685,14 +685,14 @@ test_sha (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_MAC (session, MHD_GNUTLS_MAC_SHA1);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
}
test_code_t
-test_3des (gnutls_session_t session)
+test_3des (mhd_gtls_session_t session)
{
int ret;
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_3DES_CBC);
@@ -701,14 +701,14 @@ test_3des (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
}
test_code_t
-test_arcfour (gnutls_session_t session)
+test_arcfour (mhd_gtls_session_t session)
{
int ret;
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_128);
@@ -717,14 +717,14 @@ test_arcfour (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
}
test_code_t
-test_arcfour_40 (gnutls_session_t session)
+test_arcfour_40 (mhd_gtls_session_t session)
{
int ret;
ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
@@ -733,14 +733,14 @@ test_arcfour_40 (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
return ret;
}
test_code_t
-test_tls1 (gnutls_session_t session)
+test_tls1 (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -749,7 +749,7 @@ test_tls1 (gnutls_session_t session)
ADD_PROTOCOL (session, GNUTLS_TLS1);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
@@ -760,7 +760,7 @@ test_tls1 (gnutls_session_t session)
}
test_code_t
-test_tls1_1 (gnutls_session_t session)
+test_tls1_1 (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -769,7 +769,7 @@ test_tls1_1 (gnutls_session_t session)
ADD_PROTOCOL (session, MHD_GNUTLS_TLS1_1);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
@@ -780,7 +780,7 @@ test_tls1_1 (gnutls_session_t session)
}
test_code_t
-test_tls1_1_fallback (gnutls_session_t session)
+test_tls1_1_fallback (mhd_gtls_session_t session)
{
int ret;
if (tls1_1_ok)
@@ -792,15 +792,15 @@ test_tls1_1_fallback (gnutls_session_t session)
ADD_PROTOCOL3 (session, MHD_GNUTLS_TLS1_1, GNUTLS_TLS1, MHD_GNUTLS_SSL3);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret != TEST_SUCCEED)
return TEST_FAILED;
- if (gnutls_protocol_get_version (session) == GNUTLS_TLS1)
+ if (MHD_gnutls_protocol_get_version (session) == GNUTLS_TLS1)
return TEST_SUCCEED;
- else if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ else if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
return TEST_UNSURE;
return TEST_FAILED;
@@ -811,7 +811,7 @@ test_tls1_1_fallback (gnutls_session_t session)
* but the previous SSL 3.0 test succeeded then disable TLS 1.0.
*/
test_code_t
-test_tls_disable (gnutls_session_t session)
+test_tls_disable (mhd_gtls_session_t session)
{
int ret;
if (tls1_ok != 0)
@@ -823,7 +823,7 @@ test_tls_disable (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_FAILED)
@@ -840,7 +840,7 @@ test_tls_disable (gnutls_session_t session)
}
test_code_t
-test_rsa_pms (gnutls_session_t session)
+test_rsa_pms (mhd_gtls_session_t session)
{
int ret;
@@ -855,19 +855,19 @@ test_rsa_pms (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_KX (session, MHD_GNUTLS_KX_RSA);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_FAILED)
return TEST_FAILED;
- if (gnutls_protocol_get_version (session) == GNUTLS_TLS1)
+ if (MHD_gnutls_protocol_get_version (session) == GNUTLS_TLS1)
return TEST_SUCCEED;
return TEST_UNSURE;
}
test_code_t
-test_max_record_size (gnutls_session_t session)
+test_max_record_size (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -876,14 +876,14 @@ test_max_record_size (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
- gnutls_record_set_max_size (session, 512);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_record_set_max_size (session, 512);
ret = do_handshake (session);
if (ret == TEST_FAILED)
return ret;
- ret = gnutls_record_get_max_size (session);
+ ret = MHD_gnutls_record_get_max_size (session);
if (ret == 512)
return TEST_SUCCEED;
@@ -891,7 +891,7 @@ test_max_record_size (gnutls_session_t session)
}
test_code_t
-test_hello_extension (gnutls_session_t session)
+test_hello_extension (mhd_gtls_session_t session)
{
int ret;
ADD_ALL_CIPHERS (session);
@@ -900,19 +900,19 @@ test_hello_extension (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
- gnutls_record_set_max_size (session, 512);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_record_set_max_size (session, 512);
ret = do_handshake (session);
return ret;
}
-void _gnutls_record_set_default_version (gnutls_session_t session,
+void _gnutls_record_set_default_version (mhd_gtls_session_t session,
unsigned char major,
unsigned char minor);
test_code_t
-test_version_rollback (gnutls_session_t session)
+test_version_rollback (mhd_gtls_session_t session)
{
int ret;
if (tls1_ok == 0)
@@ -931,7 +931,7 @@ test_version_rollback (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_record_set_default_version (session, 3, 0);
ret = do_handshake (session);
@@ -939,7 +939,7 @@ test_version_rollback (gnutls_session_t session)
return ret;
if (tls1_ok != 0
- && gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ && MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
return TEST_FAILED;
return TEST_SUCCEED;
@@ -950,7 +950,7 @@ test_version_rollback (gnutls_session_t session)
* message.
*/
test_code_t
-test_version_oob (gnutls_session_t session)
+test_version_oob (mhd_gtls_session_t session)
{
int ret;
/* here we enable both SSL 3.0 and TLS 1.0
@@ -962,18 +962,18 @@ test_version_oob (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_record_set_default_version (session, 5, 5);
ret = do_handshake (session);
return ret;
}
-void _gnutls_rsa_pms_set_version (gnutls_session_t session,
+void _gnutls_rsa_pms_set_version (mhd_gtls_session_t session,
unsigned char major, unsigned char minor);
test_code_t
-test_rsa_pms_version_check (gnutls_session_t session)
+test_rsa_pms_version_check (mhd_gtls_session_t session)
{
int ret;
/* here we use an arbitary version in the RSA PMS
@@ -987,7 +987,7 @@ test_rsa_pms_version_check (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_rsa_pms_set_version (session, 5, 5); /* use SSL 5.5 version */
ret = do_handshake (session);
@@ -997,7 +997,7 @@ test_rsa_pms_version_check (gnutls_session_t session)
#ifdef ENABLE_ANON
test_code_t
-test_anonymous (gnutls_session_t session)
+test_anonymous (mhd_gtls_session_t session)
{
int ret;
@@ -1007,19 +1007,19 @@ test_anonymous (gnutls_session_t session)
ADD_ALL_PROTOCOLS (session);
ADD_ALL_MACS (session);
ADD_KX (session, MHD_GNUTLS_KX_ANON_DH);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
ret = do_handshake (session);
if (ret == TEST_SUCCEED)
- gnutls_dh_get_pubkey (session, &pubkey);
+ MHD_gnutls_dh_get_pubkey (session, &pubkey);
return ret;
}
#endif
test_code_t
-test_session_resume2 (gnutls_session_t session)
+test_session_resume2 (mhd_gtls_session_t session)
{
int ret;
char tmp_session_id[32];
@@ -1035,8 +1035,8 @@ test_session_resume2 (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
gnutls_session_set_data (session, session_data, session_data_size);
@@ -1050,12 +1050,12 @@ test_session_resume2 (gnutls_session_t session)
/* check if we actually resumed the previous session */
session_id_size = sizeof (session_id);
- gnutls_session_get_id (session, session_id, &session_id_size);
+ MHD_gtls_session_get_id (session, session_id, &session_id_size);
if (session_id_size == 0)
return TEST_FAILED;
- if (gnutls_session_is_resumed (session))
+ if (MHD_gtls_session_is_resumed (session))
return TEST_SUCCEED;
if (tmp_session_id_size == session_id_size &&
@@ -1068,7 +1068,7 @@ test_session_resume2 (gnutls_session_t session)
extern char *hostname;
test_code_t
-test_certificate (gnutls_session_t session)
+test_certificate (mhd_gtls_session_t session)
{
int ret;
@@ -1082,7 +1082,7 @@ test_certificate (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
ret = do_handshake (session);
if (ret == TEST_FAILED)
@@ -1097,7 +1097,7 @@ test_certificate (gnutls_session_t session)
/* A callback function to be used at the certificate selection time.
*/
static int
-cert_callback (gnutls_session_t session,
+cert_callback (mhd_gtls_session_t session,
const gnutls_datum_t * req_ca_rdn, int nreqs,
const gnutls_pk_algorithm_t * sign_algos,
int sign_algos_length, gnutls_retr_st * st)
@@ -1137,7 +1137,7 @@ cert_callback (gnutls_session_t session,
* if the server sends a certificate request packet.
*/
test_code_t
-test_server_cas (gnutls_session_t session)
+test_server_cas (mhd_gtls_session_t session)
{
int ret;
@@ -1151,11 +1151,11 @@ test_server_cas (gnutls_session_t session)
ADD_ALL_MACS (session);
ADD_ALL_KX (session);
- gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
- gnutls_certificate_client_set_retrieve_function (xcred, cert_callback);
+ MHD_gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gtls_certificate_client_set_retrieve_function (xcred, cert_callback);
ret = do_handshake (session);
- gnutls_certificate_client_set_retrieve_function (xcred, NULL);
+ MHD_gtls_certificate_client_set_retrieve_function (xcred, NULL);
if (ret == TEST_FAILED)
return ret;
diff --git a/src/daemon/https/tests.h b/src/daemon/https/tests.h
@@ -3,40 +3,40 @@ typedef enum
TEST_SUCCEED, TEST_FAILED, TEST_UNSURE, TEST_IGNORE
} test_code_t;
-test_code_t test_srp (gnutls_session_t state);
-test_code_t test_server (gnutls_session_t state);
-test_code_t test_export (gnutls_session_t state);
-test_code_t test_export_info (gnutls_session_t state);
-test_code_t test_hello_extension (gnutls_session_t state);
-test_code_t test_dhe (gnutls_session_t state);
-test_code_t test_dhe_group (gnutls_session_t state);
-test_code_t test_ssl3 (gnutls_session_t state);
-test_code_t test_aes (gnutls_session_t state);
+test_code_t test_srp (mhd_gtls_session_t state);
+test_code_t test_server (mhd_gtls_session_t state);
+test_code_t test_export (mhd_gtls_session_t state);
+test_code_t test_export_info (mhd_gtls_session_t state);
+test_code_t test_hello_extension (mhd_gtls_session_t state);
+test_code_t test_dhe (mhd_gtls_session_t state);
+test_code_t test_dhe_group (mhd_gtls_session_t state);
+test_code_t test_ssl3 (mhd_gtls_session_t state);
+test_code_t test_aes (mhd_gtls_session_t state);
#ifdef ENABLE_CAMELLIA
-test_code_t test_camellia (gnutls_session_t state);
+test_code_t test_camellia (mhd_gtls_session_t state);
#endif
-test_code_t test_md5 (gnutls_session_t state);
-test_code_t test_sha (gnutls_session_t state);
-test_code_t test_3des (gnutls_session_t state);
-test_code_t test_arcfour (gnutls_session_t state);
-test_code_t test_arcfour_40 (gnutls_session_t state);
-test_code_t test_tls1 (gnutls_session_t state);
-test_code_t test_tls1_1 (gnutls_session_t state);
-test_code_t test_tls1_1_fallback (gnutls_session_t state);
-test_code_t test_tls_disable (gnutls_session_t state);
-test_code_t test_rsa_pms (gnutls_session_t state);
-test_code_t test_max_record_size (gnutls_session_t state);
-test_code_t test_version_rollback (gnutls_session_t state);
-test_code_t test_anonymous (gnutls_session_t state);
-test_code_t test_unknown_ciphersuites (gnutls_session_t state);
-test_code_t test_openpgp1 (gnutls_session_t state);
-test_code_t test_bye (gnutls_session_t state);
-test_code_t test_certificate (gnutls_session_t state);
-test_code_t test_server_cas (gnutls_session_t state);
-test_code_t test_session_resume2 (gnutls_session_t state);
-test_code_t test_rsa_pms_version_check (gnutls_session_t session);
-test_code_t test_version_oob (gnutls_session_t session);
-test_code_t test_zlib (gnutls_session_t session);
-test_code_t test_lzo (gnutls_session_t session);
-int _test_srp_username_callback (gnutls_session_t session,
+test_code_t test_md5 (mhd_gtls_session_t state);
+test_code_t test_sha (mhd_gtls_session_t state);
+test_code_t test_3des (mhd_gtls_session_t state);
+test_code_t test_arcfour (mhd_gtls_session_t state);
+test_code_t test_arcfour_40 (mhd_gtls_session_t state);
+test_code_t test_tls1 (mhd_gtls_session_t state);
+test_code_t test_tls1_1 (mhd_gtls_session_t state);
+test_code_t test_tls1_1_fallback (mhd_gtls_session_t state);
+test_code_t test_tls_disable (mhd_gtls_session_t state);
+test_code_t test_rsa_pms (mhd_gtls_session_t state);
+test_code_t test_max_record_size (mhd_gtls_session_t state);
+test_code_t test_version_rollback (mhd_gtls_session_t state);
+test_code_t test_anonymous (mhd_gtls_session_t state);
+test_code_t test_unknown_ciphersuites (mhd_gtls_session_t state);
+test_code_t test_openpgp1 (mhd_gtls_session_t state);
+test_code_t test_bye (mhd_gtls_session_t state);
+test_code_t test_certificate (mhd_gtls_session_t state);
+test_code_t test_server_cas (mhd_gtls_session_t state);
+test_code_t test_session_resume2 (mhd_gtls_session_t state);
+test_code_t test_rsa_pms_version_check (mhd_gtls_session_t session);
+test_code_t test_version_oob (mhd_gtls_session_t session);
+test_code_t test_zlib (mhd_gtls_session_t session);
+test_code_t test_lzo (mhd_gtls_session_t session);
+int _test_srp_username_callback (mhd_gtls_session_t session,
char **username, char **password);
diff --git a/src/daemon/https/tls/auth_anon.c b/src/daemon/https/tls/auth_anon.c
@@ -40,38 +40,38 @@
#include <gnutls_state.h>
#include <auth_dh_common.h>
-static int gen_anon_server_kx (gnutls_session_t, opaque **);
-static int proc_anon_client_kx (gnutls_session_t, opaque *, size_t);
-static int proc_anon_server_kx (gnutls_session_t, opaque *, size_t);
+static int gen_anon_server_kx (mhd_gtls_session_t, opaque **);
+static int proc_anon_client_kx (mhd_gtls_session_t, opaque *, size_t);
+static int mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t, opaque *, size_t);
-const mod_auth_st anon_auth_struct = {
+const mhd_gtls_mod_auth_st anon_auth_struct = {
"ANON",
NULL,
NULL,
gen_anon_server_kx,
- _gnutls_gen_dh_common_client_kx, /* this can be shared */
+ mhd_gtls_gen_dh_common_client_kx, /* this can be shared */
NULL,
NULL,
NULL,
NULL, /* certificate */
- proc_anon_server_kx,
+ mhd_gtls_proc_anon_server_kx,
proc_anon_client_kx,
NULL,
NULL
};
static int
-gen_anon_server_kx (gnutls_session_t session, opaque ** data)
+gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
{
mpi_t g, p;
const mpi_t *mpis;
int ret;
- gnutls_dh_params_t dh_params;
- gnutls_anon_server_credentials_t cred;
+ mhd_gtls_dh_params_t dh_params;
+ mhd_gtls_anon_server_credentials_t cred;
- cred = (gnutls_anon_server_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
+ cred = (mhd_gtls_anon_server_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -79,8 +79,8 @@ gen_anon_server_kx (gnutls_session_t session, opaque ** data)
}
dh_params =
- _gnutls_get_dh_params (cred->dh_params, cred->params_func, session);
- mpis = _gnutls_dh_params_to_mpi (dh_params);
+ mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+ mpis = mhd_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
@@ -91,16 +91,16 @@ gen_anon_server_kx (gnutls_session_t session, opaque ** data)
g = mpis[1];
if ((ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
sizeof (anon_auth_info_st), 1)) < 0)
{
gnutls_assert ();
return ret;
}
- _gnutls_dh_set_group (session, g, p);
+ mhd_gtls_dh_set_group (session, g, p);
- ret = _gnutls_dh_common_print_server_kx (session, g, p, data, 0);
+ ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -111,20 +111,20 @@ gen_anon_server_kx (gnutls_session_t session, opaque ** data)
static int
-proc_anon_client_kx (gnutls_session_t session, opaque * data,
+proc_anon_client_kx (mhd_gtls_session_t session, opaque * data,
size_t _data_size)
{
- gnutls_anon_server_credentials_t cred;
+ mhd_gtls_anon_server_credentials_t cred;
int bits;
int ret;
mpi_t p, g;
- gnutls_dh_params_t dh_params;
+ mhd_gtls_dh_params_t dh_params;
const mpi_t *mpis;
- bits = _gnutls_dh_get_allowed_prime_bits (session);
+ bits = mhd_gtls_dh_get_allowed_prime_bits (session);
- cred = (gnutls_anon_server_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
+ cred = (mhd_gtls_anon_server_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -132,8 +132,8 @@ proc_anon_client_kx (gnutls_session_t session, opaque * data,
}
dh_params =
- _gnutls_get_dh_params (cred->dh_params, cred->params_func, session);
- mpis = _gnutls_dh_params_to_mpi (dh_params);
+ mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+ mpis = mhd_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
@@ -143,14 +143,14 @@ proc_anon_client_kx (gnutls_session_t session, opaque * data,
p = mpis[0];
g = mpis[1];
- ret = _gnutls_proc_dh_common_client_kx (session, data, _data_size, g, p);
+ ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
return ret;
}
int
-proc_anon_server_kx (gnutls_session_t session, opaque * data,
+mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t session, opaque * data,
size_t _data_size)
{
@@ -158,14 +158,14 @@ proc_anon_server_kx (gnutls_session_t session, opaque * data,
/* set auth_info */
if ((ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
sizeof (anon_auth_info_st), 1)) < 0)
{
gnutls_assert ();
return ret;
}
- ret = _gnutls_proc_dh_common_server_kx (session, data, _data_size, 0);
+ ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
if (ret < 0)
{
gnutls_assert ();
diff --git a/src/daemon/https/tls/auth_anon.h b/src/daemon/https/tls/auth_anon.h
@@ -26,23 +26,23 @@
#include <gnutls_auth.h>
#include <auth_dh_common.h>
-typedef struct gnutls_anon_server_credentials_st
+typedef struct mhd_gtls_anon_server_credentials_st
{
- gnutls_dh_params_t dh_params;
+ mhd_gtls_dh_params_t dh_params;
/* this callback is used to retrieve the DH or RSA
* parameters.
*/
gnutls_params_function *params_func;
-} anon_server_credentials_st;
+} mhd_anon_server_credentials_st;
-typedef struct gnutls_anon_client_credentials_st
+typedef struct mhd_gtls_anon_client_credentials_st
{
int dummy;
-} anon_client_credentials_st;
+} mhd_anon_client_credentials_st;
-typedef struct anon_auth_info_st
+typedef struct mhd_gtls_anon_auth_info_st
{
dh_info_st dh;
-} *anon_auth_info_t;
+} * mhd_anon_auth_info_t;
-typedef struct anon_auth_info_st anon_auth_info_st;
+typedef struct mhd_gtls_anon_auth_info_st anon_auth_info_st;
diff --git a/src/daemon/https/tls/auth_cert.c b/src/daemon/https/tls/auth_cert.c
@@ -187,7 +187,7 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
* CAs and sign algorithms supported by the peer server.
*/
static int
-_find_x509_cert (const gnutls_certificate_credentials_t cred,
+_find_x509_cert (const mhd_gtls_cert_credentials_t cred,
opaque * _data, size_t _data_size,
const gnutls_pk_algorithm_t * pk_algos,
int pk_algos_length, int *indx)
@@ -205,7 +205,7 @@ _find_x509_cert (const gnutls_certificate_credentials_t cred,
{
DECR_LENGTH_RET (data_size, 2, 0);
- size = _gnutls_read_uint16 (data);
+ size = mhd_gtls_read_uint16 (data);
DECR_LENGTH_RET (data_size, size, 0);
data += 2;
@@ -258,7 +258,7 @@ _find_x509_cert (const gnutls_certificate_credentials_t cred,
/* Locates the most appropriate openpgp cert
*/
static int
-_find_openpgp_cert (const gnutls_certificate_credentials_t cred,
+_find_openpgp_cert (const mhd_gtls_cert_credentials_t cred,
gnutls_pk_algorithm_t * pk_algos,
int pk_algos_length, int *indx)
{
@@ -294,7 +294,7 @@ _find_openpgp_cert (const gnutls_certificate_credentials_t cred,
* certificate request packet.
*/
static int
-get_issuers_num (gnutls_session_t session, opaque * data, ssize_t data_size)
+get_issuers_num (mhd_gtls_session_t session, opaque * data, ssize_t data_size)
{
int issuers_dn_len = 0, result;
unsigned size;
@@ -314,7 +314,7 @@ get_issuers_num (gnutls_session_t session, opaque * data, ssize_t data_size)
*/
result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
DECR_LENGTH_COM (data_size, 2, goto error);
- size = _gnutls_read_uint16 (data);
+ size = mhd_gtls_read_uint16 (data);
result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
DECR_LENGTH_COM (data_size, size, goto error);
@@ -343,7 +343,7 @@ error:
* packet.
*/
static int
-get_issuers (gnutls_session_t session,
+get_issuers (mhd_gtls_session_t session,
gnutls_datum_t * issuers_dn, int issuers_len,
opaque * data, size_t data_size)
{
@@ -367,7 +367,7 @@ get_issuers (gnutls_session_t session,
*/
data_size -= 2;
- size = _gnutls_read_uint16 (data);
+ size = mhd_gtls_read_uint16 (data);
data += 2;
@@ -384,7 +384,7 @@ get_issuers (gnutls_session_t session,
/* Calls the client get callback.
*/
static int
-call_get_cert_callback (gnutls_session_t session,
+call_get_cert_callback (mhd_gtls_session_t session,
gnutls_datum_t * issuers_dn,
int issuers_dn_length,
gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)
@@ -395,10 +395,10 @@ call_get_cert_callback (gnutls_session_t session,
gnutls_retr_st st;
int ret;
gnutls_certificate_type_t type = gnutls_certificate_type_get (session);
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -457,7 +457,7 @@ call_get_cert_callback (gnutls_session_t session,
}
- _gnutls_selected_certs_set (session, local_certs,
+ mhd_gtls_selected_certs_set (session, local_certs,
(local_certs != NULL) ? st.ncerts : 0,
local_key, 1);
@@ -504,20 +504,20 @@ cleanup:
* algorithm (only in automatic mode).
*/
static int
-_select_client_cert (gnutls_session_t session,
+_select_client_cert (mhd_gtls_session_t session,
opaque * _data, size_t _data_size,
gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)
{
int result;
int indx = -1;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
opaque *data = _data;
ssize_t data_size = _data_size;
int issuers_dn_length;
gnutls_datum_t *issuers_dn = NULL;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -590,14 +590,14 @@ _select_client_cert (gnutls_session_t session,
if (indx >= 0)
{
- _gnutls_selected_certs_set (session,
+ mhd_gtls_selected_certs_set (session,
&cred->cert_list[indx][0],
cred->cert_list_length[indx],
&cred->pkey[indx], 0);
}
else
{
- _gnutls_selected_certs_set (session, NULL, 0, NULL, 0);
+ mhd_gtls_selected_certs_set (session, NULL, 0, NULL, 0);
}
result = 0;
@@ -613,7 +613,7 @@ cleanup:
*/
int
-_gnutls_gen_x509_crt (gnutls_session_t session, opaque ** data)
+_gnutls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
{
int ret, i;
opaque *pdata;
@@ -624,7 +624,7 @@ _gnutls_gen_x509_crt (gnutls_session_t session, opaque ** data)
/* find the appropriate certificate
*/
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -656,11 +656,11 @@ _gnutls_gen_x509_crt (gnutls_session_t session, opaque ** data)
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_uint24 (ret - 3, pdata);
+ mhd_gtls_write_uint24 (ret - 3, pdata);
pdata += 3;
for (i = 0; i < apr_cert_list_length; i++)
{
- _gnutls_write_datum24 (pdata, apr_cert_list[i].raw);
+ mhd_gtls_write_datum24 (pdata, apr_cert_list[i].raw);
pdata += (3 + apr_cert_list[i].raw.size);
}
@@ -671,7 +671,7 @@ enum PGPKeyDescriptorType
{ PGP_KEY_FINGERPRINT, PGP_KEY };
int
-_gnutls_gen_openpgp_certificate (gnutls_session_t session, opaque ** data)
+_gnutls_gen_openpgp_certificate (mhd_gtls_session_t session, opaque ** data)
{
int ret;
opaque *pdata;
@@ -681,7 +681,7 @@ _gnutls_gen_openpgp_certificate (gnutls_session_t session, opaque ** data)
/* find the appropriate certificate */
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -702,7 +702,7 @@ _gnutls_gen_openpgp_certificate (gnutls_session_t session, opaque ** data)
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_uint24 (ret - 3, pdata);
+ mhd_gtls_write_uint24 (ret - 3, pdata);
pdata += 3;
*pdata = PGP_KEY; /* whole key */
@@ -710,17 +710,17 @@ _gnutls_gen_openpgp_certificate (gnutls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
- _gnutls_write_datum24 (pdata, apr_cert_list[0].raw);
+ mhd_gtls_write_datum24 (pdata, apr_cert_list[0].raw);
pdata += (3 + apr_cert_list[0].raw.size);
}
else /* empty - no certificate */
- _gnutls_write_uint24 (0, pdata);
+ mhd_gtls_write_uint24 (0, pdata);
return ret;
}
int
-_gnutls_gen_openpgp_certificate_fpr (gnutls_session_t session, opaque ** data)
+_gnutls_gen_openpgp_certificate_fpr (mhd_gtls_session_t session, opaque ** data)
{
int ret, packet_size;
size_t fpr_size;
@@ -731,7 +731,7 @@ _gnutls_gen_openpgp_certificate_fpr (gnutls_session_t session, opaque ** data)
/* find the appropriate certificate */
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -756,7 +756,7 @@ _gnutls_gen_openpgp_certificate_fpr (gnutls_session_t session, opaque ** data)
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_uint24 (packet_size - 3, pdata);
+ mhd_gtls_write_uint24 (packet_size - 3, pdata);
pdata += 3;
*pdata = PGP_KEY_FINGERPRINT; /* key fingerprint */
@@ -787,12 +787,12 @@ _gnutls_gen_openpgp_certificate_fpr (gnutls_session_t session, opaque ** data)
int
-_gnutls_gen_cert_client_certificate (gnutls_session_t session, opaque ** data)
+mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t session, opaque ** data)
{
switch (session->security_parameters.cert_type)
{
case MHD_GNUTLS_CRT_OPENPGP:
- if (_gnutls_openpgp_send_fingerprint (session) == 0)
+ if (mhd_gtls_openpgp_send_fingerprint (session) == 0)
return _gnutls_gen_openpgp_certificate (session, data);
else
return _gnutls_gen_openpgp_certificate_fpr (session, data);
@@ -807,7 +807,7 @@ _gnutls_gen_cert_client_certificate (gnutls_session_t session, opaque ** data)
}
int
-_gnutls_gen_cert_server_certificate (gnutls_session_t session, opaque ** data)
+mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session, opaque ** data)
{
switch (session->security_parameters.cert_type)
{
@@ -824,23 +824,23 @@ _gnutls_gen_cert_server_certificate (gnutls_session_t session, opaque ** data)
/* Process server certificate
*/
-#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
+#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
int
-_gnutls_proc_x509_server_certificate (gnutls_session_t session,
+_gnutls_proc_x509_server_certificate (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
int size, len, ret;
opaque *p = data;
cert_auth_info_t info;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
ssize_t dsize = data_size;
int i, j, x;
gnutls_cert *peer_certificate_list;
int peer_certificate_list_size = 0;
gnutls_datum_t tmp;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -849,14 +849,14 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
if ((ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 1)) < 0)
{
gnutls_assert ();
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (data == NULL || data_size == 0)
{
@@ -866,7 +866,7 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
}
DECR_LEN (dsize, 3);
- size = _gnutls_read_uint24 (p);
+ size = mhd_gtls_read_uint24 (p);
p += 3;
/* some implementations send 0B 00 00 06 00 00 03 00 00 00
@@ -883,7 +883,7 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
while (i > 0)
{
DECR_LEN (dsize, 3);
- len = _gnutls_read_uint24 (p);
+ len = mhd_gtls_read_uint24 (p);
p += 3;
DECR_LEN (dsize, len);
peer_certificate_list_size++;
@@ -921,14 +921,14 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
for (j = 0; j < peer_certificate_list_size; j++)
{
- len = _gnutls_read_uint24 (p);
+ len = mhd_gtls_read_uint24 (p);
p += 3;
tmp.size = len;
tmp.data = p;
if ((ret =
- _gnutls_x509_raw_cert_to_gcert (&peer_certificate_list
+ mhd_gtls_x509_raw_cert_to_gcert (&peer_certificate_list
[j], &tmp,
CERT_ONLY_EXTENSIONS)) < 0)
{
@@ -966,23 +966,23 @@ cleanup:
}
-#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
+#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
int
-_gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
+_gnutls_proc_openpgp_server_certificate (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
int size, ret, len;
opaque *p = data;
cert_auth_info_t info;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
ssize_t dsize = data_size;
int i, x;
gnutls_cert *peer_certificate_list = NULL;
int peer_certificate_list_size = 0;
gnutls_datum_t tmp, akey = { NULL, 0 };
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -990,14 +990,14 @@ _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
}
if ((ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 1)) < 0)
{
gnutls_assert ();
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (data == NULL || data_size == 0)
{
@@ -1006,7 +1006,7 @@ _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
}
DECR_LEN (dsize, 3);
- size = _gnutls_read_uint24 (p);
+ size = mhd_gtls_read_uint24 (p);
p += 3;
if (size == 0)
@@ -1060,7 +1060,7 @@ _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
/* Read the actual certificate */
DECR_LEN (dsize, 3);
- len = _gnutls_read_uint24 (p);
+ len = mhd_gtls_read_uint24 (p);
p += 3;
if (len == 0)
@@ -1147,7 +1147,7 @@ cleanup:
}
int
-_gnutls_proc_cert_server_certificate (gnutls_session_t session,
+mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
switch (session->security_parameters.cert_type)
@@ -1185,21 +1185,21 @@ _gnutls_check_supported_sign_algo (CertificateSigType algo)
}
int
-_gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
+mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
size_t data_size)
{
int size, ret;
opaque *p;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
cert_auth_info_t info;
ssize_t dsize;
int i, j;
gnutls_pk_algorithm_t pk_algos[MAX_SIGN_ALGOS];
int pk_algos_length;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -1207,14 +1207,14 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
}
if ((ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
p = data;
dsize = data_size;
@@ -1259,7 +1259,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
/* read the certificate authorities */
DECR_LEN (dsize, 2);
- size = _gnutls_read_uint16 (p);
+ size = mhd_gtls_read_uint16 (p);
p += 2;
if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_OPENPGP
@@ -1290,7 +1290,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
}
int
-_gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session, opaque ** data)
+mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t session, opaque ** data)
{
int ret;
gnutls_cert *apr_cert_list;
@@ -1302,7 +1302,7 @@ _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session, opaque ** data)
/* find the appropriate certificate */
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -1312,7 +1312,7 @@ _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
if ((ret =
- _gnutls_tls_sign_hdata (session,
+ mhd_gtls_tls_sign_hdata (session,
&apr_cert_list[0],
apr_pkey, &signature)) < 0)
{
@@ -1332,7 +1332,7 @@ _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session, opaque ** data)
return GNUTLS_E_MEMORY_ERROR;
}
size = signature.size;
- _gnutls_write_uint16 (size, *data);
+ mhd_gtls_write_uint16 (size, *data);
memcpy (&(*data)[2], signature.data, size);
@@ -1342,14 +1342,14 @@ _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session, opaque ** data)
}
int
-_gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
+mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
int size, ret;
ssize_t dsize = data_size;
opaque *pdata = data;
gnutls_datum_t sig;
- cert_auth_info_t info = _gnutls_get_auth_info (session);
+ cert_auth_info_t info = mhd_gtls_get_auth_info (session);
gnutls_cert peer_cert;
if (info == NULL || info->ncerts == 0)
@@ -1360,7 +1360,7 @@ _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
}
DECR_LEN (dsize, 2);
- size = _gnutls_read_uint16 (pdata);
+ size = mhd_gtls_read_uint16 (pdata);
pdata += 2;
DECR_LEN (dsize, size);
@@ -1368,7 +1368,7 @@ _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
sig.data = pdata;
sig.size = size;
- ret = _gnutls_raw_cert_to_gcert (&peer_cert,
+ ret = mhd_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY);
@@ -1379,33 +1379,33 @@ _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
return ret;
}
- if ((ret = _gnutls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
+ if ((ret = mhd_gtls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
{
gnutls_assert ();
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return ret;
}
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return 0;
}
#define CERTTYPE_SIZE 3
int
-_gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
+mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
{
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
int size;
opaque *pdata;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
/* Now we need to generate the RDN sequence. This is
* already in the CERTIFICATE_CRED structure, to improve
* performance.
*/
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -1449,12 +1449,12 @@ _gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509 &&
session->internals.ignore_rdn_sequence == 0)
{
- _gnutls_write_datum16 (pdata, cred->x509_rdn_sequence);
+ mhd_gtls_write_datum16 (pdata, cred->x509_rdn_sequence);
/* pdata += cred->x509_rdn_sequence.size + 2; */
}
else
{
- _gnutls_write_uint16 (0, pdata);
+ mhd_gtls_write_uint16 (0, pdata);
/* pdata+=2; */
}
@@ -1470,7 +1470,7 @@ _gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
*
*/
int
-_gnutls_get_selected_cert (gnutls_session_t session,
+mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
gnutls_cert ** apr_cert_list,
int *apr_cert_list_length,
gnutls_privkey ** apr_pkey)
@@ -1530,7 +1530,7 @@ alloc_and_load_x509_certs (gnutls_x509_crt_t * certs, unsigned ncerts)
for (i = 0; i < ncerts; i++)
{
- ret = _gnutls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
+ ret = mhd_gtls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
if (ret < 0)
break;
}
@@ -1540,7 +1540,7 @@ alloc_and_load_x509_certs (gnutls_x509_crt_t * certs, unsigned ncerts)
gnutls_assert ();
for (j = 0; j < i; j++)
{
- _gnutls_gcert_deinit (&local_certs[j]);
+ mhd_gtls_gcert_deinit (&local_certs[j]);
}
gnutls_free (local_certs);
return NULL;
@@ -1613,7 +1613,7 @@ alloc_and_load_pgp_certs (gnutls_openpgp_crt_t cert)
if (ret < 0)
{
gnutls_assert ();
- _gnutls_gcert_deinit (local_certs);
+ mhd_gtls_gcert_deinit (local_certs);
gnutls_free (local_certs);
return NULL;
}
@@ -1658,7 +1658,7 @@ alloc_and_load_pgp_key (const gnutls_openpgp_privkey_t key)
void
-_gnutls_selected_certs_deinit (gnutls_session_t session)
+mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
{
if (session->internals.selected_need_free != 0)
{
@@ -1666,13 +1666,13 @@ _gnutls_selected_certs_deinit (gnutls_session_t session)
for (i = 0; i < session->internals.selected_cert_list_length; i++)
{
- _gnutls_gcert_deinit (&session->internals.selected_cert_list[i]);
+ mhd_gtls_gcert_deinit (&session->internals.selected_cert_list[i]);
}
gnutls_free (session->internals.selected_cert_list);
session->internals.selected_cert_list = NULL;
session->internals.selected_cert_list_length = 0;
- _gnutls_gkey_deinit (session->internals.selected_key);
+ mhd_gtls_gkey_deinit (session->internals.selected_key);
if (session->internals.selected_key)
{
gnutls_free (session->internals.selected_key);
@@ -1684,11 +1684,11 @@ _gnutls_selected_certs_deinit (gnutls_session_t session)
}
void
-_gnutls_selected_certs_set (gnutls_session_t session,
+mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
gnutls_cert * certs, int ncerts,
gnutls_privkey * key, int need_free)
{
- _gnutls_selected_certs_deinit (session);
+ mhd_gtls_selected_certs_deinit (session);
session->internals.selected_cert_list = certs;
session->internals.selected_cert_list_length = ncerts;
@@ -1709,15 +1709,15 @@ _gnutls_selected_certs_set (gnutls_session_t session,
*
*/
int
-_gnutls_server_select_cert (gnutls_session_t session,
+mhd_gtls_server_select_cert (mhd_gtls_session_t session,
gnutls_pk_algorithm_t requested_algo)
{
unsigned i;
int idx, ret;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -1759,7 +1759,7 @@ _gnutls_server_select_cert (gnutls_session_t session,
*/
if (idx >= 0 && ret == 0)
{
- _gnutls_selected_certs_set (session,
+ mhd_gtls_selected_certs_set (session,
&cred->cert_list[idx][0],
cred->cert_list_length[idx],
&cred->pkey[idx], 0);
@@ -1771,10 +1771,10 @@ _gnutls_server_select_cert (gnutls_session_t session,
return ret;
}
-/* Frees the rsa_info_st structure.
+/* Frees the mhd_gtls_rsa_info_st structure.
*/
void
-_gnutls_free_rsa_info (rsa_info_st * rsa)
+mhd_gtls_free_rsa_info (rsa_info_st * rsa)
{
_gnutls_free_datum (&rsa->modulus);
_gnutls_free_datum (&rsa->exponent);
diff --git a/src/daemon/https/tls/auth_cert.h b/src/daemon/https/tls/auth_cert.h
@@ -35,10 +35,10 @@
* support a server that has multiple certificates
*/
-typedef struct gnutls_certificate_credentials_st
+typedef struct mhd_gtls_certificate_credentials_st
{
- gnutls_dh_params_t dh_params;
- gnutls_rsa_params_t rsa_params;
+ mhd_gtls_dh_params_t dh_params;
+ mhd_gtls_rsa_params_t rsa_params;
/* this callback is used to retrieve the DH or RSA
* parameters.
*/
@@ -100,13 +100,13 @@ typedef struct gnutls_certificate_credentials_st
gnutls_certificate_server_retrieve_function *server_get_cert_callback;
} certificate_credentials_st;
-typedef struct rsa_info_st
+typedef struct mhd_gtls_rsa_info_st
{
gnutls_datum_t modulus;
gnutls_datum_t exponent;
} rsa_info_st;
-typedef struct cert_auth_info_st
+typedef struct mhd_gtls_cert_auth_info_st
{
int certificate_requested; /* if the peer requested certificate
* this is non zero;
@@ -124,36 +124,36 @@ typedef struct cert_auth_info_st
unsigned int ncerts; /* holds the size of the list above */
} *cert_auth_info_t;
-typedef struct cert_auth_info_st cert_auth_info_st;
+typedef struct mhd_gtls_cert_auth_info_st cert_auth_info_st;
-void _gnutls_free_rsa_info (rsa_info_st * rsa);
+void mhd_gtls_free_rsa_info (rsa_info_st * rsa);
/* AUTH X509 functions */
-int _gnutls_gen_cert_server_certificate (gnutls_session_t, opaque **);
-int _gnutls_gen_cert_client_certificate (gnutls_session_t, opaque **);
-int _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t, opaque **);
-int _gnutls_gen_cert_server_cert_req (gnutls_session_t, opaque **);
-int _gnutls_proc_cert_cert_req (gnutls_session_t, opaque *, size_t);
-int _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t, opaque *, size_t);
-int _gnutls_proc_cert_server_certificate (gnutls_session_t, opaque *, size_t);
-int _gnutls_get_selected_cert (gnutls_session_t session,
+int mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t, opaque **);
+int mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t, opaque **);
+int mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t, opaque **);
+int mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t, opaque **);
+int mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t, opaque *, size_t);
+int mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t, opaque *, size_t);
+int mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t, opaque *, size_t);
+int mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
gnutls_cert ** apr_cert_list,
int *apr_cert_list_length,
gnutls_privkey ** apr_pkey);
-int _gnutls_server_select_cert (struct gnutls_session_int *,
+int mhd_gtls_server_select_cert (struct MHD_gtls_session_int *,
gnutls_pk_algorithm_t);
-void _gnutls_selected_certs_deinit (gnutls_session_t session);
-void _gnutls_selected_certs_set (gnutls_session_t session,
+void mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session);
+void mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
gnutls_cert * certs, int ncerts,
gnutls_privkey * key, int need_free);
-#define _gnutls_proc_cert_client_certificate _gnutls_proc_cert_server_certificate
+#define _gnutls_proc_cert_client_certificate mhd_gtls_proc_cert_server_certificate
-gnutls_rsa_params_t _gnutls_certificate_get_rsa_params (gnutls_rsa_params_t
+mhd_gtls_rsa_params_t mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t
rsa_params,
gnutls_params_function
* func,
- gnutls_session_t);
+ mhd_gtls_session_t);
#endif
diff --git a/src/daemon/https/tls/auth_dh_common.c b/src/daemon/https/tls/auth_dh_common.c
@@ -42,7 +42,7 @@
/* Frees the dh_info_st structure.
*/
void
-_gnutls_free_dh_info (dh_info_st * dh)
+mhd_gtls_free_dh_info (dh_info_st * dh)
{
dh->secret_bits = 0;
_gnutls_free_datum (&dh->prime);
@@ -51,7 +51,7 @@ _gnutls_free_dh_info (dh_info_st * dh)
}
int
-_gnutls_proc_dh_common_client_kx (gnutls_session_t session,
+mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t g, mpi_t p)
{
@@ -62,20 +62,20 @@ _gnutls_proc_dh_common_client_kx (gnutls_session_t session,
DECR_LEN (data_size, 2);
- n_Y = _gnutls_read_uint16 (&data[0]);
+ n_Y = mhd_gtls_read_uint16 (&data[0]);
_n_Y = n_Y;
DECR_LEN (data_size, n_Y);
- if (_gnutls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
+ if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- _gnutls_dh_set_peer_public (session, session->key->client_Y);
+ mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
session->key->KEY =
- gnutls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
+ mhd_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
if (session->key->KEY == NULL)
{
@@ -83,12 +83,12 @@ _gnutls_proc_dh_common_client_kx (gnutls_session_t session,
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_mpi_release (&session->key->client_Y);
- _gnutls_mpi_release (&session->key->dh_secret);
+ mhd_gtls_mpi_release (&session->key->client_Y);
+ mhd_gtls_mpi_release (&session->key->dh_secret);
- ret = _gnutls_mpi_dprint (&session->key->key, session->key->KEY);
+ ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
- _gnutls_mpi_release (&session->key->KEY);
+ mhd_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
@@ -99,7 +99,7 @@ _gnutls_proc_dh_common_client_kx (gnutls_session_t session,
}
int
-_gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
+mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t session, opaque ** data)
{
mpi_t x = NULL, X = NULL;
size_t n_X;
@@ -107,7 +107,7 @@ _gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
*data = NULL;
- X = gnutls_calc_dh_secret (&x, session->key->client_g,
+ X = mhd_gtls_calc_dh_secret (&x, session->key->client_g,
session->key->client_p);
if (X == NULL || x == NULL)
{
@@ -116,9 +116,9 @@ _gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
goto error;
}
- _gnutls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
+ mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
- _gnutls_mpi_print (NULL, &n_X, X);
+ mhd_gtls_mpi_print (NULL, &n_X, X);
(*data) = gnutls_malloc (n_X + 2);
if (*data == NULL)
{
@@ -126,16 +126,16 @@ _gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
goto error;
}
- _gnutls_mpi_print (&(*data)[2], &n_X, X);
- _gnutls_mpi_release (&X);
+ mhd_gtls_mpi_print (&(*data)[2], &n_X, X);
+ mhd_gtls_mpi_release (&X);
- _gnutls_write_uint16 (n_X, &(*data)[0]);
+ mhd_gtls_write_uint16 (n_X, &(*data)[0]);
/* calculate the key after calculating the message */
session->key->KEY =
- gnutls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
+ mhd_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
- _gnutls_mpi_release (&x);
+ mhd_gtls_mpi_release (&x);
if (session->key->KEY == NULL)
{
gnutls_assert ();
@@ -144,13 +144,13 @@ _gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
}
/* THESE SHOULD BE DISCARDED */
- _gnutls_mpi_release (&session->key->client_Y);
- _gnutls_mpi_release (&session->key->client_p);
- _gnutls_mpi_release (&session->key->client_g);
+ mhd_gtls_mpi_release (&session->key->client_Y);
+ mhd_gtls_mpi_release (&session->key->client_p);
+ mhd_gtls_mpi_release (&session->key->client_g);
- ret = _gnutls_mpi_dprint (&session->key->key, session->key->KEY);
+ ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
- _gnutls_mpi_release (&session->key->KEY);
+ mhd_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
@@ -161,15 +161,15 @@ _gnutls_gen_dh_common_client_kx (gnutls_session_t session, opaque ** data)
return n_X + 2;
error:
- _gnutls_mpi_release (&x);
- _gnutls_mpi_release (&X);
+ mhd_gtls_mpi_release (&x);
+ mhd_gtls_mpi_release (&X);
gnutls_free (*data);
*data = NULL;
return ret;
}
int
-_gnutls_proc_dh_common_server_kx (gnutls_session_t session,
+mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
opaque * data, size_t _data_size, int psk)
{
uint16_t n_Y, n_g, n_p;
@@ -185,13 +185,13 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
if (psk != 0)
{
DECR_LEN (data_size, 2);
- psk_size = _gnutls_read_uint16 (&data[i]);
+ psk_size = mhd_gtls_read_uint16 (&data[i]);
DECR_LEN (data_size, psk_size);
i += 2 + psk_size;
}
DECR_LEN (data_size, 2);
- n_p = _gnutls_read_uint16 (&data[i]);
+ n_p = mhd_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_p);
@@ -199,7 +199,7 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
i += n_p;
DECR_LEN (data_size, 2);
- n_g = _gnutls_read_uint16 (&data[i]);
+ n_g = mhd_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_g);
@@ -207,7 +207,7 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
i += n_g;
DECR_LEN (data_size, 2);
- n_Y = _gnutls_read_uint16 (&data[i]);
+ n_Y = mhd_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_Y);
@@ -218,24 +218,24 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
_n_g = n_g;
_n_p = n_p;
- if (_gnutls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
+ if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- if (_gnutls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
+ if (mhd_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- if (_gnutls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
+ if (mhd_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- bits = _gnutls_dh_get_allowed_prime_bits (session);
+ bits = mhd_gtls_dh_get_allowed_prime_bits (session);
if (bits < 0)
{
gnutls_assert ();
@@ -250,9 +250,9 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
}
- _gnutls_dh_set_group (session, session->key->client_g,
+ mhd_gtls_dh_set_group (session, session->key->client_g,
session->key->client_p);
- _gnutls_dh_set_peer_public (session, session->key->client_Y);
+ mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
ret = n_Y + n_p + n_g + 6;
if (psk != 0)
@@ -264,7 +264,7 @@ _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
/* If the psk flag is set, then an empty psk_identity_hint will
* be inserted */
int
-_gnutls_dh_common_print_server_kx (gnutls_session_t session,
+mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
mpi_t g, mpi_t p, opaque ** data, int psk)
{
mpi_t x, X;
@@ -272,7 +272,7 @@ _gnutls_dh_common_print_server_kx (gnutls_session_t session,
int ret, data_size, pos;
uint8_t *pdata;
- X = gnutls_calc_dh_secret (&x, g, p);
+ X = mhd_gtls_calc_dh_secret (&x, g, p);
if (X == NULL || x == NULL)
{
gnutls_assert ();
@@ -280,11 +280,11 @@ _gnutls_dh_common_print_server_kx (gnutls_session_t session,
}
session->key->dh_secret = x;
- _gnutls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
+ mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
- _gnutls_mpi_print (NULL, &n_g, g);
- _gnutls_mpi_print (NULL, &n_p, p);
- _gnutls_mpi_print (NULL, &n_X, X);
+ mhd_gtls_mpi_print (NULL, &n_g, g);
+ mhd_gtls_mpi_print (NULL, &n_p, p);
+ mhd_gtls_mpi_print (NULL, &n_X, X);
data_size = n_g + n_p + n_X + 6;
if (psk != 0)
@@ -293,7 +293,7 @@ _gnutls_dh_common_print_server_kx (gnutls_session_t session,
(*data) = gnutls_malloc (data_size);
if (*data == NULL)
{
- _gnutls_mpi_release (&X);
+ mhd_gtls_mpi_release (&X);
return GNUTLS_E_MEMORY_ERROR;
}
@@ -302,24 +302,24 @@ _gnutls_dh_common_print_server_kx (gnutls_session_t session,
if (psk != 0)
{
- _gnutls_write_uint16 (0, &pdata[pos]);
+ mhd_gtls_write_uint16 (0, &pdata[pos]);
pos += 2;
}
- _gnutls_mpi_print (&pdata[pos + 2], &n_p, p);
- _gnutls_write_uint16 (n_p, &pdata[pos]);
+ mhd_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
+ mhd_gtls_write_uint16 (n_p, &pdata[pos]);
pos += n_p + 2;
- _gnutls_mpi_print (&pdata[pos + 2], &n_g, g);
- _gnutls_write_uint16 (n_g, &pdata[pos]);
+ mhd_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
+ mhd_gtls_write_uint16 (n_g, &pdata[pos]);
pos += n_g + 2;
- _gnutls_mpi_print (&pdata[pos + 2], &n_X, X);
- _gnutls_mpi_release (&X);
+ mhd_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
+ mhd_gtls_mpi_release (&X);
- _gnutls_write_uint16 (n_X, &pdata[pos]);
+ mhd_gtls_write_uint16 (n_X, &pdata[pos]);
ret = data_size;
diff --git a/src/daemon/https/tls/auth_dh_common.h b/src/daemon/https/tls/auth_dh_common.h
@@ -34,14 +34,14 @@ typedef struct
gnutls_datum_t public_key;
} dh_info_st;
-void _gnutls_free_dh_info (dh_info_st * dh);
-int _gnutls_gen_dh_common_client_kx (gnutls_session_t, opaque **);
-int _gnutls_proc_dh_common_client_kx (gnutls_session_t session,
+void mhd_gtls_free_dh_info (dh_info_st * dh);
+int mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t, opaque **);
+int mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t p, mpi_t g);
-int _gnutls_dh_common_print_server_kx (gnutls_session_t, mpi_t g, mpi_t p,
+int mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t, mpi_t g, mpi_t p,
opaque ** data, int psk);
-int _gnutls_proc_dh_common_server_kx (gnutls_session_t session,
+int mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
opaque * data, size_t _data_size,
int psk);
diff --git a/src/daemon/https/tls/auth_dhe.c b/src/daemon/https/tls/auth_dhe.c
@@ -39,47 +39,47 @@
#include <gnutls_state.h>
#include <auth_dh_common.h>
-static int gen_dhe_server_kx (gnutls_session_t, opaque **);
-static int proc_dhe_server_kx (gnutls_session_t, opaque *, size_t);
-static int proc_dhe_client_kx (gnutls_session_t, opaque *, size_t);
+static int gen_dhe_server_kx (mhd_gtls_session_t, opaque **);
+static int proc_dhe_server_kx (mhd_gtls_session_t, opaque *, size_t);
+static int proc_dhe_client_kx (mhd_gtls_session_t, opaque *, size_t);
-const mod_auth_st dhe_rsa_auth_struct = {
+const mhd_gtls_mod_auth_st dhe_rsa_auth_struct = {
"DHE_RSA",
- _gnutls_gen_cert_server_certificate,
- _gnutls_gen_cert_client_certificate,
+ mhd_gtls_gen_cert_server_certificate,
+ mhd_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
- _gnutls_gen_dh_common_client_kx,
- _gnutls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
- _gnutls_gen_cert_server_cert_req, /* server cert request */
+ mhd_gtls_gen_dh_common_client_kx,
+ mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
+ mhd_gtls_gen_cert_server_cert_req, /* server cert request */
- _gnutls_proc_cert_server_certificate,
+ mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
- _gnutls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
- _gnutls_proc_cert_cert_req /* proc server cert request */
+ mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
+ mhd_gtls_proc_cert_cert_req /* proc server cert request */
};
-const mod_auth_st dhe_dss_auth_struct = {
+const mhd_gtls_mod_auth_st dhe_dss_auth_struct = {
"DHE_DSS",
- _gnutls_gen_cert_server_certificate,
- _gnutls_gen_cert_client_certificate,
+ mhd_gtls_gen_cert_server_certificate,
+ mhd_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
- _gnutls_gen_dh_common_client_kx,
- _gnutls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
- _gnutls_gen_cert_server_cert_req, /* server cert request */
+ mhd_gtls_gen_dh_common_client_kx,
+ mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
+ mhd_gtls_gen_cert_server_cert_req, /* server cert request */
- _gnutls_proc_cert_server_certificate,
+ mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
- _gnutls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
- _gnutls_proc_cert_cert_req /* proc server cert request */
+ mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
+ mhd_gtls_proc_cert_cert_req /* proc server cert request */
};
static int
-gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
+gen_dhe_server_kx (mhd_gtls_session_t session, opaque ** data)
{
mpi_t g, p;
const mpi_t *mpis;
@@ -89,22 +89,22 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
gnutls_privkey *apr_pkey;
int apr_cert_list_length;
gnutls_datum_t signature, ddata;
- gnutls_certificate_credentials_t cred;
- gnutls_dh_params_t dh_params;
+ mhd_gtls_cert_credentials_t cred;
+ mhd_gtls_dh_params_t dh_params;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
- bits = _gnutls_dh_get_allowed_prime_bits (session);
+ bits = mhd_gtls_dh_get_allowed_prime_bits (session);
/* find the appropriate certificate */
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -112,8 +112,8 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
}
dh_params =
- _gnutls_get_dh_params (cred->dh_params, cred->params_func, session);
- mpis = _gnutls_dh_params_to_mpi (dh_params);
+ mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+ mpis = mhd_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
@@ -123,16 +123,16 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
p = mpis[0];
g = mpis[1];
- if ((ret = _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
return ret;
}
- _gnutls_dh_set_group (session, g, p);
+ mhd_gtls_dh_set_group (session, g, p);
- ret = _gnutls_dh_common_print_server_kx (session, g, p, data, 0);
+ ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -148,7 +148,7 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
if ((ret =
- _gnutls_tls_sign_params (session, &apr_cert_list[0],
+ mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
apr_pkey, &ddata, &signature)) < 0)
{
gnutls_assert ();
@@ -162,7 +162,7 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
return data_size; /* do not put a signature - ILLEGAL! */
}
- *data = gnutls_realloc_fast (*data, data_size + signature.size + 2);
+ *data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&signature);
@@ -170,7 +170,7 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_datum16 (&(*data)[data_size], signature);
+ mhd_gtls_write_datum16 (&(*data)[data_size], signature);
data_size += signature.size + 2;
_gnutls_free_datum (&signature);
@@ -179,13 +179,13 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
}
static int
-proc_dhe_server_kx (gnutls_session_t session, opaque * data,
+proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
size_t _data_size)
{
int sigsize;
gnutls_datum_t vparams, signature;
int ret;
- cert_auth_info_t info = _gnutls_get_auth_info (session);
+ cert_auth_info_t info = mhd_gtls_get_auth_info (session);
ssize_t data_size = _data_size;
gnutls_cert peer_cert;
@@ -196,7 +196,7 @@ proc_dhe_server_kx (gnutls_session_t session, opaque * data,
return GNUTLS_E_INTERNAL_ERROR;
}
- ret = _gnutls_proc_dh_common_server_kx (session, data, _data_size, 0);
+ ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -209,14 +209,14 @@ proc_dhe_server_kx (gnutls_session_t session, opaque * data,
vparams.data = data;
DECR_LEN (data_size, 2);
- sigsize = _gnutls_read_uint16 (&data[vparams.size]);
+ sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
DECR_LEN (data_size, sigsize);
signature.data = &data[vparams.size + 2];
signature.size = sigsize;
if ((ret =
- _gnutls_raw_cert_to_gcert (&peer_cert,
+ mhd_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
@@ -225,9 +225,9 @@ proc_dhe_server_kx (gnutls_session_t session, opaque * data,
return ret;
}
- ret = _gnutls_verify_sig_params (session, &peer_cert, &vparams, &signature);
+ ret = mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
if (ret < 0)
{
gnutls_assert ();
@@ -240,17 +240,17 @@ proc_dhe_server_kx (gnutls_session_t session, opaque * data,
static int
-proc_dhe_client_kx (gnutls_session_t session, opaque * data,
+proc_dhe_client_kx (mhd_gtls_session_t session, opaque * data,
size_t _data_size)
{
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
int ret;
mpi_t p, g;
const mpi_t *mpis;
- gnutls_dh_params_t dh_params;
+ mhd_gtls_dh_params_t dh_params;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -258,8 +258,8 @@ proc_dhe_client_kx (gnutls_session_t session, opaque * data,
}
dh_params =
- _gnutls_get_dh_params (cred->dh_params, cred->params_func, session);
- mpis = _gnutls_dh_params_to_mpi (dh_params);
+ mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+ mpis = mhd_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
@@ -269,7 +269,7 @@ proc_dhe_client_kx (gnutls_session_t session, opaque * data,
p = mpis[0];
g = mpis[1];
- ret = _gnutls_proc_dh_common_client_kx (session, data, _data_size, g, p);
+ ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
return ret;
diff --git a/src/daemon/https/tls/auth_rsa.c b/src/daemon/https/tls/auth_rsa.c
@@ -42,30 +42,30 @@
#include <gnutls_x509.h>
#include <gc.h>
-int _gnutls_gen_rsa_client_kx (gnutls_session_t, opaque **);
-int _gnutls_proc_rsa_client_kx (gnutls_session_t, opaque *, size_t);
+int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
+int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
-const mod_auth_st rsa_auth_struct = {
+const mhd_gtls_mod_auth_st rsa_auth_struct = {
"RSA",
- _gnutls_gen_cert_server_certificate,
- _gnutls_gen_cert_client_certificate,
+ mhd_gtls_gen_cert_server_certificate,
+ mhd_gtls_gen_cert_client_certificate,
NULL, /* gen server kx */
_gnutls_gen_rsa_client_kx,
- _gnutls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
- _gnutls_gen_cert_server_cert_req, /* server cert request */
+ mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
+ mhd_gtls_gen_cert_server_cert_req, /* server cert request */
- _gnutls_proc_cert_server_certificate,
+ mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
NULL, /* proc server kx */
_gnutls_proc_rsa_client_kx, /* proc client kx */
- _gnutls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
- _gnutls_proc_cert_cert_req /* proc server cert request */
+ mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
+ mhd_gtls_proc_cert_cert_req /* proc server cert request */
};
/* This function reads the RSA parameters from peer's certificate;
*/
int
-_gnutls_get_public_rsa_params (gnutls_session_t session,
+_gnutls_get_public_rsa_params (mhd_gtls_session_t session,
mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
int *params_len)
{
@@ -76,7 +76,7 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
/* normal non export case */
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
@@ -85,7 +85,7 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
}
ret =
- _gnutls_raw_cert_to_gcert (&peer_cert,
+ mhd_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_ONLY_PUBKEY | CERT_NO_COPY);
@@ -98,13 +98,13 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
/* EXPORT case: */
- if (_gnutls_cipher_suite_get_kx_algo
+ if (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)
== MHD_GNUTLS_KX_RSA_EXPORT
&& _gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
{
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
if (session->key->rsa[0] == NULL || session->key->rsa[1] == NULL)
{
@@ -139,7 +139,7 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
{
params[i] = _gnutls_mpi_copy (peer_cert.params[i]);
}
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return 0;
}
@@ -147,15 +147,15 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
/* This function reads the RSA parameters from the private key
*/
int
-_gnutls_get_private_rsa_params (gnutls_session_t session,
+_gnutls_get_private_rsa_params (mhd_gtls_session_t session,
mpi_t ** params, int *params_size)
{
int bits;
- gnutls_certificate_credentials_t cred;
- gnutls_rsa_params_t rsa_params;
+ mhd_gtls_cert_credentials_t cred;
+ mhd_gtls_rsa_params_t rsa_params;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -172,13 +172,13 @@ _gnutls_get_private_rsa_params (gnutls_session_t session,
_gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
params[0]);
- if (_gnutls_cipher_suite_get_kx_algo
+ if (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)
== MHD_GNUTLS_KX_RSA_EXPORT && bits > 512)
{
rsa_params =
- _gnutls_certificate_get_rsa_params (cred->rsa_params,
+ mhd_gtls_certificate_get_rsa_params (cred->rsa_params,
cred->params_func, session);
/* EXPORT case: */
if (rsa_params == NULL)
@@ -206,7 +206,7 @@ _gnutls_get_private_rsa_params (gnutls_session_t session,
}
int
-_gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
+_gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
size_t _data_size)
{
gnutls_datum_t plaintext;
@@ -217,7 +217,7 @@ _gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
int randomize_key = 0;
ssize_t data_size = _data_size;
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
/* SSL 3.0
*/
@@ -230,7 +230,7 @@ _gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
*/
DECR_LEN (data_size, 2);
ciphertext.data = &data[2];
- dsize = _gnutls_read_uint16 (data);
+ dsize = mhd_gtls_read_uint16 (data);
if (dsize != data_size)
{
@@ -247,7 +247,7 @@ _gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
return ret;
}
- ret = _gnutls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2); /* btype==2 */
+ ret = mhd_gtls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2); /* btype==2 */
if (ret < 0 || plaintext.size != TLS_MASTER_SIZE)
{
@@ -318,7 +318,7 @@ _gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
/* return RSA(random) using the peers public key
*/
int
-_gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
+_gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
{
cert_auth_info_t auth = session->key->auth_info;
gnutls_datum_t sdata; /* data to send */
@@ -352,12 +352,12 @@ _gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
return GNUTLS_E_RANDOM_FAILED;
}
- ver = _gnutls_get_adv_version (session);
+ ver = mhd_gtls_get_adv_version (session);
if (session->internals.rsa_pms_version[0] == 0)
{
- session->key->key.data[0] = _gnutls_version_get_major (ver);
- session->key->key.data[1] = _gnutls_version_get_minor (ver);
+ session->key->key.data[0] = mhd_gtls_version_get_major (ver);
+ session->key->key.data[1] = mhd_gtls_version_get_minor (ver);
}
else
{ /* use the version provided */
@@ -375,7 +375,7 @@ _gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
}
if ((ret =
- _gnutls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
+ mhd_gtls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
params, params_len, 2)) < 0)
{
gnutls_assert ();
@@ -383,9 +383,9 @@ _gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
}
for (i = 0; i < params_len; i++)
- _gnutls_mpi_release (¶ms[i]);
+ mhd_gtls_mpi_release (¶ms[i]);
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
/* SSL 3.0 */
*data = sdata.data;
@@ -399,7 +399,7 @@ _gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
_gnutls_free_datum (&sdata);
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_datum16 (*data, sdata);
+ mhd_gtls_write_datum16 (*data, sdata);
ret = sdata.size + 2;
_gnutls_free_datum (&sdata);
return ret;
diff --git a/src/daemon/https/tls/auth_rsa_export.c b/src/daemon/https/tls/auth_rsa_export.c
@@ -43,32 +43,32 @@
#include <gnutls_rsa_export.h>
#include <gnutls_state.h>
-int _gnutls_gen_rsa_client_kx (gnutls_session_t, opaque **);
-int _gnutls_proc_rsa_client_kx (gnutls_session_t, opaque *, size_t);
-static int gen_rsa_export_server_kx (gnutls_session_t, opaque **);
-static int proc_rsa_export_server_kx (gnutls_session_t, opaque *, size_t);
+int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
+int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
+static int gen_rsa_export_server_kx (mhd_gtls_session_t, opaque **);
+static int proc_rsa_export_server_kx (mhd_gtls_session_t, opaque *, size_t);
-const mod_auth_st rsa_export_auth_struct = {
+const mhd_gtls_mod_auth_st rsa_export_auth_struct = {
"RSA EXPORT",
- _gnutls_gen_cert_server_certificate,
- _gnutls_gen_cert_client_certificate,
+ mhd_gtls_gen_cert_server_certificate,
+ mhd_gtls_gen_cert_client_certificate,
gen_rsa_export_server_kx,
_gnutls_gen_rsa_client_kx,
- _gnutls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
- _gnutls_gen_cert_server_cert_req, /* server cert request */
+ mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
+ mhd_gtls_gen_cert_server_cert_req, /* server cert request */
- _gnutls_proc_cert_server_certificate,
+ mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
proc_rsa_export_server_kx,
_gnutls_proc_rsa_client_kx, /* proc client kx */
- _gnutls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
- _gnutls_proc_cert_cert_req /* proc server cert request */
+ mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
+ mhd_gtls_proc_cert_cert_req /* proc server cert request */
};
static int
-gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
+gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
{
- gnutls_rsa_params_t rsa_params;
+ mhd_gtls_rsa_params_t rsa_params;
const mpi_t *rsa_mpis;
size_t n_e, n_m;
uint8_t *data_e, *data_m;
@@ -78,10 +78,10 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
int apr_cert_list_length;
gnutls_datum_t signature, ddata;
cert_auth_info_t info;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -90,7 +90,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
/* find the appropriate certificate */
if ((ret =
- _gnutls_get_selected_cert (session, &apr_cert_list,
+ mhd_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
@@ -107,7 +107,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
}
rsa_params =
- _gnutls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
+ mhd_gtls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
session);
rsa_mpis = _gnutls_rsa_params_to_mpi (rsa_params);
if (rsa_mpis == NULL)
@@ -116,18 +116,18 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
}
- if ((ret = _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
return ret;
}
- info = _gnutls_get_auth_info (session);
- _gnutls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
+ info = mhd_gtls_get_auth_info (session);
+ mhd_gtls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
- _gnutls_mpi_print (NULL, &n_m, rsa_mpis[0]);
- _gnutls_mpi_print (NULL, &n_e, rsa_mpis[1]);
+ mhd_gtls_mpi_print (NULL, &n_m, rsa_mpis[0]);
+ mhd_gtls_mpi_print (NULL, &n_e, rsa_mpis[1]);
(*data) = gnutls_malloc (n_e + n_m + 4);
if (*data == NULL)
@@ -136,14 +136,14 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
}
data_m = &(*data)[0];
- _gnutls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
+ mhd_gtls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
- _gnutls_write_uint16 (n_m, data_m);
+ mhd_gtls_write_uint16 (n_m, data_m);
data_e = &data_m[2 + n_m];
- _gnutls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
+ mhd_gtls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
- _gnutls_write_uint16 (n_e, data_e);
+ mhd_gtls_write_uint16 (n_e, data_e);
data_size = n_m + n_e + 4;
@@ -156,7 +156,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
if ((ret =
- _gnutls_tls_sign_params (session, &apr_cert_list[0],
+ mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
apr_pkey, &ddata, &signature)) < 0)
{
gnutls_assert ();
@@ -171,7 +171,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
return data_size; /* do not put a signature - ILLEGAL! */
}
- *data = gnutls_realloc_fast (*data, data_size + signature.size + 2);
+ *data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&signature);
@@ -179,7 +179,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_write_datum16 (&((*data)[data_size]), signature);
+ mhd_gtls_write_datum16 (&((*data)[data_size]), signature);
data_size += signature.size + 2;
_gnutls_free_datum (&signature);
@@ -190,11 +190,11 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
/* if the peer's certificate is of 512 bits or less, returns non zero.
*/
int
-_gnutls_peers_cert_less_512 (gnutls_session_t session)
+_gnutls_peers_cert_less_512 (mhd_gtls_session_t session)
{
gnutls_cert peer_cert;
int ret;
- cert_auth_info_t info = _gnutls_get_auth_info (session);
+ cert_auth_info_t info = mhd_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
@@ -204,7 +204,7 @@ _gnutls_peers_cert_less_512 (gnutls_session_t session)
}
if ((ret =
- _gnutls_raw_cert_to_gcert (&peer_cert,
+ mhd_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
@@ -216,23 +216,23 @@ _gnutls_peers_cert_less_512 (gnutls_session_t session)
if (peer_cert.subject_pk_algorithm != MHD_GNUTLS_PK_RSA)
{
gnutls_assert ();
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return 0;
}
if (_gnutls_mpi_get_nbits (peer_cert.params[0]) <= 512)
{
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return 1;
}
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
return 0;
}
static int
-proc_rsa_export_server_kx (gnutls_session_t session,
+proc_rsa_export_server_kx (mhd_gtls_session_t session,
opaque * data, size_t _data_size)
{
uint16_t n_m, n_e;
@@ -246,7 +246,7 @@ proc_rsa_export_server_kx (gnutls_session_t session,
cert_auth_info_t info;
gnutls_cert peer_cert;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
@@ -258,7 +258,7 @@ proc_rsa_export_server_kx (gnutls_session_t session,
i = 0;
DECR_LEN (data_size, 2);
- n_m = _gnutls_read_uint16 (&data[i]);
+ n_m = mhd_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_m);
@@ -266,7 +266,7 @@ proc_rsa_export_server_kx (gnutls_session_t session,
i += n_m;
DECR_LEN (data_size, 2);
- n_e = _gnutls_read_uint16 (&data[i]);
+ n_e = mhd_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_e);
@@ -276,19 +276,19 @@ proc_rsa_export_server_kx (gnutls_session_t session,
_n_e = n_e;
_n_m = n_m;
- if (_gnutls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
+ if (mhd_gtls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- if (_gnutls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
+ if (mhd_gtls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
- _gnutls_rsa_export_set_pubkey (session, session->key->rsa[1],
+ mhd_gtls_rsa_export_set_pubkey (session, session->key->rsa[1],
session->key->rsa[0]);
/* VERIFY SIGNATURE */
@@ -297,14 +297,14 @@ proc_rsa_export_server_kx (gnutls_session_t session,
vparams.data = data;
DECR_LEN (data_size, 2);
- sigsize = _gnutls_read_uint16 (&data[vparams.size]);
+ sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
DECR_LEN (data_size, sigsize);
signature.data = &data[vparams.size + 2];
signature.size = sigsize;
if ((ret =
- _gnutls_raw_cert_to_gcert (&peer_cert,
+ mhd_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
@@ -313,9 +313,9 @@ proc_rsa_export_server_kx (gnutls_session_t session,
return ret;
}
- ret = _gnutls_verify_sig_params (session, &peer_cert, &vparams, &signature);
+ ret = mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
- _gnutls_gcert_deinit (&peer_cert);
+ mhd_gtls_gcert_deinit (&peer_cert);
if (ret < 0)
{
gnutls_assert ();
diff --git a/src/daemon/https/tls/debug.c b/src/daemon/https/tls/debug.c
@@ -32,7 +32,7 @@
void
-_gnutls_print_state (gnutls_session_t session)
+_gnutls_print_state (mhd_gtls_session_t session)
{
_gnutls_debug_log ("GNUTLS State:\n");
diff --git a/src/daemon/https/tls/debug.h b/src/daemon/https/tls/debug.h
@@ -23,7 +23,7 @@
*/
#ifdef DEBUG
-void _gnutls_print_state (gnutls_session_t session);
+void _gnutls_print_state (mhd_gtls_session_t session);
#endif
const char *_gnutls_packet2str (content_type_t packet);
const char *_gnutls_handshake2str (gnutls_handshake_description_t handshake);
diff --git a/src/daemon/https/tls/ext_cert_type.c b/src/daemon/https/tls/ext_cert_type.c
@@ -46,7 +46,7 @@ inline static int _gnutls_cert_type2num (int record_size);
*/
int
-_gnutls_cert_type_recv_params (gnutls_session_t session,
+mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t _data_size)
{
int new_type = -1, ret, i;
@@ -72,7 +72,7 @@ _gnutls_cert_type_recv_params (gnutls_session_t session,
/* Check if we support this cert_type */
if ((ret =
- _gnutls_session_cert_type_supported (session, new_type)) < 0)
+ mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
{
gnutls_assert ();
return ret;
@@ -100,7 +100,7 @@ _gnutls_cert_type_recv_params (gnutls_session_t session,
/* Check if we support this cert_type */
if ((ret =
- _gnutls_session_cert_type_supported (session,
+ mhd_gtls_session_cert_type_supported (session,
new_type)) < 0)
{
gnutls_assert ();
@@ -118,7 +118,7 @@ _gnutls_cert_type_recv_params (gnutls_session_t session,
}
if ((ret =
- _gnutls_session_cert_type_supported (session, new_type)) < 0)
+ mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
{
gnutls_assert ();
/* The peer has requested unsupported certificate
@@ -141,7 +141,7 @@ _gnutls_cert_type_recv_params (gnutls_session_t session,
/* returns data_size or a negative number on failure
*/
int
-_gnutls_cert_type_send_params (gnutls_session_t session, opaque * data,
+mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
size_t data_size)
{
unsigned len, i;
diff --git a/src/daemon/https/tls/ext_cert_type.h b/src/daemon/https/tls/ext_cert_type.h
@@ -25,7 +25,7 @@
/* Maps record size to numbers according to the
* extensions draft.
*/
-int _gnutls_cert_type_recv_params (gnutls_session_t session,
+int mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t data_size);
-int _gnutls_cert_type_send_params (gnutls_session_t session, opaque * data,
+int mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
size_t);
diff --git a/src/daemon/https/tls/ext_inner_application.c b/src/daemon/https/tls/ext_inner_application.c
@@ -32,10 +32,10 @@
#define YES 1
int
-_gnutls_inner_application_recv_params (gnutls_session_t session,
+mhd_gtls_inner_app_rcv_params (mhd_gtls_session_t session,
const opaque * data, size_t data_size)
{
- tls_ext_st *ext = &session->security_parameters.extensions;
+ mhd_gtls_ext_st *ext = &session->security_parameters.extensions;
if (data_size != 1)
{
@@ -66,10 +66,10 @@ _gnutls_inner_application_recv_params (gnutls_session_t session,
/* returns data_size or a negative number on failure
*/
int
-_gnutls_inner_application_send_params (gnutls_session_t session,
+mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
- tls_ext_st *ext = &session->security_parameters.extensions;
+ mhd_gtls_ext_st *ext = &session->security_parameters.extensions;
/* Set ext->gnutls_ia_enable depending on whether we have a TLS/IA
credential in the session. */
@@ -77,7 +77,7 @@ _gnutls_inner_application_send_params (gnutls_session_t session,
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
gnutls_ia_client_credentials_t cred = (gnutls_ia_client_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
if (cred)
ext->gnutls_ia_enable = 1;
@@ -85,7 +85,7 @@ _gnutls_inner_application_send_params (gnutls_session_t session,
else
{
gnutls_ia_server_credentials_t cred = (gnutls_ia_server_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
if (cred)
ext->gnutls_ia_enable = 1;
diff --git a/src/daemon/https/tls/ext_inner_application.h b/src/daemon/https/tls/ext_inner_application.h
@@ -22,8 +22,8 @@
*
*/
-int _gnutls_inner_application_recv_params (gnutls_session_t session,
+int mhd_gtls_inner_app_rcv_params (mhd_gtls_session_t session,
const opaque * data,
size_t data_size);
-int _gnutls_inner_application_send_params (gnutls_session_t session,
+int mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
opaque * data, size_t);
diff --git a/src/daemon/https/tls/ext_max_record.c b/src/daemon/https/tls/ext_max_record.c
@@ -41,7 +41,7 @@
*/
int
-_gnutls_max_record_recv_params (gnutls_session_t session,
+mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t new_size;
@@ -53,7 +53,7 @@ _gnutls_max_record_recv_params (gnutls_session_t session,
{
DECR_LEN (data_size, 1);
- new_size = _gnutls_mre_num2record (data[0]);
+ new_size = mhd_gtls_mre_num2record (data[0]);
if (new_size < 0)
{
@@ -77,7 +77,7 @@ _gnutls_max_record_recv_params (gnutls_session_t session,
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
- new_size = _gnutls_mre_num2record (data[0]);
+ new_size = mhd_gtls_mre_num2record (data[0]);
if (new_size < 0
|| new_size != session->internals.proposed_record_size)
@@ -102,7 +102,7 @@ _gnutls_max_record_recv_params (gnutls_session_t session,
/* returns data_size or a negative number on failure
*/
int
-_gnutls_max_record_send_params (gnutls_session_t session, opaque * data,
+mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
size_t data_size)
{
uint16_t len;
@@ -120,7 +120,7 @@ _gnutls_max_record_send_params (gnutls_session_t session, opaque * data,
}
data[0] =
- (uint8_t) _gnutls_mre_record2num (session->internals.
+ (uint8_t) mhd_gtls_mre_record2num (session->internals.
proposed_record_size);
return len;
}
@@ -140,7 +140,7 @@ _gnutls_max_record_send_params (gnutls_session_t session, opaque * data,
}
data[0] =
- (uint8_t) _gnutls_mre_record2num (session->
+ (uint8_t) mhd_gtls_mre_record2num (session->
security_parameters.
max_record_recv_size);
return len;
@@ -156,7 +156,7 @@ _gnutls_max_record_send_params (gnutls_session_t session, opaque * data,
* extensions draft.
*/
int
-_gnutls_mre_num2record (int num)
+mhd_gtls_mre_num2record (int num)
{
switch (num)
{
@@ -177,7 +177,7 @@ _gnutls_mre_num2record (int num)
* extensions draft.
*/
int
-_gnutls_mre_record2num (uint16_t record_size)
+mhd_gtls_mre_record2num (uint16_t record_size)
{
switch (record_size)
{
diff --git a/src/daemon/https/tls/ext_max_record.h b/src/daemon/https/tls/ext_max_record.h
@@ -25,9 +25,9 @@
/* Maps record size to numbers according to the
* extensions draft.
*/
-int _gnutls_mre_num2record (int num);
-int _gnutls_mre_record2num (uint16_t record_size);
-int _gnutls_max_record_recv_params (gnutls_session_t session,
+int mhd_gtls_mre_num2record (int num);
+int mhd_gtls_mre_record2num (uint16_t record_size);
+int mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t data_size);
-int _gnutls_max_record_send_params (gnutls_session_t session, opaque * data,
+int mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
size_t);
diff --git a/src/daemon/https/tls/ext_oprfi.c b/src/daemon/https/tls/ext_oprfi.c
@@ -33,7 +33,7 @@
#include <gnutls_num.h>
int
-oprfi_recv_server (gnutls_session_t session,
+oprfi_recv_server (mhd_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t data_size = _data_size;
@@ -46,7 +46,7 @@ oprfi_recv_server (gnutls_session_t session,
}
DECR_LEN (data_size, 2);
- len = _gnutls_read_uint16 (data);
+ len = mhd_gtls_read_uint16 (data);
data += 2;
if (len != data_size)
@@ -69,7 +69,7 @@ oprfi_recv_server (gnutls_session_t session,
}
int
-oprfi_recv_client (gnutls_session_t session,
+oprfi_recv_client (mhd_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t data_size = _data_size;
@@ -82,7 +82,7 @@ oprfi_recv_client (gnutls_session_t session,
}
DECR_LEN (data_size, 2);
- len = _gnutls_read_uint16 (data);
+ len = mhd_gtls_read_uint16 (data);
data += 2;
if (len != data_size)
@@ -111,7 +111,7 @@ oprfi_recv_client (gnutls_session_t session,
}
int
-_gnutls_oprfi_recv_params (gnutls_session_t session,
+mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t data_size)
{
if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -121,7 +121,7 @@ _gnutls_oprfi_recv_params (gnutls_session_t session,
}
int
-oprfi_send_client (gnutls_session_t session, opaque * data, size_t _data_size)
+oprfi_send_client (mhd_gtls_session_t session, opaque * data, size_t _data_size)
{
opaque *p = data;
ssize_t data_size = _data_size;
@@ -131,7 +131,7 @@ oprfi_send_client (gnutls_session_t session, opaque * data, size_t _data_size)
return 0;
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
- _gnutls_write_uint16 (oprf_size, p);
+ mhd_gtls_write_uint16 (oprf_size, p);
p += 2;
DECR_LENGTH_RET (data_size, oprf_size, GNUTLS_E_SHORT_MEMORY_BUFFER);
@@ -142,7 +142,7 @@ oprfi_send_client (gnutls_session_t session, opaque * data, size_t _data_size)
}
int
-oprfi_send_server (gnutls_session_t session, opaque * data, size_t _data_size)
+oprfi_send_server (mhd_gtls_session_t session, opaque * data, size_t _data_size)
{
opaque *p = data;
int ret;
@@ -177,7 +177,7 @@ oprfi_send_server (gnutls_session_t session, opaque * data, size_t _data_size)
}
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
- _gnutls_write_uint16 (session->security_parameters.
+ mhd_gtls_write_uint16 (session->security_parameters.
extensions.oprfi_server_len, p);
p += 2;
@@ -191,7 +191,7 @@ oprfi_send_server (gnutls_session_t session, opaque * data, size_t _data_size)
}
int
-_gnutls_oprfi_send_params (gnutls_session_t session,
+mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
opaque * data, size_t data_size)
{
if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -201,8 +201,8 @@ _gnutls_oprfi_send_params (gnutls_session_t session,
}
/**
- * gnutls_oprfi_enable_client:
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_oprfi_enable_client:
+ * @session: is a #mhd_gtls_session_t structure.
* @len: length of Opaque PRF data to use in client.
* @data: Opaque PRF data to use in client.
*
@@ -214,7 +214,7 @@ _gnutls_oprfi_send_params (gnutls_session_t session,
* may de-allocate it immediately after calling this function.
**/
void
-gnutls_oprfi_enable_client (gnutls_session_t session,
+MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
size_t len, unsigned char *data)
{
session->security_parameters.extensions.oprfi_client_len = len;
@@ -222,8 +222,8 @@ gnutls_oprfi_enable_client (gnutls_session_t session,
}
/**
- * gnutls_oprfi_enable_server:
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_oprfi_enable_server:
+ * @session: is a #mhd_gtls_session_t structure.
* @cb: function pointer to Opaque PRF extension server callback.
* @userdata: hook passed to callback function for passing application state.
*
@@ -232,7 +232,7 @@ gnutls_oprfi_enable_client (gnutls_session_t session,
* provided callback @cb will be invoked. The callback must have the
* following prototype:
*
- * int callback (gnutls_session_t session, void *userdata,
+ * int callback (mhd_gtls_session_t session, void *userdata,
* size_t oprfi_len, const unsigned char *in_oprfi,
* unsigned char *out_oprfi);
*
@@ -242,7 +242,7 @@ gnutls_oprfi_enable_client (gnutls_session_t session,
* handshake will be aborted.
**/
void
-gnutls_oprfi_enable_server (gnutls_session_t session,
+MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
gnutls_oprfi_callback_func cb, void *userdata)
{
session->security_parameters.extensions.oprfi_cb = cb;
diff --git a/src/daemon/https/tls/ext_oprfi.h b/src/daemon/https/tls/ext_oprfi.h
@@ -24,10 +24,10 @@
#include <gnutls_int.h>
-int _gnutls_oprfi_recv_params (gnutls_session_t state,
+int mhd_gtls_oprfi_recv_params (mhd_gtls_session_t state,
const opaque * data,
size_t data_size);
-int _gnutls_oprfi_send_params (gnutls_session_t state,
+int mhd_gtls_oprfi_send_params (mhd_gtls_session_t state,
opaque * data,
size_t data_size);
diff --git a/src/daemon/https/tls/ext_server_name.c b/src/daemon/https/tls/ext_server_name.c
@@ -39,7 +39,7 @@
*/
int
-_gnutls_server_name_recv_params (gnutls_session_t session,
+mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t _data_size)
{
int i;
@@ -51,7 +51,7 @@ _gnutls_server_name_recv_params (gnutls_session_t session,
if (session->security_parameters.entity == GNUTLS_SERVER)
{
DECR_LENGTH_RET (data_size, 2, 0);
- len = _gnutls_read_uint16 (data);
+ len = mhd_gtls_read_uint16 (data);
if (len != data_size)
{
@@ -71,7 +71,7 @@ _gnutls_server_name_recv_params (gnutls_session_t session,
p++;
DECR_LEN (data_size, 2);
- len = _gnutls_read_uint16 (p);
+ len = mhd_gtls_read_uint16 (p);
p += 2;
DECR_LENGTH_RET (data_size, len, 0);
@@ -96,7 +96,7 @@ _gnutls_server_name_recv_params (gnutls_session_t session,
type = *p;
p++;
- len = _gnutls_read_uint16 (p);
+ len = mhd_gtls_read_uint16 (p);
p += 2;
switch (type)
@@ -124,7 +124,7 @@ _gnutls_server_name_recv_params (gnutls_session_t session,
/* returns data_size or a negative number on failure
*/
int
-_gnutls_server_name_send_params (gnutls_session_t session,
+mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
opaque * data, size_t _data_size)
{
uint16_t len;
@@ -163,7 +163,7 @@ _gnutls_server_name_send_params (gnutls_session_t session,
/* UINT16: write total size of all names
*/
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
- _gnutls_write_uint16 (total_size - 2, p);
+ mhd_gtls_write_uint16 (total_size - 2, p);
p += 2;
for (i = 0;
@@ -191,7 +191,7 @@ _gnutls_server_name_send_params (gnutls_session_t session,
*p = 0; /* NAME_DNS type */
p++;
- _gnutls_write_uint16 (len, p);
+ mhd_gtls_write_uint16 (len, p);
p += 2;
memcpy (p,
@@ -210,8 +210,8 @@ _gnutls_server_name_send_params (gnutls_session_t session,
}
/**
- * gnutls_server_name_get - Used to get the server name indicator send by a client
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_server_name_get - Used to get the server name indicator send by a client
+ * @session: is a #mhd_gtls_session_t structure.
* @data: will hold the data
* @data_length: will hold the data length. Must hold the maximum size of data.
* @type: will hold the server name indicator type
@@ -233,7 +233,7 @@ _gnutls_server_name_send_params (gnutls_session_t session,
*
**/
int
-gnutls_server_name_get (gnutls_session_t session, void *data,
+MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
size_t * data_length,
unsigned int *type, unsigned int indx)
{
@@ -278,8 +278,8 @@ gnutls_server_name_get (gnutls_session_t session, void *data,
}
/**
- * gnutls_server_name_set - Used to set a name indicator to be sent as an extension
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_server_name_set - Used to set a name indicator to be sent as an extension
+ * @session: is a #mhd_gtls_session_t structure.
* @type: specifies the indicator type
* @name: is a string that contains the server name.
* @name_length: holds the length of name
@@ -295,7 +295,7 @@ gnutls_server_name_get (gnutls_session_t session, void *data,
*
**/
int
-gnutls_server_name_set (gnutls_session_t session,
+MHD_gnutls_server_name_set (mhd_gtls_session_t session,
gnutls_server_name_type_t type,
const void *name, size_t name_length)
{
diff --git a/src/daemon/https/tls/ext_server_name.h b/src/daemon/https/tls/ext_server_name.h
@@ -22,7 +22,7 @@
*
*/
-int _gnutls_server_name_recv_params (gnutls_session_t session,
+int mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
const opaque * data, size_t data_size);
-int _gnutls_server_name_send_params (gnutls_session_t session,
+int mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
opaque * data, size_t);
diff --git a/src/daemon/https/tls/gnutls_alert.c b/src/daemon/https/tls/gnutls_alert.c
@@ -80,15 +80,15 @@ static const gnutls_alert_entry sup_alerts[] = {
/**
- * gnutls_alert_get_name - Returns a string describing the alert number given
- * @alert: is an alert number #gnutls_session_t structure.
+ * MHD_gnutls_alert_get_name - Returns a string describing the alert number given
+ * @alert: is an alert number #mhd_gtls_session_t structure.
*
* This function will return a string that describes the given alert
* number or NULL. See gnutls_alert_get().
*
**/
const char *
-gnutls_alert_get_name (gnutls_alert_description_t alert)
+MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
{
const char *ret = NULL;
@@ -98,8 +98,8 @@ gnutls_alert_get_name (gnutls_alert_description_t alert)
}
/**
- * gnutls_alert_send - This function sends an alert message to the peer
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_alert_send - This function sends an alert message to the peer
+ * @session: is a #mhd_gtls_session_t structure.
* @level: is the level of the alert
* @desc: is the alert description
*
@@ -115,7 +115,7 @@ gnutls_alert_get_name (gnutls_alert_description_t alert)
*
**/
int
-gnutls_alert_send (gnutls_session_t session, gnutls_alert_level_t level,
+MHD_gnutls_alert_send (mhd_gtls_session_t session, gnutls_alert_level_t level,
gnutls_alert_description_t desc)
{
uint8_t data[2];
@@ -125,20 +125,20 @@ gnutls_alert_send (gnutls_session_t session, gnutls_alert_level_t level,
data[0] = (uint8_t) level;
data[1] = (uint8_t) desc;
- name = gnutls_alert_get_name ((int) data[1]);
+ name = MHD_gnutls_alert_get_name ((int) data[1]);
if (name == NULL)
name = "(unknown)";
_gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
data[1], name);
- if ((ret = _gnutls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
+ if ((ret = mhd_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
return 0;
else
return ret;
}
/**
- * gnutls_error_to_alert - This function returns an alert code based on the given error code
+ * MHD_gtls_error_to_alert - This function returns an alert code based on the given error code
* @err: is a negative integer
* @level: the alert level will be stored there
*
@@ -153,7 +153,7 @@ gnutls_alert_send (gnutls_session_t session, gnutls_alert_level_t level,
*
**/
int
-gnutls_error_to_alert (int err, int *level)
+MHD_gtls_error_to_alert (int err, int *level)
{
int ret, _level = -1;
@@ -254,12 +254,12 @@ gnutls_error_to_alert (int err, int *level)
/**
- * gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
+ * @session: is a #mhd_gtls_session_t structure.
* @err: is an integer
*
* Sends an alert to the peer depending on the error code returned by a gnutls
- * function. This function will call gnutls_error_to_alert() to determine
+ * function. This function will call MHD_gtls_error_to_alert() to determine
* the appropriate alert to send.
*
* This function may also return GNUTLS_E_AGAIN, or GNUTLS_E_INTERRUPTED.
@@ -270,23 +270,23 @@ gnutls_error_to_alert (int err, int *level)
* Returns zero on success.
*/
int
-gnutls_alert_send_appropriate (gnutls_session_t session, int err)
+MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
{
int alert;
int level;
- alert = gnutls_error_to_alert (err, &level);
+ alert = MHD_gtls_error_to_alert (err, &level);
if (alert < 0)
{
return alert;
}
- return gnutls_alert_send (session, level, alert);
+ return MHD_gnutls_alert_send (session, level, alert);
}
/**
* gnutls_alert_get - Returns the last alert number received.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function will return the last alert number received. This
* function should be called if GNUTLS_E_WARNING_ALERT_RECEIVED or
@@ -298,7 +298,7 @@ gnutls_alert_send_appropriate (gnutls_session_t session, int err)
*
**/
gnutls_alert_description_t
-gnutls_alert_get (gnutls_session_t session)
+gnutls_alert_get (mhd_gtls_session_t session)
{
return session->internals.last_alert;
}
diff --git a/src/daemon/https/tls/gnutls_algorithms.c b/src/daemon/https/tls/gnutls_algorithms.c
@@ -381,22 +381,22 @@ static const gnutls_compression_method_t supported_compressions[] = {
GNUTLS_COMPRESSION_LOOP( if(p->num == num) { a; break; } )
/* Key Exchange Section */
-extern mod_auth_st rsa_auth_struct;
-extern mod_auth_st rsa_export_auth_struct;
-extern mod_auth_st dhe_rsa_auth_struct;
-extern mod_auth_st dhe_dss_auth_struct;
-extern mod_auth_st anon_auth_struct;
-extern mod_auth_st srp_auth_struct;
-extern mod_auth_st psk_auth_struct;
-extern mod_auth_st dhe_psk_auth_struct;
-extern mod_auth_st srp_rsa_auth_struct;
-extern mod_auth_st srp_dss_auth_struct;
+extern mhd_gtls_mod_auth_st rsa_auth_struct;
+extern mhd_gtls_mod_auth_st rsa_export_auth_struct;
+extern mhd_gtls_mod_auth_st dhe_rsa_auth_struct;
+extern mhd_gtls_mod_auth_st dhe_dss_auth_struct;
+extern mhd_gtls_mod_auth_st anon_auth_struct;
+extern mhd_gtls_mod_auth_st srp_auth_struct;
+extern mhd_gtls_mod_auth_st psk_auth_struct;
+extern mhd_gtls_mod_auth_st dhe_psk_auth_struct;
+extern mhd_gtls_mod_auth_st srp_rsa_auth_struct;
+extern mhd_gtls_mod_auth_st srp_dss_auth_struct;
struct gnutls_kx_algo_entry
{
const char *name;
gnutls_kx_algorithm_t algorithm;
- mod_auth_st *auth_struct;
+ mhd_gtls_mod_auth_st *auth_struct;
int needs_dh_params;
int needs_rsa_params;
};
@@ -763,7 +763,7 @@ static const gnutls_cipher_suite_entry cs_algorithms[] = {
/* Generic Functions */
int
-_gnutls_mac_priority (gnutls_session_t session,
+mhd_gtls_mac_priority (mhd_gtls_session_t session,
gnutls_mac_algorithm_t algorithm)
{ /* actually returns the priority */
unsigned int i;
@@ -776,14 +776,14 @@ _gnutls_mac_priority (gnutls_session_t session,
}
/**
- * gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
+ * MHD_gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
* @algorithm: is a MAC algorithm
*
* Returns: a string that contains the name of the specified MAC
* algorithm, or %NULL.
**/
const char *
-gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm)
+MHD_gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm)
{
const char *ret = NULL;
@@ -794,7 +794,7 @@ gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm)
}
/**
- * gnutls_mac_get_id - Returns the gnutls id of the specified in string algorithm
+ * MHD_gtls_mac_get_id - Returns the gnutls id of the specified in string algorithm
* @algorithm: is a MAC algorithm name
*
* Returns: an %gnutls_mac_algorithm_tid of the specified in a string
@@ -802,7 +802,7 @@ gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm)
* compared in a case insensitive way.
**/
gnutls_mac_algorithm_t
-gnutls_mac_get_id (const char *name)
+MHD_gtls_mac_get_id (const char *name)
{
gnutls_mac_algorithm_t ret = MHD_GNUTLS_MAC_UNKNOWN;
@@ -813,7 +813,7 @@ gnutls_mac_get_id (const char *name)
}
/**
- * gnutls_mac_get_key_size - Returns the length of the MAC's key size
+ * MHD_gnutls_mac_get_key_size - Returns the length of the MAC's key size
* @algorithm: is an encryption algorithm
*
* Returns: length (in bytes) of the given MAC key size, or 0 if the
@@ -821,7 +821,7 @@ gnutls_mac_get_id (const char *name)
*
**/
size_t
-gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm)
+MHD_gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm)
{
size_t ret = 0;
@@ -832,7 +832,7 @@ gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm)
}
/**
- * gnutls_mac_list:
+ * MHD_gtls_mac_list:
*
* Get a list of hash algorithms for use as MACs. Note that not
* necessarily all MACs are supported in TLS cipher suites. For
@@ -843,13 +843,13 @@ gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm)
* integers indicating the available MACs.
**/
const gnutls_mac_algorithm_t *
-gnutls_mac_list (void)
+MHD_gtls_mac_list (void)
{
return supported_macs;
}
const char *
-_gnutls_x509_mac_to_oid (gnutls_mac_algorithm_t algorithm)
+mhd_gtls_x509_mac_to_oid (gnutls_mac_algorithm_t algorithm)
{
const char *ret = NULL;
@@ -860,7 +860,7 @@ _gnutls_x509_mac_to_oid (gnutls_mac_algorithm_t algorithm)
}
gnutls_mac_algorithm_t
-_gnutls_x509_oid2mac_algorithm (const char *oid)
+mhd_gtls_x509_oid2mac_algorithm (const char *oid)
{
gnutls_mac_algorithm_t ret = 0;
@@ -876,7 +876,7 @@ _gnutls_x509_oid2mac_algorithm (const char *oid)
}
int
-_gnutls_mac_is_ok (gnutls_mac_algorithm_t algorithm)
+mhd_gnutls_mac_is_ok (gnutls_mac_algorithm_t algorithm)
{
ssize_t ret = -1;
GNUTLS_HASH_ALG_LOOP (ret = p->id);
@@ -889,7 +889,7 @@ _gnutls_mac_is_ok (gnutls_mac_algorithm_t algorithm)
/* Compression Functions */
int
-_gnutls_compression_priority (gnutls_session_t session,
+mhd_gtls_compression_priority (mhd_gtls_session_t session,
gnutls_compression_method_t algorithm)
{ /* actually returns the priority */
unsigned int i;
@@ -902,14 +902,14 @@ _gnutls_compression_priority (gnutls_session_t session,
}
/**
- * gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
+ * MHD_gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
* @algorithm: is a Compression algorithm
*
* Returns: a pointer to a string that contains the name of the
* specified compression algorithm, or %NULL.
**/
const char *
-gnutls_compression_get_name (gnutls_compression_method_t algorithm)
+MHD_gnutls_compression_get_name (gnutls_compression_method_t algorithm)
{
const char *ret = NULL;
@@ -920,7 +920,7 @@ gnutls_compression_get_name (gnutls_compression_method_t algorithm)
}
/**
- * gnutls_compression_get_id - Returns the gnutls id of the specified in string algorithm
+ * MHD_gtls_compression_get_id - Returns the gnutls id of the specified in string algorithm
* @algorithm: is a compression method name
*
* The names are compared in a case insensitive way.
@@ -930,7 +930,7 @@ gnutls_compression_get_name (gnutls_compression_method_t algorithm)
*
**/
gnutls_compression_method_t
-gnutls_compression_get_id (const char *name)
+MHD_gtls_compression_get_id (const char *name)
{
gnutls_compression_method_t ret = MHD_GNUTLS_COMP_UNKNOWN;
@@ -944,7 +944,7 @@ gnutls_compression_get_id (const char *name)
}
/**
- * gnutls_compression_list:
+ * MHD_gtls_compression_list:
*
* Get a list of compression methods. Note that to be able to use LZO
* compression, you must link to libgnutls-extra and call
@@ -954,14 +954,14 @@ gnutls_compression_get_id (const char *name)
* integers indicating the available compression methods.
**/
const gnutls_compression_method_t *
-gnutls_compression_list (void)
+MHD_gtls_compression_list (void)
{
return supported_compressions;
}
/* return the tls number of the specified algorithm */
int
-_gnutls_compression_get_num (gnutls_compression_method_t algorithm)
+mhd_gtls_compression_get_num (gnutls_compression_method_t algorithm)
{
int ret = -1;
@@ -972,7 +972,7 @@ _gnutls_compression_get_num (gnutls_compression_method_t algorithm)
}
int
-_gnutls_compression_get_wbits (gnutls_compression_method_t algorithm)
+mhd_gtls_compression_get_wbits (gnutls_compression_method_t algorithm)
{
int ret = -1;
/* avoid prefix */
@@ -981,7 +981,7 @@ _gnutls_compression_get_wbits (gnutls_compression_method_t algorithm)
}
int
-_gnutls_compression_get_mem_level (gnutls_compression_method_t algorithm)
+mhd_gtls_compression_get_mem_level (gnutls_compression_method_t algorithm)
{
int ret = -1;
/* avoid prefix */
@@ -990,7 +990,7 @@ _gnutls_compression_get_mem_level (gnutls_compression_method_t algorithm)
}
int
-_gnutls_compression_get_comp_level (gnutls_compression_method_t algorithm)
+mhd_gtls_compression_get_comp_level (gnutls_compression_method_t algorithm)
{
int ret = -1;
/* avoid prefix */
@@ -1002,7 +1002,7 @@ _gnutls_compression_get_comp_level (gnutls_compression_method_t algorithm)
* method num
*/
gnutls_compression_method_t
-_gnutls_compression_get_id (int num)
+mhd_gtls_compression_get_id (int num)
{
gnutls_compression_method_t ret = -1;
@@ -1013,7 +1013,7 @@ _gnutls_compression_get_id (int num)
}
int
-_gnutls_compression_is_ok (gnutls_compression_method_t algorithm)
+mhd_gtls_compression_is_ok (gnutls_compression_method_t algorithm)
{
ssize_t ret = -1;
GNUTLS_COMPRESSION_ALG_LOOP (ret = p->id);
@@ -1026,7 +1026,7 @@ _gnutls_compression_is_ok (gnutls_compression_method_t algorithm)
/* CIPHER functions */
int
-_gnutls_cipher_get_block_size (gnutls_cipher_algorithm_t algorithm)
+mhd_gtls_cipher_get_block_size (gnutls_cipher_algorithm_t algorithm)
{
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->blocksize);
@@ -1036,7 +1036,7 @@ _gnutls_cipher_get_block_size (gnutls_cipher_algorithm_t algorithm)
/* returns the priority */
int
-_gnutls_cipher_priority (gnutls_session_t session,
+mhd_gtls_cipher_priority (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algorithm)
{
unsigned int i;
@@ -1049,7 +1049,7 @@ _gnutls_cipher_priority (gnutls_session_t session,
}
int
-_gnutls_cipher_is_block (gnutls_cipher_algorithm_t algorithm)
+mhd_gtls_cipher_is_block (gnutls_cipher_algorithm_t algorithm)
{
size_t ret = 0;
@@ -1059,14 +1059,14 @@ _gnutls_cipher_is_block (gnutls_cipher_algorithm_t algorithm)
}
/**
- * gnutls_cipher_get_key_size - Returns the length of the cipher's key size
+ * MHD_gnutls_cipher_get_key_size - Returns the length of the cipher's key size
* @algorithm: is an encryption algorithm
*
* Returns: length (in bytes) of the given cipher's key size, o 0 if
* the given cipher is invalid.
**/
size_t
-gnutls_cipher_get_key_size (gnutls_cipher_algorithm_t algorithm)
+MHD_gnutls_cipher_get_key_size (gnutls_cipher_algorithm_t algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->keysize);
@@ -1075,7 +1075,7 @@ gnutls_cipher_get_key_size (gnutls_cipher_algorithm_t algorithm)
}
int
-_gnutls_cipher_get_iv_size (gnutls_cipher_algorithm_t algorithm)
+mhd_gtls_cipher_get_iv_size (gnutls_cipher_algorithm_t algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->iv);
@@ -1084,7 +1084,7 @@ _gnutls_cipher_get_iv_size (gnutls_cipher_algorithm_t algorithm)
}
int
-_gnutls_cipher_get_export_flag (gnutls_cipher_algorithm_t algorithm)
+mhd_gtls_cipher_get_export_flag (gnutls_cipher_algorithm_t algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->export_flag);
@@ -1093,14 +1093,14 @@ _gnutls_cipher_get_export_flag (gnutls_cipher_algorithm_t algorithm)
}
/**
- * gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
+ * MHD_gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
* @algorithm: is an encryption algorithm
*
* Returns: a pointer to a string that contains the name of the
* specified cipher, or %NULL.
**/
const char *
-gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm)
+MHD_gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm)
{
const char *ret = NULL;
@@ -1111,7 +1111,7 @@ gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm)
}
/**
- * gnutls_cipher_get_id - Returns the gnutls id of the specified in string algorithm
+ * MHD_gtls_cipher_get_id - Returns the gnutls id of the specified in string algorithm
* @algorithm: is a MAC algorithm name
*
* The names are compared in a case insensitive way.
@@ -1121,7 +1121,7 @@ gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm)
*
**/
gnutls_cipher_algorithm_t
-gnutls_cipher_get_id (const char *name)
+MHD_gtls_cipher_get_id (const char *name)
{
gnutls_cipher_algorithm_t ret = MHD_GNUTLS_CIPHER_UNKNOWN;
@@ -1132,7 +1132,7 @@ gnutls_cipher_get_id (const char *name)
}
/**
- * gnutls_cipher_list:
+ * MHD_gtls_cipher_list:
*
* Get a list of supported cipher algorithms. Note that not
* necessarily all ciphers are supported as TLS cipher suites. For
@@ -1144,13 +1144,13 @@ gnutls_cipher_get_id (const char *name)
*
**/
const gnutls_cipher_algorithm_t *
-gnutls_cipher_list (void)
+MHD_gtls_cipher_list (void)
{
return supported_ciphers;
}
int
-_gnutls_cipher_is_ok (gnutls_cipher_algorithm_t algorithm)
+mhd_gtls_cipher_is_ok (gnutls_cipher_algorithm_t algorithm)
{
ssize_t ret = -1;
GNUTLS_ALG_LOOP (ret = p->id);
@@ -1162,17 +1162,17 @@ _gnutls_cipher_is_ok (gnutls_cipher_algorithm_t algorithm)
}
/* Key EXCHANGE functions */
-mod_auth_st *
-_gnutls_kx_auth_struct (gnutls_kx_algorithm_t algorithm)
+mhd_gtls_mod_auth_st *
+mhd_gtls_kx_auth_struct (gnutls_kx_algorithm_t algorithm)
{
- mod_auth_st *ret = NULL;
+ mhd_gtls_mod_auth_st *ret = NULL;
GNUTLS_KX_ALG_LOOP (ret = p->auth_struct);
return ret;
}
int
-_gnutls_kx_priority (gnutls_session_t session,
+mhd_gtls_kx_priority (mhd_gtls_session_t session,
gnutls_kx_algorithm_t algorithm)
{
unsigned int i;
@@ -1185,14 +1185,14 @@ _gnutls_kx_priority (gnutls_session_t session,
}
/**
- * gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
+ * MHD_gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
* @algorithm: is a key exchange algorithm
*
* Returns: a pointer to a string that contains the name of the
* specified key exchange algorithm, or %NULL.
**/
const char *
-gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm)
+MHD_gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm)
{
const char *ret = NULL;
@@ -1203,7 +1203,7 @@ gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm)
}
/**
- * gnutls_kx_get_id - Returns the gnutls id of the specified in string algorithm
+ * MHD_gtls_kx_get_id - Returns the gnutls id of the specified in string algorithm
* @algorithm: is a KX name
*
* The names are compared in a case insensitive way.
@@ -1212,7 +1212,7 @@ gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm)
* %GNUTLS_KX_UNKNOWN on error.
**/
gnutls_kx_algorithm_t
-gnutls_kx_get_id (const char *name)
+MHD_gtls_kx_get_id (const char *name)
{
gnutls_cipher_algorithm_t ret = MHD_GNUTLS_KX_UNKNOWN;
@@ -1223,7 +1223,7 @@ gnutls_kx_get_id (const char *name)
}
/**
- * gnutls_kx_list:
+ * MHD_gtls_kx_list:
*
* Get a list of supported key exchange algorithms.
*
@@ -1231,13 +1231,13 @@ gnutls_kx_get_id (const char *name)
* indicating the available key exchange algorithms.
**/
const gnutls_kx_algorithm_t *
-gnutls_kx_list (void)
+MHD_gtls_kx_list (void)
{
return supported_kxs;
}
int
-_gnutls_kx_is_ok (gnutls_kx_algorithm_t algorithm)
+mhd_gtls_kx_is_ok (gnutls_kx_algorithm_t algorithm)
{
ssize_t ret = -1;
GNUTLS_KX_ALG_LOOP (ret = p->algorithm);
@@ -1249,7 +1249,7 @@ _gnutls_kx_is_ok (gnutls_kx_algorithm_t algorithm)
}
int
-_gnutls_kx_needs_rsa_params (gnutls_kx_algorithm_t algorithm)
+mhd_gtls_kx_needs_rsa_params (gnutls_kx_algorithm_t algorithm)
{
ssize_t ret = 0;
GNUTLS_KX_ALG_LOOP (ret = p->needs_rsa_params);
@@ -1257,7 +1257,7 @@ _gnutls_kx_needs_rsa_params (gnutls_kx_algorithm_t algorithm)
}
int
-_gnutls_kx_needs_dh_params (gnutls_kx_algorithm_t algorithm)
+mhd_gtls_kx_needs_dh_params (gnutls_kx_algorithm_t algorithm)
{
ssize_t ret = 0;
GNUTLS_KX_ALG_LOOP (ret = p->needs_dh_params);
@@ -1266,7 +1266,7 @@ _gnutls_kx_needs_dh_params (gnutls_kx_algorithm_t algorithm)
/* Version */
int
-_gnutls_version_priority (gnutls_session_t session, gnutls_protocol_t version)
+mhd_gtls_version_priority (mhd_gtls_session_t session, gnutls_protocol_t version)
{ /* actually returns the priority */
unsigned int i;
@@ -1285,7 +1285,7 @@ _gnutls_version_priority (gnutls_session_t session, gnutls_protocol_t version)
}
gnutls_protocol_t
-_gnutls_version_lowest (gnutls_session_t session)
+mhd_gtls_version_lowest (mhd_gtls_session_t session)
{ /* returns the lowest version supported */
unsigned int i, min = 0xff;
@@ -1307,7 +1307,7 @@ _gnutls_version_lowest (gnutls_session_t session)
}
gnutls_protocol_t
-_gnutls_version_max (gnutls_session_t session)
+mhd_gtls_version_max (mhd_gtls_session_t session)
{ /* returns the maximum version supported */
unsigned int i, max = 0x00;
@@ -1329,14 +1329,14 @@ _gnutls_version_max (gnutls_session_t session)
}
/**
- * gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
+ * MHD_gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
* @version: is a (gnutls) version number
*
* Returns: a string that contains the name of the specified TLS
* version (e.g., "TLS 1.0"), or %NULL.
**/
const char *
-gnutls_protocol_get_name (gnutls_protocol_t version)
+MHD_gnutls_protocol_get_name (gnutls_protocol_t version)
{
const char *ret = NULL;
@@ -1346,7 +1346,7 @@ gnutls_protocol_get_name (gnutls_protocol_t version)
}
/**
- * gnutls_protocol_get_id - Returns the gnutls id of the specified in string protocol
+ * MHD_gtls_protocol_get_id - Returns the gnutls id of the specified in string protocol
* @algorithm: is a protocol name
*
* The names are compared in a case insensitive way.
@@ -1355,7 +1355,7 @@ gnutls_protocol_get_name (gnutls_protocol_t version)
* %GNUTLS_VERSION_UNKNOWN on error.
**/
gnutls_protocol_t
-gnutls_protocol_get_id (const char *name)
+MHD_gtls_protocol_get_id (const char *name)
{
gnutls_protocol_t ret = MHD_GNUTLS_VERSION_UNKNOWN;
@@ -1366,7 +1366,7 @@ gnutls_protocol_get_id (const char *name)
}
/**
- * gnutls_protocol_list:
+ * MHD_gtls_protocol_list:
*
* Get a list of supported protocols, e.g. SSL 3.0, TLS 1.0 etc.
*
@@ -1375,13 +1375,13 @@ gnutls_protocol_get_id (const char *name)
*
**/
const gnutls_protocol_t *
-gnutls_protocol_list (void)
+MHD_gtls_protocol_list (void)
{
return supported_protocols;
}
int
-_gnutls_version_get_minor (gnutls_protocol_t version)
+mhd_gtls_version_get_minor (gnutls_protocol_t version)
{
int ret = -1;
@@ -1390,7 +1390,7 @@ _gnutls_version_get_minor (gnutls_protocol_t version)
}
gnutls_protocol_t
-_gnutls_version_get (int major, int minor)
+mhd_gtls_version_get (int major, int minor)
{
int ret = -1;
@@ -1401,7 +1401,7 @@ _gnutls_version_get (int major, int minor)
}
int
-_gnutls_version_get_major (gnutls_protocol_t version)
+mhd_gtls_version_get_major (gnutls_protocol_t version)
{
int ret = -1;
@@ -1412,7 +1412,7 @@ _gnutls_version_get_major (gnutls_protocol_t version)
/* Version Functions */
int
-_gnutls_version_is_supported (gnutls_session_t session,
+mhd_gtls_version_is_supported (mhd_gtls_session_t session,
const gnutls_protocol_t version)
{
int ret = 0;
@@ -1421,7 +1421,7 @@ _gnutls_version_is_supported (gnutls_session_t session,
if (ret == 0)
return 0;
- if (_gnutls_version_priority (session, version) < 0)
+ if (mhd_gtls_version_priority (session, version) < 0)
return 0; /* disabled by the user */
else
return 1;
@@ -1429,7 +1429,7 @@ _gnutls_version_is_supported (gnutls_session_t session,
/* Type to KX mappings */
gnutls_kx_algorithm_t
-_gnutls_map_kx_get_kx (gnutls_credentials_type_t type, int server)
+mhd_gtls_map_kx_get_kx (gnutls_credentials_type_t type, int server)
{
gnutls_kx_algorithm_t ret = -1;
@@ -1445,7 +1445,7 @@ _gnutls_map_kx_get_kx (gnutls_credentials_type_t type, int server)
}
gnutls_credentials_type_t
-_gnutls_map_kx_get_cred (gnutls_kx_algorithm_t algorithm, int server)
+mhd_gtls_map_kx_get_cred (gnutls_kx_algorithm_t algorithm, int server)
{
gnutls_credentials_type_t ret = -1;
if (server)
@@ -1464,7 +1464,7 @@ _gnutls_map_kx_get_cred (gnutls_kx_algorithm_t algorithm, int server)
/* Cipher Suite's functions */
gnutls_cipher_algorithm_t
-_gnutls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
+mhd_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
{
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->block_algorithm);
@@ -1472,7 +1472,7 @@ _gnutls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
}
gnutls_protocol_t
-_gnutls_cipher_suite_get_version (const cipher_suite_st * suite)
+mhd_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
{
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->version);
@@ -1480,7 +1480,7 @@ _gnutls_cipher_suite_get_version (const cipher_suite_st * suite)
}
gnutls_kx_algorithm_t
-_gnutls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
+mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
{
int ret = 0;
@@ -1490,7 +1490,7 @@ _gnutls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
}
gnutls_mac_algorithm_t
-_gnutls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
+mhd_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
{ /* In bytes */
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->mac_algorithm);
@@ -1499,7 +1499,7 @@ _gnutls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
}
const char *
-_gnutls_cipher_suite_get_name (cipher_suite_st * suite)
+mhd_gtls_cipher_suite_get_name (cipher_suite_st * suite)
{
const char *ret = NULL;
@@ -1509,78 +1509,6 @@ _gnutls_cipher_suite_get_name (cipher_suite_st * suite)
return ret;
}
-/**
- * gnutls_cipher_suite_get_name - Returns a string with the name of the specified cipher suite
- * @kx_algorithm: is a Key exchange algorithm
- * @cipher_algorithm: is a cipher algorithm
- * @mac_algorithm: is a MAC algorithm
- *
- * Note that the full cipher suite name must be prepended by TLS or
- * SSL depending of the protocol in use.
- *
- * Returns: a string that contains the name of a TLS cipher suite,
- * specified by the given algorithms, or %NULL.
- **/
-const char *
-gnutls_cipher_suite_get_name (gnutls_kx_algorithm_t kx_algorithm,
- gnutls_cipher_algorithm_t cipher_algorithm,
- gnutls_mac_algorithm_t mac_algorithm)
-{
- const char *ret = NULL;
-
- /* avoid prefix */
- GNUTLS_CIPHER_SUITE_LOOP (if (kx_algorithm == p->kx_algorithm &&
- cipher_algorithm == p->block_algorithm &&
- mac_algorithm == p->mac_algorithm)
- ret = p->name + sizeof ("GNUTLS_") - 1)
- ;
-
- return ret;
-}
-
-/**
- * gnutls_cipher_suite_info:
- * @idx: index of cipher suite to get information about, starts on 0.
- * @cs_id: output buffer with room for 2 bytes, indicating cipher suite value
- * @kx: output variable indicating key exchange algorithm, or %NULL.
- * @cipher: output variable indicating cipher, or %NULL.
- * @mac: output variable indicating MAC algorithm, or %NULL.
- * @version: output variable indicating TLS protocol version, or %NULL.
- *
- * Get information about supported cipher suites. Use the function
- * iteratively to get information about all supported cipher suites.
- * Call with idx=0 to get information about first cipher suite, then
- * idx=1 and so on until the function returns NULL.
- *
- * Returns: the name of @idx cipher suite, and set the information
- * about the cipher suite in the output variables. If @idx is out of
- * bounds, %NULL is returned.
- **/
-const char *
-gnutls_cipher_suite_info (size_t idx,
- char *cs_id,
- gnutls_kx_algorithm_t * kx,
- gnutls_cipher_algorithm_t * cipher,
- gnutls_mac_algorithm_t * mac,
- gnutls_protocol_t * version)
-{
- if (idx >= CIPHER_SUITES_COUNT)
- return NULL;
-
- if (cs_id)
- memcpy (cs_id, cs_algorithms[idx].id.suite, 2);
- if (kx)
- *kx = cs_algorithms[idx].kx_algorithm;
- if (cipher)
- *cipher = cs_algorithms[idx].block_algorithm;
- if (mac)
- *mac = cs_algorithms[idx].mac_algorithm;
- if (version)
- *version = cs_algorithms[idx].version;
-
- return cs_algorithms[idx].name + sizeof ("GNU") - 1;
-}
-
static inline int
_gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
{
@@ -1602,11 +1530,11 @@ _gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
#define MAX_ELEM_SIZE 4
static inline int
-_gnutls_partition (gnutls_session_t session,
+_gnutls_partition (mhd_gtls_session_t session,
void *_base,
size_t nmemb,
size_t size,
- int (*compar) (gnutls_session_t,
+ int (*compar) (mhd_gtls_session_t,
const void *, const void *))
{
uint8_t *base = _base;
@@ -1650,11 +1578,11 @@ _gnutls_partition (gnutls_session_t session,
}
static void
-_gnutls_qsort (gnutls_session_t session,
+_gnutls_qsort (mhd_gtls_session_t session,
void *_base,
size_t nmemb,
size_t size,
- int (*compar) (gnutls_session_t, const void *, const void *))
+ int (*compar) (mhd_gtls_session_t, const void *, const void *))
{
unsigned int pivot;
char *base = _base;
@@ -1683,28 +1611,28 @@ _gnutls_qsort (gnutls_session_t session,
* For use with qsort
*/
static int
-_gnutls_compare_algo (gnutls_session_t session,
+_gnutls_compare_algo (mhd_gtls_session_t session,
const void *i_A1, const void *i_A2)
{
gnutls_kx_algorithm_t kA1 =
- _gnutls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
+ mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
gnutls_kx_algorithm_t kA2 =
- _gnutls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
+ mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
gnutls_cipher_algorithm_t cA1 =
- _gnutls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
+ mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
gnutls_cipher_algorithm_t cA2 =
- _gnutls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
+ mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
gnutls_mac_algorithm_t mA1 =
- _gnutls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
+ mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
gnutls_mac_algorithm_t mA2 =
- _gnutls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
+ mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
- int p1 = (_gnutls_kx_priority (session, kA1) + 1) * 64;
- int p2 = (_gnutls_kx_priority (session, kA2) + 1) * 64;
- p1 += (_gnutls_cipher_priority (session, cA1) + 1) * 8;
- p2 += (_gnutls_cipher_priority (session, cA2) + 1) * 8;
- p1 += _gnutls_mac_priority (session, mA1);
- p2 += _gnutls_mac_priority (session, mA2);
+ int p1 = (mhd_gtls_kx_priority (session, kA1) + 1) * 64;
+ int p2 = (mhd_gtls_kx_priority (session, kA2) + 1) * 64;
+ p1 += (mhd_gtls_cipher_priority (session, cA1) + 1) * 8;
+ p2 += (mhd_gtls_cipher_priority (session, cA2) + 1) * 8;
+ p1 += mhd_gtls_mac_priority (session, mA1);
+ p2 += mhd_gtls_mac_priority (session, mA2);
if (p1 > p2)
{
@@ -1722,8 +1650,8 @@ _gnutls_compare_algo (gnutls_session_t session,
#ifdef SORT_DEBUG
static void
-_gnutls_bsort (gnutls_session_t session, void *_base, size_t nmemb,
- size_t size, int (*compar) (gnutls_session_t, const void *,
+_gnutls_bsort (mhd_gtls_session_t session, void *_base, size_t nmemb,
+ size_t size, int (*compar) (mhd_gtls_session_t, const void *,
const void *))
{
unsigned int i, j;
@@ -1746,7 +1674,7 @@ _gnutls_bsort (gnutls_session_t session, void *_base, size_t nmemb,
#endif
int
-_gnutls_supported_ciphersuites_sorted (gnutls_session_t session,
+mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
cipher_suite_st ** ciphers)
{
@@ -1755,7 +1683,7 @@ _gnutls_supported_ciphersuites_sorted (gnutls_session_t session,
#endif
int count;
- count = _gnutls_supported_ciphersuites (session, ciphers);
+ count = mhd_gtls_supported_ciphersuites (session, ciphers);
if (count <= 0)
{
gnutls_assert ();
@@ -1765,7 +1693,7 @@ _gnutls_supported_ciphersuites_sorted (gnutls_session_t session,
_gnutls_debug_log ("Unsorted: \n");
for (i = 0; i < count; i++)
_gnutls_debug_log ("\t%d: %s\n", i,
- _gnutls_cipher_suite_get_name ((*ciphers)[i]));
+ mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
#endif
_gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
@@ -1775,14 +1703,14 @@ _gnutls_supported_ciphersuites_sorted (gnutls_session_t session,
_gnutls_debug_log ("Sorted: \n");
for (i = 0; i < count; i++)
_gnutls_debug_log ("\t%d: %s\n", i,
- _gnutls_cipher_suite_get_name ((*ciphers)[i]));
+ mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
#endif
return count;
}
int
-_gnutls_supported_ciphersuites (gnutls_session_t session,
+mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
cipher_suite_st ** _ciphers)
{
@@ -1808,7 +1736,7 @@ _gnutls_supported_ciphersuites (gnutls_session_t session,
return GNUTLS_E_MEMORY_ERROR;
}
- version = gnutls_protocol_get_version (session);
+ version = MHD_gnutls_protocol_get_version (session);
for (i = 0; i < count; i++)
{
@@ -1827,19 +1755,19 @@ _gnutls_supported_ciphersuites (gnutls_session_t session,
/* remove cipher suites which do not support the
* protocol version used.
*/
- if (_gnutls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
+ if (mhd_gtls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
continue;
- if (_gnutls_kx_priority (session,
- _gnutls_cipher_suite_get_kx_algo (&tmp_ciphers
+ if (mhd_gtls_kx_priority (session,
+ mhd_gtls_cipher_suite_get_kx_algo (&tmp_ciphers
[i])) < 0)
continue;
- if (_gnutls_mac_priority (session,
- _gnutls_cipher_suite_get_mac_algo
+ if (mhd_gtls_mac_priority (session,
+ mhd_gtls_cipher_suite_get_mac_algo
(&tmp_ciphers[i])) < 0)
continue;
- if (_gnutls_cipher_priority (session,
- _gnutls_cipher_suite_get_cipher_algo
+ if (mhd_gtls_cipher_priority (session,
+ mhd_gtls_cipher_suite_get_cipher_algo
(&tmp_ciphers[i])) < 0)
continue;
@@ -1853,7 +1781,7 @@ _gnutls_supported_ciphersuites (gnutls_session_t session,
if (ret_count > 0 && ret_count != count)
{
ciphers =
- gnutls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
+ mhd_gtls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
}
else
{
@@ -1888,7 +1816,7 @@ _gnutls_supported_ciphersuites (gnutls_session_t session,
*/
#define SUPPORTED_COMPRESSION_METHODS session->internals.priorities.compression.num_algorithms
int
-_gnutls_supported_compression_methods (gnutls_session_t session,
+mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
uint8_t ** comp)
{
unsigned int i, j;
@@ -1899,7 +1827,7 @@ _gnutls_supported_compression_methods (gnutls_session_t session,
for (i = j = 0; i < SUPPORTED_COMPRESSION_METHODS; i++)
{
- int tmp = _gnutls_compression_get_num (session->internals.priorities.
+ int tmp = mhd_gtls_compression_get_num (session->internals.priorities.
compression.priority[i]);
/* remove private compression algorithms, if requested.
@@ -1926,14 +1854,14 @@ _gnutls_supported_compression_methods (gnutls_session_t session,
}
/**
- * gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
+ * MHD_gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
* @type: is a certificate type
*
* Returns: a string (or %NULL) that contains the name of the
* specified certificate type.
**/
const char *
-gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
+MHD_gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
{
const char *ret = NULL;
@@ -1946,7 +1874,7 @@ gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
}
/**
- * gnutls_certificate_type_get_id - Returns the gnutls id of the specified in string type
+ * MHD_gtls_certificate_type_get_id - Returns the gnutls id of the specified in string type
* @name: is a certificate type name
*
* The names are compared in a case insensitive way.
@@ -1955,7 +1883,7 @@ gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
* %GNUTLS_CRT_UNKNOWN on error.
**/
gnutls_certificate_type_t
-gnutls_certificate_type_get_id (const char *name)
+MHD_gtls_certificate_type_get_id (const char *name)
{
gnutls_certificate_type_t ret = MHD_GNUTLS_CRT_UNKNOWN;
@@ -1974,7 +1902,7 @@ static const gnutls_certificate_type_t supported_certificate_types[] =
};
/**
- * gnutls_certificate_type_list:
+ * MHD_gtls_certificate_type_list:
*
* Get a list of certificate types. Note that to be able to use
* OpenPGP certificates, you must link to libgnutls-extra and call
@@ -1985,7 +1913,7 @@ static const gnutls_certificate_type_t supported_certificate_types[] =
*
**/
const gnutls_certificate_type_t *
-gnutls_certificate_type_list (void)
+MHD_gtls_certificate_type_list (void)
{
return supported_certificate_types;
}
@@ -1994,7 +1922,7 @@ gnutls_certificate_type_list (void)
* the given gnutls_kx_algorithm_t.
*/
gnutls_pk_algorithm_t
-_gnutls_map_pk_get_pk (gnutls_kx_algorithm_t kx_algorithm)
+mhd_gtls_map_pk_get_pk (gnutls_kx_algorithm_t kx_algorithm)
{
gnutls_pk_algorithm_t ret = -1;
@@ -2007,7 +1935,7 @@ _gnutls_map_pk_get_pk (gnutls_kx_algorithm_t kx_algorithm)
* ex. GNUTLS_KX_RSA requires a certificate able to encrypt... so returns CIPHER_ENCRYPT.
*/
enum encipher_type
-_gnutls_kx_encipher_type (gnutls_kx_algorithm_t kx_algorithm)
+mhd_gtls_kx_encipher_type (gnutls_kx_algorithm_t kx_algorithm)
{
int ret = CIPHER_IGN;
GNUTLS_PK_MAP_ALG_LOOP (ret = p->encipher_type) return ret;
@@ -2068,26 +1996,8 @@ static const gnutls_sign_entry sign_algorithms[] = {
#define GNUTLS_SIGN_ALG_LOOP(a) \
GNUTLS_SIGN_LOOP( if(p->id && p->id == sign) { a; break; } )
-/**
- * gnutls_sign_algorithm_get_name - Returns a string with the name of the specified sign algorithm
- * @algorithm: is a sign algorithm
- *
- * Returns: a string that contains the name of the specified sign
- * algorithm, or %NULL.
- **/
-const char *
-gnutls_sign_algorithm_get_name (gnutls_sign_algorithm_t sign)
-{
- const char *ret = NULL;
-
- /* avoid prefix */
- GNUTLS_SIGN_ALG_LOOP (ret = p->name);
-
- return ret;
-}
-
gnutls_sign_algorithm_t
-_gnutls_x509_oid2sign_algorithm (const char *oid)
+mhd_gtls_x509_oid2sign_algorithm (const char *oid)
{
gnutls_sign_algorithm_t ret = 0;
@@ -2105,7 +2015,7 @@ _gnutls_x509_oid2sign_algorithm (const char *oid)
}
gnutls_sign_algorithm_t
-_gnutls_x509_pk_to_sign (gnutls_pk_algorithm_t pk, gnutls_mac_algorithm_t mac)
+mhd_gtls_x509_pk_to_sign (gnutls_pk_algorithm_t pk, gnutls_mac_algorithm_t mac)
{
gnutls_sign_algorithm_t ret = 0;
@@ -2120,13 +2030,13 @@ _gnutls_x509_pk_to_sign (gnutls_pk_algorithm_t pk, gnutls_mac_algorithm_t mac)
}
const char *
-_gnutls_x509_sign_to_oid (gnutls_pk_algorithm_t pk,
+mhd_gtls_x509_sign_to_oid (gnutls_pk_algorithm_t pk,
gnutls_mac_algorithm_t mac)
{
gnutls_sign_algorithm_t sign;
const char *ret = NULL;
- sign = _gnutls_x509_pk_to_sign (pk, mac);
+ sign = mhd_gtls_x509_pk_to_sign (pk, mac);
if (sign == GNUTLS_SIGN_UNKNOWN)
return NULL;
@@ -2159,31 +2069,8 @@ static const gnutls_pk_entry pk_algorithms[] = {
0}
};
-/**
- * gnutls_pk_algorithm_get_name - Returns a string with the name of the specified public key algorithm
- * @algorithm: is a pk algorithm
- *
- * Returns: a string that contains the name of the specified public
- * key algorithm, or %NULL.
- **/
-const char *
-gnutls_pk_algorithm_get_name (gnutls_pk_algorithm_t algorithm)
-{
- const char *ret = NULL;
- const gnutls_pk_entry *p;
-
- for (p = pk_algorithms; p->name != NULL; p++)
- if (p->id && p->id == algorithm)
- {
- ret = p->name;
- break;
- }
-
- return ret;
-}
-
gnutls_pk_algorithm_t
-_gnutls_x509_oid2pk_algorithm (const char *oid)
+mhd_gtls_x509_oid2pk_algorithm (const char *oid)
{
gnutls_pk_algorithm_t ret = MHD_GNUTLS_PK_UNKNOWN;
const gnutls_pk_entry *p;
@@ -2199,7 +2086,7 @@ _gnutls_x509_oid2pk_algorithm (const char *oid)
}
const char *
-_gnutls_x509_pk_to_oid (gnutls_pk_algorithm_t algorithm)
+mhd_gtls_x509_pk_to_oid (gnutls_pk_algorithm_t algorithm)
{
const char *ret = NULL;
const gnutls_pk_entry *p;
diff --git a/src/daemon/https/tls/gnutls_algorithms.h b/src/daemon/https/tls/gnutls_algorithms.h
@@ -23,87 +23,87 @@
*/
#ifndef ALGORITHMS_H
-# define ALGORITHMS_H
+#define ALGORITHMS_H
#include "gnutls_auth.h"
/* Functions for version handling. */
-gnutls_protocol_t _gnutls_version_lowest (gnutls_session_t session);
-gnutls_protocol_t _gnutls_version_max (gnutls_session_t session);
-int _gnutls_version_priority (gnutls_session_t session,
+gnutls_protocol_t mhd_gtls_version_lowest (mhd_gtls_session_t session);
+gnutls_protocol_t mhd_gtls_version_max (mhd_gtls_session_t session);
+int mhd_gtls_version_priority (mhd_gtls_session_t session,
gnutls_protocol_t version);
-int _gnutls_version_is_supported (gnutls_session_t session,
+int mhd_gtls_version_is_supported (mhd_gtls_session_t session,
const gnutls_protocol_t version);
-int _gnutls_version_get_major (gnutls_protocol_t ver);
-int _gnutls_version_get_minor (gnutls_protocol_t ver);
-gnutls_protocol_t _gnutls_version_get (int major, int minor);
+int mhd_gtls_version_get_major (gnutls_protocol_t ver);
+int mhd_gtls_version_get_minor (gnutls_protocol_t ver);
+gnutls_protocol_t mhd_gtls_version_get (int major, int minor);
/* Functions for MACs. */
-int _gnutls_mac_is_ok (gnutls_mac_algorithm_t algorithm);
-gnutls_mac_algorithm_t _gnutls_x509_oid2mac_algorithm (const char *oid);
-const char *_gnutls_x509_mac_to_oid (gnutls_mac_algorithm_t mac);
+int mhd_gnutls_mac_is_ok (gnutls_mac_algorithm_t algorithm);
+gnutls_mac_algorithm_t mhd_gtls_x509_oid2mac_algorithm (const char *oid);
+const char * mhd_gtls_x509_mac_to_oid (gnutls_mac_algorithm_t mac);
/* Functions for cipher suites. */
-int _gnutls_supported_ciphersuites (gnutls_session_t session,
+int mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
cipher_suite_st ** ciphers);
-int _gnutls_supported_ciphersuites_sorted (gnutls_session_t session,
+int mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
cipher_suite_st ** ciphers);
-int _gnutls_supported_compression_methods (gnutls_session_t session,
+int mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
uint8_t ** comp);
-const char *_gnutls_cipher_suite_get_name (cipher_suite_st * algorithm);
-gnutls_cipher_algorithm_t _gnutls_cipher_suite_get_cipher_algo (const
+const char * mhd_gtls_cipher_suite_get_name (cipher_suite_st * algorithm);
+gnutls_cipher_algorithm_t mhd_gtls_cipher_suite_get_cipher_algo (const
cipher_suite_st
* algorithm);
-gnutls_kx_algorithm_t _gnutls_cipher_suite_get_kx_algo (const cipher_suite_st
+gnutls_kx_algorithm_t mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st
* algorithm);
-gnutls_mac_algorithm_t _gnutls_cipher_suite_get_mac_algo (const
+gnutls_mac_algorithm_t mhd_gtls_cipher_suite_get_mac_algo (const
cipher_suite_st *
algorithm);
-gnutls_protocol_t _gnutls_cipher_suite_get_version (const cipher_suite_st *
+gnutls_protocol_t mhd_gtls_cipher_suite_get_version (const cipher_suite_st *
algorithm);
-cipher_suite_st _gnutls_cipher_suite_get_suite_name (cipher_suite_st *
+cipher_suite_st mhd_gtls_cipher_suite_get_suite_name (cipher_suite_st *
algorithm);
/* Functions for ciphers. */
-int _gnutls_cipher_get_block_size (gnutls_cipher_algorithm_t algorithm);
-int _gnutls_cipher_is_block (gnutls_cipher_algorithm_t algorithm);
-int _gnutls_cipher_is_ok (gnutls_cipher_algorithm_t algorithm);
-int _gnutls_cipher_get_iv_size (gnutls_cipher_algorithm_t algorithm);
-int _gnutls_cipher_get_export_flag (gnutls_cipher_algorithm_t algorithm);
+int mhd_gtls_cipher_get_block_size (gnutls_cipher_algorithm_t algorithm);
+int mhd_gtls_cipher_is_block (gnutls_cipher_algorithm_t algorithm);
+int mhd_gtls_cipher_is_ok (gnutls_cipher_algorithm_t algorithm);
+int mhd_gtls_cipher_get_iv_size (gnutls_cipher_algorithm_t algorithm);
+int mhd_gtls_cipher_get_export_flag (gnutls_cipher_algorithm_t algorithm);
/* Functions for key exchange. */
-int _gnutls_kx_needs_dh_params (gnutls_kx_algorithm_t algorithm);
-int _gnutls_kx_needs_rsa_params (gnutls_kx_algorithm_t algorithm);
-mod_auth_st *_gnutls_kx_auth_struct (gnutls_kx_algorithm_t algorithm);
-int _gnutls_kx_is_ok (gnutls_kx_algorithm_t algorithm);
+int mhd_gtls_kx_needs_dh_params (gnutls_kx_algorithm_t algorithm);
+int mhd_gtls_kx_needs_rsa_params (gnutls_kx_algorithm_t algorithm);
+mhd_gtls_mod_auth_st * mhd_gtls_kx_auth_struct (gnutls_kx_algorithm_t algorithm);
+int mhd_gtls_kx_is_ok (gnutls_kx_algorithm_t algorithm);
/* Functions for compression. */
-int _gnutls_compression_is_ok (gnutls_compression_method_t algorithm);
-int _gnutls_compression_get_num (gnutls_compression_method_t algorithm);
-gnutls_compression_method_t _gnutls_compression_get_id (int num);
-int _gnutls_compression_get_mem_level (gnutls_compression_method_t algorithm);
-int _gnutls_compression_get_comp_level (gnutls_compression_method_t
+int mhd_gtls_compression_is_ok (gnutls_compression_method_t algorithm);
+int mhd_gtls_compression_get_num (gnutls_compression_method_t algorithm);
+gnutls_compression_method_t mhd_gtls_compression_get_id (int num);
+int mhd_gtls_compression_get_mem_level (gnutls_compression_method_t algorithm);
+int mhd_gtls_compression_get_comp_level (gnutls_compression_method_t
algorithm);
-int _gnutls_compression_get_wbits (gnutls_compression_method_t algorithm);
+int mhd_gtls_compression_get_wbits (gnutls_compression_method_t algorithm);
/* Type to KX mappings. */
-gnutls_kx_algorithm_t _gnutls_map_kx_get_kx (gnutls_credentials_type_t type,
+gnutls_kx_algorithm_t mhd_gtls_map_kx_get_kx (gnutls_credentials_type_t type,
int server);
-gnutls_credentials_type_t _gnutls_map_kx_get_cred (gnutls_kx_algorithm_t
+gnutls_credentials_type_t mhd_gtls_map_kx_get_cred (gnutls_kx_algorithm_t
algorithm, int server);
/* KX to PK mapping. */
-gnutls_pk_algorithm_t _gnutls_map_pk_get_pk (gnutls_kx_algorithm_t
+gnutls_pk_algorithm_t mhd_gtls_map_pk_get_pk (gnutls_kx_algorithm_t
kx_algorithm);
-gnutls_pk_algorithm_t _gnutls_x509_oid2pk_algorithm (const char *oid);
-const char *_gnutls_x509_pk_to_oid (gnutls_pk_algorithm_t pk);
+gnutls_pk_algorithm_t mhd_gtls_x509_oid2pk_algorithm (const char *oid);
+const char * mhd_gtls_x509_pk_to_oid (gnutls_pk_algorithm_t pk);
enum encipher_type
{ CIPHER_ENCRYPT = 0, CIPHER_SIGN = 1, CIPHER_IGN };
-enum encipher_type _gnutls_kx_encipher_type (gnutls_kx_algorithm_t algorithm);
+enum encipher_type mhd_gtls_kx_encipher_type (gnutls_kx_algorithm_t algorithm);
-struct gnutls_compression_entry
+struct mhd_gtls_compression_entry
{
const char *name;
gnutls_compression_method_t id;
@@ -114,28 +114,28 @@ struct gnutls_compression_entry
int mem_level;
int comp_level;
};
-typedef struct gnutls_compression_entry gnutls_compression_entry;
+typedef struct mhd_gtls_compression_entry gnutls_compression_entry;
/* Functions for sign algorithms. */
-gnutls_sign_algorithm_t _gnutls_x509_oid2sign_algorithm (const char *oid);
-gnutls_sign_algorithm_t _gnutls_x509_pk_to_sign (gnutls_pk_algorithm_t pk,
+gnutls_sign_algorithm_t mhd_gtls_x509_oid2sign_algorithm (const char *oid);
+gnutls_sign_algorithm_t mhd_gtls_x509_pk_to_sign (gnutls_pk_algorithm_t pk,
gnutls_mac_algorithm_t mac);
-const char *_gnutls_x509_sign_to_oid (gnutls_pk_algorithm_t,
+const char * mhd_gtls_x509_sign_to_oid (gnutls_pk_algorithm_t,
gnutls_mac_algorithm_t mac);
-int _gnutls_mac_priority (gnutls_session_t session,
+int mhd_gtls_mac_priority (mhd_gtls_session_t session,
gnutls_mac_algorithm_t algorithm);
-int _gnutls_cipher_priority (gnutls_session_t session,
+int mhd_gtls_cipher_priority (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algorithm);
-int _gnutls_kx_priority (gnutls_session_t session,
+int mhd_gtls_kx_priority (mhd_gtls_session_t session,
gnutls_kx_algorithm_t algorithm);
-int _gnutls_compression_priority (gnutls_session_t session,
+int mhd_gtls_compression_priority (mhd_gtls_session_t session,
gnutls_compression_method_t algorithm);
-gnutls_mac_algorithm_t gnutls_mac_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);
+gnutls_mac_algorithm_t MHD_gtls_mac_get_id (const char* name);
+gnutls_cipher_algorithm_t MHD_gtls_cipher_get_id (const char* name);
+gnutls_kx_algorithm_t MHD_gtls_kx_get_id (const char* name);
+gnutls_protocol_t MHD_gtls_protocol_get_id (const char* name);
+gnutls_certificate_type_t MHD_gtls_certificate_type_get_id (const char* name);
#endif
diff --git a/src/daemon/https/tls/gnutls_anon_cred.c b/src/daemon/https/tls/gnutls_anon_cred.c
@@ -36,22 +36,22 @@
static const int anon_dummy;
/**
- * gnutls_anon_free_server_credentials - Used to free an allocated gnutls_anon_server_credentials_t structure
- * @sc: is an #gnutls_anon_server_credentials_t structure.
+ * MHD_gnutls_anon_free_server_credentials - Used to free an allocated mhd_gtls_anon_server_credentials_t structure
+ * @sc: is an #mhd_gtls_anon_server_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to free (deallocate) it.
**/
void
-gnutls_anon_free_server_credentials (gnutls_anon_server_credentials_t sc)
+MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t sc)
{
gnutls_free (sc);
}
/**
- * gnutls_anon_allocate_server_credentials - Used to allocate an gnutls_anon_server_credentials_t structure
- * @sc: is a pointer to an #gnutls_anon_server_credentials_t structure.
+ * MHD_gnutls_anon_allocate_server_credentials - Used to allocate an mhd_gtls_anon_server_credentials_t structure
+ * @sc: is a pointer to an #mhd_gtls_anon_server_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to allocate it.
@@ -59,10 +59,10 @@ gnutls_anon_free_server_credentials (gnutls_anon_server_credentials_t sc)
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_anon_allocate_server_credentials (gnutls_anon_server_credentials_t *
+MHD_gnutls_anon_allocate_server_credentials (mhd_gtls_anon_server_credentials_t *
sc)
{
- *sc = gnutls_calloc (1, sizeof (anon_server_credentials_st));
+ *sc = gnutls_calloc (1, sizeof (mhd_anon_server_credentials_st));
if (*sc == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -71,20 +71,20 @@ gnutls_anon_allocate_server_credentials (gnutls_anon_server_credentials_t *
/**
- * gnutls_anon_free_client_credentials - Used to free an allocated gnutls_anon_client_credentials_t structure
- * @sc: is an #gnutls_anon_client_credentials_t structure.
+ * MHD_gnutls_anon_free_client_credentials - Used to free an allocated mhd_gtls_anon_client_credentials_t structure
+ * @sc: is an #mhd_gtls_anon_client_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to free (deallocate) it.
**/
void
-gnutls_anon_free_client_credentials (gnutls_anon_client_credentials_t sc)
+MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t sc)
{
}
/**
- * gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
- * @sc: is a pointer to an #gnutls_anon_client_credentials_t structure.
+ * MHD_gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
+ * @sc: is a pointer to an #mhd_gtls_anon_client_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus
* this helper function is provided in order to allocate it.
@@ -92,7 +92,7 @@ gnutls_anon_free_client_credentials (gnutls_anon_client_credentials_t sc)
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_anon_allocate_client_credentials (gnutls_anon_client_credentials_t *
+MHD_gnutls_anon_allocate_client_credentials (mhd_gtls_anon_client_credentials_t *
sc)
{
/* anon_dummy is only there for *sc not to be null.
@@ -104,8 +104,8 @@ gnutls_anon_allocate_client_credentials (gnutls_anon_client_credentials_t *
}
/**
- * gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
- * @res: is a gnutls_anon_server_credentials_t structure
+ * MHD_gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
+ * @res: is a mhd_gtls_anon_server_credentials_t structure
* @dh_params: is a structure that holds diffie hellman parameters.
*
* This function will set the diffie hellman parameters for an
@@ -113,15 +113,15 @@ gnutls_anon_allocate_client_credentials (gnutls_anon_client_credentials_t *
* Anonymous Diffie Hellman cipher suites.
**/
void
-gnutls_anon_set_server_dh_params (gnutls_anon_server_credentials_t res,
- gnutls_dh_params_t dh_params)
+MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
+ mhd_gtls_dh_params_t dh_params)
{
res->dh_params = dh_params;
}
/**
- * gnutls_anon_set_server_params_function - This function will set the DH parameters callback
- * @res: is a gnutls_certificate_credentials_t structure
+ * MHD_gnutls_anon_set_server_params_function - This function will set the DH parameters callback
+ * @res: is a mhd_gtls_cert_credentials_t structure
* @func: is the function to be called
*
* This function will set a callback in order for the server to get
@@ -129,7 +129,7 @@ gnutls_anon_set_server_dh_params (gnutls_anon_server_credentials_t res,
* callback should return zero on success.
**/
void
-gnutls_anon_set_server_params_function (gnutls_anon_server_credentials_t res,
+MHD_gnutls_anon_set_server_params_function (mhd_gtls_anon_server_credentials_t res,
gnutls_params_function * func)
{
res->params_func = func;
diff --git a/src/daemon/https/tls/gnutls_auth.c b/src/daemon/https/tls/gnutls_auth.c
@@ -37,14 +37,14 @@
*/
/**
- * gnutls_credentials_clear - Clears all the credentials previously set
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_credentials_clear - Clears all the credentials previously set
+ * @session: is a #mhd_gtls_session_t structure.
*
* Clears all the credentials previously set in this session.
*
**/
void
-gnutls_credentials_clear (gnutls_session_t session)
+MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
{
if (session->key && session->key->cred)
{ /* beginning of the list */
@@ -65,8 +65,8 @@ gnutls_credentials_clear (gnutls_session_t session)
* { algorithm, credentials, pointer to next }
*/
/**
- * gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
+ * @session: is a #mhd_gtls_session_t structure.
* @type: is the type of the credentials
* @cred: is a pointer to a structure.
*
@@ -77,20 +77,20 @@ gnutls_credentials_clear (gnutls_session_t session)
* [ In order to minimize memory usage, and share credentials between
* several threads gnutls keeps a pointer to cred, and not the whole cred
* structure. Thus you will have to keep the structure allocated until
- * you call gnutls_deinit(). ]
+ * you call MHD_gnutls_deinit(). ]
*
- * For GNUTLS_CRD_ANON cred should be gnutls_anon_client_credentials_t in case of a client.
- * In case of a server it should be gnutls_anon_server_credentials_t.
+ * For GNUTLS_CRD_ANON cred should be mhd_gtls_anon_client_credentials_t in case of a client.
+ * In case of a server it should be mhd_gtls_anon_server_credentials_t.
*
* For GNUTLS_CRD_SRP cred should be gnutls_srp_client_credentials_t
* in case of a client, and gnutls_srp_server_credentials_t, in case
* of a server.
*
- * For GNUTLS_CRD_CERTIFICATE cred should be gnutls_certificate_credentials_t.
+ * For GNUTLS_CRD_CERTIFICATE cred should be mhd_gtls_cert_credentials_t.
*
**/
int
-gnutls_credentials_set (gnutls_session_t session,
+MHD_gnutls_credentials_set (mhd_gtls_session_t session,
gnutls_credentials_type_t type, void *cred)
{
auth_cred_st *ccred = NULL, *pcred = NULL;
@@ -150,8 +150,8 @@ gnutls_credentials_set (gnutls_session_t session,
}
/**
- * gnutls_auth_get_type - Returns the type of credentials for the current authentication schema.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_auth_get_type - Returns the type of credentials for the current authentication schema.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns type of credentials for the current authentication schema.
* The returned information is to be used to distinguish the function used
@@ -161,7 +161,7 @@ gnutls_credentials_set (gnutls_session_t session,
* the same function are to be used to access the authentication data.
**/
gnutls_credentials_type_t
-gnutls_auth_get_type (gnutls_session_t session)
+MHD_gtls_auth_get_type (mhd_gtls_session_t session)
{
/* This is not the credentials we must set, but the authentication data
* we get by the peer, so it should be reversed.
@@ -169,14 +169,14 @@ gnutls_auth_get_type (gnutls_session_t session)
int server = session->security_parameters.entity == GNUTLS_SERVER ? 0 : 1;
return
- _gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
+ mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), server);
}
/**
- * gnutls_auth_server_get_type - Returns the type of credentials for the server authentication schema.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_auth_server_get_type - Returns the type of credentials for the server authentication schema.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns the type of credentials that were used for server authentication.
* The returned information is to be used to distinguish the function used
@@ -184,17 +184,17 @@ gnutls_auth_get_type (gnutls_session_t session)
*
**/
gnutls_credentials_type_t
-gnutls_auth_server_get_type (gnutls_session_t session)
+MHD_gtls_auth_server_get_type (mhd_gtls_session_t session)
{
return
- _gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
+ mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), 1);
}
/**
- * gnutls_auth_client_get_type - Returns the type of credentials for the client authentication schema.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_auth_client_get_type - Returns the type of credentials for the client authentication schema.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns the type of credentials that were used for client authentication.
* The returned information is to be used to distinguish the function used
@@ -202,10 +202,10 @@ gnutls_auth_server_get_type (gnutls_session_t session)
*
**/
gnutls_credentials_type_t
-gnutls_auth_client_get_type (gnutls_session_t session)
+MHD_gtls_auth_client_get_type (mhd_gtls_session_t session)
{
return
- _gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
+ mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), 0);
}
@@ -216,17 +216,17 @@ gnutls_auth_client_get_type (gnutls_session_t session)
* free that!!!
*/
const void *
-_gnutls_get_kx_cred (gnutls_session_t session,
+mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
gnutls_kx_algorithm_t algo, int *err)
{
int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
- return _gnutls_get_cred (session->key,
- _gnutls_map_kx_get_cred (algo, server), err);
+ return mhd_gtls_get_cred (session->key,
+ mhd_gtls_map_kx_get_cred (algo, server), err);
}
const void *
-_gnutls_get_cred (gnutls_key_st key, gnutls_credentials_type_t type, int *err)
+mhd_gtls_get_cred (mhd_gtls_key_st key, gnutls_credentials_type_t type, int *err)
{
const void *retval = NULL;
int _err = -1;
@@ -257,10 +257,10 @@ out:
}
/*-
- * _gnutls_get_auth_info - Returns a pointer to authentication information.
- * @session: is a #gnutls_session_t structure.
+ * mhd_gtls_get_auth_info - Returns a pointer to authentication information.
+ * @session: is a #mhd_gtls_session_t structure.
*
- * This function must be called after a succesful gnutls_handshake().
+ * This function must be called after a succesful MHD_gnutls_handshake().
* Returns a pointer to authentication information. That information
* is data obtained by the handshake protocol, the key exchange algorithm,
* and the TLS extensions messages.
@@ -270,21 +270,21 @@ out:
* In case of GNUTLS_CRD_SRP returns a type of &srp_(server/client)_auth_info_t;
-*/
void *
-_gnutls_get_auth_info (gnutls_session_t session)
+mhd_gtls_get_auth_info (mhd_gtls_session_t session)
{
return session->key->auth_info;
}
/*-
- * _gnutls_free_auth_info - Frees the auth info structure
- * @session: is a #gnutls_session_t structure.
+ * mhd_gtls_free_auth_info - Frees the auth info structure
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function frees the auth info structure and sets it to
* null. It must be called since some structures contain malloced
* elements.
-*/
void
-_gnutls_free_auth_info (gnutls_session_t session)
+mhd_gtls_free_auth_info (mhd_gtls_session_t session)
{
dh_info_st *dh_info;
rsa_info_st *rsa_info;
@@ -301,19 +301,19 @@ _gnutls_free_auth_info (gnutls_session_t session)
break;
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info = _gnutls_get_auth_info (session);
+ mhd_anon_auth_info_t info = mhd_gtls_get_auth_info (session);
if (info == NULL)
break;
dh_info = &info->dh;
- _gnutls_free_dh_info (dh_info);
+ mhd_gtls_free_dh_info (dh_info);
}
break;
case MHD_GNUTLS_CRD_CERTIFICATE:
{
unsigned int i;
- cert_auth_info_t info = _gnutls_get_auth_info (session);
+ cert_auth_info_t info = mhd_gtls_get_auth_info (session);
if (info == NULL)
break;
@@ -329,8 +329,8 @@ _gnutls_free_auth_info (gnutls_session_t session)
info->raw_certificate_list = NULL;
info->ncerts = 0;
- _gnutls_free_dh_info (dh_info);
- _gnutls_free_rsa_info (rsa_info);
+ mhd_gtls_free_dh_info (dh_info);
+ mhd_gtls_free_rsa_info (rsa_info);
}
@@ -353,7 +353,7 @@ _gnutls_free_auth_info (gnutls_session_t session)
* info structure to a different type.
*/
int
-_gnutls_auth_info_set (gnutls_session_t session,
+mhd_gtls_auth_info_set (mhd_gtls_session_t session,
gnutls_credentials_type_t type, int size,
int allow_change)
{
@@ -378,7 +378,7 @@ _gnutls_auth_info_set (gnutls_session_t session,
* ciphersuite which is negotiated has different authentication
* schema.
*/
- if (gnutls_auth_get_type (session) != session->key->auth_info_type)
+ if (MHD_gtls_auth_get_type (session) != session->key->auth_info_type)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
@@ -392,10 +392,10 @@ _gnutls_auth_info_set (gnutls_session_t session,
* certificate (in order to prevent revealing the certificate's contents,
* to passive eavesdropers.
*/
- if (gnutls_auth_get_type (session) != session->key->auth_info_type)
+ if (MHD_gtls_auth_get_type (session) != session->key->auth_info_type)
{
- _gnutls_free_auth_info (session);
+ mhd_gtls_free_auth_info (session);
session->key->auth_info = calloc (1, size);
if (session->key->auth_info == NULL)
diff --git a/src/daemon/https/tls/gnutls_auth.h b/src/daemon/https/tls/gnutls_auth.h
@@ -23,28 +23,28 @@
*/
#ifndef GNUTLS_AUTH_H
-# define GNUTLS_AUTH_H
+#define GNUTLS_AUTH_H
-typedef struct mod_auth_st_int
+typedef struct mhd_gtls_mod_auth_st_int
{
const char *name; /* null terminated */
- int (*gnutls_generate_server_certificate) (gnutls_session_t, opaque **);
- int (*gnutls_generate_client_certificate) (gnutls_session_t, opaque **);
- int (*gnutls_generate_server_kx) (gnutls_session_t, opaque **);
- int (*gnutls_generate_client_kx) (gnutls_session_t, opaque **); /* used in SRP */
- int (*gnutls_generate_client_cert_vrfy) (gnutls_session_t, opaque **);
- int (*gnutls_generate_server_certificate_request) (gnutls_session_t,
+ int (* mhd_gtls_gen_server_certificate) (mhd_gtls_session_t, opaque **);
+ int (* mhd_gtls_gen_client_certificate) (mhd_gtls_session_t, opaque **);
+ int (* mhd_gtls_gen_server_kx) (mhd_gtls_session_t, opaque **);
+ int (* mhd_gtls_gen_client_kx) (mhd_gtls_session_t, opaque **); /* used in SRP */
+ int (* mhd_gtls_gen_client_cert_vrfy) (mhd_gtls_session_t, opaque **);
+ int (* mhd_gtls_gen_server_certificate_request) (mhd_gtls_session_t,
opaque **);
- int (*gnutls_process_server_certificate) (gnutls_session_t, opaque *,
+ int (* mhd_gtls_process_server_certificate) (mhd_gtls_session_t, opaque *,
size_t);
- int (*gnutls_process_client_certificate) (gnutls_session_t, opaque *,
+ int (* mhd_gtls_process_client_certificate) (mhd_gtls_session_t, opaque *,
size_t);
- int (*gnutls_process_server_kx) (gnutls_session_t, opaque *, size_t);
- int (*gnutls_process_client_kx) (gnutls_session_t, opaque *, size_t);
- int (*gnutls_process_client_cert_vrfy) (gnutls_session_t, opaque *, size_t);
- int (*gnutls_process_server_certificate_request) (gnutls_session_t,
+ int (* mhd_gtls_process_server_kx) (mhd_gtls_session_t, opaque *, size_t);
+ int (* mhd_gtls_process_client_kx) (mhd_gtls_session_t, opaque *, size_t);
+ int (* mhd_gtls_process_client_cert_vrfy) (mhd_gtls_session_t, opaque *, size_t);
+ int (* mhd_gtls_process_server_certificate_request) (mhd_gtls_session_t,
opaque *, size_t);
-} mod_auth_st;
+} mhd_gtls_mod_auth_st;
#endif
diff --git a/src/daemon/https/tls/gnutls_auth_int.h b/src/daemon/https/tls/gnutls_auth_int.h
@@ -22,11 +22,11 @@
*
*/
-const void *_gnutls_get_cred (gnutls_key_st key,
+const void * mhd_gtls_get_cred (mhd_gtls_key_st key,
gnutls_credentials_type_t kx, int *err);
-const void *_gnutls_get_kx_cred (gnutls_session_t session,
+const void * mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
gnutls_kx_algorithm_t algo, int *err);
-void *_gnutls_get_auth_info (gnutls_session_t session);
-int _gnutls_auth_info_set (gnutls_session_t session,
+void * mhd_gtls_get_auth_info (mhd_gtls_session_t session);
+int mhd_gtls_auth_info_set (mhd_gtls_session_t session,
gnutls_credentials_type_t type, int size,
int allow_change);
diff --git a/src/daemon/https/tls/gnutls_buffer.h b/src/daemon/https/tls/gnutls_buffer.h
@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 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
- *
- */
-
-#include <gnutls_str.h>
-
-typedef gnutls_string gnutls_buffer;
-
-#define _gnutls_buffer_init(buf) _gnutls_string_init(buf, gnutls_malloc, gnutls_realloc, gnutls_free);
-#define _gnutls_buffer_clear _gnutls_string_clear
-#define _gnutls_buffer_append _gnutls_string_append_data
diff --git a/src/daemon/https/tls/gnutls_buffers.c b/src/daemon/https/tls/gnutls_buffers.c
@@ -23,19 +23,19 @@
*/
/* This is the only file that uses the berkeley sockets API.
- *
+ *
* Also holds all the buffering code used in gnutls.
* The buffering code works as:
*
- * RECORD LAYER:
+ * RECORD LAYER:
* 1. uses a buffer to hold data (application/handshake),
* we got but they were not requested, yet.
* (see gnutls_record_buffer_put(), gnutls_record_buffer_get_size() etc.)
*
* 2. uses a buffer to hold data that were incomplete (ie the read/write
* was interrupted)
- * (see _gnutls_io_read_buffered(), _gnutls_io_write_buffered() etc.)
- *
+ * (see mhd_gtls_io_read_buffered(), mhd_gtls_io_write_buffered() etc.)
+ *
* HANDSHAKE LAYER:
* 1. Uses a buffer to hold data that was not sent or received
* complete. (E.g. sent 10 bytes of a handshake packet that is 20 bytes
@@ -43,7 +43,7 @@
* (see _gnutls_handshake_send_int(), _gnutls_handshake_recv_int())
*
* 2. Uses buffer to hold the last received handshake message.
- * (see _gnutls_handshake_buffer_put() etc.)
+ * (see mhd_gtls_handshake_buffer_put() etc.)
*
*/
@@ -68,8 +68,8 @@
#endif
/**
- * gnutls_transport_set_errno:
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_transport_set_errno:
+ * @session: is a #mhd_gtls_session_t structure.
* @err: error value to store in session-specific errno variable.
*
* Store @err in the session-specific errno variable. Useful values
@@ -77,7 +77,7 @@
* treated as real errors in the push/pull function.
*
* This function is useful in replacement push/pull functions set by
- * gnutls_transport_set_push_function and
+ * MHD_gnutls_transport_set_push_function and
* gnutls_transport_set_pullpush_function under Windows, where the
* replacement push/pull may not have access to the same @errno
* variable that is used by GnuTLS (e.g., the application is linked to
@@ -85,16 +85,16 @@
*
* If you don't have the @session variable easily accessible from the
* push/pull function, and don't worry about thread conflicts, you can
- * also use gnutls_transport_set_global_errno().
+ * also use MHD_gnutls_transport_set_global_errno().
**/
void
-gnutls_transport_set_errno (gnutls_session_t session, int err)
+MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
{
session->internals.errnum = err;
}
/**
- * gnutls_transport_set_global_errno:
+ * MHD_gnutls_transport_set_global_errno:
* @err: error value to store in global errno variable.
*
* Store @err in the global errno variable. Useful values for @err is
@@ -102,7 +102,7 @@ gnutls_transport_set_errno (gnutls_session_t session, int err)
* errors in the push/pull function.
*
* This function is useful in replacement push/pull functions set by
- * gnutls_transport_set_push_function and
+ * MHD_gnutls_transport_set_push_function and
* gnutls_transport_set_pullpush_function under Windows, where the
* replacement push/pull may not have access to the same @errno
* variable that is used by GnuTLS (e.g., the application is linked to
@@ -111,10 +111,10 @@ gnutls_transport_set_errno (gnutls_session_t session, int err)
* Whether this function is thread safe or not depends on whether the
* global variable errno is thread safe, some system libraries make it
* a thread-local variable. When feasible, using the guaranteed
- * thread-safe gnutls_transport_set_errno() may be better.
+ * thread-safe MHD_gnutls_transport_set_errno() may be better.
**/
void
-gnutls_transport_set_global_errno (int err)
+MHD_gnutls_transport_set_global_errno (int err)
{
errno = err;
}
@@ -123,11 +123,11 @@ gnutls_transport_set_global_errno (int err)
* HANDSHAKE DATA.
*/
int
-_gnutls_record_buffer_put (content_type_t type,
- gnutls_session_t session,
- opaque * data, size_t length)
+mhd_gnutls_record_buffer_put (content_type_t type,
+ mhd_gtls_session_t session, opaque * data,
+ size_t length)
{
- gnutls_buffer *buf;
+ mhd_gtls_buffer *buf;
if (length == 0)
return 0;
@@ -157,7 +157,7 @@ _gnutls_record_buffer_put (content_type_t type,
return GNUTLS_E_INVALID_REQUEST;
}
- if (_gnutls_buffer_append (buf, data, length) < 0)
+ if (mhd_gtls_buffer_append (buf, data, length) < 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
@@ -167,7 +167,8 @@ _gnutls_record_buffer_put (content_type_t type,
}
int
-_gnutls_record_buffer_get_size (content_type_t type, gnutls_session_t session)
+mhd_gnutls_record_buffer_get_size (content_type_t type,
+ mhd_gtls_session_t session)
{
switch (type)
{
@@ -186,8 +187,8 @@ _gnutls_record_buffer_get_size (content_type_t type, gnutls_session_t session)
}
/**
- * gnutls_record_check_pending - checks if there are any data to receive in gnutls buffers.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_record_check_pending - checks if there are any data to receive in gnutls buffers.
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function checks if there are any data to receive
* in the gnutls buffers. Returns the size of that data or 0.
@@ -197,15 +198,14 @@ _gnutls_record_buffer_get_size (content_type_t type, gnutls_session_t session)
* to work).
**/
size_t
-gnutls_record_check_pending (gnutls_session_t session)
+MHD_gtls_record_check_pending (mhd_gtls_session_t session)
{
- return _gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
+ return mhd_gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
}
int
-_gnutls_record_buffer_get (content_type_t type,
- gnutls_session_t session,
- opaque * data, size_t length)
+mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
+ opaque * data, size_t length)
{
if (length == 0 || data == NULL)
{
@@ -289,8 +289,8 @@ _gnutls_record_buffer_get (content_type_t type,
* Flags are only used if the default recv() function is being used.
*/
static ssize_t
-_gnutls_read (gnutls_session_t session,
- void *iptr, size_t sizeOfPtr, int flags)
+_gnutls_read (mhd_gtls_session_t session, void *iptr,
+ size_t sizeOfPtr, int flags)
{
size_t left;
ssize_t i = 0;
@@ -303,13 +303,12 @@ _gnutls_read (gnutls_session_t session,
left = sizeOfPtr;
while (left > 0)
{
-
session->internals.errnum = 0;
-
if (session->internals._gnutls_pull_func == NULL)
{
- i = recv (GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left,
- flags);
+ i =
+ recv (GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left,
+ flags);
#if HAVE_WINSOCK
if (i < 0)
{
@@ -333,8 +332,9 @@ _gnutls_read (gnutls_session_t session,
#endif
}
else
- i = session->internals._gnutls_pull_func (fd, &ptr[sizeOfPtr -
- left], left);
+ i = session->internals._gnutls_pull_func (fd,
+ &ptr[sizeOfPtr - left],
+ left);
if (i < 0)
{
@@ -394,14 +394,14 @@ finish:
line[0] = 0;
sprintf (tmp, "%.4x - ", x);
- _gnutls_str_cat (line, sizeof (line), tmp);
+ mhd_gtls_str_cat (line, sizeof (line), tmp);
for (j = 0; j < 16; j++)
{
if (sum < (sizeOfPtr - left))
{
sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
- _gnutls_str_cat (line, sizeof (line), tmp);
+ mhd_gtls_str_cat (line, sizeof (line), tmp);
}
}
_gnutls_read_log ("%s\n", line);
@@ -417,7 +417,7 @@ finish:
* Clears the peeked data (read with MSG_PEEK).
*/
int
-_gnutls_io_clear_peeked_data (gnutls_session_t session)
+mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
{
char *peekdata;
int ret, sum;
@@ -457,7 +457,7 @@ _gnutls_io_clear_peeked_data (gnutls_session_t session)
}
void
-_gnutls_io_clear_read_buffer (gnutls_session_t session)
+mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t session)
{
session->internals.record_recv_buffer.length = 0;
}
@@ -465,16 +465,15 @@ _gnutls_io_clear_read_buffer (gnutls_session_t session)
/* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
* It does return gnutls_errno instead.
* This function reads data from the socket and keeps them in a buffer, of up to
- * MAX_RECV_SIZE.
+ * MAX_RECV_SIZE.
*
* This is not a general purpose function. It returns EXACTLY the data requested,
* which are stored in a local (in the session) buffer. A pointer (iptr) to this buffer is returned.
*
*/
ssize_t
-_gnutls_io_read_buffered (gnutls_session_t session,
- opaque ** iptr,
- size_t sizeOfPtr, content_type_t recv_type)
+mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
+ size_t sizeOfPtr, content_type_t recv_type)
{
ssize_t ret = 0, ret2 = 0;
size_t min;
@@ -501,7 +500,7 @@ _gnutls_io_read_buffered (gnutls_session_t session,
else
{
/* leave peeked data to the kernel space only if application data
- * is received and we don't have any peeked
+ * is received and we don't have any peeked
* data in gnutls session.
*/
if (recv_type != GNUTLS_APPLICATION_DATA
@@ -534,8 +533,8 @@ _gnutls_io_read_buffered (gnutls_session_t session,
/* Check if the previously read data plus the new data to
* receive are longer than the maximum receive buffer size.
*/
- if ((session->internals.record_recv_buffer.length + recvdata) >
- MAX_RECV_SIZE)
+ if ((session->internals.record_recv_buffer.length + recvdata)
+ > MAX_RECV_SIZE)
{
gnutls_assert (); /* internal error */
return GNUTLS_E_INVALID_REQUEST;
@@ -544,8 +543,8 @@ _gnutls_io_read_buffered (gnutls_session_t session,
/* Allocate the data required to store the new packet.
*/
alloc_size = recvdata + session->internals.record_recv_buffer.length;
- session->internals.record_recv_buffer.data
- = gnutls_realloc_fast (session->internals.record_recv_buffer.data,
+ session->internals.record_recv_buffer.data =
+ mhd_gtls_realloc_fast (session->internals.record_recv_buffer.data,
alloc_size);
if (session->internals.record_recv_buffer.data == NULL)
{
@@ -565,7 +564,7 @@ _gnutls_io_read_buffered (gnutls_session_t session,
/* return immediately if we got an interrupt or eagain
* error.
*/
- if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
+ if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
{
return ret;
}
@@ -592,7 +591,7 @@ _gnutls_io_read_buffered (gnutls_session_t session,
{
ret2 = _gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
- if (ret2 < 0 && gnutls_error_is_fatal (ret2) == 0)
+ if (ret2 < 0 && MHD_gtls_error_is_fatal (ret2) == 0)
{
return ret2;
}
@@ -652,7 +651,7 @@ _gnutls_io_read_buffered (gnutls_session_t session,
#define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
inline static int
-_gnutls_buffer_insert (gnutls_buffer * buffer,
+_gnutls_buffer_insert (mhd_gtls_buffer * buffer,
const opaque * _data, size_t data_size)
{
@@ -681,7 +680,7 @@ _gnutls_buffer_insert (gnutls_buffer * buffer,
}
- if (_gnutls_buffer_append (buffer, _data, data_size) < 0)
+ if (mhd_gtls_buffer_append (buffer, _data, data_size) < 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
@@ -691,7 +690,7 @@ _gnutls_buffer_insert (gnutls_buffer * buffer,
}
inline static int
-_gnutls_buffer_get (gnutls_buffer * buffer,
+_gnutls_buffer_get (mhd_gtls_buffer * buffer,
const opaque ** ptr, size_t * ptr_size)
{
*ptr_size = buffer->length;
@@ -708,12 +707,12 @@ _gnutls_buffer_get (gnutls_buffer * buffer,
*
* We need to push exactly the data in n, since we cannot send less
* data. In TLS the peer must receive the whole packet in order
- * to decrypt and verify the integrity.
+ * to decrypt and verify the integrity.
*
*/
ssize_t
-_gnutls_io_write_buffered (gnutls_session_t session,
- const void *iptr, size_t n)
+mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
+ const void *iptr, size_t n)
{
size_t left;
unsigned j, x, sum = 0;
@@ -743,9 +742,8 @@ _gnutls_io_write_buffered (gnutls_session_t session,
if (iptr == NULL)
{
/* checking is handled above */
- ret
- =
- _gnutls_buffer_get (&session->internals.record_send_buffer, &ptr, &n);
+ ret = _gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
+ &n);
if (ret < 0)
{
gnutls_assert ();
@@ -843,14 +841,14 @@ _gnutls_io_write_buffered (gnutls_session_t session,
break;
sprintf (tmp, "%.4x - ", x);
- _gnutls_str_cat (line, sizeof (line), tmp);
+ mhd_gtls_str_cat (line, sizeof (line), tmp);
for (j = 0; j < 16; j++)
{
if (sum < n - left)
{
sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
- _gnutls_str_cat (line, sizeof (line), tmp);
+ mhd_gtls_str_cat (line, sizeof (line), tmp);
}
else
break;
@@ -874,14 +872,14 @@ _gnutls_io_write_buffered (gnutls_session_t session,
* interrupted.
*/
ssize_t
-_gnutls_io_write_flush (gnutls_session_t session)
+mhd_gtls_io_write_flush (mhd_gtls_session_t session)
{
ssize_t ret;
if (session->internals.record_send_buffer.length == 0)
return 0; /* done */
- ret = _gnutls_io_write_buffered (session, NULL, 0);
+ ret = mhd_gtls_io_write_buffered (session, NULL, 0);
_gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
session->internals.record_send_buffer.length);
@@ -893,10 +891,10 @@ _gnutls_io_write_flush (gnutls_session_t session)
* interrupted.
*/
ssize_t
-_gnutls_handshake_io_write_flush (gnutls_session_t session)
+mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session)
{
ssize_t ret;
- ret = _gnutls_handshake_io_send_int (session, 0, 0, NULL, 0);
+ ret = mhd_gtls_handshake_io_send_int (session, 0, 0, NULL, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -914,14 +912,14 @@ _gnutls_handshake_io_write_flush (gnutls_session_t session)
return ret;
}
-/* This is a send function for the gnutls handshake
+/* This is a send function for the gnutls handshake
* protocol. Just makes sure that all data have been sent.
*/
ssize_t
-_gnutls_handshake_io_send_int (gnutls_session_t session,
- content_type_t type,
- gnutls_handshake_description_t htype,
- const void *iptr, size_t n)
+mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
+ content_type_t type,
+ gnutls_handshake_description_t htype,
+ const void *iptr, size_t n)
{
size_t left;
ssize_t ret = 0;
@@ -936,9 +934,8 @@ _gnutls_handshake_io_send_int (gnutls_session_t session,
/* resuming previously interrupted write
*/
gnutls_assert ();
- ret =
- _gnutls_buffer_get (&session->internals.handshake_send_buffer, &ptr,
- &n);
+ ret = _gnutls_buffer_get (&session->internals.handshake_send_buffer,
+ &ptr, &n);
if (ret < 0)
{
gnutls_assert ();
@@ -996,7 +993,7 @@ _gnutls_handshake_io_send_int (gnutls_session_t session,
left = n;
while (left > 0)
{
- ret = _gnutls_send_int (session, type, htype, &ptr[n - left], left);
+ ret = mhd_gtls_send_int (session, type, htype, &ptr[n - left], left);
if (ret <= 0)
{
@@ -1006,14 +1003,15 @@ _gnutls_handshake_io_send_int (gnutls_session_t session,
ret = GNUTLS_E_INTERNAL_ERROR;
}
- if (left > 0
- && (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN))
+ if (left > 0 && (ret == GNUTLS_E_INTERRUPTED || ret
+ == GNUTLS_E_AGAIN))
{
gnutls_assert ();
- retval = _gnutls_buffer_insert (&session->internals.
- handshake_send_buffer,
- &ptr[n - left], left);
+ retval =
+ _gnutls_buffer_insert (&session->internals.
+ handshake_send_buffer, &ptr[n - left],
+ left);
if (retval < 0)
{
gnutls_assert ();
@@ -1047,14 +1045,14 @@ _gnutls_handshake_io_send_int (gnutls_session_t session,
}
-/* This is a receive function for the gnutls handshake
+/* This is a receive function for the gnutls handshake
* protocol. Makes sure that we have received all data.
*/
ssize_t
-_gnutls_handshake_io_recv_int (gnutls_session_t session,
- content_type_t type,
- gnutls_handshake_description_t htype,
- void *iptr, size_t sizeOfPtr)
+mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
+ content_type_t type,
+ gnutls_handshake_description_t htype,
+ void *iptr, size_t sizeOfPtr)
{
size_t left;
ssize_t i;
@@ -1084,8 +1082,7 @@ _gnutls_handshake_io_recv_int (gnutls_session_t session,
session->internals.handshake_recv_buffer.length -= sizeOfPtr;
memmove (session->internals.handshake_recv_buffer.data,
- &session->internals.handshake_recv_buffer.
- data[sizeOfPtr],
+ &session->internals.handshake_recv_buffer.data[sizeOfPtr],
session->internals.handshake_recv_buffer.length);
return sizeOfPtr;
@@ -1105,7 +1102,7 @@ _gnutls_handshake_io_recv_int (gnutls_session_t session,
while (left > 0)
{
dsize = sizeOfPtr - left;
- i = _gnutls_recv_int (session, type, htype, &ptr[dsize], left);
+ i = mhd_gtls_recv_int (session, type, htype, &ptr[dsize], left);
if (i < 0)
{
@@ -1114,7 +1111,8 @@ _gnutls_handshake_io_recv_int (gnutls_session_t session,
gnutls_assert ();
session->internals.handshake_recv_buffer.data
- = gnutls_realloc_fast (session->internals.
+ =
+ mhd_gtls_realloc_fast (session->internals.
handshake_recv_buffer.data, dsize);
if (session->internals.handshake_recv_buffer.data == NULL)
{
@@ -1157,15 +1155,16 @@ _gnutls_handshake_io_recv_int (gnutls_session_t session,
* and finished messages.
*/
int
-_gnutls_handshake_buffer_put (gnutls_session_t session,
- opaque * data, size_t length)
+mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
+ size_t length)
{
if (length == 0)
return 0;
if ((session->internals.max_handshake_data_buffer_size > 0) && ((length
- + session->
+ +
+ session->
internals.
handshake_hash_buffer.
length) >
@@ -1179,8 +1178,8 @@ _gnutls_handshake_buffer_put (gnutls_session_t session,
_gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
- if (_gnutls_buffer_append (&session->internals.handshake_hash_buffer, data,
- length) < 0)
+ if (mhd_gtls_buffer_append (&session->internals.handshake_hash_buffer, data,
+ length) < 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
@@ -1190,7 +1189,7 @@ _gnutls_handshake_buffer_put (gnutls_session_t session,
}
int
-_gnutls_handshake_buffer_get_size (gnutls_session_t session)
+mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session)
{
return session->internals.handshake_hash_buffer.length;
@@ -1200,8 +1199,8 @@ _gnutls_handshake_buffer_get_size (gnutls_session_t session)
* and returns data from it (peek mode!)
*/
int
-_gnutls_handshake_buffer_peek (gnutls_session_t session,
- opaque * data, size_t length)
+mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
+ size_t length)
{
if (length > session->internals.handshake_hash_buffer.length)
{
@@ -1218,8 +1217,8 @@ _gnutls_handshake_buffer_peek (gnutls_session_t session,
* and returns data from it (peek mode!)
*/
int
-_gnutls_handshake_buffer_get_ptr (gnutls_session_t session,
- opaque ** data_ptr, size_t * length)
+mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
+ opaque ** data_ptr, size_t * length)
{
if (length != NULL)
*length = session->internals.handshake_hash_buffer.length;
@@ -1235,7 +1234,7 @@ _gnutls_handshake_buffer_get_ptr (gnutls_session_t session,
/* Does not free the buffer
*/
int
-_gnutls_handshake_buffer_empty (gnutls_session_t session)
+mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session)
{
_gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
@@ -1246,12 +1245,9 @@ _gnutls_handshake_buffer_empty (gnutls_session_t session)
}
int
-_gnutls_handshake_buffer_clear (gnutls_session_t session)
+mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session)
{
-
_gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
-
- _gnutls_buffer_clear (&session->internals.handshake_hash_buffer);
-
+ mhd_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
return 0;
}
diff --git a/src/daemon/https/tls/gnutls_buffers.h b/src/daemon/https/tls/gnutls_buffers.h
@@ -22,46 +22,46 @@
*
*/
-int _gnutls_record_buffer_put (content_type_t type,
- gnutls_session_t session, opaque * data,
+int mhd_gnutls_record_buffer_put (content_type_t type,
+ mhd_gtls_session_t session, opaque * data,
size_t length);
-int _gnutls_record_buffer_get_size (content_type_t type,
- gnutls_session_t session);
-int _gnutls_record_buffer_get (content_type_t type,
- gnutls_session_t session, opaque * data,
+int mhd_gnutls_record_buffer_get_size (content_type_t type,
+ mhd_gtls_session_t session);
+int mhd_gtls_record_buffer_get (content_type_t type,
+ mhd_gtls_session_t session, opaque * data,
size_t length);
-ssize_t _gnutls_io_read_buffered (gnutls_session_t, opaque ** iptr,
+ssize_t mhd_gtls_io_read_buffered (mhd_gtls_session_t, opaque ** iptr,
size_t n, content_type_t);
-void _gnutls_io_clear_read_buffer (gnutls_session_t);
-int _gnutls_io_clear_peeked_data (gnutls_session_t session);
+void mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t);
+int mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session);
-ssize_t _gnutls_io_write_buffered (gnutls_session_t, const void *iptr,
+ssize_t mhd_gtls_io_write_buffered (mhd_gtls_session_t, const void *iptr,
size_t n);
-ssize_t _gnutls_io_write_buffered2 (gnutls_session_t, const void *iptr,
+ssize_t mhd_gtls_io_write_buffered2 (mhd_gtls_session_t, const void *iptr,
size_t n, const void *iptr2, size_t n2);
-int _gnutls_handshake_buffer_get_size (gnutls_session_t session);
-int _gnutls_handshake_buffer_peek (gnutls_session_t session, opaque * data,
+int mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session);
+int mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
size_t length);
-int _gnutls_handshake_buffer_put (gnutls_session_t session, opaque * data,
+int mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
size_t length);
-int _gnutls_handshake_buffer_clear (gnutls_session_t session);
-int _gnutls_handshake_buffer_empty (gnutls_session_t session);
-int _gnutls_handshake_buffer_get_ptr (gnutls_session_t session,
+int mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session);
+int mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session);
+int mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
opaque ** data_ptr, size_t * length);
#define _gnutls_handshake_io_buffer_clear( session) \
- _gnutls_buffer_clear( &session->internals.handshake_send_buffer); \
- _gnutls_buffer_clear( &session->internals.handshake_recv_buffer); \
+ mhd_gtls_buffer_clear( &session->internals.handshake_send_buffer); \
+ mhd_gtls_buffer_clear( &session->internals.handshake_recv_buffer); \
session->internals.handshake_send_buffer_prev_size = 0
-ssize_t _gnutls_handshake_io_recv_int (gnutls_session_t, content_type_t,
+ssize_t mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t, content_type_t,
gnutls_handshake_description_t, void *,
size_t);
-ssize_t _gnutls_handshake_io_send_int (gnutls_session_t, content_type_t,
+ssize_t mhd_gtls_handshake_io_send_int (mhd_gtls_session_t, content_type_t,
gnutls_handshake_description_t,
const void *, size_t);
-ssize_t _gnutls_io_write_flush (gnutls_session_t session);
-ssize_t _gnutls_handshake_io_write_flush (gnutls_session_t session);
+ssize_t mhd_gtls_io_write_flush (mhd_gtls_session_t session);
+ssize_t mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session);
-size_t gnutls_record_check_pending (gnutls_session_t session);
+size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
diff --git a/src/daemon/https/tls/gnutls_cert.c b/src/daemon/https/tls/gnutls_cert.c
@@ -46,8 +46,8 @@
#include "mpi.h"
/**
- * gnutls_certificate_free_keys - Used to free all the keys from a gnutls_certificate_credentials_t structure
- * @sc: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_free_keys - Used to free all the keys from a mhd_gtls_cert_credentials_t structure
+ * @sc: is an #mhd_gtls_cert_credentials_t structure.
*
* This function will delete all the keys and the certificates associated
* with the given credentials. This function must not be called when a
@@ -55,7 +55,7 @@
*
**/
void
-gnutls_certificate_free_keys (gnutls_certificate_credentials_t sc)
+MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
{
unsigned i, j;
@@ -63,7 +63,7 @@ gnutls_certificate_free_keys (gnutls_certificate_credentials_t sc)
{
for (j = 0; j < sc->cert_list_length[i]; j++)
{
- _gnutls_gcert_deinit (&sc->cert_list[i][j]);
+ mhd_gtls_gcert_deinit (&sc->cert_list[i][j]);
}
gnutls_free (sc->cert_list[i]);
}
@@ -76,7 +76,7 @@ gnutls_certificate_free_keys (gnutls_certificate_credentials_t sc)
for (i = 0; i < sc->ncerts; i++)
{
- _gnutls_gkey_deinit (&sc->pkey[i]);
+ mhd_gtls_gkey_deinit (&sc->pkey[i]);
}
gnutls_free (sc->pkey);
@@ -87,17 +87,17 @@ gnutls_certificate_free_keys (gnutls_certificate_credentials_t sc)
}
/**
- * gnutls_certificate_free_cas - Used to free all the CAs from a gnutls_certificate_credentials_t structure
- * @sc: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_free_cas - Used to free all the CAs from a mhd_gtls_cert_credentials_t structure
+ * @sc: is an #mhd_gtls_cert_credentials_t structure.
*
* This function will delete all the CAs associated
* with the given credentials. Servers that do not use
- * gnutls_certificate_verify_peers2() may call this to
+ * MHD_gtls_certificate_verify_peers2() may call this to
* save some memory.
*
**/
void
-gnutls_certificate_free_cas (gnutls_certificate_credentials_t sc)
+MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc)
{
unsigned j;
@@ -114,8 +114,8 @@ gnutls_certificate_free_cas (gnutls_certificate_credentials_t sc)
}
/**
- * gnutls_certificate_free_ca_names - Used to free all the CA names from a gnutls_certificate_credentials_t structure
- * @sc: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_free_ca_names - Used to free all the CA names from a mhd_gtls_cert_credentials_t structure
+ * @sc: is an #mhd_gtls_cert_credentials_t structure.
*
* This function will delete all the CA name in the
* given credentials. Clients may call this to save some memory
@@ -126,13 +126,13 @@ gnutls_certificate_free_cas (gnutls_certificate_credentials_t sc)
*
**/
void
-gnutls_certificate_free_ca_names (gnutls_certificate_credentials_t sc)
+MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc)
{
_gnutls_free_datum (&sc->x509_rdn_sequence);
}
/*-
- * _gnutls_certificate_get_rsa_params - Returns the RSA parameters pointer
+ * mhd_gtls_certificate_get_rsa_params - Returns the RSA parameters pointer
* @rsa_params: holds the RSA parameters or NULL.
* @func: function to retrieve the parameters or NULL.
* @session: The session.
@@ -140,10 +140,10 @@ gnutls_certificate_free_ca_names (gnutls_certificate_credentials_t sc)
* This function will return the rsa parameters pointer.
*
-*/
-gnutls_rsa_params_t
-_gnutls_certificate_get_rsa_params (gnutls_rsa_params_t rsa_params,
+mhd_gtls_rsa_params_t
+mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
gnutls_params_function * func,
- gnutls_session_t session)
+ mhd_gtls_session_t session)
{
gnutls_params_st params;
int ret;
@@ -172,8 +172,8 @@ _gnutls_certificate_get_rsa_params (gnutls_rsa_params_t rsa_params,
/**
- * gnutls_certificate_free_credentials - Used to free an allocated gnutls_certificate_credentials_t structure
- * @sc: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_free_credentials - Used to free an allocated mhd_gtls_cert_credentials_t structure
+ * @sc: is an #mhd_gtls_cert_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus
* this helper function is provided in order to free (deallocate) it.
@@ -183,13 +183,13 @@ _gnutls_certificate_get_rsa_params (gnutls_rsa_params_t rsa_params,
* this function).
**/
void
-gnutls_certificate_free_credentials (gnutls_certificate_credentials_t sc)
+MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t sc)
{
- gnutls_certificate_free_keys (sc);
- gnutls_certificate_free_cas (sc);
- gnutls_certificate_free_ca_names (sc);
+ MHD_gnutls_certificate_free_keys (sc);
+ MHD_gnutls_certificate_free_cas (sc);
+ MHD_gnutls_certificate_free_ca_names (sc);
#ifdef ENABLE_PKI
- gnutls_certificate_free_crls (sc);
+ MHD_gnutls_certificate_free_crls (sc);
#endif
#ifndef KEYRING_HACK
@@ -204,8 +204,8 @@ gnutls_certificate_free_credentials (gnutls_certificate_credentials_t sc)
/**
- * gnutls_certificate_allocate_credentials - Used to allocate a gnutls_certificate_credentials_t structure
- * @res: is a pointer to an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_allocate_credentials - Used to allocate a mhd_gtls_cert_credentials_t structure
+ * @res: is a pointer to an #mhd_gtls_cert_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to allocate it.
@@ -213,7 +213,7 @@ gnutls_certificate_free_credentials (gnutls_certificate_credentials_t sc)
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_certificate_allocate_credentials (gnutls_certificate_credentials_t *
+MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
res)
{
*res = gnutls_calloc (1, sizeof (certificate_credentials_st));
@@ -235,7 +235,7 @@ gnutls_certificate_allocate_credentials (gnutls_certificate_credentials_t *
* extensions in order to disable unneded algorithms.
*/
int
-_gnutls_selected_cert_supported_kx (gnutls_session_t session,
+mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
gnutls_kx_algorithm_t ** alg,
int *alg_size)
{
@@ -257,7 +257,7 @@ _gnutls_selected_cert_supported_kx (gnutls_session_t session,
for (kx = 0; kx < MAX_ALGOS; kx++)
{
- pk = _gnutls_map_pk_get_pk (kx);
+ pk = mhd_gtls_map_pk_get_pk (kx);
if (pk == cert->subject_pk_algorithm)
{
/* then check key usage */
@@ -288,8 +288,8 @@ _gnutls_selected_cert_supported_kx (gnutls_session_t session,
/**
- * gnutls_certificate_server_set_request - Used to set whether to request a client certificate
- * @session: is an #gnutls_session_t structure.
+ * MHD_gtls_certificate_server_set_request - Used to set whether to request a client certificate
+ * @session: is an #mhd_gtls_session_t structure.
* @req: is one of GNUTLS_CERT_REQUEST, GNUTLS_CERT_REQUIRE
*
* This function specifies if we (in case of a server) are going
@@ -300,21 +300,21 @@ _gnutls_selected_cert_supported_kx (gnutls_session_t session,
* send a certificate.
**/
void
-gnutls_certificate_server_set_request (gnutls_session_t session,
+MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
gnutls_certificate_request_t req)
{
session->internals.send_cert_req = req;
}
/**
- * gnutls_certificate_client_set_retrieve_function - Used to set a callback to retrieve the certificate
- * @cred: is a #gnutls_certificate_credentials_t structure.
+ * MHD_gtls_certificate_client_set_retrieve_function - Used to set a callback to retrieve the certificate
+ * @cred: is a #mhd_gtls_cert_credentials_t structure.
* @func: is the callback function
*
* This function sets a callback to be called in order to retrieve the certificate
* to be used in the handshake.
* The callback's function prototype is:
- * int (*callback)(gnutls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs,
+ * int (*callback)(mhd_gtls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs,
* const gnutls_pk_algorithm_t* pk_algos, int pk_algos_length, gnutls_retr_st* st);
*
* @req_ca_cert is only used in X.509 certificates.
@@ -336,22 +336,22 @@ gnutls_certificate_server_set_request (gnutls_session_t session,
* should be set to zero. The value (-1) indicates error and the handshake
* will be terminated.
**/
-void gnutls_certificate_client_set_retrieve_function
- (gnutls_certificate_credentials_t cred,
+void MHD_gtls_certificate_client_set_retrieve_function
+ (mhd_gtls_cert_credentials_t cred,
gnutls_certificate_client_retrieve_function * func)
{
cred->client_get_cert_callback = func;
}
/**
- * gnutls_certificate_server_set_retrieve_function - Used to set a callback to retrieve the certificate
- * @cred: is a #gnutls_certificate_credentials_t structure.
+ * MHD_gtls_certificate_server_set_retrieve_function - Used to set a callback to retrieve the certificate
+ * @cred: is a #mhd_gtls_cert_credentials_t structure.
* @func: is the callback function
*
* This function sets a callback to be called in order to retrieve the certificate
* to be used in the handshake.
* The callback's function prototype is:
- * int (*callback)(gnutls_session_t, gnutls_retr_st* st);
+ * int (*callback)(mhd_gtls_session_t, gnutls_retr_st* st);
*
* @st should contain the certificates and private keys.
*
@@ -362,8 +362,8 @@ void gnutls_certificate_client_set_retrieve_function
* return 0 on success. The value (-1) indicates error and the handshake
* will be terminated.
**/
-void gnutls_certificate_server_set_retrieve_function
- (gnutls_certificate_credentials_t cred,
+void MHD_gtls_certificate_server_set_retrieve_function
+ (mhd_gtls_cert_credentials_t cred,
gnutls_certificate_server_retrieve_function * func)
{
cred->server_get_cert_callback = func;
@@ -446,21 +446,21 @@ _gnutls_x509_get_raw_crt_expiration_time (const gnutls_datum_t * cert)
*
-*/
int
-_gnutls_openpgp_crt_verify_peers (gnutls_session_t session,
+_gnutls_openpgp_crt_verify_peers (mhd_gtls_session_t session,
unsigned int *status)
{
cert_auth_info_t info;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
int peer_certificate_list_size, ret;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INVALID_REQUEST;
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -506,7 +506,7 @@ _gnutls_openpgp_crt_verify_peers (gnutls_session_t session,
/**
- * gnutls_certificate_verify_peers2 - This function returns the peer's certificate verification status
+ * MHD_gtls_certificate_verify_peers2 - This function returns the peer's certificate verification status
* @session: is a gnutls session
* @status: is the output of the verification
*
@@ -516,7 +516,7 @@ _gnutls_openpgp_crt_verify_peers (gnutls_session_t session,
* elements bitwise or'd. To avoid denial of service attacks some
* default upper limits regarding the certificate key size and chain
* size are set. To override them use
- * gnutls_certificate_set_verify_limits().
+ * MHD_gnutls_certificate_set_verify_limits().
*
* Note that you must also check the peer's name in order to check if
* the verified certificate belongs to the actual peer.
@@ -526,20 +526,20 @@ _gnutls_openpgp_crt_verify_peers (gnutls_session_t session,
*
* Note that some commonly used X.509 Certificate Authorities are
* still using Version 1 certificates. If you want to accept them,
- * you need to call gnutls_certificate_set_verify_flags() with, e.g.,
+ * you need to call MHD_gnutls_certificate_set_verify_flags() with, e.g.,
* %GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT parameter.
*
* Returns: a negative error code on error and zero on success.
**/
int
-gnutls_certificate_verify_peers2 (gnutls_session_t session,
+MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
unsigned int *status)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
return GNUTLS_E_NO_CERTIFICATE_FOUND;
@@ -560,7 +560,7 @@ gnutls_certificate_verify_peers2 (gnutls_session_t session,
}
/**
- * gnutls_certificate_verify_peers - This function returns the peer's certificate verification status
+ * MHD_gtls_certificate_verify_peers - This function returns the peer's certificate verification status
* @session: is a gnutls session
*
* This function will try to verify the peer's certificate and return
@@ -574,15 +574,15 @@ gnutls_certificate_verify_peers2 (gnutls_session_t session,
*
* This is the same as gnutls_x509_crt_list_verify().
*
- * Deprecated: Use gnutls_certificate_verify_peers2() instead.
+ * Deprecated: Use MHD_gtls_certificate_verify_peers2() instead.
**/
int
-gnutls_certificate_verify_peers (gnutls_session_t session)
+MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
{
unsigned int status;
int ret;
- ret = gnutls_certificate_verify_peers2 (session, &status);
+ ret = MHD_gtls_certificate_verify_peers2 (session, &status);
if (ret < 0)
{
@@ -594,7 +594,7 @@ gnutls_certificate_verify_peers (gnutls_session_t session)
}
/**
- * gnutls_certificate_expiration_time_peers - This function returns the peer's certificate expiration time
+ * MHD_gtls_certificate_expiration_time_peers - This function returns the peer's certificate expiration time
* @session: is a gnutls session
*
* This function will return the peer's certificate expiration time.
@@ -602,13 +602,13 @@ gnutls_certificate_verify_peers (gnutls_session_t session)
* Returns: (time_t)-1 on error.
**/
time_t
-gnutls_certificate_expiration_time_peers (gnutls_session_t session)
+MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
return (time_t) - 1;
@@ -638,7 +638,7 @@ gnutls_certificate_expiration_time_peers (gnutls_session_t session)
}
/**
- * gnutls_certificate_activation_time_peers - This function returns the peer's certificate activation time
+ * MHD_gtls_certificate_activation_time_peers - This function returns the peer's certificate activation time
* @session: is a gnutls session
*
* This function will return the peer's certificate activation time.
@@ -647,13 +647,13 @@ gnutls_certificate_expiration_time_peers (gnutls_session_t session)
* Returns: (time_t)-1 on error.
**/
time_t
-gnutls_certificate_activation_time_peers (gnutls_session_t session)
+MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
return (time_t) - 1;
@@ -683,7 +683,7 @@ gnutls_certificate_activation_time_peers (gnutls_session_t session)
}
int
-_gnutls_raw_cert_to_gcert (gnutls_cert * gcert,
+mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
gnutls_certificate_type_t type,
const gnutls_datum_t * raw_cert,
int flags /* OR of ConvFlags */ )
@@ -691,7 +691,7 @@ _gnutls_raw_cert_to_gcert (gnutls_cert * gcert,
switch (type)
{
case MHD_GNUTLS_CRT_X509:
- return _gnutls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
+ return mhd_gtls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
case MHD_GNUTLS_CRT_OPENPGP:
if (_E_gnutls_openpgp_raw_key_to_gcert == NULL)
{
@@ -706,7 +706,7 @@ _gnutls_raw_cert_to_gcert (gnutls_cert * gcert,
}
int
-_gnutls_raw_privkey_to_gkey (gnutls_privkey * key,
+mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
gnutls_certificate_type_t type,
const gnutls_datum_t * raw_key,
int key_enc /* DER or PEM */ )
@@ -741,7 +741,7 @@ _gnutls_raw_privkey_to_gkey (gnutls_privkey * key,
* The critical extensions will be catched by the verification functions.
*/
int
-_gnutls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
+mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
const gnutls_datum_t * derCert,
int flags /* OR of ConvFlags */ )
{
@@ -763,7 +763,7 @@ _gnutls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
return ret;
}
- ret = _gnutls_x509_crt_to_gcert (gcert, cert, flags);
+ ret = mhd_gtls_x509_crt_to_gcert (gcert, cert, flags);
gnutls_x509_crt_deinit (cert);
return ret;
@@ -772,7 +772,7 @@ _gnutls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
/* Like above but it accepts a parsed certificate instead.
*/
int
-_gnutls_x509_crt_to_gcert (gnutls_cert * gcert,
+mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
gnutls_x509_crt_t cert, unsigned int flags)
{
int ret = 0;
@@ -857,7 +857,7 @@ _gnutls_x509_crt_to_gcert (gnutls_cert * gcert,
}
void
-_gnutls_gcert_deinit (gnutls_cert * cert)
+mhd_gtls_gcert_deinit (gnutls_cert * cert)
{
int i;
@@ -866,21 +866,21 @@ _gnutls_gcert_deinit (gnutls_cert * cert)
for (i = 0; i < cert->params_size; i++)
{
- _gnutls_mpi_release (&cert->params[i]);
+ mhd_gtls_mpi_release (&cert->params[i]);
}
_gnutls_free_datum (&cert->raw);
}
/**
- * gnutls_sign_callback_set:
+ * MHD_gtls_sign_callback_set:
* @session: is a gnutls session
* @sign_func: function pointer to application's sign callback.
* @userdata: void pointer that will be passed to sign callback.
*
* Set the callback function. The function must have this prototype:
*
- * typedef int (*gnutls_sign_func) (gnutls_session_t session,
+ * typedef int (*gnutls_sign_func) (mhd_gtls_session_t session,
* void *userdata,
* gnutls_certificate_type_t cert_type,
* const gnutls_datum_t * cert,
@@ -889,10 +889,10 @@ _gnutls_gcert_deinit (gnutls_cert * cert)
*
* The @userdata parameter is passed to the @sign_func verbatim, and
* can be used to store application-specific data needed in the
- * callback function. See also gnutls_sign_callback_get().
+ * callback function. See also MHD_gtls_sign_callback_get().
**/
void
-gnutls_sign_callback_set (gnutls_session_t session,
+MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
gnutls_sign_func sign_func, void *userdata)
{
session->internals.sign_func = sign_func;
@@ -900,17 +900,17 @@ gnutls_sign_callback_set (gnutls_session_t session,
}
/**
- * gnutls_sign_callback_get:
+ * MHD_gtls_sign_callback_get:
* @session: is a gnutls session
* @userdata: if non-%NULL, will be set to abstract callback pointer.
*
* Retrieve the callback function, and its userdata pointer.
*
- * Returns: The function pointer set by gnutls_sign_callback_set(), or
+ * Returns: The function pointer set by MHD_gtls_sign_callback_set(), or
* if not set, %NULL.
**/
gnutls_sign_func
-gnutls_sign_callback_get (gnutls_session_t session, void **userdata)
+MHD_gtls_sign_callback_get (mhd_gtls_session_t session, void **userdata)
{
if (userdata)
*userdata = session->internals.sign_func_userdata;
diff --git a/src/daemon/https/tls/gnutls_cert.h b/src/daemon/https/tls/gnutls_cert.h
@@ -98,7 +98,7 @@ typedef struct gnutls_privkey_int
gnutls_pk_algorithm_t pk_algorithm;
} gnutls_privkey;
-struct gnutls_session_int; /* because gnutls_session_t is not defined when this file is included */
+struct MHD_gtls_session_int; /* because mhd_gtls_session_t is not defined when this file is included */
typedef enum ConvFlags
{
@@ -107,24 +107,24 @@ typedef enum ConvFlags
CERT_ONLY_EXTENSIONS = 16
} ConvFlags;
-int _gnutls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
+int mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
const gnutls_datum_t * derCert,
int flags);
-int _gnutls_x509_crt_to_gcert (gnutls_cert * gcert, gnutls_x509_crt_t cert,
+int mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert, gnutls_x509_crt_t cert,
unsigned int flags);
-void _gnutls_gkey_deinit (gnutls_privkey * key);
-void _gnutls_gcert_deinit (gnutls_cert * cert);
+void mhd_gtls_gkey_deinit (gnutls_privkey * key);
+void mhd_gtls_gcert_deinit (gnutls_cert * cert);
-int _gnutls_selected_cert_supported_kx (struct gnutls_session_int *session,
+int mhd_gtls_selected_cert_supported_kx (struct MHD_gtls_session_int *session,
gnutls_kx_algorithm_t ** alg,
int *alg_size);
-int _gnutls_raw_cert_to_gcert (gnutls_cert * gcert,
+int mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
gnutls_certificate_type_t type,
const gnutls_datum_t * raw_cert,
int flags /* OR of ConvFlags */ );
-int _gnutls_raw_privkey_to_gkey (gnutls_privkey * key,
+int mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
gnutls_certificate_type_t type,
const gnutls_datum_t * raw_key,
int key_enc /* DER or PEM */ );
diff --git a/src/daemon/https/tls/gnutls_cipher.c b/src/daemon/https/tls/gnutls_cipher.c
@@ -42,7 +42,7 @@
#include <gc.h>
inline static int
-is_write_comp_null (gnutls_session_t session)
+is_write_comp_null (mhd_gtls_session_t session)
{
if (session->security_parameters.write_compression_algorithm ==
MHD_GNUTLS_COMP_NULL)
@@ -52,7 +52,7 @@ is_write_comp_null (gnutls_session_t session)
}
inline static int
-is_read_comp_null (gnutls_session_t session)
+is_read_comp_null (mhd_gtls_session_t session)
{
if (session->security_parameters.read_compression_algorithm ==
MHD_GNUTLS_COMP_NULL)
@@ -68,7 +68,7 @@ is_read_comp_null (gnutls_session_t session)
* If random pad != 0 then the random pad data will be appended.
*/
int
-_gnutls_encrypt (gnutls_session_t session, const opaque * headers,
+mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type, int random_pad)
@@ -99,7 +99,7 @@ _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
}
}
- ret = _gnutls_compressed2ciphertext (session, &ciphertext[headers_size],
+ ret = mhd_gtls_compressed2ciphertext (session, &ciphertext[headers_size],
ciphertext_size - headers_size,
comp, type, random_pad);
@@ -115,7 +115,7 @@ _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
/* copy the headers */
memcpy (ciphertext, headers, headers_size);
- _gnutls_write_uint16 (ret, &ciphertext[3]);
+ mhd_gtls_write_uint16 (ret, &ciphertext[3]);
return ret + headers_size;
}
@@ -124,7 +124,7 @@ _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
* Returns the decrypted data length.
*/
int
-_gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
+mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
size_t ciphertext_size, uint8_t * data,
size_t max_data_size, content_type_t type)
{
@@ -139,7 +139,7 @@ _gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
gcipher.data = ciphertext;
ret =
- _gnutls_ciphertext2compressed (session, data, max_data_size,
+ mhd_gtls_ciphertext2compressed (session, data, max_data_size,
gcipher, type);
if (ret < 0)
{
@@ -204,11 +204,11 @@ mac_init (gnutls_mac_algorithm_t mac, opaque * secret, int secret_size,
if (ver == MHD_GNUTLS_SSL3)
{ /* SSL 3.0 */
- td = _gnutls_mac_init_ssl3 (mac, secret, secret_size);
+ td = mhd_gnutls_mac_init_ssl3 (mac, secret, secret_size);
}
else
{ /* TLS 1.x */
- td = _gnutls_hmac_init (mac, secret, secret_size);
+ td = mhd_gtls_hmac_init (mac, secret, secret_size);
}
return td;
@@ -219,16 +219,16 @@ mac_deinit (mac_hd_t td, opaque * res, int ver)
{
if (ver == MHD_GNUTLS_SSL3)
{ /* SSL 3.0 */
- _gnutls_mac_deinit_ssl3 (td, res);
+ mhd_gnutls_mac_deinit_ssl3 (td, res);
}
else
{
- _gnutls_hmac_deinit (td, res);
+ mhd_gnutls_hmac_deinit (td, res);
}
}
inline static int
-calc_enc_length (gnutls_session_t session, int data_size,
+calc_enc_length (mhd_gtls_session_t session, int data_size,
int hash_size, uint8_t * pad, int random_pad,
cipher_type_t block_algo, uint16_t blocksize)
{
@@ -289,7 +289,7 @@ calc_enc_length (gnutls_session_t session, int data_size,
* return the actual encrypted data length.
*/
int
-_gnutls_compressed2ciphertext (gnutls_session_t session,
+mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
opaque * cipher_data, int cipher_size,
gnutls_datum_t compressed,
content_type_t _type, int random_pad)
@@ -302,21 +302,21 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
uint8_t type = _type;
uint8_t major, minor;
int hash_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
+ mhd_gnutls_hash_get_algo_len (session->security_parameters.
write_mac_algorithm);
gnutls_protocol_t ver;
int blocksize =
- _gnutls_cipher_get_block_size (session->security_parameters.
+ mhd_gtls_cipher_get_block_size (session->security_parameters.
write_bulk_cipher_algorithm);
cipher_type_t block_algo =
- _gnutls_cipher_is_block (session->security_parameters.
+ mhd_gtls_cipher_is_block (session->security_parameters.
write_bulk_cipher_algorithm);
opaque *data_ptr;
- ver = gnutls_protocol_get_version (session);
- minor = _gnutls_version_get_minor (ver);
- major = _gnutls_version_get_major (ver);
+ ver = MHD_gnutls_protocol_get_version (session);
+ minor = mhd_gtls_version_get_minor (ver);
+ major = mhd_gtls_version_get_major (ver);
/* Initialize MAC */
@@ -332,22 +332,22 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
return GNUTLS_E_INTERNAL_ERROR;
}
- c_length = _gnutls_conv_uint16 (compressed.size);
+ c_length = mhd_gtls_conv_uint16 (compressed.size);
if (td != GNUTLS_MAC_FAILED)
{ /* actually when the algorithm in not the NULL one */
- _gnutls_hmac (td,
+ mhd_gnutls_hash (td,
UINT64DATA (session->connection_state.
write_sequence_number), 8);
- _gnutls_hmac (td, &type, 1);
+ mhd_gnutls_hash (td, &type, 1);
if (ver >= MHD_GNUTLS_TLS1_0)
{ /* TLS 1.0 or higher */
- _gnutls_hmac (td, &major, 1);
- _gnutls_hmac (td, &minor, 1);
+ mhd_gnutls_hash (td, &major, 1);
+ mhd_gnutls_hash (td, &minor, 1);
}
- _gnutls_hmac (td, &c_length, 2);
- _gnutls_hmac (td, compressed.data, compressed.size);
+ mhd_gnutls_hash (td, &c_length, 2);
+ mhd_gnutls_hash (td, compressed.data, compressed.size);
mac_deinit (td, MAC, ver);
}
@@ -401,7 +401,7 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
/* Actual encryption (inplace).
*/
- ret = _gnutls_cipher_encrypt (session->connection_state.
+ ret = mhd_gtls_cipher_encrypt (session->connection_state.
write_cipher_state, cipher_data, length);
if (ret < 0)
{
@@ -416,7 +416,7 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
* Returns the actual compressed packet size.
*/
int
-_gnutls_ciphertext2compressed (gnutls_session_t session,
+mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
opaque * compress_data,
int compress_size,
gnutls_datum_t ciphertext, uint8_t type)
@@ -431,14 +431,14 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
uint8_t major, minor;
gnutls_protocol_t ver;
int hash_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
+ mhd_gnutls_hash_get_algo_len (session->security_parameters.
read_mac_algorithm);
- ver = gnutls_protocol_get_version (session);
- minor = _gnutls_version_get_minor (ver);
- major = _gnutls_version_get_major (ver);
+ ver = MHD_gnutls_protocol_get_version (session);
+ minor = mhd_gtls_version_get_minor (ver);
+ major = mhd_gtls_version_get_major (ver);
- blocksize = _gnutls_cipher_get_block_size (session->security_parameters.
+ blocksize = mhd_gtls_cipher_get_block_size (session->security_parameters.
read_bulk_cipher_algorithm);
/* initialize MAC
@@ -458,11 +458,11 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
/* actual decryption (inplace)
*/
- switch (_gnutls_cipher_is_block
+ switch (mhd_gtls_cipher_is_block
(session->security_parameters.read_bulk_cipher_algorithm))
{
case CIPHER_STREAM:
- if ((ret = _gnutls_cipher_decrypt (session->connection_state.
+ if ((ret = mhd_gtls_cipher_decrypt (session->connection_state.
read_cipher_state,
ciphertext.data,
ciphertext.size)) < 0)
@@ -481,7 +481,7 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
return GNUTLS_E_DECRYPTION_FAILED;
}
- if ((ret = _gnutls_cipher_decrypt (session->connection_state.
+ if ((ret = mhd_gtls_cipher_decrypt (session->connection_state.
read_cipher_state,
ciphertext.data,
ciphertext.size)) < 0)
@@ -534,27 +534,27 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
if (length < 0)
length = 0;
- c_length = _gnutls_conv_uint16 ((uint16_t) length);
+ c_length = mhd_gtls_conv_uint16 ((uint16_t) length);
/* Pass the type, version, length and compressed through
* MAC.
*/
if (td != GNUTLS_MAC_FAILED)
{
- _gnutls_hmac (td,
+ mhd_gnutls_hash (td,
UINT64DATA (session->connection_state.
read_sequence_number), 8);
- _gnutls_hmac (td, &type, 1);
+ mhd_gnutls_hash (td, &type, 1);
if (ver >= MHD_GNUTLS_TLS1_0)
{ /* TLS 1.x */
- _gnutls_hmac (td, &major, 1);
- _gnutls_hmac (td, &minor, 1);
+ mhd_gnutls_hash (td, &major, 1);
+ mhd_gnutls_hash (td, &minor, 1);
}
- _gnutls_hmac (td, &c_length, 2);
+ mhd_gnutls_hash (td, &c_length, 2);
if (length > 0)
- _gnutls_hmac (td, ciphertext.data, length);
+ mhd_gnutls_hash (td, ciphertext.data, length);
mac_deinit (td, MAC, ver);
}
diff --git a/src/daemon/https/tls/gnutls_cipher.h b/src/daemon/https/tls/gnutls_cipher.h
@@ -22,20 +22,20 @@
*
*/
-int _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
+int mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type,
int random_pad);
-int _gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
+int mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
size_t ciphertext_size, uint8_t * data, size_t data_size,
content_type_t type);
-int _gnutls_compressed2ciphertext (gnutls_session_t session,
+int mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
opaque * cipher_data, int cipher_size,
gnutls_datum_t compressed,
content_type_t _type, int random_pad);
-int _gnutls_ciphertext2compressed (gnutls_session_t session,
+int mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
opaque * compress_data,
int compress_size,
gnutls_datum_t ciphertext, uint8_t type);
diff --git a/src/daemon/https/tls/gnutls_cipher_int.c b/src/daemon/https/tls/gnutls_cipher_int.c
@@ -28,7 +28,7 @@
#include <gnutls_datum.h>
cipher_hd_t
-_gnutls_cipher_init (gnutls_cipher_algorithm_t cipher,
+mhd_gtls_cipher_init (gnutls_cipher_algorithm_t cipher,
const gnutls_datum_t * key, const gnutls_datum_t * iv)
{
cipher_hd_t ret = NULL;
@@ -95,7 +95,7 @@ _gnutls_cipher_init (gnutls_cipher_algorithm_t cipher,
}
int
-_gnutls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
+mhd_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
{
if (handle != GNUTLS_CIPHER_FAILED)
{
@@ -109,7 +109,7 @@ _gnutls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
}
int
-_gnutls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
+mhd_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
int ciphertextlen)
{
if (handle != GNUTLS_CIPHER_FAILED)
@@ -124,7 +124,7 @@ _gnutls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
}
void
-_gnutls_cipher_deinit (cipher_hd_t handle)
+mhd_gnutls_cipher_deinit (cipher_hd_t handle)
{
if (handle != GNUTLS_CIPHER_FAILED)
{
diff --git a/src/daemon/https/tls/gnutls_cipher_int.h b/src/daemon/https/tls/gnutls_cipher_int.h
@@ -29,18 +29,18 @@
#define GNUTLS_CIPHER_FAILED NULL
// TODO gc_cipher_handle -> void * x3
-void * _gnutls_cipher_init(gnutls_cipher_algorithm_t cipher,
+void * mhd_gtls_cipher_init(gnutls_cipher_algorithm_t cipher,
const gnutls_datum_t * key,
const gnutls_datum_t * iv);
-int _gnutls_cipher_encrypt(void * handle,
+int mhd_gtls_cipher_encrypt(void * handle,
void *text,
int textlen);
-int _gnutls_cipher_decrypt(void * handle,
+int mhd_gtls_cipher_decrypt(void * handle,
void *ciphertext,
int ciphertextlen);
-void _gnutls_cipher_deinit(void * handle);
+void mhd_gnutls_cipher_deinit(void * handle);
#endif /* GNUTLS_CIPHER_INT */
diff --git a/src/daemon/https/tls/gnutls_compress.c b/src/daemon/https/tls/gnutls_compress.c
@@ -34,7 +34,7 @@
/* These functions allocate the return value internally
*/
int
-_gnutls_m_plaintext2compressed (gnutls_session_t session,
+_gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
gnutls_datum_t * compressed,
const gnutls_datum_t * plaintext)
{
@@ -42,7 +42,7 @@ _gnutls_m_plaintext2compressed (gnutls_session_t session,
opaque *data;
size =
- _gnutls_compress (session->connection_state.write_compression_state,
+ mhd_gtls_compress (session->connection_state.write_compression_state,
plaintext->data, plaintext->size, &data,
MAX_RECORD_SEND_SIZE + EXTRA_COMP_SIZE);
if (size < 0)
@@ -57,7 +57,7 @@ _gnutls_m_plaintext2compressed (gnutls_session_t session,
}
int
-_gnutls_m_compressed2plaintext (gnutls_session_t session,
+_gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
gnutls_datum_t * plain,
const gnutls_datum_t * compressed)
{
@@ -65,7 +65,7 @@ _gnutls_m_compressed2plaintext (gnutls_session_t session,
opaque *data;
size =
- _gnutls_decompress (session->connection_state.
+ mhd_gtls_decompress (session->connection_state.
read_compression_state, compressed->data,
compressed->size, &data, MAX_RECORD_RECV_SIZE);
if (size < 0)
diff --git a/src/daemon/https/tls/gnutls_compress.h b/src/daemon/https/tls/gnutls_compress.h
@@ -22,9 +22,9 @@
*
*/
-int _gnutls_m_plaintext2compressed (gnutls_session_t session,
+int _gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
gnutls_datum_t * compressed,
const gnutls_datum_t *plaintext);
-int _gnutls_m_compressed2plaintext (gnutls_session_t session,
+int _gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
gnutls_datum_t * plain,
const gnutls_datum_t* compressed);
diff --git a/src/daemon/https/tls/gnutls_compress_int.c b/src/daemon/https/tls/gnutls_compress_int.c
@@ -31,7 +31,7 @@
* decompress.
*/
comp_hd_t
-_gnutls_comp_init (gnutls_compression_method_t method, int d)
+mhd_gtls_comp_init (gnutls_compression_method_t method, int d)
{
comp_hd_t ret;
@@ -54,9 +54,9 @@ _gnutls_comp_init (gnutls_compression_method_t method, int d)
int comp_level;
z_stream *zhandle;
- window_bits = _gnutls_compression_get_wbits (method);
- mem_level = _gnutls_compression_get_mem_level (method);
- comp_level = _gnutls_compression_get_comp_level (method);
+ window_bits = mhd_gtls_compression_get_wbits (method);
+ mem_level = mhd_gtls_compression_get_mem_level (method);
+ comp_level = mhd_gtls_compression_get_comp_level (method);
ret->handle = gnutls_malloc (sizeof (z_stream));
if (ret->handle == NULL)
@@ -102,7 +102,7 @@ cleanup_ret:
* decompress.
*/
void
-_gnutls_comp_deinit (comp_hd_t handle, int d)
+mhd_gtls_comp_deinit (comp_hd_t handle, int d)
{
if (handle != NULL)
{
@@ -129,7 +129,7 @@ _gnutls_comp_deinit (comp_hd_t handle, int d)
*/
int
-_gnutls_compress (comp_hd_t handle, const opaque * plain,
+mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
size_t plain_size, opaque ** compressed,
size_t max_comp_size)
{
@@ -204,7 +204,7 @@ _gnutls_compress (comp_hd_t handle, const opaque * plain,
int
-_gnutls_decompress (comp_hd_t handle, opaque * compressed,
+mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
size_t compressed_size, opaque ** plain,
size_t max_record_size)
{
@@ -247,7 +247,7 @@ _gnutls_decompress (comp_hd_t handle, opaque * compressed,
do
{
out_size += 512;
- *plain = gnutls_realloc_fast (*plain, out_size);
+ *plain = mhd_gtls_realloc_fast (*plain, out_size);
if (*plain == NULL)
{
gnutls_assert ();
diff --git a/src/daemon/https/tls/gnutls_compress_int.h b/src/daemon/https/tls/gnutls_compress_int.h
@@ -37,13 +37,13 @@ typedef struct comp_hd_t_STRUCT
gnutls_compression_method_t algo;
} *comp_hd_t;
-comp_hd_t _gnutls_comp_init (gnutls_compression_method_t, int d);
-void _gnutls_comp_deinit (comp_hd_t handle, int d);
+comp_hd_t mhd_gtls_comp_init (gnutls_compression_method_t, int d);
+void mhd_gtls_comp_deinit (comp_hd_t handle, int d);
-int _gnutls_decompress (comp_hd_t handle, opaque * compressed,
+int mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
size_t compressed_size, opaque ** plain,
size_t max_record_size);
-int _gnutls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
+int mhd_gtls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
opaque ** compressed, size_t max_comp_size);
#endif
diff --git a/src/daemon/https/tls/gnutls_constate.c b/src/daemon/https/tls/gnutls_constate.c
@@ -55,7 +55,7 @@ static const int servwrite_length = sizeof (servwrite) - 1;
* (session->cipher_specs)
*/
int
-_gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
+_gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
int key_size, int export_flag)
{
@@ -99,7 +99,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_SSL3)
{ /* SSL 3 */
ret =
- _gnutls_ssl3_generate_random (session->
+ mhd_gnutls_ssl3_generate_random (session->
security_parameters.
master_secret,
TLS_MASTER_SIZE, rnd,
@@ -109,7 +109,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
else
{ /* TLS 1.0 */
ret =
- _gnutls_PRF (session, session->security_parameters.master_secret,
+ mhd_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, keyexp, keyexp_length,
rnd, 2 * TLS_RANDOM_SIZE, block_size, key_block);
}
@@ -122,7 +122,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
}
_gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
- _gnutls_bin2hex (key_block, block_size, buf,
+ mhd_gtls_bin2hex (key_block, block_size, buf,
sizeof (buf)));
pos = 0;
@@ -192,7 +192,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_SSL3)
{ /* SSL 3 */
ret =
- _gnutls_ssl3_hash_md5 (&key_block[pos],
+ mhd_gnutls_ssl3_hash_md5 (&key_block[pos],
key_size, rrnd,
2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE,
@@ -202,7 +202,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
else
{ /* TLS 1.0 */
ret =
- _gnutls_PRF (session, &key_block[pos], key_size,
+ mhd_gtls_PRF (session, &key_block[pos], key_size,
cliwrite, cliwrite_length,
rrnd,
2 * TLS_RANDOM_SIZE,
@@ -224,7 +224,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_SSL3)
{ /* SSL 3 */
ret =
- _gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
+ mhd_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
rnd, 2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE,
server_write_key);
@@ -232,7 +232,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
else
{ /* TLS 1.0 */
ret =
- _gnutls_PRF (session, &key_block[pos], key_size,
+ mhd_gtls_PRF (session, &key_block[pos], key_size,
servwrite, servwrite_length,
rrnd, 2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE, server_write_key);
@@ -262,7 +262,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
}
_gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
client_write_key_size,
- _gnutls_bin2hex (client_write_key,
+ mhd_gtls_bin2hex (client_write_key,
client_write_key_size, buf,
sizeof (buf)));
@@ -278,7 +278,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
_gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
server_write_key_size,
- _gnutls_bin2hex (server_write_key,
+ mhd_gtls_bin2hex (server_write_key,
server_write_key_size, buf,
sizeof (buf)));
@@ -325,7 +325,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_SSL3)
{ /* SSL 3 */
- ret = _gnutls_ssl3_hash_md5 ("", 0,
+ ret = mhd_gnutls_ssl3_hash_md5 ("", 0,
rrnd, TLS_RANDOM_SIZE * 2,
IV_size, iv_block);
@@ -337,14 +337,14 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
return ret;
}
- ret = _gnutls_ssl3_hash_md5 ("", 0, rnd,
+ ret = mhd_gnutls_ssl3_hash_md5 ("", 0, rnd,
TLS_RANDOM_SIZE * 2,
IV_size, &iv_block[IV_size]);
}
else
{ /* TLS 1.0 */
- ret = _gnutls_PRF (session, "", 0,
+ ret = mhd_gtls_PRF (session, "", 0,
ivblock, ivblock_length, rrnd,
2 * TLS_RANDOM_SIZE, IV_size * 2, iv_block);
}
@@ -385,7 +385,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
}
int
-_gnutls_set_read_keys (gnutls_session_t session)
+_gnutls_set_read_keys (mhd_gtls_session_t session)
{
int hash_size;
int IV_size;
@@ -396,17 +396,17 @@ _gnutls_set_read_keys (gnutls_session_t session)
mac_algo = session->security_parameters.read_mac_algorithm;
algo = session->security_parameters.read_bulk_cipher_algorithm;
- hash_size = _gnutls_hash_get_algo_len (mac_algo);
- IV_size = _gnutls_cipher_get_iv_size (algo);
- key_size = gnutls_cipher_get_key_size (algo);
- export_flag = _gnutls_cipher_get_export_flag (algo);
+ hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
+ IV_size = mhd_gtls_cipher_get_iv_size (algo);
+ key_size = MHD_gnutls_cipher_get_key_size (algo);
+ export_flag = mhd_gtls_cipher_get_export_flag (algo);
return _gnutls_set_keys (session, hash_size, IV_size, key_size,
export_flag);
}
int
-_gnutls_set_write_keys (gnutls_session_t session)
+_gnutls_set_write_keys (mhd_gtls_session_t session)
{
int hash_size;
int IV_size;
@@ -417,10 +417,10 @@ _gnutls_set_write_keys (gnutls_session_t session)
mac_algo = session->security_parameters.write_mac_algorithm;
algo = session->security_parameters.write_bulk_cipher_algorithm;
- hash_size = _gnutls_hash_get_algo_len (mac_algo);
- IV_size = _gnutls_cipher_get_iv_size (algo);
- key_size = gnutls_cipher_get_key_size (algo);
- export_flag = _gnutls_cipher_get_export_flag (algo);
+ hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
+ IV_size = mhd_gtls_cipher_get_iv_size (algo);
+ key_size = MHD_gnutls_cipher_get_key_size (algo);
+ export_flag = mhd_gtls_cipher_get_export_flag (algo);
return _gnutls_set_keys (session, hash_size, IV_size, key_size,
export_flag);
@@ -439,12 +439,12 @@ _gnutls_set_write_keys (gnutls_session_t session)
dst->max_record_recv_size = src->max_record_recv_size; \
dst->max_record_send_size = src->max_record_send_size; \
dst->version = src->version; \
- memcpy( &dst->extensions, &src->extensions, sizeof(tls_ext_st)); \
+ memcpy( &dst->extensions, &src->extensions, sizeof(mhd_gtls_ext_st)); \
memcpy( &dst->inner_secret, &src->inner_secret, TLS_MASTER_SIZE);
static void
-_gnutls_cpy_read_security_parameters (security_parameters_st *
- dst, security_parameters_st * src)
+_gnutls_cpy_read_security_parameters (mhd_gtls_security_param_st *
+ dst, mhd_gtls_security_param_st * src)
{
CPY_COMMON;
@@ -454,8 +454,8 @@ _gnutls_cpy_read_security_parameters (security_parameters_st *
}
static void
-_gnutls_cpy_write_security_parameters (security_parameters_st *
- dst, security_parameters_st * src)
+_gnutls_cpy_write_security_parameters (mhd_gtls_security_param_st *
+ dst, mhd_gtls_security_param_st * src)
{
CPY_COMMON;
@@ -471,13 +471,13 @@ _gnutls_cpy_write_security_parameters (security_parameters_st *
* This is to be called after sending the Change Cipher Spec packet.
*/
int
-_gnutls_connection_state_init (gnutls_session_t session)
+mhd_gtls_connection_state_init (mhd_gtls_session_t session)
{
int ret;
/* Setup the master secret
*/
- if ((ret = _gnutls_generate_master (session, 0), 0) < 0)
+ if ((ret = mhd_gtls_generate_master (session, 0), 0) < 0)
{
gnutls_assert ();
return ret;
@@ -492,7 +492,7 @@ _gnutls_connection_state_init (gnutls_session_t session)
* (read encrypted data)
*/
int
-_gnutls_read_connection_state_init (gnutls_session_t session)
+mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
{
int mac_size;
int rc;
@@ -504,27 +504,27 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
*/
if (session->internals.resumed == RESUME_FALSE)
{
- rc = _gnutls_set_read_cipher (session,
- _gnutls_cipher_suite_get_cipher_algo
+ rc = mhd_gtls_set_read_cipher (session,
+ mhd_gtls_cipher_suite_get_cipher_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_read_mac (session,
- _gnutls_cipher_suite_get_mac_algo
+ rc = mhd_gtls_set_read_mac (session,
+ mhd_gtls_cipher_suite_get_mac_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_kx (session,
- _gnutls_cipher_suite_get_kx_algo
+ rc = mhd_gtls_set_kx (session,
+ mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_read_compression (session,
+ rc = mhd_gtls_set_read_compression (session,
session->internals.
compression_method);
if (rc < 0)
@@ -545,18 +545,18 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
return rc;
_gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
- session, _gnutls_cipher_suite_get_name (&session->
+ session, mhd_gtls_cipher_suite_get_name (&session->
security_parameters.
current_cipher_suite));
- if (_gnutls_compression_is_ok
+ if (mhd_gtls_compression_is_ok
(session->security_parameters.read_compression_algorithm) != 0)
{
gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
- if (_gnutls_mac_is_ok
+ if (mhd_gnutls_mac_is_ok
(session->security_parameters.read_mac_algorithm) != 0)
{
gnutls_assert ();
@@ -569,14 +569,14 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
_gnutls_free_datum (&session->connection_state.read_mac_secret);
if (session->connection_state.read_cipher_state != NULL)
- _gnutls_cipher_deinit (session->connection_state.read_cipher_state);
+ mhd_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
if (session->connection_state.read_compression_state != NULL)
- _gnutls_comp_deinit (session->connection_state.read_compression_state, 1);
+ mhd_gtls_comp_deinit (session->connection_state.read_compression_state, 1);
mac_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
+ mhd_gnutls_hash_get_algo_len (session->security_parameters.
read_mac_algorithm);
_gnutls_handshake_log
@@ -588,7 +588,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
/* initialize cipher session
*/
session->connection_state.read_cipher_state =
- _gnutls_cipher_init (session->security_parameters.
+ mhd_gtls_cipher_init (session->security_parameters.
read_bulk_cipher_algorithm,
&session->cipher_specs.
client_write_key,
@@ -624,7 +624,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
case GNUTLS_CLIENT:
session->connection_state.read_cipher_state =
- _gnutls_cipher_init (session->security_parameters.
+ mhd_gtls_cipher_init (session->security_parameters.
read_bulk_cipher_algorithm,
&session->cipher_specs.
server_write_key,
@@ -664,7 +664,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
}
session->connection_state.read_compression_state =
- _gnutls_comp_init (session->security_parameters.
+ mhd_gtls_comp_init (session->security_parameters.
read_compression_algorithm, 1);
if (session->connection_state.read_compression_state == GNUTLS_COMP_FAILED)
@@ -682,7 +682,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
* (write encrypted data)
*/
int
-_gnutls_write_connection_state_init (gnutls_session_t session)
+mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
{
int mac_size;
int rc;
@@ -694,27 +694,27 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
*/
if (session->internals.resumed == RESUME_FALSE)
{
- rc = _gnutls_set_write_cipher (session,
- _gnutls_cipher_suite_get_cipher_algo
+ rc = mhd_gtls_set_write_cipher (session,
+ mhd_gtls_cipher_suite_get_cipher_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_write_mac (session,
- _gnutls_cipher_suite_get_mac_algo
+ rc = mhd_gtls_set_write_mac (session,
+ mhd_gtls_cipher_suite_get_mac_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_kx (session,
- _gnutls_cipher_suite_get_kx_algo
+ rc = mhd_gtls_set_kx (session,
+ mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
- rc = _gnutls_set_write_compression (session,
+ rc = mhd_gtls_set_write_compression (session,
session->internals.
compression_method);
if (rc < 0)
@@ -734,18 +734,18 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
return rc;
_gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
- _gnutls_cipher_suite_get_name (&session->
+ mhd_gtls_cipher_suite_get_name (&session->
security_parameters.
current_cipher_suite));
- if (_gnutls_compression_is_ok
+ if (mhd_gtls_compression_is_ok
(session->security_parameters.write_compression_algorithm) != 0)
{
gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
- if (_gnutls_mac_is_ok
+ if (mhd_gnutls_mac_is_ok
(session->security_parameters.write_mac_algorithm) != 0)
{
gnutls_assert ();
@@ -760,14 +760,14 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
_gnutls_free_datum (&session->connection_state.write_mac_secret);
if (session->connection_state.write_cipher_state != NULL)
- _gnutls_cipher_deinit (session->connection_state.write_cipher_state);
+ mhd_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
if (session->connection_state.write_compression_state != NULL)
- _gnutls_comp_deinit (session->connection_state.
+ mhd_gtls_comp_deinit (session->connection_state.
write_compression_state, 0);
mac_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
+ mhd_gnutls_hash_get_algo_len (session->security_parameters.
write_mac_algorithm);
_gnutls_handshake_log
@@ -779,7 +779,7 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
/* initialize cipher session
*/
session->connection_state.write_cipher_state =
- _gnutls_cipher_init (session->security_parameters.
+ mhd_gtls_cipher_init (session->security_parameters.
write_bulk_cipher_algorithm,
&session->cipher_specs.
server_write_key,
@@ -818,7 +818,7 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
case GNUTLS_CLIENT:
session->connection_state.write_cipher_state =
- _gnutls_cipher_init (session->security_parameters.
+ mhd_gtls_cipher_init (session->security_parameters.
write_bulk_cipher_algorithm,
&session->cipher_specs.
client_write_key,
@@ -858,7 +858,7 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
session->connection_state.write_compression_state =
- _gnutls_comp_init (session->security_parameters.
+ mhd_gtls_comp_init (session->security_parameters.
write_compression_algorithm, 0);
if (session->connection_state.write_compression_state == GNUTLS_COMP_FAILED)
@@ -873,13 +873,13 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
/* Sets the specified cipher into the pending session
*/
int
-_gnutls_set_read_cipher (gnutls_session_t session,
+mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algo)
{
- if (_gnutls_cipher_is_ok (algo) == 0)
+ if (mhd_gtls_cipher_is_ok (algo) == 0)
{
- if (_gnutls_cipher_priority (session, algo) < 0)
+ if (mhd_gtls_cipher_priority (session, algo) < 0)
{
gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
@@ -899,13 +899,13 @@ _gnutls_set_read_cipher (gnutls_session_t session,
}
int
-_gnutls_set_write_cipher (gnutls_session_t session,
+mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algo)
{
- if (_gnutls_cipher_is_ok (algo) == 0)
+ if (mhd_gtls_cipher_is_ok (algo) == 0)
{
- if (_gnutls_cipher_priority (session, algo) < 0)
+ if (mhd_gtls_cipher_priority (session, algo) < 0)
{
gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
@@ -928,11 +928,11 @@ _gnutls_set_write_cipher (gnutls_session_t session,
/* Sets the specified algorithm into pending compression session
*/
int
-_gnutls_set_read_compression (gnutls_session_t session,
+mhd_gtls_set_read_compression (mhd_gtls_session_t session,
gnutls_compression_method_t algo)
{
- if (_gnutls_compression_is_ok (algo) == 0)
+ if (mhd_gtls_compression_is_ok (algo) == 0)
{
session->security_parameters.read_compression_algorithm = algo;
}
@@ -946,11 +946,11 @@ _gnutls_set_read_compression (gnutls_session_t session,
}
int
-_gnutls_set_write_compression (gnutls_session_t session,
+mhd_gtls_set_write_compression (mhd_gtls_session_t session,
gnutls_compression_method_t algo)
{
- if (_gnutls_compression_is_ok (algo) == 0)
+ if (mhd_gtls_compression_is_ok (algo) == 0)
{
session->security_parameters.write_compression_algorithm = algo;
}
@@ -966,10 +966,10 @@ _gnutls_set_write_compression (gnutls_session_t session,
/* Sets the specified kx algorithm into pending session
*/
int
-_gnutls_set_kx (gnutls_session_t session, gnutls_kx_algorithm_t algo)
+mhd_gtls_set_kx (mhd_gtls_session_t session, gnutls_kx_algorithm_t algo)
{
- if (_gnutls_kx_is_ok (algo) == 0)
+ if (mhd_gtls_kx_is_ok (algo) == 0)
{
session->security_parameters.kx_algorithm = algo;
}
@@ -978,7 +978,7 @@ _gnutls_set_kx (gnutls_session_t session, gnutls_kx_algorithm_t algo)
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- if (_gnutls_kx_priority (session, algo) < 0)
+ if (mhd_gtls_kx_priority (session, algo) < 0)
{
gnutls_assert ();
/* we shouldn't get here */
@@ -991,10 +991,10 @@ _gnutls_set_kx (gnutls_session_t session, gnutls_kx_algorithm_t algo)
/* Sets the specified mac algorithm into pending session */
int
-_gnutls_set_read_mac (gnutls_session_t session, gnutls_mac_algorithm_t algo)
+mhd_gtls_set_read_mac (mhd_gtls_session_t session, gnutls_mac_algorithm_t algo)
{
- if (_gnutls_mac_is_ok (algo) == 0)
+ if (mhd_gnutls_mac_is_ok (algo) == 0)
{
session->security_parameters.read_mac_algorithm = algo;
}
@@ -1003,7 +1003,7 @@ _gnutls_set_read_mac (gnutls_session_t session, gnutls_mac_algorithm_t algo)
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- if (_gnutls_mac_priority (session, algo) < 0)
+ if (mhd_gtls_mac_priority (session, algo) < 0)
{
gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
@@ -1015,10 +1015,10 @@ _gnutls_set_read_mac (gnutls_session_t session, gnutls_mac_algorithm_t algo)
}
int
-_gnutls_set_write_mac (gnutls_session_t session, gnutls_mac_algorithm_t algo)
+mhd_gtls_set_write_mac (mhd_gtls_session_t session, gnutls_mac_algorithm_t algo)
{
- if (_gnutls_mac_is_ok (algo) == 0)
+ if (mhd_gnutls_mac_is_ok (algo) == 0)
{
session->security_parameters.write_mac_algorithm = algo;
}
@@ -1027,7 +1027,7 @@ _gnutls_set_write_mac (gnutls_session_t session, gnutls_mac_algorithm_t algo)
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- if (_gnutls_mac_priority (session, algo) < 0)
+ if (mhd_gtls_mac_priority (session, algo) < 0)
{
gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
diff --git a/src/daemon/https/tls/gnutls_constate.h b/src/daemon/https/tls/gnutls_constate.h
@@ -22,19 +22,19 @@
*
*/
-int _gnutls_connection_state_init (gnutls_session_t session);
-int _gnutls_read_connection_state_init (gnutls_session_t session);
-int _gnutls_write_connection_state_init (gnutls_session_t session);
-int _gnutls_set_write_cipher (gnutls_session_t session,
+int mhd_gtls_connection_state_init (mhd_gtls_session_t session);
+int mhd_gtls_read_connection_state_init (mhd_gtls_session_t session);
+int mhd_gtls_write_connection_state_init (mhd_gtls_session_t session);
+int mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algo);
-int _gnutls_set_write_mac (gnutls_session_t session,
+int mhd_gtls_set_write_mac (mhd_gtls_session_t session,
gnutls_mac_algorithm_t algo);
-int _gnutls_set_read_cipher (gnutls_session_t session,
+int mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
gnutls_cipher_algorithm_t algo);
-int _gnutls_set_read_mac (gnutls_session_t session,
+int mhd_gtls_set_read_mac (mhd_gtls_session_t session,
gnutls_mac_algorithm_t algo);
-int _gnutls_set_read_compression (gnutls_session_t session,
+int mhd_gtls_set_read_compression (mhd_gtls_session_t session,
gnutls_compression_method_t algo);
-int _gnutls_set_write_compression (gnutls_session_t session,
+int mhd_gtls_set_write_compression (mhd_gtls_session_t session,
gnutls_compression_method_t algo);
-int _gnutls_set_kx (gnutls_session_t session, gnutls_kx_algorithm_t algo);
+int mhd_gtls_set_kx (mhd_gtls_session_t session, gnutls_kx_algorithm_t algo);
diff --git a/src/daemon/https/tls/gnutls_datum.c b/src/daemon/https/tls/gnutls_datum.c
@@ -34,31 +34,31 @@
void
-_gnutls_write_datum16 (opaque * dest, gnutls_datum_t dat)
+mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat)
{
- _gnutls_write_uint16 (dat.size, dest);
+ mhd_gtls_write_uint16 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[2], dat.data, dat.size);
}
void
-_gnutls_write_datum24 (opaque * dest, gnutls_datum_t dat)
+mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat)
{
- _gnutls_write_uint24 (dat.size, dest);
+ mhd_gtls_write_uint24 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[3], dat.data, dat.size);
}
void
-_gnutls_write_datum32 (opaque * dest, gnutls_datum_t dat)
+mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat)
{
- _gnutls_write_uint32 (dat.size, dest);
+ mhd_gtls_write_uint32 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[4], dat.data, dat.size);
}
void
-_gnutls_write_datum8 (opaque * dest, gnutls_datum_t dat)
+mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat)
{
dest[0] = (uint8_t) dat.size;
if (dat.data != NULL)
@@ -67,7 +67,7 @@ _gnutls_write_datum8 (opaque * dest, gnutls_datum_t dat)
int
-_gnutls_set_datum_m (gnutls_datum_t * dat, const void *data,
+mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_alloc_function galloc_func)
{
if (data_size == 0 || data == NULL)
@@ -88,7 +88,7 @@ _gnutls_set_datum_m (gnutls_datum_t * dat, const void *data,
}
int
-_gnutls_datum_append_m (gnutls_datum_t * dst, const void *data,
+mhd_gtls_datum_append_m (gnutls_datum_t * dst, const void *data,
size_t data_size,
gnutls_realloc_function grealloc_func)
{
@@ -104,7 +104,7 @@ _gnutls_datum_append_m (gnutls_datum_t * dst, const void *data,
}
void
-_gnutls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function gfree_func)
+mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function gfree_func)
{
if (dat->data != NULL)
gfree_func (dat->data);
diff --git a/src/daemon/https/tls/gnutls_datum.h b/src/daemon/https/tls/gnutls_datum.h
@@ -22,19 +22,19 @@
*
*/
-void _gnutls_write_datum16 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum24 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum32 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum8 (opaque * dest, gnutls_datum_t dat);
+void mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat);
+void mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat);
+void mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat);
+void mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat);
-int _gnutls_set_datum_m (gnutls_datum_t * dat, const void *data,
+int mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_alloc_function);
-#define _gnutls_set_datum( x, y, z) _gnutls_set_datum_m(x,y,z, gnutls_malloc)
-#define _gnutls_sset_datum( x, y, z) _gnutls_set_datum_m(x,y,z, gnutls_secure_malloc)
+#define _gnutls_set_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_malloc)
+#define _gnutls_sset_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_secure_malloc)
-int _gnutls_datum_append_m (gnutls_datum_t * dat, const void *data,
+int mhd_gtls_datum_append_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_realloc_function);
-#define _gnutls_datum_append(x,y,z) _gnutls_datum_append_m(x,y,z, gnutls_realloc)
+#define _gnutls_datum_append(x,y,z) mhd_gtls_datum_append_m(x,y,z, gnutls_realloc)
-void _gnutls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function);
-#define _gnutls_free_datum(x) _gnutls_free_datum_m(x, gnutls_free)
+void mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function);
+#define _gnutls_free_datum(x) mhd_gtls_free_datum_m(x, gnutls_free)
diff --git a/src/daemon/https/tls/gnutls_dh.c b/src/daemon/https/tls/gnutls_dh.c
@@ -35,11 +35,11 @@
his_key = X ^ y mod p;
// generate our secret and the public value (X) for it
- X = gnutls_calc_dh_secret(&x, g, p);
+ X = mhd_gtls_calc_dh_secret(&x, g, p);
// now we can calculate the shared secret
- key = gnutls_calc_dh_key(Y, x, g, p);
- _gnutls_mpi_release(x);
- _gnutls_mpi_release(g);
+ key = mhd_gtls_calc_dh_key(Y, x, g, p);
+ mhd_gtls_mpi_release(x);
+ mhd_gtls_mpi_release(g);
*/
#define MAX_BITS 18000
@@ -47,7 +47,7 @@
/* returns the public value (X), and the secret (ret_x).
*/
mpi_t
-gnutls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
+mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
{
mpi_t e, x;
int x_size = _gnutls_mpi_get_nbits (prime) - 1;
@@ -89,7 +89,7 @@ gnutls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
if (ret_x)
*ret_x = NULL;
- _gnutls_mpi_release (&x);
+ mhd_gtls_mpi_release (&x);
return NULL;
}
@@ -98,13 +98,13 @@ gnutls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
if (ret_x)
*ret_x = x;
else
- _gnutls_mpi_release (&x);
+ mhd_gtls_mpi_release (&x);
return e;
}
mpi_t
-gnutls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
+mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
{
mpi_t k;
int bits;
@@ -124,7 +124,7 @@ gnutls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
}
/*-
- * _gnutls_get_dh_params - Returns the DH parameters pointer
+ * mhd_gtls_get_dh_params - Returns the DH parameters pointer
* @dh_params: is an DH parameters structure, or NULL.
* @func: is a callback function to receive the parameters or NULL.
* @session: a gnutls session.
@@ -132,10 +132,10 @@ gnutls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
* This function will return the dh parameters pointer.
*
-*/
-gnutls_dh_params_t
-_gnutls_get_dh_params (gnutls_dh_params_t dh_params,
+mhd_gtls_dh_params_t
+mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
gnutls_params_function * func,
- gnutls_session_t session)
+ mhd_gtls_session_t session)
{
gnutls_params_st params;
int ret;
diff --git a/src/daemon/https/tls/gnutls_dh.h b/src/daemon/https/tls/gnutls_dh.h
@@ -25,14 +25,14 @@
#ifndef GNUTLS_DH_H
# define GNUTLS_DH_H
-const mpi_t *_gnutls_dh_params_to_mpi (gnutls_dh_params_t);
-mpi_t gnutls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
-mpi_t gnutls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
-int _gnutls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
+const mpi_t * mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t);
+mpi_t mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
+mpi_t mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
+int mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
-gnutls_dh_params_t
-_gnutls_get_dh_params (gnutls_dh_params_t dh_params,
+mhd_gtls_dh_params_t
+mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
gnutls_params_function * func,
- gnutls_session_t session);
+ mhd_gtls_session_t session);
#endif
diff --git a/src/daemon/https/tls/gnutls_dh_primes.c b/src/daemon/https/tls/gnutls_dh_primes.c
@@ -36,7 +36,7 @@
/* returns the prime and the generator of DH params.
*/
const mpi_t *
-_gnutls_dh_params_to_mpi (gnutls_dh_params_t dh_primes)
+mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t dh_primes)
{
if (dh_primes == NULL || dh_primes->params[1] == NULL
|| dh_primes->params[0] == NULL)
@@ -48,7 +48,7 @@ _gnutls_dh_params_to_mpi (gnutls_dh_params_t dh_primes)
}
int
-_gnutls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
+mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
{
mpi_t g = NULL, prime = NULL;
gcry_error_t err;
@@ -75,7 +75,7 @@ _gnutls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (times)
{
- _gnutls_mpi_release (&prime);
+ mhd_gtls_mpi_release (&prime);
gcry_prime_release_factors (factors);
}
@@ -119,17 +119,17 @@ _gnutls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (ret_g)
*ret_g = g;
else
- _gnutls_mpi_release (&g);
+ mhd_gtls_mpi_release (&g);
if (ret_n)
*ret_n = prime;
else
- _gnutls_mpi_release (&prime);
+ mhd_gtls_mpi_release (&prime);
return 0;
cleanup:gcry_prime_release_factors (factors);
- _gnutls_mpi_release (&g);
- _gnutls_mpi_release (&prime);
+ mhd_gtls_mpi_release (&g);
+ mhd_gtls_mpi_release (&prime);
return result;
@@ -139,60 +139,17 @@ cleanup:gcry_prime_release_factors (factors);
* generated one.
*/
/**
- * gnutls_dh_params_import_raw - This function will import DH parameters
- * @dh_params: Is a structure that will hold the prime numbers
- * @prime: holds the new prime
- * @generator: holds the new generator
- *
- * This function will replace the pair of prime and generator for use in
- * the Diffie-Hellman key exchange. The new parameters should be stored in the
- * appropriate gnutls_datum.
- *
- **/
-int
-gnutls_dh_params_import_raw (gnutls_dh_params_t dh_params,
- const gnutls_datum_t * prime,
- const gnutls_datum_t * generator)
-{
- mpi_t tmp_prime, tmp_g;
- size_t siz;
-
- siz = prime->size;
- if (_gnutls_mpi_scan_nz (&tmp_prime, prime->data, &siz))
- {
- gnutls_assert ();
- return GNUTLS_E_MPI_SCAN_FAILED;
- }
-
- siz = generator->size;
- if (_gnutls_mpi_scan_nz (&tmp_g, generator->data, &siz))
- {
- _gnutls_mpi_release (&tmp_prime);
- gnutls_assert ();
- return GNUTLS_E_MPI_SCAN_FAILED;
- }
-
- /* store the generated values
- */
- dh_params->params[0] = tmp_prime;
- dh_params->params[1] = tmp_g;
-
- return 0;
-
-}
-
-/**
- * gnutls_dh_params_init - This function will initialize the DH parameters
+ * MHD_gnutls_dh_params_init - This function will initialize the DH parameters
* @dh_params: Is a structure that will hold the prime numbers
*
* This function will initialize the DH parameters structure.
*
**/
int
-gnutls_dh_params_init (gnutls_dh_params_t * dh_params)
+MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params)
{
- (*dh_params) = gnutls_calloc (1, sizeof (dh_params_st));
+ (*dh_params) = gnutls_calloc (1, sizeof (mhd_gtls_dh_params_st));
if (*dh_params == NULL)
{
gnutls_assert ();
@@ -204,59 +161,35 @@ gnutls_dh_params_init (gnutls_dh_params_t * dh_params)
}
/**
- * gnutls_dh_params_deinit - This function will deinitialize the DH parameters
+ * MHD_gnutls_dh_params_deinit - This function will deinitialize the DH parameters
* @dh_params: Is a structure that holds the prime numbers
*
* This function will deinitialize the DH parameters structure.
*
**/
void
-gnutls_dh_params_deinit (gnutls_dh_params_t dh_params)
+MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params)
{
if (dh_params == NULL)
return;
- _gnutls_mpi_release (&dh_params->params[0]);
- _gnutls_mpi_release (&dh_params->params[1]);
+ mhd_gtls_mpi_release (&dh_params->params[0]);
+ mhd_gtls_mpi_release (&dh_params->params[1]);
gnutls_free (dh_params);
}
/**
- * gnutls_dh_params_cpy - This function will copy a DH parameters structure
- * @dst: Is the destination structure, which should be initialized.
- * @src: Is the source structure
- *
- * This function will copy the DH parameters structure from source
- * to destination.
- *
- **/
-int
-gnutls_dh_params_cpy (gnutls_dh_params_t dst, gnutls_dh_params_t src)
-{
- if (src == NULL)
- return GNUTLS_E_INVALID_REQUEST;
-
- dst->params[0] = _gnutls_mpi_copy (src->params[0]);
- dst->params[1] = _gnutls_mpi_copy (src->params[1]);
-
- if (dst->params[0] == NULL || dst->params[1] == NULL)
- return GNUTLS_E_MEMORY_ERROR;
-
- return 0;
-}
-
-/**
- * gnutls_dh_params_generate2 - This function will generate new DH parameters
+ * MHD_gnutls_dh_params_generate2 - This function will generate new DH parameters
* @params: Is the structure that the DH parameters will be stored
* @bits: is the prime's number of bits
*
- * This function will generate a new pair of prime and generator for use in
+ * This function will generate a new pair of prime and generator for use in
* the Diffie-Hellman key exchange. The new parameters will be allocated using
* gnutls_malloc() and will be stored in the appropriate datum.
- * This function is normally slow.
- *
+ * This function is normally slow.
+ *
* Note that the bits value should be one of 768, 1024, 2048, 3072 or 4096.
* Also note that the DH parameters are only useful to servers.
* Since clients use the parameters sent by the server, it's of
@@ -264,12 +197,12 @@ gnutls_dh_params_cpy (gnutls_dh_params_t dst, gnutls_dh_params_t src)
*
**/
int
-gnutls_dh_params_generate2 (gnutls_dh_params_t params, unsigned int bits)
+MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params, unsigned int bits)
{
int ret;
ret =
- _gnutls_dh_generate_prime (¶ms->params[1], ¶ms->params[0], bits);
+ mhd_gtls_dh_generate_prime (¶ms->params[1], ¶ms->params[0], bits);
if (ret < 0)
{
gnutls_assert ();
@@ -278,349 +211,3 @@ gnutls_dh_params_generate2 (gnutls_dh_params_t params, unsigned int bits)
return 0;
}
-
-/**
- * gnutls_dh_params_import_pkcs3 - This function will import DH params from a pkcs3 structure
- * @params: A structure where the parameters will be copied to
- * @pkcs3_params: should contain a PKCS3 DHParams structure PEM or DER encoded
- * @format: the format of params. PEM or DER.
- *
- * This function will extract the DHParams found in a PKCS3 formatted
- * structure. This is the format generated by "openssl dhparam" tool.
- *
- * If the structure is PEM encoded, it should have a header
- * of "BEGIN DH PARAMETERS".
- *
- * In case of failure a negative value will be returned, and
- * 0 on success.
- *
- **/
-int
-gnutls_dh_params_import_pkcs3 (gnutls_dh_params_t params,
- const gnutls_datum_t * pkcs3_params,
- gnutls_x509_crt_fmt_t format)
-{
- ASN1_TYPE c2;
- int result, need_free = 0;
- gnutls_datum_t _params;
-
- if (format == GNUTLS_X509_FMT_PEM)
- {
- opaque *out;
-
- result = _gnutls_fbase64_decode ("DH PARAMETERS", pkcs3_params->data,
- pkcs3_params->size, &out);
-
- if (result <= 0)
- {
- if (result == 0)
- result = GNUTLS_E_INTERNAL_ERROR;
- gnutls_assert ();
- return result;
- }
-
- _params.data = out;
- _params.size = result;
-
- need_free = 1;
-
- }
- else
- {
- _params.data = pkcs3_params->data;
- _params.size = pkcs3_params->size;
- }
-
- if ((result =
- asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DHParameter",
- &c2)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- if (need_free != 0)
- {
- gnutls_free (_params.data);
- _params.data = NULL;
- }
- return _gnutls_asn2err (result);
- }
-
- result = asn1_der_decoding (&c2, _params.data, _params.size, NULL);
-
- if (need_free != 0)
- {
- gnutls_free (_params.data);
- _params.data = NULL;
- }
-
- if (result != ASN1_SUCCESS)
- {
- /* couldn't decode DER */
-
- _gnutls_x509_log ("DHParams: Decoding error %d\n", result);
- gnutls_assert ();
- asn1_delete_structure (&c2);
- return _gnutls_asn2err (result);
- }
-
- /* Read PRIME
- */
- result = _gnutls_x509_read_int (c2, "prime", ¶ms->params[0]);
- if (result < 0)
- {
- asn1_delete_structure (&c2);
- gnutls_assert ();
- return result;
- }
-
- /* read the generator
- */
- result = _gnutls_x509_read_int (c2, "base", ¶ms->params[1]);
- if (result < 0)
- {
- asn1_delete_structure (&c2);
- _gnutls_mpi_release (¶ms->params[0]);
- gnutls_assert ();
- return result;
- }
-
- asn1_delete_structure (&c2);
-
- return 0;
-}
-
-/**
- * gnutls_dh_params_export_pkcs3 - This function will export DH params to a pkcs3 structure
- * @params: Holds the DH parameters
- * @format: the format of output params. One of PEM or DER.
- * @params_data: will contain a PKCS3 DHParams structure PEM or DER encoded
- * @params_data_size: holds the size of params_data (and will be replaced by the actual size of parameters)
- *
- * This function will export the given dh parameters to a PKCS3
- * DHParams structure. This is the format generated by "openssl dhparam" tool.
- * If the buffer provided is not long enough to hold the output, then
- * GNUTLS_E_SHORT_MEMORY_BUFFER will be returned.
- *
- * If the structure is PEM encoded, it will have a header
- * of "BEGIN DH PARAMETERS".
- *
- * In case of failure a negative value will be returned, and
- * 0 on success.
- *
- **/
-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)
-{
- ASN1_TYPE c2;
- int result, _params_data_size;
- size_t g_size, p_size;
- opaque *p_data, *g_data;
- opaque *all_data;
-
- _gnutls_mpi_print_lz (NULL, &g_size, params->params[1]);
- _gnutls_mpi_print_lz (NULL, &p_size, params->params[0]);
-
- all_data = gnutls_malloc (g_size + p_size);
- if (all_data == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- p_data = &all_data[0];
- g_data = &all_data[p_size];
-
- _gnutls_mpi_print_lz (p_data, &p_size, params->params[0]);
- _gnutls_mpi_print_lz (g_data, &g_size, params->params[1]);
-
- /* Ok. Now we have the data. Create the asn1 structures
- */
-
- if ((result =
- asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DHParameter",
- &c2)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- gnutls_free (all_data);
- return _gnutls_asn2err (result);
- }
-
- /* Write PRIME
- */
- if ((result =
- asn1_write_value (c2, "prime", p_data, p_size)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- gnutls_free (all_data);
- asn1_delete_structure (&c2);
- return _gnutls_asn2err (result);
- }
-
- /* Write the GENERATOR
- */
- if ((result =
- asn1_write_value (c2, "base", g_data, g_size)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- gnutls_free (all_data);
- asn1_delete_structure (&c2);
- return _gnutls_asn2err (result);
- }
-
- gnutls_free (all_data);
-
- if ((result = asn1_write_value (c2, "privateValueLength",
- NULL, 0)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- asn1_delete_structure (&c2);
- return _gnutls_asn2err (result);
- }
-
- if (format == GNUTLS_X509_FMT_DER)
- {
- if (params_data == NULL)
- *params_data_size = 0;
-
- _params_data_size = *params_data_size;
- result =
- asn1_der_coding (c2, "", params_data, &_params_data_size, NULL);
- *params_data_size = _params_data_size;
- asn1_delete_structure (&c2);
-
- if (result != ASN1_SUCCESS)
- {
- gnutls_assert ();
- if (result == ASN1_MEM_ERROR)
- return GNUTLS_E_SHORT_MEMORY_BUFFER;
-
- return _gnutls_asn2err (result);
- }
-
- }
- else
- { /* PEM */
- opaque *tmp;
- opaque *out;
- int len;
-
- len = 0;
- asn1_der_coding (c2, "", NULL, &len, NULL);
-
- tmp = gnutls_malloc (len);
- if (tmp == NULL)
- {
- gnutls_assert ();
- asn1_delete_structure (&c2);
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- if ((result =
- asn1_der_coding (c2, "", tmp, &len, NULL)) != ASN1_SUCCESS)
- {
- gnutls_assert ();
- gnutls_free (tmp);
- asn1_delete_structure (&c2);
- return _gnutls_asn2err (result);
- }
-
- asn1_delete_structure (&c2);
-
- result = _gnutls_fbase64_encode ("DH PARAMETERS", tmp, len, &out);
-
- gnutls_free (tmp);
-
- if (result < 0)
- {
- gnutls_assert ();
- return result;
- }
-
- if (result == 0)
- { /* oooops */
- gnutls_assert ();
- gnutls_free (out);
- return GNUTLS_E_INTERNAL_ERROR;
- }
-
- if ((unsigned) result + 1 > *params_data_size)
- {
- gnutls_assert ();
- gnutls_free (out);
- *params_data_size = result + 1;
- return GNUTLS_E_SHORT_MEMORY_BUFFER;
- }
-
- *params_data_size = result;
-
- if (params_data)
- {
- memcpy (params_data, out, result);
- params_data[result] = 0;
- }
- gnutls_free (out);
-
- }
-
- return 0;
-}
-
-/**
- * gnutls_dh_params_export_raw - This function will export the raw DH parameters
- * @params: Holds the DH parameters
- * @prime: will hold the new prime
- * @generator: will hold the new generator
- * @bits: if non null will hold is the prime's number of bits
- *
- * This function will export the pair of prime and generator for use in
- * the Diffie-Hellman key exchange. The new parameters will be allocated using
- * gnutls_malloc() and will be stored in the appropriate datum.
- *
- **/
-int
-gnutls_dh_params_export_raw (gnutls_dh_params_t params,
- gnutls_datum_t * prime,
- gnutls_datum_t * generator, unsigned int *bits)
-{
-
- size_t size;
-
- if (params->params[1] == NULL || params->params[0] == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_INVALID_REQUEST;
- }
-
- size = 0;
- _gnutls_mpi_print (NULL, &size, params->params[1]);
-
- generator->data = gnutls_malloc (size);
- if (generator->data == NULL)
- {
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- generator->size = size;
- _gnutls_mpi_print (generator->data, &size, params->params[1]);
-
- size = 0;
- _gnutls_mpi_print (NULL, &size, params->params[0]);
-
- prime->data = gnutls_malloc (size);
- if (prime->data == NULL)
- {
- gnutls_free (generator->data);
- generator->data = NULL;
- return GNUTLS_E_MEMORY_ERROR;
- }
- prime->size = size;
- _gnutls_mpi_print (prime->data, &size, params->params[0]);
-
- if (bits)
- *bits = _gnutls_mpi_get_nbits (params->params[0]);
-
- return 0;
-
-}
diff --git a/src/daemon/https/tls/gnutls_errors.c b/src/daemon/https/tls/gnutls_errors.c
@@ -263,7 +263,7 @@ static const gnutls_error_entry error_algorithms[] = {
/**
- * gnutls_error_is_fatal - Returns non-zero in case of a fatal error
+ * MHD_gtls_error_is_fatal - Returns non-zero in case of a fatal error
* @error: is an error returned by a gnutls function. Error should be a negative value.
*
* If a function returns a negative value you may feed that value
@@ -279,7 +279,7 @@ static const gnutls_error_entry error_algorithms[] = {
*
**/
int
-gnutls_error_is_fatal (int error)
+MHD_gtls_error_is_fatal (int error)
{
int ret = 1;
@@ -294,14 +294,14 @@ gnutls_error_is_fatal (int error)
}
/**
- * gnutls_perror - prints a string to stderr with a description of an error
+ * MHD_gtls_perror - prints a string to stderr with a description of an error
* @error: is an error returned by a gnutls function. Error is always a negative value.
*
* This function is like perror(). The only difference is that it accepts an
* error number returned by a gnutls function.
**/
void
-gnutls_perror (int error)
+MHD_gtls_perror (int error)
{
const char *ret = NULL;
@@ -314,7 +314,7 @@ gnutls_perror (int error)
/**
- * gnutls_strerror - Returns a string with a description of an error
+ * MHD_gtls_strerror - Returns a string with a description of an error
* @error: is an error returned by a gnutls function. Error is always a negative value.
*
* This function is similar to strerror(). Differences: it accepts an error
@@ -322,7 +322,7 @@ gnutls_perror (int error)
* a descriptive string is sent instead of NULL.
**/
const char *
-gnutls_strerror (int error)
+MHD_gtls_strerror (int error)
{
const char *ret = NULL;
diff --git a/src/daemon/https/tls/gnutls_extensions.c b/src/daemon/https/tls/gnutls_extensions.c
@@ -43,26 +43,26 @@
#define MAX_EXT_SIZE 10
-const int _gnutls_extensions_size = MAX_EXT_SIZE;
+const int mhd_gtls_extensions_size = MAX_EXT_SIZE;
-gnutls_extension_entry _gnutls_extensions[MAX_EXT_SIZE] = {
+mhd_gtls_extension_entry mhd_gtls_extensions[MAX_EXT_SIZE] = {
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_MAX_RECORD_SIZE,
EXTENSION_TLS,
- _gnutls_max_record_recv_params,
- _gnutls_max_record_send_params),
+ mhd_gtls_max_record_recv_params,
+ mhd_gtls_max_record_send_params),
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_CERT_TYPE,
EXTENSION_TLS,
- _gnutls_cert_type_recv_params,
- _gnutls_cert_type_send_params),
+ mhd_gtls_cert_type_recv_params,
+ mhd_gtls_cert_type_send_params),
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SERVER_NAME,
EXTENSION_APPLICATION,
- _gnutls_server_name_recv_params,
- _gnutls_server_name_send_params),
+ mhd_gtls_server_name_recv_params,
+ mhd_gtls_server_name_send_params),
#ifdef ENABLE_OPRFI
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_OPAQUE_PRF_INPUT,
EXTENSION_TLS,
- _gnutls_oprfi_recv_params,
- _gnutls_oprfi_send_params),
+ mhd_gtls_oprfi_recv_params,
+ mhd_gtls_oprfi_send_params),
#endif
#ifdef ENABLE_SRP
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SRP,
@@ -72,14 +72,14 @@ gnutls_extension_entry _gnutls_extensions[MAX_EXT_SIZE] = {
#endif
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_INNER_APPLICATION,
EXTENSION_TLS,
- _gnutls_inner_application_recv_params,
- _gnutls_inner_application_send_params),
+ mhd_gtls_inner_app_rcv_params,
+ mhd_gtls_inner_app_send_params),
{0, 0, 0, 0}
};
#define GNUTLS_EXTENSION_LOOP2(b) \
- gnutls_extension_entry *p; \
- for(p = _gnutls_extensions; p->name != NULL; p++) { b ; }
+ mhd_gtls_extension_entry *p; \
+ for(p = mhd_gtls_extensions; p->name != NULL; p++) { b ; }
#define GNUTLS_EXTENSION_LOOP(a) \
GNUTLS_EXTENSION_LOOP2( if(p->type == type) { a; break; } )
@@ -87,10 +87,10 @@ gnutls_extension_entry _gnutls_extensions[MAX_EXT_SIZE] = {
/* EXTENSION functions */
-ext_recv_func
-_gnutls_ext_func_recv (uint16_t type, tls_ext_parse_type_t parse_type)
+mhd_gtls_ext_recv_func
+mhd_gtls_ext_func_recv (uint16_t type, mhd_gtls_ext_parse_type_t parse_type)
{
- ext_recv_func ret = NULL;
+ mhd_gtls_ext_recv_func ret = NULL;
GNUTLS_EXTENSION_LOOP (if
(parse_type == EXTENSION_ANY
|| p->parse_type == parse_type) ret =
@@ -99,17 +99,17 @@ _gnutls_ext_func_recv (uint16_t type, tls_ext_parse_type_t parse_type)
}
-ext_send_func
-_gnutls_ext_func_send (uint16_t type)
+mhd_gtls_ext_send_func
+mhd_gtls_ext_func_send (uint16_t type)
{
- ext_send_func ret = NULL;
+ mhd_gtls_ext_send_func ret = NULL;
GNUTLS_EXTENSION_LOOP (ret = p->gnutls_ext_func_send);
return ret;
}
const char *
-_gnutls_extension_get_name (uint16_t type)
+mhd_gtls_extension_get_name (uint16_t type)
{
const char *ret = NULL;
@@ -123,7 +123,7 @@ _gnutls_extension_get_name (uint16_t type)
* requested ones. Otherwise it's a fatal error.
*/
static int
-_gnutls_extension_list_check (gnutls_session_t session, uint16_t type)
+_gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
{
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
@@ -140,15 +140,15 @@ _gnutls_extension_list_check (gnutls_session_t session, uint16_t type)
}
int
-_gnutls_parse_extensions (gnutls_session_t session,
- tls_ext_parse_type_t parse_type,
+mhd_gtls_parse_extensions (mhd_gtls_session_t session,
+ mhd_gtls_ext_parse_type_t parse_type,
const opaque * data, int data_size)
{
int next, ret;
int pos = 0;
uint16_t type;
const opaque *sdata;
- ext_recv_func ext_recv;
+ mhd_gtls_ext_recv_func ext_recv;
uint16_t size;
#ifdef DEBUG
@@ -159,14 +159,14 @@ _gnutls_parse_extensions (gnutls_session_t session,
{
_gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
session,
- _gnutls_extension_get_name (session->
+ mhd_gtls_extension_get_name (session->
internals.
extensions_sent[i]));
}
#endif
DECR_LENGTH_RET (data_size, 2, 0);
- next = _gnutls_read_uint16 (data);
+ next = mhd_gtls_read_uint16 (data);
pos += 2;
DECR_LENGTH_RET (data_size, next, 0);
@@ -174,11 +174,11 @@ _gnutls_parse_extensions (gnutls_session_t session,
do
{
DECR_LENGTH_RET (next, 2, 0);
- type = _gnutls_read_uint16 (&data[pos]);
+ type = mhd_gtls_read_uint16 (&data[pos]);
pos += 2;
_gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
- _gnutls_extension_get_name (type), type);
+ mhd_gtls_extension_get_name (type), type);
if ((ret = _gnutls_extension_list_check (session, type)) < 0)
{
@@ -187,14 +187,14 @@ _gnutls_parse_extensions (gnutls_session_t session,
}
DECR_LENGTH_RET (next, 2, 0);
- size = _gnutls_read_uint16 (&data[pos]);
+ size = mhd_gtls_read_uint16 (&data[pos]);
pos += 2;
DECR_LENGTH_RET (next, size, 0);
sdata = &data[pos];
pos += size;
- ext_recv = _gnutls_ext_func_recv (type, parse_type);
+ ext_recv = mhd_gtls_ext_func_recv (type, parse_type);
if (ext_recv == NULL)
continue;
if ((ret = ext_recv (session, sdata, size)) < 0)
@@ -215,7 +215,7 @@ _gnutls_parse_extensions (gnutls_session_t session,
* extensions are the ones we requested.
*/
static void
-_gnutls_extension_list_add (gnutls_session_t session, uint16_t type)
+_gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
{
if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -234,15 +234,15 @@ _gnutls_extension_list_add (gnutls_session_t session, uint16_t type)
}
int
-_gnutls_gen_extensions (gnutls_session_t session, opaque * data,
+mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
size_t data_size)
{
int size;
uint16_t pos = 0;
opaque *sdata;
int sdata_size;
- ext_send_func ext_send;
- gnutls_extension_entry *p;
+ mhd_gtls_ext_send_func ext_send;
+ mhd_gtls_extension_entry *p;
if (data_size < 2)
{
@@ -261,9 +261,9 @@ _gnutls_gen_extensions (gnutls_session_t session, opaque * data,
}
pos += 2;
- for (p = _gnutls_extensions; p->name != NULL; p++)
+ for (p = mhd_gtls_extensions; p->name != NULL; p++)
{
- ext_send = _gnutls_ext_func_send (p->type);
+ ext_send = mhd_gtls_ext_func_send (p->type);
if (ext_send == NULL)
continue;
size = ext_send (session, sdata, sdata_size);
@@ -277,11 +277,11 @@ _gnutls_gen_extensions (gnutls_session_t session, opaque * data,
}
/* write extension type */
- _gnutls_write_uint16 (p->type, &data[pos]);
+ mhd_gtls_write_uint16 (p->type, &data[pos]);
pos += 2;
/* write size */
- _gnutls_write_uint16 (size, &data[pos]);
+ mhd_gtls_write_uint16 (size, &data[pos]);
pos += 2;
memcpy (&data[pos], sdata, size);
@@ -292,7 +292,7 @@ _gnutls_gen_extensions (gnutls_session_t session, opaque * data,
_gnutls_extension_list_add (session, p->type);
_gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
- _gnutls_extension_get_name (p->type));
+ mhd_gtls_extension_get_name (p->type));
}
else if (size < 0)
{
@@ -305,7 +305,7 @@ _gnutls_gen_extensions (gnutls_session_t session, opaque * data,
size = pos;
pos -= 2; /* remove the size of the size header! */
- _gnutls_write_uint16 (pos, data);
+ mhd_gtls_write_uint16 (pos, data);
if (size == 2)
{ /* empty */
diff --git a/src/daemon/https/tls/gnutls_extensions.h b/src/daemon/https/tls/gnutls_extensions.h
@@ -24,22 +24,22 @@
#include <gnutls_int.h>
-const char *_gnutls_extension_get_name (uint16_t type);
-int _gnutls_parse_extensions (gnutls_session_t, tls_ext_parse_type_t, const opaque *, int);
-int _gnutls_gen_extensions (gnutls_session_t session, opaque * data,
+const char * mhd_gtls_extension_get_name (uint16_t type);
+int mhd_gtls_parse_extensions (mhd_gtls_session_t, mhd_gtls_ext_parse_type_t, const opaque *, int);
+int mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
size_t data_size);
-typedef int (*ext_recv_func) (gnutls_session_t, const opaque *, size_t); /* recv data */
-typedef int (*ext_send_func) (gnutls_session_t, opaque *, size_t); /* send data */
+typedef int (* mhd_gtls_ext_recv_func) (mhd_gtls_session_t, const opaque *, size_t); /* recv data */
+typedef int (* mhd_gtls_ext_send_func) (mhd_gtls_session_t, opaque *, size_t); /* send data */
-ext_send_func _gnutls_ext_func_send (uint16_t type);
-ext_recv_func _gnutls_ext_func_recv (uint16_t type, tls_ext_parse_type_t);
+mhd_gtls_ext_send_func mhd_gtls_ext_func_send (uint16_t type);
+mhd_gtls_ext_recv_func mhd_gtls_ext_func_recv (uint16_t type, mhd_gtls_ext_parse_type_t);
typedef struct
{
const char *name;
uint16_t type;
- tls_ext_parse_type_t parse_type;
- ext_recv_func gnutls_ext_func_recv;
- ext_send_func gnutls_ext_func_send;
-} gnutls_extension_entry;
+ mhd_gtls_ext_parse_type_t parse_type;
+ mhd_gtls_ext_recv_func gnutls_ext_func_recv;
+ mhd_gtls_ext_send_func gnutls_ext_func_send;
+} mhd_gtls_extension_entry;
diff --git a/src/daemon/https/tls/gnutls_extra_hooks.h b/src/daemon/https/tls/gnutls_extra_hooks.h
@@ -29,7 +29,7 @@
#include <auth_cert.h>
typedef int (*_gnutls_openpgp_verify_key_func)
-(const gnutls_certificate_credentials_t,
+(const mhd_gtls_cert_credentials_t,
const gnutls_datum_t *, int,
unsigned int *);
@@ -40,8 +40,8 @@ typedef time_t (*_gnutls_openpgp_crt_expiration_time_func)
(const gnutls_datum_t *);
typedef int (*_gnutls_openpgp_crt_request_func)
-(gnutls_session_t, gnutls_datum_t *,
- const gnutls_certificate_credentials_t,
+(mhd_gtls_session_t, gnutls_datum_t *,
+ const mhd_gtls_cert_credentials_t,
opaque *, int);
typedef int (*_gnutls_openpgp_fingerprint_func)
diff --git a/src/daemon/https/tls/gnutls_global.c b/src/daemon/https/tls/gnutls_global.c
@@ -59,7 +59,7 @@ ASN1_TYPE _gnutls_pkix1_asn;
ASN1_TYPE _gnutls_gnutls_asn;
/**
- * gnutls_global_set_log_function - This function sets the logging function
+ * MHD_gtls_global_set_log_function - This function sets the logging function
* @log_func: it's a log function
*
* This is the function where you set the logging function gnutls
@@ -71,13 +71,13 @@ ASN1_TYPE _gnutls_gnutls_asn;
* void (*gnutls_log_func)( int level, const char*);
**/
void
-gnutls_global_set_log_function (gnutls_log_func log_func)
+MHD_gtls_global_set_log_function (gnutls_log_func log_func)
{
_gnutls_log_func = log_func;
}
/**
- * gnutls_global_set_log_level - This function sets the logging level
+ * MHD_gtls_global_set_log_level - This function sets the logging level
* @level: it's an integer from 0 to 9.
*
* This is the function that allows you to set the log level.
@@ -89,7 +89,7 @@ gnutls_global_set_log_function (gnutls_log_func log_func)
*
**/
void
-gnutls_global_set_log_level (int level)
+MHD_gtls_global_set_log_level (int level)
{
_gnutls_log_level = level;
}
@@ -105,7 +105,7 @@ extern void *(*gnutls_calloc) (size_t, size_t);
int _gnutls_is_secure_mem_null (const void *);
/**
- * gnutls_global_set_mem_functions - This function sets the memory allocation functions
+ * MHD_gtls_global_set_mem_functions - This function sets the memory allocation functions
* @alloc_func: it's the default memory allocation function. Like malloc().
* @secure_alloc_func: This is the memory allocation function that will be used for sensitive data.
* @is_secure_func: a function that returns 0 if the memory given is not secure. May be NULL.
@@ -118,17 +118,16 @@ int _gnutls_is_secure_mem_null (const void *);
* This function is provided to set the memory allocation functions to
* something other than the defaults (ie the gcrypt allocation functions).
*
- * This function must be called before gnutls_global_init() is called.
+ * This function must be called before MHD_gnutls_global_init() is called.
*
**/
-void
-gnutls_global_set_mem_functions (gnutls_alloc_function alloc_func,
- gnutls_alloc_function
- secure_alloc_func,
- gnutls_is_secure_function
- is_secure_func,
- gnutls_realloc_function realloc_func,
- gnutls_free_function free_func)
+void MHD_gtls_global_set_mem_functions(gnutls_alloc_function alloc_func,
+ gnutls_alloc_function
+ secure_alloc_func,
+ gnutls_is_secure_function
+ is_secure_func,
+ gnutls_realloc_function realloc_func,
+ gnutls_free_function free_func)
{
gnutls_secure_malloc = secure_alloc_func;
gnutls_malloc = alloc_func;
@@ -148,10 +147,10 @@ gnutls_global_set_mem_functions (gnutls_alloc_function alloc_func,
gnutls_calloc = calloc;
}
else
- { /* use the included ones */
- gnutls_calloc = _gnutls_calloc;
+ { /* use the included ones */
+ gnutls_calloc = mhd_gtls_calloc;
}
- gnutls_strdup = _gnutls_strdup;
+ gnutls_strdup = mhd_gtls_strdup;
}
@@ -167,12 +166,12 @@ _gnutls_gcry_log_handler (void *dummy, int level,
static int _gnutls_init = 0;
/**
- * gnutls_global_init - This function initializes the global data to defaults.
+ * MHD_gnutls_global_init - This function initializes the global data to defaults.
*
* This function initializes the global data to defaults.
* Every gnutls application has a global data which holds common parameters
* shared by gnutls session structures.
- * You must call gnutls_global_deinit() when gnutls usage is no longer needed
+ * You must call MHD_gnutls_global_deinit() when gnutls usage is no longer needed
* Returns zero on success.
*
* Note that this function will also initialize libgcrypt, if it has not
@@ -181,8 +180,8 @@ static int _gnutls_init = 0;
* want to disable libgcrypt's internal lockings etc.
*
* This function increment a global counter, so that
- * gnutls_global_deinit() only releases resources when it has been
- * called as many times as gnutls_global_init(). This is useful when
+ * MHD_gnutls_global_deinit() only releases resources when it has been
+ * called as many times as MHD_gnutls_global_init(). This is useful when
* GnuTLS is used by more than one library in an application. This
* function can be called many times, but will only do something the
* first time.
@@ -197,7 +196,7 @@ static int _gnutls_init = 0;
*
**/
int
-gnutls_global_init (void)
+MHD_gnutls_global_init (void)
{
int result = 0;
int res;
@@ -279,7 +278,7 @@ gnutls_global_init (void)
}
#ifdef DEBUG
- gnutls_global_set_log_function (MHD_tls_log_func);
+ MHD_gtls_global_set_log_function (MHD_tls_log_func);
#endif
/* initialize parser
@@ -308,17 +307,17 @@ gnutls_global_init (void)
}
/**
- * gnutls_global_deinit - This function deinitializes the global data
+ * MHD_gnutls_global_deinit - This function deinitializes the global data
*
* This function deinitializes the global data, that were initialized
- * using gnutls_global_init().
+ * using MHD_gnutls_global_init().
*
* Note! This function is not thread safe. See the discussion for
- * gnutls_global_init() for more information.
+ * MHD_gnutls_global_init() for more information.
*
**/
void
-gnutls_global_deinit (void)
+MHD_gnutls_global_deinit (void)
{
if (_gnutls_init == 1)
{
@@ -337,7 +336,7 @@ gnutls_global_deinit (void)
*/
/**
- * gnutls_transport_set_pull_function - This function sets a read like function
+ * MHD_gnutls_transport_set_pull_function - This function sets a read like function
* @pull_func: a callback function similar to read()
* @session: gnutls session
*
@@ -347,17 +346,17 @@ gnutls_global_deinit (void)
* probably be ok.
*
* PULL_FUNC is of the form,
- * ssize_t (*gnutls_pull_func)(gnutls_transport_ptr_t, void*, size_t);
+ * ssize_t (*mhd_gtls_pull_func)(gnutls_transport_ptr_t, void*, size_t);
**/
void
-gnutls_transport_set_pull_function (gnutls_session_t session,
- gnutls_pull_func pull_func)
+MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
+ mhd_gtls_pull_func pull_func)
{
session->internals._gnutls_pull_func = pull_func;
}
/**
- * gnutls_transport_set_push_function - This function sets the function to send data
+ * MHD_gnutls_transport_set_push_function - This function sets the function to send data
* @push_func: a callback function similar to write()
* @session: gnutls session
*
@@ -368,11 +367,11 @@ gnutls_transport_set_pull_function (gnutls_session_t session,
* specify this function for gnutls to be able to send data.
*
* PUSH_FUNC is of the form,
- * ssize_t (*gnutls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
+ * ssize_t (*mhd_gtls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
**/
void
-gnutls_transport_set_push_function (gnutls_session_t session,
- gnutls_push_func push_func)
+MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
+ mhd_gtls_push_func push_func)
{
session->internals._gnutls_push_func = push_func;
}
diff --git a/src/daemon/https/tls/gnutls_global.h b/src/daemon/https/tls/gnutls_global.h
@@ -27,7 +27,7 @@
#include <libtasn1.h>
-/* this mutex is used to synchronize threads attemting call gnutls_global_init / gnutls_global_deinit */
+/* this mutex is used to synchronize threads attemting call MHD_gnutls_global_init / MHD_gnutls_global_deinit */
pthread_mutex_t gnutls_init_mutex;
int gnutls_is_secure_memory (const void *mem);
diff --git a/src/daemon/https/tls/gnutls_handshake.c b/src/daemon/https/tls/gnutls_handshake.c
@@ -46,7 +46,7 @@
#include "gnutls_record.h"
#include "gnutls_state.h"
#include "gnutls_rsa_export.h" /* for gnutls_get_rsa_params() */
-#include "auth_anon.h" /* for gnutls_anon_server_credentials_t */
+#include "auth_anon.h" /* for mhd_gtls_anon_server_credentials_t */
#include "gc.h"
#ifdef HANDSHAKE_DEBUG
@@ -58,20 +58,20 @@
#define TRUE 1
#define FALSE 0
-int _gnutls_server_select_comp_method (gnutls_session_t session,
+int _gnutls_server_select_comp_method (mhd_gtls_session_t session,
opaque * data, int datalen);
/* Clears the handshake hash buffers and handles.
*/
inline static void
-_gnutls_handshake_hash_buffers_clear (gnutls_session_t session)
+_gnutls_handshake_hash_buffers_clear (mhd_gtls_session_t session)
{
- _gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
- _gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
+ mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
+ mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
session->internals.handshake_mac_handle_md5 = NULL;
session->internals.handshake_mac_handle_sha = NULL;
- _gnutls_handshake_buffer_clear (session);
+ mhd_gtls_handshake_buffer_clear (session);
}
/* this will copy the required values for resuming to
@@ -79,7 +79,7 @@ _gnutls_handshake_hash_buffers_clear (gnutls_session_t session)
* this will keep as less data to security_parameters.
*/
static void
-resume_copy_required_values (gnutls_session_t session)
+resume_copy_required_values (mhd_gtls_session_t session)
{
/* get the new random values */
memcpy (session->internals.resumed_security_parameters.
@@ -107,7 +107,7 @@ resume_copy_required_values (gnutls_session_t session)
session->security_parameters.entity =
session->internals.resumed_security_parameters.entity;
- _gnutls_set_current_version (session,
+ mhd_gtls_set_current_version (session,
session->internals.
resumed_security_parameters.version);
@@ -122,13 +122,13 @@ resume_copy_required_values (gnutls_session_t session)
}
void
-_gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd)
+mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd)
{
memcpy (session->security_parameters.server_random, rnd, TLS_RANDOM_SIZE);
}
void
-_gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd)
+mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd)
{
memcpy (session->security_parameters.client_random, rnd, TLS_RANDOM_SIZE);
}
@@ -138,25 +138,25 @@ _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd)
#define SSL3_SERVER_MSG "SRVR"
#define SSL_MSG_LEN 4
static int
-_gnutls_ssl3_finished (gnutls_session_t session, int type, opaque * ret)
+_gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
{
const int siz = SSL_MSG_LEN;
mac_hd_t td_md5;
mac_hd_t td_sha;
const char *mesg;
- td_md5 = _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+ td_md5 = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- td_sha = _gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+ td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
- _gnutls_hash_deinit (td_md5, NULL);
+ mhd_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
@@ -169,13 +169,13 @@ _gnutls_ssl3_finished (gnutls_session_t session, int type, opaque * ret)
mesg = SSL3_CLIENT_MSG;
}
- _gnutls_hash (td_md5, mesg, siz);
- _gnutls_hash (td_sha, mesg, siz);
+ mhd_gnutls_hash (td_md5, mesg, siz);
+ mhd_gnutls_hash (td_sha, mesg, siz);
- _gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
- _gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
@@ -187,7 +187,7 @@ _gnutls_ssl3_finished (gnutls_session_t session, int type, opaque * ret)
#define CLIENT_MSG "client finished"
#define TLS_MSG_LEN 15
int
-_gnutls_finished (gnutls_session_t session, int type, void *ret)
+_gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
{
const int siz = TLS_MSG_LEN;
opaque concat[36];
@@ -195,12 +195,12 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
const char *mesg;
mac_hd_t td_md5 = NULL;
mac_hd_t td_sha;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
if (ver < MHD_GNUTLS_TLS1_2)
{
td_md5 =
- _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+ mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
@@ -208,23 +208,23 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
}
}
- td_sha = _gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+ td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
- _gnutls_hash_deinit (td_md5, NULL);
+ mhd_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
if (ver < MHD_GNUTLS_TLS1_2)
{
- _gnutls_hash_deinit (td_md5, concat);
- _gnutls_hash_deinit (td_sha, &concat[16]);
+ mhd_gnutls_hash_deinit (td_md5, concat);
+ mhd_gnutls_hash_deinit (td_sha, &concat[16]);
len = 20 + 16;
}
else
{
- _gnutls_hash_deinit (td_sha, concat);
+ mhd_gnutls_hash_deinit (td_sha, concat);
len = 20;
}
@@ -237,7 +237,7 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
mesg = CLIENT_MSG;
}
- return _gnutls_PRF (session, session->security_parameters.master_secret,
+ return mhd_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, mesg, siz, concat, len, 12, ret);
}
@@ -245,7 +245,7 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
* and put it to dst.
*/
int
-_gnutls_tls_create_random (opaque * dst)
+mhd_gtls_tls_create_random (opaque * dst)
{
uint32_t tim;
@@ -256,7 +256,7 @@ _gnutls_tls_create_random (opaque * dst)
tim = time (NULL);
/* generate server random value */
- _gnutls_write_uint32 (tim, dst);
+ mhd_gtls_write_uint32 (tim, dst);
if (gc_nonce (&dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
{
@@ -270,18 +270,18 @@ _gnutls_tls_create_random (opaque * dst)
/* returns the 0 on success or a negative value.
*/
int
-_gnutls_negotiate_version (gnutls_session_t session,
+mhd_gtls_negotiate_version (mhd_gtls_session_t session,
gnutls_protocol_t adv_version)
{
int ret;
/* if we do not support that version */
- if (_gnutls_version_is_supported (session, adv_version) == 0)
+ if (mhd_gtls_version_is_supported (session, adv_version) == 0)
{
/* If he requested something we do not support
* then we send him the highest we support.
*/
- ret = _gnutls_version_max (session);
+ ret = mhd_gtls_version_max (session);
if (ret == MHD_GNUTLS_VERSION_UNKNOWN)
{
/* this check is not really needed.
@@ -295,13 +295,13 @@ _gnutls_negotiate_version (gnutls_session_t session,
ret = adv_version;
}
- _gnutls_set_current_version (session, ret);
+ mhd_gtls_set_current_version (session, ret);
return ret;
}
int
-_gnutls_user_hello_func (gnutls_session session,
+mhd_gtls_user_hello_func (gnutls_session session,
gnutls_protocol_t adv_version)
{
int ret;
@@ -317,7 +317,7 @@ _gnutls_user_hello_func (gnutls_session session,
/* Here we need to renegotiate the version since the callee might
* have disabled some TLS versions.
*/
- ret = _gnutls_negotiate_version (session, adv_version);
+ ret = mhd_gtls_negotiate_version (session, adv_version);
if (ret < 0)
{
gnutls_assert ();
@@ -333,7 +333,7 @@ _gnutls_user_hello_func (gnutls_session session,
* since SSL version 2.0 is not supported).
*/
int
-_gnutls_read_client_hello (gnutls_session_t session, opaque * data,
+_gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
int datalen)
{
uint8_t session_id_len;
@@ -349,11 +349,11 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
_gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
data[pos], data[pos + 1]);
- adv_version = _gnutls_version_get (data[pos], data[pos + 1]);
+ adv_version = mhd_gtls_version_get (data[pos], data[pos + 1]);
set_adv_version (session, data[pos], data[pos + 1]);
pos += 2;
- neg_version = _gnutls_negotiate_version (session, adv_version);
+ neg_version = mhd_gtls_negotiate_version (session, adv_version);
if (neg_version < 0)
{
gnutls_assert ();
@@ -363,11 +363,11 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
/* Read client random value.
*/
DECR_LEN (len, TLS_RANDOM_SIZE);
- _gnutls_set_client_random (session, &data[pos]);
+ mhd_gtls_set_client_random (session, &data[pos]);
pos += TLS_RANDOM_SIZE;
- _gnutls_tls_create_random (rnd);
- _gnutls_set_server_random (session, rnd);
+ mhd_gtls_tls_create_random (rnd);
+ mhd_gtls_set_server_random (session, rnd);
session->security_parameters.timestamp = time (NULL);
@@ -389,11 +389,11 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
{ /* resumed! */
resume_copy_required_values (session);
session->internals.resumed = RESUME_TRUE;
- return _gnutls_user_hello_func (session, adv_version);
+ return mhd_gtls_user_hello_func (session, adv_version);
}
else
{
- _gnutls_generate_session_id (session->security_parameters.
+ mhd_gtls_generate_session_id (session->security_parameters.
session_id,
&session->security_parameters.
session_id_size);
@@ -404,7 +404,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
/* Remember ciphersuites for later
*/
DECR_LEN (len, 2);
- suite_size = _gnutls_read_uint16 (&data[pos]);
+ suite_size = mhd_gtls_read_uint16 (&data[pos]);
pos += 2;
DECR_LEN (len, suite_size);
@@ -424,7 +424,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
*/
if (neg_version >= MHD_GNUTLS_TLS1_0)
{
- ret = _gnutls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */
+ ret = mhd_gtls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
@@ -432,7 +432,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
}
}
- ret = _gnutls_user_hello_func (session, adv_version);
+ ret = mhd_gtls_user_hello_func (session, adv_version);
if (ret < 0)
{
gnutls_assert ();
@@ -441,7 +441,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
if (neg_version >= MHD_GNUTLS_TLS1_0)
{
- ret = _gnutls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */
+ ret = mhd_gtls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
@@ -451,7 +451,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
/* select an appropriate cipher suite
*/
- ret = _gnutls_server_select_suite (session, suite_ptr, suite_size);
+ ret = mhd_gtls_server_select_suite (session, suite_ptr, suite_size);
if (ret < 0)
{
gnutls_assert ();
@@ -472,7 +472,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
/* here we hash all pending data.
*/
inline static int
-_gnutls_handshake_hash_pending (gnutls_session_t session)
+_gnutls_handshake_hash_pending (mhd_gtls_session_t session)
{
size_t siz;
int ret;
@@ -487,7 +487,7 @@ _gnutls_handshake_hash_pending (gnutls_session_t session)
/* We check if there are pending data to hash.
*/
- if ((ret = _gnutls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
+ if ((ret = mhd_gtls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
{
gnutls_assert ();
return ret;
@@ -495,11 +495,11 @@ _gnutls_handshake_hash_pending (gnutls_session_t session)
if (siz > 0)
{
- _gnutls_hash (session->internals.handshake_mac_handle_sha, data, siz);
- _gnutls_hash (session->internals.handshake_mac_handle_md5, data, siz);
+ mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, data, siz);
+ mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, data, siz);
}
- _gnutls_handshake_buffer_empty (session);
+ mhd_gtls_handshake_buffer_empty (session);
return 0;
}
@@ -510,7 +510,7 @@ _gnutls_handshake_hash_pending (gnutls_session_t session)
* we send.
*/
int
-_gnutls_send_finished (gnutls_session_t session, int again)
+_gnutls_send_finished (mhd_gtls_session_t session, int again)
{
uint8_t data[36];
int ret;
@@ -529,7 +529,7 @@ _gnutls_send_finished (gnutls_session_t session, int again)
return ret;
}
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
ret =
_gnutls_ssl3_finished (session,
@@ -553,7 +553,7 @@ _gnutls_send_finished (gnutls_session_t session, int again)
}
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_FINISHED);
return ret;
@@ -563,7 +563,7 @@ _gnutls_send_finished (gnutls_session_t session, int again)
* went fine we have negotiated a secure connection
*/
int
-_gnutls_recv_finished (gnutls_session_t session)
+_gnutls_recv_finished (mhd_gtls_session_t session)
{
uint8_t data[36], *vrfy;
int data_size;
@@ -571,7 +571,7 @@ _gnutls_recv_finished (gnutls_session_t session)
int vrfysize;
ret =
- _gnutls_recv_handshake (session, &vrfy, &vrfysize,
+ mhd_gtls_recv_handshake (session, &vrfy, &vrfysize,
GNUTLS_HANDSHAKE_FINISHED, MANDATORY_PACKET);
if (ret < 0)
{
@@ -581,7 +581,7 @@ _gnutls_recv_finished (gnutls_session_t session)
}
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
data_size = 36;
}
@@ -597,7 +597,7 @@ _gnutls_recv_finished (gnutls_session_t session)
return GNUTLS_E_ERROR_IN_FINISHED_PACKET;
}
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
ret =
_gnutls_ssl3_finished (session,
@@ -650,11 +650,11 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
for (j = 0; j < datalen; j += 2)
{
memcpy (&cs.suite, &data[j], 2);
- kx = _gnutls_cipher_suite_get_kx_algo (&cs);
+ kx = mhd_gtls_cipher_suite_get_kx_algo (&cs);
- if (_gnutls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
+ if (mhd_gtls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
{
- algo = _gnutls_map_pk_get_pk (kx);
+ algo = mhd_gtls_map_pk_get_pk (kx);
if (algo != prev_algo && prev_algo != 0)
return GNUTLS_PK_ANY;
@@ -670,7 +670,7 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
* it adds the suite to the session and performs some checks.
*/
int
-_gnutls_server_select_suite (gnutls_session_t session, opaque * data,
+mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
int datalen)
{
int x, i, j;
@@ -682,7 +682,7 @@ _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
pk_algo = _gnutls_server_find_pk_algos_in_ciphersuites (data, datalen);
- x = _gnutls_supported_ciphersuites (session, &ciphers);
+ x = mhd_gtls_supported_ciphersuites (session, &ciphers);
if (x < 0)
{ /* the case x==0 is handled within the function. */
gnutls_assert ();
@@ -693,7 +693,7 @@ _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
* the certificate requested, or to the
* authentication requested (e.g. SRP).
*/
- x = _gnutls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
+ x = mhd_gtls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
if (x <= 0)
{
gnutls_assert ();
@@ -719,12 +719,12 @@ _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
for (j = 0; j < datalen; j += 2)
{
memcpy (&cs.suite, &data[j], 2);
- _gnutls_handshake_log ("\t%s\n", _gnutls_cipher_suite_get_name (&cs));
+ _gnutls_handshake_log ("\t%s\n", mhd_gtls_cipher_suite_get_name (&cs));
}
_gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
for (j = 0; j < x; j++)
_gnutls_handshake_log ("\t%s\n",
- _gnutls_cipher_suite_get_name (&ciphers[j]));
+ mhd_gtls_cipher_suite_get_name (&ciphers[j]));
#endif
memset (session->security_parameters.current_cipher_suite.suite, '\0', 2);
@@ -740,7 +740,7 @@ _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
_gnutls_handshake_log
("HSK[%x]: Selected cipher suite: %s\n", session,
- _gnutls_cipher_suite_get_name (&cs));
+ mhd_gtls_cipher_suite_get_name (&cs));
memcpy (session->security_parameters.current_cipher_suite.
suite, ciphers[i].suite, 2);
retval = 0;
@@ -760,9 +760,9 @@ finish:
/* check if the credentials (username, public key etc.) are ok
*/
- if (_gnutls_get_kx_cred
+ if (mhd_gtls_get_kx_cred
(session,
- _gnutls_cipher_suite_get_kx_algo (&session->security_parameters.
+ mhd_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
current_cipher_suite),
&err) == NULL && err != 0)
{
@@ -771,12 +771,12 @@ finish:
}
- /* set the mod_auth_st to the appropriate struct
+ /* set the mhd_gtls_mod_auth_st to the appropriate struct
* according to the KX algorithm. This is needed since all the
* handshake functions are read from there;
*/
session->internals.auth_struct =
- _gnutls_kx_auth_struct (_gnutls_cipher_suite_get_kx_algo
+ mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (session->internals.auth_struct == NULL)
@@ -797,13 +797,13 @@ finish:
/* This selects the best supported compression method from the ones provided
*/
int
-_gnutls_server_select_comp_method (gnutls_session_t session,
+_gnutls_server_select_comp_method (mhd_gtls_session_t session,
opaque * data, int datalen)
{
int x, i, j;
uint8_t *comps;
- x = _gnutls_supported_compression_methods (session, &comps);
+ x = mhd_gtls_supported_compression_methods (session, &comps);
if (x < 0)
{
gnutls_assert ();
@@ -820,14 +820,14 @@ _gnutls_server_select_comp_method (gnutls_session_t session,
if (comps[i] == data[j])
{
gnutls_compression_method_t method =
- _gnutls_compression_get_id (comps[i]);
+ mhd_gtls_compression_get_id (comps[i]);
session->internals.compression_method = method;
gnutls_free (comps);
_gnutls_handshake_log
("HSK[%x]: Selected Compression Method: %s\n", session,
- gnutls_compression_get_name (session->internals.
+ MHD_gnutls_compression_get_name (session->internals.
compression_method));
@@ -851,7 +851,7 @@ _gnutls_server_select_comp_method (gnutls_session_t session,
* (until it returns ok), with NULL parameters.
*/
int
-_gnutls_send_empty_handshake (gnutls_session_t session,
+_gnutls_send_empty_handshake (mhd_gtls_session_t session,
gnutls_handshake_description_t type, int again)
{
opaque data = 0;
@@ -862,13 +862,13 @@ _gnutls_send_empty_handshake (gnutls_session_t session,
else
ptr = NULL;
- return _gnutls_send_handshake (session, ptr, 0, type);
+ return mhd_gtls_send_handshake (session, ptr, 0, type);
}
/* This function will hash the handshake message we sent. */
static int
-_gnutls_handshake_hash_add_sent (gnutls_session_t session,
+_gnutls_handshake_hash_add_sent (mhd_gtls_session_t session,
gnutls_handshake_description_t type,
opaque * dataptr, uint32_t datalen)
{
@@ -882,9 +882,9 @@ _gnutls_handshake_hash_add_sent (gnutls_session_t session,
if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
{
- _gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
+ mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
datalen);
- _gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
+ mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
datalen);
}
@@ -893,12 +893,12 @@ _gnutls_handshake_hash_add_sent (gnutls_session_t session,
/* This function sends a handshake message of type 'type' containing the
- * data specified here. If the previous _gnutls_send_handshake() returned
+ * data specified here. If the previous mhd_gtls_send_handshake() returned
* GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
* (until it returns ok), with NULL parameters.
*/
int
-_gnutls_send_handshake (gnutls_session_t session, void *i_data,
+mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
uint32_t i_datasize,
gnutls_handshake_description_t type)
{
@@ -912,7 +912,7 @@ _gnutls_send_handshake (gnutls_session_t session, void *i_data,
/* we are resuming a previously interrupted
* send.
*/
- ret = _gnutls_handshake_io_write_flush (session);
+ ret = mhd_gtls_handshake_io_write_flush (session);
return ret;
}
@@ -933,7 +933,7 @@ _gnutls_send_handshake (gnutls_session_t session, void *i_data,
}
data[pos++] = (uint8_t) type;
- _gnutls_write_uint24 (i_datasize, &data[pos]);
+ mhd_gtls_write_uint24 (i_datasize, &data[pos]);
pos += 3;
if (i_datasize > 0)
@@ -953,7 +953,7 @@ _gnutls_send_handshake (gnutls_session_t session, void *i_data,
session->internals.last_handshake_out = type;
ret =
- _gnutls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
+ mhd_gtls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
data, datasize);
_gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
@@ -972,7 +972,7 @@ _gnutls_send_handshake (gnutls_session_t session, void *i_data,
*/
#define SSL2_HEADERS 1
static int
-_gnutls_recv_handshake_header (gnutls_session_t session,
+_gnutls_recv_handshake_header (mhd_gtls_session_t session,
gnutls_handshake_description_t type,
gnutls_handshake_description_t * recv_type)
{
@@ -1006,7 +1006,7 @@ _gnutls_recv_handshake_header (gnutls_session_t session,
if (session->internals.handshake_header_buffer.header_size < SSL2_HEADERS)
{
ret =
- _gnutls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+ mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type, dataptr, SSL2_HEADERS);
if (ret < 0)
@@ -1029,7 +1029,7 @@ _gnutls_recv_handshake_header (gnutls_session_t session,
|| type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
{
ret =
- _gnutls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+ mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type,
&dataptr[session->
internals.
@@ -1055,7 +1055,7 @@ _gnutls_recv_handshake_header (gnutls_session_t session,
/* we do not use DECR_LEN because we know
* that the packet has enough data.
*/
- length32 = _gnutls_read_uint24 (&dataptr[1]);
+ length32 = mhd_gtls_read_uint24 (&dataptr[1]);
handshake_header_size = HANDSHAKE_HEADER_SIZE;
_gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
@@ -1105,7 +1105,7 @@ _gnutls_recv_handshake_header (gnutls_session_t session,
* handshake data.
*/
static int
-_gnutls_handshake_hash_add_recvd (gnutls_session_t session,
+_gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
gnutls_handshake_description_t recv_type,
opaque * header, uint16_t header_size,
opaque * dataptr, uint32_t datalen)
@@ -1127,7 +1127,7 @@ _gnutls_handshake_hash_add_recvd (gnutls_session_t session,
{
if ((ret =
- _gnutls_handshake_buffer_put (session, header, header_size)) < 0)
+ mhd_gtls_handshake_buffer_put (session, header, header_size)) < 0)
{
gnutls_assert ();
return ret;
@@ -1136,7 +1136,7 @@ _gnutls_handshake_hash_add_recvd (gnutls_session_t session,
if (datalen > 0)
{
if ((ret =
- _gnutls_handshake_buffer_put (session, dataptr, datalen)) < 0)
+ mhd_gtls_handshake_buffer_put (session, dataptr, datalen)) < 0)
{
gnutls_assert ();
return ret;
@@ -1151,10 +1151,10 @@ _gnutls_handshake_hash_add_recvd (gnutls_session_t session,
/* This function will receive handshake messages of the given types,
* and will pass the message to the right place in order to be processed.
* E.g. for the SERVER_HELLO message (if it is expected), it will be
- * passed to _gnutls_recv_hello().
+ * passed to mhd_gtls_recv_hello().
*/
int
-_gnutls_recv_handshake (gnutls_session_t session, uint8_t ** data,
+mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
int *datalen, gnutls_handshake_description_t type,
Optional optional)
{
@@ -1204,7 +1204,7 @@ _gnutls_recv_handshake (gnutls_session_t session, uint8_t ** data,
if (length32 > 0)
{
ret =
- _gnutls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+ mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type, dataptr, length32);
if (ret <= 0)
{
@@ -1241,7 +1241,7 @@ _gnutls_recv_handshake (gnutls_session_t session, uint8_t ** data,
{
case GNUTLS_HANDSHAKE_CLIENT_HELLO:
case GNUTLS_HANDSHAKE_SERVER_HELLO:
- ret = _gnutls_recv_hello (session, dataptr, length32);
+ ret = mhd_gtls_recv_hello (session, dataptr, length32);
/* dataptr is freed because the caller does not
* need it */
gnutls_free (dataptr);
@@ -1278,7 +1278,7 @@ _gnutls_recv_handshake (gnutls_session_t session, uint8_t ** data,
* to the session;
*/
static int
-_gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
+_gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
{
uint8_t z;
cipher_suite_st *cipher_suites;
@@ -1286,7 +1286,7 @@ _gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
int i, err;
z = 1;
- cipher_suite_num = _gnutls_supported_ciphersuites (session, &cipher_suites);
+ cipher_suite_num = mhd_gtls_supported_ciphersuites (session, &cipher_suites);
if (cipher_suite_num < 0)
{
gnutls_assert ();
@@ -1313,7 +1313,7 @@ _gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
memcpy (session->security_parameters.current_cipher_suite.suite, suite, 2);
_gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
- _gnutls_cipher_suite_get_name (&session->
+ mhd_gtls_cipher_suite_get_name (&session->
security_parameters.
current_cipher_suite));
@@ -1321,8 +1321,8 @@ _gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
/* check if the credentials (username, public key etc.) are ok.
* Actually checks if they exist.
*/
- if (_gnutls_get_kx_cred
- (session, _gnutls_cipher_suite_get_kx_algo (&session->
+ if (mhd_gtls_get_kx_cred
+ (session, mhd_gtls_cipher_suite_get_kx_algo (&session->
security_parameters.
current_cipher_suite),
&err) == NULL && err != 0)
@@ -1332,12 +1332,12 @@ _gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
}
- /* set the mod_auth_st to the appropriate struct
+ /* set the mhd_gtls_mod_auth_st to the appropriate struct
* according to the KX algorithm. This is needed since all the
* handshake functions are read from there;
*/
session->internals.auth_struct =
- _gnutls_kx_auth_struct (_gnutls_cipher_suite_get_kx_algo
+ mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
@@ -1358,13 +1358,13 @@ _gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
/* This function sets the given comp method to the session.
*/
static int
-_gnutls_client_set_comp_method (gnutls_session_t session, opaque comp_method)
+_gnutls_client_set_comp_method (mhd_gtls_session_t session, opaque comp_method)
{
int comp_methods_num;
uint8_t *compression_methods;
int i;
- comp_methods_num = _gnutls_supported_compression_methods (session,
+ comp_methods_num = mhd_gtls_supported_compression_methods (session,
&compression_methods);
if (comp_methods_num < 0)
{
@@ -1390,7 +1390,7 @@ _gnutls_client_set_comp_method (gnutls_session_t session, opaque comp_method)
}
session->internals.compression_method =
- _gnutls_compression_get_id (comp_method);
+ mhd_gtls_compression_get_id (comp_method);
return 0;
@@ -1401,7 +1401,7 @@ _gnutls_client_set_comp_method (gnutls_session_t session, opaque comp_method)
* hello.
*/
static int
-_gnutls_client_check_if_resuming (gnutls_session_t session,
+_gnutls_client_check_if_resuming (mhd_gtls_session_t session,
opaque * session_id, int session_id_len)
{
opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
@@ -1409,7 +1409,7 @@ _gnutls_client_check_if_resuming (gnutls_session_t session,
_gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
session_id_len);
_gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
- _gnutls_bin2hex (session_id, session_id_len, buf,
+ mhd_gtls_bin2hex (session_id, session_id_len, buf,
sizeof (buf)));
if (session_id_len > 0 &&
@@ -1448,7 +1448,7 @@ _gnutls_client_check_if_resuming (gnutls_session_t session,
* session.
*/
static int
-_gnutls_read_server_hello (gnutls_session_t session,
+_gnutls_read_server_hello (mhd_gtls_session_t session,
opaque * data, int datalen)
{
uint8_t session_id_len = 0;
@@ -1467,21 +1467,21 @@ _gnutls_read_server_hello (gnutls_session_t session,
session, data[pos], data[pos + 1]);
DECR_LEN (len, 2);
- version = _gnutls_version_get (data[pos], data[pos + 1]);
- if (_gnutls_version_is_supported (session, version) == 0)
+ version = mhd_gtls_version_get (data[pos], data[pos + 1]);
+ if (mhd_gtls_version_is_supported (session, version) == 0)
{
gnutls_assert ();
return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
}
else
{
- _gnutls_set_current_version (session, version);
+ mhd_gtls_set_current_version (session, version);
}
pos += 2;
DECR_LEN (len, TLS_RANDOM_SIZE);
- _gnutls_set_server_random (session, &data[pos]);
+ mhd_gtls_set_server_random (session, &data[pos]);
pos += TLS_RANDOM_SIZE;
@@ -1536,7 +1536,7 @@ _gnutls_read_server_hello (gnutls_session_t session,
*/
if (version >= MHD_GNUTLS_TLS1_0)
{
- ret = _gnutls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */
+ ret = mhd_gtls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
@@ -1551,7 +1551,7 @@ _gnutls_read_server_hello (gnutls_session_t session,
* Needed in client hello messages. Returns the new data length.
*/
static int
-_gnutls_copy_ciphersuites (gnutls_session_t session,
+_gnutls_copy_ciphersuites (mhd_gtls_session_t session,
opaque * ret_data, size_t ret_data_size)
{
int ret, i;
@@ -1559,7 +1559,7 @@ _gnutls_copy_ciphersuites (gnutls_session_t session,
uint16_t cipher_num;
int datalen, pos;
- ret = _gnutls_supported_ciphersuites_sorted (session, &cipher_suites);
+ ret = mhd_gtls_supported_ciphersuites_sorted (session, &cipher_suites);
if (ret < 0)
{
gnutls_assert ();
@@ -1571,7 +1571,7 @@ _gnutls_copy_ciphersuites (gnutls_session_t session,
* authentication requested (eg SRP).
*/
ret =
- _gnutls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
+ mhd_gtls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
if (ret < 0)
{
gnutls_assert ();
@@ -1602,7 +1602,7 @@ _gnutls_copy_ciphersuites (gnutls_session_t session,
return GNUTLS_E_INTERNAL_ERROR;
}
- _gnutls_write_uint16 (cipher_num, ret_data);
+ mhd_gtls_write_uint16 (cipher_num, ret_data);
pos += 2;
for (i = 0; i < (cipher_num / 2); i++)
@@ -1620,14 +1620,14 @@ _gnutls_copy_ciphersuites (gnutls_session_t session,
* Needed in hello messages. Returns the new data length.
*/
static int
-_gnutls_copy_comp_methods (gnutls_session_t session,
+_gnutls_copy_comp_methods (mhd_gtls_session_t session,
opaque * ret_data, size_t ret_data_size)
{
int ret, i;
uint8_t *compression_methods, comp_num;
int datalen, pos;
- ret = _gnutls_supported_compression_methods (session, &compression_methods);
+ ret = mhd_gtls_supported_compression_methods (session, &compression_methods);
if (ret < 0)
{
gnutls_assert ();
@@ -1665,7 +1665,7 @@ _gnutls_copy_comp_methods (gnutls_session_t session,
/* This function sends the client hello handshake message.
*/
static int
-_gnutls_send_client_hello (gnutls_session_t session, int again)
+_gnutls_send_client_hello (mhd_gtls_session_t session, int again)
{
opaque *data = NULL;
int extdatalen;
@@ -1703,7 +1703,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
* version number to the previously established.
*/
if (SessionID == NULL)
- hver = _gnutls_version_max (session);
+ hver = mhd_gtls_version_max (session);
else
{ /* we are resuming a session */
hver = session->internals.resumed_security_parameters.version;
@@ -1716,13 +1716,13 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
return GNUTLS_E_INTERNAL_ERROR;
}
- data[pos++] = _gnutls_version_get_major (hver);
- data[pos++] = _gnutls_version_get_minor (hver);
+ data[pos++] = mhd_gtls_version_get_major (hver);
+ data[pos++] = mhd_gtls_version_get_minor (hver);
/* Set the version we advertized as maximum
* (RSA uses it).
*/
- _gnutls_set_adv_version (session, hver);
+ mhd_gtls_set_adv_version (session, hver);
/* Some old implementations do not interoperate if we send a
* different version in the record layer.
@@ -1732,7 +1732,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
* handshake packet and ignore the one in the packet's record
* header.
*/
- _gnutls_set_current_version (session, hver);
+ mhd_gtls_set_current_version (session, hver);
/* In order to know when this session was initiated.
*/
@@ -1740,8 +1740,8 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
/* Generate random data
*/
- _gnutls_tls_create_random (rnd);
- _gnutls_set_client_random (session, rnd);
+ mhd_gtls_tls_create_random (rnd);
+ mhd_gtls_set_client_random (session, rnd);
memcpy (&data[pos], rnd, TLS_RANDOM_SIZE);
pos += TLS_RANDOM_SIZE;
@@ -1763,7 +1763,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
if (extdatalen > 0)
{
datalen += extdatalen;
- data = gnutls_realloc_fast (data, datalen);
+ data = mhd_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
@@ -1791,7 +1791,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
if (extdatalen > 0)
{
datalen += extdatalen;
- data = gnutls_realloc_fast (data, datalen);
+ data = mhd_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
@@ -1816,12 +1816,12 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
if (hver >= MHD_GNUTLS_TLS1_0)
{
extdatalen =
- _gnutls_gen_extensions (session, extdata, sizeof (extdata));
+ mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
if (extdatalen > 0)
{
datalen += extdatalen;
- data = gnutls_realloc_fast (data, datalen);
+ data = mhd_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
@@ -1840,7 +1840,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
}
ret =
- _gnutls_send_handshake (session, data, datalen,
+ mhd_gtls_send_handshake (session, data, datalen,
GNUTLS_HANDSHAKE_CLIENT_HELLO);
gnutls_free (data);
@@ -1848,7 +1848,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
}
static int
-_gnutls_send_server_hello (gnutls_session_t session, int again)
+_gnutls_send_server_hello (mhd_gtls_session_t session, int again)
{
opaque *data = NULL;
opaque extdata[MAX_EXT_DATA_LENGTH];
@@ -1867,7 +1867,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
#ifdef ENABLE_SRP
if (IS_SRP_KX
- (_gnutls_cipher_suite_get_kx_algo
+ (mhd_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)))
{
/* While resuming we cannot check the username extension since it is
@@ -1882,7 +1882,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
* alert and abort.
*/
gnutls_assert ();
- ret = gnutls_alert_send (session, GNUTLS_AL_FATAL,
+ ret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
GNUTLS_A_UNKNOWN_PSK_IDENTITY);
if (ret < 0)
{
@@ -1899,7 +1899,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
{
datalen = 2 + session_id_len + 1 + TLS_RANDOM_SIZE + 3;
extdatalen =
- _gnutls_gen_extensions (session, extdata, sizeof (extdata));
+ mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
if (extdatalen < 0)
{
@@ -1915,9 +1915,9 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
}
data[pos++] =
- _gnutls_version_get_major (session->security_parameters.version);
+ mhd_gtls_version_get_major (session->security_parameters.version);
data[pos++] =
- _gnutls_version_get_minor (session->security_parameters.version);
+ mhd_gtls_version_get_minor (session->security_parameters.version);
memcpy (&data[pos],
session->security_parameters.server_random, TLS_RANDOM_SIZE);
@@ -1931,7 +1931,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
pos += session_id_len;
_gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
- _gnutls_bin2hex (SessionID, session_id_len,
+ mhd_gtls_bin2hex (SessionID, session_id_len,
buf, sizeof (buf)));
memcpy (&data[pos],
@@ -1939,7 +1939,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
pos += 2;
comp =
- (uint8_t) _gnutls_compression_get_num (session->
+ (uint8_t) mhd_gtls_compression_get_num (session->
internals.compression_method);
data[pos++] = comp;
@@ -1953,7 +1953,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
}
ret =
- _gnutls_send_handshake (session, data, datalen,
+ mhd_gtls_send_handshake (session, data, datalen,
GNUTLS_HANDSHAKE_SERVER_HELLO);
gnutls_afree (data);
@@ -1961,7 +1961,7 @@ _gnutls_send_server_hello (gnutls_session_t session, int again)
}
int
-_gnutls_send_hello (gnutls_session_t session, int again)
+mhd_gtls_send_hello (mhd_gtls_session_t session, int again)
{
int ret;
@@ -1983,7 +1983,7 @@ _gnutls_send_hello (gnutls_session_t session, int again)
* and internals.compression_method.
*/
int
-_gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
+mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
{
int ret;
@@ -2010,7 +2010,7 @@ _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
return ret;
}
-/* The packets in gnutls_handshake (it's more broad than original TLS handshake)
+/* The packets in MHD_gnutls_handshake (it's more broad than original TLS handshake)
*
* Client Server
*
@@ -2034,8 +2034,8 @@ _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
*/
/**
- * gnutls_rehandshake - This function will renegotiate security parameters
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_rehandshake - This function will renegotiate security parameters
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function will renegotiate security parameters with the
* client. This should only be called in case of a server.
@@ -2044,7 +2044,7 @@ _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
* parameters (perform a handshake).
*
* If this function succeeds (returns 0), you must call the
- * gnutls_handshake() function in order to negotiate the new
+ * MHD_gnutls_handshake() function in order to negotiate the new
* parameters.
*
* If the client does not wish to renegotiate parameters he will
@@ -2057,7 +2057,7 @@ _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
*
**/
int
-gnutls_rehandshake (gnutls_session_t session)
+MHD_gnutls_rehandshake (mhd_gtls_session_t session)
{
int ret;
@@ -2081,7 +2081,7 @@ gnutls_rehandshake (gnutls_session_t session)
}
inline static int
-_gnutls_abort_handshake (gnutls_session_t session, int ret)
+_gnutls_abort_handshake (mhd_gtls_session_t session, int ret)
{
if (((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) &&
(gnutls_alert_get (session) == GNUTLS_A_NO_RENEGOTIATION))
@@ -2097,13 +2097,13 @@ _gnutls_abort_handshake (gnutls_session_t session, int ret)
* required for finished messages.
*/
inline static int
-_gnutls_handshake_hash_init (gnutls_session_t session)
+_gnutls_handshake_hash_init (mhd_gtls_session_t session)
{
if (session->internals.handshake_mac_handle_md5 == NULL)
{
session->internals.handshake_mac_handle_md5 =
- _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
+ mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (session->internals.handshake_mac_handle_md5 == GNUTLS_HASH_FAILED)
{
@@ -2115,7 +2115,7 @@ _gnutls_handshake_hash_init (gnutls_session_t session)
if (session->internals.handshake_mac_handle_sha == NULL)
{
session->internals.handshake_mac_handle_sha =
- _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (session->internals.handshake_mac_handle_sha == GNUTLS_HASH_FAILED)
{
gnutls_assert ();
@@ -2127,19 +2127,19 @@ _gnutls_handshake_hash_init (gnutls_session_t session)
}
int
-_gnutls_send_supplemental (gnutls_session_t session, int again)
+_gnutls_send_supplemental (mhd_gtls_session_t session, int again)
{
int ret = 0;
_gnutls_debug_log ("EXT[%x]: Sending supplemental data\n", session);
if (again)
- ret = _gnutls_send_handshake (session, NULL, 0,
+ ret = mhd_gtls_send_handshake (session, NULL, 0,
GNUTLS_HANDSHAKE_SUPPLEMENTAL);
else
{
- gnutls_buffer buf;
- _gnutls_buffer_init (&buf);
+ mhd_gtls_buffer buf;
+ mhd_gtls_buffer_init (&buf);
ret = _gnutls_gen_supplemental (session, &buf);
if (ret < 0)
@@ -2148,16 +2148,16 @@ _gnutls_send_supplemental (gnutls_session_t session, int again)
return ret;
}
- ret = _gnutls_send_handshake (session, buf.data, buf.length,
+ ret = mhd_gtls_send_handshake (session, buf.data, buf.length,
GNUTLS_HANDSHAKE_SUPPLEMENTAL);
- _gnutls_buffer_clear (&buf);
+ mhd_gtls_buffer_clear (&buf);
}
return ret;
}
int
-_gnutls_recv_supplemental (gnutls_session_t session)
+_gnutls_recv_supplemental (mhd_gtls_session_t session)
{
uint8_t *data = NULL;
int datalen = 0;
@@ -2165,7 +2165,7 @@ _gnutls_recv_supplemental (gnutls_session_t session)
_gnutls_debug_log ("EXT[%x]: Expecting supplemental data\n", session);
- ret = _gnutls_recv_handshake (session, &data, &datalen,
+ ret = mhd_gtls_recv_handshake (session, &data, &datalen,
GNUTLS_HANDSHAKE_SUPPLEMENTAL,
OPTIONAL_PACKET);
if (ret < 0)
@@ -2187,8 +2187,8 @@ _gnutls_recv_supplemental (gnutls_session_t session)
}
/**
- * gnutls_handshake - This is the main function in the handshake protocol.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_handshake - This is the main function in the handshake protocol.
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function does the handshake of the TLS/SSL protocol, and
* initializes the TLS connection.
@@ -2201,8 +2201,8 @@ _gnutls_recv_supplemental (gnutls_session_t session)
* The non-fatal errors such as %GNUTLS_E_AGAIN and
* %GNUTLS_E_INTERRUPTED interrupt the handshake procedure, which
* should be later be resumed. Call this function again, until it
- * returns 0; cf. gnutls_record_get_direction() and
- * gnutls_error_is_fatal().
+ * returns 0; cf. MHD_gnutls_record_get_direction() and
+ * MHD_gtls_error_is_fatal().
*
* If this function is called by a server after a rehandshake request
* then %GNUTLS_E_GOT_APPLICATION_DATA or
@@ -2214,7 +2214,7 @@ _gnutls_recv_supplemental (gnutls_session_t session)
*
**/
int
-gnutls_handshake (gnutls_session_t session)
+MHD_gnutls_handshake (mhd_gtls_session_t session)
{
int ret;
@@ -2226,11 +2226,11 @@ gnutls_handshake (gnutls_session_t session)
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
- ret = _gnutls_handshake_client (session);
+ ret = mhd_gtls_handshake_client (session);
}
else
{
- ret = _gnutls_handshake_server (session);
+ ret = mhd_gtls_handshake_server (session);
}
if (ret < 0)
{
@@ -2243,7 +2243,7 @@ gnutls_handshake (gnutls_session_t session)
return ret;
}
- ret = _gnutls_handshake_common (session);
+ ret = mhd_gtls_handshake_common (session);
if (ret < 0)
{
@@ -2256,14 +2256,14 @@ gnutls_handshake (gnutls_session_t session)
STATE = STATE0;
_gnutls_handshake_io_buffer_clear (session);
- _gnutls_handshake_internal_state_clear (session);
+ mhd_gtls_handshake_internal_state_clear (session);
return 0;
}
#define IMED_RET( str, ret) do { \
if (ret < 0) { \
- if (gnutls_error_is_fatal(ret)==0) return ret; \
+ if (MHD_gtls_error_is_fatal(ret)==0) return ret; \
gnutls_assert(); \
ERR( str, ret); \
_gnutls_handshake_hash_buffers_clear(session); \
@@ -2273,11 +2273,11 @@ gnutls_handshake (gnutls_session_t session)
/*
- * _gnutls_handshake_client
+ * mhd_gtls_handshake_client
* This function performs the client side of the handshake of the TLS/SSL protocol.
*/
int
-_gnutls_handshake_client (gnutls_session_t session)
+mhd_gtls_handshake_client (mhd_gtls_session_t session)
{
int ret = 0;
@@ -2286,7 +2286,7 @@ _gnutls_handshake_client (gnutls_session_t session)
if (session->internals.resumed_security_parameters.session_id_size > 0)
_gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
- _gnutls_bin2hex (session->internals.
+ mhd_gtls_bin2hex (session->internals.
resumed_security_parameters.
session_id,
session->internals.
@@ -2299,14 +2299,14 @@ _gnutls_handshake_client (gnutls_session_t session)
{
case STATE0:
case STATE1:
- ret = _gnutls_send_hello (session, AGAIN (STATE1));
+ ret = mhd_gtls_send_hello (session, AGAIN (STATE1));
STATE = STATE1;
IMED_RET ("send hello", ret);
case STATE2:
/* receive the server hello */
ret =
- _gnutls_recv_handshake (session, NULL, NULL,
+ mhd_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_SERVER_HELLO,
MANDATORY_PACKET);
STATE = STATE2;
@@ -2323,14 +2323,14 @@ _gnutls_handshake_client (gnutls_session_t session)
case STATE3:
/* RECV CERTIFICATE */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_server_certificate (session);
+ ret = mhd_gtls_recv_server_certificate (session);
STATE = STATE3;
IMED_RET ("recv server certificate", ret);
case STATE4:
/* receive the server key exchange */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_server_kx_message (session);
+ ret = mhd_gtls_recv_server_kx_message (session);
STATE = STATE4;
IMED_RET ("recv server kx message", ret);
@@ -2339,7 +2339,7 @@ _gnutls_handshake_client (gnutls_session_t session)
*/
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_server_certificate_request (session);
+ ret = mhd_gtls_recv_server_certificate_request (session);
STATE = STATE5;
IMED_RET ("recv server certificate request message", ret);
@@ -2347,7 +2347,7 @@ _gnutls_handshake_client (gnutls_session_t session)
/* receive the server hello done */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret =
- _gnutls_recv_handshake (session, NULL, NULL,
+ mhd_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
MANDATORY_PACKET);
STATE = STATE6;
@@ -2365,13 +2365,13 @@ _gnutls_handshake_client (gnutls_session_t session)
/* send our certificate - if any and if requested
*/
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_send_client_certificate (session, AGAIN (STATE7));
+ ret = mhd_gtls_send_client_certificate (session, AGAIN (STATE7));
STATE = STATE7;
IMED_RET ("send client certificate", ret);
case STATE8:
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_send_client_kx_message (session, AGAIN (STATE8));
+ ret = mhd_gtls_send_client_kx_message (session, AGAIN (STATE8));
STATE = STATE8;
IMED_RET ("send client kx", ret);
@@ -2379,7 +2379,7 @@ _gnutls_handshake_client (gnutls_session_t session)
/* send client certificate verify */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret =
- _gnutls_send_client_certificate_verify (session, AGAIN (STATE9));
+ mhd_gtls_send_client_certificate_verify (session, AGAIN (STATE9));
STATE = STATE9;
IMED_RET ("send client certificate verify", ret);
@@ -2395,7 +2395,7 @@ _gnutls_handshake_client (gnutls_session_t session)
/* This function sends the final handshake packets and initializes connection
*/
static int
-_gnutls_send_handshake_final (gnutls_session_t session, int init)
+_gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
{
int ret = 0;
@@ -2405,7 +2405,7 @@ _gnutls_send_handshake_final (gnutls_session_t session, int init)
{
case STATE0:
case STATE20:
- ret = _gnutls_send_change_cipher_spec (session, AGAIN (STATE20));
+ ret = mhd_gtls_send_change_cipher_spec (session, AGAIN (STATE20));
STATE = STATE20;
if (ret < 0)
{
@@ -2418,7 +2418,7 @@ _gnutls_send_handshake_final (gnutls_session_t session, int init)
*/
if (init == TRUE)
{
- ret = _gnutls_connection_state_init (session);
+ ret = mhd_gtls_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
@@ -2426,7 +2426,7 @@ _gnutls_send_handshake_final (gnutls_session_t session, int init)
}
}
- ret = _gnutls_write_connection_state_init (session);
+ ret = mhd_gtls_write_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
@@ -2457,7 +2457,7 @@ _gnutls_send_handshake_final (gnutls_session_t session, int init)
* read session.
*/
static int
-_gnutls_recv_handshake_final (gnutls_session_t session, int init)
+_gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
{
int ret = 0;
uint8_t ch;
@@ -2466,7 +2466,7 @@ _gnutls_recv_handshake_final (gnutls_session_t session, int init)
{
case STATE0:
case STATE30:
- ret = _gnutls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
+ ret = mhd_gtls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
STATE = STATE30;
if (ret <= 0)
{
@@ -2478,7 +2478,7 @@ _gnutls_recv_handshake_final (gnutls_session_t session, int init)
/* Initialize the connection session (start encryption) - in case of server */
if (init == TRUE)
{
- ret = _gnutls_connection_state_init (session);
+ ret = mhd_gtls_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
@@ -2486,7 +2486,7 @@ _gnutls_recv_handshake_final (gnutls_session_t session, int init)
}
}
- ret = _gnutls_read_connection_state_init (session);
+ ret = mhd_gtls_read_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
@@ -2512,12 +2512,12 @@ _gnutls_recv_handshake_final (gnutls_session_t session, int init)
}
/*
- * _gnutls_handshake_server
+ * mhd_gtls_handshake_server
* This function does the server stuff of the handshake protocol.
*/
int
-_gnutls_handshake_server (gnutls_session_t session)
+mhd_gtls_handshake_server (mhd_gtls_session_t session)
{
int ret = 0;
@@ -2526,14 +2526,14 @@ _gnutls_handshake_server (gnutls_session_t session)
case STATE0:
case STATE1:
ret =
- _gnutls_recv_handshake (session, NULL, NULL,
+ mhd_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_CLIENT_HELLO,
MANDATORY_PACKET);
STATE = STATE1;
IMED_RET ("recv hello", ret);
case STATE2:
- ret = _gnutls_send_hello (session, AGAIN (STATE2));
+ ret = mhd_gtls_send_hello (session, AGAIN (STATE2));
STATE = STATE2;
IMED_RET ("send hello", ret);
@@ -2550,14 +2550,14 @@ _gnutls_handshake_server (gnutls_session_t session)
/* NOTE: these should not be send if we are resuming */
if (session->internals.resumed == RESUME_FALSE)
- ret = _gnutls_send_server_certificate (session, AGAIN (STATE3));
+ ret = mhd_gtls_send_server_certificate (session, AGAIN (STATE3));
STATE = STATE3;
IMED_RET ("send server certificate", ret);
case STATE4:
/* send server key exchange (A) */
if (session->internals.resumed == RESUME_FALSE)
- ret = _gnutls_send_server_kx_message (session, AGAIN (STATE4));
+ ret = mhd_gtls_send_server_kx_message (session, AGAIN (STATE4));
STATE = STATE4;
IMED_RET ("send server kx", ret);
@@ -2565,7 +2565,7 @@ _gnutls_handshake_server (gnutls_session_t session)
/* Send certificate request - if requested to */
if (session->internals.resumed == RESUME_FALSE)
ret =
- _gnutls_send_server_certificate_request (session, AGAIN (STATE5));
+ mhd_gtls_send_server_certificate_request (session, AGAIN (STATE5));
STATE = STATE5;
IMED_RET ("send server cert request", ret);
@@ -2591,21 +2591,21 @@ _gnutls_handshake_server (gnutls_session_t session)
case STATE7:
/* receive the client certificate message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_client_certificate (session);
+ ret = mhd_gtls_recv_client_certificate (session);
STATE = STATE7;
IMED_RET ("recv client certificate", ret);
case STATE8:
/* receive the client key exchange message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_client_kx_message (session);
+ ret = mhd_gtls_recv_client_kx_message (session);
STATE = STATE8;
IMED_RET ("recv client kx", ret);
case STATE9:
/* receive the client certificate verify message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
- ret = _gnutls_recv_client_certificate_verify_message (session);
+ ret = mhd_gtls_recv_client_certificate_verify_message (session);
STATE = STATE9;
IMED_RET ("recv client certificate verify", ret);
@@ -2618,7 +2618,7 @@ _gnutls_handshake_server (gnutls_session_t session)
}
int
-_gnutls_handshake_common (gnutls_session_t session)
+mhd_gtls_handshake_common (mhd_gtls_session_t session)
{
int ret = 0;
@@ -2653,7 +2653,7 @@ _gnutls_handshake_common (gnutls_session_t session)
}
int
-_gnutls_generate_session_id (opaque * session_id, uint8_t * len)
+mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len)
{
*len = TLS_MAX_SESSION_ID_SIZE;
@@ -2667,7 +2667,7 @@ _gnutls_generate_session_id (opaque * session_id, uint8_t * len)
}
int
-_gnutls_recv_hello_request (gnutls_session_t session, void *data,
+mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
uint32_t data_size)
{
uint8_t type;
@@ -2696,33 +2696,33 @@ _gnutls_recv_hello_request (gnutls_session_t session, void *data,
* (DH or RSA) set up. Otherwise returns 0.
*/
inline static int
-check_server_params (gnutls_session_t session,
+check_server_params (mhd_gtls_session_t session,
gnutls_kx_algorithm_t kx,
gnutls_kx_algorithm_t * alg, int alg_size)
{
int cred_type;
- gnutls_dh_params_t dh_params = NULL;
- gnutls_rsa_params_t rsa_params = NULL;
+ mhd_gtls_dh_params_t dh_params = NULL;
+ mhd_gtls_rsa_params_t rsa_params = NULL;
int j;
- cred_type = _gnutls_map_kx_get_cred (kx, 1);
+ cred_type = mhd_gtls_map_kx_get_cred (kx, 1);
/* Read the Diffie Hellman parameters, if any.
*/
if (cred_type == MHD_GNUTLS_CRD_CERTIFICATE)
{
int delete;
- gnutls_certificate_credentials_t x509_cred =
- (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
+ mhd_gtls_cert_credentials_t x509_cred =
+ (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
cred_type, NULL);
if (x509_cred != NULL)
{
dh_params =
- _gnutls_get_dh_params (x509_cred->dh_params,
+ mhd_gtls_get_dh_params (x509_cred->dh_params,
x509_cred->params_func, session);
rsa_params =
- _gnutls_certificate_get_rsa_params (x509_cred->rsa_params,
+ mhd_gtls_certificate_get_rsa_params (x509_cred->rsa_params,
x509_cred->params_func,
session);
}
@@ -2747,14 +2747,14 @@ check_server_params (gnutls_session_t session,
}
else if (cred_type == MHD_GNUTLS_CRD_ANON)
{
- gnutls_anon_server_credentials_t anon_cred =
- (gnutls_anon_server_credentials_t) _gnutls_get_cred (session->key,
+ mhd_gtls_anon_server_credentials_t anon_cred =
+ (mhd_gtls_anon_server_credentials_t) mhd_gtls_get_cred (session->key,
cred_type, NULL);
if (anon_cred != NULL)
{
dh_params =
- _gnutls_get_dh_params (anon_cred->dh_params,
+ mhd_gtls_get_dh_params (anon_cred->dh_params,
anon_cred->params_func, session);
}
#endif
@@ -2763,13 +2763,13 @@ check_server_params (gnutls_session_t session,
else if (cred_type == MHD_GNUTLS_CRD_PSK)
{
gnutls_psk_server_credentials_t psk_cred =
- (gnutls_psk_server_credentials_t) _gnutls_get_cred (session->key,
+ (gnutls_psk_server_credentials_t) mhd_gtls_get_cred (session->key,
cred_type, NULL);
if (psk_cred != NULL)
{
dh_params =
- _gnutls_get_dh_params (psk_cred->dh_params, psk_cred->params_func,
+ mhd_gtls_get_dh_params (psk_cred->dh_params, psk_cred->params_func,
session);
}
#endif
@@ -2781,7 +2781,7 @@ check_server_params (gnutls_session_t session,
/* If the key exchange method needs RSA or DH params,
* but they are not set then remove it.
*/
- if (_gnutls_kx_needs_rsa_params (kx) != 0)
+ if (mhd_gtls_kx_needs_rsa_params (kx) != 0)
{
/* needs rsa params. */
if (_gnutls_rsa_params_to_mpi (rsa_params) == NULL)
@@ -2791,10 +2791,10 @@ check_server_params (gnutls_session_t session,
}
}
- if (_gnutls_kx_needs_dh_params (kx) != 0)
+ if (mhd_gtls_kx_needs_dh_params (kx) != 0)
{
/* needs DH params. */
- if (_gnutls_dh_params_to_mpi (dh_params) == NULL)
+ if (mhd_gtls_dh_params_to_mpi (dh_params) == NULL)
{
gnutls_assert ();
return 1;
@@ -2812,7 +2812,7 @@ check_server_params (gnutls_session_t session,
* by checking certificates etc.
*/
int
-_gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
+mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
cipher_suite_st ** cipherSuites,
int numCipherSuites,
gnutls_pk_algorithm_t requested_pk_algo)
@@ -2821,7 +2821,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
int ret = 0;
cipher_suite_st *newSuite, cs;
int newSuiteSize = 0, i;
- gnutls_certificate_credentials_t cert_cred;
+ mhd_gtls_cert_credentials_t cert_cred;
gnutls_kx_algorithm_t kx;
int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
gnutls_kx_algorithm_t *alg = NULL;
@@ -2834,7 +2834,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
*/
cert_cred =
- (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
+ (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
MHD_GNUTLS_CRD_CERTIFICATE,
NULL);
@@ -2844,12 +2844,12 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
if (session->security_parameters.entity == GNUTLS_SERVER
&& cert_cred != NULL)
{
- ret = _gnutls_server_select_cert (session, requested_pk_algo);
+ ret = mhd_gtls_server_select_cert (session, requested_pk_algo);
if (ret < 0)
{
gnutls_assert ();
_gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
- gnutls_strerror (ret));
+ MHD_gtls_strerror (ret));
cert_cred = NULL;
}
}
@@ -2858,7 +2858,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
* supported by the X509 certificate parameters.
*/
if ((ret =
- _gnutls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
+ mhd_gtls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
{
gnutls_assert ();
return ret;
@@ -2881,11 +2881,11 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
/* finds the key exchange algorithm in
* the ciphersuite
*/
- kx = _gnutls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
+ kx = mhd_gtls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
/* if it is defined but had no credentials
*/
- if (_gnutls_get_kx_cred (session, kx, NULL) == NULL)
+ if (mhd_gtls_get_kx_cred (session, kx, NULL) == NULL)
{
delete = 1;
}
@@ -2903,7 +2903,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
SRP credential too. */
if (kx == MHD_GNUTLS_KX_SRP_RSA || kx == MHD_GNUTLS_KX_SRP_DSS)
{
- if (!_gnutls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
+ if (!mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
delete = 1;
}
@@ -2914,7 +2914,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
_gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
session,
- _gnutls_cipher_suite_get_name (&cs));
+ mhd_gtls_cipher_suite_get_name (&cs));
memcpy (newSuite[newSuiteSize].suite, (*cipherSuites)[i].suite, 2);
newSuiteSize++;
@@ -2923,7 +2923,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
{
_gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
session,
- _gnutls_cipher_suite_get_name (&cs));
+ mhd_gtls_cipher_suite_get_name (&cs));
}
}
@@ -2939,8 +2939,8 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
}
/**
- * gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
+ * @session: is a #mhd_gtls_session_t structure.
* @max: is the maximum number.
*
* This function will set the maximum size of a handshake message.
@@ -2950,28 +2950,28 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
*
**/
void
-gnutls_handshake_set_max_packet_length (gnutls_session_t session, size_t max)
+MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session, size_t max)
{
session->internals.max_handshake_data_buffer_size = max;
}
void
-_gnutls_set_adv_version (gnutls_session_t session, gnutls_protocol_t ver)
+mhd_gtls_set_adv_version (mhd_gtls_session_t session, gnutls_protocol_t ver)
{
- set_adv_version (session, _gnutls_version_get_major (ver),
- _gnutls_version_get_minor (ver));
+ set_adv_version (session, mhd_gtls_version_get_major (ver),
+ mhd_gtls_version_get_minor (ver));
}
gnutls_protocol_t
-_gnutls_get_adv_version (gnutls_session_t session)
+mhd_gtls_get_adv_version (mhd_gtls_session_t session)
{
- return _gnutls_version_get (_gnutls_get_adv_version_major (session),
+ return mhd_gtls_version_get (_gnutls_get_adv_version_major (session),
_gnutls_get_adv_version_minor (session));
}
/**
- * gnutls_handshake_get_last_in - Returns the last handshake message received.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_handshake_get_last_in - Returns the last handshake message received.
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function is only useful to check where the last performed
* handshake failed. If the previous handshake succeed or was not
@@ -2984,14 +2984,14 @@ _gnutls_get_adv_version (gnutls_session_t session)
* %gnutls_handshake_description_t.
**/
gnutls_handshake_description_t
-gnutls_handshake_get_last_in (gnutls_session_t session)
+MHD_gtls_handshake_get_last_in (mhd_gtls_session_t session)
{
return session->internals.last_handshake_in;
}
/**
- * gnutls_handshake_get_last_out - Returns the last handshake message sent.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_handshake_get_last_out - Returns the last handshake message sent.
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function is only useful to check where the last performed
* handshake failed. If the previous handshake succeed or was not
@@ -3004,7 +3004,7 @@ gnutls_handshake_get_last_in (gnutls_session_t session)
* %gnutls_handshake_description_t.
**/
gnutls_handshake_description_t
-gnutls_handshake_get_last_out (gnutls_session_t session)
+MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session)
{
return session->internals.last_handshake_out;
}
diff --git a/src/daemon/https/tls/gnutls_handshake.h b/src/daemon/https/tls/gnutls_handshake.h
@@ -25,33 +25,33 @@
typedef enum Optional
{ OPTIONAL_PACKET, MANDATORY_PACKET } Optional;
-int _gnutls_send_handshake (gnutls_session_t session, void *i_data,
+int mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
uint32_t i_datasize,
gnutls_handshake_description_t type);
-int _gnutls_recv_hello_request (gnutls_session_t session, void *data,
+int mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
uint32_t data_size);
-int _gnutls_send_hello (gnutls_session_t session, int again);
-int _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen);
-int _gnutls_recv_handshake (gnutls_session_t session, uint8_t **, int *,
+int mhd_gtls_send_hello (mhd_gtls_session_t session, int again);
+int mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen);
+int mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t **, int *,
gnutls_handshake_description_t,
Optional optional);
-int _gnutls_generate_session_id (opaque * session_id, uint8_t * len);
-int _gnutls_handshake_common (gnutls_session_t session);
-int _gnutls_handshake_client (gnutls_session_t session);
-int _gnutls_handshake_server (gnutls_session_t session);
-void _gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd);
-void _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd);
-int _gnutls_tls_create_random (opaque * dst);
-int _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
+int mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len);
+int mhd_gtls_handshake_common (mhd_gtls_session_t session);
+int mhd_gtls_handshake_client (mhd_gtls_session_t session);
+int mhd_gtls_handshake_server (mhd_gtls_session_t session);
+void mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd);
+void mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd);
+int mhd_gtls_tls_create_random (opaque * dst);
+int mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
cipher_suite_st ** cipherSuites,
int numCipherSuites,
gnutls_pk_algorithm_t);
-int _gnutls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
-int _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
+int mhd_gtls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
+int mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
int datalen);
-int _gnutls_negotiate_version( gnutls_session_t session, gnutls_protocol_t adv_version);
-int _gnutls_user_hello_func( gnutls_session, gnutls_protocol_t adv_version);
+int mhd_gtls_negotiate_version( mhd_gtls_session_t session, gnutls_protocol_t adv_version);
+int mhd_gtls_user_hello_func( gnutls_session, gnutls_protocol_t adv_version);
#define STATE session->internals.handshake_state
/* This returns true if we have got there
diff --git a/src/daemon/https/tls/gnutls_hash_int.c b/src/daemon/https/tls/gnutls_hash_int.c
@@ -55,7 +55,7 @@ _gnutls_mac2gc (gnutls_mac_algorithm_t mac)
}
GNUTLS_HASH_HANDLE
-_gnutls_hash_init (gnutls_mac_algorithm_t algorithm)
+mhd_gtls_hash_init (gnutls_mac_algorithm_t algorithm)
{
mac_hd_t ret;
int result;
@@ -81,7 +81,7 @@ _gnutls_hash_init (gnutls_mac_algorithm_t algorithm)
}
int
-_gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm)
+mhd_gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm)
{
int ret;
@@ -92,7 +92,7 @@ _gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm)
}
int
-_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
+mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
{
if (textlen > 0)
gc_hash_write (handle->handle, textlen, text);
@@ -100,7 +100,7 @@ _gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
}
GNUTLS_HASH_HANDLE
-_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
+mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
{
GNUTLS_HASH_HANDLE ret;
int result;
@@ -126,12 +126,12 @@ _gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
}
void
-_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
+mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
{
const opaque *mac;
int maclen;
- maclen = _gnutls_hash_get_algo_len (handle->algorithm);
+ maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
mac = gc_hash_read (handle->handle);
if (digest != NULL)
@@ -144,7 +144,7 @@ _gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
mac_hd_t
-_gnutls_hmac_init (gnutls_mac_algorithm_t algorithm,
+mhd_gtls_hmac_init (gnutls_mac_algorithm_t algorithm,
const void *key, int keylen)
{
mac_hd_t ret;
@@ -171,12 +171,12 @@ _gnutls_hmac_init (gnutls_mac_algorithm_t algorithm,
}
void
-_gnutls_hmac_deinit (mac_hd_t handle, void *digest)
+mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest)
{
const opaque *mac;
int maclen;
- maclen = _gnutls_hash_get_algo_len (handle->algorithm);
+ maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
mac = gc_hash_read (handle->handle);
@@ -203,7 +203,7 @@ get_padsize (gnutls_mac_algorithm_t algorithm)
}
mac_hd_t
-_gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
+mhd_gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
int keylen)
{
mac_hd_t ret;
@@ -219,22 +219,22 @@ _gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
memset (ipad, 0x36, padsize);
- ret = _gnutls_hash_init (algorithm);
+ ret = mhd_gtls_hash_init (algorithm);
if (ret != GNUTLS_HASH_FAILED)
{
ret->key = key;
ret->keysize = keylen;
if (keylen > 0)
- _gnutls_hash (ret, key, keylen);
- _gnutls_hash (ret, ipad, padsize);
+ mhd_gnutls_hash (ret, key, keylen);
+ mhd_gnutls_hash (ret, ipad, padsize);
}
return ret;
}
void
-_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
+mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
{
opaque ret[MAX_HASH_SIZE];
mac_hd_t td;
@@ -251,23 +251,23 @@ _gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
memset (opad, 0x5C, padsize);
- td = _gnutls_hash_init (handle->algorithm);
+ td = mhd_gtls_hash_init (handle->algorithm);
if (td != GNUTLS_MAC_FAILED)
{
if (handle->keysize > 0)
- _gnutls_hash (td, handle->key, handle->keysize);
+ mhd_gnutls_hash (td, handle->key, handle->keysize);
- _gnutls_hash (td, opad, padsize);
- block = _gnutls_hmac_get_algo_len (handle->algorithm);
- _gnutls_hash_deinit (handle, ret); /* get the previous hash */
- _gnutls_hash (td, ret, block);
+ mhd_gnutls_hash (td, opad, padsize);
+ block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
+ mhd_gnutls_hash_deinit (handle, ret); /* get the previous hash */
+ mhd_gnutls_hash (td, ret, block);
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
}
}
void
-_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
+mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
void *digest, opaque * key,
uint32_t key_size)
{
@@ -288,23 +288,23 @@ _gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
memset (opad, 0x5C, padsize);
memset (ipad, 0x36, padsize);
- td = _gnutls_hash_init (handle->algorithm);
+ td = mhd_gtls_hash_init (handle->algorithm);
if (td != GNUTLS_HASH_FAILED)
{
if (key_size > 0)
- _gnutls_hash (td, key, key_size);
+ mhd_gnutls_hash (td, key, key_size);
- _gnutls_hash (td, opad, padsize);
- block = _gnutls_hmac_get_algo_len (handle->algorithm);
+ mhd_gnutls_hash (td, opad, padsize);
+ block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
if (key_size > 0)
- _gnutls_hash (handle, key, key_size);
- _gnutls_hash (handle, ipad, padsize);
- _gnutls_hash_deinit (handle, ret); /* get the previous hash */
+ mhd_gnutls_hash (handle, key, key_size);
+ mhd_gnutls_hash (handle, ipad, padsize);
+ mhd_gnutls_hash_deinit (handle, ret); /* get the previous hash */
- _gnutls_hash (td, ret, block);
+ mhd_gnutls_hash (td, ret, block);
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
}
}
@@ -322,18 +322,18 @@ ssl3_sha (int i, opaque * secret, int secret_len,
text1[j] = 65 + i; /* A==65 */
}
- td = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (td == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td, text1, i + 1);
- _gnutls_hash (td, secret, secret_len);
- _gnutls_hash (td, rnd, rnd_len);
+ mhd_gnutls_hash (td, text1, i + 1);
+ mhd_gnutls_hash (td, secret, secret_len);
+ mhd_gnutls_hash (td, rnd, rnd_len);
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
return 0;
}
@@ -345,49 +345,49 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
mac_hd_t td;
int ret;
- td = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
+ td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td, secret, secret_len);
+ mhd_gnutls_hash (td, secret, secret_len);
ret = ssl3_sha (i, secret, secret_len, rnd, rnd_len, tmp);
if (ret < 0)
{
gnutls_assert ();
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
return ret;
}
- _gnutls_hash (td, tmp, _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
+ mhd_gnutls_hash (td, tmp, mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
return 0;
}
int
-_gnutls_ssl3_hash_md5 (void *first, int first_len,
+mhd_gnutls_ssl3_hash_md5 (void *first, int first_len,
void *second, int second_len, int ret_len,
opaque * ret)
{
opaque digest[MAX_HASH_SIZE];
mac_hd_t td;
- int block = _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
+ int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
- td = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
+ td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td, first, first_len);
- _gnutls_hash (td, second, second_len);
+ mhd_gnutls_hash (td, first, first_len);
+ mhd_gnutls_hash (td, second, second_len);
- _gnutls_hash_deinit (td, digest);
+ mhd_gnutls_hash_deinit (td, digest);
if (ret_len > block)
{
@@ -402,13 +402,13 @@ _gnutls_ssl3_hash_md5 (void *first, int first_len,
}
int
-_gnutls_ssl3_generate_random (void *secret, int secret_len,
+mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int rnd_len,
int ret_bytes, opaque * ret)
{
int i = 0, copy, output_bytes;
opaque digest[MAX_HASH_SIZE];
- int block = _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
+ int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
int result, times;
output_bytes = 0;
diff --git a/src/daemon/https/tls/gnutls_hash_int.h b/src/daemon/https/tls/gnutls_hash_int.h
@@ -42,31 +42,30 @@ typedef mac_hd_t GNUTLS_HASH_HANDLE;
#define GNUTLS_HASH_FAILED NULL
#define GNUTLS_MAC_FAILED NULL
-mac_hd_t _gnutls_hmac_init (gnutls_mac_algorithm_t algorithm,
+mac_hd_t mhd_gtls_hmac_init (gnutls_mac_algorithm_t algorithm,
const void *key, int keylen);
-#define _gnutls_hmac_get_algo_len _gnutls_hash_get_algo_len
-#define _gnutls_hmac _gnutls_hash
-void _gnutls_hmac_deinit (mac_hd_t handle, void *digest);
-mac_hd_t _gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
+void mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest);
+
+mac_hd_t mhd_gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
int keylen);
-void _gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
+void mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
-GNUTLS_HASH_HANDLE _gnutls_hash_init (gnutls_mac_algorithm_t algorithm);
-int _gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm);
-int _gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
+GNUTLS_HASH_HANDLE mhd_gtls_hash_init (gnutls_mac_algorithm_t algorithm);
+int mhd_gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm);
+int mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
size_t textlen);
-void _gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
+void mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
-int _gnutls_ssl3_generate_random (void *secret, int secret_len,
+int mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int random_len, int bytes,
opaque * ret);
-int _gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
+int mhd_gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
int second_len, int ret_len, opaque * ret);
-void _gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
+void mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
opaque * key, uint32_t key_size);
-GNUTLS_HASH_HANDLE _gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
+GNUTLS_HASH_HANDLE mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
#endif /* GNUTLS_HASH_INT_H */
diff --git a/src/daemon/https/tls/gnutls_int.h b/src/daemon/https/tls/gnutls_int.h
@@ -128,7 +128,13 @@ typedef enum handshake_state_t
STATE70, STATE71
} handshake_state_t;
-#include <gnutls_buffer.h>
+#include <gnutls_str.h>
+
+typedef mhd_gtls_string mhd_gtls_buffer;
+
+#define mhd_gtls_buffer_init(buf) mhd_gtls_string_init(buf, gnutls_malloc, gnutls_realloc, gnutls_free);
+#define mhd_gtls_buffer_clear mhd_gtls_string_clear
+#define mhd_gtls_buffer_append mhd_gtls_string_append_data
/* This is the maximum number of algorithms (ciphers or macs etc).
* keep it synced with GNUTLS_MAX_ALGORITHM_NUM in gnutls.h
@@ -175,17 +181,17 @@ typedef void (*LOG_FUNC)(int,
const char *);
/* Store & Retrieve functions defines: */
-typedef struct auth_cred_st
+typedef struct mhd_gtls_auth_cred_st
{
gnutls_credentials_type_t algorithm;
/* the type of credentials depends on algorithm
*/
void *credentials;
- struct auth_cred_st *next;
+ struct mhd_gtls_auth_cred_st *next;
} auth_cred_st;
-struct gnutls_key_st
+struct mhd_gtls_key
{
/* For DH KX */
gnutls_datum_t key;
@@ -229,7 +235,7 @@ struct gnutls_key_st
* for a client certificate verify
*/
};
-typedef struct gnutls_key_st *gnutls_key_st;
+typedef struct mhd_gtls_key * mhd_gtls_key_st;
/* STATE (cont) */
#include <gnutls_hash_int.h>
@@ -276,7 +282,7 @@ typedef struct
uint16_t oprfi_client_len;
opaque *oprfi_server;
uint16_t oprfi_server_len;
- } tls_ext_st;
+ } mhd_gtls_ext_st;
/* This flag indicates for an extension whether
* it is useful to application level or TLS level only.
@@ -288,7 +294,7 @@ typedef enum tls_ext_parse_type_t
EXTENSION_ANY,
EXTENSION_APPLICATION,
EXTENSION_TLS
- } tls_ext_parse_type_t;
+ } mhd_gtls_ext_parse_type_t;
/* auth_info_t structures now MAY contain malloced
* elements.
@@ -335,7 +341,7 @@ typedef struct
opaque session_id[TLS_MAX_SESSION_ID_SIZE];
uint8_t session_id_size;
time_t timestamp;
- tls_ext_st extensions;
+ mhd_gtls_ext_st extensions;
/* The send size is the one requested by the programmer.
* The recv size is the one negotiated with the peer.
@@ -347,7 +353,7 @@ typedef struct
gnutls_protocol_t version; /* moved here */
/* For TLS/IA. XXX: Move to IA credential? */
opaque inner_secret[TLS_MASTER_SIZE];
- } security_parameters_st;
+ } mhd_gtls_security_param_st;
/* This structure holds the generated keys
*/
@@ -363,7 +369,7 @@ typedef struct
* been generated. Non zero
* otherwise.
*/
- } cipher_specs_st;
+ } mhd_gtls_cipher_specs_st;
typedef struct
{
@@ -375,25 +381,25 @@ typedef struct
gnutls_datum_t write_mac_secret;
uint64 read_sequence_number;
uint64 write_sequence_number;
- } conn_stat_st;
+ } mhd_gtls_conn_stat_st;
typedef struct
{
unsigned int priority[MAX_ALGOS];
unsigned int num_algorithms;
- } priority_st;
+ } mhd_gtls_priority_st;
/* For the external api */
-struct gnutls_priority_st
+struct MHD_gtls_priority_st
{
- priority_st cipher;
- priority_st mac;
- priority_st kx;
- priority_st compression;
- priority_st protocol;
+ mhd_gtls_priority_st cipher;
+ mhd_gtls_priority_st mac;
+ mhd_gtls_priority_st kx;
+ mhd_gtls_priority_st compression;
+ mhd_gtls_priority_st protocol;
/* certificate type : x509, OpenPGP, etc. */
- priority_st cert_type;
+ mhd_gtls_priority_st cert_type;
/* to disable record padding */
int no_padding;
@@ -401,20 +407,20 @@ struct gnutls_priority_st
/* DH and RSA parameters types.
*/
-typedef struct gnutls_dh_params_int
+typedef struct MHD_gtls_dh_params_int
{
/* [0] is the prime, [1] is the generator.
*/
mpi_t params[2];
- } dh_params_st;
+ } mhd_gtls_dh_params_st;
typedef struct
{
- gnutls_dh_params_t dh_params;
+ mhd_gtls_dh_params_t dh_params;
int free_dh_params;
- gnutls_rsa_params_t rsa_params;
+ mhd_gtls_rsa_params_t rsa_params;
int free_rsa_params;
- } internal_params_st;
+ } mhd_gtls_internal_params_st;
typedef struct
{
@@ -424,18 +430,18 @@ typedef struct
/* this holds the length of the handshake packet */
size_t packet_length;
gnutls_handshake_description_t recv_type;
- } handshake_header_buffer_st;
+ } mhd_gtls_handshake_header_buffer_st;
typedef struct
{
- gnutls_buffer application_data_buffer; /* holds data to be delivered to application layer */
- gnutls_buffer handshake_hash_buffer; /* used to keep the last received handshake
+ mhd_gtls_buffer application_data_buffer; /* holds data to be delivered to application layer */
+ mhd_gtls_buffer handshake_hash_buffer; /* used to keep the last received handshake
* message */
mac_hd_t handshake_mac_handle_sha; /* hash of the handshake messages */
mac_hd_t handshake_mac_handle_md5; /* hash of the handshake messages */
- gnutls_buffer handshake_data_buffer; /* this is a buffer that holds the current handshake message */
- gnutls_buffer ia_data_buffer; /* holds inner application data (TLS/IA) */
+ mhd_gtls_buffer handshake_data_buffer; /* this is a buffer that holds the current handshake message */
+ mhd_gtls_buffer ia_data_buffer; /* holds inner application data (TLS/IA) */
resumable_session_t resumable; /* TRUE or FALSE - if we can resume that session */
handshake_state_t handshake_state; /* holds
* a number which indicates where
@@ -463,11 +469,11 @@ typedef struct
gnutls_compression_method_t compression_method;
/* priorities */
- struct gnutls_priority_st priorities;
+ struct MHD_gtls_priority_st priorities;
/* resumed session */
resumable_session_t resumed; /* RESUME_TRUE or FALSE - if we are resuming a session */
- security_parameters_st resumed_security_parameters;
+ mhd_gtls_security_param_st resumed_security_parameters;
/* sockets internals */
int lowat;
@@ -475,19 +481,19 @@ typedef struct
/* These buffers are used in the handshake
* protocol only. freed using _gnutls_handshake_io_buffer_clear();
*/
- gnutls_buffer handshake_send_buffer;
+ mhd_gtls_buffer handshake_send_buffer;
size_t handshake_send_buffer_prev_size;
content_type_t handshake_send_buffer_type;
gnutls_handshake_description_t handshake_send_buffer_htype;
content_type_t handshake_recv_buffer_type;
gnutls_handshake_description_t handshake_recv_buffer_htype;
- gnutls_buffer handshake_recv_buffer;
+ mhd_gtls_buffer handshake_recv_buffer;
/* this buffer holds a record packet -mostly used for
* non blocking IO.
*/
- gnutls_buffer record_recv_buffer;
- gnutls_buffer record_send_buffer; /* holds cached data
+ mhd_gtls_buffer record_recv_buffer;
+ mhd_gtls_buffer record_send_buffer; /* holds cached data
* for the gnutls_io_write_buffered()
* function.
*/
@@ -504,7 +510,7 @@ typedef struct
int have_peeked_data;
int expire_time; /* after expire_time seconds this session will expire */
- struct mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
+ struct mhd_gtls_mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
/* TODO rm */
int v2_hello; /* 0 if the client hello is v3+.
@@ -512,7 +518,7 @@ typedef struct
*/
/* keeps the headers of the handshake packet
*/
- handshake_header_buffer_st handshake_header_buffer;
+ mhd_gtls_handshake_header_buffer_st handshake_header_buffer;
/* this is the highest version available
* to the peer. (advertized version).
@@ -529,7 +535,7 @@ typedef struct
int send_cert_req;
/* bits to use for DHE and DHA
- * use _gnutls_dh_get_prime_bits() and gnutls_dh_set_prime_bits()
+ * use _gnutls_dh_get_prime_bits() and MHD_gnutls_dh_set_prime_bits()
* to access it.
*/
uint16_t dh_prime_bits;
@@ -538,22 +544,14 @@ typedef struct
/* PUSH & PULL functions.
*/
- gnutls_pull_func _gnutls_pull_func;
- gnutls_push_func _gnutls_push_func;
+ mhd_gtls_pull_func _gnutls_pull_func;
+ mhd_gtls_push_func _gnutls_push_func;
/* Holds the first argument of PUSH and PULL
* functions;
*/
gnutls_transport_ptr_t transport_recv_ptr;
gnutls_transport_ptr_t transport_send_ptr;
- /* STORE & RETRIEVE functions. Only used if other
- * backend than gdbm is used.
- */
- gnutls_db_store_func db_store_func;
- gnutls_db_retr_func db_retrieve_func;
- gnutls_db_remove_func db_remove_func;
- void *db_ptr;
-
/* post client hello callback (server side only)
*/
gnutls_handshake_post_client_hello_func user_hello_func;
@@ -564,7 +562,7 @@ typedef struct
uint16_t proposed_record_size;
/* holds the selected certificate and key.
- * use _gnutls_selected_certs_deinit() and _gnutls_selected_certs_set()
+ * use mhd_gtls_selected_certs_deinit() and mhd_gtls_selected_certs_set()
* to change them.
*/
gnutls_cert *selected_cert_list;
@@ -604,7 +602,7 @@ typedef struct
/* This callback will be used (if set) to receive an
* openpgp key. (if the peer sends a fingerprint)
*/
- gnutls_openpgp_recv_key_func openpgp_recv_key_func;
+ mhd_gtls_openpgp_recv_key_func openpgp_recv_key_func;
/* If non zero the server will not advertize the CA's he
* trusts (do not send an RDN sequence).
@@ -624,7 +622,7 @@ typedef struct
* credentials structure, or from a callback. That is to
* minimize external calls.
*/
- internal_params_st params;
+ mhd_gtls_internal_params_st params;
/* This buffer is used by the record recv functions,
* as a temporary store buffer.
@@ -633,7 +631,7 @@ typedef struct
/* To avoid using global variables, and especially on Windows where
* the application may use a different errno variable than GnuTLS,
- * it is possible to use gnutls_transport_set_errno to set a
+ * it is possible to use MHD_gnutls_transport_set_errno to set a
* session-specific errno variable in the user-replaceable push/pull
* functions. This value is used by the send/recv functions. (The
* strange name of this variable is because 'errno' is typically
@@ -643,28 +641,28 @@ typedef struct
/* Function used to perform public-key signing operation during
handshake. Used by gnutls_sig.c:_gnutls_tls_sign(), see also
- gnutls_sign_callback_set(). */
+ MHD_gtls_sign_callback_set(). */
gnutls_sign_func sign_func;
void *sign_func_userdata;
- /* If you add anything here, check _gnutls_handshake_internal_state_clear().
+ /* If you add anything here, check mhd_gtls_handshake_internal_state_clear().
*/
- } internals_st;
+ } mhd_gtls_internals_st;
-struct gnutls_session_int
+struct MHD_gtls_session_int
{
- security_parameters_st security_parameters;
- cipher_specs_st cipher_specs;
- conn_stat_st connection_state;
- internals_st internals;
- gnutls_key_st key;
+ mhd_gtls_security_param_st security_parameters;
+ mhd_gtls_cipher_specs_st cipher_specs;
+ mhd_gtls_conn_stat_st connection_state;
+ mhd_gtls_internals_st internals;
+ mhd_gtls_key_st key;
};
/* functions */
-void _gnutls_set_current_version(gnutls_session_t session,
+void mhd_gtls_set_current_version(mhd_gtls_session_t session,
gnutls_protocol_t version);
-void _gnutls_free_auth_info(gnutls_session_t session);
+void mhd_gtls_free_auth_info(mhd_gtls_session_t session);
/* These two macros return the advertized TLS version of
* the peer.
@@ -679,8 +677,8 @@ void _gnutls_free_auth_info(gnutls_session_t session);
session->internals.adv_version_major = major; \
session->internals.adv_version_minor = minor
-void _gnutls_set_adv_version(gnutls_session_t,
+void mhd_gtls_set_adv_version(mhd_gtls_session_t,
gnutls_protocol_t);
-gnutls_protocol_t _gnutls_get_adv_version(gnutls_session_t);
+gnutls_protocol_t mhd_gtls_get_adv_version(mhd_gtls_session_t);
#endif /* GNUTLS_INT_H */
diff --git a/src/daemon/https/tls/gnutls_kx.c b/src/daemon/https/tls/gnutls_kx.c
@@ -23,7 +23,7 @@
*/
/* This file contains functions which are wrappers for the key exchange
- * part of TLS. They are called by the handshake functions (gnutls_handshake)
+ * part of TLS. They are called by the handshake functions (MHD_gnutls_handshake)
*/
#include "gnutls_int.h"
@@ -42,10 +42,10 @@
*/
#define MASTER_SECRET "master secret"
-static int generate_normal_master (gnutls_session_t session, int);
+static int generate_normal_master (mhd_gtls_session_t session, int);
int
-_gnutls_generate_master (gnutls_session_t session, int keep_premaster)
+mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster)
{
if (session->internals.resumed == RESUME_FALSE)
return generate_normal_master (session, keep_premaster);
@@ -56,22 +56,22 @@ _gnutls_generate_master (gnutls_session_t session, int keep_premaster)
*/
#define PREMASTER session->key->key
static int
-generate_normal_master (gnutls_session_t session, int keep_premaster)
+generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
{
int ret = 0;
char buf[512];
_gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
- _gnutls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
+ mhd_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
sizeof (buf)));
_gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
- _gnutls_bin2hex (session->security_parameters.
+ mhd_gtls_bin2hex (session->security_parameters.
client_random, 32, buf, sizeof (buf)));
_gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
- _gnutls_bin2hex (session->security_parameters.
+ mhd_gtls_bin2hex (session->security_parameters.
server_random, 32, buf, sizeof (buf)));
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
{
opaque rnd[2 * TLS_RANDOM_SIZE + 1];
@@ -81,7 +81,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
session->security_parameters.server_random, TLS_RANDOM_SIZE);
ret =
- _gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
+ mhd_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
rnd, 2 * TLS_RANDOM_SIZE,
TLS_MASTER_SIZE,
session->security_parameters.
@@ -107,7 +107,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
_gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
session->security_parameters.
extensions.oprfi_server_len,
- _gnutls_bin2hex (session->security_parameters.
+ mhd_gtls_bin2hex (session->security_parameters.
extensions.oprfi_client,
session->security_parameters.
extensions.oprfi_client_len,
@@ -115,7 +115,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
_gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
session->security_parameters.
extensions.oprfi_server_len,
- _gnutls_bin2hex (session->security_parameters.
+ mhd_gtls_bin2hex (session->security_parameters.
extensions.oprfi_server,
session->security_parameters.
extensions.oprfi_server_len,
@@ -135,7 +135,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
session->security_parameters.extensions.oprfi_server,
session->security_parameters.extensions.oprfi_server_len);
- ret = _gnutls_PRF (session, PREMASTER.data, PREMASTER.size,
+ ret = mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
MASTER_SECRET, strlen (MASTER_SECRET),
rnd, rndlen, TLS_MASTER_SIZE,
session->security_parameters.master_secret);
@@ -152,7 +152,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
session->security_parameters.server_random, TLS_RANDOM_SIZE);
ret =
- _gnutls_PRF (session, PREMASTER.data, PREMASTER.size,
+ mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
MASTER_SECRET, strlen (MASTER_SECRET),
rnd, 2 * TLS_RANDOM_SIZE, TLS_MASTER_SIZE,
session->security_parameters.master_secret);
@@ -169,7 +169,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
return ret;
_gnutls_hard_log ("INT: MASTER SECRET: %s\n",
- _gnutls_bin2hex (session->security_parameters.
+ mhd_gtls_bin2hex (session->security_parameters.
master_secret, TLS_MASTER_SIZE, buf,
sizeof (buf)));
@@ -182,13 +182,13 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
* by the selected ciphersuite.
*/
int
-_gnutls_send_server_kx_message (gnutls_session_t session, int again)
+mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
int ret = 0;
- if (session->internals.auth_struct->gnutls_generate_server_kx == NULL)
+ if (session->internals.auth_struct->mhd_gtls_gen_server_kx == NULL)
return 0;
data = NULL;
@@ -198,7 +198,7 @@ _gnutls_send_server_kx_message (gnutls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
- gnutls_generate_server_kx (session, &data);
+ mhd_gtls_gen_server_kx (session, &data);
if (data_size == GNUTLS_E_INT_RET_0)
{
@@ -214,7 +214,7 @@ _gnutls_send_server_kx_message (gnutls_session_t session, int again)
}
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE);
gnutls_free (data);
@@ -230,14 +230,14 @@ _gnutls_send_server_kx_message (gnutls_session_t session, int again)
* client.
*/
int
-_gnutls_send_server_certificate_request (gnutls_session_t session, int again)
+mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
int ret = 0;
if (session->internals.auth_struct->
- gnutls_generate_server_certificate_request == NULL)
+ mhd_gtls_gen_server_certificate_request == NULL)
return 0;
if (session->internals.send_cert_req <= 0)
@@ -250,7 +250,7 @@ _gnutls_send_server_certificate_request (gnutls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
- gnutls_generate_server_certificate_request (session, &data);
+ mhd_gtls_gen_server_certificate_request (session, &data);
if (data_size < 0)
{
@@ -259,7 +259,7 @@ _gnutls_send_server_certificate_request (gnutls_session_t session, int again)
}
}
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST);
gnutls_free (data);
@@ -276,13 +276,13 @@ _gnutls_send_server_certificate_request (gnutls_session_t session, int again)
* exchange message
*/
int
-_gnutls_send_client_kx_message (gnutls_session_t session, int again)
+mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
{
uint8_t *data;
int data_size;
int ret = 0;
- if (session->internals.auth_struct->gnutls_generate_client_kx == NULL)
+ if (session->internals.auth_struct->mhd_gtls_gen_client_kx == NULL)
return 0;
@@ -293,7 +293,7 @@ _gnutls_send_client_kx_message (gnutls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
- gnutls_generate_client_kx (session, &data);
+ mhd_gtls_gen_client_kx (session, &data);
if (data_size < 0)
{
gnutls_assert ();
@@ -301,7 +301,7 @@ _gnutls_send_client_kx_message (gnutls_session_t session, int again)
}
}
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE);
gnutls_free (data);
@@ -319,7 +319,7 @@ _gnutls_send_client_kx_message (gnutls_session_t session, int again)
* verify message
*/
int
-_gnutls_send_client_certificate_verify (gnutls_session_t session, int again)
+mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session, int again)
{
uint8_t *data;
int ret = 0;
@@ -335,7 +335,7 @@ _gnutls_send_client_certificate_verify (gnutls_session_t session, int again)
if (session->key->certificate_requested == 0)
return 0;
- if (session->internals.auth_struct->gnutls_generate_client_cert_vrfy ==
+ if (session->internals.auth_struct->mhd_gtls_gen_client_cert_vrfy ==
NULL)
{
gnutls_assert ();
@@ -350,7 +350,7 @@ _gnutls_send_client_certificate_verify (gnutls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
- gnutls_generate_client_cert_vrfy (session, &data);
+ mhd_gtls_gen_client_cert_vrfy (session, &data);
if (data_size < 0)
{
gnutls_assert ();
@@ -361,7 +361,7 @@ _gnutls_send_client_certificate_verify (gnutls_session_t session, int again)
}
ret =
- _gnutls_send_handshake (session, data,
+ mhd_gtls_send_handshake (session, data,
data_size, GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY);
gnutls_free (data);
@@ -370,18 +370,18 @@ _gnutls_send_client_certificate_verify (gnutls_session_t session, int again)
int
-_gnutls_recv_server_kx_message (gnutls_session_t session)
+mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session)
{
uint8_t *data = NULL;
int datasize;
int ret = 0;
- if (session->internals.auth_struct->gnutls_process_server_kx != NULL)
+ if (session->internals.auth_struct->mhd_gtls_process_server_kx != NULL)
{
/* EXCEPTION FOR RSA_EXPORT cipher suite
*/
- if (_gnutls_session_is_export (session) != 0 &&
+ if (mhd_gtls_session_is_export (session) != 0 &&
_gnutls_peers_cert_less_512 (session) != 0)
{
gnutls_assert ();
@@ -389,7 +389,7 @@ _gnutls_recv_server_kx_message (gnutls_session_t session)
}
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE,
MANDATORY_PACKET);
@@ -401,7 +401,7 @@ _gnutls_recv_server_kx_message (gnutls_session_t session)
ret =
session->internals.auth_struct->
- gnutls_process_server_kx (session, data, datasize);
+ mhd_gtls_process_server_kx (session, data, datasize);
gnutls_free (data);
if (ret < 0)
@@ -415,18 +415,18 @@ _gnutls_recv_server_kx_message (gnutls_session_t session)
}
int
-_gnutls_recv_server_certificate_request (gnutls_session_t session)
+mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
{
uint8_t *data;
int datasize;
int ret = 0;
if (session->internals.auth_struct->
- gnutls_process_server_certificate_request != NULL)
+ mhd_gtls_process_server_certificate_request != NULL)
{
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST,
OPTIONAL_PACKET);
@@ -438,7 +438,7 @@ _gnutls_recv_server_certificate_request (gnutls_session_t session)
ret =
session->internals.auth_struct->
- gnutls_process_server_certificate_request (session, data, datasize);
+ mhd_gtls_process_server_certificate_request (session, data, datasize);
gnutls_free (data);
if (ret < 0)
return ret;
@@ -448,7 +448,7 @@ _gnutls_recv_server_certificate_request (gnutls_session_t session)
}
int
-_gnutls_recv_client_kx_message (gnutls_session_t session)
+mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
{
uint8_t *data;
int datasize;
@@ -456,11 +456,11 @@ _gnutls_recv_client_kx_message (gnutls_session_t session)
/* Do key exchange only if the algorithm permits it */
- if (session->internals.auth_struct->gnutls_process_client_kx != NULL)
+ if (session->internals.auth_struct->mhd_gtls_process_client_kx != NULL)
{
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE,
MANDATORY_PACKET);
@@ -469,7 +469,7 @@ _gnutls_recv_client_kx_message (gnutls_session_t session)
ret =
session->internals.auth_struct->
- gnutls_process_client_kx (session, data, datasize);
+ mhd_gtls_process_client_kx (session, data, datasize);
gnutls_free (data);
if (ret < 0)
return ret;
@@ -483,7 +483,7 @@ _gnutls_recv_client_kx_message (gnutls_session_t session)
/* This is called when we want send our certificate
*/
int
-_gnutls_send_client_certificate (gnutls_session_t session, int again)
+mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
@@ -494,7 +494,7 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
return 0;
if (session->internals.auth_struct->
- gnutls_generate_client_certificate == NULL)
+ mhd_gtls_gen_client_certificate == NULL)
return 0;
data = NULL;
@@ -502,14 +502,14 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
if (again == 0)
{
- if (gnutls_protocol_get_version (session) != MHD_GNUTLS_SSL3 ||
+ if (MHD_gnutls_protocol_get_version (session) != MHD_GNUTLS_SSL3 ||
session->internals.selected_cert_list_length > 0)
{
/* TLS 1.0 or SSL 3.0 with a valid certificate
*/
data_size =
session->internals.auth_struct->
- gnutls_generate_client_certificate (session, &data);
+ mhd_gtls_gen_client_certificate (session, &data);
if (data_size < 0)
{
@@ -523,11 +523,11 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
* no certificate alert instead of an
* empty certificate.
*/
- if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
+ if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
session->internals.selected_cert_list_length == 0)
{
ret =
- gnutls_alert_send (session, GNUTLS_AL_WARNING,
+ MHD_gnutls_alert_send (session, GNUTLS_AL_WARNING,
GNUTLS_A_SSL3_NO_CERTIFICATE);
}
@@ -535,7 +535,7 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
{ /* TLS 1.0 or SSL 3.0 with a valid certificate
*/
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
gnutls_free (data);
}
@@ -553,7 +553,7 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
/* This is called when we want send our certificate
*/
int
-_gnutls_send_server_certificate (gnutls_session_t session, int again)
+mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
@@ -561,7 +561,7 @@ _gnutls_send_server_certificate (gnutls_session_t session, int again)
if (session->internals.auth_struct->
- gnutls_generate_server_certificate == NULL)
+ mhd_gtls_gen_server_certificate == NULL)
return 0;
data = NULL;
@@ -571,7 +571,7 @@ _gnutls_send_server_certificate (gnutls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
- gnutls_generate_server_certificate (session, &data);
+ mhd_gtls_gen_server_certificate (session, &data);
if (data_size < 0)
{
@@ -580,7 +580,7 @@ _gnutls_send_server_certificate (gnutls_session_t session, int again)
}
}
ret =
- _gnutls_send_handshake (session, data, data_size,
+ mhd_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
gnutls_free (data);
@@ -595,7 +595,7 @@ _gnutls_send_server_certificate (gnutls_session_t session, int again)
int
-_gnutls_recv_client_certificate (gnutls_session_t session)
+mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
{
int datasize;
opaque *data;
@@ -603,7 +603,7 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
int optional;
if (session->internals.auth_struct->
- gnutls_process_client_certificate != NULL)
+ mhd_gtls_process_client_certificate != NULL)
{
/* if we have not requested a certificate then just return
@@ -619,7 +619,7 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
optional = OPTIONAL_PACKET;
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT, optional);
@@ -631,7 +631,7 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
*/
if (optional == OPTIONAL_PACKET &&
ret == GNUTLS_E_WARNING_ALERT_RECEIVED &&
- gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
+ MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
{
@@ -666,7 +666,7 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
}
ret =
session->internals.auth_struct->
- gnutls_process_client_certificate (session, data, datasize);
+ mhd_gtls_process_client_certificate (session, data, datasize);
gnutls_free (data);
if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
@@ -688,18 +688,18 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
}
int
-_gnutls_recv_server_certificate (gnutls_session_t session)
+mhd_gtls_recv_server_certificate (mhd_gtls_session_t session)
{
int datasize;
opaque *data;
int ret = 0;
if (session->internals.auth_struct->
- gnutls_process_server_certificate != NULL)
+ mhd_gtls_process_server_certificate != NULL)
{
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT,
MANDATORY_PACKET);
@@ -711,7 +711,7 @@ _gnutls_recv_server_certificate (gnutls_session_t session)
ret =
session->internals.auth_struct->
- gnutls_process_server_certificate (session, data, datasize);
+ mhd_gtls_process_server_certificate (session, data, datasize);
gnutls_free (data);
if (ret < 0)
{
@@ -728,14 +728,14 @@ _gnutls_recv_server_certificate (gnutls_session_t session)
* arrive if the peer did not send us a certificate.
*/
int
-_gnutls_recv_client_certificate_verify_message (gnutls_session_t session)
+mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
{
uint8_t *data;
int datasize;
int ret = 0;
- if (session->internals.auth_struct->gnutls_process_client_cert_vrfy != NULL)
+ if (session->internals.auth_struct->mhd_gtls_process_client_cert_vrfy != NULL)
{
if (session->internals.send_cert_req == 0 ||
@@ -745,7 +745,7 @@ _gnutls_recv_client_certificate_verify_message (gnutls_session_t session)
}
ret =
- _gnutls_recv_handshake (session, &data,
+ mhd_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY,
OPTIONAL_PACKET);
@@ -762,7 +762,7 @@ _gnutls_recv_client_certificate_verify_message (gnutls_session_t session)
ret =
session->internals.auth_struct->
- gnutls_process_client_cert_vrfy (session, data, datasize);
+ mhd_gtls_process_client_cert_vrfy (session, data, datasize);
gnutls_free (data);
if (ret < 0)
return ret;
diff --git a/src/daemon/https/tls/gnutls_kx.h b/src/daemon/https/tls/gnutls_kx.h
@@ -22,18 +22,18 @@
*
*/
-int _gnutls_send_server_kx_message (gnutls_session_t session, int again);
-int _gnutls_send_client_kx_message (gnutls_session_t session, int again);
-int _gnutls_recv_server_kx_message (gnutls_session_t session);
-int _gnutls_recv_client_kx_message (gnutls_session_t session);
-int _gnutls_send_client_certificate_verify (gnutls_session_t session,
+int mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again);
+int mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again);
+int mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session);
+int mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session);
+int mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
int again);
-int _gnutls_send_server_certificate (gnutls_session_t session, int again);
-int _gnutls_generate_master (gnutls_session_t session, int keep_premaster);
-int _gnutls_recv_client_certificate (gnutls_session_t session);
-int _gnutls_recv_server_certificate (gnutls_session_t session);
-int _gnutls_send_client_certificate (gnutls_session_t session, int again);
-int _gnutls_recv_server_certificate_request (gnutls_session_t session);
-int _gnutls_send_server_certificate_request (gnutls_session_t session,
+int mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again);
+int mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster);
+int mhd_gtls_recv_client_certificate (mhd_gtls_session_t session);
+int mhd_gtls_recv_server_certificate (mhd_gtls_session_t session);
+int mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again);
+int mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session);
+int mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
int again);
-int _gnutls_recv_client_certificate_verify_message (gnutls_session_t session);
+int mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session);
diff --git a/src/daemon/https/tls/gnutls_mem.c b/src/daemon/https/tls/gnutls_mem.c
@@ -32,7 +32,7 @@ gnutls_free_function gnutls_free = free;
gnutls_realloc_function gnutls_realloc = realloc;
void *(*gnutls_calloc) (size_t, size_t) = calloc;
-char *(*gnutls_strdup) (const char *) = _gnutls_strdup;
+char *(*gnutls_strdup) (const char *) = mhd_gtls_strdup;
int
_gnutls_is_secure_mem_null (const void *ign)
@@ -44,7 +44,7 @@ int (*_gnutls_is_secure_memory) (const void *) = _gnutls_is_secure_mem_null;
void *
-_gnutls_calloc (size_t nmemb, size_t size)
+mhd_gtls_calloc (size_t nmemb, size_t size)
{
void *ret;
size *= nmemb;
@@ -55,7 +55,7 @@ _gnutls_calloc (size_t nmemb, size_t size)
}
svoid *
-gnutls_secure_calloc (size_t nmemb, size_t size)
+mhd_gtls_secure_calloc (size_t nmemb, size_t size)
{
svoid *ret;
size *= nmemb;
@@ -69,7 +69,7 @@ gnutls_secure_calloc (size_t nmemb, size_t size)
* fails.
*/
void *
-gnutls_realloc_fast (void *ptr, size_t size)
+mhd_gtls_realloc_fast (void *ptr, size_t size)
{
void *ret;
@@ -86,7 +86,7 @@ gnutls_realloc_fast (void *ptr, size_t size)
}
char *
-_gnutls_strdup (const char *str)
+mhd_gtls_strdup (const char *str)
{
size_t siz = strlen (str) + 1;
char *ret;
@@ -109,7 +109,7 @@ _gnutls_strdup (const char *str)
* return a pointer to memory. This function is supposed
* to be used by callbacks.
*
- * The allocation function used is the one set by gnutls_global_set_mem_functions().
+ * The allocation function used is the one set by MHD_gtls_global_set_mem_functions().
*
**/
void *
@@ -123,7 +123,7 @@ gnutls_malloc (size_t s)
*
* This function will free data pointed by ptr.
*
- * The deallocation function used is the one set by gnutls_global_set_mem_functions().
+ * The deallocation function used is the one set by MHD_gtls_global_set_mem_functions().
*
**/
void
diff --git a/src/daemon/https/tls/gnutls_mem.h b/src/daemon/https/tls/gnutls_mem.h
@@ -60,11 +60,11 @@ extern int (*_gnutls_is_secure_memory) (const void *);
/* this realloc function will return ptr if size==0, and
* will free the ptr if the new allocation failed.
*/
-void *gnutls_realloc_fast (void *ptr, size_t size);
+void * mhd_gtls_realloc_fast (void *ptr, size_t size);
-svoid *gnutls_secure_calloc (size_t nmemb, size_t size);
+svoid * mhd_gtls_secure_calloc (size_t nmemb, size_t size);
-void *_gnutls_calloc (size_t nmemb, size_t size);
-char *_gnutls_strdup (const char *);
+void * mhd_gtls_calloc (size_t nmemb, size_t size);
+char * mhd_gtls_strdup (const char *);
#endif /* GNUTLS_MEM_H */
diff --git a/src/daemon/https/tls/gnutls_mpi.c b/src/daemon/https/tls/gnutls_mpi.c
@@ -35,7 +35,7 @@
*/
void
-_gnutls_mpi_release (mpi_t * x)
+mhd_gtls_mpi_release (mpi_t * x)
{
if (*x == NULL)
return;
@@ -46,7 +46,7 @@ _gnutls_mpi_release (mpi_t * x)
/* returns zero on success
*/
int
-_gnutls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
+mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
{
int ret;
@@ -60,7 +60,7 @@ _gnutls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
/* returns zero on success. Fails if the number is zero.
*/
int
-_gnutls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
+mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
{
int ret;
@@ -72,7 +72,7 @@ _gnutls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
*/
if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
{
- _gnutls_mpi_release (ret_mpi);
+ mhd_gtls_mpi_release (ret_mpi);
return GNUTLS_E_MPI_SCAN_FAILED;
}
@@ -80,7 +80,7 @@ _gnutls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
}
int
-_gnutls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
+mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
{
int ret;
ret = gcry_mpi_scan (ret_mpi, GCRYMPI_FMT_PGP, buffer, *nbytes, nbytes);
@@ -91,7 +91,7 @@ _gnutls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
*/
if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
{
- _gnutls_mpi_release (ret_mpi);
+ mhd_gtls_mpi_release (ret_mpi);
return GNUTLS_E_MPI_SCAN_FAILED;
}
@@ -99,7 +99,7 @@ _gnutls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
}
int
-_gnutls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
+mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
{
int ret;
@@ -115,7 +115,7 @@ _gnutls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
/* Always has the first bit zero */
int
-_gnutls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
+mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
{
int ret;
@@ -131,7 +131,7 @@ _gnutls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
/* Always has the first bit zero */
int
-_gnutls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
+mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
{
int ret;
opaque *buf = NULL;
@@ -160,7 +160,7 @@ _gnutls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
}
int
-_gnutls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
+mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
{
int ret;
opaque *buf = NULL;
@@ -225,7 +225,7 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
}
s_len = tmpstr_size;
- if (_gnutls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
+ if (mhd_gtls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
{
gnutls_assert ();
gnutls_afree (tmpstr);
@@ -248,9 +248,9 @@ _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
s_len = 0;
if (lz)
- result = _gnutls_mpi_print_lz (NULL, &s_len, mpi);
+ result = mhd_gtls_mpi_print_lz (NULL, &s_len, mpi);
else
- result = _gnutls_mpi_print (NULL, &s_len, mpi);
+ result = mhd_gtls_mpi_print (NULL, &s_len, mpi);
tmpstr = gnutls_alloca (s_len);
if (tmpstr == NULL)
@@ -260,9 +260,9 @@ _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
}
if (lz)
- result = _gnutls_mpi_print_lz (tmpstr, &s_len, mpi);
+ result = mhd_gtls_mpi_print_lz (tmpstr, &s_len, mpi);
else
- result = _gnutls_mpi_print (tmpstr, &s_len, mpi);
+ result = mhd_gtls_mpi_print (tmpstr, &s_len, mpi);
if (result != 0)
{
diff --git a/src/daemon/https/tls/gnutls_mpi.h b/src/daemon/https/tls/gnutls_mpi.h
@@ -60,19 +60,19 @@ typedef gcry_mpi_t mpi_t;
#define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(_gnutls_mpi_get_nbits(x))
#define _gnutls_mpi_salloc_like(x) _gnutls_mpi_snew(_gnutls_mpi_get_nbits(x))
-void _gnutls_mpi_release (mpi_t * x);
+void mhd_gtls_mpi_release (mpi_t * x);
-int _gnutls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
+int mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
-int _gnutls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
+int mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
-int _gnutls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
+int mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
-int _gnutls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
-int _gnutls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
+int mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
+int mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
-int _gnutls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a);
-int _gnutls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a);
+int mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a);
+int mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a);
#endif
diff --git a/src/daemon/https/tls/gnutls_num.c b/src/daemon/https/tls/gnutls_num.c
@@ -35,7 +35,7 @@
* has been reached.
*/
int
-_gnutls_uint64pp (uint64 * x)
+mhd_gtls_uint64pp (uint64 * x)
{
register int i, y = 0;
@@ -60,7 +60,7 @@ _gnutls_uint64pp (uint64 * x)
}
uint32_t
-_gnutls_uint24touint32 (uint24 num)
+mhd_gtls_uint24touint32 (uint24 num)
{
uint32_t ret = 0;
@@ -71,7 +71,7 @@ _gnutls_uint24touint32 (uint24 num)
}
uint24
-_gnutls_uint32touint24 (uint32_t num)
+mhd_gtls_uint32touint24 (uint32_t num)
{
uint24 ret;
@@ -84,7 +84,7 @@ _gnutls_uint32touint24 (uint32_t num)
/* data should be at least 3 bytes */
uint32_t
-_gnutls_read_uint24 (const opaque * data)
+mhd_gtls_read_uint24 (const opaque * data)
{
uint32_t res;
uint24 num;
@@ -93,7 +93,7 @@ _gnutls_read_uint24 (const opaque * data)
num.pint[1] = data[1];
num.pint[2] = data[2];
- res = _gnutls_uint24touint32 (num);
+ res = mhd_gtls_uint24touint32 (num);
#ifndef WORDS_BIGENDIAN
res = byteswap32 (res);
#endif
@@ -101,14 +101,14 @@ _gnutls_read_uint24 (const opaque * data)
}
void
-_gnutls_write_uint24 (uint32_t num, opaque * data)
+mhd_gtls_write_uint24 (uint32_t num, opaque * data)
{
uint24 tmp;
#ifndef WORDS_BIGENDIAN
num = byteswap32 (num);
#endif
- tmp = _gnutls_uint32touint24 (num);
+ tmp = mhd_gtls_uint32touint24 (num);
data[0] = tmp.pint[0];
data[1] = tmp.pint[1];
@@ -116,7 +116,7 @@ _gnutls_write_uint24 (uint32_t num, opaque * data)
}
uint32_t
-_gnutls_read_uint32 (const opaque * data)
+mhd_gtls_read_uint32 (const opaque * data)
{
uint32_t res;
@@ -128,7 +128,7 @@ _gnutls_read_uint32 (const opaque * data)
}
void
-_gnutls_write_uint32 (uint32_t num, opaque * data)
+mhd_gtls_write_uint32 (uint32_t num, opaque * data)
{
#ifndef WORDS_BIGENDIAN
@@ -138,7 +138,7 @@ _gnutls_write_uint32 (uint32_t num, opaque * data)
}
uint16_t
-_gnutls_read_uint16 (const opaque * data)
+mhd_gtls_read_uint16 (const opaque * data)
{
uint16_t res;
memcpy (&res, data, sizeof (uint16_t));
@@ -149,7 +149,7 @@ _gnutls_read_uint16 (const opaque * data)
}
void
-_gnutls_write_uint16 (uint16_t num, opaque * data)
+mhd_gtls_write_uint16 (uint16_t num, opaque * data)
{
#ifndef WORDS_BIGENDIAN
@@ -159,7 +159,7 @@ _gnutls_write_uint16 (uint16_t num, opaque * data)
}
uint32_t
-_gnutls_conv_uint32 (uint32_t data)
+mhd_gtls_conv_uint32 (uint32_t data)
{
#ifndef WORDS_BIGENDIAN
return byteswap32 (data);
@@ -169,7 +169,7 @@ _gnutls_conv_uint32 (uint32_t data)
}
uint16_t
-_gnutls_conv_uint16 (uint16_t data)
+mhd_gtls_conv_uint16 (uint16_t data)
{
#ifndef WORDS_BIGENDIAN
return byteswap16 (data);
@@ -179,7 +179,7 @@ _gnutls_conv_uint16 (uint16_t data)
}
uint32_t
-_gnutls_uint64touint32 (const uint64 * num)
+mhd_gtls_uint64touint32 (const uint64 * num)
{
uint32_t ret;
diff --git a/src/daemon/https/tls/gnutls_num.h b/src/daemon/https/tls/gnutls_num.h
@@ -32,18 +32,18 @@
#define byteswap16(x) ((rotl16(x, 8) & 0x00ff) | (rotr16(x, 8) & 0xff00))
#define byteswap32(x) ((rotl32(x, 8) & 0x00ff00ffUL) | (rotr32(x, 8) & 0xff00ff00UL))
-uint32_t _gnutls_uint24touint32 (uint24 num);
-uint24 _gnutls_uint32touint24 (uint32_t num);
-uint32_t _gnutls_read_uint32 (const opaque * data);
-uint16_t _gnutls_read_uint16 (const opaque * data);
-uint32_t _gnutls_conv_uint32 (uint32_t data);
-uint16_t _gnutls_conv_uint16 (uint16_t data);
-uint32_t _gnutls_read_uint24 (const opaque * data);
-void _gnutls_write_uint24 (uint32_t num, opaque * data);
-void _gnutls_write_uint32 (uint32_t num, opaque * data);
-void _gnutls_write_uint16 (uint16_t num, opaque * data);
-uint32_t _gnutls_uint64touint32 (const uint64 *);
+uint32_t mhd_gtls_uint24touint32 (uint24 num);
+uint24 mhd_gtls_uint32touint24 (uint32_t num);
+uint32_t mhd_gtls_read_uint32 (const opaque * data);
+uint16_t mhd_gtls_read_uint16 (const opaque * data);
+uint32_t mhd_gtls_conv_uint32 (uint32_t data);
+uint16_t mhd_gtls_conv_uint16 (uint16_t data);
+uint32_t mhd_gtls_read_uint24 (const opaque * data);
+void mhd_gtls_write_uint24 (uint32_t num, opaque * data);
+void mhd_gtls_write_uint32 (uint32_t num, opaque * data);
+void mhd_gtls_write_uint16 (uint16_t num, opaque * data);
+uint32_t mhd_gtls_uint64touint32 (const uint64 *);
-int _gnutls_uint64pp (uint64 *);
+int mhd_gtls_uint64pp (uint64 *);
# define _gnutls_uint64zero(x) x.i[0] = x.i[1] = x.i[2] = x.i[3] = x.i[4] = x.i[5] = x.i[6] = x.i[7] = 0
# define UINT64DATA(x) x.i
diff --git a/src/daemon/https/tls/gnutls_pk.c b/src/daemon/https/tls/gnutls_pk.c
@@ -54,7 +54,7 @@ static int _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
* params is modulus, public exp.
*/
int
-_gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
+mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
const gnutls_datum_t * plaintext,
mpi_t * params, unsigned params_len,
unsigned btype)
@@ -143,7 +143,7 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
ps[psize] = 0;
memcpy (&ps[psize + 1], plaintext->data, plaintext->size);
- if (_gnutls_mpi_scan_nz (&m, edata, &k) != 0)
+ if (mhd_gtls_mpi_scan_nz (&m, edata, &k) != 0)
{
gnutls_assert ();
gnutls_afree (edata);
@@ -156,7 +156,7 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
else /* sign */
ret = _gnutls_pk_sign (GCRY_PK_RSA, &res, m, params, params_len);
- _gnutls_mpi_release (&m);
+ mhd_gtls_mpi_release (&m);
if (ret < 0)
{
@@ -164,7 +164,7 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
return ret;
}
- _gnutls_mpi_print (NULL, &psize, res);
+ mhd_gtls_mpi_print (NULL, &psize, res);
if (psize < k)
{
@@ -180,7 +180,7 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
{ /* psize > k !!! */
/* This is an impossible situation */
gnutls_assert ();
- _gnutls_mpi_release (&res);
+ mhd_gtls_mpi_release (&res);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -188,16 +188,16 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
if (ciphertext->data == NULL)
{
gnutls_assert ();
- _gnutls_mpi_release (&res);
+ mhd_gtls_mpi_release (&res);
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_mpi_print (&ciphertext->data[pad], &psize, res);
+ mhd_gtls_mpi_print (&ciphertext->data[pad], &psize, res);
for (i = 0; i < pad; i++)
ciphertext->data[i] = 0;
ciphertext->size = k;
- _gnutls_mpi_release (&res);
+ mhd_gtls_mpi_release (&res);
return 0;
}
@@ -208,7 +208,7 @@ _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
* Can decrypt block type 1 and type 2 packets.
*/
int
-_gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
+mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
const gnutls_datum_t * ciphertext,
mpi_t * params, unsigned params_len,
unsigned btype)
@@ -232,7 +232,7 @@ _gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
return GNUTLS_E_PK_DECRYPTION_FAILED;
}
- if (_gnutls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
+ if (mhd_gtls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
@@ -247,7 +247,7 @@ _gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
{
ret = _gnutls_pk_encrypt (GCRY_PK_RSA, &res, c, params, params_len);
}
- _gnutls_mpi_release (&c);
+ mhd_gtls_mpi_release (&c);
if (ret < 0)
{
@@ -255,17 +255,17 @@ _gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
return ret;
}
- _gnutls_mpi_print (NULL, &esize, res);
+ mhd_gtls_mpi_print (NULL, &esize, res);
edata = gnutls_alloca (esize + 1);
if (edata == NULL)
{
gnutls_assert ();
- _gnutls_mpi_release (&res);
+ mhd_gtls_mpi_release (&res);
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_mpi_print (&edata[1], &esize, res);
+ mhd_gtls_mpi_print (&edata[1], &esize, res);
- _gnutls_mpi_release (&res);
+ mhd_gtls_mpi_release (&res);
/* EB = 00||BT||PS||00||D
* (use block type 'btype')
@@ -345,7 +345,7 @@ _gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
int
-_gnutls_rsa_verify (const gnutls_datum_t * vdata,
+mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * ciphertext, mpi_t * params,
int params_len, int btype)
{
@@ -355,7 +355,7 @@ _gnutls_rsa_verify (const gnutls_datum_t * vdata,
/* decrypt signature */
if ((ret =
- _gnutls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
+ mhd_gtls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
btype)) < 0)
{
gnutls_assert ();
@@ -433,7 +433,7 @@ encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
/* Do DSA signature calculation. params is p, q, g, y, x in that order.
*/
int
-_gnutls_dsa_sign (gnutls_datum_t * signature,
+mhd_gtls_dsa_sign (gnutls_datum_t * signature,
const gnutls_datum_t * hash, mpi_t * params,
unsigned params_len)
{
@@ -448,7 +448,7 @@ _gnutls_dsa_sign (gnutls_datum_t * signature,
return GNUTLS_E_PK_SIGN_FAILED;
}
- if (_gnutls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
+ if (mhd_gtls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
{
gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
@@ -456,7 +456,7 @@ _gnutls_dsa_sign (gnutls_datum_t * signature,
ret = _gnutls_pk_sign (GCRY_PK_DSA, rs, mdata, params, params_len);
/* rs[0], rs[1] now hold r,s */
- _gnutls_mpi_release (&mdata);
+ mhd_gtls_mpi_release (&mdata);
if (ret < 0)
{
@@ -467,8 +467,8 @@ _gnutls_dsa_sign (gnutls_datum_t * signature,
ret = encode_ber_rs (signature, rs[0], rs[1]);
/* free r,s */
- _gnutls_mpi_release (&rs[0]);
- _gnutls_mpi_release (&rs[1]);
+ mhd_gtls_mpi_release (&rs[0]);
+ mhd_gtls_mpi_release (&rs[1]);
if (ret != 0)
{
@@ -516,7 +516,7 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
if (result < 0)
{
gnutls_assert ();
- _gnutls_mpi_release (s);
+ mhd_gtls_mpi_release (s);
asn1_delete_structure (&sig);
return result;
}
@@ -529,7 +529,7 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
/* params is p, q, g, y in that order
*/
int
-_gnutls_dsa_verify (const gnutls_datum_t * vdata,
+mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * sig_value, mpi_t * params,
int params_len)
{
@@ -552,19 +552,19 @@ _gnutls_dsa_verify (const gnutls_datum_t * vdata,
}
k = vdata->size;
- if (_gnutls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
+ if (mhd_gtls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
{
gnutls_assert ();
- _gnutls_mpi_release (&rs[0]);
- _gnutls_mpi_release (&rs[1]);
+ mhd_gtls_mpi_release (&rs[0]);
+ mhd_gtls_mpi_release (&rs[1]);
return GNUTLS_E_MPI_SCAN_FAILED;
}
/* decrypt signature */
ret = _gnutls_pk_verify (GCRY_PK_DSA, mdata, rs, params, params_len);
- _gnutls_mpi_release (&mdata);
- _gnutls_mpi_release (&rs[0]);
- _gnutls_mpi_release (&rs[1]);
+ mhd_gtls_mpi_release (&mdata);
+ mhd_gtls_mpi_release (&rs[0]);
+ mhd_gtls_mpi_release (&rs[1]);
if (ret < 0)
{
diff --git a/src/daemon/https/tls/gnutls_pk.h b/src/daemon/https/tls/gnutls_pk.h
@@ -25,21 +25,21 @@
#ifndef GNUTLS_PK_H
#define GNUTLS_PK_H
-int _gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
+int mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
const gnutls_datum_t * plaintext,
mpi_t * params, unsigned params_len,
unsigned btype);
-int _gnutls_dsa_sign (gnutls_datum_t * signature,
+int mhd_gtls_dsa_sign (gnutls_datum_t * signature,
const gnutls_datum_t * plaintext, mpi_t * params,
unsigned params_len);
-int _gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
+int mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
const gnutls_datum_t * ciphertext,
mpi_t * params, unsigned params_len,
unsigned btype);
-int _gnutls_rsa_verify (const gnutls_datum_t * vdata,
+int mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * ciphertext, mpi_t * params,
int params_len, int btype);
-int _gnutls_dsa_verify (const gnutls_datum_t * vdata,
+int mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * sig_value, mpi_t * params,
int params_len);
diff --git a/src/daemon/https/tls/gnutls_priority.c b/src/daemon/https/tls/gnutls_priority.c
@@ -33,8 +33,8 @@
#define MAX_ELEMENTS 48
/**
- * gnutls_cipher_set_priority - Sets the priority on the ciphers supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_cipher_set_priority - Sets the priority on the ciphers supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_cipher_algorithm_t elements.
*
* Sets the priority on the ciphers supported by gnutls.
@@ -48,7 +48,7 @@
*
**/
int
-gnutls_cipher_set_priority (gnutls_session_t session, const int *list)
+MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session, const int *list)
{
int num = 0, i;
@@ -67,7 +67,7 @@ gnutls_cipher_set_priority (gnutls_session_t session, const int *list)
}
inline static int
-_set_priority (priority_st * st, const int *list)
+_set_priority (mhd_gtls_priority_st * st, const int *list)
{
int num = 0, i;
@@ -86,8 +86,8 @@ _set_priority (priority_st * st, const int *list)
}
/**
- * gnutls_kx_set_priority - Sets the priority on the key exchange algorithms supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_kx_set_priority - Sets the priority on the key exchange algorithms supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_kx_algorithm_t elements.
*
* Sets the priority on the key exchange algorithms supported by gnutls.
@@ -101,14 +101,14 @@ _set_priority (priority_st * st, const int *list)
*
**/
int
-gnutls_kx_set_priority (gnutls_session_t session, const int *list)
+MHD_gnutls_kx_set_priority (mhd_gtls_session_t session, const int *list)
{
return _set_priority (&session->internals.priorities.kx, list);
}
/**
- * gnutls_mac_set_priority - Sets the priority on the mac algorithms supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_mac_set_priority - Sets the priority on the mac algorithms supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_mac_algorithm_t elements.
*
* Sets the priority on the mac algorithms supported by gnutls.
@@ -122,14 +122,14 @@ gnutls_kx_set_priority (gnutls_session_t session, const int *list)
*
**/
int
-gnutls_mac_set_priority (gnutls_session_t session, const int *list)
+MHD_gnutls_mac_set_priority (mhd_gtls_session_t session, const int *list)
{
return _set_priority (&session->internals.priorities.mac, list);
}
/**
- * gnutls_compression_set_priority - Sets the priority on the compression algorithms supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_compression_set_priority - Sets the priority on the compression algorithms supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_compression_method_t elements.
*
* Sets the priority on the compression algorithms supported by gnutls.
@@ -147,14 +147,14 @@ gnutls_mac_set_priority (gnutls_session_t session, const int *list)
*
**/
int
-gnutls_compression_set_priority (gnutls_session_t session, const int *list)
+MHD_gnutls_compression_set_priority (mhd_gtls_session_t session, const int *list)
{
return _set_priority (&session->internals.priorities.compression, list);
}
/**
- * gnutls_protocol_set_priority - Sets the priority on the protocol versions supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_protocol_set_priority - Sets the priority on the protocol versions supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_protocol_t elements.
*
* Sets the priority on the protocol versions supported by gnutls.
@@ -165,7 +165,7 @@ gnutls_compression_set_priority (gnutls_session_t session, const int *list)
*
**/
int
-gnutls_protocol_set_priority (gnutls_session_t session, const int *list)
+MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session, const int *list)
{
int ret;
@@ -175,14 +175,14 @@ gnutls_protocol_set_priority (gnutls_session_t session, const int *list)
* This will be overridden later.
*/
if (list)
- _gnutls_set_current_version (session, list[0]);
+ mhd_gtls_set_current_version (session, list[0]);
return ret;
}
/**
- * gnutls_certificate_type_set_priority - Sets the priority on the certificate types supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_certificate_type_set_priority - Sets the priority on the certificate types supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @list: is a 0 terminated list of gnutls_certificate_type_t elements.
*
* Sets the priority on the certificate types supported by gnutls.
@@ -196,7 +196,7 @@ gnutls_protocol_set_priority (gnutls_session_t session, const int *list)
*
**/
int
-gnutls_certificate_type_set_priority (gnutls_session_t session,
+MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
const int *list)
{
#if ENABLE_OPENPGP
@@ -235,11 +235,11 @@ static const int comp_priority[] = { MHD_GNUTLS_COMP_NULL,
0
};
-typedef void (rmadd_func) (priority_st * priority_list, int alg);
+typedef void (rmadd_func) (mhd_gtls_priority_st * priority_list, int alg);
/**
- * gnutls_priority_set - Sets priorities for the cipher suites supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_priority_set - Sets priorities for the cipher suites supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @priority: is a #gnutls_priority_t structure.
*
* Sets the priorities to use on the ciphers, key exchange methods,
@@ -249,7 +249,7 @@ typedef void (rmadd_func) (priority_st * priority_list, int alg);
*
**/
int
-gnutls_priority_set (gnutls_session_t session, gnutls_priority_t priority)
+MHD_gnutls_priority_set (mhd_gtls_session_t session, gnutls_priority_t priority)
{
if (priority == NULL)
{
@@ -258,13 +258,13 @@ gnutls_priority_set (gnutls_session_t session, gnutls_priority_t priority)
}
memcpy (&session->internals.priorities, priority,
- sizeof (struct gnutls_priority_st));
+ sizeof (struct MHD_gtls_priority_st));
return 0;
}
/**
- * gnutls_priority_init - Sets priorities for the cipher suites supported by gnutls.
+ * MHD_tls_set_default_priority - Sets priorities for the cipher suites supported by gnutls.
* @priority_cache: is a #gnutls_prioritity_t structure.
* @priorities: is a string describing priorities
* @err_pos: In case of an error this will have the position in the string the error occured
@@ -329,10 +329,10 @@ gnutls_priority_set (gnutls_session_t session, gnutls_priority_t priority)
* 0 on success.
**/
int
-gnutls_priority_init (gnutls_priority_t * priority_cache,
+MHD_tls_set_default_priority (gnutls_priority_t * priority_cache,
const char *priorities, const char **err_pos)
{
- *priority_cache = gnutls_calloc (1, sizeof (struct gnutls_priority_st));
+ *priority_cache = gnutls_calloc (1, sizeof (struct MHD_gtls_priority_st));
if (*priority_cache == NULL)
{
gnutls_assert ();
@@ -352,104 +352,54 @@ gnutls_priority_init (gnutls_priority_t * priority_cache,
}
/**
- * gnutls_priority_deinit - Deinitialize the priorities cache for the cipher suites supported by gnutls.
+ * MHD_gnutls_priority_deinit - Deinitialize the priorities cache for the cipher suites supported by gnutls.
* @priority_cache: is a #gnutls_prioritity_t structure.
*
* Deinitializes the priority cache.
*
**/
void
-gnutls_priority_deinit (gnutls_priority_t priority_cache)
+MHD_gnutls_priority_deinit (gnutls_priority_t priority_cache)
{
gnutls_free (priority_cache);
}
/**
- * gnutls_priority_set_direct - Sets priorities for the cipher suites supported by gnutls.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_priority_set_direct - Sets priorities for the cipher suites supported by gnutls.
+ * @session: is a #mhd_gtls_session_t structure.
* @priorities: is a string describing priorities
* @err_pos: In case of an error this will have the position in the string the error occured
*
* Sets the priorities to use on the ciphers, key exchange methods,
* macs and compression methods. This function avoids keeping a
* priority cache and is used to directly set string priorities to a
- * TLS session. For documentation check the gnutls_priority_init().
+ * TLS session. For documentation check the MHD_tls_set_default_priority().
*
* On syntax error GNUTLS_E_INVALID_REQUEST is returned and 0 on success.
*
**/
int
-gnutls_priority_set_direct (gnutls_session_t session,
+MHD_gnutls_priority_set_direct (mhd_gtls_session_t session,
const char *priorities, const char **err_pos)
{
gnutls_priority_t prio;
int ret;
- ret = gnutls_priority_init (&prio, priorities, err_pos);
+ ret = MHD_tls_set_default_priority (&prio, priorities, err_pos);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
- ret = gnutls_priority_set (session, prio);
+ ret = MHD_gnutls_priority_set (session, prio);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
- gnutls_priority_deinit (prio);
+ MHD_gnutls_priority_deinit (prio);
return 0;
}
-
-/**
- * gnutls_set_default_priority - Sets some default priority on the cipher suites supported by gnutls.
- * @session: is a #gnutls_session_t structure.
- *
- * Sets some default priority on the ciphers, key exchange methods,
- * macs and compression methods.
- *
- * This is the same as calling:
- *
- * gnutls_priority_set_direct (session, "NORMAL", NULL);
- *
- * This function is kept around for backwards compatibility, but
- * because of its wide use it is still fully supported. If you wish
- * to allow users to provide a string that specify which ciphers to
- * use (which is recommended), you should use
- * gnutls_priority_set_direct() or gnutls_priority_set() instead.
- *
- * Returns 0 on success.
- **/
-int
-gnutls_set_default_priority (gnutls_session_t session)
-{
- return gnutls_priority_set_direct (session, "NORMAL", NULL);
-}
-
-/**
- * gnutls_set_default_export_priority - Sets some default priority on the cipher suites supported by gnutls.
- * @session: is a #gnutls_session_t structure.
- *
- * Sets some default priority on the ciphers, key exchange methods, macs
- * and compression methods. This function also includes weak algorithms.
- *
- * This is the same as calling:
- *
- * gnutls_priority_set_direct (session, "EXPORT", NULL);
- *
- * This function is kept around for backwards compatibility, but
- * because of its wide use it is still fully supported. If you wish
- * to allow users to provide a string that specify which ciphers to
- * use (which is recommended), you should use
- * gnutls_priority_set_direct() or gnutls_priority_set() instead.
- *
- * Returns 0 on success.
- **/
-int
-gnutls_set_default_export_priority (gnutls_session_t session)
-{
- return gnutls_priority_set_direct (session, "EXPORT", NULL);
-}
diff --git a/src/daemon/https/tls/gnutls_record.c b/src/daemon/https/tls/gnutls_record.c
@@ -44,27 +44,27 @@
#include <gnutls_dh.h>
/**
- * gnutls_protocol_get_version - Returns the version of the currently used protocol
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_protocol_get_version - Returns the version of the currently used protocol
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the version of the currently used protocol.
**/
gnutls_protocol_t
-gnutls_protocol_get_version (gnutls_session_t session)
+MHD_gnutls_protocol_get_version (mhd_gtls_session_t session)
{
return session->security_parameters.version;
}
void
-_gnutls_set_current_version (gnutls_session_t session,
+mhd_gtls_set_current_version (mhd_gtls_session_t session,
gnutls_protocol_t version)
{
session->security_parameters.version = version;
}
/**
- * gnutls_transport_set_lowat - Used to set the lowat value in order for select to check for pending data.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_transport_set_lowat - Used to set the lowat value in order for select to check for pending data.
+ * @session: is a #mhd_gtls_session_t structure.
* @num: is the low water value.
*
* Used to set the lowat value in order for select to check if there
@@ -75,14 +75,14 @@ _gnutls_set_current_version (gnutls_session_t session,
* to zero.
**/
void
-gnutls_transport_set_lowat (gnutls_session_t session, int num)
+MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num)
{
session->internals.lowat = num;
}
/**
- * gnutls_record_disable_padding - Used to disabled padding in TLS 1.0 and above
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_record_disable_padding - Used to disabled padding in TLS 1.0 and above
+ * @session: is a #mhd_gtls_session_t structure.
*
* Used to disabled padding in TLS 1.0 and above. Normally you do
* not need to use this function, but there are buggy clients that
@@ -93,14 +93,14 @@ gnutls_transport_set_lowat (gnutls_session_t session, int num)
* out there, need to call this function.
**/
void
-gnutls_record_disable_padding (gnutls_session_t session)
+MHD_gtls_record_disable_padding (mhd_gtls_session_t session)
{
session->internals.priorities.no_padding = 1;
}
/**
- * gnutls_transport_set_ptr - Used to set first argument of the transport functions
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_transport_set_ptr - Used to set first argument of the transport functions
+ * @session: is a #mhd_gtls_session_t structure.
* @ptr: is the value.
*
* Used to set the first argument of the transport function (like
@@ -108,7 +108,7 @@ gnutls_record_disable_padding (gnutls_session_t session)
* the connection handle.
**/
void
-gnutls_transport_set_ptr (gnutls_session_t session,
+MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
gnutls_transport_ptr_t ptr)
{
session->internals.transport_recv_ptr = ptr;
@@ -116,8 +116,8 @@ gnutls_transport_set_ptr (gnutls_session_t session,
}
/**
- * gnutls_transport_set_ptr2 - Used to set first argument of the transport functions
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_transport_set_ptr2 - Used to set first argument of the transport functions
+ * @session: is a #mhd_gtls_session_t structure.
* @recv_ptr: is the value for the pull function
* @send_ptr: is the value for the push function
*
@@ -127,7 +127,7 @@ gnutls_transport_set_ptr (gnutls_session_t session,
* different pointers for receiving and sending.
**/
void
-gnutls_transport_set_ptr2 (gnutls_session_t session,
+MHD_gnutls_transport_set_ptr2 (mhd_gtls_session_t session,
gnutls_transport_ptr_t recv_ptr,
gnutls_transport_ptr_t send_ptr)
{
@@ -136,48 +136,12 @@ gnutls_transport_set_ptr2 (gnutls_session_t session,
}
/**
- * gnutls_transport_get_ptr - Used to return the first argument of the transport functions
- * @session: is a #gnutls_session_t structure.
- *
- * Used to get the first argument of the transport function (like
- * PUSH and PULL). This must have been set using
- * gnutls_transport_set_ptr().
- *
- * Returns: first argument of the transport function.
- **/
-gnutls_transport_ptr_t
-gnutls_transport_get_ptr (gnutls_session_t session)
-{
- return session->internals.transport_recv_ptr;
-}
-
-/**
- * gnutls_transport_get_ptr2 - Used to return the first argument of the transport functions
- * @session: is a #gnutls_session_t structure.
- * @recv_ptr: will hold the value for the pull function
- * @send_ptr: will hold the value for the push function
- *
- * Used to get the arguments of the transport functions (like PUSH
- * and PULL). These should have been set using
- * gnutls_transport_set_ptr2().
- **/
-void
-gnutls_transport_get_ptr2 (gnutls_session_t session,
- gnutls_transport_ptr_t * recv_ptr,
- gnutls_transport_ptr_t * send_ptr)
-{
-
- *recv_ptr = session->internals.transport_recv_ptr;
- *send_ptr = session->internals.transport_send_ptr;
-}
-
-/**
- * gnutls_bye - This function terminates the current TLS/SSL connection.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_bye - This function terminates the current TLS/SSL connection.
+ * @session: is a #mhd_gtls_session_t structure.
* @how: is an integer
*
* Terminates the current TLS/SSL connection. The connection should
- * have been initiated using gnutls_handshake(). @how should be one
+ * have been initiated using MHD_gnutls_handshake(). @how should be one
* of %GNUTLS_SHUT_RDWR, %GNUTLS_SHUT_WR.
*
* In case of %GNUTLS_SHUT_RDWR then the TLS connection gets
@@ -199,13 +163,13 @@ gnutls_transport_get_ptr2 (gnutls_session_t session,
* session, thus this behavior is not recommended.
*
* This function may also return %GNUTLS_E_AGAIN or
- * %GNUTLS_E_INTERRUPTED; cf. gnutls_record_get_direction().
+ * %GNUTLS_E_INTERRUPTED; cf. MHD_gnutls_record_get_direction().
*
* Returns: %GNUTLS_E_SUCCESS on success, or an error code, see
* function documentation for entire semantics.
**/
int
-gnutls_bye (gnutls_session_t session, gnutls_close_request_t how)
+MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
{
int ret = 0;
@@ -213,7 +177,7 @@ gnutls_bye (gnutls_session_t session, gnutls_close_request_t how)
{
case STATE0:
case STATE60:
- ret = _gnutls_io_write_flush (session);
+ ret = mhd_gtls_io_write_flush (session);
STATE = STATE60;
if (ret < 0)
{
@@ -223,7 +187,7 @@ gnutls_bye (gnutls_session_t session, gnutls_close_request_t how)
case STATE61:
ret =
- gnutls_alert_send (session, GNUTLS_AL_WARNING, GNUTLS_A_CLOSE_NOTIFY);
+ MHD_gnutls_alert_send (session, GNUTLS_AL_WARNING, GNUTLS_A_CLOSE_NOTIFY);
STATE = STATE61;
if (ret < 0)
{
@@ -237,8 +201,8 @@ gnutls_bye (gnutls_session_t session, gnutls_close_request_t how)
{
do
{
- _gnutls_io_clear_peeked_data (session);
- ret = _gnutls_recv_int (session, GNUTLS_ALERT, -1, NULL, 0);
+ mhd_gtls_io_clear_peeked_data (session);
+ ret = mhd_gtls_recv_int (session, GNUTLS_ALERT, -1, NULL, 0);
}
while (ret == GNUTLS_E_GOT_APPLICATION_DATA);
@@ -266,13 +230,13 @@ gnutls_bye (gnutls_session_t session, gnutls_close_request_t how)
}
inline static void
-session_invalidate (gnutls_session_t session)
+session_invalidate (mhd_gtls_session_t session)
{
session->internals.valid_connection = VALID_FALSE;
}
inline static void
-session_unresumable (gnutls_session_t session)
+session_unresumable (mhd_gtls_session_t session)
{
session->internals.resumable = RESUME_FALSE;
}
@@ -280,7 +244,7 @@ session_unresumable (gnutls_session_t session)
/* returns 0 if session is valid
*/
inline static int
-session_is_valid (gnutls_session_t session)
+session_is_valid (mhd_gtls_session_t session)
{
if (session->internals.valid_connection == VALID_FALSE)
return GNUTLS_E_INVALID_SESSION;
@@ -292,7 +256,7 @@ session_is_valid (gnutls_session_t session)
* version must have 2 bytes at least.
*/
inline static void
-copy_record_version (gnutls_session_t session,
+copy_record_version (mhd_gtls_session_t session,
gnutls_handshake_description_t htype, opaque version[2])
{
gnutls_protocol_t lver;
@@ -300,10 +264,10 @@ copy_record_version (gnutls_session_t session,
if (htype != GNUTLS_HANDSHAKE_CLIENT_HELLO
|| session->internals.default_record_version[0] == 0)
{
- lver = gnutls_protocol_get_version (session);
+ lver = MHD_gnutls_protocol_get_version (session);
- version[0] = _gnutls_version_get_major (lver);
- version[1] = _gnutls_version_get_minor (lver);
+ version[0] = mhd_gtls_version_get_major (lver);
+ version[1] = mhd_gtls_version_get_minor (lver);
}
else
{
@@ -313,7 +277,7 @@ copy_record_version (gnutls_session_t session,
}
/* This function behaves exactly like write(). The only difference is
- * that it accepts, the gnutls_session_t and the content_type_t of data to
+ * that it accepts, the mhd_gtls_session_t and the content_type_t of data to
* send (if called by the user the Content is specific)
* It is intended to transfer data, under the current session.
*
@@ -327,7 +291,7 @@ copy_record_version (gnutls_session_t session,
*
*/
ssize_t
-_gnutls_send_int (gnutls_session_t session,
+mhd_gtls_send_int (mhd_gtls_session_t session,
content_type_t type,
gnutls_handshake_description_t htype,
const void *_data, size_t sizeofdata)
@@ -366,7 +330,7 @@ _gnutls_send_int (gnutls_session_t session,
_gnutls_record_log
("REC[%x]: Sending Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
+ (int) mhd_gtls_uint64touint32 (&session->connection_state.
write_sequence_number),
_gnutls_packet2str (type), type, sizeofdata);
@@ -380,7 +344,7 @@ _gnutls_send_int (gnutls_session_t session,
*/
if (session->internals.record_send_buffer.length > 0)
{
- ret = _gnutls_io_write_flush (session);
+ ret = mhd_gtls_io_write_flush (session);
if (ret > 0)
cipher_size = ret;
else
@@ -403,7 +367,7 @@ _gnutls_send_int (gnutls_session_t session,
}
cipher_size =
- _gnutls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
+ mhd_gtls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
data2send_size, cipher, cipher_size, type,
(session->internals.priorities.no_padding ==
0) ? 1 : 0);
@@ -421,7 +385,7 @@ _gnutls_send_int (gnutls_session_t session,
/* increase sequence number
*/
- if (_gnutls_uint64pp
+ if (mhd_gtls_uint64pp
(&session->connection_state.write_sequence_number) != 0)
{
session_invalidate (session);
@@ -430,13 +394,13 @@ _gnutls_send_int (gnutls_session_t session,
return GNUTLS_E_RECORD_LIMIT_REACHED;
}
- ret = _gnutls_io_write_buffered (session, cipher, cipher_size);
+ ret = mhd_gtls_io_write_buffered (session, cipher, cipher_size);
gnutls_free (cipher);
}
if (ret != cipher_size)
{
- if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
+ if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
{
/* If we have sent any data then just return
* the error value. Do not invalidate the session.
@@ -460,7 +424,7 @@ _gnutls_send_int (gnutls_session_t session,
_gnutls_record_log ("REC[%x]: Sent Packet[%d] %s(%d) with length: %d\n",
session,
- (int) _gnutls_uint64touint32 (&session->
+ (int) mhd_gtls_uint64touint32 (&session->
connection_state.
write_sequence_number),
_gnutls_packet2str (type), type, cipher_size);
@@ -472,7 +436,7 @@ _gnutls_send_int (gnutls_session_t session,
* completed. This sends a Change Cipher Spec packet to the peer.
*/
ssize_t
-_gnutls_send_change_cipher_spec (gnutls_session_t session, int again)
+mhd_gtls_send_change_cipher_spec (mhd_gtls_session_t session, int again)
{
static const opaque data[1] = {
GNUTLS_TYPE_CHANGE_CIPHER_SPEC
@@ -481,10 +445,10 @@ _gnutls_send_change_cipher_spec (gnutls_session_t session, int again)
_gnutls_handshake_log ("REC[%x]: Sent ChangeCipherSpec\n", session);
if (again == 0)
- return _gnutls_send_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, data, 1);
+ return mhd_gtls_send_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, data, 1);
else
{
- return _gnutls_io_write_flush (session);
+ return mhd_gtls_io_write_flush (session);
}
}
@@ -510,16 +474,16 @@ check_recv_type (content_type_t recv_type)
* then it copies the data.
*/
static int
-check_buffers (gnutls_session_t session,
+check_buffers (mhd_gtls_session_t session,
content_type_t type, opaque * data, int sizeofdata)
{
if ((type == GNUTLS_APPLICATION_DATA || type == GNUTLS_HANDSHAKE || type
- == GNUTLS_INNER_APPLICATION) && _gnutls_record_buffer_get_size (type,
+ == GNUTLS_INNER_APPLICATION) && mhd_gnutls_record_buffer_get_size (type,
session)
> 0)
{
int ret, ret2;
- ret = _gnutls_record_buffer_get (type, session, data, sizeofdata);
+ ret = mhd_gtls_record_buffer_get (type, session, data, sizeofdata);
if (ret < 0)
{
gnutls_assert ();
@@ -527,9 +491,9 @@ check_buffers (gnutls_session_t session,
}
/* if the buffer just got empty */
- if (_gnutls_record_buffer_get_size (type, session) == 0)
+ if (mhd_gnutls_record_buffer_get_size (type, session) == 0)
{
- if ((ret2 = _gnutls_io_clear_peeked_data (session)) < 0)
+ if ((ret2 = mhd_gtls_io_clear_peeked_data (session)) < 0)
{
gnutls_assert ();
return ret2;
@@ -546,7 +510,7 @@ check_buffers (gnutls_session_t session,
* content type.
*/
static int
-record_check_headers (gnutls_session_t session,
+record_check_headers (mhd_gtls_session_t session,
uint8_t headers[RECORD_HEADER_SIZE],
content_type_t type,
gnutls_handshake_description_t htype,
@@ -594,7 +558,7 @@ record_check_headers (gnutls_session_t session,
/* No DECR_LEN, since headers has enough size.
*/
- *length = _gnutls_read_uint16 (&headers[3]);
+ *length = mhd_gtls_read_uint16 (&headers[3]);
}
return 0;
@@ -604,7 +568,7 @@ record_check_headers (gnutls_session_t session,
* negotiated in the handshake.
*/
inline static int
-record_check_version (gnutls_session_t session,
+record_check_version (mhd_gtls_session_t session,
gnutls_handshake_description_t htype, opaque version[2])
{
if (htype == GNUTLS_HANDSHAKE_CLIENT_HELLO)
@@ -621,8 +585,8 @@ record_check_version (gnutls_session_t session,
}
}
else if (htype != GNUTLS_HANDSHAKE_SERVER_HELLO
- && gnutls_protocol_get_version (session)
- != _gnutls_version_get (version[0], version[1]))
+ && MHD_gnutls_protocol_get_version (session)
+ != mhd_gtls_version_get (version[0], version[1]))
{
/* Reject record packets that have a different version than the
* one negotiated. Note that this version is not protected by any
@@ -642,7 +606,7 @@ record_check_version (gnutls_session_t session,
* the one we actually expect.
*/
static int
-record_check_type (gnutls_session_t session,
+record_check_type (mhd_gtls_session_t session,
content_type_t recv_type,
content_type_t type,
gnutls_handshake_description_t htype,
@@ -655,7 +619,7 @@ record_check_type (gnutls_session_t session,
== GNUTLS_HANDSHAKE
|| type == GNUTLS_INNER_APPLICATION))
{
- _gnutls_record_buffer_put (type, session, (void *) data, data_size);
+ mhd_gnutls_record_buffer_put (type, session, (void *) data, data_size);
}
else
{
@@ -665,7 +629,7 @@ record_check_type (gnutls_session_t session,
_gnutls_record_log
("REC[%x]: Alert[%d|%d] - %s - was received\n", session,
- data[0], data[1], gnutls_alert_get_name ((int) data[1]));
+ data[0], data[1], MHD_gnutls_alert_get_name ((int) data[1]));
session->internals.last_alert = data[1];
session->internals.last_alert_level = data[0];
@@ -710,7 +674,7 @@ record_check_type (gnutls_session_t session,
case GNUTLS_APPLICATION_DATA:
/* even if data is unexpected put it into the buffer */
if ((ret =
- _gnutls_record_buffer_put (recv_type, session, (void *) data,
+ mhd_gnutls_record_buffer_put (recv_type, session, (void *) data,
data_size)) < 0)
{
gnutls_assert ();
@@ -747,13 +711,13 @@ record_check_type (gnutls_session_t session,
*/
/* So we accept it */
- return _gnutls_recv_hello_request (session, data, data_size);
+ return mhd_gtls_recv_hello_request (session, data, data_size);
break;
case GNUTLS_INNER_APPLICATION:
/* even if data is unexpected put it into the buffer */
if ((ret =
- _gnutls_record_buffer_put (recv_type, session, (void *) data,
+ mhd_gnutls_record_buffer_put (recv_type, session, (void *) data,
data_size)) < 0)
{
gnutls_assert ();
@@ -782,7 +746,7 @@ record_check_type (gnutls_session_t session,
* also initialize it.
*/
inline static int
-get_temp_recv_buffer (gnutls_session_t session, gnutls_datum_t * tmp)
+get_temp_recv_buffer (mhd_gtls_session_t session, gnutls_datum_t * tmp)
{
size_t max_record_size;
@@ -824,14 +788,14 @@ get_temp_recv_buffer (gnutls_session_t session, gnutls_datum_t * tmp)
#define MAX_EMPTY_PACKETS_SEQUENCE 4
/* This function behaves exactly like read(). The only difference is
- * that it accepts the gnutls_session_t and the content_type_t of data to
+ * that it accepts the mhd_gtls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
-_gnutls_recv_int (gnutls_session_t session,
+mhd_gtls_recv_int (mhd_gtls_session_t session,
content_type_t type,
gnutls_handshake_description_t htype,
opaque * data, size_t sizeofdata)
@@ -885,10 +849,10 @@ begin:
*/
header_size = RECORD_HEADER_SIZE;
- if ((ret = _gnutls_io_read_buffered (session, &headers, header_size, -1))
+ if ((ret = mhd_gtls_io_read_buffered (session, &headers, header_size, -1))
!= header_size)
{
- if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
+ if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
return ret;
session_invalidate (session);
@@ -930,12 +894,12 @@ begin:
_gnutls_record_log
("REC[%x]: Expected Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
+ (int) mhd_gtls_uint64touint32 (&session->connection_state.
read_sequence_number),
_gnutls_packet2str (type), type, sizeofdata);
_gnutls_record_log
("REC[%x]: Received Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
+ (int) mhd_gtls_uint64touint32 (&session->connection_state.
read_sequence_number),
_gnutls_packet2str (recv_type), recv_type, length);
@@ -953,11 +917,11 @@ begin:
/* check if we have that data into buffer.
*/
- if ((ret = _gnutls_io_read_buffered (session, &recv_data,
+ if ((ret = mhd_gtls_io_read_buffered (session, &recv_data,
header_size + length, recv_type))
!= header_size + length)
{
- if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
+ if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
return ret;
session_unresumable (session);
@@ -969,7 +933,7 @@ begin:
/* ok now we are sure that we can read all the data - so
* move on !
*/
- _gnutls_io_clear_read_buffer (session);
+ mhd_gtls_io_clear_read_buffer (session);
ciphertext = &recv_data[header_size];
ret = get_temp_recv_buffer (session, &tmp);
@@ -980,7 +944,7 @@ begin:
}
/* decrypt the data we got. */
- ret = _gnutls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
+ ret = mhd_gtls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
recv_type);
if (ret < 0)
{
@@ -1012,13 +976,13 @@ begin:
_gnutls_record_log
("REC[%x]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
+ (int) mhd_gtls_uint64touint32 (&session->connection_state.
read_sequence_number),
_gnutls_packet2str (recv_type), recv_type, decrypted_length);
/* increase sequence number
*/
- if (_gnutls_uint64pp (&session->connection_state.read_sequence_number) != 0)
+ if (mhd_gtls_uint64pp (&session->connection_state.read_sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
@@ -1043,7 +1007,7 @@ begin:
|| type == GNUTLS_INNER_APPLICATION))
{
- ret = _gnutls_record_buffer_get (type, session, data, sizeofdata);
+ ret = mhd_gtls_record_buffer_get (type, session, data, sizeofdata);
if (ret < 0)
{
gnutls_assert ();
@@ -1052,9 +1016,9 @@ begin:
/* if the buffer just got empty
*/
- if (_gnutls_record_buffer_get_size (type, session) == 0)
+ if (mhd_gnutls_record_buffer_get_size (type, session) == 0)
{
- if ((ret2 = _gnutls_io_clear_peeked_data (session)) < 0)
+ if ((ret2 = mhd_gtls_io_clear_peeked_data (session)) < 0)
{
gnutls_assert ();
return ret2;
@@ -1086,8 +1050,8 @@ begin:
}
/**
- * gnutls_record_send - sends to the peer the specified data
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_record_send - sends to the peer the specified data
+ * @session: is a #mhd_gtls_session_t structure.
* @data: contains the data to send
* @sizeofdata: is the length of the data
*
@@ -1098,7 +1062,7 @@ begin:
* Note that if the send buffer is full, send() will block this
* function. See the send() documentation for full information. You
* can replace the default push function by using
- * gnutls_transport_set_ptr2() with a call to send() with a
+ * MHD_gnutls_transport_set_ptr2() with a call to send() with a
* MSG_DONTWAIT flag if blocking is a problem.
*
* If the EINTR is returned by the internal push function (the
@@ -1106,7 +1070,7 @@ begin:
* %GNUTLS_E_INTERRUPTED or %GNUTLS_E_AGAIN is returned, you must
* call this function again, with the same parameters; alternatively
* you could provide a %NULL pointer for data, and 0 for
- * size. cf. gnutls_record_get_direction().
+ * size. cf. MHD_gnutls_record_get_direction().
*
* Returns: the number of bytes sent, or a negative error code. The
* number of bytes sent might be less than @sizeofdata. The maximum
@@ -1114,16 +1078,16 @@ begin:
* the negotiated maximum record size.
**/
ssize_t
-gnutls_record_send (gnutls_session_t session,
+MHD_gnutls_record_send (mhd_gtls_session_t session,
const void *data, size_t sizeofdata)
{
- return _gnutls_send_int (session, GNUTLS_APPLICATION_DATA, -1, data,
+ return mhd_gtls_send_int (session, GNUTLS_APPLICATION_DATA, -1, data,
sizeofdata);
}
/**
- * gnutls_record_recv - reads data from the TLS record protocol
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_record_recv - reads data from the TLS record protocol
+ * @session: is a #mhd_gtls_session_t structure.
* @data: the buffer that the data will be read into
* @sizeofdata: the number of requested bytes
*
@@ -1141,7 +1105,7 @@ gnutls_record_send (gnutls_session_t session,
* is recv()) then %GNUTLS_E_INTERRUPTED will be returned. If
* %GNUTLS_E_INTERRUPTED or %GNUTLS_E_AGAIN is returned, you must
* call this function again to get the data. See also
- * gnutls_record_get_direction().
+ * MHD_gnutls_record_get_direction().
*
* A server may also receive %GNUTLS_E_REHANDSHAKE when a client has
* initiated a handshake. In that case the server can only initiate a
@@ -1152,22 +1116,22 @@ gnutls_record_send (gnutls_session_t session,
* received might be less than @sizeofdata.
**/
ssize_t
-gnutls_record_recv (gnutls_session_t session, void *data, size_t sizeofdata)
+MHD_gnutls_record_recv (mhd_gtls_session_t session, void *data, size_t sizeofdata)
{
- return _gnutls_recv_int (session, GNUTLS_APPLICATION_DATA, -1, data,
+ return mhd_gtls_recv_int (session, GNUTLS_APPLICATION_DATA, -1, data,
sizeofdata);
}
/**
- * gnutls_record_get_max_size - returns the maximum record size
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_record_get_max_size - returns the maximum record size
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function returns the maximum record packet size in this
* connection. The maximum record size is negotiated by the client
* after the first handshake message.
**/
size_t
-gnutls_record_get_max_size (gnutls_session_t session)
+MHD_gnutls_record_get_max_size (mhd_gtls_session_t session)
{
/* Recv will hold the negotiated max record size
* always.
@@ -1176,8 +1140,8 @@ gnutls_record_get_max_size (gnutls_session_t session)
}
/**
- * gnutls_record_set_max_size - sets the maximum record size
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_record_set_max_size - sets the maximum record size
+ * @session: is a #mhd_gtls_session_t structure.
* @size: is the new size
*
* This function sets the maximum record packet size in this
@@ -1193,14 +1157,14 @@ gnutls_record_get_max_size (gnutls_session_t session)
* all TLS implementations use or even understand this extension.
**/
ssize_t
-gnutls_record_set_max_size (gnutls_session_t session, size_t size)
+MHD_gnutls_record_set_max_size (mhd_gtls_session_t session, size_t size)
{
ssize_t new_size;
if (session->security_parameters.entity == GNUTLS_SERVER)
return GNUTLS_E_INVALID_REQUEST;
- new_size = _gnutls_mre_record2num (size);
+ new_size = mhd_gtls_mre_record2num (size);
if (new_size < 0)
{
diff --git a/src/daemon/https/tls/gnutls_record.h b/src/daemon/https/tls/gnutls_record.h
@@ -22,11 +22,11 @@
*
*/
-ssize_t _gnutls_send_int (gnutls_session_t session, content_type_t type,
+ssize_t mhd_gtls_send_int (mhd_gtls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
const void *data, size_t sizeofdata);
-ssize_t _gnutls_recv_int (gnutls_session_t session, content_type_t type,
+ssize_t mhd_gtls_recv_int (mhd_gtls_session_t session, content_type_t type,
gnutls_handshake_description_t, opaque * data,
size_t sizeofdata);
-ssize_t _gnutls_send_change_cipher_spec (gnutls_session_t session, int again);
-void gnutls_transport_set_lowat (gnutls_session_t session, int num);
+ssize_t mhd_gtls_send_change_cipher_spec (mhd_gtls_session_t session, int again);
+void MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num);
diff --git a/src/daemon/https/tls/gnutls_rsa_export.c b/src/daemon/https/tls/gnutls_rsa_export.c
@@ -46,7 +46,7 @@
* We only support limited key sizes.
*/
const mpi_t *
-_gnutls_rsa_params_to_mpi (gnutls_rsa_params_t rsa_params)
+_gnutls_rsa_params_to_mpi (mhd_gtls_rsa_params_t rsa_params)
{
if (rsa_params == NULL)
{
@@ -167,42 +167,15 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
}
-
-/**
- * gnutls_rsa_params_import_raw - This function will replace the old RSA parameters
- * @rsa_params: Is a structure will hold the parameters
- * @m: holds the modulus
- * @e: holds the public exponent
- * @d: holds the private exponent
- * @p: holds the first prime (p)
- * @q: holds the second prime (q)
- * @u: holds the coefficient
- *
- * This function will replace the parameters in the given structure.
- * The new parameters should be stored in the appropriate gnutls_datum.
- *
- **/
-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)
-{
- return gnutls_x509_privkey_import_rsa_raw (rsa_params, m, e, d, p, q, u);
-}
-
/**
- * gnutls_rsa_params_init - This function will initialize the temporary RSA parameters
+ * MHD_gnutls_rsa_params_init - This function will initialize the temporary RSA parameters
* @rsa_params: Is a structure that will hold the parameters
*
* This function will initialize the temporary RSA parameters structure.
*
**/
int
-gnutls_rsa_params_init (gnutls_rsa_params_t * rsa_params)
+MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params)
{
int ret;
@@ -219,42 +192,27 @@ gnutls_rsa_params_init (gnutls_rsa_params_t * rsa_params)
}
/**
- * gnutls_rsa_params_deinit - This function will deinitialize the RSA parameters
+ * MHD_gnutls_rsa_params_deinit - This function will deinitialize the RSA parameters
* @rsa_params: Is a structure that holds the parameters
*
* This function will deinitialize the RSA parameters structure.
*
**/
void
-gnutls_rsa_params_deinit (gnutls_rsa_params_t rsa_params)
+MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params)
{
gnutls_x509_privkey_deinit (rsa_params);
}
/**
- * gnutls_rsa_params_cpy - This function will copy an RSA parameters structure
- * @dst: Is the destination structure, which should be initialized.
- * @src: Is the source structure
- *
- * This function will copy the RSA parameters structure from source
- * to destination.
- *
- **/
-int
-gnutls_rsa_params_cpy (gnutls_rsa_params_t dst, gnutls_rsa_params_t src)
-{
- return gnutls_x509_privkey_cpy (dst, src);
-}
-
-/**
- * gnutls_rsa_params_generate2 - This function will generate temporary RSA parameters
+ * MHD_gnutls_rsa_params_generate2 - This function will generate temporary RSA parameters
* @params: The structure where the parameters will be stored
* @bits: is the prime's number of bits
*
- * This function will generate new temporary RSA parameters for use in
- * RSA-EXPORT ciphersuites. This function is normally slow.
- *
- * Note that if the parameters are to be used in export cipher suites the
+ * This function will generate new temporary RSA parameters for use in
+ * RSA-EXPORT ciphersuites. This function is normally slow.
+ *
+ * Note that if the parameters are to be used in export cipher suites the
* bits value should be 512 or less.
* Also note that the generation of new RSA parameters is only useful
* to servers. Clients use the parameters sent by the server, thus it's
@@ -262,100 +220,7 @@ gnutls_rsa_params_cpy (gnutls_rsa_params_t dst, gnutls_rsa_params_t src)
*
**/
int
-gnutls_rsa_params_generate2 (gnutls_rsa_params_t params, unsigned int bits)
+MHD_gnutls_rsa_params_generate2 (mhd_gtls_rsa_params_t params, unsigned int bits)
{
return gnutls_x509_privkey_generate (params, MHD_GNUTLS_PK_RSA, bits, 0);
}
-
-/**
- * gnutls_rsa_params_import_pkcs1 - This function will import RSA params from a pkcs1 structure
- * @params: A structure where the parameters will be copied to
- * @pkcs1_params: should contain a PKCS1 RSAPublicKey structure PEM or DER encoded
- * @format: the format of params. PEM or DER.
- *
- * This function will extract the RSAPublicKey found in a PKCS1 formatted
- * structure.
- *
- * If the structure is PEM encoded, it should have a header
- * of "BEGIN RSA PRIVATE KEY".
- *
- * In case of failure a negative value will be returned, and
- * 0 on success.
- *
- **/
-int
-gnutls_rsa_params_import_pkcs1 (gnutls_rsa_params_t params,
- const gnutls_datum_t * pkcs1_params,
- gnutls_x509_crt_fmt_t format)
-{
- return gnutls_x509_privkey_import (params, pkcs1_params, format);
-}
-
-
-/**
- * gnutls_rsa_params_export_pkcs1 - This function will export RSA params to a pkcs1 structure
- * @params: Holds the RSA parameters
- * @format: the format of output params. One of PEM or DER.
- * @params_data: will contain a PKCS1 RSAPublicKey structure PEM or DER encoded
- * @params_data_size: holds the size of params_data (and will be replaced by the actual size of parameters)
- *
- * This function will export the given RSA parameters to a PKCS1
- * RSAPublicKey structure. If the buffer provided is not long enough to
- * hold the output, then GNUTLS_E_SHORT_MEMORY_BUFFER will be returned.
- *
- * If the structure is PEM encoded, it will have a header
- * of "BEGIN RSA PRIVATE KEY".
- *
- * In case of failure a negative value will be returned, and
- * 0 on success.
- *
- **/
-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)
-{
- return gnutls_x509_privkey_export (params, format,
- params_data, params_data_size);
-}
-
-
-/**
- * gnutls_rsa_params_export_raw - This function will export the RSA parameters
- * @params: a structure that holds the rsa parameters
- * @m: will hold the modulus
- * @e: will hold the public exponent
- * @d: will hold the private exponent
- * @p: will hold the first prime (p)
- * @q: will hold the second prime (q)
- * @u: will hold the coefficient
- * @bits: if non null will hold the prime's number of bits
- *
- * This function will export the RSA parameters found in the given
- * structure. The new parameters will be allocated using
- * gnutls_malloc() and will be stored in the appropriate datum.
- *
- **/
-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 ret;
-
- ret = gnutls_x509_privkey_export_rsa_raw (params, m, e, d, p, q, u);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- if (bits)
- *bits = _gnutls_mpi_get_nbits (params->params[3]);
-
- return 0;
-
-}
diff --git a/src/daemon/https/tls/gnutls_rsa_export.h b/src/daemon/https/tls/gnutls_rsa_export.h
@@ -22,6 +22,6 @@
*
*/
-const mpi_t *_gnutls_rsa_params_to_mpi (gnutls_rsa_params_t);
-int _gnutls_peers_cert_less_512 (gnutls_session_t session);
+const mpi_t * _gnutls_rsa_params_to_mpi (mhd_gtls_rsa_params_t);
+int _gnutls_peers_cert_less_512 (mhd_gtls_session_t session);
int _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
diff --git a/src/daemon/https/tls/gnutls_session.c b/src/daemon/https/tls/gnutls_session.c
@@ -27,9 +27,11 @@
#include "gnutls_session_pack.h"
#include <gnutls_datum.h>
+/* TODO this file should be removed if session resumption will be abandoned */
+
/**
* gnutls_session_get_data - Returns all session parameters.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @session_data: is a pointer to space to hold the session.
* @session_data_size: is the session_data's size, or it will be set by the function.
*
@@ -40,46 +42,46 @@
*
* Resuming sessions is really useful and speedups connections after a succesful one.
**/
-int
-gnutls_session_get_data (gnutls_session_t session,
- void *session_data, size_t * session_data_size)
-{
-
- gnutls_datum_t psession;
- int ret;
-
- if (session->internals.resumable == RESUME_FALSE)
- return GNUTLS_E_INVALID_SESSION;
-
- psession.data = session_data;
-
- ret = _gnutls_session_pack (session, &psession);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
- *session_data_size = psession.size;
-
- if (psession.size > *session_data_size)
- {
- ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
- goto error;
- }
-
- if (session_data != NULL)
- memcpy (session_data, psession.data, psession.size);
-
- ret = 0;
-
-error:
- _gnutls_free_datum (&psession);
- return ret;
-}
+//int
+//gnutls_session_get_data (mhd_gtls_session_t session,
+// void *session_data, size_t * session_data_size)
+//{
+//
+// gnutls_datum_t psession;
+// int ret;
+//
+// if (session->internals.resumable == RESUME_FALSE)
+// return GNUTLS_E_INVALID_SESSION;
+//
+// psession.data = session_data;
+//
+// ret = _gnutls_session_pack (session, &psession);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// return ret;
+// }
+// *session_data_size = psession.size;
+//
+// if (psession.size > *session_data_size)
+// {
+// ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
+// goto error;
+// }
+//
+// if (session_data != NULL)
+// memcpy (session_data, psession.data, psession.size);
+//
+// ret = 0;
+//
+//error:
+// _gnutls_free_datum (&psession);
+// return ret;
+//}
/**
* gnutls_session_get_data2 - Returns all session parameters.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @session_data: is a pointer to a datum that will hold the session.
*
* Returns all session parameters, in order to support resuming.
@@ -90,34 +92,34 @@ error:
*
* Resuming sessions is really useful and speedups connections after a succesful one.
**/
-int
-gnutls_session_get_data2 (gnutls_session_t session, gnutls_datum_t * data)
-{
-
- int ret;
-
- if (data == NULL)
- {
- return GNUTLS_E_INVALID_REQUEST;
- }
-
- if (session->internals.resumable == RESUME_FALSE)
- return GNUTLS_E_INVALID_SESSION;
-
- ret = _gnutls_session_pack (session, data);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- return 0;
-}
+//int
+//gnutls_session_get_data2 (mhd_gtls_session_t session, gnutls_datum_t * data)
+//{
+//
+// int ret;
+//
+// if (data == NULL)
+// {
+// return GNUTLS_E_INVALID_REQUEST;
+// }
+//
+// if (session->internals.resumable == RESUME_FALSE)
+// return GNUTLS_E_INVALID_SESSION;
+//
+// ret = _gnutls_session_pack (session, data);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// return ret;
+// }
+//
+// return 0;
+//}
/**
- * gnutls_session_get_id - Returns session id.
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_get_id - Returns session id.
+ * @session: is a #mhd_gtls_session_t structure.
* @session_id: is a pointer to space to hold the session id.
* @session_id_size: is the session id's size, or it will be set by the function.
*
@@ -132,7 +134,7 @@ gnutls_session_get_data2 (gnutls_session_t session, gnutls_datum_t * data)
* Returns zero on success.
**/
int
-gnutls_session_get_id (gnutls_session_t session,
+MHD_gtls_session_get_id (mhd_gtls_session_t session,
void *session_id, size_t * session_id_size)
{
size_t given_session_id_size = *session_id_size;
@@ -158,13 +160,13 @@ gnutls_session_get_id (gnutls_session_t session,
/**
* gnutls_session_set_data - Sets all session parameters
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @session_data: is a pointer to space to hold the session.
* @session_data_size: is the session's size
*
* Sets all session parameters, in order to resume a previously established
* session. The session data given must be the one returned by gnutls_session_get_data().
- * This function should be called before gnutls_handshake().
+ * This function should be called before MHD_gnutls_handshake().
*
* Keep in mind that session resuming is advisory. The server may
* choose not to resume the session, thus a full handshake will be
@@ -173,27 +175,27 @@ gnutls_session_get_id (gnutls_session_t session,
* Returns a negative value on error.
*
**/
-int
-gnutls_session_set_data (gnutls_session_t session,
- const void *session_data, size_t session_data_size)
-{
- int ret;
- gnutls_datum_t psession;
-
- psession.data = (opaque *) session_data;
- psession.size = session_data_size;
-
- if (session_data == NULL || session_data_size == 0)
- {
- gnutls_assert ();
- return GNUTLS_E_INVALID_REQUEST;
- }
- ret = _gnutls_session_unpack (session, &psession);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- return 0;
-}
+//int
+//gnutls_session_set_data (mhd_gtls_session_t session,
+// const void *session_data, size_t session_data_size)
+//{
+// int ret;
+// gnutls_datum_t psession;
+//
+// psession.data = (opaque *) session_data;
+// psession.size = session_data_size;
+//
+// if (session_data == NULL || session_data_size == 0)
+// {
+// gnutls_assert ();
+// return GNUTLS_E_INVALID_REQUEST;
+// }
+// ret = _gnutls_session_unpack (session, &psession);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// return ret;
+// }
+//
+// return 0;
+//}
diff --git a/src/daemon/https/tls/gnutls_session_pack.c b/src/daemon/https/tls/gnutls_session_pack.c
@@ -43,15 +43,15 @@
#define PACK_HEADER_SIZE 1
#define MAX_SEC_PARAMS 7+MAX_SRP_USERNAME+MAX_SERVER_NAME_EXTENSIONS*(3+MAX_SERVER_NAME_SIZE)+165
-static int pack_certificate_auth_info (gnutls_session_t,
+static int pack_certificate_auth_info (mhd_gtls_session_t,
gnutls_datum_t * packed_session);
-static int unpack_certificate_auth_info (gnutls_session_t,
+static int unpack_certificate_auth_info (mhd_gtls_session_t,
const gnutls_datum_t *
packed_session);
-static int unpack_security_parameters (gnutls_session_t session,
+static int unpack_security_parameters (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session);
-static int pack_security_parameters (gnutls_session_t session,
+static int pack_security_parameters (mhd_gtls_session_t session,
gnutls_datum_t * packed_session);
/* Packs the ANON session authentication data. */
@@ -69,9 +69,9 @@ static int pack_security_parameters (gnutls_session_t session,
* x bytes the public key
*/
static int
-pack_anon_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
+pack_anon_auth_info (mhd_gtls_session_t session, gnutls_datum_t * packed_session)
{
- anon_auth_info_t info = _gnutls_get_auth_info (session);
+ mhd_anon_auth_info_t info = mhd_gtls_get_auth_info (session);
int pos = 0;
size_t pack_size;
@@ -95,19 +95,19 @@ pack_anon_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
}
packed_session->data[0] = MHD_GNUTLS_CRD_ANON;
- _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+ mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
pos += 4 + PACK_HEADER_SIZE;
if (pack_size > 0)
{
- _gnutls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
+ mhd_gtls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
pos += 2;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
pos += 4 + info->dh.prime.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
pos += 4 + info->dh.generator.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
pos += 4 + info->dh.public_key.size;
}
@@ -127,12 +127,12 @@ pack_anon_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
* x bytes the public key
*/
static int
-unpack_anon_auth_info (gnutls_session_t session,
+unpack_anon_auth_info (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
size_t pack_size;
int pos = 0, size, ret;
- anon_auth_info_t info;
+ mhd_anon_auth_info_t info;
if (packed_session->data[0] != MHD_GNUTLS_CRD_ANON)
{
@@ -140,7 +140,7 @@ unpack_anon_auth_info (gnutls_session_t session,
return GNUTLS_E_INVALID_REQUEST;
}
- pack_size = _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+ pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
pos += PACK_HEADER_SIZE + 4;
@@ -157,7 +157,7 @@ unpack_anon_auth_info (gnutls_session_t session,
/* client and serer have the same auth_info here
*/
ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
sizeof (anon_auth_info_st), 1);
if (ret < 0)
{
@@ -165,17 +165,17 @@ unpack_anon_auth_info (gnutls_session_t session,
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- info->dh.secret_bits = _gnutls_read_uint16 (&packed_session->data[pos]);
+ info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
if (ret < 0)
@@ -185,7 +185,7 @@ unpack_anon_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
@@ -196,7 +196,7 @@ unpack_anon_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
@@ -227,7 +227,7 @@ error:
* The data will be in a platform independent format.
*/
int
-_gnutls_session_pack (gnutls_session_t session,
+_gnutls_session_pack (mhd_gtls_session_t session,
gnutls_datum_t * packed_session)
{
int ret;
@@ -239,7 +239,7 @@ _gnutls_session_pack (gnutls_session_t session,
}
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
#ifdef ENABLE_SRP
case MHD_GNUTLS_CRD_SRP:
@@ -284,7 +284,7 @@ _gnutls_session_pack (gnutls_session_t session,
}
- /* Auth_info structures copied. Now copy security_parameters_st.
+ /* Auth_info structures copied. Now copy mhd_gtls_security_param_st.
* packed_session must have allocated space for the security parameters.
*/
ret = pack_security_parameters (session, packed_session);
@@ -302,7 +302,7 @@ _gnutls_session_pack (gnutls_session_t session,
/* Load session data from a buffer.
*/
int
-_gnutls_session_unpack (gnutls_session_t session,
+_gnutls_session_unpack (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
int ret;
@@ -313,9 +313,9 @@ _gnutls_session_unpack (gnutls_session_t session,
return GNUTLS_E_INTERNAL_ERROR;
}
- if (_gnutls_get_auth_info (session) != NULL)
+ if (mhd_gtls_get_auth_info (session) != NULL)
{
- _gnutls_free_auth_info (session);
+ mhd_gtls_free_auth_info (session);
}
switch (packed_session->data[0])
@@ -364,7 +364,7 @@ _gnutls_session_unpack (gnutls_session_t session,
}
- /* Auth_info structures copied. Now copy security_parameters_st.
+ /* Auth_info structures copied. Now copy mhd_gtls_security_param_st.
* packed_session must have allocated space for the security parameters.
*/
ret = unpack_security_parameters (session, packed_session);
@@ -401,12 +401,12 @@ _gnutls_session_unpack (gnutls_session_t session,
* and so on...
*/
static int
-pack_certificate_auth_info (gnutls_session_t session,
+pack_certificate_auth_info (mhd_gtls_session_t session,
gnutls_datum_t * packed_session)
{
unsigned int pos = 0, i;
int cert_size, pack_size;
- cert_auth_info_t info = _gnutls_get_auth_info (session);
+ cert_auth_info_t info = mhd_gtls_get_auth_info (session);
if (info)
{
@@ -437,36 +437,36 @@ pack_certificate_auth_info (gnutls_session_t session,
}
packed_session->data[0] = MHD_GNUTLS_CRD_CERTIFICATE;
- _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+ mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
pos += 4 + PACK_HEADER_SIZE;
if (pack_size > 0)
{
- _gnutls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
+ mhd_gtls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
pos += 2;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
pos += 4 + info->dh.prime.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
pos += 4 + info->dh.generator.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
pos += 4 + info->dh.public_key.size;
- _gnutls_write_datum32 (&packed_session->data[pos],
+ mhd_gtls_write_datum32 (&packed_session->data[pos],
info->rsa_export.modulus);
pos += 4 + info->rsa_export.modulus.size;
- _gnutls_write_datum32 (&packed_session->data[pos],
+ mhd_gtls_write_datum32 (&packed_session->data[pos],
info->rsa_export.exponent);
pos += 4 + info->rsa_export.exponent.size;
- _gnutls_write_uint32 (info->ncerts, &packed_session->data[pos]);
+ mhd_gtls_write_uint32 (info->ncerts, &packed_session->data[pos]);
pos += 4;
for (i = 0; i < info->ncerts; i++)
{
- _gnutls_write_datum32 (&packed_session->data[pos],
+ mhd_gtls_write_datum32 (&packed_session->data[pos],
info->raw_certificate_list[i]);
pos += sizeof (uint32_t) + info->raw_certificate_list[i].size;
}
@@ -479,7 +479,7 @@ pack_certificate_auth_info (gnutls_session_t session,
/* Upack certificate info.
*/
static int
-unpack_certificate_auth_info (gnutls_session_t session,
+unpack_certificate_auth_info (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
int pos = 0, size, ret;
@@ -493,7 +493,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
return GNUTLS_E_INVALID_REQUEST;
}
- pack_size = _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+ pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
pos += PACK_HEADER_SIZE + 4;
if (pack_size == 0)
@@ -509,7 +509,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
/* client and server have the same auth_info here
*/
ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 1);
if (ret < 0)
{
@@ -517,17 +517,17 @@ unpack_certificate_auth_info (gnutls_session_t session,
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- info->dh.secret_bits = _gnutls_read_uint16 (&packed_session->data[pos]);
+ info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
if (ret < 0)
@@ -537,7 +537,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
@@ -548,7 +548,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
@@ -560,7 +560,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->rsa_export.modulus,
@@ -572,7 +572,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->rsa_export.exponent,
@@ -584,7 +584,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
}
pos += size;
- info->ncerts = _gnutls_read_uint32 (&packed_session->data[pos]);
+ info->ncerts = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
if (info->ncerts > 0)
@@ -601,7 +601,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
for (i = 0; i < info->ncerts; i++)
{
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += sizeof (uint32_t);
ret =
@@ -646,9 +646,9 @@ error:
* x bytes the SRP username
*/
static int
-pack_srp_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
+pack_srp_auth_info (mhd_gtls_session_t session, gnutls_datum_t * packed_session)
{
- srp_server_auth_info_t info = _gnutls_get_auth_info (session);
+ srp_server_auth_info_t info = mhd_gtls_get_auth_info (session);
int pack_size;
if (info && info->username)
@@ -670,7 +670,7 @@ pack_srp_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
}
packed_session->data[0] = MHD_GNUTLS_CRD_SRP;
- _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+ mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
if (pack_size > 0)
memcpy (&packed_session->data[PACK_HEADER_SIZE + sizeof (uint32_t)],
@@ -681,7 +681,7 @@ pack_srp_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
static int
-unpack_srp_auth_info (gnutls_session_t session,
+unpack_srp_auth_info (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
size_t username_size;
@@ -695,7 +695,7 @@ unpack_srp_auth_info (gnutls_session_t session,
}
username_size =
- _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+ mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
if (username_size == 0)
return 0; /* nothing to be done */
@@ -708,7 +708,7 @@ unpack_srp_auth_info (gnutls_session_t session,
}
ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_SRP,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_SRP,
sizeof (srp_server_auth_info_st), 1);
if (ret < 0)
{
@@ -716,7 +716,7 @@ unpack_srp_auth_info (gnutls_session_t session,
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
@@ -751,12 +751,12 @@ unpack_srp_auth_info (gnutls_session_t session,
* x bytes the public key
*/
static int
-pack_psk_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
+pack_psk_auth_info (mhd_gtls_session_t session, gnutls_datum_t * packed_session)
{
psk_auth_info_t info;
int pack_size, username_size = 0, pos;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info)
{
@@ -786,26 +786,26 @@ pack_psk_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
packed_session->data[pos] = MHD_GNUTLS_CRD_PSK;
pos++;
- _gnutls_write_uint32 (pack_size, &packed_session->data[pos]);
+ mhd_gtls_write_uint32 (pack_size, &packed_session->data[pos]);
pos += 4;
if (pack_size > 0)
{
- _gnutls_write_uint32 (username_size, &packed_session->data[pos]);
+ mhd_gtls_write_uint32 (username_size, &packed_session->data[pos]);
pos += 4;
memcpy (&packed_session->data[pos], info->username, username_size);
pos += username_size;
- _gnutls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
+ mhd_gtls_write_uint16 (info->dh.secret_bits, &packed_session->data[pos]);
pos += 2;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
pos += 4 + info->dh.prime.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
pos += 4 + info->dh.generator.size;
- _gnutls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
+ mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.public_key);
pos += 4 + info->dh.public_key.size;
}
@@ -815,7 +815,7 @@ pack_psk_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
}
static int
-unpack_psk_auth_info (gnutls_session_t session,
+unpack_psk_auth_info (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
size_t username_size;
@@ -829,7 +829,7 @@ unpack_psk_auth_info (gnutls_session_t session,
return GNUTLS_E_INVALID_REQUEST;
}
- pack_size = _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+ pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
pos += PACK_HEADER_SIZE + 4;
@@ -846,7 +846,7 @@ unpack_psk_auth_info (gnutls_session_t session,
/* client and serer have the same auth_info here
*/
ret =
- _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_PSK,
+ mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_PSK,
sizeof (psk_auth_info_st), 1);
if (ret < 0)
{
@@ -854,23 +854,23 @@ unpack_psk_auth_info (gnutls_session_t session,
return ret;
}
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- username_size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ username_size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
memcpy (info->username, &packed_session->data[pos], username_size);
pos += username_size;
- info->dh.secret_bits = _gnutls_read_uint16 (&packed_session->data[pos]);
+ info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
if (ret < 0)
@@ -880,7 +880,7 @@ unpack_psk_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
@@ -891,7 +891,7 @@ unpack_psk_auth_info (gnutls_session_t session,
}
pos += size;
- size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
ret =
_gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
@@ -963,7 +963,7 @@ error:
* MAX: 7+MAX_SRP_USERNAME+MAX_SERVER_NAME_EXTENSIONS*(3+MAX_SERVER_NAME_SIZE)
*/
static int
-pack_security_parameters (gnutls_session_t session,
+pack_security_parameters (mhd_gtls_session_t session,
gnutls_datum_t * packed_session)
{
int pos = 0;
@@ -972,7 +972,7 @@ pack_security_parameters (gnutls_session_t session,
/* move after the auth info stuff.
*/
init =
- _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
+ mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
PACK_HEADER_SIZE;
pos = init + 4; /* make some space to write later the size */
@@ -1015,16 +1015,16 @@ pack_security_parameters (gnutls_session_t session,
session->security_parameters.session_id_size);
pos += session->security_parameters.session_id_size;
- _gnutls_write_uint32 (session->security_parameters.timestamp,
+ mhd_gtls_write_uint32 (session->security_parameters.timestamp,
&packed_session->data[pos]);
pos += 4;
/* Extensions */
- _gnutls_write_uint16 (session->security_parameters.max_record_send_size,
+ mhd_gtls_write_uint16 (session->security_parameters.max_record_send_size,
&packed_session->data[pos]);
pos += 2;
- _gnutls_write_uint16 (session->security_parameters.max_record_recv_size,
+ mhd_gtls_write_uint16 (session->security_parameters.max_record_recv_size,
&packed_session->data[pos]);
pos += 2;
@@ -1036,7 +1036,7 @@ pack_security_parameters (gnutls_session_t session,
session->security_parameters.extensions.srp_username, len);
pos += len;
- _gnutls_write_uint16 (session->security_parameters.extensions.
+ mhd_gtls_write_uint16 (session->security_parameters.extensions.
server_names_size, &packed_session->data[pos]);
pos += 2;
@@ -1045,7 +1045,7 @@ pack_security_parameters (gnutls_session_t session,
{
packed_session->data[pos++] =
session->security_parameters.extensions.server_names[i].type;
- _gnutls_write_uint16 (session->security_parameters.extensions.
+ mhd_gtls_write_uint16 (session->security_parameters.extensions.
server_names[i].name_length,
&packed_session->data[pos]);
pos += 2;
@@ -1059,7 +1059,7 @@ pack_security_parameters (gnutls_session_t session,
}
/* write the total size */
- _gnutls_write_uint32 (pos - init - 4, &packed_session->data[init]);
+ mhd_gtls_write_uint32 (pos - init - 4, &packed_session->data[init]);
packed_session->size += pos - init;
return 0;
@@ -1067,7 +1067,7 @@ pack_security_parameters (gnutls_session_t session,
static int
-unpack_security_parameters (gnutls_session_t session,
+unpack_security_parameters (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session)
{
size_t pack_size, init, i;
@@ -1077,12 +1077,12 @@ unpack_security_parameters (gnutls_session_t session,
/* skip the auth info stuff */
init =
- _gnutls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
+ mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
PACK_HEADER_SIZE;
pos = init;
- pack_size = _gnutls_read_uint32 (&packed_session->data[pos]);
+ pack_size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
@@ -1141,7 +1141,7 @@ unpack_security_parameters (gnutls_session_t session,
pos += session->internals.resumed_security_parameters.session_id_size;
session->internals.resumed_security_parameters.timestamp =
- _gnutls_read_uint32 (&packed_session->data[pos]);
+ mhd_gtls_read_uint32 (&packed_session->data[pos]);
pos += 4;
if (timestamp - session->internals.resumed_security_parameters.timestamp >
@@ -1154,11 +1154,11 @@ unpack_security_parameters (gnutls_session_t session,
/* Extensions */
session->internals.resumed_security_parameters.max_record_send_size =
- _gnutls_read_uint16 (&packed_session->data[pos]);
+ mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
session->internals.resumed_security_parameters.max_record_recv_size =
- _gnutls_read_uint16 (&packed_session->data[pos]);
+ mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
@@ -1171,7 +1171,7 @@ unpack_security_parameters (gnutls_session_t session,
pos += len;
session->internals.resumed_security_parameters.extensions.
- server_names_size = _gnutls_read_uint16 (&packed_session->data[pos]);
+ server_names_size = mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
for (i = 0;
i <
@@ -1182,7 +1182,7 @@ unpack_security_parameters (gnutls_session_t session,
server_names[i].type = packed_session->data[pos++];
session->internals.resumed_security_parameters.extensions.
server_names[i].name_length =
- _gnutls_read_uint16 (&packed_session->data[pos]);
+ mhd_gtls_read_uint16 (&packed_session->data[pos]);
pos += 2;
memcpy (session->internals.resumed_security_parameters.extensions.
diff --git a/src/daemon/https/tls/gnutls_session_pack.h b/src/daemon/https/tls/gnutls_session_pack.h
@@ -22,7 +22,7 @@
*
*/
-int _gnutls_session_pack (gnutls_session_t session,
+int _gnutls_session_pack (mhd_gtls_session_t session,
gnutls_datum_t * packed_session);
-int _gnutls_session_unpack (gnutls_session_t session,
+int _gnutls_session_unpack (mhd_gtls_session_t session,
const gnutls_datum_t * packed_session);
diff --git a/src/daemon/https/tls/gnutls_sig.c b/src/daemon/https/tls/gnutls_sig.c
@@ -37,7 +37,7 @@
#include <gnutls_sig.h>
#include <gnutls_kx.h>
-static int _gnutls_tls_sign (gnutls_session_t session,
+static int _gnutls_tls_sign (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey,
const gnutls_datum_t * hash_concat,
@@ -47,7 +47,7 @@ static int _gnutls_tls_sign (gnutls_session_t session,
* handshake procedure. (20040227: now it works for SSL 3.0 as well)
*/
int
-_gnutls_tls_sign_hdata (gnutls_session_t session,
+mhd_gtls_tls_sign_hdata (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey, gnutls_datum_t * signature)
{
@@ -56,9 +56,9 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
opaque concat[36];
mac_hd_t td_md5;
mac_hd_t td_sha;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
- td_sha = _gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+ td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
@@ -67,25 +67,25 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
if (ver == MHD_GNUTLS_SSL3)
{
- ret = _gnutls_generate_master (session, 1);
+ ret = mhd_gtls_generate_master (session, 1);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
- _gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
}
else
- _gnutls_hash_deinit (td_sha, &concat[16]);
+ mhd_gnutls_hash_deinit (td_sha, &concat[16]);
switch (cert->subject_pk_algorithm)
{
case MHD_GNUTLS_PK_RSA:
td_md5 =
- _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+ mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
@@ -93,11 +93,11 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
}
if (ver == MHD_GNUTLS_SSL3)
- _gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
else
- _gnutls_hash_deinit (td_md5, concat);
+ mhd_gnutls_hash_deinit (td_md5, concat);
dconcat.data = concat;
dconcat.size = 36;
@@ -119,7 +119,7 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
* Used in DHE_* ciphersuites.
*/
int
-_gnutls_tls_sign_params (gnutls_session_t session,
+mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey,
gnutls_datum_t * params, gnutls_datum_t * signature)
@@ -128,41 +128,41 @@ _gnutls_tls_sign_params (gnutls_session_t session,
int ret;
mac_hd_t td_sha;
opaque concat[36];
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
- td_sha = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ td_sha = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (td_sha == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td_sha, session->security_parameters.client_random,
+ mhd_gnutls_hash (td_sha, session->security_parameters.client_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_sha, session->security_parameters.server_random,
+ mhd_gnutls_hash (td_sha, session->security_parameters.server_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_sha, params->data, params->size);
+ mhd_gnutls_hash (td_sha, params->data, params->size);
switch (cert->subject_pk_algorithm)
{
case MHD_GNUTLS_PK_RSA:
if (ver < MHD_GNUTLS_TLS1_2)
{
- mac_hd_t td_md5 = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
+ mac_hd_t td_md5 = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td_md5 == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td_md5, session->security_parameters.client_random,
+ mhd_gnutls_hash (td_md5, session->security_parameters.client_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_md5, session->security_parameters.server_random,
+ mhd_gnutls_hash (td_md5, session->security_parameters.server_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_md5, params->data, params->size);
+ mhd_gnutls_hash (td_md5, params->data, params->size);
- _gnutls_hash_deinit (td_md5, concat);
- _gnutls_hash_deinit (td_sha, &concat[16]);
+ mhd_gnutls_hash_deinit (td_md5, concat);
+ mhd_gnutls_hash_deinit (td_sha, &concat[16]);
dconcat.size = 36;
}
@@ -173,13 +173,13 @@ _gnutls_tls_sign_params (gnutls_session_t session,
memcpy (concat,
"\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
15);
- _gnutls_hash_deinit (td_sha, &concat[15]);
+ mhd_gnutls_hash_deinit (td_sha, &concat[15]);
dconcat.size = 35;
#else
/* No parameters field. */
memcpy (concat,
"\x30\x1f\x30\x07\x06\x05\x2b\x0e\x03\x02\x1a\x04\x14", 13);
- _gnutls_hash_deinit (td_sha, &concat[13]);
+ mhd_gnutls_hash_deinit (td_sha, &concat[13]);
dconcat.size = 33;
#endif
}
@@ -187,7 +187,7 @@ _gnutls_tls_sign_params (gnutls_session_t session,
break;
default:
gnutls_assert ();
- _gnutls_hash_deinit (td_sha, NULL);
+ mhd_gnutls_hash_deinit (td_sha, NULL);
return GNUTLS_E_INTERNAL_ERROR;
}
ret = _gnutls_tls_sign (session, cert, pkey, &dconcat, signature);
@@ -204,7 +204,7 @@ _gnutls_tls_sign_params (gnutls_session_t session,
* given data. The output will be allocated and be put in signature.
*/
int
-_gnutls_sign (gnutls_pk_algorithm_t algo,
+mhd_gtls_sign (gnutls_pk_algorithm_t algo,
mpi_t * params,
int params_size,
const gnutls_datum_t * data, gnutls_datum_t * signature)
@@ -216,7 +216,7 @@ _gnutls_sign (gnutls_pk_algorithm_t algo,
case MHD_GNUTLS_PK_RSA:
/* encrypt */
if ((ret =
- _gnutls_pkcs1_rsa_encrypt (signature, data, params, params_size,
+ mhd_gtls_pkcs1_rsa_encrypt (signature, data, params, params_size,
1)) < 0)
{
gnutls_assert ();
@@ -238,7 +238,7 @@ _gnutls_sign (gnutls_pk_algorithm_t algo,
* it supports signing.
*/
static int
-_gnutls_tls_sign (gnutls_session_t session,
+_gnutls_tls_sign (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey,
const gnutls_datum_t * hash_concat,
@@ -269,7 +269,7 @@ _gnutls_tls_sign (gnutls_session_t session,
hash_concat, signature);
}
- return _gnutls_sign (pkey->pk_algorithm, pkey->params, pkey->params_size,
+ return mhd_gtls_sign (pkey->pk_algorithm, pkey->params, pkey->params_size,
hash_concat, signature);
}
@@ -307,7 +307,7 @@ _gnutls_verify_sig (gnutls_cert * cert,
vdata.size = hash_concat->size;
/* verify signature */
- if ((ret = _gnutls_rsa_verify (&vdata, signature, cert->params,
+ if ((ret = mhd_gtls_rsa_verify (&vdata, signature, cert->params,
cert->params_size, 1)) < 0)
{
gnutls_assert ();
@@ -327,7 +327,7 @@ _gnutls_verify_sig (gnutls_cert * cert,
* verify message).
*/
int
-_gnutls_verify_sig_hdata (gnutls_session_t session,
+mhd_gtls_verify_sig_hdata (mhd_gtls_session_t session,
gnutls_cert * cert, gnutls_datum_t * signature)
{
int ret;
@@ -335,43 +335,43 @@ _gnutls_verify_sig_hdata (gnutls_session_t session,
mac_hd_t td_md5;
mac_hd_t td_sha;
gnutls_datum_t dconcat;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
- td_md5 = _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+ td_md5 = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- td_sha = _gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+ td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
- _gnutls_hash_deinit (td_md5, NULL);
+ mhd_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
if (ver == MHD_GNUTLS_SSL3)
{
- ret = _gnutls_generate_master (session, 1);
+ ret = mhd_gtls_generate_master (session, 1);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
- _gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
- _gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
+ mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
}
else
{
- _gnutls_hash_deinit (td_md5, concat);
- _gnutls_hash_deinit (td_sha, &concat[16]);
+ mhd_gnutls_hash_deinit (td_md5, concat);
+ mhd_gnutls_hash_deinit (td_sha, &concat[16]);
}
dconcat.data = concat;
@@ -392,7 +392,7 @@ _gnutls_verify_sig_hdata (gnutls_session_t session,
* Used in DHE_* ciphersuites.
*/
int
-_gnutls_verify_sig_params (gnutls_session_t session,
+mhd_gtls_verify_sig_params (mhd_gtls_session_t session,
gnutls_cert * cert,
const gnutls_datum_t * params,
gnutls_datum_t * signature)
@@ -402,43 +402,43 @@ _gnutls_verify_sig_params (gnutls_session_t session,
mac_hd_t td_md5 = NULL;
mac_hd_t td_sha;
opaque concat[36];
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
if (ver < MHD_GNUTLS_TLS1_2)
{
- td_md5 = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
+ td_md5 = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td_md5 == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td_md5, session->security_parameters.client_random,
+ mhd_gnutls_hash (td_md5, session->security_parameters.client_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_md5, session->security_parameters.server_random,
+ mhd_gnutls_hash (td_md5, session->security_parameters.server_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_md5, params->data, params->size);
+ mhd_gnutls_hash (td_md5, params->data, params->size);
}
- td_sha = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ td_sha = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (td_sha == NULL)
{
gnutls_assert ();
if (td_md5)
- _gnutls_hash_deinit (td_md5, NULL);
+ mhd_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (td_sha, session->security_parameters.client_random,
+ mhd_gnutls_hash (td_sha, session->security_parameters.client_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_sha, session->security_parameters.server_random,
+ mhd_gnutls_hash (td_sha, session->security_parameters.server_random,
TLS_RANDOM_SIZE);
- _gnutls_hash (td_sha, params->data, params->size);
+ mhd_gnutls_hash (td_sha, params->data, params->size);
if (ver < MHD_GNUTLS_TLS1_2)
{
- _gnutls_hash_deinit (td_md5, concat);
- _gnutls_hash_deinit (td_sha, &concat[16]);
+ mhd_gnutls_hash_deinit (td_md5, concat);
+ mhd_gnutls_hash_deinit (td_sha, &concat[16]);
dconcat.size = 36;
}
else
@@ -448,13 +448,13 @@ _gnutls_verify_sig_params (gnutls_session_t session,
memcpy (concat,
"\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
15);
- _gnutls_hash_deinit (td_sha, &concat[15]);
+ mhd_gnutls_hash_deinit (td_sha, &concat[15]);
dconcat.size = 35;
#else
/* No parameters field. */
memcpy (concat,
"\x30\x1f\x30\x07\x06\x05\x2b\x0e\x03\x02\x1a\x04\x14", 13);
- _gnutls_hash_deinit (td_sha, &concat[13]);
+ mhd_gnutls_hash_deinit (td_sha, &concat[13]);
dconcat.size = 33;
#endif
}
diff --git a/src/daemon/https/tls/gnutls_sig.h b/src/daemon/https/tls/gnutls_sig.h
@@ -25,26 +25,26 @@
#ifndef GNUTLS_SIG_H
# define GNUTLS_SIG_H
-int _gnutls_tls_sign_hdata (gnutls_session_t session,
+int mhd_gtls_tls_sign_hdata (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey,
gnutls_datum_t * signature);
-int _gnutls_tls_sign_params (gnutls_session_t session,
+int mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
gnutls_cert * cert,
gnutls_privkey * pkey,
gnutls_datum_t * params,
gnutls_datum_t * signature);
-int _gnutls_verify_sig_hdata (gnutls_session_t session,
+int mhd_gtls_verify_sig_hdata (mhd_gtls_session_t session,
gnutls_cert * cert, gnutls_datum_t * signature);
-int _gnutls_verify_sig_params (gnutls_session_t session,
+int mhd_gtls_verify_sig_params (mhd_gtls_session_t session,
gnutls_cert * cert,
const gnutls_datum_t * params,
gnutls_datum_t * signature);
-int _gnutls_sign (gnutls_pk_algorithm_t algo,
+int mhd_gtls_sign (gnutls_pk_algorithm_t algo,
mpi_t * params, int params_size,
const gnutls_datum_t * data, gnutls_datum_t * signature);
diff --git a/src/daemon/https/tls/gnutls_state.c b/src/daemon/https/tls/gnutls_state.c
@@ -43,7 +43,7 @@
#include <gnutls_rsa_export.h>
void
-_gnutls_session_cert_type_set (gnutls_session_t session,
+_gnutls_session_cert_type_set (mhd_gtls_session_t session,
gnutls_certificate_type_t ct)
{
session->security_parameters.cert_type = ct;
@@ -51,19 +51,19 @@ _gnutls_session_cert_type_set (gnutls_session_t session,
/**
* gnutls_cipher_get - Returns the currently used cipher.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the currently used cipher.
**/
gnutls_cipher_algorithm_t
-gnutls_cipher_get (gnutls_session_t session)
+gnutls_cipher_get (mhd_gtls_session_t session)
{
return session->security_parameters.read_bulk_cipher_algorithm;
}
/**
* gnutls_certificate_type_get - Returns the currently used certificate type.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* The certificate type is by default X.509, unless it is negotiated
* as a TLS extension.
@@ -72,43 +72,43 @@ gnutls_cipher_get (gnutls_session_t session)
* type.
**/
gnutls_certificate_type_t
-gnutls_certificate_type_get (gnutls_session_t session)
+gnutls_certificate_type_get (mhd_gtls_session_t session)
{
return session->security_parameters.cert_type;
}
/**
* gnutls_kx_get - Returns the key exchange algorithm.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the key exchange algorithm used in the last handshake.
**/
gnutls_kx_algorithm_t
-gnutls_kx_get (gnutls_session_t session)
+gnutls_kx_get (mhd_gtls_session_t session)
{
return session->security_parameters.kx_algorithm;
}
/**
* gnutls_mac_get - Returns the currently used mac algorithm.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the currently used mac algorithm.
**/
gnutls_mac_algorithm_t
-gnutls_mac_get (gnutls_session_t session)
+gnutls_mac_get (mhd_gtls_session_t session)
{
return session->security_parameters.read_mac_algorithm;
}
/**
* gnutls_compression_get - Returns the currently used compression algorithm.
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the currently used compression method.
**/
gnutls_compression_method_t
-gnutls_compression_get (gnutls_session_t session)
+gnutls_compression_get (mhd_gtls_session_t session)
{
return session->security_parameters.read_compression_algorithm;
}
@@ -118,17 +118,17 @@ gnutls_compression_get (gnutls_session_t session)
* and a matching certificate exists.
*/
int
-_gnutls_session_cert_type_supported (gnutls_session_t session,
+mhd_gtls_session_cert_type_supported (mhd_gtls_session_t session,
gnutls_certificate_type_t cert_type)
{
unsigned i;
unsigned cert_found = 0;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
if (session->security_parameters.entity == GNUTLS_SERVER)
{
cred
- = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
+ = (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
MHD_GNUTLS_CRD_CERTIFICATE,
NULL);
@@ -172,13 +172,13 @@ _gnutls_session_cert_type_supported (gnutls_session_t session,
* in a session struct.
*/
inline static void
-deinit_internal_params (gnutls_session_t session)
+deinit_internal_params (mhd_gtls_session_t session)
{
if (session->internals.params.free_dh_params)
- gnutls_dh_params_deinit (session->internals.params.dh_params);
+ MHD_gnutls_dh_params_deinit (session->internals.params.dh_params);
if (session->internals.params.free_rsa_params)
- gnutls_rsa_params_deinit (session->internals.params.rsa_params);
+ MHD_gnutls_rsa_params_deinit (session->internals.params.rsa_params);
memset (&session->internals.params, 0, sizeof (session->internals.params));
}
@@ -188,7 +188,7 @@ deinit_internal_params (gnutls_session_t session)
* This is used to allow further handshakes.
*/
void
-_gnutls_handshake_internal_state_clear (gnutls_session_t session)
+mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
{
session->internals.extensions_sent_size = 0;
@@ -198,7 +198,7 @@ _gnutls_handshake_internal_state_clear (gnutls_session_t session)
session->internals.adv_version_minor = 0;
session->internals.v2_hello = 0;
memset (&session->internals.handshake_header_buffer, 0,
- sizeof (handshake_header_buffer_st));
+ sizeof (mhd_gtls_handshake_header_buffer_st));
session->internals.adv_version_minor = 0;
session->internals.adv_version_minor = 0;
session->internals.direction = 0;
@@ -218,14 +218,14 @@ _gnutls_handshake_internal_state_clear (gnutls_session_t session)
#define MIN_DH_BITS 727
/**
- * gnutls_init - This function initializes the session to null (null encryption etc...).
+ * MHD_gnutls_init - This function initializes the session to null (null encryption etc...).
* @con_end: indicate if this session is to be used for server or client.
- * @session: is a pointer to a #gnutls_session_t structure.
+ * @session: is a pointer to a #mhd_gtls_session_t structure.
*
* This function initializes the current session to null. Every
* session must be initialized before use, so internal structures can
* be allocated. This function allocates structures which can only
- * be free'd by calling gnutls_deinit(). Returns zero on success.
+ * be free'd by calling MHD_gnutls_deinit(). Returns zero on success.
*
* @con_end can be one of %GNUTLS_CLIENT and %GNUTLS_SERVER.
*
@@ -234,9 +234,9 @@ _gnutls_handshake_internal_state_clear (gnutls_session_t session)
/* TODO rm redundent pointer ref */
int
-gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
+MHD_gnutls_init (mhd_gtls_session_t * session, gnutls_connection_end_t con_end)
{
- *session = gnutls_calloc (1, sizeof (struct gnutls_session_int));
+ *session = gnutls_calloc (1, sizeof (struct MHD_gtls_session_int));
if (*session == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -261,18 +261,18 @@ gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
(*session)->internals.enable_private = 0;
/* Initialize buffers */
- _gnutls_buffer_init (&(*session)->internals.application_data_buffer);
- _gnutls_buffer_init (&(*session)->internals.handshake_data_buffer);
- _gnutls_buffer_init (&(*session)->internals.handshake_hash_buffer);
- _gnutls_buffer_init (&(*session)->internals.ia_data_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.application_data_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.handshake_data_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.handshake_hash_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.ia_data_buffer);
- _gnutls_buffer_init (&(*session)->internals.record_send_buffer);
- _gnutls_buffer_init (&(*session)->internals.record_recv_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.record_send_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.record_recv_buffer);
- _gnutls_buffer_init (&(*session)->internals.handshake_send_buffer);
- _gnutls_buffer_init (&(*session)->internals.handshake_recv_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.handshake_send_buffer);
+ mhd_gtls_buffer_init (&(*session)->internals.handshake_recv_buffer);
- (*session)->key = gnutls_calloc (1, sizeof (struct gnutls_key_st));
+ (*session)->key = gnutls_calloc (1, sizeof (struct mhd_gtls_key));
if ((*session)->key == NULL)
{
cleanup_session:gnutls_free (*session);
@@ -282,11 +282,11 @@ gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
(*session)->internals.expire_time = DEFAULT_EXPIRE_TIME; /* one hour default */
- gnutls_dh_set_prime_bits ((*session), MIN_DH_BITS);
+ MHD_gnutls_dh_set_prime_bits ((*session), MIN_DH_BITS);
- gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT); /* the default for tcp */
+ MHD_gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT); /* the default for tcp */
- gnutls_handshake_set_max_packet_length ((*session),
+ MHD_gnutls_handshake_set_max_packet_length ((*session),
MAX_HANDSHAKE_PACKET_SIZE);
/* Allocate a minimum size for recv_data
@@ -316,7 +316,7 @@ gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
* as NULL or 0. This is why calloc is used.
*/
- _gnutls_handshake_internal_state_clear (*session);
+ mhd_gtls_handshake_internal_state_clear (*session);
return 0;
}
@@ -324,54 +324,54 @@ gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
/* returns RESUME_FALSE or RESUME_TRUE.
*/
int
-_gnutls_session_is_resumable (gnutls_session_t session)
+mhd_gtls_session_is_resumable (mhd_gtls_session_t session)
{
return session->internals.resumable;
}
/**
- * gnutls_deinit - This function clears all buffers associated with a session
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_deinit - This function clears all buffers associated with a session
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function clears all buffers associated with the @session.
* This function will also remove session data from the session
* database if the session was terminated abnormally.
**/
void
-gnutls_deinit (gnutls_session_t session)
+MHD_gnutls_deinit (mhd_gtls_session_t session)
{
if (session == NULL)
return;
/* remove auth info firstly */
- _gnutls_free_auth_info (session);
+ mhd_gtls_free_auth_info (session);
- _gnutls_handshake_internal_state_clear (session);
+ mhd_gtls_handshake_internal_state_clear (session);
_gnutls_handshake_io_buffer_clear (session);
_gnutls_free_datum (&session->connection_state.read_mac_secret);
_gnutls_free_datum (&session->connection_state.write_mac_secret);
- _gnutls_buffer_clear (&session->internals.ia_data_buffer);
- _gnutls_buffer_clear (&session->internals.handshake_hash_buffer);
- _gnutls_buffer_clear (&session->internals.handshake_data_buffer);
- _gnutls_buffer_clear (&session->internals.application_data_buffer);
- _gnutls_buffer_clear (&session->internals.record_recv_buffer);
- _gnutls_buffer_clear (&session->internals.record_send_buffer);
+ mhd_gtls_buffer_clear (&session->internals.ia_data_buffer);
+ mhd_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
+ mhd_gtls_buffer_clear (&session->internals.handshake_data_buffer);
+ mhd_gtls_buffer_clear (&session->internals.application_data_buffer);
+ mhd_gtls_buffer_clear (&session->internals.record_recv_buffer);
+ mhd_gtls_buffer_clear (&session->internals.record_send_buffer);
- gnutls_credentials_clear (session);
- _gnutls_selected_certs_deinit (session);
+ MHD_gnutls_credentials_clear (session);
+ mhd_gtls_selected_certs_deinit (session);
if (session->connection_state.read_cipher_state != NULL)
- _gnutls_cipher_deinit (session->connection_state.read_cipher_state);
+ mhd_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
if (session->connection_state.write_cipher_state != NULL)
- _gnutls_cipher_deinit (session->connection_state.write_cipher_state);
+ mhd_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
if (session->connection_state.read_compression_state != NULL)
- _gnutls_comp_deinit (session->connection_state.read_compression_state, 1);
+ mhd_gtls_comp_deinit (session->connection_state.read_compression_state, 1);
if (session->connection_state.write_compression_state != NULL)
- _gnutls_comp_deinit (session->connection_state.
+ mhd_gtls_comp_deinit (session->connection_state.
write_compression_state, 0);
_gnutls_free_datum (&session->cipher_specs.server_write_mac_secret);
@@ -383,23 +383,23 @@ gnutls_deinit (gnutls_session_t session)
if (session->key != NULL)
{
- _gnutls_mpi_release (&session->key->KEY);
- _gnutls_mpi_release (&session->key->client_Y);
- _gnutls_mpi_release (&session->key->client_p);
- _gnutls_mpi_release (&session->key->client_g);
-
- _gnutls_mpi_release (&session->key->u);
- _gnutls_mpi_release (&session->key->a);
- _gnutls_mpi_release (&session->key->x);
- _gnutls_mpi_release (&session->key->A);
- _gnutls_mpi_release (&session->key->B);
- _gnutls_mpi_release (&session->key->b);
+ mhd_gtls_mpi_release (&session->key->KEY);
+ mhd_gtls_mpi_release (&session->key->client_Y);
+ mhd_gtls_mpi_release (&session->key->client_p);
+ mhd_gtls_mpi_release (&session->key->client_g);
+
+ mhd_gtls_mpi_release (&session->key->u);
+ mhd_gtls_mpi_release (&session->key->a);
+ mhd_gtls_mpi_release (&session->key->x);
+ mhd_gtls_mpi_release (&session->key->A);
+ mhd_gtls_mpi_release (&session->key->B);
+ mhd_gtls_mpi_release (&session->key->b);
/* RSA */
- _gnutls_mpi_release (&session->key->rsa[0]);
- _gnutls_mpi_release (&session->key->rsa[1]);
+ mhd_gtls_mpi_release (&session->key->rsa[0]);
+ mhd_gtls_mpi_release (&session->key->rsa[1]);
- _gnutls_mpi_release (&session->key->dh_secret);
+ mhd_gtls_mpi_release (&session->key->dh_secret);
gnutls_free (session->key);
session->key = NULL;
@@ -414,30 +414,30 @@ gnutls_deinit (gnutls_session_t session)
gnutls_free (session->internals.srp_password);
}
- memset (session, 0, sizeof (struct gnutls_session_int));
+ memset (session, 0, sizeof (struct MHD_gtls_session_int));
gnutls_free (session);
}
/* Returns the minimum prime bits that are acceptable.
*/
int
-_gnutls_dh_get_allowed_prime_bits (gnutls_session_t session)
+mhd_gtls_dh_get_allowed_prime_bits (mhd_gtls_session_t session)
{
return session->internals.dh_prime_bits;
}
int
-_gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
+mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
{
dh_info_st *dh;
int ret;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ mhd_anon_auth_info_t info;
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -448,7 +448,7 @@ _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -460,7 +460,7 @@ _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
return GNUTLS_E_INTERNAL_ERROR;
}
- ret = _gnutls_mpi_dprint_lz (&dh->public_key, public);
+ ret = mhd_gtls_mpi_dprint_lz (&dh->public_key, public);
if (ret < 0)
{
gnutls_assert ();
@@ -471,14 +471,14 @@ _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
}
int
-_gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits)
+mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits)
{
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ mhd_anon_auth_info_t info;
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
info->dh.secret_bits = bits;
@@ -488,7 +488,7 @@ _gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -507,24 +507,24 @@ _gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits)
* RSA exponent and the modulus.
*/
int
-_gnutls_rsa_export_set_pubkey (gnutls_session_t session,
+mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
mpi_t exponent, mpi_t modulus)
{
cert_auth_info_t info;
int ret;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
- ret = _gnutls_mpi_dprint_lz (&info->rsa_export.modulus, modulus);
+ ret = mhd_gtls_mpi_dprint_lz (&info->rsa_export.modulus, modulus);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
- ret = _gnutls_mpi_dprint_lz (&info->rsa_export.exponent, exponent);
+ ret = mhd_gtls_mpi_dprint_lz (&info->rsa_export.exponent, exponent);
if (ret < 0)
{
gnutls_assert ();
@@ -538,17 +538,17 @@ _gnutls_rsa_export_set_pubkey (gnutls_session_t session,
/* Sets the prime and the generator in the auth info structure.
*/
int
-_gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
+mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
{
dh_info_st *dh;
int ret;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ mhd_anon_auth_info_t info;
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -559,7 +559,7 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -573,7 +573,7 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
/* prime
*/
- ret = _gnutls_mpi_dprint_lz (&dh->prime, prime);
+ ret = mhd_gtls_mpi_dprint_lz (&dh->prime, prime);
if (ret < 0)
{
gnutls_assert ();
@@ -582,7 +582,7 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
/* generator
*/
- ret = _gnutls_mpi_dprint_lz (&dh->generator, gen);
+ ret = mhd_gtls_mpi_dprint_lz (&dh->generator, gen);
if (ret < 0)
{
gnutls_assert ();
@@ -594,8 +594,8 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
}
/**
- * 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.
+ * MHD_gtls_openpgp_send_cert - This function will order gnutls to send the openpgp fingerprint instead of the key
+ * @session: is a pointer to a #mhd_gtls_session_t structure.
* @status: is one of GNUTLS_OPENPGP_CERT, or GNUTLS_OPENPGP_CERT_FINGERPRINT
*
* This function will order gnutls to send the key fingerprint
@@ -604,15 +604,15 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
* that the server can obtain the client's key.
**/
void
-gnutls_openpgp_send_cert (gnutls_session_t session,
+MHD_gtls_openpgp_send_cert (mhd_gtls_session_t session,
gnutls_openpgp_crt_status_t status)
{
session->internals.pgp_fingerprint = status;
}
/**
- * gnutls_certificate_send_x509_rdn_sequence - This function will order gnutls to send or not the x.509 rdn sequence
- * @session: is a pointer to a #gnutls_session_t structure.
+ * MHD_gnutls_certificate_send_x509_rdn_sequence - This function will order gnutls to send or not the x.509 rdn sequence
+ * @session: is a pointer to a #mhd_gtls_session_t structure.
* @status: is 0 or 1
*
* If status is non zero, this function will order gnutls not to send
@@ -625,21 +625,21 @@ gnutls_openpgp_send_cert (gnutls_session_t session,
* methods other than certificate with X.509 certificates.
**/
void
-gnutls_certificate_send_x509_rdn_sequence (gnutls_session_t session,
+MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t session,
int status)
{
session->internals.ignore_rdn_sequence = status;
}
int
-_gnutls_openpgp_send_fingerprint (gnutls_session_t session)
+mhd_gtls_openpgp_send_fingerprint (mhd_gtls_session_t session)
{
return session->internals.pgp_fingerprint;
}
/*-
* _gnutls_record_set_default_version - Used to set the default version for the first record packet
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @major: is a tls major version
* @minor: is a tls minor version
*
@@ -649,7 +649,7 @@ _gnutls_openpgp_send_fingerprint (gnutls_session_t session)
*
-*/
void
-_gnutls_record_set_default_version (gnutls_session_t session,
+_gnutls_record_set_default_version (mhd_gtls_session_t session,
unsigned char major, unsigned char minor)
{
session->internals.default_record_version[0] = major;
@@ -657,8 +657,8 @@ _gnutls_record_set_default_version (gnutls_session_t session,
}
/**
- * gnutls_handshake_set_private_extensions - Used to enable the private cipher suites
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_handshake_set_private_extensions - Used to enable the private cipher suites
+ * @session: is a #mhd_gtls_session_t structure.
* @allow: is an integer (0 or 1)
*
* This function will enable or disable the use of private cipher
@@ -673,7 +673,7 @@ _gnutls_record_set_default_version (gnutls_session_t session,
* gnutls servers and clients may cause interoperability problems.
**/
void
-gnutls_handshake_set_private_extensions (gnutls_session_t session, int allow)
+MHD_gtls_handshake_set_private_extensions (mhd_gtls_session_t session, int allow)
{
session->internals.enable_private = allow;
}
@@ -686,15 +686,15 @@ _gnutls_cal_PRF_A (gnutls_mac_algorithm_t algorithm,
{
mac_hd_t td1;
- td1 = _gnutls_hmac_init (algorithm, secret, secret_size);
+ td1 = mhd_gtls_hmac_init (algorithm, secret, secret_size);
if (td1 == GNUTLS_MAC_FAILED)
{
gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
- _gnutls_hmac (td1, seed, seed_size);
- _gnutls_hmac_deinit (td1, result);
+ mhd_gnutls_hash (td1, seed, seed_size);
+ mhd_gnutls_hmac_deinit (td1, result);
return 0;
}
@@ -723,7 +723,7 @@ _gnutls_P_hash (gnutls_mac_algorithm_t algorithm,
return GNUTLS_E_INTERNAL_ERROR;
}
- blocksize = _gnutls_hmac_get_algo_len (algorithm);
+ blocksize = mhd_gnutls_hash_get_algo_len (algorithm);
output_bytes = 0;
do
@@ -741,7 +741,7 @@ _gnutls_P_hash (gnutls_mac_algorithm_t algorithm,
for (i = 0; i < times; i++)
{
- td2 = _gnutls_hmac_init (algorithm, secret, secret_size);
+ td2 = mhd_gtls_hmac_init (algorithm, secret, secret_size);
if (td2 == GNUTLS_MAC_FAILED)
{
gnutls_assert ();
@@ -753,15 +753,15 @@ _gnutls_P_hash (gnutls_mac_algorithm_t algorithm,
A_size, Atmp)) < 0)
{
gnutls_assert ();
- _gnutls_hmac_deinit (td2, final);
+ mhd_gnutls_hmac_deinit (td2, final);
return result;
}
A_size = blocksize;
- _gnutls_hmac (td2, Atmp, A_size);
- _gnutls_hmac (td2, seed, seed_size);
- _gnutls_hmac_deinit (td2, final);
+ mhd_gnutls_hash (td2, Atmp, A_size);
+ mhd_gnutls_hash (td2, seed, seed_size);
+ mhd_gnutls_hmac_deinit (td2, final);
if ((1 + i) * blocksize < total_bytes)
{
@@ -800,7 +800,7 @@ _gnutls_xor (opaque * o1, opaque * o2, int length)
* available.
*/
int
-_gnutls_PRF (gnutls_session_t session,
+mhd_gtls_PRF (mhd_gtls_session_t session,
const opaque * secret,
int secret_size,
const char *label,
@@ -812,7 +812,7 @@ _gnutls_PRF (gnutls_session_t session,
opaque s_seed[MAX_SEED_SIZE];
opaque o1[MAX_PRF_BYTES], o2[MAX_PRF_BYTES];
int result;
- gnutls_protocol_t ver = gnutls_protocol_get_version (session);
+ gnutls_protocol_t ver = MHD_gnutls_protocol_get_version (session);
if (total_bytes > MAX_PRF_BYTES)
{
@@ -882,8 +882,8 @@ _gnutls_PRF (gnutls_session_t session,
}
/**
- * gnutls_prf_raw - access the TLS PRF directly
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_prf_raw - access the TLS PRF directly
+ * @session: is a #mhd_gtls_session_t structure.
* @label_size: length of the @label variable.
* @label: label used in PRF computation, typically a short string.
* @seed_size: length of the @seed variable.
@@ -904,21 +904,21 @@ _gnutls_PRF (gnutls_session_t session,
* session unless @seed include the client random and server random
* fields (the PRF would output the same data on another connection
* resumed from the first one), it is not recommended to use this
- * function directly. The gnutls_prf() function seed the PRF with the
+ * function directly. The MHD_gnutls_prf() function seed the PRF with the
* client and server random fields directly, and is recommended if you
* want to generate pseudo random data unique for each session.
*
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_prf_raw (gnutls_session_t session,
+MHD_gnutls_prf_raw (mhd_gtls_session_t session,
size_t label_size,
const char *label,
size_t seed_size, const char *seed, size_t outsize, char *out)
{
int ret;
- ret = _gnutls_PRF (session, session->security_parameters.master_secret,
+ ret = mhd_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, label, label_size, (opaque *) seed,
seed_size, outsize, out);
@@ -926,8 +926,8 @@ gnutls_prf_raw (gnutls_session_t session,
}
/**
- * gnutls_prf - derive pseudo-random data using the TLS PRF
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_prf - derive pseudo-random data using the TLS PRF
+ * @session: is a #mhd_gtls_session_t structure.
* @label_size: length of the @label variable.
* @label: label used in PRF computation, typically a short string.
* @server_random_first: non-0 if server random field should be first in seed
@@ -955,7 +955,7 @@ gnutls_prf_raw (gnutls_session_t session,
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_prf (gnutls_session_t session,
+MHD_gnutls_prf (mhd_gtls_session_t session,
size_t label_size,
const char *label,
int server_random_first,
@@ -981,7 +981,7 @@ gnutls_prf (gnutls_session_t session,
memcpy (seed + 2 * TLS_RANDOM_SIZE, extra, extra_size);
- ret = _gnutls_PRF (session, session->security_parameters.master_secret,
+ ret = mhd_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, label, label_size, seed, seedsize,
outsize, out);
@@ -991,8 +991,8 @@ gnutls_prf (gnutls_session_t session,
}
/**
- * gnutls_session_get_client_random - get the session's client random value
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_get_client_random - get the session's client random value
+ * @session: is a #mhd_gtls_session_t structure.
*
* Return a pointer to the 32-byte client random field used in the
* session. The pointer must not be modified or deallocated.
@@ -1004,14 +1004,14 @@ gnutls_prf (gnutls_session_t session,
* Returns: pointer to client random data.
**/
const void *
-gnutls_session_get_client_random (gnutls_session_t session)
+MHD_gtls_session_get_client_random (mhd_gtls_session_t session)
{
return (char *) session->security_parameters.client_random;
}
/**
- * gnutls_session_get_server_random - get the session's server random value
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_get_server_random - get the session's server random value
+ * @session: is a #mhd_gtls_session_t structure.
*
* Return a pointer to the 32-byte server random field used in the
* session. The pointer must not be modified or deallocated.
@@ -1023,14 +1023,14 @@ gnutls_session_get_client_random (gnutls_session_t session)
* Returns: pointer to server random data.
**/
const void *
-gnutls_session_get_server_random (gnutls_session_t session)
+MHD_gtls_session_get_server_random (mhd_gtls_session_t session)
{
return (char *) session->security_parameters.server_random;
}
/**
- * gnutls_session_get_master_secret - get the session's master secret value
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_get_master_secret - get the session's master secret value
+ * @session: is a #mhd_gtls_session_t structure.
*
* Return a pointer to the 48-byte master secret in the session. The
* pointer must not be modified or deallocated.
@@ -1039,26 +1039,26 @@ gnutls_session_get_server_random (gnutls_session_t session)
* will be garbage; in particular, a %NULL return value should not be
* expected.
*
- * Consider using gnutls_prf() rather than extracting the master
+ * Consider using MHD_gnutls_prf() rather than extracting the master
* secret and use it to derive further data.
*
* Returns: pointer to master secret data.
**/
const void *
-gnutls_session_get_master_secret (gnutls_session_t session)
+MHD_gtls_session_get_master_secret (mhd_gtls_session_t session)
{
return (char *) session->security_parameters.master_secret;
}
/**
- * gnutls_session_is_resumed - Used to check whether this session is a resumed one
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_is_resumed - Used to check whether this session is a resumed one
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: non zero if this session is resumed, or a zero if this is
* a new session.
**/
int
-gnutls_session_is_resumed (gnutls_session_t session)
+MHD_gtls_session_is_resumed (mhd_gtls_session_t session)
{
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
@@ -1081,81 +1081,81 @@ gnutls_session_is_resumed (gnutls_session_t session)
}
/*-
- * _gnutls_session_is_export - Used to check whether this session is of export grade
- * @session: is a #gnutls_session_t structure.
+ * mhd_gtls_session_is_export - Used to check whether this session is of export grade
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function will return non zero if this session is of export grade.
*
-*/
int
-_gnutls_session_is_export (gnutls_session_t session)
+mhd_gtls_session_is_export (mhd_gtls_session_t session)
{
gnutls_cipher_algorithm_t cipher;
cipher =
- _gnutls_cipher_suite_get_cipher_algo (&session->security_parameters.
+ mhd_gtls_cipher_suite_get_cipher_algo (&session->security_parameters.
current_cipher_suite);
- if (_gnutls_cipher_get_export_flag (cipher) != 0)
+ if (mhd_gtls_cipher_get_export_flag (cipher) != 0)
return 1;
return 0;
}
/**
- * gnutls_session_get_ptr - Used to get the user pointer from the session structure
- * @session: is a #gnutls_session_t structure.
+ * MHD_gtls_session_get_ptr - Used to get the user pointer from the session structure
+ * @session: is a #mhd_gtls_session_t structure.
*
* Returns: the user given pointer from the session structure. This
- * is the pointer set with gnutls_session_set_ptr().
+ * is the pointer set with MHD_gnutls_session_set_ptr().
**/
void *
-gnutls_session_get_ptr (gnutls_session_t session)
+MHD_gtls_session_get_ptr (mhd_gtls_session_t session)
{
return session->internals.user_ptr;
}
/**
- * gnutls_session_set_ptr - Used to set the user pointer to the session structure
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_session_set_ptr - Used to set the user pointer to the session structure
+ * @session: is a #mhd_gtls_session_t structure.
* @ptr: is the user pointer
*
* This function will set (associate) the user given pointer to the
* session structure. This is pointer can be accessed with
- * gnutls_session_get_ptr().
+ * MHD_gtls_session_get_ptr().
**/
void
-gnutls_session_set_ptr (gnutls_session_t session, void *ptr)
+MHD_gnutls_session_set_ptr (mhd_gtls_session_t session, void *ptr)
{
session->internals.user_ptr = ptr;
}
/**
- * gnutls_record_get_direction - This function will return the direction of the last interrupted function call
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_record_get_direction - This function will return the direction of the last interrupted function call
+ * @session: is a #mhd_gtls_session_t structure.
*
* This function provides information about the internals of the
* record protocol and is only useful if a prior gnutls function call
- * (e.g. gnutls_handshake()) was interrupted for some reason, that
+ * (e.g. MHD_gnutls_handshake()) was interrupted for some reason, that
* is, if a function returned %GNUTLS_E_INTERRUPTED or
* %GNUTLS_E_AGAIN. In such a case, you might want to call select()
* or poll() before calling the interrupted gnutls function again.
* To tell you whether a file descriptor should be selected for
- * either reading or writing, gnutls_record_get_direction() returns 0
+ * either reading or writing, MHD_gnutls_record_get_direction() returns 0
* if the interrupted function was trying to read data, and 1 if it
* was trying to write data.
*
* Returns: 0 if trying to read data, 1 if trying to write data.
**/
int
-gnutls_record_get_direction (gnutls_session_t session)
+MHD_gnutls_record_get_direction (mhd_gtls_session_t session)
{
return session->internals.direction;
}
/*-
* _gnutls_rsa_pms_set_version - Sets a version to be used at the RSA PMS
- * @session: is a #gnutls_session_t structure.
+ * @session: is a #mhd_gtls_session_t structure.
* @major: is the major version to use
* @minor: is the minor version to use
*
@@ -1165,7 +1165,7 @@ gnutls_record_get_direction (gnutls_session_t session)
*
-*/
void
-_gnutls_rsa_pms_set_version (gnutls_session_t session,
+_gnutls_rsa_pms_set_version (mhd_gtls_session_t session,
unsigned char major, unsigned char minor)
{
session->internals.rsa_pms_version[0] = major;
@@ -1173,8 +1173,8 @@ _gnutls_rsa_pms_set_version (gnutls_session_t session,
}
/**
- * gnutls_handshake_set_post_client_hello_function - This function will a callback to be called after the client hello is received
- * @res: is a gnutls_anon_server_credentials_t structure
+ * MHD_gnutls_handshake_set_post_client_hello_function - This function will a callback to be called after the client hello is received
+ * @res: is a mhd_gtls_anon_server_credentials_t structure
* @func: is the function to be called
*
* This function will set a callback to be called after the client
@@ -1195,27 +1195,9 @@ _gnutls_rsa_pms_set_version (gnutls_session_t session,
*
**/
void
-gnutls_handshake_set_post_client_hello_function (gnutls_session_t session,
+MHD_gnutls_handshake_set_post_client_hello_function (mhd_gtls_session_t session,
gnutls_handshake_post_client_hello_func
func)
{
session->internals.user_hello_func = func;
}
-
-/**
- * gnutls_session_enable_compatibility_mode - Used to disable certain features in TLS in order to honour compatibility
- * @session: is a #gnutls_session_t structure.
- *
- * This function can be used to disable certain (security) features
- * in TLS in order to maintain maximum compatibility with buggy
- * clients. It is equivalent to calling:
- * gnutls_record_disable_padding()
- *
- * Normally only servers that require maximum compatibility with
- * everything out there, need to call this function.
- **/
-void
-gnutls_session_enable_compatibility_mode (gnutls_session_t session)
-{
- gnutls_record_disable_padding (session);
-}
diff --git a/src/daemon/https/tls/gnutls_state.h b/src/daemon/https/tls/gnutls_state.h
@@ -27,46 +27,46 @@
#include <gnutls_int.h>
-void _gnutls_session_cert_type_set (gnutls_session_t session,
+void _gnutls_session_cert_type_set (mhd_gtls_session_t session,
gnutls_certificate_type_t);
-gnutls_kx_algorithm_t gnutls_kx_get (gnutls_session_t session);
-gnutls_cipher_algorithm_t gnutls_cipher_get (gnutls_session_t session);
-gnutls_certificate_type_t gnutls_certificate_type_get (gnutls_session_t);
+gnutls_kx_algorithm_t gnutls_kx_get (mhd_gtls_session_t session);
+gnutls_cipher_algorithm_t gnutls_cipher_get (mhd_gtls_session_t session);
+gnutls_certificate_type_t gnutls_certificate_type_get (mhd_gtls_session_t);
#include <gnutls_auth_int.h>
-#define CHECK_AUTH(auth, ret) if (gnutls_auth_get_type(session) != auth) { \
+#define CHECK_AUTH(auth, ret) if (MHD_gtls_auth_get_type(session) != auth) { \
gnutls_assert(); \
return ret; \
}
#endif
-int _gnutls_session_cert_type_supported (gnutls_session_t,
+int mhd_gtls_session_cert_type_supported (mhd_gtls_session_t,
gnutls_certificate_type_t);
-int _gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits);
+int mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits);
-int _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public);
-int _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime);
+int mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public);
+int mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime);
-int _gnutls_dh_get_allowed_prime_bits (gnutls_session_t session);
-void _gnutls_handshake_internal_state_clear (gnutls_session_t);
+int mhd_gtls_dh_get_allowed_prime_bits (mhd_gtls_session_t session);
+void mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t);
-int _gnutls_rsa_export_set_pubkey (gnutls_session_t session,
+int mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
mpi_t exponent, mpi_t modulus);
-int _gnutls_session_is_resumable (gnutls_session_t session);
-int _gnutls_session_is_export (gnutls_session_t session);
+int mhd_gtls_session_is_resumable (mhd_gtls_session_t session);
+int mhd_gtls_session_is_export (mhd_gtls_session_t session);
-int _gnutls_openpgp_send_fingerprint (gnutls_session_t session);
+int mhd_gtls_openpgp_send_fingerprint (mhd_gtls_session_t session);
-int _gnutls_PRF (gnutls_session_t session,
+int mhd_gtls_PRF (mhd_gtls_session_t session,
const opaque * secret, int secret_size,
const char *label, int label_size,
const opaque * seed, int seed_size,
int total_bytes, void *ret);
-int gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end);
+int MHD_gnutls_init (mhd_gtls_session_t * session, gnutls_connection_end_t con_end);
#define DEFAULT_CERT_TYPE MHD_GNUTLS_CRT_X509
diff --git a/src/daemon/https/tls/gnutls_str.c b/src/daemon/https/tls/gnutls_str.c
@@ -34,7 +34,7 @@
* They should be used only with null terminated strings.
*/
void
-_gnutls_str_cat (char *dest, size_t dest_tot_size, const char *src)
+mhd_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src)
{
size_t str_size = strlen (src);
size_t dest_size = strlen (dest);
@@ -54,7 +54,7 @@ _gnutls_str_cat (char *dest, size_t dest_tot_size, const char *src)
}
void
-_gnutls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
+mhd_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
{
size_t str_size = strlen (src);
@@ -73,7 +73,7 @@ _gnutls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
}
void
-_gnutls_mem_cpy (char *dest,
+mhd_gtls_mem_cpy (char *dest,
size_t dest_tot_size, const char *src, size_t src_size)
{
@@ -91,7 +91,7 @@ _gnutls_mem_cpy (char *dest,
}
void
-_gnutls_string_init (gnutls_string * str,
+mhd_gtls_string_init (mhd_gtls_string * str,
gnutls_alloc_function alloc_func,
gnutls_realloc_function realloc_func,
gnutls_free_function free_func)
@@ -106,7 +106,7 @@ _gnutls_string_init (gnutls_string * str,
}
void
-_gnutls_string_clear (gnutls_string * str)
+mhd_gtls_string_clear (mhd_gtls_string * str)
{
if (str == NULL || str->data == NULL)
return;
@@ -120,7 +120,7 @@ _gnutls_string_clear (gnutls_string * str)
/* This one does not copy the string.
*/
gnutls_datum_t
-_gnutls_string2datum (gnutls_string * str)
+mhd_gtls_string2datum (mhd_gtls_string * str)
{
gnutls_datum_t ret;
@@ -133,7 +133,7 @@ _gnutls_string2datum (gnutls_string * str)
#define MIN_CHUNK 256
int
-_gnutls_string_copy_str (gnutls_string * dest, const char *src)
+mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src)
{
size_t src_len = strlen (src);
size_t max;
@@ -163,7 +163,7 @@ _gnutls_string_copy_str (gnutls_string * dest, const char *src)
}
int
-_gnutls_string_append_str (gnutls_string * dest, const char *src)
+mhd_gtls_string_append_str (mhd_gtls_string * dest, const char *src)
{
size_t src_len = strlen (src);
size_t tot_len = src_len + dest->length;
@@ -196,7 +196,7 @@ _gnutls_string_append_str (gnutls_string * dest, const char *src)
}
int
-_gnutls_string_append_data (gnutls_string * dest,
+mhd_gtls_string_append_data (mhd_gtls_string * dest,
const void *data, size_t data_size)
{
size_t tot_len = data_size + dest->length;
@@ -229,7 +229,7 @@ _gnutls_string_append_data (gnutls_string * dest,
}
int
-_gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...)
+mhd_gtls_string_append_printf (mhd_gtls_string * dest, const char *fmt, ...)
{
va_list args;
int len;
@@ -242,7 +242,7 @@ _gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...)
if (len < 0 || !str)
return -1;
- len = _gnutls_string_append_str (dest, str);
+ len = mhd_gtls_string_append_str (dest, str);
free (str);
@@ -255,7 +255,7 @@ _gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...)
* truncated hex string is returned (always null terminated).
*/
char *
-_gnutls_bin2hex (const void *_old,
+mhd_gtls_bin2hex (const void *_old,
size_t oldlen, char *buffer, size_t buffer_size)
{
unsigned int i, j;
@@ -274,7 +274,7 @@ _gnutls_bin2hex (const void *_old,
/* just a hex2bin function.
*/
int
-_gnutls_hex2bin (const opaque * hex_data,
+mhd_gtls_hex2bin (const opaque * hex_data,
int hex_size, opaque * bin_data, size_t * bin_size)
{
int i, j;
diff --git a/src/daemon/https/tls/gnutls_str.h b/src/daemon/https/tls/gnutls_str.h
@@ -27,10 +27,10 @@
#include <gnutls_int.h>
-void _gnutls_str_cpy (char *dest, size_t dest_tot_size, const char *src);
-void _gnutls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
+void mhd_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void mhd_gtls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
size_t src_size);
-void _gnutls_str_cat (char *dest, size_t dest_tot_size, const char *src);
+void mhd_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src);
typedef struct
{
@@ -40,26 +40,26 @@ typedef struct
gnutls_realloc_function realloc_func;
gnutls_alloc_function alloc_func;
gnutls_free_function free_func;
-} gnutls_string;
+} mhd_gtls_string;
-void _gnutls_string_init (gnutls_string *, gnutls_alloc_function,
+void mhd_gtls_string_init (mhd_gtls_string *, gnutls_alloc_function,
gnutls_realloc_function, gnutls_free_function);
-void _gnutls_string_clear (gnutls_string *);
+void mhd_gtls_string_clear (mhd_gtls_string *);
/* Beware, do not clear the string, after calling this
* function
*/
-gnutls_datum_t _gnutls_string2datum (gnutls_string * str);
+gnutls_datum_t mhd_gtls_string2datum (mhd_gtls_string * str);
-int _gnutls_string_copy_str (gnutls_string * dest, const char *src);
-int _gnutls_string_append_str (gnutls_string *, const char *str);
-int _gnutls_string_append_data (gnutls_string *, const void *data,
+int mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src);
+int mhd_gtls_string_append_str (mhd_gtls_string *, const char *str);
+int mhd_gtls_string_append_data (mhd_gtls_string *, const void *data,
size_t data_size);
-int _gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...);
+int mhd_gtls_string_append_printf (mhd_gtls_string * dest, const char *fmt, ...);
-char *_gnutls_bin2hex (const void *old, size_t oldlen, char *buffer,
+char * mhd_gtls_bin2hex (const void *old, size_t oldlen, char *buffer,
size_t buffer_size);
-int _gnutls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
+int mhd_gtls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
size_t * bin_size);
#endif
diff --git a/src/daemon/https/tls/gnutls_supplemental.c b/src/daemon/https/tls/gnutls_supplemental.c
@@ -25,7 +25,7 @@
/* This file contains support functions for 'TLS Handshake Message for
* Supplemental Data' (RFC 4680).
*
- * The idea here is simple. gnutls_handshake() in gnuts_handshake.c
+ * The idea here is simple. MHD_gnutls_handshake() in gnuts_handshake.c
* will call _gnutls_gen_supplemental and _gnutls_parse_supplemental
* when some extension requested that supplemental data be sent or
* received. Extension request this by setting the flags
@@ -50,9 +50,9 @@
#include "gnutls_errors.h"
#include "gnutls_num.h"
-typedef int (*supp_recv_func) (gnutls_session_t session,
+typedef int (*supp_recv_func) (mhd_gtls_session_t session,
const opaque * data, size_t data_size);
-typedef int (*supp_send_func) (gnutls_session_t session, gnutls_buffer * buf);
+typedef int (*supp_send_func) (mhd_gtls_session_t session, mhd_gtls_buffer * buf);
typedef struct
{
@@ -67,7 +67,7 @@ gnutls_supplemental_entry _gnutls_supplemental[] = {
};
const char *
-gnutls_supplemental_get_name (gnutls_supplemental_data_format_type_t type)
+MHD_gtls_supplemental_get_name (gnutls_supplemental_data_format_type_t type)
{
gnutls_supplemental_entry *p;
@@ -91,13 +91,13 @@ get_supp_func_recv (gnutls_supplemental_data_format_type_t type)
}
int
-_gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer * buf)
+_gnutls_gen_supplemental (mhd_gtls_session_t session, mhd_gtls_buffer * buf)
{
gnutls_supplemental_entry *p;
int ret;
/* Make room for 3 byte length field. */
- ret = _gnutls_buffer_append (buf, "\0\0\0", 3);
+ ret = mhd_gtls_buffer_append (buf, "\0\0\0", 3);
if (ret < 0)
{
gnutls_assert ();
@@ -111,7 +111,7 @@ _gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer * buf)
int ret;
/* Make room for supplement type and length byte length field. */
- ret = _gnutls_buffer_append (buf, "\0\0\0\0", 4);
+ ret = mhd_gtls_buffer_append (buf, "\0\0\0\0", 4);
if (ret < 0)
{
gnutls_assert ();
@@ -148,7 +148,7 @@ _gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer * buf)
}
int
-_gnutls_parse_supplemental (gnutls_session_t session,
+_gnutls_parse_supplemental (mhd_gtls_session_t session,
const uint8_t * data, int datalen)
{
const opaque *p = data;
@@ -156,7 +156,7 @@ _gnutls_parse_supplemental (gnutls_session_t session,
size_t total_size;
DECR_LEN (dsize, 3);
- total_size = _gnutls_read_uint24 (p);
+ total_size = mhd_gtls_read_uint24 (p);
p += 3;
if (dsize != total_size)
@@ -172,11 +172,11 @@ _gnutls_parse_supplemental (gnutls_session_t session,
supp_recv_func recv_func;
DECR_LEN (dsize, 2);
- supp_data_type = _gnutls_read_uint16 (p);
+ supp_data_type = mhd_gtls_read_uint16 (p);
p += 2;
DECR_LEN (dsize, 2);
- supp_data_length = _gnutls_read_uint16 (p);
+ supp_data_length = mhd_gtls_read_uint16 (p);
p += 2;
_gnutls_debug_log ("EXT[%x]: Got supplemental type=%02x length=%d\n",
diff --git a/src/daemon/https/tls/gnutls_supplemental.h b/src/daemon/https/tls/gnutls_supplemental.h
@@ -24,8 +24,8 @@
#include <gnutls_int.h>
-int _gnutls_parse_supplemental (gnutls_session_t session,
+int _gnutls_parse_supplemental (mhd_gtls_session_t session,
const uint8_t *data,
int data_size);
-int _gnutls_gen_supplemental (gnutls_session_t session,
- gnutls_buffer *buf);
+int _gnutls_gen_supplemental (mhd_gtls_session_t session,
+ mhd_gtls_buffer *buf);
diff --git a/src/daemon/https/tls/gnutls_ui.c b/src/daemon/https/tls/gnutls_ui.c
@@ -37,8 +37,8 @@
/* ANON & DHE */
/**
- * gnutls_dh_set_prime_bits - Used to set the bits for a DH ciphersuite
- * @session: is a #gnutls_session_t structure.
+ * MHD_gnutls_dh_set_prime_bits - Used to set the bits for a DH ciphersuite
+ * @session: is a #mhd_gtls_session_t structure.
* @bits: is the number of bits
*
* This function sets the number of bits, for use in an
@@ -53,13 +53,13 @@
*
**/
void
-gnutls_dh_set_prime_bits (gnutls_session_t session, unsigned int bits)
+MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session, unsigned int bits)
{
session->internals.dh_prime_bits = bits;
}
/**
- * gnutls_dh_get_group - This function returns the group of the DH authentication
+ * MHD_gnutls_dh_get_group - This function returns the group of the DH authentication
* @session: is a gnutls session
* @raw_gen: will hold the generator.
* @raw_prime: will hold the prime.
@@ -73,24 +73,24 @@ gnutls_dh_set_prime_bits (gnutls_session_t session, unsigned int bits)
*
**/
int
-gnutls_dh_get_group (gnutls_session_t session,
+MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
gnutls_datum_t * raw_gen, gnutls_datum_t * raw_prime)
{
dh_info_st *dh;
int ret;
- anon_auth_info_t anon_info;
+ mhd_anon_auth_info_t anon_info;
cert_auth_info_t cert_info;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
- anon_info = _gnutls_get_auth_info (session);
+ anon_info = mhd_gtls_get_auth_info (session);
if (anon_info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &anon_info->dh;
break;
case MHD_GNUTLS_CRD_CERTIFICATE:
- cert_info = _gnutls_get_auth_info (session);
+ cert_info = mhd_gtls_get_auth_info (session);
if (cert_info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &cert_info->dh;
@@ -119,7 +119,7 @@ gnutls_dh_get_group (gnutls_session_t session,
}
/**
- * gnutls_dh_get_pubkey - This function returns the peer's public key used in DH authentication
+ * MHD_gnutls_dh_get_pubkey - This function returns the peer's public key used in DH authentication
* @session: is a gnutls session
* @raw_key: will hold the public key.
*
@@ -131,18 +131,18 @@ gnutls_dh_get_group (gnutls_session_t session,
*
**/
int
-gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
+MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session, gnutls_datum_t * raw_key)
{
dh_info_st *dh;
- anon_auth_info_t anon_info;
+ mhd_anon_auth_info_t anon_info;
cert_auth_info_t cert_info;
cert_auth_info_t psk_info;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_info = _gnutls_get_auth_info (session);
+ anon_info = mhd_gtls_get_auth_info (session);
if (anon_info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &anon_info->dh;
@@ -150,7 +150,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
}
case MHD_GNUTLS_CRD_PSK:
{
- psk_info = _gnutls_get_auth_info (session);
+ psk_info = mhd_gtls_get_auth_info (session);
if (psk_info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &psk_info->dh;
@@ -159,7 +159,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
case MHD_GNUTLS_CRD_CERTIFICATE:
{
- cert_info = _gnutls_get_auth_info (session);
+ cert_info = mhd_gtls_get_auth_info (session);
if (cert_info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &cert_info->dh;
@@ -175,7 +175,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
}
/**
- * gnutls_rsa_export_get_pubkey - This function returns the peer's public key used in RSA-EXPORT authentication
+ * MHD_gtls_rsa_export_get_pubkey - This function returns the peer's public key used in RSA-EXPORT authentication
* @session: is a gnutls session
* @exponent: will hold the exponent.
* @modulus: will hold the modulus.
@@ -188,16 +188,16 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
*
**/
int
-gnutls_rsa_export_get_pubkey (gnutls_session_t session,
+MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
gnutls_datum_t * exponent,
gnutls_datum_t * modulus)
{
cert_auth_info_t info;
int ret;
- if (gnutls_auth_get_type (session) == MHD_GNUTLS_CRD_CERTIFICATE)
+ if (MHD_gtls_auth_get_type (session) == MHD_GNUTLS_CRD_CERTIFICATE)
{
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -225,7 +225,7 @@ gnutls_rsa_export_get_pubkey (gnutls_session_t session,
}
/**
- * gnutls_dh_get_secret_bits - This function returns the bits used in DH authentication
+ * MHD_gnutls_dh_get_secret_bits - This function returns the bits used in DH authentication
* @session: is a gnutls session
*
* This function will return the bits used in the last Diffie Hellman authentication
@@ -234,15 +234,15 @@ gnutls_rsa_export_get_pubkey (gnutls_session_t session,
*
**/
int
-gnutls_dh_get_secret_bits (gnutls_session_t session)
+MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
{
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
+ mhd_anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
return info->dh.secret_bits;
@@ -251,7 +251,7 @@ gnutls_dh_get_secret_bits (gnutls_session_t session)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -264,7 +264,7 @@ gnutls_dh_get_secret_bits (gnutls_session_t session)
}
/**
- * gnutls_dh_get_prime_bits - This function returns the bits used in DH authentication
+ * MHD_gnutls_dh_get_prime_bits - This function returns the bits used in DH authentication
* @session: is a gnutls session
*
* This function will return the bits of the prime used in the last Diffie Hellman authentication
@@ -273,17 +273,17 @@ gnutls_dh_get_secret_bits (gnutls_session_t session)
*
**/
int
-gnutls_dh_get_prime_bits (gnutls_session_t session)
+MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
{
dh_info_st *dh;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
+ mhd_anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
dh = &info->dh;
@@ -293,7 +293,7 @@ gnutls_dh_get_prime_bits (gnutls_session_t session)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -310,7 +310,7 @@ gnutls_dh_get_prime_bits (gnutls_session_t session)
}
/**
- * gnutls_rsa_export_get_modulus_bits - This function returns the bits used in RSA-export key exchange
+ * MHD_gtls_rsa_export_get_modulus_bits - This function returns the bits used in RSA-export key exchange
* @session: is a gnutls session
*
* This function will return the bits used in the last RSA-EXPORT key exchange
@@ -319,11 +319,11 @@ gnutls_dh_get_prime_bits (gnutls_session_t session)
*
**/
int
-gnutls_rsa_export_get_modulus_bits (gnutls_session_t session)
+MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -331,7 +331,7 @@ gnutls_rsa_export_get_modulus_bits (gnutls_session_t session)
}
/**
- * gnutls_dh_get_peers_public_bits - This function returns the bits used in DH authentication
+ * MHD_gnutls_dh_get_peers_public_bits - This function returns the bits used in DH authentication
* @session: is a gnutls session
*
* This function will return the bits used in the last Diffie Hellman authentication
@@ -340,17 +340,17 @@ gnutls_rsa_export_get_modulus_bits (gnutls_session_t session)
*
**/
int
-gnutls_dh_get_peers_public_bits (gnutls_session_t session)
+MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
{
dh_info_st *dh;
- switch (gnutls_auth_get_type (session))
+ switch (MHD_gtls_auth_get_type (session))
{
case MHD_GNUTLS_CRD_ANON:
{
- anon_auth_info_t info;
+ mhd_anon_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -361,7 +361,7 @@ gnutls_dh_get_peers_public_bits (gnutls_session_t session)
{
cert_auth_info_t info;
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
@@ -380,7 +380,7 @@ gnutls_dh_get_peers_public_bits (gnutls_session_t session)
/* CERTIFICATE STUFF */
/**
- * gnutls_certificate_get_ours - This function returns the raw certificate sent in the last handshake
+ * MHD_gtls_certificate_get_ours - This function returns the raw certificate sent in the last handshake
* @session: is a gnutls session
*
* This function will return the certificate as sent to the peer,
@@ -391,14 +391,14 @@ gnutls_dh_get_peers_public_bits (gnutls_session_t session)
*
**/
const gnutls_datum_t *
-gnutls_certificate_get_ours (gnutls_session_t session)
+MHD_gtls_certificate_get_ours (mhd_gtls_session_t session)
{
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred
- = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
+ = (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
MHD_GNUTLS_CRD_CERTIFICATE,
NULL);
if (cred == NULL || cred->cert_list == NULL)
@@ -414,7 +414,7 @@ gnutls_certificate_get_ours (gnutls_session_t session)
}
/**
- * gnutls_certificate_get_peers - This function returns the peer's raw certificate
+ * MHD_gtls_certificate_get_peers - This function returns the peer's raw certificate
* @session: is a gnutls session
* @list_size: is the length of the certificate list
*
@@ -431,14 +431,14 @@ gnutls_certificate_get_ours (gnutls_session_t session)
*
**/
const gnutls_datum_t *
-gnutls_certificate_get_peers (gnutls_session_t
+MHD_gtls_certificate_get_peers (mhd_gtls_session_t
session, unsigned int *list_size)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return NULL;
@@ -447,7 +447,7 @@ gnutls_certificate_get_peers (gnutls_session_t
}
/**
- * gnutls_certificate_client_get_request_status - This function returns the certificate request status
+ * MHD_gtls_certificate_client_get_request_status - This function returns the certificate request status
* @session: is a gnutls session
*
* This function will return 0 if the peer (server) did not request client
@@ -456,20 +456,20 @@ gnutls_certificate_get_peers (gnutls_session_t
*
**/
int
-gnutls_certificate_client_get_request_status (gnutls_session_t session)
+MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t session)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, 0);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
return GNUTLS_E_INTERNAL_ERROR;
return info->certificate_requested;
}
/**
- * gnutls_fingerprint - This function calculates the fingerprint of the given data
+ * MHD_gnutls_fingerprint - This function calculates the fingerprint of the given data
* @algo: is a digest algorithm
* @data: is the data
* @result: is the place where the result will be copied (may be null).
@@ -489,12 +489,12 @@ gnutls_certificate_client_get_request_status (gnutls_session_t session)
*
**/
int
-gnutls_fingerprint (gnutls_digest_algorithm_t algo,
+MHD_gnutls_fingerprint (gnutls_digest_algorithm_t algo,
const gnutls_datum_t * data,
void *result, size_t * result_size)
{
GNUTLS_HASH_HANDLE td;
- int hash_len = _gnutls_hash_get_algo_len (HASH2MAC (algo));
+ int hash_len = mhd_gnutls_hash_get_algo_len (HASH2MAC (algo));
if (hash_len < 0 || (unsigned) hash_len > *result_size || result == NULL)
{
@@ -505,21 +505,21 @@ gnutls_fingerprint (gnutls_digest_algorithm_t algo,
if (result)
{
- td = _gnutls_hash_init (HASH2MAC (algo));
+ td = mhd_gtls_hash_init (HASH2MAC (algo));
if (td == NULL)
return GNUTLS_E_HASH_FAILED;
- _gnutls_hash (td, data->data, data->size);
+ mhd_gnutls_hash (td, data->data, data->size);
- _gnutls_hash_deinit (td, result);
+ mhd_gnutls_hash_deinit (td, result);
}
return 0;
}
/**
- * gnutls_certificate_set_dh_params - This function will set the DH parameters for a server to use
- * @res: is a gnutls_certificate_credentials_t structure
+ * MHD_gnutls_certificate_set_dh_params - This function will set the DH parameters for a server to use
+ * @res: is a mhd_gtls_cert_credentials_t structure
* @dh_params: is a structure that holds diffie hellman parameters.
*
* This function will set the diffie hellman parameters for a
@@ -531,15 +531,15 @@ gnutls_fingerprint (gnutls_digest_algorithm_t algo,
*
**/
void
-gnutls_certificate_set_dh_params (gnutls_certificate_credentials_t res,
- gnutls_dh_params_t dh_params)
+MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
+ mhd_gtls_dh_params_t dh_params)
{
res->dh_params = dh_params;
}
/**
* gnutls_certificate_set_params_function - This function will set the DH or RSA parameters callback
- * @res: is a gnutls_certificate_credentials_t structure
+ * @res: is a mhd_gtls_cert_credentials_t structure
* @func: is the function to be called
*
* This function will set a callback in order for the server to get the
@@ -548,15 +548,15 @@ gnutls_certificate_set_dh_params (gnutls_certificate_credentials_t res,
*
**/
void
-gnutls_certificate_set_params_function (gnutls_certificate_credentials_t res,
+gnutls_certificate_set_params_function (mhd_gtls_cert_credentials_t res,
gnutls_params_function * func)
{
res->params_func = func;
}
/**
- * gnutls_certificate_set_verify_flags - This function will set the flags to be used at certificate verification
- * @res: is a gnutls_certificate_credentials_t structure
+ * MHD_gnutls_certificate_set_verify_flags - This function will set the flags to be used at certificate verification
+ * @res: is a mhd_gtls_cert_credentials_t structure
* @flags: are the flags
*
* This function will set the flags to be used at verification of the
@@ -565,25 +565,25 @@ gnutls_certificate_set_params_function (gnutls_certificate_credentials_t res,
*
**/
void
-gnutls_certificate_set_verify_flags (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
res, unsigned int flags)
{
res->verify_flags = flags;
}
/**
- * gnutls_certificate_set_verify_limits - This function will set the upper limits to be used at certificate verification
+ * MHD_gnutls_certificate_set_verify_limits - This function will set the upper limits to be used at certificate verification
* @res: is a gnutls_certificate_credentials structure
* @max_bits: is the number of bits of an acceptable certificate (default 8200)
* @max_depth: is maximum depth of the verification of a certificate chain (default 5)
*
* This function will set some upper limits for the default verification function,
- * gnutls_certificate_verify_peers2(), to avoid denial of service attacks.
+ * MHD_gtls_certificate_verify_peers2(), to avoid denial of service attacks.
* You can set them to zero to disable limits.
*
**/
void
-gnutls_certificate_set_verify_limits (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
res,
unsigned int max_bits,
unsigned int max_depth)
@@ -593,8 +593,8 @@ gnutls_certificate_set_verify_limits (gnutls_certificate_credentials_t
}
/**
- * gnutls_certificate_set_rsa_export_params - This function will set the RSA parameters for a server to use
- * @res: is a gnutls_certificate_credentials_t structure
+ * MHD_gnutls_certificate_set_rsa_export_params - This function will set the RSA parameters for a server to use
+ * @res: is a mhd_gtls_cert_credentials_t structure
* @rsa_params: is a structure that holds temporary RSA parameters.
*
* This function will set the temporary RSA parameters for a certificate
@@ -603,15 +603,15 @@ gnutls_certificate_set_verify_limits (gnutls_certificate_credentials_t
*
**/
void
-gnutls_certificate_set_rsa_export_params (gnutls_certificate_credentials_t
- res, gnutls_rsa_params_t rsa_params)
+MHD_gnutls_certificate_set_rsa_export_params (mhd_gtls_cert_credentials_t
+ res, mhd_gtls_rsa_params_t rsa_params)
{
res->rsa_params = rsa_params;
}
/**
* gnutls_anon_set_params_function - This function will set the DH or RSA parameters callback
- * @res: is a gnutls_anon_server_credentials_t structure
+ * @res: is a mhd_gtls_anon_server_credentials_t structure
* @func: is the function to be called
*
* This function will set a callback in order for the server to get the
@@ -620,7 +620,7 @@ gnutls_certificate_set_rsa_export_params (gnutls_certificate_credentials_t
*
**/
void
-gnutls_anon_set_params_function (gnutls_anon_server_credentials_t res,
+gnutls_anon_set_params_function (mhd_gtls_anon_server_credentials_t res,
gnutls_params_function * func)
{
res->params_func = func;
diff --git a/src/daemon/https/tls/gnutls_x509.c b/src/daemon/https/tls/gnutls_x509.c
@@ -100,25 +100,25 @@ check_bits (gnutls_x509_crt_t crt, unsigned int max_bits)
*
-*/
int
-_gnutls_x509_cert_verify_peers (gnutls_session_t session,
+_gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
unsigned int *status)
{
cert_auth_info_t info;
- gnutls_certificate_credentials_t cred;
+ mhd_gtls_cert_credentials_t cred;
gnutls_x509_crt_t *peer_certificate_list;
int peer_certificate_list_size, i, x, ret;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
- info = _gnutls_get_auth_info (session);
+ info = mhd_gtls_get_auth_info (session);
if (info == NULL)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
- cred = (gnutls_certificate_credentials_t)
- _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+ cred = (mhd_gtls_cert_credentials_t)
+ mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
@@ -206,7 +206,7 @@ _gnutls_x509_cert_verify_peers (gnutls_session_t session,
* the given key parameters.
*/
static int
-_gnutls_check_key_cert_match (gnutls_certificate_credentials_t res)
+_gnutls_check_key_cert_match (mhd_gtls_cert_credentials_t res)
{
gnutls_datum_t cid;
gnutls_datum_t kid;
@@ -263,7 +263,7 @@ parse_crt_mem (gnutls_cert ** cert_list, unsigned *ncerts,
i = *ncerts + 1;
*cert_list =
- (gnutls_cert *) gnutls_realloc_fast (*cert_list,
+ (gnutls_cert *) mhd_gtls_realloc_fast (*cert_list,
i * sizeof (gnutls_cert));
if (*cert_list == NULL)
@@ -272,7 +272,7 @@ parse_crt_mem (gnutls_cert ** cert_list, unsigned *ncerts,
return GNUTLS_E_MEMORY_ERROR;
}
- ret = _gnutls_x509_crt_to_gcert (&cert_list[0][i - 1], cert, 0);
+ ret = mhd_gtls_x509_crt_to_gcert (&cert_list[0][i - 1], cert, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -408,7 +408,7 @@ parse_pkcs7_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts, const
if (ret >= 0)
{
*cert_list =
- (gnutls_cert *) gnutls_realloc_fast (*cert_list,
+ (gnutls_cert *) mhd_gtls_realloc_fast (*cert_list,
i * sizeof (gnutls_cert));
if (*cert_list == NULL)
@@ -422,7 +422,7 @@ parse_pkcs7_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts, const
tmp2.size = pcert_size;
ret =
- _gnutls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp2, 0);
+ mhd_gtls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp2, 0);
if (ret < 0)
{
@@ -502,7 +502,7 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
}
*cert_list =
- (gnutls_cert *) gnutls_realloc_fast (*cert_list,
+ (gnutls_cert *) mhd_gtls_realloc_fast (*cert_list,
i * sizeof (gnutls_cert));
if (*cert_list == NULL)
@@ -514,7 +514,7 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
tmp.data = ptr2;
tmp.size = siz2;
- ret = _gnutls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp, 0);
+ ret = mhd_gtls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp, 0);
if (ret < 0)
{
gnutls_assert ();
@@ -559,14 +559,14 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
/* Reads a DER or PEM certificate from memory
*/
static int
-read_cert_mem (gnutls_certificate_credentials_t res, const void *cert,
+read_cert_mem (mhd_gtls_cert_credentials_t res, const void *cert,
int cert_size, gnutls_x509_crt_fmt_t type)
{
int ret;
/* allocate space for the certificate to add
*/
- res->cert_list = gnutls_realloc_fast (res->cert_list,
+ res->cert_list = mhd_gtls_realloc_fast (res->cert_list,
(1 +
res->ncerts) *
sizeof (gnutls_cert *));
@@ -576,7 +576,7 @@ read_cert_mem (gnutls_certificate_credentials_t res, const void *cert,
return GNUTLS_E_MEMORY_ERROR;
}
- res->cert_list_length = gnutls_realloc_fast (res->cert_list_length,
+ res->cert_list_length = mhd_gtls_realloc_fast (res->cert_list_length,
(1 +
res->ncerts) * sizeof (int));
if (res->cert_list_length == NULL)
@@ -636,13 +636,13 @@ cleanup:
for (i = 0; i < src->params_size; i++)
{
- _gnutls_mpi_release (&dest->params[i]);
+ mhd_gtls_mpi_release (&dest->params[i]);
}
return ret;
}
void
-_gnutls_gkey_deinit (gnutls_privkey * key)
+mhd_gtls_gkey_deinit (gnutls_privkey * key)
{
int i;
if (key == NULL)
@@ -650,7 +650,7 @@ _gnutls_gkey_deinit (gnutls_privkey * key)
for (i = 0; i < key->params_size; i++)
{
- _gnutls_mpi_release (&key->params[i]);
+ mhd_gtls_mpi_release (&key->params[i]);
}
}
@@ -702,7 +702,7 @@ _gnutls_x509_raw_privkey_to_gkey (gnutls_privkey * privkey,
* that GnuTLS doesn't know the private key.
*/
static int
-read_key_mem (gnutls_certificate_credentials_t res,
+read_key_mem (mhd_gtls_cert_credentials_t res,
const void *key, int key_size, gnutls_x509_crt_fmt_t type)
{
int ret;
@@ -711,7 +711,7 @@ read_key_mem (gnutls_certificate_credentials_t res,
/* allocate space for the pkey list
*/
res->pkey =
- gnutls_realloc_fast (res->pkey,
+ mhd_gtls_realloc_fast (res->pkey,
(res->ncerts + 1) * sizeof (gnutls_privkey));
if (res->pkey == NULL)
{
@@ -742,7 +742,7 @@ read_key_mem (gnutls_certificate_credentials_t res,
/* Reads a certificate file
*/
static int
-read_cert_file (gnutls_certificate_credentials_t res,
+read_cert_file (mhd_gtls_cert_credentials_t res,
const char *certfile, gnutls_x509_crt_fmt_t type)
{
int ret;
@@ -768,7 +768,7 @@ read_cert_file (gnutls_certificate_credentials_t res,
* stores it).
*/
static int
-read_key_file (gnutls_certificate_credentials_t res,
+read_key_file (mhd_gtls_cert_credentials_t res,
const char *keyfile, gnutls_x509_crt_fmt_t type)
{
int ret;
@@ -788,14 +788,14 @@ read_key_file (gnutls_certificate_credentials_t res,
}
/**
- * gnutls_certificate_set_x509_key_mem - Used to set keys in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_key_mem - Used to set keys in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @cert: contains a certificate list (path) for the specified private key
* @key: is the private key, or %NULL
* @type: is PEM or DER
*
* This function sets a certificate/private key pair in the
- * gnutls_certificate_credentials_t structure. This function may be called
+ * mhd_gtls_cert_credentials_t structure. This function may be called
* more than once (in case multiple keys/certificates exist for the
* server).
*
@@ -813,12 +813,12 @@ read_key_file (gnutls_certificate_credentials_t res,
* then the strings that hold their values must be null terminated.
*
* The @key may be %NULL if you are using a sign callback, see
- * gnutls_sign_callback_set().
+ * MHD_gtls_sign_callback_set().
*
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_certificate_set_x509_key_mem (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
res, const gnutls_datum_t * cert,
const gnutls_datum_t * key,
gnutls_x509_crt_fmt_t type)
@@ -846,100 +846,15 @@ gnutls_certificate_set_x509_key_mem (gnutls_certificate_credentials_t
}
/**
- * gnutls_certificate_set_x509_key - Used to set keys in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
- * @cert_list: contains a certificate list (path) for the specified private key
- * @cert_list_size: holds the size of the certificate list
- * @key: is a gnutls_x509_privkey_t key
- *
- * This function sets a certificate/private key pair in the
- * gnutls_certificate_credentials_t structure. This function may be
- * called more than once (in case multiple keys/certificates exist
- * for the server).
- *
- * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
- **/
-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 ret, i;
-
- /* this should be first
- */
-
- res->pkey =
- gnutls_realloc_fast (res->pkey,
- (res->ncerts + 1) * sizeof (gnutls_privkey));
- if (res->pkey == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- ret = _gnutls_x509_privkey_to_gkey (&res->pkey[res->ncerts], key);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- res->cert_list = gnutls_realloc_fast (res->cert_list,
- (1 +
- res->ncerts) *
- sizeof (gnutls_cert *));
- if (res->cert_list == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- res->cert_list_length = gnutls_realloc_fast (res->cert_list_length,
- (1 +
- res->ncerts) * sizeof (int));
- if (res->cert_list_length == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- res->cert_list[res->ncerts] = NULL; /* for realloc */
- res->cert_list_length[res->ncerts] = 0;
-
-
- for (i = 0; i < cert_list_size; i++)
- {
- ret = parse_crt_mem (&res->cert_list[res->ncerts],
- &res->cert_list_length[res->ncerts], cert_list[i]);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
- }
- res->ncerts++;
-
- if ((ret = _gnutls_check_key_cert_match (res)) < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- return 0;
-}
-
-/**
- * gnutls_certificate_set_x509_key_file - Used to set keys in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_key_file - Used to set keys in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @CERTFILE: is a file that containing the certificate list (path) for
* the specified private key, in PKCS7 format, or a list of certificates
* @KEYFILE: is a file that contains the private key
* @type: is PEM or DER
*
* This function sets a certificate/private key pair in the
- * gnutls_certificate_credentials_t structure. This function may be
+ * mhd_gtls_cert_credentials_t structure. This function may be
* called more than once (in case multiple keys/certificates exist
* for the server).
*
@@ -949,7 +864,7 @@ gnutls_certificate_set_x509_key (gnutls_certificate_credentials_t res,
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
-gnutls_certificate_set_x509_key_file (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_key_file (mhd_gtls_cert_credentials_t
res, const char *CERTFILE,
const char *KEYFILE,
gnutls_x509_crt_fmt_t type)
@@ -976,7 +891,7 @@ gnutls_certificate_set_x509_key_file (gnutls_certificate_credentials_t
}
static int
-generate_rdn_seq (gnutls_certificate_credentials_t res)
+generate_rdn_seq (mhd_gtls_cert_credentials_t res)
{
gnutls_datum_t tmp;
int ret;
@@ -1028,7 +943,7 @@ generate_rdn_seq (gnutls_certificate_credentials_t res)
return ret;
}
- _gnutls_write_datum16 (pdata, tmp);
+ mhd_gtls_write_datum16 (pdata, tmp);
pdata += (2 + tmp.size);
_gnutls_free_datum (&tmp);
}
@@ -1051,13 +966,13 @@ _gnutls_check_key_usage (const gnutls_cert * cert, gnutls_kx_algorithm_t alg)
return GNUTLS_E_INTERNAL_ERROR;
}
- if (_gnutls_map_kx_get_cred (alg, 1) == MHD_GNUTLS_CRD_CERTIFICATE ||
- _gnutls_map_kx_get_cred (alg, 0) == MHD_GNUTLS_CRD_CERTIFICATE)
+ if (mhd_gtls_map_kx_get_cred (alg, 1) == MHD_GNUTLS_CRD_CERTIFICATE ||
+ mhd_gtls_map_kx_get_cred (alg, 0) == MHD_GNUTLS_CRD_CERTIFICATE)
{
key_usage = cert->key_usage;
- encipher_type = _gnutls_kx_encipher_type (alg);
+ encipher_type = mhd_gtls_kx_encipher_type (alg);
if (key_usage != 0 && encipher_type != CIPHER_IGN)
{
@@ -1125,7 +1040,7 @@ parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
{
*cert_list =
- (gnutls_x509_crt_t *) gnutls_realloc_fast (*cert_list,
+ (gnutls_x509_crt_t *) mhd_gtls_realloc_fast (*cert_list,
i *
sizeof
(gnutls_x509_crt_t));
@@ -1203,7 +1118,7 @@ parse_der_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
i = *ncerts + 1;
*cert_list =
- (gnutls_x509_crt_t *) gnutls_realloc_fast (*cert_list,
+ (gnutls_x509_crt_t *) mhd_gtls_realloc_fast (*cert_list,
i *
sizeof (gnutls_x509_crt_t));
@@ -1237,26 +1152,26 @@ parse_der_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
}
/**
- * gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @ca: is a list of trusted CAs or a DER certificate
* @type: is DER or PEM
*
* This function adds the trusted CAs in order to verify client or
* server certificates. In case of a client this is not required to
* be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2(). This function may be called
+ * MHD_gtls_certificate_verify_peers2(). This function may be called
* multiple times.
*
* In case of a server the CAs set here will be sent to the client if
* a certificate request is sent. This can be disabled using
- * gnutls_certificate_send_x509_rdn_sequence().
+ * MHD_gnutls_certificate_send_x509_rdn_sequence().
*
* Returns: the number of certificates processed or a negative value
* on error.
**/
int
-gnutls_certificate_set_x509_trust_mem (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
res, const gnutls_datum_t * ca,
gnutls_x509_crt_fmt_t type)
{
@@ -1276,87 +1191,26 @@ gnutls_certificate_set_x509_trust_mem (gnutls_certificate_credentials_t
}
/**
- * gnutls_certificate_set_x509_trust - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
- * @ca_list: is a list of trusted CAs
- * @ca_list_size: holds the size of the CA list
- *
- * This function adds the trusted CAs in order to verify client
- * or server certificates. In case of a client this is not required
- * to be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2().
- * This function may be called multiple times.
- *
- * In case of a server the CAs set here will be sent to the client if
- * a certificate request is sent. This can be disabled using
- * gnutls_certificate_send_x509_rdn_sequence().
- *
- * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
- **/
-int
-gnutls_certificate_set_x509_trust (gnutls_certificate_credentials_t res,
- gnutls_x509_crt_t * ca_list,
- int ca_list_size)
-{
- int ret, i, ret2;
-
- res->x509_ca_list = gnutls_realloc_fast (res->x509_ca_list,
- (ca_list_size +
- res->x509_ncas) *
- sizeof (gnutls_x509_crt_t));
- if (res->x509_ca_list == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- for (i = 0; i < ca_list_size; i++)
- {
- ret = gnutls_x509_crt_init (&res->x509_ca_list[res->x509_ncas]);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- ret = _gnutls_x509_crt_cpy (res->x509_ca_list[res->x509_ncas],
- ca_list[i]);
- if (ret < 0)
- {
- gnutls_assert ();
- gnutls_x509_crt_deinit (res->x509_ca_list[res->x509_ncas]);
- return ret;
- }
- res->x509_ncas++;
- }
-
- if ((ret2 = generate_rdn_seq (res)) < 0)
- return ret2;
-
- return 0;
-}
-
-/**
- * gnutls_certificate_set_x509_trust_file - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_trust_file - Used to add trusted CAs in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @cafile: is a file containing the list of trusted CAs (DER or PEM list)
* @type: is PEM or DER
*
* This function adds the trusted CAs in order to verify client or
* server certificates. In case of a client this is not required to
* be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2(). This function may be called
+ * MHD_gtls_certificate_verify_peers2(). This function may be called
* multiple times.
*
* In case of a server the names of the CAs set here will be sent to
* the client if a certificate request is sent. This can be disabled
- * using gnutls_certificate_send_x509_rdn_sequence().
+ * using MHD_gnutls_certificate_send_x509_rdn_sequence().
*
* Returns: number of certificates processed, or a negative value on
* error.
**/
int
-gnutls_certificate_set_x509_trust_file (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_trust_file (mhd_gtls_cert_credentials_t
res, const char *cafile,
gnutls_x509_crt_fmt_t type)
{
@@ -1419,7 +1273,7 @@ parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
{
*crl_list =
- (gnutls_x509_crl_t *) gnutls_realloc_fast (*crl_list,
+ (gnutls_x509_crl_t *) mhd_gtls_realloc_fast (*crl_list,
i *
sizeof
(gnutls_x509_crl_t));
@@ -1487,7 +1341,7 @@ parse_der_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
i = *ncrls + 1;
*crl_list =
- (gnutls_x509_crl_t *) gnutls_realloc_fast (*crl_list,
+ (gnutls_x509_crl_t *) mhd_gtls_realloc_fast (*crl_list,
i *
sizeof (gnutls_x509_crl_t));
@@ -1524,14 +1378,14 @@ parse_der_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
/* Reads a DER or PEM CRL from memory
*/
static int
-read_crl_mem (gnutls_certificate_credentials_t res, const void *crl,
+read_crl_mem (mhd_gtls_cert_credentials_t res, const void *crl,
int crl_size, gnutls_x509_crt_fmt_t type)
{
int ret;
/* allocate space for the certificate to add
*/
- res->x509_crl_list = gnutls_realloc_fast (res->x509_crl_list,
+ res->x509_crl_list = mhd_gtls_realloc_fast (res->x509_crl_list,
(1 +
res->x509_ncrls) *
sizeof (gnutls_x509_crl_t));
@@ -1558,21 +1412,21 @@ read_crl_mem (gnutls_certificate_credentials_t res, const void *crl,
}
/**
- * gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @CRL: is a list of trusted CRLs. They should have been verified before.
* @type: is DER or PEM
*
* This function adds the trusted CRLs in order to verify client or
* server certificates. In case of a client this is not required to
* be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2(). This function may be called
+ * MHD_gtls_certificate_verify_peers2(). This function may be called
* multiple times.
*
* Returns: number of CRLs processed, or a negative value on error.
**/
int
-gnutls_certificate_set_x509_crl_mem (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
res, const gnutls_datum_t * CRL,
gnutls_x509_crt_fmt_t type)
{
@@ -1585,74 +1439,21 @@ gnutls_certificate_set_x509_crl_mem (gnutls_certificate_credentials_t
}
/**
- * gnutls_certificate_set_x509_crl - Used to add CRLs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
- * @crl_list: is a list of trusted CRLs. They should have been verified before.
- * @crl_list_size: holds the size of the crl_list
- *
- * This function adds the trusted CRLs in order to verify client or
- * server certificates. In case of a client this is not required to
- * be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2(). This function may be called
- * multiple times.
- *
- * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
- **/
-int
-gnutls_certificate_set_x509_crl (gnutls_certificate_credentials_t res,
- gnutls_x509_crl_t * crl_list,
- int crl_list_size)
-{
- int ret, i;
-
- res->x509_crl_list = gnutls_realloc_fast (res->x509_crl_list,
- (crl_list_size +
- res->x509_ncrls) *
- sizeof (gnutls_x509_crl_t));
- if (res->x509_crl_list == NULL)
- {
- gnutls_assert ();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- for (i = 0; i < crl_list_size; i++)
- {
- ret = gnutls_x509_crl_init (&res->x509_crl_list[res->x509_ncrls]);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- ret = _gnutls_x509_crl_cpy (res->x509_crl_list[res->x509_ncrls],
- crl_list[i]);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
- res->x509_ncrls++;
- }
-
- return 0;
-}
-
-/**
- * gnutls_certificate_set_x509_crl_file - Used to add CRLs in a gnutls_certificate_credentials_t structure
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_set_x509_crl_file - Used to add CRLs in a mhd_gtls_cert_credentials_t structure
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @crlfile: is a file containing the list of verified CRLs (DER or PEM list)
* @type: is PEM or DER
*
* This function adds the trusted CRLs in order to verify client or server
* certificates. In case of a client this is not required
* to be called if the certificates are not verified using
- * gnutls_certificate_verify_peers2().
+ * MHD_gtls_certificate_verify_peers2().
* This function may be called multiple times.
*
* Returns: number of CRLs processed or a negative value on error.
**/
int
-gnutls_certificate_set_x509_crl_file (gnutls_certificate_credentials_t
+MHD_gnutls_certificate_set_x509_crl_file (mhd_gtls_cert_credentials_t
res, const char *crlfile,
gnutls_x509_crt_fmt_t type)
{
@@ -1687,7 +1488,7 @@ gnutls_certificate_set_x509_crl_file (gnutls_certificate_credentials_t
#include <pkcs12.h>
static int
-parse_pkcs12 (gnutls_certificate_credentials_t res,
+parse_pkcs12 (mhd_gtls_cert_credentials_t res,
gnutls_pkcs12_t p12,
const char *password,
gnutls_x509_privkey_t * key,
@@ -1840,13 +1641,13 @@ done:
/**
* gnutls_certificate_set_x509_simple_pkcs12_file:
- * @res: is an #gnutls_certificate_credentials_t structure.
+ * @res: is an #mhd_gtls_cert_credentials_t structure.
* @pkcs12file: filename of file containing PKCS#12 blob.
* @type: is PEM or DER of the @pkcs12file.
* @password: optional password used to decrypt PKCS#12 file, bags and keys.
*
* This function sets a certificate/private key pair and/or a CRL in
- * the gnutls_certificate_credentials_t structure. This function may
+ * the mhd_gtls_cert_credentials_t structure. This function may
* be called more than once (in case multiple keys/certificates exist
* for the server).
*
@@ -1870,107 +1671,107 @@ done:
*
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
-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)
-{
- gnutls_pkcs12_t p12;
- gnutls_datum_t p12blob;
- gnutls_x509_privkey_t key = NULL;
- gnutls_x509_crt_t cert = NULL;
- gnutls_x509_crl_t crl = NULL;
- int ret;
- size_t size;
-
- ret = gnutls_pkcs12_init (&p12);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- p12blob.data = read_binary_file (pkcs12file, &size);
- p12blob.size = (unsigned int) size;
- if (p12blob.data == NULL)
- {
- gnutls_assert ();
- gnutls_pkcs12_deinit (p12);
- return GNUTLS_E_FILE_ERROR;
- }
-
- ret = gnutls_pkcs12_import (p12, &p12blob, type, 0);
- free (p12blob.data);
- if (ret < 0)
- {
- gnutls_assert ();
- gnutls_pkcs12_deinit (p12);
- return ret;
- }
-
- if (password)
- {
- ret = gnutls_pkcs12_verify_mac (p12, password);
- if (ret < 0)
- {
- gnutls_assert ();
- gnutls_pkcs12_deinit (p12);
- return ret;
- }
- }
-
- ret = parse_pkcs12 (res, p12, password, &key, &cert, &crl);
- gnutls_pkcs12_deinit (p12);
- if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
-
- if (key && cert)
- {
- ret = gnutls_certificate_set_x509_key (res, &cert, 1, key);
- if (ret < 0)
- {
- gnutls_assert ();
- goto done;
- }
- }
-
- if (crl)
- {
- ret = gnutls_certificate_set_x509_crl (res, &crl, 1);
- if (ret < 0)
- {
- gnutls_assert ();
- goto done;
- }
- }
-
- ret = 0;
-
-done:
- if (cert)
- gnutls_x509_crt_deinit (cert);
- if (key)
- gnutls_x509_privkey_deinit (key);
- if (crl)
- gnutls_x509_crl_deinit (crl);
-
- return ret;
-}
+//int
+// gnutls_certificate_set_x509_simple_pkcs12_file
+// (mhd_gtls_cert_credentials_t res, const char *pkcs12file,
+// gnutls_x509_crt_fmt_t type, const char *password)
+//{
+// gnutls_pkcs12_t p12;
+// gnutls_datum_t p12blob;
+// gnutls_x509_privkey_t key = NULL;
+// gnutls_x509_crt_t cert = NULL;
+// gnutls_x509_crl_t crl = NULL;
+// int ret;
+// size_t size;
+//
+// ret = gnutls_pkcs12_init (&p12);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// return ret;
+// }
+//
+// p12blob.data = read_binary_file (pkcs12file, &size);
+// p12blob.size = (unsigned int) size;
+// if (p12blob.data == NULL)
+// {
+// gnutls_assert ();
+// gnutls_pkcs12_deinit (p12);
+// return GNUTLS_E_FILE_ERROR;
+// }
+//
+// ret = gnutls_pkcs12_import (p12, &p12blob, type, 0);
+// free (p12blob.data);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// gnutls_pkcs12_deinit (p12);
+// return ret;
+// }
+//
+// if (password)
+// {
+// ret = gnutls_pkcs12_verify_mac (p12, password);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// gnutls_pkcs12_deinit (p12);
+// return ret;
+// }
+// }
+//
+// ret = parse_pkcs12 (res, p12, password, &key, &cert, &crl);
+// gnutls_pkcs12_deinit (p12);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// return ret;
+// }
+//
+// if (key && cert)
+// {
+// ret = gnutls_certificate_set_x509_key (res, &cert, 1, key);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// goto done;
+// }
+// }
+//
+// if (crl)
+// {
+// ret = gnutls_certificate_set_x509_crl (res, &crl, 1);
+// if (ret < 0)
+// {
+// gnutls_assert ();
+// goto done;
+// }
+// }
+//
+// ret = 0;
+//
+//done:
+// if (cert)
+// gnutls_x509_crt_deinit (cert);
+// if (key)
+// gnutls_x509_privkey_deinit (key);
+// if (crl)
+// gnutls_x509_crl_deinit (crl);
+//
+// return ret;
+//}
/**
- * gnutls_certificate_free_crls - Used to free all the CRLs from a gnutls_certificate_credentials_t structure
- * @sc: is an #gnutls_certificate_credentials_t structure.
+ * MHD_gnutls_certificate_free_crls - Used to free all the CRLs from a mhd_gtls_cert_credentials_t structure
+ * @sc: is an #mhd_gtls_cert_credentials_t structure.
*
* This function will delete all the CRLs associated
* with the given credentials.
*
**/
void
-gnutls_certificate_free_crls (gnutls_certificate_credentials_t sc)
+MHD_gnutls_certificate_free_crls (mhd_gtls_cert_credentials_t sc)
{
unsigned j;
diff --git a/src/daemon/https/tls/gnutls_x509.h b/src/daemon/https/tls/gnutls_x509.h
@@ -24,7 +24,7 @@
#include <libtasn1.h>
-int _gnutls_x509_cert_verify_peers (gnutls_session_t session,
+int _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
unsigned int *status);
#define PEM_CERT_SEP2 "-----BEGIN X509 CERTIFICATE"
diff --git a/src/daemon/https/tls/x509_b64.c b/src/daemon/https/tls/x509_b64.c
@@ -287,7 +287,7 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
}
/**
- * gnutls_pem_base64_encode - This function will convert raw data to Base64 encoded
+ * MHD_gtls_pem_base64_encode - This function will convert raw data to Base64 encoded
* @msg: is a message to be put in the header
* @data: contain the raw data
* @result: the place where base64 data will be copied
@@ -302,7 +302,7 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
*
**/
int
-gnutls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
+MHD_gtls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
char *result, size_t * result_size)
{
opaque *ret;
@@ -329,7 +329,7 @@ gnutls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
}
/**
- * gnutls_pem_base64_encode_alloc - This function will convert raw data to Base64 encoded
+ * MHD_gtls_pem_base64_encode_alloc - This function will convert raw data to Base64 encoded
* @msg: is a message to be put in the encoded header
* @data: contains the raw data
* @result: will hold the newly allocated encoded data
@@ -342,7 +342,7 @@ gnutls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
*
**/
int
-gnutls_pem_base64_encode_alloc (const char *msg,
+MHD_gtls_pem_base64_encode_alloc (const char *msg,
const gnutls_datum_t * data,
gnutls_datum_t * result)
{
@@ -436,9 +436,9 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
int kdata_size;
char pem_header[128];
- _gnutls_str_cpy (pem_header, sizeof (pem_header), top);
+ mhd_gtls_str_cpy (pem_header, sizeof (pem_header), top);
if (header != NULL)
- _gnutls_str_cat (pem_header, sizeof (pem_header), header);
+ mhd_gtls_str_cat (pem_header, sizeof (pem_header), header);
rdata = memmem (data, data_size, pem_header, strlen (pem_header));
@@ -520,7 +520,7 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
}
/**
- * gnutls_pem_base64_decode - This function will decode base64 encoded data
+ * MHD_gtls_pem_base64_decode - This function will decode base64 encoded data
* @header: A null terminated string with the PEM header (eg. CERTIFICATE)
* @b64_data: contain the encoded data
* @result: the place where decoded data will be copied
@@ -534,7 +534,7 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
* or 0 on success.
**/
int
-gnutls_pem_base64_decode (const char *header,
+MHD_gtls_pem_base64_decode (const char *header,
const gnutls_datum_t * b64_data,
unsigned char *result, size_t * result_size)
{
@@ -563,7 +563,7 @@ gnutls_pem_base64_decode (const char *header,
}
/**
- * gnutls_pem_base64_decode_alloc - This function will decode base64 encoded data
+ * MHD_gtls_pem_base64_decode_alloc - This function will decode base64 encoded data
* @header: The PEM header (eg. CERTIFICATE)
* @b64_data: contains the encoded data
* @result: the place where decoded data lie
@@ -578,7 +578,7 @@ gnutls_pem_base64_decode (const char *header,
*
**/
int
-gnutls_pem_base64_decode_alloc (const char *header,
+MHD_gtls_pem_base64_decode_alloc (const char *header,
const gnutls_datum_t * b64_data,
gnutls_datum_t * result)
{
diff --git a/src/daemon/https/x509/Makefile.am b/src/daemon/https/x509/Makefile.am
@@ -32,6 +32,5 @@ sign.c \
x509_verify.c \
x509.c \
x509_write.c
-# output.c
diff --git a/src/daemon/https/x509/common.c b/src/daemon/https/x509/common.c
@@ -288,8 +288,8 @@ _gnutls_x509_oid_data2string (const char *oid,
return GNUTLS_E_INTERNAL_ERROR;
}
- _gnutls_str_cpy (str, sizeof (str), "PKIX1.");
- _gnutls_str_cat (str, sizeof (str), ANAME);
+ mhd_gtls_str_cpy (str, sizeof (str), "PKIX1.");
+ mhd_gtls_str_cat (str, sizeof (str), ANAME);
if ((result = asn1_create_element (_gnutls_get_pkix (), str,
&tmpasn)) != ASN1_SUCCESS)
@@ -323,7 +323,7 @@ _gnutls_x509_oid_data2string (const char *oid,
str[len] = 0;
if (res)
- _gnutls_str_cpy (res, *res_size, str);
+ mhd_gtls_str_cpy (res, *res_size, str);
*res_size = len;
asn1_delete_structure (&tmpasn);
@@ -345,7 +345,7 @@ _gnutls_x509_oid_data2string (const char *oid,
if (strcmp (str, "teletexString") == 0)
teletex = 1;
- _gnutls_str_cpy (tmpname, sizeof (tmpname), str);
+ mhd_gtls_str_cpy (tmpname, sizeof (tmpname), str);
len = sizeof (str) - 1;
if ((result = asn1_read_value (tmpasn, tmpname, str, &len))
@@ -376,7 +376,7 @@ _gnutls_x509_oid_data2string (const char *oid,
if (non_printable == 0)
{
str[len] = 0;
- _gnutls_str_cpy (res, *res_size, str);
+ mhd_gtls_str_cpy (res, *res_size, str);
*res_size = len;
}
else
@@ -411,7 +411,7 @@ _gnutls_x509_data2hex (const opaque * data,
return GNUTLS_E_INTERNAL_ERROR;
}
- res = _gnutls_bin2hex (data, data_size, escaped, sizeof (escaped));
+ res = mhd_gtls_bin2hex (data, data_size, escaped, sizeof (escaped));
if (res)
{
@@ -694,7 +694,7 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
time_t c_time = (time_t) - 1;
int len, result;
- _gnutls_str_cpy (name, sizeof (name), when);
+ mhd_gtls_str_cpy (name, sizeof (name), when);
len = sizeof (ttime) - 1;
if ((result = asn1_read_value (c2, name, ttime, &len)) < 0)
@@ -707,7 +707,7 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
if (strcmp (ttime, "generalTime") == 0)
{
- _gnutls_str_cat (name, sizeof (name), ".generalTime");
+ mhd_gtls_str_cat (name, sizeof (name), ".generalTime");
len = sizeof (ttime) - 1;
result = asn1_read_value (c2, name, ttime, &len);
if (result == ASN1_SUCCESS)
@@ -716,7 +716,7 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
else
{ /* UTCTIME */
- _gnutls_str_cat (name, sizeof (name), ".utcTime");
+ mhd_gtls_str_cat (name, sizeof (name), ".utcTime");
len = sizeof (ttime) - 1;
result = asn1_read_value (c2, name, ttime, &len);
if (result == ASN1_SUCCESS)
@@ -745,7 +745,7 @@ _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
char name[128];
int result, len;
- _gnutls_str_cpy (name, sizeof (name), where);
+ mhd_gtls_str_cpy (name, sizeof (name), where);
if ((result = asn1_write_value (c2, name, "utcTime", 1)) < 0)
{
@@ -760,7 +760,7 @@ _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
return result;
}
- _gnutls_str_cat (name, sizeof (name), ".utcTime");
+ mhd_gtls_str_cat (name, sizeof (name), ".utcTime");
len = strlen (str_time);
result = asn1_write_value (c2, name, str_time, len);
@@ -894,11 +894,11 @@ _gnutls_x509_decode_octet_string (const char *string_type,
char strname[64];
if (string_type == NULL)
- _gnutls_str_cpy (strname, sizeof (strname), "PKIX1.pkcs-7-Data");
+ mhd_gtls_str_cpy (strname, sizeof (strname), "PKIX1.pkcs-7-Data");
else
{
- _gnutls_str_cpy (strname, sizeof (strname), "PKIX1.");
- _gnutls_str_cat (strname, sizeof (strname), string_type);
+ mhd_gtls_str_cpy (strname, sizeof (strname), "PKIX1.");
+ mhd_gtls_str_cat (strname, sizeof (strname), string_type);
}
if ((result =
@@ -1226,7 +1226,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
int result;
char name[128];
- pk = _gnutls_x509_pk_to_oid (pk_algorithm);
+ pk = mhd_gtls_x509_pk_to_oid (pk_algorithm);
if (pk == NULL)
{
gnutls_assert ();
@@ -1235,8 +1235,8 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
/* write the OID
*/
- _gnutls_str_cpy (name, sizeof (name), dst_name);
- _gnutls_str_cat (name, sizeof (name), ".algorithm.algorithm");
+ mhd_gtls_str_cpy (name, sizeof (name), dst_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
result = asn1_write_value (dst, name, pk, 1);
if (result != ASN1_SUCCESS)
{
@@ -1248,8 +1248,8 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
{
/* disable parameters, which are not used in RSA.
*/
- _gnutls_str_cpy (name, sizeof (name), dst_name);
- _gnutls_str_cat (name, sizeof (name), ".algorithm.parameters");
+ mhd_gtls_str_cpy (name, sizeof (name), dst_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".algorithm.parameters");
result = asn1_write_value (dst, name, NULL, 0);
if (result != ASN1_SUCCESS)
{
@@ -1266,8 +1266,8 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
/* Write the DER parameters. (in bits)
*/
- _gnutls_str_cpy (name, sizeof (name), dst_name);
- _gnutls_str_cat (name, sizeof (name), ".subjectPublicKey");
+ mhd_gtls_str_cpy (name, sizeof (name), dst_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
result = asn1_write_value (dst, name, der.data, der.size * 8);
_gnutls_free_datum (&der);
@@ -1299,8 +1299,8 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
char name[128];
- _gnutls_str_cpy (name, sizeof (name), src_name);
- _gnutls_str_cat (name, sizeof (name), ".algorithm.algorithm");
+ mhd_gtls_str_cpy (name, sizeof (name), src_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
len = sizeof (oid);
result = asn1_read_value (src, name, oid, &len);
@@ -1311,7 +1311,7 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
return _gnutls_asn2err (result);
}
- algo = _gnutls_x509_oid2pk_algorithm (oid);
+ algo = mhd_gtls_x509_oid2pk_algorithm (oid);
if (bits == NULL)
{
@@ -1321,8 +1321,8 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
/* Now read the parameters' bits
*/
- _gnutls_str_cpy (name, sizeof (name), src_name);
- _gnutls_str_cat (name, sizeof (name), ".subjectPublicKey");
+ mhd_gtls_str_cpy (name, sizeof (name), src_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
len = 0;
result = asn1_read_value (src, name, NULL, &len);
@@ -1347,8 +1347,8 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
return GNUTLS_E_MEMORY_ERROR;
}
- _gnutls_str_cpy (name, sizeof (name), src_name);
- _gnutls_str_cat (name, sizeof (name), ".subjectPublicKey");
+ mhd_gtls_str_cpy (name, sizeof (name), src_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
result = asn1_read_value (src, name, str, &len);
@@ -1373,8 +1373,8 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
bits[0] = _gnutls_mpi_get_nbits (params[0]);
- _gnutls_mpi_release (¶ms[0]);
- _gnutls_mpi_release (¶ms[1]);
+ mhd_gtls_mpi_release (¶ms[0]);
+ mhd_gtls_mpi_release (¶ms[1]);
}
break;
default:
diff --git a/src/daemon/https/x509/crl.c b/src/daemon/https/x509/crl.c
@@ -305,7 +305,7 @@ gnutls_x509_crl_get_signature_algorithm (gnutls_x509_crl_t crl)
return result;
}
- result = _gnutls_x509_oid2sign_algorithm ((const char *) sa.data);
+ result = mhd_gtls_x509_oid2sign_algorithm ((const char *) sa.data);
_gnutls_free_datum (&sa);
diff --git a/src/daemon/https/x509/crq.c b/src/daemon/https/x509/crq.c
@@ -338,8 +338,8 @@ parse_attribute (ASN1_TYPE asn1_struct,
*/
/* Read the OID
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer1);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer1);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
len = sizeof (oid) - 1;
result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
diff --git a/src/daemon/https/x509/dn.c b/src/daemon/https/x509/dn.c
@@ -91,7 +91,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
const char *asn1_rdn_name, char *buf,
size_t * sizeof_buf)
{
- gnutls_string out_str;
+ mhd_gtls_string out_str;
int k2, k1, result;
char tmpbuffer1[MAX_NAME_SIZE];
char tmpbuffer2[MAX_NAME_SIZE];
@@ -115,7 +115,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
else
*sizeof_buf = 0;
- _gnutls_string_init (&out_str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ mhd_gtls_string_init (&out_str, gnutls_malloc, gnutls_realloc, gnutls_free);
k1 = 0;
do
@@ -175,8 +175,8 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
/* Read the OID
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
len = sizeof (oid) - 1;
result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
@@ -192,8 +192,8 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
/* Read the Value
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
len = 0;
result = asn1_read_value (asn1_struct, tmpbuffer3, NULL, &len);
@@ -214,7 +214,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
result = _gnutls_asn2err (result);
goto cleanup;
}
-#define STR_APPEND(y) if ((result=_gnutls_string_append_str( &out_str, y)) < 0) { \
+#define STR_APPEND(y) if ((result=mhd_gtls_string_append_str( &out_str, y)) < 0) { \
gnutls_assert(); \
goto cleanup; \
}
@@ -280,7 +280,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
gnutls_assert ();
_gnutls_x509_log
("Found OID: '%s' with value '%s'\n",
- oid, _gnutls_bin2hex (value2, len, escaped, sizeof_escaped));
+ oid, mhd_gtls_bin2hex (value2, len, escaped, sizeof_escaped));
goto cleanup;
}
STR_APPEND (str_escape (string, escaped, sizeof_escaped));
@@ -319,7 +319,7 @@ cleanup:
gnutls_free (value2);
gnutls_free (string);
gnutls_free (escaped);
- _gnutls_string_clear (&out_str);
+ mhd_gtls_string_clear (&out_str);
return result;
}
@@ -418,8 +418,8 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
/* Read the OID
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
len = sizeof (oid) - 1;
result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
@@ -438,8 +438,8 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
/* Read the Value
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
len = *sizeof_buf;
result = asn1_read_value (asn1_struct, tmpbuffer3, buf, &len);
@@ -587,8 +587,8 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
/* Read the OID
*/
- _gnutls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
- _gnutls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+ mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+ mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
len = sizeof (oid) - 1;
result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
@@ -660,8 +660,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
return GNUTLS_E_X509_UNSUPPORTED_OID;
}
- _gnutls_str_cpy (tmp, sizeof (tmp), "PKIX1.");
- _gnutls_str_cat (tmp, sizeof (tmp), val_name);
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), "PKIX1.");
+ mhd_gtls_str_cat (tmp, sizeof (tmp), val_name);
result = asn1_create_element (_gnutls_get_pkix (), tmp, &c2);
if (result != ASN1_SUCCESS)
@@ -702,7 +702,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (tmp, sizeof (tmp), string_type);
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), string_type);
}
result = asn1_write_value (c2, tmp, data, sizeof_data);
@@ -717,12 +717,12 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
/* write the data (value)
*/
- _gnutls_str_cpy (tmp, sizeof (tmp), where);
- _gnutls_str_cat (tmp, sizeof (tmp), ".value");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".value");
if (multi != 0)
{ /* if not writing an AttributeTypeAndValue, but an Attribute */
- _gnutls_str_cat (tmp, sizeof (tmp), "s"); /* values */
+ mhd_gtls_str_cat (tmp, sizeof (tmp), "s"); /* values */
result = asn1_write_value (asn1_struct, tmp, "NEW", 1);
if (result != ASN1_SUCCESS)
@@ -731,7 +731,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
return _gnutls_asn2err (result);
}
- _gnutls_str_cat (tmp, sizeof (tmp), ".?LAST");
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
}
@@ -744,8 +744,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
/* write the type
*/
- _gnutls_str_cpy (tmp, sizeof (tmp), where);
- _gnutls_str_cat (tmp, sizeof (tmp), ".type");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".type");
result = asn1_write_value (asn1_struct, tmp, given_oid, 1);
if (result != ASN1_SUCCESS)
@@ -772,12 +772,12 @@ _gnutls_x509_write_attribute (const char *given_oid,
/* write the data (value)
*/
- _gnutls_str_cpy (tmp, sizeof (tmp), where);
- _gnutls_str_cat (tmp, sizeof (tmp), ".value");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".value");
if (multi != 0)
{ /* if not writing an AttributeTypeAndValue, but an Attribute */
- _gnutls_str_cat (tmp, sizeof (tmp), "s"); /* values */
+ mhd_gtls_str_cat (tmp, sizeof (tmp), "s"); /* values */
result = asn1_write_value (asn1_struct, tmp, "NEW", 1);
if (result != ASN1_SUCCESS)
@@ -786,7 +786,7 @@ _gnutls_x509_write_attribute (const char *given_oid,
return _gnutls_asn2err (result);
}
- _gnutls_str_cat (tmp, sizeof (tmp), ".?LAST");
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
}
@@ -799,8 +799,8 @@ _gnutls_x509_write_attribute (const char *given_oid,
/* write the type
*/
- _gnutls_str_cpy (tmp, sizeof (tmp), where);
- _gnutls_str_cat (tmp, sizeof (tmp), ".type");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".type");
result = asn1_write_value (asn1_struct, tmp, given_oid, 1);
if (result != ASN1_SUCCESS)
@@ -832,8 +832,8 @@ _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
/* Read the OID
*/
- _gnutls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
- _gnutls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".type");
+ mhd_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
+ mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".type");
len = oid_size - 1;
result = asn1_read_value (asn1_struct, tmpbuffer, oid, &len);
@@ -848,11 +848,11 @@ _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
/* Read the Value
*/
- _gnutls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
- _gnutls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".value");
+ mhd_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
+ mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".value");
if (multi)
- _gnutls_str_cat (tmpbuffer, sizeof (tmpbuffer), "s.?1"); /* .values.?1 */
+ mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), "s.?1"); /* .values.?1 */
result =
_gnutls_x509_read_value (asn1_struct, tmpbuffer, value, octet_string);
@@ -896,8 +896,8 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (asn1_rdn_name, sizeof (asn1_rdn_name), asn1_name);
- _gnutls_str_cat (asn1_rdn_name, sizeof (asn1_rdn_name), ".rdnSequence");
+ mhd_gtls_str_cpy (asn1_rdn_name, sizeof (asn1_rdn_name), asn1_name);
+ mhd_gtls_str_cat (asn1_rdn_name, sizeof (asn1_rdn_name), ".rdnSequence");
/* create a new element
*/
@@ -908,8 +908,8 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
- _gnutls_str_cat (tmp, sizeof (tmp), ".?LAST");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
/* create the set with only one element
*/
@@ -923,8 +923,8 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
/* Encode and write the data
*/
- _gnutls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
- _gnutls_str_cat (tmp, sizeof (tmp), ".?LAST.?LAST");
+ mhd_gtls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
+ mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST.?LAST");
if (!raw_flag)
{
diff --git a/src/daemon/https/x509/extensions.c b/src/daemon/https/x509/extensions.c
@@ -82,8 +82,8 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
do
{
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".extnID");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
len = sizeof (extnID) - 1;
result = asn1_read_value (cert->cert, name2, extnID, &len);
@@ -108,8 +108,8 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
/* read the critical status.
*/
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".critical");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".critical");
len = sizeof (str_critical);
result =
@@ -133,8 +133,8 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
/* read the value.
*/
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".extnValue");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".extnValue");
result = _gnutls_x509_read_value (cert->cert, name2, &value, 0);
if (result < 0)
@@ -206,8 +206,8 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
do
{
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".extnID");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
len = sizeof (extnID) - 1;
result = asn1_read_value (cert->cert, name2, extnID, &len);
@@ -335,8 +335,8 @@ overwrite_extension (ASN1_TYPE asn, unsigned int indx,
else
str = "TRUE";
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".critical");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".critical");
result = asn1_write_value (asn, name2, str, 1);
if (result != ASN1_SUCCESS)
@@ -345,8 +345,8 @@ overwrite_extension (ASN1_TYPE asn, unsigned int indx,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".extnValue");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".extnValue");
result = _gnutls_x509_write_value (asn, name2, ext_data, 0);
if (result < 0)
@@ -397,8 +397,8 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
do
{
- _gnutls_str_cpy (name2, sizeof (name2), name);
- _gnutls_str_cat (name2, sizeof (name2), ".extnID");
+ mhd_gtls_str_cpy (name2, sizeof (name2), name);
+ mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
len = sizeof (extnID) - 1;
result = asn1_read_value (cert->cert, name2, extnID, &len);
@@ -687,12 +687,12 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
if (ext_name[0] == 0)
{ /* no dot */
- _gnutls_str_cpy (name, sizeof (name), "?LAST");
+ mhd_gtls_str_cpy (name, sizeof (name), "?LAST");
}
else
{
- _gnutls_str_cpy (name, sizeof (name), ext_name);
- _gnutls_str_cat (name, sizeof (name), ".?LAST");
+ mhd_gtls_str_cpy (name, sizeof (name), ext_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".?LAST");
}
result = asn1_write_value (ext, name, str, 1);
@@ -702,8 +702,8 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
return _gnutls_asn2err (result);
}
- _gnutls_str_cat (name, sizeof (name), ".");
- _gnutls_str_cat (name, sizeof (name), str);
+ mhd_gtls_str_cat (name, sizeof (name), ".");
+ mhd_gtls_str_cat (name, sizeof (name), str);
result = asn1_write_value (ext, name, data_string, strlen (data_string));
if (result != ASN1_SUCCESS)
diff --git a/src/daemon/https/x509/mpi.c b/src/daemon/https/x509/mpi.c
@@ -71,7 +71,7 @@ _gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
_gnutls_x509_read_int (spk, "publicExponent", ¶ms[1])) < 0)
{
gnutls_assert ();
- _gnutls_mpi_release (¶ms[0]);
+ mhd_gtls_mpi_release (¶ms[0]);
asn1_delete_structure (&spk);
return GNUTLS_E_ASN1_GENERIC_ERROR;
}
@@ -129,7 +129,7 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
{
gnutls_assert ();
asn1_delete_structure (&spk);
- _gnutls_mpi_release (¶ms[0]);
+ mhd_gtls_mpi_release (¶ms[0]);
return GNUTLS_E_ASN1_GENERIC_ERROR;
}
@@ -139,8 +139,8 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
{
gnutls_assert ();
asn1_delete_structure (&spk);
- _gnutls_mpi_release (¶ms[0]);
- _gnutls_mpi_release (¶ms[1]);
+ mhd_gtls_mpi_release (¶ms[0]);
+ mhd_gtls_mpi_release (¶ms[1]);
return GNUTLS_E_ASN1_GENERIC_ERROR;
}
@@ -343,10 +343,10 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
char name[128];
const char *pk;
- _gnutls_str_cpy (name, sizeof (name), dst_name);
- _gnutls_str_cat (name, sizeof (name), ".algorithm");
+ mhd_gtls_str_cpy (name, sizeof (name), dst_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".algorithm");
- pk = _gnutls_x509_sign_to_oid (pk_algorithm, HASH2MAC (dig));
+ pk = mhd_gtls_x509_sign_to_oid (pk_algorithm, HASH2MAC (dig));
if (pk == NULL)
{
gnutls_assert ();
@@ -362,8 +362,8 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (name, sizeof (name), dst_name);
- _gnutls_str_cat (name, sizeof (name), ".parameters");
+ mhd_gtls_str_cpy (name, sizeof (name), dst_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".parameters");
if (pk_algorithm == MHD_GNUTLS_PK_RSA)
{ /* RSA */
@@ -536,11 +536,11 @@ _gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
if (len == 1)
*ret = tmpstr[0];
else if (len == 2)
- *ret = _gnutls_read_uint16 (tmpstr);
+ *ret = mhd_gtls_read_uint16 (tmpstr);
else if (len == 3)
- *ret = _gnutls_read_uint24 (tmpstr);
+ *ret = mhd_gtls_read_uint24 (tmpstr);
else if (len == 4)
- *ret = _gnutls_read_uint32 (tmpstr);
+ *ret = mhd_gtls_read_uint32 (tmpstr);
else
{
gnutls_assert ();
@@ -561,7 +561,7 @@ _gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
opaque tmpstr[4];
int result;
- _gnutls_write_uint32 (num, tmpstr);
+ mhd_gtls_write_uint32 (num, tmpstr);
result = asn1_write_value (node, value, tmpstr, 4);
diff --git a/src/daemon/https/x509/output.c b/src/daemon/https/x509/output.c
@@ -1,1360 +0,0 @@
-/*
- * Copyright (C) 2007 Free Software Foundation
- *
- * Author: Simon Josefsson
- *
- * 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
- *
- */
-
-/* Functions for printing X.509 Certificate structures
- */
-
-#include <gnutls_int.h>
-#include <common.h>
-#include <gnutls_x509.h>
-#include <x509.h>
-#include <gnutls_errors.h>
-
-/* I18n of error codes. */
-#include "gettext.h"
-#define _(String) dgettext (PACKAGE, String)
-#define N_(String) gettext_noop (String)
-
-#define addf _gnutls_string_append_printf
-#define adds _gnutls_string_append_str
-
-static void
-hexdump (gnutls_string * str, const char *data, size_t len, const char *spc)
-{
- size_t j;
-
- if (spc)
- adds (str, spc);
- for (j = 0; j < len; j++)
- {
- if (((j + 1) % 16) == 0)
- {
- addf (str, "%.2x\n", (unsigned char) data[j]);
- if (spc && j != (len - 1))
- adds (str, spc);
- }
- else if (j == (len - 1))
- addf (str, "%.2x", (unsigned char) data[j]);
- else
- addf (str, "%.2x:", (unsigned char) data[j]);
- }
- if ((j % 16) != 0)
- adds (str, "\n");
-}
-
-static void
-hexprint (gnutls_string * str, const char *data, size_t len)
-{
- size_t j;
-
- if (len == 0)
- adds (str, "00");
- else
- {
- for (j = 0; j < len; j++)
- addf (str, "%.2x", (unsigned char) data[j]);
- }
-}
-
-
-static void
-asciiprint (gnutls_string * str, const char *data, size_t len)
-{
- size_t j;
-
- for (j = 0; j < len; j++)
- if (isprint (data[j]))
- addf (str, "%c", (unsigned char) data[j]);
- else
- addf (str, ".");
-}
-
-static void
-print_proxy (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- int pathlen;
- char *policyLanguage;
- char *policy;
- size_t npolicy;
- int err;
-
- err = gnutls_x509_crt_get_proxy (cert, NULL,
- &pathlen, &policyLanguage,
- &policy, &npolicy);
- if (err < 0)
- {
- addf (str, "error: get_proxy: %s\n", gnutls_strerror (err));
- return;
- }
-
- if (pathlen >= 0)
- addf (str, _("\t\t\tPath Length Constraint: %d\n"), pathlen);
- addf (str, _("\t\t\tPolicy Language: %s"), policyLanguage);
- if (strcmp (policyLanguage, "1.3.6.1.5.5.7.21.1") == 0)
- adds (str, " (id-ppl-inheritALL)\n");
- else if (strcmp (policyLanguage, "1.3.6.1.5.5.7.21.2") == 0)
- adds (str, " (id-ppl-independent)\n");
- else
- adds (str, "\n");
- if (npolicy)
- {
- adds (str, _("\t\t\tPolicy:\n\t\t\t\tASCII: "));
- asciiprint (str, policy, npolicy);
- adds (str, _("\n\t\t\t\tHexdump: "));
- hexprint (str, policy, npolicy);
- adds (str, "\n");
- }
-}
-
-static void
-print_ski (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- char *buffer = NULL;
- size_t size = 0;
- int err;
-
- err = gnutls_x509_crt_get_subject_key_id (cert, buffer, &size, NULL);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_subject_key_id: %s\n", gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_subject_key_id (cert, buffer, &size, NULL);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_subject_key_id2: %s\n", gnutls_strerror (err));
- return;
- }
-
- adds (str, "\t\t\t");
- hexprint (str, buffer, size);
- adds (str, "\n");
-
- gnutls_free (buffer);
-}
-
-static void
-print_aki (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- char *buffer = NULL;
- size_t size = 0;
- int err;
-
- err = gnutls_x509_crt_get_authority_key_id (cert, buffer, &size, NULL);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_authority_key_id: %s\n", gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_authority_key_id (cert, buffer, &size, NULL);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_authority_key_id2: %s\n", gnutls_strerror (err));
- return;
- }
-
- adds (str, "\t\t\t");
- hexprint (str, buffer, size);
- adds (str, "\n");
-
- gnutls_free (buffer);
-}
-
-static void
-print_key_usage (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- unsigned int key_usage;
- int err;
-
- err = gnutls_x509_crt_get_key_usage (cert, &key_usage, NULL);
- if (err < 0)
- {
- addf (str, "error: get_key_usage: %s\n", gnutls_strerror (err));
- return;
- }
-
- if (key_usage & GNUTLS_KEY_DIGITAL_SIGNATURE)
- addf (str, _("\t\t\tDigital signature.\n"));
- if (key_usage & GNUTLS_KEY_NON_REPUDIATION)
- addf (str, _("\t\t\tNon repudiation.\n"));
- if (key_usage & GNUTLS_KEY_KEY_ENCIPHERMENT)
- addf (str, _("\t\t\tKey encipherment.\n"));
- if (key_usage & GNUTLS_KEY_DATA_ENCIPHERMENT)
- addf (str, _("\t\t\tData encipherment.\n"));
- if (key_usage & GNUTLS_KEY_KEY_AGREEMENT)
- addf (str, _("\t\t\tKey agreement.\n"));
- if (key_usage & GNUTLS_KEY_KEY_CERT_SIGN)
- addf (str, _("\t\t\tCertificate signing.\n"));
- if (key_usage & GNUTLS_KEY_CRL_SIGN)
- addf (str, _("\t\t\tCRL signing.\n"));
- if (key_usage & GNUTLS_KEY_ENCIPHER_ONLY)
- addf (str, _("\t\t\tKey encipher only.\n"));
- if (key_usage & GNUTLS_KEY_DECIPHER_ONLY)
- addf (str, _("\t\t\tKey decipher only.\n"));
-}
-
-static void
-print_crldist (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- char *buffer = NULL;
- size_t size;
- int err;
- int indx;
-
- for (indx = 0;; indx++)
- {
- size = 0;
- err = gnutls_x509_crt_get_crl_dist_points (cert, indx, buffer, &size,
- NULL, NULL);
- if (err == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
- return;
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_crl_dist_points: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_crl_dist_points (cert, indx, buffer, &size,
- NULL, NULL);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_crl_dist_points2: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- switch (err)
- {
- case GNUTLS_SAN_DNSNAME:
- addf (str, "\t\t\tDNSname: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_RFC822NAME:
- addf (str, "\t\t\tRFC822name: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_URI:
- addf (str, "\t\t\tURI: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_IPADDRESS:
- addf (str, "\t\t\tIPAddress: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_DN:
- addf (str, "\t\t\tdirectoryName: %.*s\n", size, buffer);
- break;
-
- default:
- addf (str, "error: unknown SAN\n");
- break;
- }
- gnutls_free (buffer);
- }
-}
-
-static void
-print_key_purpose (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- int indx;
- char *buffer = NULL;
- size_t size;
- int err;
-
- for (indx = 0;; indx++)
- {
- size = 0;
- err = gnutls_x509_crt_get_key_purpose_oid (cert, indx, buffer,
- &size, NULL);
- if (err == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
- return;
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_key_purpose_oid: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_key_purpose_oid (cert, indx, buffer,
- &size, NULL);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_key_purpose_oid2: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- if (strcmp (buffer, GNUTLS_KP_TLS_WWW_SERVER) == 0)
- addf (str, _("\t\t\tTLS WWW Server.\n"));
- else if (strcmp (buffer, GNUTLS_KP_TLS_WWW_CLIENT) == 0)
- addf (str, _("\t\t\tTLS WWW Client.\n"));
- else if (strcmp (buffer, GNUTLS_KP_CODE_SIGNING) == 0)
- addf (str, _("\t\t\tCode signing.\n"));
- else if (strcmp (buffer, GNUTLS_KP_EMAIL_PROTECTION) == 0)
- addf (str, _("\t\t\tEmail protection.\n"));
- else if (strcmp (buffer, GNUTLS_KP_TIME_STAMPING) == 0)
- addf (str, _("\t\t\tTime stamping.\n"));
- else if (strcmp (buffer, GNUTLS_KP_OCSP_SIGNING) == 0)
- addf (str, _("\t\t\tOCSP signing.\n"));
- else if (strcmp (buffer, GNUTLS_KP_ANY) == 0)
- addf (str, _("\t\t\tAny purpose.\n"));
- else
- addf (str, "\t\t\t%s\n", buffer);
-
- gnutls_free (buffer);
- }
-}
-
-static void
-print_basic (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- int pathlen;
- int err;
-
- err = gnutls_x509_crt_get_basic_constraints (cert, NULL, NULL, &pathlen);
- if (err < 0)
- {
- addf (str, "error: get_basic_constraints: %s\n", gnutls_strerror (err));
- return;
- }
-
- if (err == 0)
- addf (str, _("\t\t\tCertificate Authority (CA): FALSE\n"));
- else
- addf (str, _("\t\t\tCertificate Authority (CA): TRUE\n"));
-
- if (pathlen >= 0)
- addf (str, _("\t\t\tPath Length Constraint: %d\n"), pathlen);
-}
-
-static void
-print_san (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- unsigned int san_idx;
-
- for (san_idx = 0;; san_idx++)
- {
- char *buffer = NULL;
- size_t size = 0;
- int err;
-
- err =
- gnutls_x509_crt_get_subject_alt_name (cert, san_idx, buffer, &size,
- NULL);
- if (err == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
- break;
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_subject_alt_name: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_subject_alt_name (cert, san_idx,
- buffer, &size, NULL);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_subject_alt_name2: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- switch (err)
- {
- case GNUTLS_SAN_DNSNAME:
- addf (str, "\t\t\tDNSname: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_RFC822NAME:
- addf (str, "\t\t\tRFC822name: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_URI:
- addf (str, "\t\t\tURI: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_IPADDRESS:
- addf (str, "\t\t\tIPAddress: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_DN:
- addf (str, "\t\t\tdirectoryName: %.*s\n", size, buffer);
- break;
-
- case GNUTLS_SAN_OTHERNAME:
- {
- char *oid = NULL;
- size_t oidsize;
-
- oidsize = 0;
- err = gnutls_x509_crt_get_subject_alt_othername_oid
- (cert, san_idx, oid, &oidsize);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- gnutls_free (buffer);
- addf (str, "error: get_subject_alt_othername_oid: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- oid = gnutls_malloc (oidsize);
- if (!oid)
- {
- gnutls_free (buffer);
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_subject_alt_othername_oid
- (cert, san_idx, oid, &oidsize);
- if (err < 0)
- {
- gnutls_free (buffer);
- gnutls_free (oid);
- addf (str, "error: get_subject_alt_othername_oid2: %s\n",
- gnutls_strerror (err));
- return;
- }
-
- if (err == GNUTLS_SAN_OTHERNAME_XMPP)
- addf (str, _("\t\t\tXMPP Address: %.*s\n"), size, buffer);
- else
- {
- addf (str, _("\t\t\totherName OID: %.*s\n"), oidsize, oid);
- addf (str, _("\t\t\totherName DER: "));
- hexprint (str, buffer, size);
- addf (str, _("\n\t\t\totherName ASCII: "));
- asciiprint (str, buffer, size);
- addf (str, "\n");
- }
- gnutls_free (oid);
- }
- break;
-
- default:
- addf (str, "error: unknown SAN\n");
- break;
- }
-
- gnutls_free (buffer);
- }
-}
-
-static void
-print_cert (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
-{
- /* Version. */
- {
- int version = gnutls_x509_crt_get_version (cert);
- if (version < 0)
- addf (str, "error: get_version: %s\n", gnutls_strerror (version));
- else
- addf (str, _("\tVersion: %d\n"), version);
- }
-
- /* Serial. */
- {
- char serial[128];
- size_t serial_size = sizeof (serial);
- int err;
-
- err = gnutls_x509_crt_get_serial (cert, serial, &serial_size);
- if (err < 0)
- addf (str, "error: get_serial: %s\n", gnutls_strerror (err));
- else
- {
- addf (str, _("\tSerial Number (hex): "));
- hexprint (str, serial, serial_size);
- addf (str, "\n");
- }
- }
-
- /* Issuer. */
- if (!notsigned)
- {
- char dn[1024];
- size_t dn_size = sizeof (dn);
- int err;
-
- err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
- if (err < 0)
- addf (str, "error: get_issuer_dn: %s\n", gnutls_strerror (err));
- else
- addf (str, _("\tIssuer: %s\n"), dn);
- }
-
- /* Validity. */
- {
- time_t tim;
-
- addf (str, _("\tValidity:\n"));
-
- tim = gnutls_x509_crt_get_activation_time (cert);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "error: gmtime_r (%d)\n", t);
- else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
- addf (str, "error: strftime (%d)\n", t);
- else
- addf (str, _("\t\tNot Before: %s\n"), s);
- }
-
- tim = gnutls_x509_crt_get_expiration_time (cert);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "error: gmtime_r (%d)\n", t);
- else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
- addf (str, "error: strftime (%d)\n", t);
- else
- addf (str, _("\t\tNot After: %s\n"), s);
- }
- }
-
- /* Subject. */
- {
- char dn[1024];
- size_t dn_size = sizeof (dn);
- int err;
-
- err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
- if (err < 0)
- addf (str, "error: get_dn: %s\n", gnutls_strerror (err));
- else
- addf (str, _("\tSubject: %s\n"), dn);
- }
-
- /* SubjectPublicKeyInfo. */
- {
- int err;
- unsigned int bits;
-
- err = gnutls_x509_crt_get_pk_algorithm (cert, &bits);
- if (err < 0)
- addf (str, "error: get_pk_algorithm: %s\n", gnutls_strerror (err));
- else
- {
- const char *name = gnutls_pk_algorithm_get_name (err);
- if (name == NULL)
- name = "Unknown";
-
- addf (str, _("\tSubject Public Key Algorithm: %s\n"), name);
- switch (err)
- {
- case MHD_GNUTLS_PK_RSA:
- {
- gnutls_datum_t m, e;
-
- err = gnutls_x509_crt_get_pk_rsa_raw (cert, &m, &e);
- if (err < 0)
- addf (str, "error: get_pk_rsa_raw: %s\n",
- gnutls_strerror (err));
- else
- {
- addf (str, _("\t\tModulus (bits %d):\n"), bits);
- hexdump (str, m.data, m.size, "\t\t\t");
- addf (str, _("\t\tExponent:\n"));
- hexdump (str, e.data, e.size, "\t\t\t");
- }
-
- gnutls_free (m.data);
- gnutls_free (e.data);
- }
- break;
-
- case GNUTLS_PK_DSA:
- {
- gnutls_datum_t p, q, g, y;
-
- err = gnutls_x509_crt_get_pk_dsa_raw (cert, &p, &q, &g, &y);
- if (err < 0)
- addf (str, "error: get_pk_dsa_raw: %s\n",
- gnutls_strerror (err));
- else
- {
- addf (str, _("\t\tPublic key (bits %d):\n"), bits);
- hexdump (str, y.data, y.size, "\t\t\t");
- addf (str, _("\t\tP:\n"));
- hexdump (str, p.data, p.size, "\t\t\t");
- addf (str, _("\t\tQ:\n"));
- hexdump (str, q.data, q.size, "\t\t\t");
- addf (str, _("\t\tG:\n"));
- hexdump (str, g.data, g.size, "\t\t\t");
- }
- }
- break;
-
- default:
- break;
- }
- }
- }
-
- /* Extensions. */
- if (gnutls_x509_crt_get_version (cert) >= 3)
- {
- size_t i;
- int err = 0;
-
- for (i = 0;; i++)
- {
- char oid[128] = "";
- size_t sizeof_oid = sizeof (oid);
- int critical;
- size_t san_idx = 0;
- size_t proxy_idx = 0;
- size_t basic_idx = 0;
- size_t keyusage_idx = 0;
- size_t keypurpose_idx = 0;
- size_t ski_idx = 0;
- size_t aki_idx = 0;
- size_t crldist_idx = 0;
-
- err = gnutls_x509_crt_get_extension_info (cert, i,
- oid, &sizeof_oid,
- &critical);
- if (err < 0)
- {
- if (err == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
- break;
- addf (str, "error: get_extension_info: %s\n",
- gnutls_strerror (err));
- continue;
- }
-
- if (i == 0)
- addf (str, _("\tExtensions:\n"));
-
- if (strcmp (oid, "2.5.29.19") == 0)
- {
- if (basic_idx)
- {
- addf (str, "error: more than one basic constraint\n");
- continue;
- }
-
- addf (str, _("\t\tBasic Constraints (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_basic (str, cert);
-
- basic_idx++;
- }
- else if (strcmp (oid, "2.5.29.14") == 0)
- {
- if (ski_idx)
- {
- addf (str, "error: more than one SKI extension\n");
- continue;
- }
-
- addf (str, _("\t\tSubject Key Identifier (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_ski (str, cert);
-
- ski_idx++;
- }
- else if (strcmp (oid, "2.5.29.35") == 0)
- {
- if (aki_idx)
- {
- addf (str, "error: more than one AKI extension\n");
- continue;
- }
-
- addf (str, _("\t\tAuthority Key Identifier (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_aki (str, cert);
-
- aki_idx++;
- }
- else if (strcmp (oid, "2.5.29.15") == 0)
- {
- if (keyusage_idx)
- {
- addf (str, "error: more than one key usage extension\n");
- continue;
- }
-
- addf (str, _("\t\tKey Usage (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_key_usage (str, cert);
-
- keyusage_idx++;
- }
- else if (strcmp (oid, "2.5.29.37") == 0)
- {
- if (keypurpose_idx)
- {
- addf (str, "error: more than one key purpose extension\n");
- continue;
- }
-
- addf (str, _("\t\tKey Purpose (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_key_purpose (str, cert);
-
- keypurpose_idx++;
- }
- else if (strcmp (oid, "2.5.29.17") == 0)
- {
- if (san_idx)
- {
- addf (str, "error: more than one SKI extension\n");
- continue;
- }
-
- addf (str, _("\t\tSubject Alternative Name (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_san (str, cert);
-
- san_idx++;
- }
- else if (strcmp (oid, "2.5.29.31") == 0)
- {
- if (crldist_idx)
- {
- addf (str, "error: more than one CRL distribution point\n");
- continue;
- }
-
- addf (str, _("\t\tCRL Distribution points (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_crldist (str, cert);
-
- crldist_idx++;
- }
- else if (strcmp (oid, "1.3.6.1.5.5.7.1.14") == 0)
- {
- if (proxy_idx)
- {
- addf (str, "error: more than one proxy extension\n");
- continue;
- }
-
- addf (str, _("\t\tProxy Certificate Information (%s):\n"),
- critical ? _("critical") : _("not critical"));
-
- print_proxy (str, cert);
-
- proxy_idx++;
- }
- else
- {
- char *buffer;
- size_t extlen = 0;
-
- addf (str, _("\t\tUnknown extension %s (%s):\n"), oid,
- critical ? _("critical") : _("not critical"));
-
- err = gnutls_x509_crt_get_extension_data (cert, i,
- NULL, &extlen);
- if (err < 0)
- {
- addf (str, "error: get_extension_data: %s\n",
- gnutls_strerror (err));
- continue;
- }
-
- buffer = gnutls_malloc (extlen);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- continue;
- }
-
- err = gnutls_x509_crt_get_extension_data (cert, i,
- buffer, &extlen);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_extension_data2: %s\n",
- gnutls_strerror (err));
- continue;
- }
-
- addf (str, _("\t\t\tASCII: "));
- asciiprint (str, buffer, extlen);
- addf (str, "\n");
-
- addf (str, _("\t\t\tHexdump: "));
- hexprint (str, buffer, extlen);
- adds (str, "\n");
-
- gnutls_free (buffer);
- }
- }
- }
-
- /* Signature. */
- if (!notsigned)
- {
- int err;
- size_t size = 0;
- char *buffer = NULL;
-
- err = gnutls_x509_crt_get_signature_algorithm (cert);
- if (err < 0)
- addf (str, "error: get_signature_algorithm: %s\n",
- gnutls_strerror (err));
- else
- {
- const char *name = gnutls_sign_algorithm_get_name (err);
- if (name == NULL)
- name = "Unknown";
- addf (str, _("\tSignature Algorithm: %s\n"), name);
- }
- if (err == GNUTLS_SIGN_RSA_MD5 || err == GNUTLS_SIGN_RSA_MD2)
- {
- addf (str,
- _
- ("warning: signed using a broken signature algorithm that can be forged.\n"));
- }
-
- err = gnutls_x509_crt_get_signature (cert, buffer, &size);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_signature: %s\n", gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_signature (cert, buffer, &size);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_signature2: %s\n", gnutls_strerror (err));
- return;
- }
-
- addf (str, _("\tSignature:\n"));
- hexdump (str, buffer, size, "\t\t");
-
- gnutls_free (buffer);
- }
-}
-
-static void
-print_fingerprint (gnutls_string * str, gnutls_x509_crt_t cert,
- gnutls_digest_algorithm_t algo)
-{
- int err;
- char buffer[MAX_HASH_SIZE];
- size_t size = sizeof (buffer);
-
- err = gnutls_x509_crt_get_fingerprint (cert, algo, buffer, &size);
- if (err < 0)
- {
- addf (str, "error: get_fingerprint: %s\n", gnutls_strerror (err));
- return;
- }
-
- if (algo == MHD_GNUTLS_DIG_MD5)
- addf (str, _("\tMD5 fingerprint:\n\t\t"));
- else
- addf (str, _("\tSHA-1 fingerprint:\n\t\t"));
- hexprint (str, buffer, size);
- adds (str, "\n");
-}
-
-static void
-print_keyid (gnutls_string * str, gnutls_x509_crt_t cert)
-{
- int err;
- size_t size = 0;
- char *buffer = NULL;
-
- err = gnutls_x509_crt_get_key_id (cert, 0, buffer, &size);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_key_id: %s\n", gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crt_get_key_id (cert, 0, buffer, &size);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_key_id2: %s\n", gnutls_strerror (err));
- return;
- }
-
- addf (str, _("\tPublic Key Id:\n\t\t"));
- hexprint (str, buffer, size);
- adds (str, "\n");
-
- gnutls_free (buffer);
-}
-
-static void
-print_other (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
-{
- if (!notsigned)
- {
- print_fingerprint (str, cert, MHD_GNUTLS_DIG_MD5);
- print_fingerprint (str, cert, MHD_GNUTLS_DIG_SHA1);
- }
- print_keyid (str, cert);
-}
-
-static void
-print_oneline (gnutls_string * str, gnutls_x509_crt_t cert)
-{
-
- /* Subject. */
- {
- char dn[1024];
- size_t dn_size = sizeof (dn);
- int err;
-
- err = gnutls_x509_crt_get_dn (cert, dn, &dn_size);
- if (err < 0)
- addf (str, "unknown subject (%s), ", gnutls_strerror (err));
- else
- addf (str, "subject `%s', ", dn);
- }
-
- /* Issuer. */
- {
- char dn[1024];
- size_t dn_size = sizeof (dn);
- int err;
-
- err = gnutls_x509_crt_get_issuer_dn (cert, dn, &dn_size);
- if (err < 0)
- addf (str, "unknown issuer (%s), ", gnutls_strerror (err));
- else
- addf (str, "issuer `%s', ", dn);
- }
-
- {
- int bits;
- const char *name = gnutls_pk_algorithm_get_name
- (gnutls_x509_crt_get_pk_algorithm (cert, &bits));
- if (name == NULL)
- name = "Unknown";
- addf (str, "%s key %d bits, ", name, bits);
- }
-
- /* Validity. */
- {
- time_t tim;
-
- tim = gnutls_x509_crt_get_activation_time (cert);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "unknown activation (%d), ", t);
- else if (strftime (s, max, "%Y-%m-%d %H:%M:%S UTC", &t) == 0)
- addf (str, "failed activation (%d), ", t);
- else
- addf (str, "activated `%s', ", s);
- }
-
- tim = gnutls_x509_crt_get_expiration_time (cert);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "unknown expiry (%d), ", t);
- else if (strftime (s, max, "%Y-%m-%d %H:%M:%S UTC", &t) == 0)
- addf (str, "failed expiry (%d), ", t);
- else
- addf (str, "expires `%s', ", s);
- }
- }
-
- {
- int pathlen;
- char *policyLanguage;
- int err;
-
- err = gnutls_x509_crt_get_proxy (cert, NULL,
- &pathlen, &policyLanguage, NULL, NULL);
- if (err == 0)
- {
- addf (str, "proxy certificate (policy=");
- if (strcmp (policyLanguage, "1.3.6.1.5.5.7.21.1") == 0)
- addf (str, "id-ppl-inheritALL");
- else if (strcmp (policyLanguage, "1.3.6.1.5.5.7.21.2") == 0)
- addf (str, "id-ppl-independent");
- else
- addf (str, "%s", policyLanguage);
- if (pathlen >= 0)
- addf (str, ", pathlen=%d), ", pathlen);
- else
- addf (str, "), ");
- gnutls_free (policyLanguage);
- }
- }
-
- {
- char buffer[20];
- size_t size = sizeof (buffer);
- int err;
-
- err = gnutls_x509_crt_get_fingerprint (cert, MHD_GNUTLS_DIG_SHA1,
- buffer, &size);
- if (err < 0)
- {
- addf (str, "unknown fingerprint (%s)", gnutls_strerror (err));
- }
- else
- {
- addf (str, "SHA-1 fingerprint `");
- hexprint (str, buffer, size);
- adds (str, "'");
- }
- }
-
-}
-
-/**
- * gnutls_x509_crt_print - Pretty print X.509 certificates
- * @cert: The structure to be printed
- * @format: Indicate the format to use
- * @out: Newly allocated datum with zero terminated string.
- *
- * This function will pretty print a X.509 certificate, suitable for
- * display to a human.
- *
- * If the format is %GNUTLS_X509_CRT_FULL then all fields of the
- * certificate will be output, on multiple lines. The
- * %GNUTLS_X509_CRT_ONELINE format will generate one line with some
- * selected fields, which is useful for logging purposes.
- *
- * The output @out needs to be deallocate using gnutls_free().
- *
- * Returns 0 on success.
- **/
-int
-gnutls_x509_crt_print (gnutls_x509_crt_t cert,
- gnutls_certificate_print_formats_t format,
- gnutls_datum_t * out)
-{
- gnutls_string str;
-
- if (format == GNUTLS_X509_CRT_FULL
- || format == GNUTLS_X509_CRT_UNSIGNED_FULL)
- {
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
-
- _gnutls_string_append_str (&str, _("X.509 Certificate Information:\n"));
-
- print_cert (&str, cert, format == GNUTLS_X509_CRT_UNSIGNED_FULL);
-
- _gnutls_string_append_str (&str, _("Other Information:\n"));
-
- print_other (&str, cert, format == GNUTLS_X509_CRT_UNSIGNED_FULL);
-
- _gnutls_string_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
- }
- else if (format == GNUTLS_X509_CRT_ONELINE)
- {
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
-
- print_oneline (&str, cert);
-
- _gnutls_string_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
- }
- else
- {
- gnutls_assert ();
- return GNUTLS_E_INVALID_REQUEST;
- }
-
- return 0;
-}
-
-static void
-print_crl (gnutls_string * str, gnutls_x509_crl_t crl, int notsigned)
-{
- /* Version. */
- {
- int version = gnutls_x509_crl_get_version (crl);
- if (version == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
- addf (str, _("\tVersion: 1 (default)\n"));
- else if (version < 0)
- addf (str, "error: get_version: %s\n", gnutls_strerror (version));
- else
- addf (str, _("\tVersion: %d\n"), version);
- }
-
- /* Issuer. */
- if (!notsigned)
- {
- char dn[1024];
- size_t dn_size = sizeof (dn);
- int err;
-
- err = gnutls_x509_crl_get_issuer_dn (crl, dn, &dn_size);
- if (err < 0)
- addf (str, "error: get_issuer_dn: %s\n", gnutls_strerror (err));
- else
- addf (str, _("\tIssuer: %s\n"), dn);
- }
-
- /* Validity. */
- {
- time_t tim;
-
- addf (str, _("\tUpdate dates:\n"));
-
- tim = gnutls_x509_crl_get_this_update (crl);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "error: gmtime_r (%d)\n", t);
- else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
- addf (str, "error: strftime (%d)\n", t);
- else
- addf (str, _("\t\tIssued: %s\n"), s);
- }
-
- tim = gnutls_x509_crl_get_next_update (crl);
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- if (tim == -1)
- addf (str, "\t\tNo next update time.\n");
- else if (gmtime_r (&tim, &t) == NULL)
- addf (str, "error: gmtime_r (%d)\n", t);
- else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
- addf (str, "error: strftime (%d)\n", t);
- else
- addf (str, _("\t\tNext at: %s\n"), s);
- }
- }
-
- /* Revoked certificates. */
- {
- int num = gnutls_x509_crl_get_crt_count (crl);
- int j;
-
- if (num)
- addf (str, _("\tRevoked certificates (%d):\n"), num);
- else
- addf (str, _("\tNo revoked certificates.\n"));
-
- for (j = 0; j < num; j++)
- {
- char serial[128];
- size_t serial_size = sizeof (serial);
- int err;
- time_t tim;
-
- err = gnutls_x509_crl_get_crt_serial (crl, j, serial,
- &serial_size, &tim);
- if (err < 0)
- addf (str, "error: get_crt_serial: %s\n", gnutls_strerror (err));
- else
- {
- char s[42];
- size_t max = sizeof (s);
- struct tm t;
-
- addf (str, _("\t\tSerial Number (hex): "));
- hexprint (str, serial, serial_size);
- adds (str, "\n");
-
- if (gmtime_r (&tim, &t) == NULL)
- addf (str, "error: gmtime_r (%d)\n", t);
- else if (strftime (s, max, "%a %b %e %H:%M:%S UTC %Y", &t) == 0)
- addf (str, "error: strftime (%d)\n", t);
- else
- addf (str, _("\t\tRevoked at: %s\n"), s);
- }
- }
- }
-
- /* Signature. */
- if (!notsigned)
- {
- int err;
- size_t size = 0;
- char *buffer = NULL;
-
- err = gnutls_x509_crl_get_signature_algorithm (crl);
- if (err < 0)
- addf (str, "error: get_signature_algorithm: %s\n",
- gnutls_strerror (err));
- else
- {
- const char *name = gnutls_sign_algorithm_get_name (err);
- if (name == NULL)
- name = "Unknown";
- addf (str, _("\tSignature Algorithm: %s\n"), name);
- }
- if (err == GNUTLS_SIGN_RSA_MD5 || err == GNUTLS_SIGN_RSA_MD2)
- {
- addf (str,
- _
- ("warning: signed using a broken signature algorithm that can be forged.\n"));
- }
-
- err = gnutls_x509_crl_get_signature (crl, buffer, &size);
- if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
- {
- addf (str, "error: get_signature: %s\n", gnutls_strerror (err));
- return;
- }
-
- buffer = gnutls_malloc (size);
- if (!buffer)
- {
- addf (str, "error: malloc: %s\n", gnutls_strerror (err));
- return;
- }
-
- err = gnutls_x509_crl_get_signature (crl, buffer, &size);
- if (err < 0)
- {
- gnutls_free (buffer);
- addf (str, "error: get_signature2: %s\n", gnutls_strerror (err));
- return;
- }
-
- addf (str, _("\tSignature:\n"));
- hexdump (str, buffer, size, "\t\t");
-
- gnutls_free (buffer);
- }
-}
-
-/**
- * gnutls_x509_crl_print - Pretty print X.509 certificate revocation list
- * @crl: The structure to be printed
- * @format: Indicate the format to use
- * @out: Newly allocated datum with zero terminated string.
- *
- * This function will pretty print a X.509 certificate revocation
- * list, suitable for display to a human.
- *
- * The output @out needs to be deallocate using gnutls_free().
- *
- * Returns 0 on success.
- **/
-int
-gnutls_x509_crl_print (gnutls_x509_crl_t crl,
- gnutls_certificate_print_formats_t format,
- gnutls_datum_t * out)
-{
- gnutls_string str;
-
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
-
- _gnutls_string_append_str
- (&str, _("X.509 Certificate Revocation List Information:\n"));
-
- print_crl (&str, crl, format == GNUTLS_X509_CRT_UNSIGNED_FULL);
-
- _gnutls_string_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
-
- return 0;
-}
diff --git a/src/daemon/https/x509/pkcs12.c b/src/daemon/https/x509/pkcs12.c
@@ -161,7 +161,7 @@ gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12)
* gnutls_pkcs12_deinit - This function deinitializes memory used by a gnutls_pkcs12_t structure
* @pkcs12: The structure to be initialized
*
- * This function will deinitialize a PKCS12 structure.
+ * This function will deinitialize a PKCS12 structure.
*
**/
void
@@ -338,7 +338,7 @@ ucs2_to_ascii (char *data, int size)
}
/* Decodes the SafeContents, and puts the output in
- * the given bag.
+ * the given bag.
*/
int
_pkcs12_decode_safe_contents (const gnutls_datum_t * content,
@@ -760,7 +760,7 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
return result;
}
- /* Step 3. Encode the bag elements into a SafeContents
+ /* Step 3. Encode the bag elements into a SafeContents
* structure.
*/
result = _pkcs12_encode_safe_contents (bag, &safe_cont, &enc);
@@ -924,7 +924,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
/* MAC the data
*/
- td1 = _gnutls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
+ td1 = mhd_gtls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
if (td1 == GNUTLS_MAC_FAILED)
{
gnutls_assert ();
@@ -932,10 +932,10 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
goto cleanup;
}
- _gnutls_hmac (td1, tmp.data, tmp.size);
+ mhd_gnutls_hash (td1, tmp.data, tmp.size);
_gnutls_free_datum (&tmp);
- _gnutls_hmac_deinit (td1, sha_mac);
+ mhd_gnutls_hmac_deinit (td1, sha_mac);
result =
@@ -1050,7 +1050,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
/* MAC the data
*/
- td1 = _gnutls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
+ td1 = mhd_gtls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
if (td1 == GNUTLS_MAC_FAILED)
{
gnutls_assert ();
@@ -1058,10 +1058,10 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
goto cleanup;
}
- _gnutls_hmac (td1, tmp.data, tmp.size);
+ mhd_gnutls_hash (td1, tmp.data, tmp.size);
_gnutls_free_datum (&tmp);
- _gnutls_hmac_deinit (td1, sha_mac);
+ mhd_gnutls_hmac_deinit (td1, sha_mac);
len = sizeof (sha_mac_orig);
result =
@@ -1126,8 +1126,8 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
return _gnutls_asn2err (result);
}
- _gnutls_str_cpy (root, sizeof (root), where);
- _gnutls_str_cat (root, sizeof (root), ".?LAST");
+ mhd_gtls_str_cpy (root, sizeof (root), where);
+ mhd_gtls_str_cat (root, sizeof (root), ".?LAST");
result =
_gnutls_x509_encode_and_write_attribute (KEY_ID_OID, c2, root,
@@ -1176,8 +1176,8 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
p++;
}
- _gnutls_str_cpy (root, sizeof (root), where);
- _gnutls_str_cat (root, sizeof (root), ".?LAST");
+ mhd_gtls_str_cpy (root, sizeof (root), where);
+ mhd_gtls_str_cat (root, sizeof (root), ".?LAST");
result =
_gnutls_x509_encode_and_write_attribute (FRIENDLY_NAME_OID, c2,
diff --git a/src/daemon/https/x509/pkcs12_encr.c b/src/daemon/https/x509/pkcs12_encr.c
@@ -134,7 +134,7 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
for (i = 0; i < 64; i++)
buf_b[i] = hash[i % 20];
n = 64;
- rc = _gnutls_mpi_scan (&num_b1, buf_b, &n);
+ rc = mhd_gtls_mpi_scan (&num_b1, buf_b, &n);
if (rc < 0)
{
gnutls_assert ();
@@ -146,7 +146,7 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
mpi_t num_ij;
n = 64;
- rc = _gnutls_mpi_scan (&num_ij, buf_i + i, &n);
+ rc = mhd_gtls_mpi_scan (&num_ij, buf_i + i, &n);
if (rc < 0)
{
gnutls_assert ();
@@ -155,7 +155,7 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
gcry_mpi_add (num_ij, num_ij, num_b1);
gcry_mpi_clear_highbit (num_ij, 64 * 8);
n = 64;
- rc = _gnutls_mpi_print (buf_i + i, &n, num_ij);
+ rc = mhd_gtls_mpi_print (buf_i + i, &n, num_ij);
if (rc < 0)
{
gnutls_assert ();
diff --git a/src/daemon/https/x509/privkey_pkcs8.c b/src/daemon/https/x509/privkey_pkcs8.c
@@ -1424,7 +1424,7 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
if (kdf_params->key_size == 0)
{
- key_size = gnutls_cipher_get_key_size (enc_params->cipher);
+ key_size = MHD_gnutls_cipher_get_key_size (enc_params->cipher);
}
else
key_size = kdf_params->key_size;
@@ -1474,7 +1474,7 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
d_iv.data = (opaque *) enc_params->iv;
d_iv.size = enc_params->iv_size;
- ch = _gnutls_cipher_init (enc_params->cipher, &dkey, &d_iv);
+ ch = mhd_gtls_cipher_init (enc_params->cipher, &dkey, &d_iv);
gnutls_afree (key);
key = NULL;
@@ -1486,7 +1486,7 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
goto error;
}
- result = _gnutls_cipher_decrypt (ch, data, data_size);
+ result = mhd_gtls_cipher_decrypt (ch, data, data_size);
if (result < 0)
{
gnutls_assert ();
@@ -1495,12 +1495,12 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
decrypted_data->data = data;
- if (_gnutls_cipher_get_block_size (enc_params->cipher) != 1)
+ if (mhd_gtls_cipher_get_block_size (enc_params->cipher) != 1)
decrypted_data->size = data_size - data[data_size - 1];
else
decrypted_data->size = data_size;
- _gnutls_cipher_deinit (ch);
+ mhd_gnutls_cipher_deinit (ch);
return 0;
@@ -1508,7 +1508,7 @@ error:
gnutls_free (data);
gnutls_afree (key);
if (ch != NULL)
- _gnutls_cipher_deinit (ch);
+ mhd_gnutls_cipher_deinit (ch);
return result;
}
@@ -1568,7 +1568,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
/* write the iteration count
*/
- _gnutls_write_uint32 (kdf_params->iter_count, tmp);
+ mhd_gtls_write_uint32 (kdf_params->iter_count, tmp);
result = asn1_write_value (pbkdf2_asn, "iterationCount", tmp, 4);
if (result != ASN1_SUCCESS)
@@ -1727,9 +1727,9 @@ generate_key (schema_id schema,
kdf_params->iter_count = 256 + rnd[0];
key->size = kdf_params->key_size =
- gnutls_cipher_get_key_size (enc_params->cipher);
+ MHD_gnutls_cipher_get_key_size (enc_params->cipher);
- enc_params->iv_size = _gnutls_cipher_get_iv_size (enc_params->cipher);
+ enc_params->iv_size = mhd_gtls_cipher_get_iv_size (enc_params->cipher);
key->data = gnutls_secure_malloc (key->size);
if (key->data == NULL)
@@ -1893,7 +1893,7 @@ encrypt_data (const gnutls_datum_t * plain,
cipher_hd_t ch = NULL;
opaque pad, pad_size;
- pad_size = _gnutls_cipher_get_block_size (enc_params->cipher);
+ pad_size = mhd_gtls_cipher_get_block_size (enc_params->cipher);
if (pad_size == 1) /* stream */
pad_size = 0;
@@ -1921,7 +1921,7 @@ encrypt_data (const gnutls_datum_t * plain,
d_iv.data = (opaque *) enc_params->iv;
d_iv.size = enc_params->iv_size;
- ch = _gnutls_cipher_init (enc_params->cipher, key, &d_iv);
+ ch = mhd_gtls_cipher_init (enc_params->cipher, key, &d_iv);
if (ch == GNUTLS_CIPHER_FAILED)
{
@@ -1930,7 +1930,7 @@ encrypt_data (const gnutls_datum_t * plain,
goto error;
}
- result = _gnutls_cipher_encrypt (ch, data, data_size);
+ result = mhd_gtls_cipher_encrypt (ch, data, data_size);
if (result < 0)
{
gnutls_assert ();
@@ -1940,14 +1940,14 @@ encrypt_data (const gnutls_datum_t * plain,
encrypted->data = data;
encrypted->size = data_size;
- _gnutls_cipher_deinit (ch);
+ mhd_gnutls_cipher_deinit (ch);
return 0;
error:
gnutls_free (data);
if (ch != NULL)
- _gnutls_cipher_deinit (ch);
+ mhd_gnutls_cipher_deinit (ch);
return result;
}
diff --git a/src/daemon/https/x509/sign.c b/src/daemon/https/x509/sign.c
@@ -56,7 +56,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
int result;
const char *algo;
- algo = _gnutls_x509_mac_to_oid ((gnutls_mac_algorithm_t) hash);
+ algo = mhd_gtls_x509_mac_to_oid ((gnutls_mac_algorithm_t) hash);
if (algo == NULL)
{
gnutls_assert ();
@@ -140,18 +140,18 @@ pkcs1_rsa_sign (gnutls_digest_algorithm_t hash, const gnutls_datum_t * text,
GNUTLS_HASH_HANDLE hd;
gnutls_datum_t digest, info;
- hd = _gnutls_hash_init (HASH2MAC (hash));
+ hd = mhd_gtls_hash_init (HASH2MAC (hash));
if (hd == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (hd, text->data, text->size);
- _gnutls_hash_deinit (hd, _digest);
+ mhd_gnutls_hash (hd, text->data, text->size);
+ mhd_gnutls_hash_deinit (hd, _digest);
digest.data = _digest;
- digest.size = _gnutls_hash_get_algo_len (HASH2MAC (hash));
+ digest.size = mhd_gnutls_hash_get_algo_len (HASH2MAC (hash));
/* Encode the digest as a DigestInfo
*/
@@ -162,7 +162,7 @@ pkcs1_rsa_sign (gnutls_digest_algorithm_t hash, const gnutls_datum_t * text,
}
if ((ret =
- _gnutls_sign (MHD_GNUTLS_PK_RSA, params, params_len, &info,
+ mhd_gtls_sign (MHD_GNUTLS_PK_RSA, params, params_len, &info,
signature)) < 0)
{
gnutls_assert ();
@@ -278,8 +278,8 @@ _gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
/* Step 1. Copy the issuer's name into the certificate.
*/
- _gnutls_str_cpy (name, sizeof (name), src_name);
- _gnutls_str_cat (name, sizeof (name), ".issuer");
+ mhd_gtls_str_cpy (name, sizeof (name), src_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".issuer");
result = asn1_copy_node (src, name, issuer->cert, "tbsCertificate.subject");
if (result != ASN1_SUCCESS)
@@ -290,8 +290,8 @@ _gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
/* Step 1.5. Write the signature stuff in the tbsCertificate.
*/
- _gnutls_str_cpy (name, sizeof (name), src_name);
- _gnutls_str_cat (name, sizeof (name), ".signature");
+ mhd_gtls_str_cpy (name, sizeof (name), src_name);
+ mhd_gtls_str_cat (name, sizeof (name), ".signature");
result = _gnutls_x509_write_sig_params (src, name,
issuer_key->pk_algorithm, dig,
diff --git a/src/daemon/https/x509/x509.c b/src/daemon/https/x509/x509.c
@@ -487,7 +487,7 @@ gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert)
return result;
}
- result = _gnutls_x509_oid2sign_algorithm (sa.data);
+ result = mhd_gtls_x509_oid2sign_algorithm (sa.data);
_gnutls_free_datum (&sa);
@@ -950,9 +950,9 @@ parse_general_name (ASN1_TYPE src,
if (type == GNUTLS_SAN_OTHERNAME)
{
if (othername_oid)
- _gnutls_str_cat (nptr, sizeof (nptr), ".otherName.type-id");
+ mhd_gtls_str_cat (nptr, sizeof (nptr), ".otherName.type-id");
else
- _gnutls_str_cat (nptr, sizeof (nptr), ".otherName.value");
+ mhd_gtls_str_cat (nptr, sizeof (nptr), ".otherName.value");
len = *name_size;
result = asn1_read_value (src, nptr, name, &len);
@@ -1025,7 +1025,7 @@ parse_general_name (ASN1_TYPE src,
}
else if (type == GNUTLS_SAN_DN)
{
- _gnutls_str_cat (nptr, sizeof (nptr), ".directoryName");
+ mhd_gtls_str_cat (nptr, sizeof (nptr), ".directoryName");
result = _gnutls_x509_parse_dn (src, nptr, name, name_size);
if (result < 0)
{
@@ -1039,8 +1039,8 @@ parse_general_name (ASN1_TYPE src,
{
size_t orig_name_size = *name_size;
- _gnutls_str_cat (nptr, sizeof (nptr), ".");
- _gnutls_str_cat (nptr, sizeof (nptr), choice_type);
+ mhd_gtls_str_cat (nptr, sizeof (nptr), ".");
+ mhd_gtls_str_cat (nptr, sizeof (nptr), choice_type);
len = *name_size;
result = asn1_read_value (src, nptr, name, &len);
@@ -1980,7 +1980,7 @@ gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
tmp.data = cert_buf;
tmp.size = cert_buf_size;
- result = gnutls_fingerprint (algo, &tmp, buf, sizeof_buf);
+ result = MHD_gnutls_fingerprint (algo, &tmp, buf, sizeof_buf);
gnutls_afree (cert_buf);
return result;
@@ -2053,7 +2053,7 @@ rsadsa_get_key_id (gnutls_x509_crt_t crt,
else
return GNUTLS_E_INTERNAL_ERROR;
- hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (hd == GNUTLS_HASH_FAILED)
{
gnutls_assert ();
@@ -2061,9 +2061,9 @@ rsadsa_get_key_id (gnutls_x509_crt_t crt,
goto cleanup;
}
- _gnutls_hash (hd, der.data, der.size);
+ mhd_gnutls_hash (hd, der.data, der.size);
- _gnutls_hash_deinit (hd, output_data);
+ mhd_gnutls_hash_deinit (hd, output_data);
*output_data_size = 20;
result = 0;
@@ -2076,7 +2076,7 @@ cleanup:
*/
for (i = 0; i < params_size; i++)
{
- _gnutls_mpi_release (¶ms[i]);
+ mhd_gtls_mpi_release (¶ms[i]);
}
return result;
}
@@ -2165,7 +2165,7 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
return _gnutls_asn2err (result);
}
- result = gnutls_fingerprint (MHD_GNUTLS_DIG_SHA1, &pubkey, output_data,
+ result = MHD_gnutls_fingerprint (MHD_GNUTLS_DIG_SHA1, &pubkey, output_data,
output_data_size);
gnutls_afree (pubkey.data);
@@ -2420,7 +2420,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
/* Return the different names from the first CRLDistr. point.
* The whole thing is a mess.
*/
- _gnutls_str_cpy (name, sizeof (name), "?1.distributionPoint.fullName");
+ mhd_gtls_str_cpy (name, sizeof (name), "?1.distributionPoint.fullName");
result = parse_general_name (c2, name, seq, ret, ret_size, NULL, 0);
if (result < 0)
@@ -2435,7 +2435,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
*/
if (reason_flags)
{
- _gnutls_str_cpy (name, sizeof (name), "?1.reasons");
+ mhd_gtls_str_cpy (name, sizeof (name), "?1.reasons");
reasons[0] = reasons[1] = 0;
@@ -2594,14 +2594,14 @@ gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
return ret;
}
- ret = _gnutls_mpi_dprint (m, params[0]);
+ ret = mhd_gtls_mpi_dprint (m, params[0]);
if (ret < 0)
{
gnutls_assert ();
goto cleanup;
}
- ret = _gnutls_mpi_dprint (e, params[1]);
+ ret = mhd_gtls_mpi_dprint (e, params[1]);
if (ret < 0)
{
gnutls_assert ();
@@ -2613,7 +2613,7 @@ gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
cleanup:for (i = 0; i < params_size; i++)
{
- _gnutls_mpi_release (¶ms[i]);
+ mhd_gtls_mpi_release (¶ms[i]);
}
return ret;
}
@@ -2659,7 +2659,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
}
/* P */
- ret = _gnutls_mpi_dprint (p, params[0]);
+ ret = mhd_gtls_mpi_dprint (p, params[0]);
if (ret < 0)
{
gnutls_assert ();
@@ -2667,7 +2667,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
}
/* Q */
- ret = _gnutls_mpi_dprint (q, params[1]);
+ ret = mhd_gtls_mpi_dprint (q, params[1]);
if (ret < 0)
{
gnutls_assert ();
@@ -2676,7 +2676,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
}
/* G */
- ret = _gnutls_mpi_dprint (g, params[2]);
+ ret = mhd_gtls_mpi_dprint (g, params[2]);
if (ret < 0)
{
gnutls_assert ();
@@ -2686,7 +2686,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
}
/* Y */
- ret = _gnutls_mpi_dprint (y, params[3]);
+ ret = mhd_gtls_mpi_dprint (y, params[3]);
if (ret < 0)
{
gnutls_assert ();
@@ -2700,7 +2700,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
cleanup:for (i = 0; i < params_size; i++)
{
- _gnutls_mpi_release (¶ms[i]);
+ mhd_gtls_mpi_release (¶ms[i]);
}
return ret;
diff --git a/src/daemon/https/x509/x509.h b/src/daemon/https/x509/x509.h
@@ -778,7 +778,7 @@ typedef struct gnutls_x509_crt_int
# error INCREASE MAX_PRIV_PARAMS
#endif
-typedef struct gnutls_x509_privkey_int
+typedef struct MHD_gtls_x509_privkey_int
{
mpi_t params[MAX_PRIV_PARAMS_SIZE]; /* the size of params depends on the public
* key algorithm
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
@@ -88,7 +88,7 @@ gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key)
for (i = 0; i < key->params_size; i++)
{
- _gnutls_mpi_release (&key->params[i]);
+ mhd_gtls_mpi_release (&key->params[i]);
}
asn1_delete_structure (&key->key);
@@ -238,12 +238,12 @@ _gnutls_privkey_decode_pkcs1_rsa_key (const gnutls_datum_t * raw_key,
return pkey_asn;
error:asn1_delete_structure (&pkey_asn);
- _gnutls_mpi_release (&pkey->params[0]);
- _gnutls_mpi_release (&pkey->params[1]);
- _gnutls_mpi_release (&pkey->params[2]);
- _gnutls_mpi_release (&pkey->params[3]);
- _gnutls_mpi_release (&pkey->params[4]);
- _gnutls_mpi_release (&pkey->params[5]);
+ mhd_gtls_mpi_release (&pkey->params[0]);
+ mhd_gtls_mpi_release (&pkey->params[1]);
+ mhd_gtls_mpi_release (&pkey->params[2]);
+ mhd_gtls_mpi_release (&pkey->params[3]);
+ mhd_gtls_mpi_release (&pkey->params[4]);
+ mhd_gtls_mpi_release (&pkey->params[5]);
return NULL;
}
@@ -311,11 +311,11 @@ decode_dsa_key (const gnutls_datum_t * raw_key, gnutls_x509_privkey_t pkey)
return dsa_asn;
error:asn1_delete_structure (&dsa_asn);
- _gnutls_mpi_release (&pkey->params[0]);
- _gnutls_mpi_release (&pkey->params[1]);
- _gnutls_mpi_release (&pkey->params[2]);
- _gnutls_mpi_release (&pkey->params[3]);
- _gnutls_mpi_release (&pkey->params[4]);
+ mhd_gtls_mpi_release (&pkey->params[0]);
+ mhd_gtls_mpi_release (&pkey->params[1]);
+ mhd_gtls_mpi_release (&pkey->params[2]);
+ mhd_gtls_mpi_release (&pkey->params[3]);
+ mhd_gtls_mpi_release (&pkey->params[4]);
return NULL;
}
@@ -430,9 +430,9 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
}
#define FREE_RSA_PRIVATE_PARAMS for (i=0;i<RSA_PRIVATE_PARAMS;i++) \
- _gnutls_mpi_release(&key->params[i])
+ mhd_gtls_mpi_release(&key->params[i])
#define FREE_DSA_PRIVATE_PARAMS for (i=0;i<DSA_PRIVATE_PARAMS;i++) \
- _gnutls_mpi_release(&key->params[i])
+ mhd_gtls_mpi_release(&key->params[i])
/**
* gnutls_x509_privkey_import_rsa_raw - This function will import a raw RSA key
@@ -467,7 +467,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
}
siz = m->size;
- if (_gnutls_mpi_scan_nz (&key->params[0], m->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[0], m->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -475,7 +475,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
}
siz = e->size;
- if (_gnutls_mpi_scan_nz (&key->params[1], e->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[1], e->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -483,7 +483,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
}
siz = d->size;
- if (_gnutls_mpi_scan_nz (&key->params[2], d->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[2], d->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -491,7 +491,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
}
siz = p->size;
- if (_gnutls_mpi_scan_nz (&key->params[3], p->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[3], p->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -499,7 +499,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
}
siz = q->size;
- if (_gnutls_mpi_scan_nz (&key->params[4], q->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[4], q->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -519,7 +519,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
_gnutls_mpi_invm (key->params[5], key->params[3], key->params[4]);
#else
siz = u->size;
- if (_gnutls_mpi_scan_nz (&key->params[5], u->data, &siz))
+ if (mhd_gtls_mpi_scan_nz (&key->params[5], u->data, &siz))
{
gnutls_assert ();
FREE_RSA_PRIVATE_PARAMS;
@@ -668,7 +668,7 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
m->data = e->data = d->data = p->data = q->data = u->data = NULL;
m->size = e->size = d->size = p->size = q->size = u->size = 0;
- ret = _gnutls_mpi_dprint (m, key->params[0]);
+ ret = mhd_gtls_mpi_dprint (m, key->params[0]);
if (ret < 0)
{
gnutls_assert ();
@@ -676,7 +676,7 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
}
/* E */
- ret = _gnutls_mpi_dprint (e, key->params[1]);
+ ret = mhd_gtls_mpi_dprint (e, key->params[1]);
if (ret < 0)
{
gnutls_assert ();
@@ -684,7 +684,7 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
}
/* D */
- ret = _gnutls_mpi_dprint (d, key->params[2]);
+ ret = mhd_gtls_mpi_dprint (d, key->params[2]);
if (ret < 0)
{
gnutls_assert ();
@@ -692,7 +692,7 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
}
/* P */
- ret = _gnutls_mpi_dprint (p, key->params[3]);
+ ret = mhd_gtls_mpi_dprint (p, key->params[3]);
if (ret < 0)
{
gnutls_assert ();
@@ -700,7 +700,7 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
}
/* Q */
- ret = _gnutls_mpi_dprint (q, key->params[4]);
+ ret = mhd_gtls_mpi_dprint (q, key->params[4]);
if (ret < 0)
{
gnutls_assert ();
@@ -718,17 +718,17 @@ gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
}
_gnutls_mpi_invm (coeff, key->params[4], key->params[3]);
- ret = _gnutls_mpi_dprint (u, coeff);
+ ret = mhd_gtls_mpi_dprint (u, coeff);
if (ret < 0)
{
gnutls_assert ();
goto error;
}
- _gnutls_mpi_release (&coeff);
+ mhd_gtls_mpi_release (&coeff);
#else
/* U */
- ret = _gnutls_mpi_dprint (u, key->params[5]);
+ ret = mhd_gtls_mpi_dprint (u, key->params[5]);
if (ret < 0)
{
gnutls_assert ();
@@ -743,7 +743,7 @@ error:_gnutls_free_datum (m);
_gnutls_free_datum (e);
_gnutls_free_datum (p);
_gnutls_free_datum (q);
- _gnutls_mpi_release (&coeff);
+ mhd_gtls_mpi_release (&coeff);
return ret;
}
@@ -778,7 +778,7 @@ gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
}
/* P */
- ret = _gnutls_mpi_dprint (p, key->params[0]);
+ ret = mhd_gtls_mpi_dprint (p, key->params[0]);
if (ret < 0)
{
gnutls_assert ();
@@ -786,7 +786,7 @@ gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
}
/* Q */
- ret = _gnutls_mpi_dprint (q, key->params[1]);
+ ret = mhd_gtls_mpi_dprint (q, key->params[1]);
if (ret < 0)
{
gnutls_assert ();
@@ -795,7 +795,7 @@ gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
}
/* G */
- ret = _gnutls_mpi_dprint (g, key->params[2]);
+ ret = mhd_gtls_mpi_dprint (g, key->params[2]);
if (ret < 0)
{
gnutls_assert ();
@@ -805,7 +805,7 @@ gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
}
/* Y */
- ret = _gnutls_mpi_dprint (y, key->params[3]);
+ ret = mhd_gtls_mpi_dprint (y, key->params[3]);
if (ret < 0)
{
gnutls_assert ();
@@ -816,7 +816,7 @@ gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
}
/* X */
- ret = _gnutls_mpi_dprint (x, key->params[4]);
+ ret = mhd_gtls_mpi_dprint (x, key->params[4]);
if (ret < 0)
{
gnutls_assert ();
@@ -847,7 +847,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
total = 0;
for (i = 0; i < 5; i++)
{
- _gnutls_mpi_print_lz (NULL, &size[i], params[i]);
+ mhd_gtls_mpi_print_lz (NULL, &size[i], params[i]);
total += size[i];
}
@@ -895,7 +895,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
_gnutls_mpi_invm (u, params[4], params[3]);
/* inverse of q mod p */
- _gnutls_mpi_print_lz (NULL, &size[5], u);
+ mhd_gtls_mpi_print_lz (NULL, &size[5], u);
total += size[5];
_gnutls_mpi_sub_ui (p1, params[3], 1);
@@ -905,10 +905,10 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
_gnutls_mpi_mod (exp2, params[2], q1);
/* calculate exp's size */
- _gnutls_mpi_print_lz (NULL, &size[6], exp1);
+ mhd_gtls_mpi_print_lz (NULL, &size[6], exp1);
total += size[6];
- _gnutls_mpi_print_lz (NULL, &size[7], exp2);
+ mhd_gtls_mpi_print_lz (NULL, &size[7], exp2);
total += size[7];
/* Encoding phase.
@@ -939,14 +939,14 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
p += size[6];
exp2_data = p;
- _gnutls_mpi_print_lz (m_data, &size[0], params[0]);
- _gnutls_mpi_print_lz (pube_data, &size[1], params[1]);
- _gnutls_mpi_print_lz (prie_data, &size[2], params[2]);
- _gnutls_mpi_print_lz (p1_data, &size[3], params[3]);
- _gnutls_mpi_print_lz (p2_data, &size[4], params[4]);
- _gnutls_mpi_print_lz (u_data, &size[5], u);
- _gnutls_mpi_print_lz (exp1_data, &size[6], exp1);
- _gnutls_mpi_print_lz (exp2_data, &size[7], exp2);
+ mhd_gtls_mpi_print_lz (m_data, &size[0], params[0]);
+ mhd_gtls_mpi_print_lz (pube_data, &size[1], params[1]);
+ mhd_gtls_mpi_print_lz (prie_data, &size[2], params[2]);
+ mhd_gtls_mpi_print_lz (p1_data, &size[3], params[3]);
+ mhd_gtls_mpi_print_lz (p2_data, &size[4], params[4]);
+ mhd_gtls_mpi_print_lz (u_data, &size[5], u);
+ mhd_gtls_mpi_print_lz (exp1_data, &size[6], exp1);
+ mhd_gtls_mpi_print_lz (exp2_data, &size[7], exp2);
/* Ok. Now we have the data. Create the asn1 structures
*/
@@ -1026,11 +1026,11 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
goto cleanup;
}
- _gnutls_mpi_release (&exp1);
- _gnutls_mpi_release (&exp2);
- _gnutls_mpi_release (&q1);
- _gnutls_mpi_release (&p1);
- _gnutls_mpi_release (&u);
+ mhd_gtls_mpi_release (&exp1);
+ mhd_gtls_mpi_release (&exp2);
+ mhd_gtls_mpi_release (&q1);
+ mhd_gtls_mpi_release (&p1);
+ mhd_gtls_mpi_release (&u);
gnutls_free (all_data);
if ((result = asn1_write_value (*c2, "otherPrimeInfos",
@@ -1050,11 +1050,11 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
return 0;
-cleanup:_gnutls_mpi_release (&u);
- _gnutls_mpi_release (&exp1);
- _gnutls_mpi_release (&exp2);
- _gnutls_mpi_release (&q1);
- _gnutls_mpi_release (&p1);
+cleanup:mhd_gtls_mpi_release (&u);
+ mhd_gtls_mpi_release (&exp1);
+ mhd_gtls_mpi_release (&exp2);
+ mhd_gtls_mpi_release (&q1);
+ mhd_gtls_mpi_release (&p1);
asn1_delete_structure (c2);
gnutls_free (all_data);
@@ -1076,7 +1076,7 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
total = 0;
for (i = 0; i < DSA_PRIVATE_PARAMS; i++)
{
- _gnutls_mpi_print_lz (NULL, &size[i], params[i]);
+ mhd_gtls_mpi_print_lz (NULL, &size[i], params[i]);
total += size[i];
}
@@ -1102,11 +1102,11 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
p += size[3];
x_data = p;
- _gnutls_mpi_print_lz (p_data, &size[0], params[0]);
- _gnutls_mpi_print_lz (q_data, &size[1], params[1]);
- _gnutls_mpi_print_lz (g_data, &size[2], params[2]);
- _gnutls_mpi_print_lz (y_data, &size[3], params[3]);
- _gnutls_mpi_print_lz (x_data, &size[4], params[4]);
+ mhd_gtls_mpi_print_lz (p_data, &size[0], params[0]);
+ mhd_gtls_mpi_print_lz (q_data, &size[1], params[1]);
+ mhd_gtls_mpi_print_lz (g_data, &size[2], params[2]);
+ mhd_gtls_mpi_print_lz (y_data, &size[3], params[3]);
+ mhd_gtls_mpi_print_lz (x_data, &size[4], params[4]);
/* Ok. Now we have the data. Create the asn1 structures
*/
@@ -1236,7 +1236,7 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
cleanup:key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
key->params_size = 0;
for (i = 0; i < params_len; i++)
- _gnutls_mpi_release (&key->params[i]);
+ mhd_gtls_mpi_release (&key->params[i]);
return ret;
}
@@ -1300,7 +1300,7 @@ gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
else
return GNUTLS_E_INTERNAL_ERROR;
- hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (hd == GNUTLS_HASH_FAILED)
{
gnutls_assert ();
@@ -1308,9 +1308,9 @@ gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
goto cleanup;
}
- _gnutls_hash (hd, der.data, der.size);
+ mhd_gnutls_hash (hd, der.data, der.size);
- _gnutls_hash_deinit (hd, output_data);
+ mhd_gnutls_hash_deinit (hd, output_data);
*output_data_size = 20;
result = 0;
@@ -1408,7 +1408,7 @@ gnutls_x509_privkey_sign_hash (gnutls_x509_privkey_t key,
return GNUTLS_E_INVALID_REQUEST;
}
- result = _gnutls_sign (key->pk_algorithm, key->params,
+ result = mhd_gtls_sign (key->pk_algorithm, key->params,
key->params_size, hash, signature);
if (result < 0)
{
diff --git a/src/daemon/https/x509/x509_verify.c b/src/daemon/https/x509/x509_verify.c
@@ -498,7 +498,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
return _gnutls_asn2err (result);
}
- *hash = _gnutls_x509_oid2mac_algorithm (str);
+ *hash = mhd_gtls_x509_oid2mac_algorithm (str);
if (*hash == MHD_GNUTLS_MAC_UNKNOWN)
{
@@ -555,7 +555,7 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
gnutls_datum_t decrypted;
ret =
- _gnutls_pkcs1_rsa_decrypt (&decrypted, signature, params, params_len, 1);
+ mhd_gtls_pkcs1_rsa_decrypt (&decrypted, signature, params, params_len, 1);
if (ret < 0)
{
gnutls_assert ();
@@ -576,21 +576,21 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
_gnutls_free_datum (&decrypted);
- if (digest_size != _gnutls_hash_get_algo_len (hash))
+ if (digest_size != mhd_gnutls_hash_get_algo_len (hash))
{
gnutls_assert ();
return GNUTLS_E_ASN1_GENERIC_ERROR;
}
- hd = _gnutls_hash_init (hash);
+ hd = mhd_gtls_hash_init (hash);
if (hd == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (hd, text->data, text->size);
- _gnutls_hash_deinit (hd, md);
+ mhd_gnutls_hash (hd, text->data, text->size);
+ mhd_gnutls_hash_deinit (hd, md);
if (memcmp (md, digest, digest_size) != 0)
{
@@ -613,20 +613,20 @@ dsa_verify_sig (const gnutls_datum_t * text,
gnutls_datum_t digest;
GNUTLS_HASH_HANDLE hd;
- hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
+ hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (hd == NULL)
{
gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
- _gnutls_hash (hd, text->data, text->size);
- _gnutls_hash_deinit (hd, _digest);
+ mhd_gnutls_hash (hd, text->data, text->size);
+ mhd_gnutls_hash_deinit (hd, _digest);
digest.data = _digest;
digest.size = 20;
- ret = _gnutls_dsa_verify (&digest, signature, params, params_len);
+ ret = mhd_gtls_dsa_verify (&digest, signature, params, params_len);
return ret;
}
@@ -699,7 +699,7 @@ _gnutls_x509_verify_signature (const gnutls_datum_t * tbs,
*/
for (i = 0; i < issuer_params_size; i++)
{
- _gnutls_mpi_release (&issuer_params[i]);
+ mhd_gtls_mpi_release (&issuer_params[i]);
}
return ret;
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
@@ -549,7 +549,7 @@ struct MHD_Connection
#if HTTPS_SUPPORT
/* TODO rename as this might be an SSL connection */
- gnutls_session_t tls_session;
+ mhd_gtls_session_t tls_session;
#endif
};
@@ -630,16 +630,16 @@ struct MHD_Daemon
gnutls_credentials_type_t cred_type;
/* server x509 credintials */
- gnutls_certificate_credentials_t x509_cred;
+ mhd_gtls_cert_credentials_t x509_cred;
/* credentials used for anonymous authentication */
- gnutls_anon_server_credentials_t anon_cred;
+ mhd_gtls_anon_server_credentials_t anon_cred;
/* cipher priority cache */
gnutls_priority_t priority_cache;
/* Diffie-Hellman parameters */
- gnutls_dh_params_t dh_params;
+ mhd_gtls_dh_params_t dh_params;
const char * https_key_path;
diff --git a/src/testcurl/https/tls_alert_test.c b/src/testcurl/https/tls_alert_test.c
@@ -57,45 +57,45 @@ http_ahc (void *cls, struct MHD_Connection *connection,
}
static int
-setup (gnutls_session_t * session,
+setup (mhd_gtls_session_t * session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t * xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t * xcred)
{
int ret;
const char ** err_pos;
- gnutls_certificate_allocate_credentials (xcred);
+ MHD_gnutls_certificate_allocate_credentials (xcred);
- _gnutls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
- _gnutls_set_datum_m (cert, srv_self_signed_cert_pem,
+ mhd_gtls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
+ mhd_gtls_set_datum_m (cert, srv_self_signed_cert_pem,
strlen (srv_self_signed_cert_pem), &malloc);
- gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
+ MHD_gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
GNUTLS_X509_FMT_PEM);
- gnutls_init (session, GNUTLS_CLIENT);
- ret = gnutls_priority_set_direct (*session, "PERFORMANCE", err_pos);
+ MHD_gnutls_init (session, GNUTLS_CLIENT);
+ ret = MHD_gnutls_priority_set_direct (*session, "NORMAL", err_pos);
if (ret < 0)
{
return -1;
}
- gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
return 0;
}
static int
-teardown (gnutls_session_t session,
+teardown (mhd_gtls_session_t session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t xcred)
{
- _gnutls_free_datum_m (key, free);
- _gnutls_free_datum_m (cert, free);
+ mhd_gtls_free_datum_m (key, free);
+ mhd_gtls_free_datum_m (cert, free);
- gnutls_deinit (session);
+ MHD_gnutls_deinit (session);
- gnutls_certificate_free_credentials (xcred);
+ MHD_gnutls_certificate_free_credentials (xcred);
return 0;
}
@@ -106,7 +106,7 @@ teardown (gnutls_session_t session,
* @param session: an initialized TLS session
*/
static int
-test_alert_close_notify (gnutls_session_t session)
+test_alert_close_notify (mhd_gtls_session_t session)
{
int sd, ret;
struct sockaddr_in sa;
@@ -117,7 +117,7 @@ test_alert_close_notify (gnutls_session_t session)
sa.sin_port = htons (42433);
inet_pton (AF_INET, "127.0.0.1", &sa.sin_addr);
- gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
+ MHD_gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = connect (sd, &sa, sizeof (struct sockaddr_in));
@@ -127,16 +127,16 @@ test_alert_close_notify (gnutls_session_t session)
return -1;
}
- ret = gnutls_handshake (session);
+ ret = MHD_gnutls_handshake (session);
if (ret < 0)
{
return -1;
}
- gnutls_alert_send (session, GNUTLS_AL_FATAL, GNUTLS_A_CLOSE_NOTIFY);
+ MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL, GNUTLS_A_CLOSE_NOTIFY);
/* check server responds with a 'close-notify' */
- _gnutls_recv_int (session, GNUTLS_ALERT, GNUTLS_HANDSHAKE_FINISHED, 0, 0);
+ mhd_gtls_recv_int (session, GNUTLS_ALERT, GNUTLS_HANDSHAKE_FINISHED, 0, 0);
close (sd);
/* CLOSE_NOTIFY */
@@ -155,7 +155,7 @@ test_alert_close_notify (gnutls_session_t session)
* @param session: an initialized TLS session
*/
static int
-test_alert_unexpected_message (gnutls_session_t session)
+test_alert_unexpected_message (mhd_gtls_session_t session)
{
int sd, ret;
struct sockaddr_in sa;
@@ -166,7 +166,7 @@ test_alert_unexpected_message (gnutls_session_t session)
sa.sin_port = htons (42433);
inet_pton (AF_INET, "127.0.0.1", &sa.sin_addr);
- gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
+ MHD_gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) ((void *) sd));
ret = connect (sd, &sa, sizeof (struct sockaddr_in));
@@ -176,13 +176,13 @@ test_alert_unexpected_message (gnutls_session_t session)
return -1;
}
- ret = gnutls_handshake (session);
+ ret = MHD_gnutls_handshake (session);
if (ret < 0)
{
return -1;
}
- gnutls_alert_send (session, GNUTLS_AL_FATAL, GNUTLS_A_UNEXPECTED_MESSAGE);
+ MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL, GNUTLS_A_UNEXPECTED_MESSAGE);
usleep (100);
/* TODO better RST trigger */
@@ -200,13 +200,13 @@ main (int argc, char *const *argv)
{
int errorCount = 0;;
struct MHD_Daemon *d;
- gnutls_session_t session;
+ mhd_gtls_session_t session;
gnutls_datum_t key;
gnutls_datum_t cert;
- gnutls_certificate_credentials_t xcred;
+ mhd_gtls_cert_credentials_t xcred;
- gnutls_global_init ();
- gnutls_global_set_log_level (11);
+ MHD_gnutls_global_init ();
+ MHD_gtls_global_set_log_level (11);
d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION | MHD_USE_SSL |
MHD_USE_DEBUG, 42433,
@@ -233,7 +233,7 @@ main (int argc, char *const *argv)
fprintf (stderr, "Failed test: %s.\n", argv[0]);
MHD_stop_daemon (d);
- gnutls_global_deinit ();
+ MHD_gnutls_global_deinit ();
return errorCount != 0;
}
diff --git a/src/testcurl/https/tls_authentication_test.c b/src/testcurl/https/tls_authentication_test.c
@@ -309,7 +309,7 @@ main (int argc, char *const *argv)
FILE *test_fd;
unsigned int errorCount = 0;
- gnutls_global_set_log_level (DEBUG_GNUTLS_LOG_LEVEL);
+ MHD_gtls_global_set_log_level (DEBUG_GNUTLS_LOG_LEVEL);
if (curl_check_version (MHD_REQ_CURL_VERSION))
{
diff --git a/src/testcurl/https/tls_cipher_change_test.c b/src/testcurl/https/tls_cipher_change_test.c
@@ -47,7 +47,7 @@ rehandshake_ahc (void *cls, struct MHD_Connection *connection,
{
int ret;
/* server side re-handshake request */
- ret = gnutls_rehandshake (connection->tls_session);
+ ret = MHD_gnutls_rehandshake (connection->tls_session);
if (ret < 0)
{
@@ -59,45 +59,45 @@ rehandshake_ahc (void *cls, struct MHD_Connection *connection,
}
static int
-setup (gnutls_session_t * session,
+setup (mhd_gtls_session_t * session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t * xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t * xcred)
{
int ret;
const char **err_pos;
- gnutls_certificate_allocate_credentials (xcred);
+ MHD_gnutls_certificate_allocate_credentials (xcred);
- _gnutls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
- _gnutls_set_datum_m (cert, srv_self_signed_cert_pem,
+ mhd_gtls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
+ mhd_gtls_set_datum_m (cert, srv_self_signed_cert_pem,
strlen (srv_self_signed_cert_pem), &malloc);
- gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
+ MHD_gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
GNUTLS_X509_FMT_PEM);
- gnutls_init (session, GNUTLS_CLIENT);
- ret = gnutls_priority_set_direct (*session, "PERFORMANCE", err_pos);
+ MHD_gnutls_init (session, GNUTLS_CLIENT);
+ ret = MHD_gnutls_priority_set_direct (*session, "NORMAL", err_pos);
if (ret < 0)
{
return -1;
}
- gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
return 0;
}
static int
-teardown (gnutls_session_t session,
+teardown (mhd_gtls_session_t session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t xcred)
{
- _gnutls_free_datum_m (key, free);
- _gnutls_free_datum_m (cert, free);
+ mhd_gtls_free_datum_m (key, free);
+ mhd_gtls_free_datum_m (cert, free);
- gnutls_deinit (session);
+ MHD_gnutls_deinit (session);
- gnutls_certificate_free_credentials (xcred);
+ MHD_gnutls_certificate_free_credentials (xcred);
return 0;
}
@@ -110,7 +110,7 @@ teardown (gnutls_session_t session,
* @param session: initiallized TLS session
*/
static int
-test_out_of_context_cipher_change (gnutls_session_t session)
+test_out_of_context_cipher_change (mhd_gtls_session_t session)
{
int sd, ret;
struct sockaddr_in sa;
@@ -121,7 +121,7 @@ test_out_of_context_cipher_change (gnutls_session_t session)
sa.sin_port = htons (42433);
inet_pton (AF_INET, "127.0.0.1", &sa.sin_addr);
- gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
+ MHD_gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = connect (sd, &sa, sizeof (struct sockaddr_in));
@@ -131,14 +131,14 @@ test_out_of_context_cipher_change (gnutls_session_t session)
return -1;
}
- ret = gnutls_handshake (session);
+ ret = MHD_gnutls_handshake (session);
if (ret < 0)
{
return -1;
}
/* send an out of context cipher change spec */
- _gnutls_send_change_cipher_spec (session, 0);
+ mhd_gtls_send_change_cipher_spec (session, 0);
/* assert server has closed connection */
@@ -149,13 +149,52 @@ test_out_of_context_cipher_change (gnutls_session_t session)
}
close (sd);
+ fprintf (stderr, "%s. f: %s, l: %d\n", "ok", __FUNCTION__, __LINE__);
return 0;
}
+/* */
static int
-test_rehandshake (gnutls_session_t session)
+test_rehandshake (mhd_gtls_session_t session)
{
- /* TODO impl */
+ int sd, ret;
+ struct sockaddr_in sa;
+
+ sd = socket (AF_INET, SOCK_STREAM, 0);
+ memset (&sa, '\0', sizeof (struct sockaddr_in));
+ sa.sin_family = AF_INET;
+ sa.sin_port = htons (42433);
+ inet_pton (AF_INET, "127.0.0.1", &sa.sin_addr);
+
+ MHD_gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
+
+ ret = connect (sd, &sa, sizeof (struct sockaddr_in));
+
+ if (ret < 0)
+ {
+ fprintf (stderr, "Error: %s)\n", MHD_E_FAILED_TO_CONNECT);
+ return -1;
+ }
+
+ ret = MHD_gnutls_handshake (session);
+ if (ret < 0)
+ {
+ return -1;
+ }
+
+ ret = MHD_gnutls_record_send (session, http_get_req, strlen (http_get_req));
+
+ /* check server responds with a 'close-notify' */
+ mhd_gtls_recv_int (session, GNUTLS_ALERT, GNUTLS_HANDSHAKE_FINISHED, 0, 0);
+
+
+ /* CLOSE_NOTIFY */
+ if (session->internals.last_alert != GNUTLS_A_CLOSE_NOTIFY)
+ {
+ return -1;
+ }
+
+ close (sd);
return 0;
}
@@ -164,13 +203,13 @@ main (int argc, char *const *argv)
{
int errorCount = 0;;
struct MHD_Daemon *d;
- gnutls_session_t session;
+ mhd_gtls_session_t session;
gnutls_datum_t key;
gnutls_datum_t cert;
- gnutls_certificate_credentials_t xcred;
+ mhd_gtls_cert_credentials_t xcred;
- gnutls_global_init ();
- gnutls_global_set_log_level (11);
+ MHD_gnutls_global_init ();
+ MHD_gtls_global_set_log_level (11);
d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION | MHD_USE_SSL |
MHD_USE_DEBUG, 42433,
@@ -193,7 +232,7 @@ main (int argc, char *const *argv)
fprintf (stderr, "Failed test: %s.\n", argv[0]);
MHD_stop_daemon (d);
- gnutls_global_deinit ();
+ MHD_gnutls_global_deinit ();
return errorCount != 0;
}
diff --git a/src/testcurl/https/tls_daemon_options_test.c b/src/testcurl/https/tls_daemon_options_test.c
@@ -404,7 +404,7 @@ main (int argc, char *const *argv)
FILE *test_fd;
unsigned int errorCount = 0;
- gnutls_global_set_log_level (DEBUG_GNUTLS_LOG_LEVEL);
+ MHD_gtls_global_set_log_level (DEBUG_GNUTLS_LOG_LEVEL);
if (curl_check_version (MHD_REQ_CURL_VERSION))
{
@@ -428,42 +428,47 @@ main (int argc, char *const *argv)
int cipher[] = { MHD_GNUTLS_CIPHER_3DES_CBC, 0 };
int kx[] = { MHD_GNUTLS_KX_ANON_DH, 0 };
+// errorCount +=
+// test_wrap ("https_transfer", &test_https_transfer, test_fd, "AES256-SHA",
+// CURL_SSLVERSION_TLSv1,
+// MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
+// MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
+// MHD_OPTION_END);
+// errorCount +=
+// test_wrap ("file certificates", &test_file_certificates, test_fd,
+// "AES256-SHA", CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY,
+// srv_key_pem, MHD_OPTION_HTTPS_MEM_CERT,
+// srv_self_signed_cert_pem, MHD_OPTION_END);
+// errorCount +=
+// test_wrap ("protocol_version", &test_protocol_version, test_fd,
+// "AES256-SHA", CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY,
+// srv_key_pem, MHD_OPTION_HTTPS_MEM_CERT,
+// srv_self_signed_cert_pem, MHD_OPTION_PROTOCOL_VERSION, p,
+// MHD_OPTION_END);
+// errorCount +=
+// test_wrap ("cipher DES-CBC3-SHA", &test_https_transfer, test_fd,
+// "DES-CBC3-SHA", CURL_SSLVERSION_TLSv1,
+// MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
+// MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
+// MHD_OPTION_CIPHER_ALGORITHM, cipher, MHD_OPTION_END);
+// errorCount +=
+// test_wrap ("mac SH1", &test_https_transfer, test_fd, "AES256-SHA",
+// CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
+// MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
+// MHD_OPTION_MAC_ALGO, mac, MHD_OPTION_END);
+// errorCount +=
+// test_wrap ("kx ANON_DH", &test_https_transfer, test_fd,
+// "ADH-DES-CBC3-SHA", CURL_SSLVERSION_TLSv1,
+// MHD_OPTION_CRED_TYPE, MHD_GNUTLS_CRD_ANON,
+// MHD_OPTION_CIPHER_ALGORITHM, cipher, MHD_OPTION_KX_PRIORITY,
+// kx, MHD_OPTION_END);
errorCount +=
- test_wrap ("https_transfer", &test_https_transfer, test_fd, "AES256-SHA",
- CURL_SSLVERSION_TLSv1,
- MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
- MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
- MHD_OPTION_END);
- errorCount +=
- test_wrap ("file certificates", &test_file_certificates, test_fd,
- "AES256-SHA", CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY,
- srv_key_pem, MHD_OPTION_HTTPS_MEM_CERT,
- srv_self_signed_cert_pem, MHD_OPTION_END);
- errorCount +=
- test_wrap ("protocol_version", &test_protocol_version, test_fd,
- "AES256-SHA", CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY,
- srv_key_pem, MHD_OPTION_HTTPS_MEM_CERT,
- srv_self_signed_cert_pem, MHD_OPTION_PROTOCOL_VERSION, p,
- MHD_OPTION_END);
- errorCount +=
- test_wrap ("cipher DES-CBC3-SHA", &test_https_transfer, test_fd,
- "DES-CBC3-SHA", CURL_SSLVERSION_TLSv1,
- MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
- MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
- MHD_OPTION_CIPHER_ALGORITHM, cipher, MHD_OPTION_END);
- errorCount +=
- test_wrap ("mac SH1", &test_https_transfer, test_fd, "AES256-SHA",
- CURL_SSLVERSION_TLSv1, MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
- MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
- MHD_OPTION_MAC_ALGO, mac, MHD_OPTION_END);
- errorCount +=
- test_wrap ("kx ANON_DH", &test_https_transfer, test_fd,
- "ADH-DES-CBC3-SHA", CURL_SSLVERSION_TLSv1,
- MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
- MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
- MHD_OPTION_CRED_TYPE, MHD_GNUTLS_CRD_ANON,
- MHD_OPTION_CIPHER_ALGORITHM, cipher, MHD_OPTION_KX_PRIORITY,
- kx, MHD_OPTION_END);
+ test_wrap ("ADH-AES256-SHA", &test_https_transfer, test_fd,
+ "ADH-AES256-SHA", CURL_SSLVERSION_TLSv1,
+ MHD_OPTION_CRED_TYPE, MHD_GNUTLS_CRD_ANON,
+ MHD_OPTION_KX_PRIORITY,
+ kx, MHD_OPTION_END);
+
/*gnutls_mac_algorithm_t mac[] = {
{MHD_GNUTLS_MAC_MD5, 0}, 0};
diff --git a/src/testcurl/https/tls_session_time_out_test.c b/src/testcurl/https/tls_session_time_out_test.c
@@ -55,50 +55,50 @@ http_ahc (void *cls, struct MHD_Connection *connection,
}
static int
-setup (gnutls_session_t * session,
+setup (mhd_gtls_session_t * session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t * xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t * xcred)
{
int ret;
const char **err_pos;
- gnutls_certificate_allocate_credentials (xcred);
+ MHD_gnutls_certificate_allocate_credentials (xcred);
- _gnutls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
- _gnutls_set_datum_m (cert, srv_self_signed_cert_pem,
+ mhd_gtls_set_datum_m (key, srv_key_pem, strlen (srv_key_pem), &malloc);
+ mhd_gtls_set_datum_m (cert, srv_self_signed_cert_pem,
strlen (srv_self_signed_cert_pem), &malloc);
- gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
+ MHD_gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
GNUTLS_X509_FMT_PEM);
- gnutls_init (session, GNUTLS_CLIENT);
- ret = gnutls_priority_set_direct (*session, "PERFORMANCE", err_pos);
+ MHD_gnutls_init (session, GNUTLS_CLIENT);
+ ret = MHD_gnutls_priority_set_direct (*session, "NORMAL", err_pos);
if (ret < 0)
{
return -1;
}
- gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
+ MHD_gnutls_credentials_set (*session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
return 0;
}
static int
-teardown (gnutls_session_t session,
+teardown (mhd_gtls_session_t session,
gnutls_datum_t * key,
- gnutls_datum_t * cert, gnutls_certificate_credentials_t xcred)
+ gnutls_datum_t * cert, mhd_gtls_cert_credentials_t xcred)
{
- _gnutls_free_datum_m (key, free);
- _gnutls_free_datum_m (cert, free);
+ mhd_gtls_free_datum_m (key, free);
+ mhd_gtls_free_datum_m (cert, free);
- gnutls_deinit (session);
+ MHD_gnutls_deinit (session);
- gnutls_certificate_free_credentials (xcred);
+ MHD_gnutls_certificate_free_credentials (xcred);
return 0;
}
static int
-test_tls_session_time_out (gnutls_session_t session)
+test_tls_session_time_out (mhd_gtls_session_t session)
{
int sd, ret;
struct sockaddr_in sa;
@@ -109,7 +109,7 @@ test_tls_session_time_out (gnutls_session_t session)
sa.sin_port = htons (42433);
inet_pton (AF_INET, "127.0.0.1", &sa.sin_addr);
- gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
+ MHD_gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = connect (sd, &sa, sizeof (struct sockaddr_in));
@@ -119,7 +119,7 @@ test_tls_session_time_out (gnutls_session_t session)
return -1;
}
- ret = gnutls_handshake (session);
+ ret = MHD_gnutls_handshake (session);
if (ret < 0)
{
return -1;
@@ -144,13 +144,13 @@ main (int argc, char *const *argv)
{
int errorCount = 0;;
struct MHD_Daemon *d;
- gnutls_session_t session;
+ mhd_gtls_session_t session;
gnutls_datum_t key;
gnutls_datum_t cert;
- gnutls_certificate_credentials_t xcred;
+ mhd_gtls_cert_credentials_t xcred;
- gnutls_global_init ();
- gnutls_global_set_log_level (11);
+ MHD_gnutls_global_init ();
+ MHD_gtls_global_set_log_level (11);
d = MHD_start_daemon_ip(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_SSL |
MHD_USE_DEBUG, 42433, "127.0.0.1",
@@ -174,7 +174,7 @@ main (int argc, char *const *argv)
fprintf (stderr, "Failed test: %s.\n", argv[0]);
MHD_stop_daemon (d);
- gnutls_global_deinit ();
+ MHD_gnutls_global_deinit ();
return errorCount != 0;
}
